• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 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 OS_ACCOUNT_SERVICES_ACCOUNTMGR_INCLUDE_ACCOUNT_IAM_CALLBACK_H
17 #define OS_ACCOUNT_SERVICES_ACCOUNTMGR_INCLUDE_ACCOUNT_IAM_CALLBACK_H
18 
19 #include <condition_variable>
20 #include <map>
21 #include <vector>
22 
23 #include "access_token.h"
24 #include "account_file_operator.h"
25 #include "account_iam_info.h"
26 #include "domain_account_callback.h"
27 #include "get_cred_info_callback_stub.h"
28 #include "get_enrolled_id_callback_stub.h"
29 #include "get_set_prop_callback_stub.h"
30 #include "id_m_callback_stub.h"
31 #include "iremote_object.h"
32 #include "iremote_stub.h"
33 #include "pre_remote_auth_callback_stub.h"
34 
35 namespace OHOS {
36 namespace AccountSA {
37 class AuthCallbackDeathRecipient : public IRemoteObject::DeathRecipient {
38 public:
39     AuthCallbackDeathRecipient() = default;
40     ~AuthCallbackDeathRecipient() override = default;
41 
42     void SetContextId(uint16_t context);
43     void OnRemoteDied(const wptr<IRemoteObject> &remote) override;
44 
45 private:
46     uint64_t contextId_ = 0;
47 };
48 
49 class AuthCallback : public AuthenticationCallback {
50 public:
51     AuthCallback(uint32_t userId, AuthType authType, AuthIntent authIntent, const sptr<IIDMCallback> &callback);
52     AuthCallback(uint32_t userId, AuthType authType, AuthIntent authIntent,
53         bool isRemoteAuth, const sptr<IIDMCallback> &callback);
54     virtual ~AuthCallback() = default;
55 
56     void SetDeathRecipient(const sptr<AuthCallbackDeathRecipient> &deathRecipient);
57     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override;
58     void OnResult(int32_t result, const Attributes &extraInfo) override;
59 
60 private:
61     ErrCode UnlockAccount(int32_t accountId, const std::vector<uint8_t> &token,
62         const std::vector<uint8_t> &secret, bool &isUpdateVerifiedStatus);
63     ErrCode HandleAuthResult(const Attributes &extraInfo, int32_t accountId, bool &isUpdateVerifiedStatus);
64     void HandleReEnroll(const Attributes &extraInfo, int32_t accountId, const std::vector<uint8_t> &token);
65     ErrCode InnerHandleReEnroll(const std::vector<uint8_t> &token);
66     ErrCode UnlockUserScreen(int32_t accountId, const std::vector<uint8_t> &token,
67         const std::vector<uint8_t> &secret, bool &isUpdateVerifiedStatus);
68 
69 private:
70     uint32_t userId_;
71     uint32_t callerTokenId_ = 0;
72     AuthType authType_;
73     AuthIntent authIntent_;
74     bool isRemoteAuth_ = false;
75     sptr<IIDMCallback> innerCallback_ = nullptr;
76     sptr<AuthCallbackDeathRecipient> deathRecipient_ = nullptr;
77 };
78 
79 class IDMCallbackDeathRecipient : public IRemoteObject::DeathRecipient {
80 public:
81     IDMCallbackDeathRecipient(uint32_t userId);
82     void OnRemoteDied(const wptr<IRemoteObject> &remote) override;
83 
84 private:
85     uint32_t userId_ = 0;
86 };
87 
88 class AddCredCallback : public UserIdmClientCallback {
89 public:
90     AddCredCallback(uint32_t userId, const CredentialParameters &credInfo,
91         const sptr<IIDMCallback> &callback);
92     virtual ~AddCredCallback();
93 
94     void SetDeathRecipient(const sptr<IDMCallbackDeathRecipient> &deathRecipient);
95     void OnResult(int32_t result, const Attributes &extraInfo) override;
96     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override;
97 
98 public:
99     std::mutex mutex_;
100     bool isCalled_ = false;
101     std::condition_variable onResultCondition_;
102 
103 private:
104     std::uint32_t userId_;
105     CredentialParameters credInfo_;
106     sptr<IDMCallbackDeathRecipient> deathRecipient_ = nullptr;
107     sptr<IIDMCallback> innerCallback_ = nullptr;
108 };
109 
110 class UpdateCredCallback : public UserIdmClientCallback {
111 public:
112     UpdateCredCallback(uint32_t userId, const CredentialParameters &credInfo,
113         const sptr<IIDMCallback> &callback);
114     virtual ~UpdateCredCallback();
115 
116     void SetDeathRecipient(const sptr<IDMCallbackDeathRecipient> &deathRecipient);
117     void OnResult(int32_t result, const Attributes &extraInfo) override;
118     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override;
119 
120 private:
121     void InnerOnResult(int32_t result, const Attributes &extraInfo);
122 
123 public:
124     std::mutex mutex_;
125     bool isCalled_ = false;
126     std::condition_variable onResultCondition_;
127 
128 private:
129     std::uint32_t userId_;
130     CredentialParameters credInfo_;
131     sptr<IDMCallbackDeathRecipient> deathRecipient_ = nullptr;
132     const sptr<IIDMCallback> innerCallback_ = nullptr;
133 };
134 
135 #ifdef HAS_PIN_AUTH_PART
136 class DelUserInputer : public IInputer {
137 public:
138     DelUserInputer() = default;
139     virtual ~DelUserInputer() = default;
140 
141     void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
142         std::shared_ptr<IInputerData> inputerData) override;
143 };
144 #endif // HAS_PIN_AUTH_PART
145 
146 class VerifyTokenCallbackWrapper : public VerifyTokenCallback {
147 public:
148     VerifyTokenCallbackWrapper(uint32_t userId, const std::vector<uint8_t> &token,
149         Security::AccessToken::AccessTokenID callerTokenId, const sptr<IIDMCallback> &callback);
150     virtual ~VerifyTokenCallbackWrapper();
151     void OnResult(int32_t result, const Attributes &extraInfo) override;
152 
153 private:
154     void InnerOnResult(int32_t result, const Attributes &extraInfo);
155 
156 public:
157     std::mutex mutex_;
158     bool isCalled_ = false;
159     std::condition_variable onResultCondition_;
160 
161 private:
162     std::uint32_t userId_;
163     std::vector<uint8_t> token_;
164     Security::AccessToken::AccessTokenID callerTokenId_;
165     const sptr<IIDMCallback> innerCallback_ = nullptr;
166 };
167 
168 class CommitDelCredCallback : public UserIdmClientCallback {
169 public:
170     CommitDelCredCallback(uint32_t userId, const sptr<IIDMCallback> callback);
171     virtual ~CommitDelCredCallback() = default;
172 
173     void OnResult(int32_t result, const UserIam::UserAuth::Attributes &extraInfo) override;
174     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const UserIam::UserAuth::Attributes &extraInfo) override;
175 
176 public:
177     bool isCalled_ = false;
178     std::mutex mutex_;
179     std::condition_variable onResultCondition_;
180 
181 private:
182     std::uint32_t userId_;
183     const sptr<IIDMCallback> innerCallback_ = nullptr;
184 };
185 
186 struct UpdateCredInfo {
187     uint64_t credentialId = 0;
188     uint64_t secureUid = 0;
189     std::vector<uint8_t> token;
190     std::vector<uint8_t> newSecret;
191     std::vector<uint8_t> oldSecret;
192 
193     UpdateCredInfo() = default;
194     UpdateCredInfo(const Attributes &extraInfo);
195     virtual ~UpdateCredInfo();
196 };
197 
198 class CommitCredUpdateCallback : public UserIdmClientCallback {
199 public:
200     CommitCredUpdateCallback(int32_t userId, const UpdateCredInfo &extraUpdateInfo, const sptr<IIDMCallback> &callback);
201     virtual ~CommitCredUpdateCallback() = default;
202 
203     void OnResult(int32_t result, const Attributes &extraInfo) override;
204     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override;
205 
206 private:
207     void InnerOnResult(int32_t result, const Attributes &extraInfo);
208 
209 public:
210     std::mutex mutex_;
211     bool isCalled_ = false;
212     std::condition_variable onResultCondition_;
213 
214 private:
215     int32_t userId_;
216     UpdateCredInfo extraUpdateInfo_;
217     sptr<IIDMCallback> innerCallback_ = nullptr;
218 };
219 
220 class DelCredCallback : public UserIdmClientCallback {
221 public:
222     DelCredCallback(int32_t userId, bool isPIN, std::vector<uint8_t> token, const sptr<IIDMCallback> &callback);
223     virtual ~DelCredCallback();
224 
225     void OnResult(int32_t result, const Attributes &extraInfo) override;
226     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override;
227 
228 private:
229     int32_t userId_;
230     bool isPIN_;
231     std::vector<uint8_t> token_;
232     sptr<IIDMCallback> innerCallback_ = nullptr;
233 };
234 
235 class GetCredInfoCallbackWrapper : public GetCredentialInfoCallback {
236 public:
237     GetCredInfoCallbackWrapper(int32_t userId, int32_t authType, const sptr<IGetCredInfoCallback> &callback);
238     virtual ~GetCredInfoCallbackWrapper() = default;
239 
240     void OnCredentialInfo(int32_t result, const std::vector<CredentialInfo> &infoList) override;
241 
242 private:
243     int32_t userId_;
244     int32_t authType_;
245     sptr<IGetCredInfoCallback> innerCallback_ = nullptr;
246 };
247 
248 class GetCredentialInfoSyncCallback : public UserIam::UserAuth::GetCredentialInfoCallback {
249 public:
250     GetCredentialInfoSyncCallback(int32_t userId);
251     virtual ~GetCredentialInfoSyncCallback() = default;
252 
253     void OnCredentialInfo(int32_t result, const std::vector<UserIam::UserAuth::CredentialInfo> &infoList);
254 
255     int32_t userId_;
256     bool hasPIN_ = false;
257     bool isCalled_ = false;
258     int32_t result_ = -1;
259     std::mutex secureMtx_;
260     std::condition_variable secureCv_;
261 };
262 
263 class GetPropCallbackWrapper : public GetPropCallback {
264 public:
265     GetPropCallbackWrapper(int32_t userId, const sptr<IGetSetPropCallback> &callback);
266     virtual ~GetPropCallbackWrapper() = default;
267 
268     void OnResult(int32_t result, const Attributes &extraInfo) override;
269 
270 private:
271     int32_t userId_;
272     sptr<IGetSetPropCallback> innerCallback_;
273 };
274 
275 class SetPropCallbackWrapper : public SetPropCallback {
276 public:
277     SetPropCallbackWrapper(int32_t userId, const sptr<IGetSetPropCallback> &callback);
278     virtual ~SetPropCallbackWrapper() = default;
279 
280     void OnResult(int32_t result, const Attributes &extraInfo) override;
281 
282 private:
283     int32_t userId_;
284     sptr<IGetSetPropCallback> innerCallback_;
285 };
286 
287 class GetSecUserInfoCallbackWrapper : public GetSecUserInfoCallback {
288 public:
289     GetSecUserInfoCallbackWrapper(int32_t userId, AuthType authType, const sptr<IGetEnrolledIdCallback> &callback);
290     virtual ~GetSecUserInfoCallbackWrapper() = default;
291 
292     void OnSecUserInfo(int32_t result, const SecUserInfo &info) override;
293 
294 private:
295     int32_t userId_;
296     AuthType authType_;
297     sptr<IGetEnrolledIdCallback> innerCallback_;
298 };
299 
300 class GetSecureUidCallback final : public GetSecUserInfoCallback {
301 public:
302     GetSecureUidCallback(int32_t userId);
303 
304     void OnSecUserInfo(int32_t result, const SecUserInfo &info) override;
305 
306 public:
307     int32_t userId_;
308     uint64_t secureUid_ = 0;
309     bool isCalled_ = false;
310     std::mutex secureMtx_;
311     std::condition_variable secureCv_;
312 };
313 
314 class PrepareRemoteAuthCallbackWrapper : public PrepareRemoteAuthCallback {
315 public:
316     PrepareRemoteAuthCallbackWrapper(const sptr<IPreRemoteAuthCallback> &callback);
317     virtual ~PrepareRemoteAuthCallbackWrapper() = default;
318 
319     void OnResult(int32_t result) override;
320 
321 private:
322     sptr<IPreRemoteAuthCallback> innerCallback_;
323 };
324 
325 #ifdef SUPPORT_DOMAIN_ACCOUNTS
326 class GetDomainAuthStatusInfoCallback final : public DomainAccountCallback {
327 public:
328     GetDomainAuthStatusInfoCallback(const GetPropertyRequest &request, const sptr<IGetSetPropCallback> &callback);
329 
330     void OnResult(int32_t result, Parcel &parcel) override;
331 
332 private:
333     GetPropertyRequest request_;
334     sptr<IGetSetPropCallback> innerCallback_;
335 };
336 #endif // SUPPORT_DOMAIN_ACCOUNTS
337 
338 class ReEnrollCallback final : public IRemoteStub<IIDMCallback> {
339 public:
340     bool isCalled_ = false;
341     ErrCode result_ = ERR_ACCOUNT_COMMON_NOT_INIT_ERROR;
342     std::mutex mutex_;
343     std::condition_variable onResultCondition_;
344 
345     ReEnrollCallback(const sptr<IIDMCallback> &innerCallback);
346     ErrCode OnResult(int32_t resultCode, const std::vector<uint8_t>& extraInfoBuffer) override;
347     ErrCode OnAcquireInfo(int32_t module, uint32_t acquireInfo, const std::vector<uint8_t>& extraInfoBuffer) override;
348 private:
349     sptr<IIDMCallback> innerCallback_;
350 };
351 }  // namespace AccountSA
352 }  // namespace OHOS
353 #endif  // OS_ACCOUNT_SERVICES_ACCOUNTMGR_INCLUDE_ACCOUNT_IAM_CALLBACK_H
354