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 #include <gmock/gmock.h>
17 #include "accesstoken_kit.h"
18 #define private public
19 #include "account_iam_callback_service.h"
20 #include "account_iam_client.h"
21 #undef private
22 #ifdef PROXY_MOCK
23 #define private public
24 #include "account_iam_service.h"
25 #include "account_iam_mgr_proxy.h"
26 #undef private
27 #endif
28 #include "account_log_wrapper.h"
29 #include "token_setproc.h"
30 
31 namespace OHOS {
32 namespace AccountTest {
33 namespace {
34 constexpr int32_t TEST_USER_ID = 200;
35 constexpr uint64_t TEST_CONTEXT_ID = 122;
36 constexpr uint64_t TEST_CREDENTIAL_ID = 0;
37 const std::vector<uint8_t> TEST_CHALLENGE = {1, 2, 3, 4};
38 }
39 
40 using namespace testing;
41 using namespace testing::ext;
42 using namespace OHOS::AccountSA;
43 using namespace OHOS::Security::AccessToken;
44 
45 class MockIDMCallback final : public IDMCallback {
46 public:
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)47     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override
48     {
49         return;
50     }
OnResult(int32_t result,const Attributes & extraInfo)51     void OnResult(int32_t result, const Attributes &extraInfo) override
52     {
53         result_ = result;
54         return;
55     }
56 
57 public:
58     int32_t result_ = -1;
59 };
60 
61 class MockGetCredInfoCallback final : public GetCredInfoCallback {
62 public:
OnCredentialInfo(int32_t result,const std::vector<CredentialInfo> & infoList)63     void OnCredentialInfo(int32_t result, const std::vector<CredentialInfo> &infoList)override
64     {
65         return;
66     }
67 };
68 
69 class MockGetSetPropCallback final : public GetSetPropCallback {
70 public:
OnResult(int32_t result,const Attributes & extraInfo)71     void OnResult(int32_t result, const Attributes &extraInfo) override
72     {
73         result_ = result;
74         return;
75     }
76 
77 public:
78     int32_t result_ = -1;
79 };
80 
81 class MockGetEnrolledIdCallback final : public GetEnrolledIdCallback {
82 public:
OnEnrolledId(int32_t result,uint64_t enrolledId)83     void OnEnrolledId(int32_t result, uint64_t enrolledId) override
84     {
85         result_ = result;
86         return;
87     }
88 
89 public:
90     int32_t result_ = -1;
91 };
92 
93 #ifdef HAS_PIN_AUTH_PART
94 class MockIInputer : public OHOS::AccountSA::IInputer {
95 public:
~MockIInputer()96     virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)97     void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
98         std::shared_ptr<IInputerData> inputerData) override
99     {
100         return;
101     }
102 };
103 #endif
104 
105 class MockPreRemoteAuthCallback final : public AccountSA::PreRemoteAuthCallback {
106 public:
OnResult(int32_t result)107     void OnResult(int32_t result) override
108     {
109         result_ = result;
110     }
111 
112 public:
113     int32_t result_ = -1;
114 };
115 
116 class AccountIAMClientNoPermissionTest : public testing::Test {
117 public:
118     static void SetUpTestCase(void);
119     static void TearDownTestCase(void);
120     void SetUp(void) override;
121     void TearDown(void) override;
122 };
123 
SetUpTestCase(void)124 void AccountIAMClientNoPermissionTest::SetUpTestCase(void)
125 {
126 #ifdef PROXY_MOCK
127     sptr<IAccountIAM> service = new (std::nothrow) AccountIAMService();
128     ASSERT_NE(service, nullptr);
129     AccountIAMClient::GetInstance().proxy_ = new (std::nothrow) AccountIAMMgrProxy(service->AsObject());
130     ASSERT_NE(AccountIAMClient::GetInstance().proxy_, nullptr);
131 #endif
132 }
133 
TearDownTestCase(void)134 void AccountIAMClientNoPermissionTest::TearDownTestCase(void)
135 {}
136 
SetUp(void)137 void AccountIAMClientNoPermissionTest::SetUp(void) __attribute__((no_sanitize("cfi")))
138 {
139     testing::UnitTest *test = testing::UnitTest::GetInstance();
140     ASSERT_NE(test, nullptr);
141     const testing::TestInfo *testinfo = test->current_test_info();
142     ASSERT_NE(testinfo, nullptr);
143     string testCaseName = string(testinfo->name());
144     ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
145 }
146 
TearDown(void)147 void AccountIAMClientNoPermissionTest::TearDown(void)
148 {}
149 
150 /**
151  * @tc.name: AccountIAMClientNoPermission_OpenSession_0100
152  * @tc.desc: Open Session without permission.
153  * @tc.type: FUNC
154  * @tc.require:
155  */
156 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_OpenSession_0100, TestSize.Level0)
157 {
158     std::vector<uint8_t> challenge;
159     int32_t res = AccountIAMClient::GetInstance().OpenSession(0, challenge);
160     EXPECT_TRUE(res == ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
161     AccountIAMClient::GetInstance().CloseSession(0);
162 }
163 
164 /**
165  * @tc.name: AccountIAMClientNoPermission_CloseSession_0100
166  * @tc.desc: Close Session without permission.
167  * @tc.type: FUNC
168  * @tc.require:
169  */
170 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_CloseSession_0100, TestSize.Level0)
171 {
172     std::vector<uint8_t> challenge;
173     int32_t res = AccountIAMClient::GetInstance().CloseSession(0);
174     EXPECT_TRUE(res == ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
175 }
176 
177 /**
178  * @tc.name: AccountIAMClientNoPermission_AddCredential_0100
179  * @tc.desc: Add credential without permission.
180  * @tc.type: FUNC
181  * @tc.require:
182  */
183 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_AddCredential_0100, TestSize.Level0)
184 {
185     CredentialParameters testPara = {};
186     auto callback = std::make_shared<MockIDMCallback>();
187     ASSERT_NE(callback, nullptr);
188     AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, callback);
189     EXPECT_EQ(callback->result_, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
190 }
191 
192 /**
193  * @tc.name: AccountIAMClientNoPermission_UpdateCredential_0100
194  * @tc.desc: Update credential without permission.
195  * @tc.type: FUNC
196  * @tc.require:
197  */
198 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_UpdateCredential_0100, TestSize.Level0)
199 {
200     CredentialParameters testPara = {};
201     auto callback = std::make_shared<MockIDMCallback>();
202     ASSERT_NE(callback, nullptr);
203     AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, callback);
204     EXPECT_EQ(callback->result_, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
205 }
206 
207 /**
208  * @tc.name: AccountIAMClientNoPermission_Cancel_0100
209  * @tc.desc: Cancel without permission.
210  * @tc.type: FUNC
211  * @tc.require:
212  */
213 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_Cancel_0100, TestSize.Level0)
214 {
215     int32_t res = AccountIAMClient::GetInstance().Cancel(TEST_USER_ID);
216     EXPECT_EQ(res, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
217 }
218 
219 /**
220  * @tc.name: AccountIAMClientNoPermission_DelCred_0100
221  * @tc.desc: Delete credential without permission.
222  * @tc.type: FUNC
223  * @tc.require:
224  */
225 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_DelCred_0100, TestSize.Level0)
226 {
227     uint64_t testCredentialId = 111;
228     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
229     auto callback = std::make_shared<MockIDMCallback>();
230     ASSERT_NE(callback, nullptr);
231     AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, callback);
232     EXPECT_EQ(callback->result_, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
233 }
234 
235 /**
236  * @tc.name: AccountIAMClientNoPermission_DelUser_0100
237  * @tc.desc: Delete user without permission.
238  * @tc.type: FUNC
239  * @tc.require:
240  */
241 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_DelUser_0100, TestSize.Level0)
242 {
243     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
244     auto callback = std::make_shared<MockIDMCallback>();
245     ASSERT_NE(callback, nullptr);
246     AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, callback);
247     EXPECT_EQ(callback->result_, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
248 }
249 
250 /**
251  * @tc.name: AccountIAMClientNoPermission_GetCredentialInfo_0100
252  * @tc.desc: Get credential info without permission.
253  * @tc.type: FUNC
254  * @tc.require:
255  */
256 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetCredentialInfo_0100, TestSize.Level0)
257 {
258     auto callback = std::make_shared<MockGetCredInfoCallback>();
259     ASSERT_NE(callback, nullptr);
260     int32_t res = AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, callback);
261     EXPECT_EQ(res, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
262 }
263 
264 /**
265  * @tc.name: AccountIAMClientNoPermission_GetEnrolledId_0100
266  * @tc.desc: Get credential info without permission.
267  * @tc.type: FUNC
268  * @tc.require:
269  */
270 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetEnrolledId_0100, TestSize.Level0)
271 {
272     auto callback = std::make_shared<MockGetEnrolledIdCallback>();
273     ASSERT_NE(callback, nullptr);
274     AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, callback);
275     EXPECT_EQ(callback->result_, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
276 }
277 
278 /**
279  * @tc.name: AccountIAMClientNoPermission_GetAvailableStatus_0100
280  * @tc.desc: Get available status without permission.
281  * @tc.type: FUNC
282  * @tc.require:
283  */
284 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetAvailableStatus_0100, TestSize.Level0)
285 {
286     int32_t status;
287     int32_t res = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
288     EXPECT_EQ(res, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
289 }
290 
291 /**
292  * @tc.name: AccountIAMClientNoPermission_GetProperty_0100
293  * @tc.desc: Get property without permission.
294  * @tc.type: FUNC
295  * @tc.require:
296  */
297 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetProperty_0100, TestSize.Level0)
298 {
299     GetPropertyRequest testRequest = {};
300     auto callback = std::make_shared<MockGetSetPropCallback>();
301     ASSERT_NE(callback, nullptr);
302     AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequest, callback);
303 }
304 
305 /**
306  * @tc.name: AccountIAMClientNoPermission_GetPropertyById_0100
307  * @tc.desc: Get property by id without permission.
308  * @tc.type: FUNC
309  * @tc.require:
310  */
311 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_GetPropertyById_0100, TestSize.Level0)
312 {
313     auto callback = std::make_shared<MockGetSetPropCallback>();
314     ASSERT_NE(callback, nullptr);
315     std::vector<Attributes::AttributeKey> keys { Attributes::AttributeKey::ATTR_PIN_SUB_TYPE };
316     AccountIAMClient::GetInstance().GetPropertyByCredentialId(TEST_CREDENTIAL_ID, keys, callback);
317     EXPECT_EQ(callback->result_, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
318 }
319 
320 /**
321  * @tc.name: AccountIAMClientNoPermission_SetProperty_0100
322  * @tc.desc: Set property without permission.
323  * @tc.type: FUNC
324  * @tc.require:
325  */
326 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_SetProperty_0100, TestSize.Level0)
327 {
328     SetPropertyRequest testRequest = {};
329     auto callback = std::make_shared<MockGetSetPropCallback>();
330     ASSERT_NE(callback, nullptr);
331     AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequest, callback);
332 }
333 
334 #ifdef HAS_PIN_AUTH_PART
335 /**
336  * @tc.name: AccountIAMClientNoPermission_RegisterInputer_0100
337  * @tc.desc: RegisterInputer without permission.
338  * @tc.type: FUNC
339  * @tc.require:
340  */
341 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_RegisterInputer_0100, TestSize.Level0)
342 {
343     std::shared_ptr<MockIInputer> inputer = std::make_shared<MockIInputer>();
344     int32_t res = AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputer);
345     EXPECT_EQ(res, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
346     AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN);
347 }
348 #endif
349 
350 /**
351  * @tc.name: AccountIAMClientNoPermission_AuthUser_0100
352  * @tc.desc: Auth user without permission.
353  * @tc.type: FUNC
354  * @tc.require:
355  */
356 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_AuthUser_0100, TestSize.Level0)
357 {
358     SetPropertyRequest testRequest = {};
359     auto callback = std::make_shared<MockIDMCallback>();
360     ASSERT_NE(callback, nullptr);
361     AuthOptions authOptions;
362     authOptions.accountId = TEST_USER_ID;
363     int32_t res = AccountIAMClient::GetInstance().AuthUser(
364         authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, callback);
365     EXPECT_EQ(res, 0);
366 }
367 
368 /**
369  * @tc.name: AccountIAMClientNoPermission_CancelAuth_0100
370  * @tc.desc: Cancel authentication without permission.
371  * @tc.type: FUNC
372  * @tc.require:
373  */
374 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_CancelAuth_0100, TestSize.Level0)
375 {
376     int32_t res = AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID);
377     EXPECT_EQ(res, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
378 }
379 
380 /**
381  * @tc.name: AccountIAMClientNoPermission_prepareRemoteAuth_0100
382  * @tc.desc: prepare remote authentication without permission.
383  * @tc.type: FUNC
384  * @tc.require:
385  */
386 HWTEST_F(AccountIAMClientNoPermissionTest, AccountIAMClientNoPermission_prepareRemoteAuth_0100, TestSize.Level0)
387 {
388     auto callback = std::make_shared<MockPreRemoteAuthCallback>();
389     ASSERT_NE(callback, nullptr);
390     int32_t res = AccountIAMClient::GetInstance().PrepareRemoteAuth("testString", callback);
391     EXPECT_EQ(res, ERR_ACCOUNT_COMMON_PERMISSION_DENIED);
392 }
393 }  // namespace AccountTest
394 }  // namespace OHOS