1 /*
2 * Copyright (c) 2022 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 "remote_token_kit_test.h"
17 #include <thread>
18
19 #include "accesstoken_kit.h"
20 #include "accesstoken_log.h"
21 #include "nativetoken_kit.h"
22 #include "softbus_bus_center.h"
23 #include "token_setproc.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::Security::AccessToken;
27
28 namespace {
29 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "RemoteTokenKitTest"};
30
31 static const std::string TEST_BUNDLE_NAME = "ohos";
32 static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA";
33 static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA";
34 static const std::string TEST_PERMISSION_NAME_GAMMA = "ohos.permission.GAMMA";
35 static const std::string TEST_PKG_NAME = "com.softbus.test";
36 static const int TEST_USER_ID = 0;
37
38 PermissionStateFull g_grantPermissionReq = {
39 .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS",
40 .isGeneral = true,
41 .resDeviceID = {"device"},
42 .grantStatus = {PermissionState::PERMISSION_GRANTED},
43 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
44 };
45 PermissionStateFull g_revokePermissionReq = {
46 .permissionName = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS",
47 .isGeneral = true,
48 .resDeviceID = {"device"},
49 .grantStatus = {PermissionState::PERMISSION_GRANTED},
50 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}
51 };
52
53 PermissionDef g_infoManagerTestPermDef1 = {
54 .permissionName = "ohos.permission.test1",
55 .bundleName = "accesstoken_test",
56 .grantMode = 1,
57 .availableLevel = APL_NORMAL,
58 .label = "label",
59 .labelId = 1,
60 .description = "open the door",
61 .descriptionId = 1,
62 };
63
64 PermissionDef g_infoManagerTestPermDef2 = {
65 .permissionName = "ohos.permission.test2",
66 .bundleName = "accesstoken_test",
67 .grantMode = 1,
68 .availableLevel = APL_NORMAL,
69 .label = "label",
70 .labelId = 1,
71 .description = "break the door",
72 .descriptionId = 1,
73 };
74
75 PermissionStateFull g_infoManagerTestState1 = {
76 .permissionName = "ohos.permission.test1",
77 .isGeneral = true,
78 .resDeviceID = {"local"},
79 .grantStatus = {PermissionState::PERMISSION_GRANTED},
80 .grantFlags = {1},
81 };
82
83 PermissionStateFull g_infoManagerTestState2 = {
84 .permissionName = "ohos.permission.test2",
85 .isGeneral = false,
86 .resDeviceID = {"device 1", "device 2"},
87 .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED},
88 .grantFlags = {1, 2},
89 };
90
91 HapInfoParams g_infoManagerTestInfoParms = {
92 .userID = 1,
93 .bundleName = "accesstoken_test",
94 .instIndex = 0,
95 .appIDDesc = "testtesttesttest"
96 };
97
98 HapPolicyParams g_infoManagerTestPolicyPrams = {
99 .apl = APL_NORMAL,
100 .domain = "test.domain",
101 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
102 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
103 };
104
105 HapInfoParams g_infoManagerTestInfoParmsBak = {
106 .userID = 1,
107 .bundleName = "accesstoken_test",
108 .instIndex = 0,
109 .appIDDesc = "testtesttesttest"
110 };
111
112 HapPolicyParams g_infoManagerTestPolicyPramsBak = {
113 .apl = APL_NORMAL,
114 .domain = "test.domain",
115 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
116 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
117 };
118
NativeTokenGet()119 void NativeTokenGet()
120 {
121 uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service");
122 ASSERT_NE(tokenId, INVALID_TOKENID);
123 SetSelfTokenID(tokenId);
124 }
125 }
126
SetUpTestCase()127 void RemoteTokenKitTest::SetUpTestCase()
128 {
129 // make test case clean
130 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
131 g_infoManagerTestInfoParms.bundleName,
132 g_infoManagerTestInfoParms.instIndex);
133 AccessTokenKit::DeleteToken(tokenID);
134
135 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
136 AccessTokenKit::DeleteToken(tokenID);
137
138 NativeTokenGet();
139 }
140
TearDownTestCase()141 void RemoteTokenKitTest::TearDownTestCase()
142 {
143 }
144
SetUp()145 void RemoteTokenKitTest::SetUp()
146 {
147 selfTokenId_ = GetSelfTokenID();
148 g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak;
149 g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak;
150 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
151 g_infoManagerTestInfoParms.bundleName,
152 g_infoManagerTestInfoParms.instIndex);
153 AccessTokenKit::DeleteToken(tokenID);
154
155 NodeBasicInfo deviceInfo;
156 int32_t res = ::GetLocalNodeDeviceInfo(TEST_PKG_NAME.c_str(), &deviceInfo);
157 ASSERT_EQ(res, RET_SUCCESS);
158 char udid[128] = {0}; // 128 is udid length
159 ::GetNodeKeyInfo(TEST_PKG_NAME.c_str(), deviceInfo.networkId,
160 NodeDeviceInfoKey::NODE_KEY_UDID, reinterpret_cast<uint8_t *>(udid), 128); // 128 is udid length
161
162 udid_.append(udid);
163 networkId_.append(deviceInfo.networkId);
164
165 ACCESSTOKEN_LOG_INFO(LABEL, "SetUp ok.");
166 }
167
TearDown()168 void RemoteTokenKitTest::TearDown()
169 {
170 AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
171 AccessTokenKit::DeleteToken(tokenID);
172 SetSelfTokenID(selfTokenId_);
173 udid_.clear();
174 networkId_.clear();
175 }
176
GetAccessTokenID(int userID,std::string bundleName,int instIndex)177 unsigned int RemoteTokenKitTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex)
178 {
179 return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
180 }
181
DeleteTestToken() const182 void RemoteTokenKitTest::DeleteTestToken() const
183 {
184 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
185 g_infoManagerTestInfoParms.bundleName,
186 g_infoManagerTestInfoParms.instIndex);
187 int ret = AccessTokenKit::DeleteToken(tokenID);
188 if (tokenID != 0) {
189 ASSERT_EQ(RET_SUCCESS, ret);
190 }
191 }
192
AllocTestToken() const193 void RemoteTokenKitTest::AllocTestToken() const
194 {
195 AccessTokenIDEx tokenIdEx = {0};
196 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
197 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
198 }
199
200 #ifdef TOKEN_SYNC_ENABLE
201 /**
202 * @tc.name: SetRemoteHapTokenInfo001
203 * @tc.desc: set remote hap token info success
204 * @tc.type: FUNC
205 * @tc.require:issue I5R4UF
206 */
207 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo001, TestSize.Level1)
208 {
209 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo001 start.");
210 std::string deviceID = udid_;
211 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
212 HapTokenInfo baseInfo = {
213 .apl = APL_NORMAL,
214 .ver = 1,
215 .userID = 1,
216 .bundleName = "com.ohos.access_token",
217 .instIndex = 1,
218 .appID = "testtesttesttest",
219 .deviceID = deviceID,
220 .tokenID = 0x20100000,
221 .tokenAttr = 0
222 };
223
224 PermissionStateFull infoManagerTestState = {
225 .permissionName = "ohos.permission.test1",
226 .isGeneral = true,
227 .resDeviceID = {"local"},
228 .grantStatus = {PermissionState::PERMISSION_GRANTED},
229 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
230 std::vector<PermissionStateFull> permStateList;
231 permStateList.emplace_back(infoManagerTestState);
232
233 HapTokenInfoForSync remoteTokenInfo = {
234 .baseInfo = baseInfo,
235 .permStateList = permStateList
236 };
237
238 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
239 ASSERT_EQ(ret, RET_SUCCESS);
240
241 // Get local map token ID
242 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
243 ASSERT_NE(mapID, 0);
244
245 // check local map token
246 HapTokenInfo resultInfo;
247 ret = AccessTokenKit::GetHapTokenInfo(mapID, resultInfo);
248 ASSERT_EQ(ret, RET_SUCCESS);
249 ASSERT_EQ(resultInfo.apl, remoteTokenInfo.baseInfo.apl);
250 ASSERT_EQ(resultInfo.ver, remoteTokenInfo.baseInfo.ver);
251 ASSERT_EQ(resultInfo.userID, remoteTokenInfo.baseInfo.userID);
252 ASSERT_EQ(resultInfo.bundleName, remoteTokenInfo.baseInfo.bundleName);
253 ASSERT_EQ(resultInfo.instIndex, remoteTokenInfo.baseInfo.instIndex);
254 ASSERT_EQ(resultInfo.appID, remoteTokenInfo.baseInfo.appID);
255 ASSERT_EQ(resultInfo.deviceID, remoteTokenInfo.baseInfo.deviceID);
256 ASSERT_NE(resultInfo.tokenID, remoteTokenInfo.baseInfo.tokenID); // tokenID already is map tokenID
257 ASSERT_EQ(resultInfo.tokenAttr, remoteTokenInfo.baseInfo.tokenAttr);
258
259 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
260 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
261
262 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
263 ASSERT_EQ(ret, RET_SUCCESS);
264 }
265
266 /**
267 * @tc.name: SetRemoteHapTokenInfo002
268 * @tc.desc: set remote hap token info, token info is wrong
269 * @tc.type: FUNC
270 * @tc.require:issue I5R4UF
271 */
272 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo002, TestSize.Level1)
273 {
274 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo002 start.");
275 std::string deviceID = udid_;
276 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
277 HapTokenInfo rightBaseInfo = {
278 .apl = APL_NORMAL,
279 .ver = 1,
280 .userID = 1,
281 .bundleName = "com.ohos.access_token",
282 .instIndex = 1,
283 .appID = "testtesttesttest",
284 .deviceID = udid_,
285 .tokenID = 0x20100000,
286 .tokenAttr = 0
287 };
288
289 HapTokenInfo wrongBaseInfo = rightBaseInfo;
290 wrongBaseInfo.apl = (ATokenAplEnum)11; // wrong apl
291
292 PermissionStateFull infoManagerTestState = {
293 .permissionName = "ohos.permission.test1",
294 .isGeneral = true,
295 .resDeviceID = {"local"},
296 .grantStatus = {PermissionState::PERMISSION_GRANTED},
297 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
298 std::vector<PermissionStateFull> permStateList;
299 permStateList.emplace_back(infoManagerTestState);
300
301 HapTokenInfoForSync remoteTokenInfo = {
302 .baseInfo = wrongBaseInfo,
303 .permStateList = permStateList
304 };
305
306 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
307 ASSERT_NE(ret, RET_SUCCESS);
308
309 std::string wrongStr(10241, 'x');
310
311 wrongBaseInfo = rightBaseInfo;
312 wrongBaseInfo.appID = wrongStr; // wrong appID
313 remoteTokenInfo.baseInfo = wrongBaseInfo;
314 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
315 ASSERT_NE(ret, RET_SUCCESS);
316
317 wrongBaseInfo = rightBaseInfo;
318 wrongBaseInfo.bundleName = wrongStr; // wrong bundleName
319 remoteTokenInfo.baseInfo = wrongBaseInfo;
320 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
321 ASSERT_NE(ret, RET_SUCCESS);
322
323 wrongBaseInfo = rightBaseInfo;
324 wrongBaseInfo.deviceID = wrongStr; // wrong deviceID
325 remoteTokenInfo.baseInfo = wrongBaseInfo;
326 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
327 ASSERT_NE(ret, RET_SUCCESS);
328
329 wrongBaseInfo = rightBaseInfo;
330 wrongBaseInfo.tokenID = 0; // wrong tokenID
331 remoteTokenInfo.baseInfo = wrongBaseInfo;
332 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
333 ASSERT_NE(ret, RET_SUCCESS);
334 }
335
336 /**
337 * @tc.name: SetRemoteHapTokenInfo003
338 * @tc.desc: set remote hap token wrong permission grant
339 * @tc.type: FUNC
340 * @tc.require:issue I5R4UF
341 */
342 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo003, TestSize.Level1)
343 {
344 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo003 start.");
345 std::string deviceID = udid_;
346 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
347 HapTokenInfo baseInfo = {
348 .apl = APL_NORMAL,
349 .ver = 1,
350 .userID = 1,
351 .bundleName = "com.ohos.access_token",
352 .instIndex = 1,
353 .appID = "testtesttesttest",
354 .deviceID = udid_,
355 .tokenID = 0x20100000,
356 .tokenAttr = 0
357 };
358
359 PermissionStateFull infoManagerTestState = {
360 .permissionName = "ohos.permission.test1",
361 .isGeneral = true,
362 .resDeviceID = {"local"},
363 .grantStatus = {PermissionState::PERMISSION_GRANTED},
364 .grantFlags = {11}, // wrong flags
365 };
366 std::vector<PermissionStateFull> permStateList;
367 permStateList.emplace_back(infoManagerTestState);
368
369 HapTokenInfoForSync remoteTokenInfo = {
370 .baseInfo = baseInfo,
371 .permStateList = permStateList
372 };
373
374 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
375 ASSERT_EQ(ret, RET_SUCCESS);
376
377 // Get local map token ID
378 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
379 ASSERT_NE(mapID, 0);
380
381 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
382 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
383
384 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
385 ASSERT_EQ(ret, RET_SUCCESS);
386 }
387
388 /**
389 * @tc.name: SetRemoteHapTokenInfo004
390 * @tc.desc: update remote hap token when remote exist
391 * @tc.type: FUNC
392 * @tc.require:issue I5R4UF
393 */
394 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo004, TestSize.Level1)
395 {
396 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo004 start.");
397 std::string deviceID = udid_;
398 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
399 HapTokenInfo baseInfo = {
400 .apl = APL_NORMAL,
401 .ver = 1,
402 .userID = 1,
403 .bundleName = "com.ohos.access_token",
404 .instIndex = 1,
405 .appID = "testtesttesttest",
406 .deviceID = udid_,
407 .tokenID = 0x20100000,
408 .tokenAttr = 0
409 };
410
411 PermissionStateFull infoManagerTestState = {
412 .permissionName = "ohos.permission.test1",
413 .isGeneral = true,
414 .resDeviceID = {"local"},
415 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
416 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
417 std::vector<PermissionStateFull> permStateList;
418 permStateList.emplace_back(infoManagerTestState);
419
420 HapTokenInfoForSync remoteTokenInfo = {
421 .baseInfo = baseInfo,
422 .permStateList = permStateList
423 };
424
425 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
426 ASSERT_EQ(ret, RET_SUCCESS);
427
428 // Get local map token ID
429 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
430 ASSERT_NE(mapID, 0);
431
432 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
433 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
434
435 remoteTokenInfo.permStateList[0].grantStatus[0] = PermissionState::PERMISSION_GRANTED; // second granted
436 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
437 ASSERT_EQ(ret, RET_SUCCESS);
438
439 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
440 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
441
442 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
443 ASSERT_EQ(ret, RET_SUCCESS);
444 }
445
446 /**
447 * @tc.name: SetRemoteHapTokenInfo005
448 * @tc.desc: add remote hap token, it can not grant by GrantPermission
449 * @tc.type: FUNC
450 * @tc.require:issue I5R4UF
451 */
452 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo005, TestSize.Level1)
453 {
454 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo005 start.");
455 std::string deviceID = udid_;
456 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
457 HapTokenInfo baseInfo = {
458 .apl = APL_NORMAL,
459 .ver = 1,
460 .userID = 1,
461 .bundleName = "com.ohos.access_token",
462 .instIndex = 1,
463 .appID = "testtesttesttest",
464 .deviceID = udid_,
465 .tokenID = 0x20100000,
466 .tokenAttr = 0
467 };
468
469 PermissionStateFull infoManagerTestState = {
470 .permissionName = "ohos.permission.test1",
471 .isGeneral = true,
472 .resDeviceID = {"local"},
473 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
474 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
475 std::vector<PermissionStateFull> permStateList;
476 permStateList.emplace_back(infoManagerTestState);
477
478 HapTokenInfoForSync remoteTokenInfo = {
479 .baseInfo = baseInfo,
480 .permStateList = permStateList
481 };
482
483 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
484 ASSERT_EQ(ret, RET_SUCCESS);
485
486 // Get local map token ID
487 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
488 ASSERT_NE(mapID, 0);
489
490 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
491 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
492
493 ret = AccessTokenKit::GrantPermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED);
494 ASSERT_EQ(ret, RET_SUCCESS);
495
496 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
497 ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED);
498
499 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
500 ASSERT_EQ(ret, RET_SUCCESS);
501 }
502
503 /**
504 * @tc.name: SetRemoteHapTokenInfo006
505 * @tc.desc: add remote hap token, it can not revoke by RevokePermission
506 * @tc.type: FUNC
507 * @tc.require:issue I5R4UF
508 */
509 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo006, TestSize.Level1)
510 {
511 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo006 start.");
512 std::string deviceID = udid_;
513 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
514 HapTokenInfo baseInfo = {
515 .apl = APL_NORMAL,
516 .ver = 1,
517 .userID = 1,
518 .bundleName = "com.ohos.access_token",
519 .instIndex = 1,
520 .appID = "testtesttesttest",
521 .deviceID = udid_,
522 .tokenID = 0x20100000,
523 .tokenAttr = 0
524 };
525
526 PermissionStateFull infoManagerTestState = {
527 .permissionName = "ohos.permission.test1",
528 .isGeneral = true,
529 .resDeviceID = {"local"},
530 .grantStatus = {PermissionState::PERMISSION_GRANTED}, // first grant
531 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
532 std::vector<PermissionStateFull> permStateList;
533 permStateList.emplace_back(infoManagerTestState);
534
535 HapTokenInfoForSync remoteTokenInfo = {
536 .baseInfo = baseInfo,
537 .permStateList = permStateList
538 };
539
540 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
541 ASSERT_EQ(ret, RET_SUCCESS);
542
543 // Get local map token ID
544 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
545 ASSERT_NE(mapID, 0);
546
547 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
548 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
549
550 ret = AccessTokenKit::RevokePermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED);
551 ASSERT_EQ(ret, RET_SUCCESS);
552
553 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
554 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
555
556 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
557 ASSERT_EQ(ret, RET_SUCCESS);
558 }
559
560 /**
561 * @tc.name: SetRemoteHapTokenInfo007
562 * @tc.desc: add remote hap token, it can not delete by DeleteToken
563 * @tc.type: FUNC
564 * @tc.require:issue I5R4UF
565 */
566 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo007, TestSize.Level1)
567 {
568 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo007 start.");
569 std::string deviceID = udid_;
570 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
571 HapTokenInfo baseInfo = {
572 .apl = APL_NORMAL,
573 .ver = 1,
574 .userID = 1,
575 .bundleName = "com.ohos.access_token",
576 .instIndex = 1,
577 .appID = "testtesttesttest",
578 .deviceID = udid_,
579 .tokenID = 0x20100000,
580 .tokenAttr = 0
581 };
582
583 PermissionStateFull infoManagerTestState = {
584 .permissionName = "ohos.permission.test1",
585 .isGeneral = true,
586 .resDeviceID = {"local"},
587 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
588 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
589 std::vector<PermissionStateFull> permStateList;
590 permStateList.emplace_back(infoManagerTestState);
591
592 HapTokenInfoForSync remoteTokenInfo = {
593 .baseInfo = baseInfo,
594 .permStateList = permStateList
595 };
596
597 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
598 ASSERT_EQ(ret, RET_SUCCESS);
599
600 // Get local map token ID
601 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
602 ASSERT_NE(mapID, 0);
603
604 ret = AccessTokenKit::DeleteToken(mapID);
605 ASSERT_EQ(ret, RET_FAILED);
606
607 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
608 ASSERT_EQ(ret, RET_SUCCESS);
609 }
610
611 /**
612 * @tc.name: SetRemoteHapTokenInfo008
613 * @tc.desc: add remote hap token, it can not update by UpdateHapToken
614 * @tc.type: FUNC
615 * @tc.require:issue I5R4UF
616 */
617 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo008, TestSize.Level1)
618 {
619 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo008 start.");
620 std::string deviceID = udid_;
621 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
622 int32_t DEFAULT_API_VERSION = 8;
623 HapTokenInfo baseInfo = {
624 .apl = APL_NORMAL,
625 .ver = 1,
626 .userID = 1,
627 .bundleName = "com.ohos.access_token",
628 .instIndex = 1,
629 .appID = "testtesttesttest",
630 .deviceID = udid_,
631 .tokenID = 0x20100000,
632 .tokenAttr = 0
633 };
634
635 PermissionStateFull infoManagerTestState = {
636 .permissionName = "ohos.permission.test1",
637 .isGeneral = true,
638 .resDeviceID = {"local"},
639 .grantStatus = {PermissionState::PERMISSION_DENIED}, // first denied
640 .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED}};
641 std::vector<PermissionStateFull> permStateList;
642 permStateList.emplace_back(infoManagerTestState);
643
644 HapTokenInfoForSync remoteTokenInfo = {
645 .baseInfo = baseInfo,
646 .permStateList = permStateList
647 };
648
649 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
650 ASSERT_EQ(ret, RET_SUCCESS);
651
652 // Get local map token ID
653 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
654 ASSERT_NE(mapID, 0);
655
656 HapPolicyParams policy;
657
658 ret = AccessTokenKit::UpdateHapToken(mapID, "updateFailed", DEFAULT_API_VERSION, policy);
659 ASSERT_EQ(ret, RET_FAILED);
660
661 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
662 ASSERT_EQ(ret, RET_SUCCESS);
663 }
664
665 /**
666 * @tc.name: SetRemoteHapTokenInfo009
667 * @tc.desc: add remote hap token, it can not clear by ClearUserGrantedPermissionState
668 * @tc.type: FUNC
669 * @tc.require:issue I5R4UF
670 */
671 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo009, TestSize.Level1)
672 {
673 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo009 start.");
674 std::string deviceID = udid_;
675 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
676 HapTokenInfo baseInfo = {
677 .apl = APL_NORMAL,
678 .ver = 1,
679 .userID = 1,
680 .bundleName = "com.ohos.access_token",
681 .instIndex = 1,
682 .appID = "testtesttesttest",
683 .deviceID = udid_,
684 .tokenID = 0x20100000,
685 .tokenAttr = 0
686 };
687
688 PermissionStateFull infoManagerTestState = {
689 .permissionName = "ohos.permission.test1",
690 .isGeneral = true,
691 .resDeviceID = {"local"},
692 .grantStatus = {PermissionState::PERMISSION_GRANTED},
693 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
694 std::vector<PermissionStateFull> permStateList;
695 permStateList.emplace_back(infoManagerTestState);
696
697 HapTokenInfoForSync remoteTokenInfo = {
698 .baseInfo = baseInfo,
699 .permStateList = permStateList
700 };
701
702 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
703 ASSERT_EQ(ret, RET_SUCCESS);
704
705 // Get local map token ID
706 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
707 ASSERT_NE(mapID, 0);
708
709 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
710 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
711
712 ret = AccessTokenKit::ClearUserGrantedPermissionState(mapID);
713 ASSERT_EQ(ret, RET_SUCCESS);
714
715 ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1");
716 ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED);
717
718 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
719 ASSERT_EQ(ret, RET_SUCCESS);
720 }
721
722 /**
723 * @tc.name: SetRemoteHapTokenInfo010
724 * @tc.desc: tokenID is not hap token
725 * @tc.type: FUNC
726 * @tc.require:issue I5R4UF
727 */
728 HWTEST_F(RemoteTokenKitTest, SetRemoteHapTokenInfo010, TestSize.Level1)
729 {
730 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteHapTokenInfo009 start.");
731 std::string deviceID = udid_;
732 HapTokenInfo baseInfo = {
733 .apl = APL_NORMAL,
734 .ver = 1,
735 .userID = 1,
736 .bundleName = "com.ohos.access_token",
737 .instIndex = 1,
738 .appID = "testtesttesttest",
739 .deviceID = udid_,
740 .tokenID = 0x28100000,
741 .tokenAttr = 0
742 };
743
744 PermissionStateFull infoManagerTestState = {
745 .permissionName = "ohos.permission.test1",
746 .isGeneral = true,
747 .resDeviceID = {"local"},
748 .grantStatus = {PermissionState::PERMISSION_GRANTED},
749 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
750 std::vector<PermissionStateFull> permStateList;
751 permStateList.emplace_back(infoManagerTestState);
752
753 HapTokenInfoForSync remoteTokenInfo = {
754 .baseInfo = baseInfo,
755 .permStateList = permStateList
756 };
757
758 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
759 ASSERT_NE(ret, RET_SUCCESS);
760 }
761
762 /**
763 * @tc.name: DeleteRemoteDeviceToken001
764 * @tc.desc: delete exist device mapping tokenId
765 * @tc.type: FUNC
766 * @tc.require:issue I5R4UF
767 */
768 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceToken001, TestSize.Level1)
769 {
770 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
771 std::string deviceID = udid_;
772 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
773 HapTokenInfo baseInfo = {
774 .apl = APL_NORMAL,
775 .ver = 1,
776 .userID = 1,
777 .bundleName = "com.ohos.access_token",
778 .instIndex = 1,
779 .appID = "testtesttesttest",
780 .deviceID = deviceID,
781 .tokenID = 0x20100000,
782 .tokenAttr = 0
783 };
784
785 PermissionStateFull infoManagerTestState = {
786 .permissionName = "ohos.permission.test1",
787 .isGeneral = true,
788 .resDeviceID = {"local"},
789 .grantStatus = {PermissionState::PERMISSION_GRANTED},
790 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
791 std::vector<PermissionStateFull> permStateList;
792 permStateList.emplace_back(infoManagerTestState);
793
794 HapTokenInfoForSync remoteTokenInfo = {
795 .baseInfo = baseInfo,
796 .permStateList = permStateList
797 };
798
799 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
800 ASSERT_EQ(ret, RET_SUCCESS);
801
802 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
803 ASSERT_NE(mapID, 0);
804
805 HapTokenInfo info;
806 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
807 ASSERT_EQ(ret, RET_SUCCESS);
808
809 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
810 ASSERT_EQ(ret, RET_SUCCESS);
811
812 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
813 ASSERT_NE(ret, RET_SUCCESS);
814 }
815
816 /**
817 * @tc.name: DeleteRemoteDeviceToken002
818 * @tc.desc: delete exist device mapping tokenId
819 * @tc.type: FUNC
820 * @tc.require:issue I5R4UF
821 */
822 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceToken002, TestSize.Level1)
823 {
824 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
825 std::string deviceID = udid_;
826 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
827 HapTokenInfo baseInfo = {
828 .apl = APL_NORMAL,
829 .ver = 1,
830 .userID = 1,
831 .bundleName = "com.ohos.access_token",
832 .instIndex = 1,
833 .appID = "testtesttesttest",
834 .deviceID = deviceID,
835 .tokenID = 0x20100000,
836 .tokenAttr = 0
837 };
838
839 PermissionStateFull infoManagerTestState = {
840 .permissionName = "ohos.permission.test1",
841 .isGeneral = true,
842 .resDeviceID = {"local"},
843 .grantStatus = {PermissionState::PERMISSION_GRANTED},
844 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
845 std::vector<PermissionStateFull> permStateList;
846 permStateList.emplace_back(infoManagerTestState);
847
848 HapTokenInfoForSync remoteTokenInfo = {
849 .baseInfo = baseInfo,
850 .permStateList = permStateList
851 };
852
853 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
854 ASSERT_EQ(ret, RET_SUCCESS);
855
856 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
857 ASSERT_NE(mapID, 0);
858
859 HapTokenInfo info;
860 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
861 ASSERT_EQ(ret, RET_SUCCESS);
862
863 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0);
864 ASSERT_NE(ret, RET_SUCCESS);
865
866 // deviceID is wrong
867 std::string wrongStr(10241, 'x');
868 deviceID = wrongStr;
869 ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
870 ASSERT_NE(ret, RET_SUCCESS);
871 }
872
873 /**
874 * @tc.name: DeleteRemoteDeviceToken003
875 * @tc.desc: delete exist device mapping tokenId
876 * @tc.type: FUNC
877 * @tc.require:issue I5R4UF
878 */
879 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceToken003, TestSize.Level1)
880 {
881 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceToken003 start.");
882 std::string deviceID = udid_;
883 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
884
885 int ret = AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
886 ASSERT_NE(ret, RET_SUCCESS);
887 }
888
889 /**
890 * @tc.name: DeleteRemoteDeviceTokens001
891 * @tc.desc: delete all mapping tokens of exist device
892 * @tc.type: FUNC
893 * @tc.require:issue I5R4UF
894 */
895 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceTokens001, TestSize.Level1)
896 {
897 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens001 start.");
898 std::string deviceID = udid_;
899 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
900 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100001);
901 HapTokenInfo baseInfo = {
902 .apl = APL_NORMAL,
903 .ver = 1,
904 .userID = 1,
905 .bundleName = "com.ohos.access_token",
906 .instIndex = 1,
907 .appID = "testtesttesttest",
908 .deviceID = udid_,
909 .tokenID = 0x20100000,
910 .tokenAttr = 0
911 };
912
913 PermissionStateFull infoManagerTestState = {
914 .permissionName = "ohos.permission.test1",
915 .isGeneral = true,
916 .resDeviceID = {"local"},
917 .grantStatus = {PermissionState::PERMISSION_GRANTED},
918 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
919 std::vector<PermissionStateFull> permStateList;
920 permStateList.emplace_back(infoManagerTestState);
921
922 HapTokenInfoForSync remoteTokenInfo = {
923 .baseInfo = baseInfo,
924 .permStateList = permStateList
925 };
926
927 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
928 ASSERT_EQ(ret, RET_SUCCESS);
929
930 HapTokenInfoForSync remoteTokenInfo1 = remoteTokenInfo;
931 remoteTokenInfo1.baseInfo.tokenID = 0x20100001;
932 remoteTokenInfo1.baseInfo.bundleName = "com.ohos.access_token1";
933 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo1);
934 ASSERT_EQ(ret, RET_SUCCESS);
935
936 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
937 ASSERT_NE(mapID, 0);
938 AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100001);
939 ASSERT_NE(mapID1, 0);
940
941 ret = AccessTokenKit::DeleteRemoteDeviceTokens(deviceID);
942 ASSERT_EQ(ret, RET_SUCCESS);
943
944 HapTokenInfo info;
945 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
946 ASSERT_NE(ret, RET_SUCCESS);
947 ret = AccessTokenKit::GetHapTokenInfo(mapID1, info);
948 ASSERT_NE(ret, RET_SUCCESS);
949 }
950
951 /**
952 * @tc.name: DeleteRemoteDeviceTokens002
953 * @tc.desc: delete all mapping tokens of NOT exist device
954 * @tc.type: FUNC
955 * @tc.require:issue I5R4UF
956 */
957 HWTEST_F(RemoteTokenKitTest, DeleteRemoteDeviceTokens002, TestSize.Level1)
958 {
959 ACCESSTOKEN_LOG_INFO(LABEL, "DeleteRemoteDeviceTokens002 start.");
960 std::string deviceID = udid_;
961 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
962 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100001);
963 HapTokenInfo baseInfo = {
964 .apl = APL_NORMAL,
965 .ver = 1,
966 .userID = 1,
967 .bundleName = "com.ohos.access_token",
968 .instIndex = 1,
969 .appID = "testtesttesttest",
970 .deviceID = udid_,
971 .tokenID = 0x20100000,
972 .tokenAttr = 0
973 };
974
975 PermissionStateFull infoManagerTestState = {
976 .permissionName = "ohos.permission.test1",
977 .isGeneral = true,
978 .resDeviceID = {"local"},
979 .grantStatus = {PermissionState::PERMISSION_GRANTED},
980 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
981 std::vector<PermissionStateFull> permStateList;
982 permStateList.emplace_back(infoManagerTestState);
983
984 HapTokenInfoForSync remoteTokenInfo = {
985 .baseInfo = baseInfo,
986 .permStateList = permStateList
987 };
988
989 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
990 ASSERT_EQ(ret, RET_SUCCESS);
991
992 HapTokenInfoForSync remoteTokenInfo1 = remoteTokenInfo;
993 remoteTokenInfo1.baseInfo.tokenID = 0x20100001;
994 remoteTokenInfo1.baseInfo.bundleName = "com.ohos.access_token1";
995 ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo1);
996 ASSERT_EQ(ret, RET_SUCCESS);
997
998 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
999 ASSERT_NE(mapID, 0);
1000 AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100001);
1001 ASSERT_NE(mapID1, 0);
1002
1003 ret = AccessTokenKit::DeleteRemoteDeviceTokens("1111111");
1004 ASSERT_NE(ret, RET_SUCCESS);
1005
1006 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
1007 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100001);
1008 }
1009
1010 /**
1011 * @tc.name: GetHapTokenInfoFromRemote001
1012 * @tc.desc: get normal local tokenInfo
1013 * @tc.type: FUNC
1014 * @tc.require:issue I5R4UF
1015 */
1016 HWTEST_F(RemoteTokenKitTest, GetHapTokenInfoFromRemote001, TestSize.Level1)
1017 {
1018 ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote001 start.");
1019 AccessTokenIDEx tokenIdEx = {0};
1020 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
1021 AccessTokenID localTokenID = tokenIdEx.tokenIdExStruct.tokenID;
1022
1023 HapTokenInfoForSync infoSync;
1024 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(localTokenID, infoSync);
1025 ASSERT_EQ(ret, RET_SUCCESS);
1026 ASSERT_EQ(infoSync.baseInfo.apl, g_infoManagerTestPolicyPrams.apl);
1027 ASSERT_EQ(infoSync.permStateList.size(), static_cast<uint32_t>(2));
1028 ASSERT_EQ(infoSync.permStateList[1].grantFlags.size(), 2);
1029
1030 ASSERT_EQ(infoSync.permStateList[0].permissionName, g_infoManagerTestPolicyPrams.permStateList[0].permissionName);
1031 ASSERT_EQ(infoSync.permStateList[0].grantFlags[0], g_infoManagerTestPolicyPrams.permStateList[0].grantFlags[0]);
1032 ASSERT_EQ(infoSync.permStateList[0].grantStatus[0], g_infoManagerTestPolicyPrams.permStateList[0].grantStatus[0]);
1033 ASSERT_EQ(infoSync.permStateList[0].resDeviceID[0], g_infoManagerTestPolicyPrams.permStateList[0].resDeviceID[0]);
1034 ASSERT_EQ(infoSync.permStateList[0].isGeneral, g_infoManagerTestPolicyPrams.permStateList[0].isGeneral);
1035
1036 ASSERT_EQ(infoSync.permStateList[1].permissionName, g_infoManagerTestPolicyPrams.permStateList[1].permissionName);
1037 ASSERT_EQ(infoSync.permStateList[1].grantFlags[0], g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[0]);
1038 ASSERT_EQ(infoSync.permStateList[1].grantStatus[0], g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[0]);
1039 ASSERT_EQ(infoSync.permStateList[1].resDeviceID[0], g_infoManagerTestPolicyPrams.permStateList[1].resDeviceID[0]);
1040 ASSERT_EQ(infoSync.permStateList[1].isGeneral, g_infoManagerTestPolicyPrams.permStateList[1].isGeneral);
1041
1042 ASSERT_EQ(infoSync.permStateList[1].grantFlags[1], g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[1]);
1043 ASSERT_EQ(infoSync.permStateList[1].grantStatus[1], g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[1]);
1044 ASSERT_EQ(infoSync.permStateList[1].resDeviceID[1], g_infoManagerTestPolicyPrams.permStateList[1].resDeviceID[1]);
1045
1046 ASSERT_EQ(infoSync.baseInfo.bundleName, g_infoManagerTestInfoParms.bundleName);
1047 ASSERT_EQ(infoSync.baseInfo.userID, g_infoManagerTestInfoParms.userID);
1048 ASSERT_EQ(infoSync.baseInfo.instIndex, g_infoManagerTestInfoParms.instIndex);
1049 ASSERT_EQ(infoSync.baseInfo.appID, g_infoManagerTestInfoParms.appIDDesc);
1050 ASSERT_EQ(infoSync.baseInfo.ver, 1);
1051 ASSERT_EQ(infoSync.baseInfo.tokenID, localTokenID);
1052 ASSERT_EQ(infoSync.baseInfo.tokenAttr, 0);
1053
1054 AccessTokenKit::DeleteToken(localTokenID);
1055 }
1056
1057 /**
1058 * @tc.name: GetHapTokenInfoFromRemote002
1059 * @tc.desc: get remote mapping tokenInfo
1060 * @tc.type: FUNC
1061 * @tc.require:issue I5R4UF
1062 */
1063 HWTEST_F(RemoteTokenKitTest, GetHapTokenInfoFromRemote002, TestSize.Level1)
1064 {
1065 ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote002 start.");
1066 std::string deviceID = udid_;
1067 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
1068 HapTokenInfo baseInfo = {
1069 .apl = APL_NORMAL,
1070 .ver = 1,
1071 .userID = 1,
1072 .bundleName = "com.ohos.access_token",
1073 .instIndex = 1,
1074 .appID = "testtesttesttest",
1075 .deviceID = udid_,
1076 .tokenID = 0x20100000,
1077 .tokenAttr = 0
1078 };
1079
1080 PermissionStateFull infoManagerTestState = {
1081 .permissionName = "ohos.permission.test1",
1082 .isGeneral = true,
1083 .resDeviceID = {"local"},
1084 .grantStatus = {PermissionState::PERMISSION_GRANTED},
1085 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
1086 std::vector<PermissionStateFull> permStateList;
1087 permStateList.emplace_back(infoManagerTestState);
1088
1089 HapTokenInfoForSync remoteTokenInfo = {
1090 .baseInfo = baseInfo,
1091 .permStateList = permStateList
1092 };
1093
1094 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
1095 ASSERT_EQ(ret, RET_SUCCESS);
1096
1097 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
1098 ASSERT_NE(mapID, 0);
1099
1100 HapTokenInfoForSync infoSync;
1101 ret = AccessTokenKit::GetHapTokenInfoFromRemote(mapID, infoSync);
1102 ASSERT_NE(ret, RET_SUCCESS);
1103
1104 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
1105 }
1106
1107 /**
1108 * @tc.name: GetHapTokenInfoFromRemote003
1109 * @tc.desc: get wrong tokenInfo
1110 * @tc.type: FUNC
1111 * @tc.require:issue I5R4UF
1112 */
1113 HWTEST_F(RemoteTokenKitTest, GetHapTokenInfoFromRemote003, TestSize.Level1)
1114 {
1115 ACCESSTOKEN_LOG_INFO(LABEL, "GetHapTokenInfoFromRemote003 start.");
1116 HapTokenInfoForSync infoSync;
1117 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(0, infoSync);
1118 ASSERT_NE(ret, RET_SUCCESS);
1119 }
1120
1121 /**
1122 * @tc.name: AllocLocalTokenID001
1123 * @tc.desc: get already mapping tokenInfo, makesure ipc right
1124 * @tc.type: FUNC
1125 * @tc.require:issue I5R4UF
1126 */
1127 HWTEST_F(RemoteTokenKitTest, AllocLocalTokenID001, TestSize.Level1)
1128 {
1129 ACCESSTOKEN_LOG_INFO(LABEL, "AllocLocalTokenID001 start.");
1130 std::string deviceID = udid_;
1131 AccessTokenKit::DeleteRemoteToken(deviceID, 0x20100000);
1132 HapTokenInfo baseInfo = {
1133 .apl = APL_NORMAL,
1134 .ver = 1,
1135 .userID = 1,
1136 .bundleName = "com.ohos.access_token",
1137 .instIndex = 1,
1138 .appID = "testtesttesttest",
1139 .deviceID = udid_,
1140 .tokenID = 0x20100000,
1141 .tokenAttr = 0
1142 };
1143
1144 PermissionStateFull infoManagerTestState = {
1145 .permissionName = "ohos.permission.test1",
1146 .isGeneral = true,
1147 .resDeviceID = {"local"},
1148 .grantStatus = {PermissionState::PERMISSION_GRANTED},
1149 .grantFlags = {PermissionFlag::PERMISSION_USER_SET}};
1150 std::vector<PermissionStateFull> permStateList;
1151 permStateList.emplace_back(infoManagerTestState);
1152
1153 HapTokenInfoForSync remoteTokenInfo = {
1154 .baseInfo = baseInfo,
1155 .permStateList = permStateList
1156 };
1157
1158 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID, remoteTokenInfo);
1159 ASSERT_EQ(ret, RET_SUCCESS);
1160
1161 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
1162 ASSERT_NE(mapID, 0);
1163 }
1164
1165 /**
1166 * @tc.name: GetAllNativeTokenInfo001
1167 * @tc.desc: get all native token with dcaps
1168 * @tc.type: FUNC
1169 * @tc.require:issue I5R4UF
1170 */
1171 HWTEST_F(RemoteTokenKitTest, GetAllNativeTokenInfo001, TestSize.Level1)
1172 {
1173 ACCESSTOKEN_LOG_INFO(LABEL, "GetAllNativeTokenInfo001 start.");
1174
1175 std::vector<NativeTokenInfoForSync> nativeTokenInfosRes;
1176 int ret = AccessTokenKit::GetAllNativeTokenInfo(nativeTokenInfosRes);
1177 ASSERT_EQ(ret, RET_SUCCESS);
1178 }
1179
1180 /**
1181 * @tc.name: GetAllNativeTokenInfo002
1182 * @tc.desc: GetAllNativeTokenInfo function test.
1183 * @tc.type: FUNC
1184 * @tc.require: issueI61NS6
1185 */
1186 HWTEST_F(RemoteTokenKitTest, GetAllNativeTokenInfo002, TestSize.Level1)
1187 {
1188 AccessTokenID tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service");
1189 SetSelfTokenID(tokenId);
1190 std::vector<NativeTokenInfoForSync> nativeTokenInfoRes;
1191 int res = AccessTokenKit::GetAllNativeTokenInfo(nativeTokenInfoRes);
1192 ASSERT_EQ(0, res);
1193 }
1194
1195 /**
1196 * @tc.name: SetRemoteNativeTokenInfo001
1197 * @tc.desc: set already mapping tokenInfo
1198 * @tc.type: FUNC
1199 * @tc.require:issue I5R4UF
1200 */
1201 HWTEST_F(RemoteTokenKitTest, SetRemoteNativeTokenInfo001, TestSize.Level1)
1202 {
1203 ACCESSTOKEN_LOG_INFO(LABEL, "SetRemoteNativeTokenInfo001 start.");
1204 std::string deviceID = udid_;
1205
1206 NativeTokenInfoForSync native1 = {
1207 .baseInfo.apl = APL_NORMAL,
1208 .baseInfo.ver = 1,
1209 .baseInfo.processName = "native_test1",
1210 .baseInfo.dcap = {"SYSDCAP", "DMSDCAP"},
1211 .baseInfo.tokenID = 0x28000000,
1212 .baseInfo.tokenAttr = 0,
1213 .baseInfo.nativeAcls = {"ohos.permission.DISTRIBUTED_DATASYNC"},
1214 };
1215
1216 std::vector<NativeTokenInfoForSync> nativeTokenInfoList;
1217 nativeTokenInfoList.emplace_back(native1);
1218
1219 int ret = AccessTokenKit::SetRemoteNativeTokenInfo(deviceID, nativeTokenInfoList);
1220 ASSERT_EQ(ret, RET_SUCCESS);
1221
1222 AccessTokenID mapID = AccessTokenKit::GetRemoteNativeTokenID(deviceID, 0x28000000);
1223 ASSERT_NE(mapID, 0);
1224
1225 NativeTokenInfo resultInfo;
1226 ret = AccessTokenKit::GetNativeTokenInfo(mapID, resultInfo);
1227 ASSERT_EQ(ret, RET_SUCCESS);
1228
1229 ASSERT_EQ(resultInfo.apl, native1.baseInfo.apl);
1230 ASSERT_EQ(resultInfo.ver, native1.baseInfo.ver);
1231 ASSERT_EQ(resultInfo.processName, native1.baseInfo.processName);
1232 ASSERT_EQ(resultInfo.dcap.size(), 2);
1233 ASSERT_EQ(resultInfo.dcap[0], "SYSDCAP");
1234 ASSERT_EQ(resultInfo.dcap[1], "DMSDCAP");
1235 ASSERT_EQ(resultInfo.nativeAcls.size(), 1);
1236 ASSERT_EQ(resultInfo.nativeAcls[0], "ohos.permission.DISTRIBUTED_DATASYNC");
1237 ASSERT_EQ(resultInfo.tokenID, mapID);
1238 ASSERT_EQ(resultInfo.tokenAttr, native1.baseInfo.tokenAttr);
1239 }
1240
1241 /**
1242 * @tc.name: DeleteRemoteToken001
1243 * @tc.desc: DeleteRemoteToken with invalid parameters.
1244 * @tc.type: FUNC
1245 * @tc.require:Issue Number
1246 */
1247 HWTEST_F(RemoteTokenKitTest, DeleteRemoteToken001, TestSize.Level1)
1248 {
1249 std::string deviceId = "device";
1250 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
1251 g_infoManagerTestInfoParms.bundleName,
1252 g_infoManagerTestInfoParms.instIndex);
1253 int res = AccessTokenKit::DeleteRemoteToken("", tokenID);
1254 ASSERT_EQ(RET_FAILED, res);
1255
1256 res = AccessTokenKit::DeleteRemoteToken(deviceId, tokenID);
1257 ASSERT_EQ(RET_FAILED, res);
1258 }
1259 #endif
1260