1 /* 2 * Copyright (C) 2019 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.pm; 18 19 20 import static org.hamcrest.MatcherAssert.assertThat; 21 import static org.hamcrest.Matchers.contains; 22 import static org.junit.Assert.assertFalse; 23 import static org.junit.Assert.assertTrue; 24 import static org.mockito.ArgumentMatchers.any; 25 import static org.mockito.Mockito.doAnswer; 26 import static org.mockito.Mockito.verify; 27 import static org.mockito.Mockito.when; 28 29 import android.annotation.Nullable; 30 import android.content.Intent; 31 import android.content.IntentFilter; 32 import android.content.pm.ApplicationInfo; 33 import android.content.pm.PackageParser; 34 import android.content.pm.PackageParser.SigningDetails; 35 import android.content.pm.Signature; 36 import android.content.pm.UserInfo; 37 import android.content.pm.parsing.ParsingPackage; 38 import android.content.pm.parsing.component.ParsedActivity; 39 import android.content.pm.parsing.component.ParsedInstrumentation; 40 import android.content.pm.parsing.component.ParsedIntentInfo; 41 import android.content.pm.parsing.component.ParsedProvider; 42 import android.os.Build; 43 import android.os.Process; 44 import android.os.UserHandle; 45 import android.platform.test.annotations.Presubmit; 46 import android.util.ArrayMap; 47 import android.util.ArraySet; 48 import android.util.SparseArray; 49 50 import androidx.annotation.NonNull; 51 52 import com.android.server.om.OverlayReferenceMapper; 53 import com.android.server.pm.parsing.pkg.AndroidPackage; 54 import com.android.server.pm.parsing.pkg.PackageImpl; 55 import com.android.server.pm.parsing.pkg.ParsedPackage; 56 import com.android.server.utils.WatchableTester; 57 58 import org.junit.Before; 59 import org.junit.Test; 60 import org.junit.runner.RunWith; 61 import org.junit.runners.JUnit4; 62 import org.mockito.Mock; 63 import org.mockito.Mockito; 64 import org.mockito.MockitoAnnotations; 65 import org.mockito.stubbing.Answer; 66 67 import java.security.cert.CertificateException; 68 import java.util.ArrayList; 69 import java.util.Arrays; 70 import java.util.Collections; 71 import java.util.List; 72 import java.util.Map; 73 import java.util.Set; 74 import java.util.concurrent.Executor; 75 76 @Presubmit 77 @RunWith(JUnit4.class) 78 public class AppsFilterTest { 79 80 private static final int DUMMY_CALLING_APPID = 10345; 81 private static final int DUMMY_TARGET_APPID = 10556; 82 private static final int DUMMY_ACTOR_APPID = 10656; 83 private static final int DUMMY_OVERLAY_APPID = 10756; 84 private static final int SYSTEM_USER = 0; 85 private static final int SECONDARY_USER = 10; 86 private static final int[] USER_ARRAY = {SYSTEM_USER, SECONDARY_USER}; 87 private static final UserInfo[] USER_INFO_LIST = Arrays.stream(USER_ARRAY).mapToObj( 88 id -> new UserInfo(id, Integer.toString(id), 0)).toArray(UserInfo[]::new); 89 90 @Mock 91 AppsFilter.FeatureConfig mFeatureConfigMock; 92 @Mock 93 AppsFilter.StateProvider mStateProvider; 94 @Mock 95 Executor mMockExecutor; 96 97 private ArrayMap<String, PackageSetting> mExisting = new ArrayMap<>(); 98 pkg(String packageName)99 private static ParsingPackage pkg(String packageName) { 100 return PackageImpl.forTesting(packageName) 101 .setTargetSdkVersion(Build.VERSION_CODES.R); 102 } 103 pkg(String packageName, Intent... queries)104 private static ParsingPackage pkg(String packageName, Intent... queries) { 105 ParsingPackage pkg = pkg(packageName); 106 if (queries != null) { 107 for (Intent intent : queries) { 108 pkg.addQueriesIntent(intent); 109 } 110 } 111 return pkg; 112 } 113 pkgQueriesProvider(String packageName, String... queriesAuthorities)114 private static ParsingPackage pkgQueriesProvider(String packageName, 115 String... queriesAuthorities) { 116 ParsingPackage pkg = pkg(packageName); 117 if (queriesAuthorities != null) { 118 for (String authority : queriesAuthorities) { 119 pkg.addQueriesProvider(authority); 120 } 121 } 122 return pkg; 123 } 124 pkg(String packageName, String... queriesPackages)125 private static ParsingPackage pkg(String packageName, String... queriesPackages) { 126 ParsingPackage pkg = pkg(packageName); 127 if (queriesPackages != null) { 128 for (String queryPackageName : queriesPackages) { 129 pkg.addQueriesPackage(queryPackageName); 130 } 131 } 132 return pkg; 133 } 134 pkg(String packageName, IntentFilter... filters)135 private static ParsingPackage pkg(String packageName, IntentFilter... filters) { 136 ParsedActivity activity = createActivity(packageName, filters); 137 return pkg(packageName).addActivity(activity); 138 } 139 pkgWithReceiver(String packageName, IntentFilter... filters)140 private static ParsingPackage pkgWithReceiver(String packageName, IntentFilter... filters) { 141 ParsedActivity receiver = createActivity(packageName, filters); 142 return pkg(packageName).addReceiver(receiver); 143 } 144 pkgWithSharedLibrary(String packageName, String libName)145 private static ParsingPackage pkgWithSharedLibrary(String packageName, String libName) { 146 return pkg(packageName).addLibraryName(libName); 147 } 148 createActivity(String packageName, IntentFilter[] filters)149 private static ParsedActivity createActivity(String packageName, IntentFilter[] filters) { 150 ParsedActivity activity = new ParsedActivity(); 151 activity.setPackageName(packageName); 152 for (IntentFilter filter : filters) { 153 final ParsedIntentInfo info = new ParsedIntentInfo(); 154 if (filter.countActions() > 0) { 155 filter.actionsIterator().forEachRemaining(info::addAction); 156 } 157 if (filter.countCategories() > 0) { 158 filter.actionsIterator().forEachRemaining(info::addAction); 159 } 160 if (filter.countDataAuthorities() > 0) { 161 filter.authoritiesIterator().forEachRemaining(info::addDataAuthority); 162 } 163 if (filter.countDataSchemes() > 0) { 164 filter.schemesIterator().forEachRemaining(info::addDataScheme); 165 } 166 activity.addIntent(info); 167 activity.setExported(true); 168 } 169 return activity; 170 } 171 pkgWithInstrumentation( String packageName, String instrumentationTargetPackage)172 private static ParsingPackage pkgWithInstrumentation( 173 String packageName, String instrumentationTargetPackage) { 174 ParsedInstrumentation instrumentation = new ParsedInstrumentation(); 175 instrumentation.setTargetPackage(instrumentationTargetPackage); 176 return pkg(packageName).addInstrumentation(instrumentation); 177 } 178 pkgWithProvider(String packageName, String authority)179 private static ParsingPackage pkgWithProvider(String packageName, String authority) { 180 ParsedProvider provider = new ParsedProvider(); 181 provider.setPackageName(packageName); 182 provider.setExported(true); 183 provider.setAuthority(authority); 184 return pkg(packageName) 185 .addProvider(provider); 186 } 187 188 @Before setup()189 public void setup() throws Exception { 190 mExisting = new ArrayMap<>(); 191 192 MockitoAnnotations.initMocks(this); 193 doAnswer(invocation -> { 194 ((AppsFilter.StateProvider.CurrentStateCallback) invocation.getArgument(0)) 195 .currentState(mExisting, USER_INFO_LIST); 196 return new Object(); 197 }).when(mStateProvider) 198 .runWithState(any(AppsFilter.StateProvider.CurrentStateCallback.class)); 199 200 doAnswer(invocation -> { 201 ((Runnable) invocation.getArgument(0)).run(); 202 return new Object(); 203 }).when(mMockExecutor).execute(any(Runnable.class)); 204 205 when(mFeatureConfigMock.isGloballyEnabled()).thenReturn(true); 206 when(mFeatureConfigMock.packageIsEnabled(any(AndroidPackage.class))).thenAnswer( 207 (Answer<Boolean>) invocation -> 208 ((AndroidPackage)invocation.getArgument(SYSTEM_USER)).getTargetSdkVersion() 209 >= Build.VERSION_CODES.R); 210 } 211 212 @Test testSystemReadyPropogates()213 public void testSystemReadyPropogates() throws Exception { 214 final AppsFilter appsFilter = 215 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 216 mMockExecutor); 217 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 218 watcher.register(); 219 appsFilter.onSystemReady(); 220 watcher.verifyChangeReported("systemReady"); 221 verify(mFeatureConfigMock).onSystemReady(); 222 } 223 224 @Test testQueriesAction_FilterMatches()225 public void testQueriesAction_FilterMatches() throws Exception { 226 final AppsFilter appsFilter = 227 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 228 mMockExecutor); 229 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 230 watcher.register(); 231 simulateAddBasicAndroid(appsFilter); 232 watcher.verifyChangeReported("addBasicAndroid"); 233 appsFilter.onSystemReady(); 234 watcher.verifyChangeReported("systemReady"); 235 236 PackageSetting target = simulateAddPackage(appsFilter, 237 pkg("com.some.package", new IntentFilter("TEST_ACTION")), DUMMY_TARGET_APPID); 238 watcher.verifyChangeReported("add package"); 239 PackageSetting calling = simulateAddPackage(appsFilter, 240 pkg("com.some.other.package", new Intent("TEST_ACTION")), DUMMY_CALLING_APPID); 241 watcher.verifyChangeReported("add package"); 242 243 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 244 SYSTEM_USER)); 245 watcher.verifyNoChangeReported("shouldFilterAplication"); 246 } 247 @Test testQueriesProtectedAction_FilterDoesNotMatch()248 public void testQueriesProtectedAction_FilterDoesNotMatch() throws Exception { 249 final AppsFilter appsFilter = 250 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 251 mMockExecutor); 252 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 253 watcher.register(); 254 final Signature frameworkSignature = Mockito.mock(Signature.class); 255 final PackageParser.SigningDetails frameworkSigningDetails = 256 new PackageParser.SigningDetails(new Signature[]{frameworkSignature}, 1); 257 final ParsingPackage android = pkg("android"); 258 watcher.verifyNoChangeReported("prepare"); 259 android.addProtectedBroadcast("TEST_ACTION"); 260 simulateAddPackage(appsFilter, android, 1000, 261 b -> b.setSigningDetails(frameworkSigningDetails)); 262 watcher.verifyChangeReported("addPackage"); 263 appsFilter.onSystemReady(); 264 watcher.verifyChangeReported("systemReady"); 265 266 final int activityUid = DUMMY_TARGET_APPID; 267 PackageSetting targetActivity = simulateAddPackage(appsFilter, 268 pkg("com.target.activity", new IntentFilter("TEST_ACTION")), activityUid); 269 watcher.verifyChangeReported("addPackage"); 270 final int receiverUid = DUMMY_TARGET_APPID + 1; 271 PackageSetting targetReceiver = simulateAddPackage(appsFilter, 272 pkgWithReceiver("com.target.receiver", new IntentFilter("TEST_ACTION")), 273 receiverUid); 274 watcher.verifyChangeReported("addPackage"); 275 final int callingUid = DUMMY_CALLING_APPID; 276 PackageSetting calling = simulateAddPackage(appsFilter, 277 pkg("com.calling.action", new Intent("TEST_ACTION")), callingUid); 278 watcher.verifyChangeReported("addPackage"); 279 final int wildcardUid = DUMMY_CALLING_APPID + 1; 280 PackageSetting callingWildCard = simulateAddPackage(appsFilter, 281 pkg("com.calling.wildcard", new Intent("*")), wildcardUid); 282 watcher.verifyChangeReported("addPackage"); 283 284 assertFalse(appsFilter.shouldFilterApplication(callingUid, calling, targetActivity, 285 SYSTEM_USER)); 286 assertTrue(appsFilter.shouldFilterApplication(callingUid, calling, targetReceiver, 287 SYSTEM_USER)); 288 289 assertFalse(appsFilter.shouldFilterApplication( 290 wildcardUid, callingWildCard, targetActivity, SYSTEM_USER)); 291 assertTrue(appsFilter.shouldFilterApplication( 292 wildcardUid, callingWildCard, targetReceiver, SYSTEM_USER)); 293 watcher.verifyNoChangeReported("shouldFilterApplication"); 294 } 295 296 @Test testQueriesProvider_FilterMatches()297 public void testQueriesProvider_FilterMatches() throws Exception { 298 final AppsFilter appsFilter = 299 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 300 mMockExecutor); 301 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 302 watcher.register(); 303 simulateAddBasicAndroid(appsFilter); 304 watcher.verifyChangeReported("addPackage"); 305 appsFilter.onSystemReady(); 306 watcher.verifyChangeReported("systemReady"); 307 308 PackageSetting target = simulateAddPackage(appsFilter, 309 pkgWithProvider("com.some.package", "com.some.authority"), DUMMY_TARGET_APPID); 310 watcher.verifyChangeReported("addPackage"); 311 PackageSetting calling = simulateAddPackage(appsFilter, 312 pkgQueriesProvider("com.some.other.package", "com.some.authority"), 313 DUMMY_CALLING_APPID); 314 watcher.verifyChangeReported("addPackage"); 315 316 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 317 SYSTEM_USER)); 318 watcher.verifyNoChangeReported("shouldFilterApplication"); 319 } 320 321 @Test testQueriesDifferentProvider_Filters()322 public void testQueriesDifferentProvider_Filters() throws Exception { 323 final AppsFilter appsFilter = 324 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 325 mMockExecutor); 326 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 327 watcher.register(); 328 simulateAddBasicAndroid(appsFilter); 329 watcher.verifyChangeReported("addPackage"); 330 appsFilter.onSystemReady(); 331 watcher.verifyChangeReported("systemReady"); 332 333 PackageSetting target = simulateAddPackage(appsFilter, 334 pkgWithProvider("com.some.package", "com.some.authority"), DUMMY_TARGET_APPID); 335 watcher.verifyChangeReported("addPackage"); 336 PackageSetting calling = simulateAddPackage(appsFilter, 337 pkgQueriesProvider("com.some.other.package", "com.some.other.authority"), 338 DUMMY_CALLING_APPID); 339 watcher.verifyChangeReported("addPackage"); 340 341 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 342 SYSTEM_USER)); 343 watcher.verifyNoChangeReported("shouldFilterApplication"); 344 } 345 346 @Test testQueriesProviderWithSemiColon_FilterMatches()347 public void testQueriesProviderWithSemiColon_FilterMatches() throws Exception { 348 final AppsFilter appsFilter = 349 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 350 mMockExecutor); 351 simulateAddBasicAndroid(appsFilter); 352 appsFilter.onSystemReady(); 353 354 PackageSetting target = simulateAddPackage(appsFilter, 355 pkgWithProvider("com.some.package", "com.some.authority;com.some.other.authority"), 356 DUMMY_TARGET_APPID); 357 PackageSetting calling = simulateAddPackage(appsFilter, 358 pkgQueriesProvider("com.some.other.package", "com.some.authority"), 359 DUMMY_CALLING_APPID); 360 361 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 362 SYSTEM_USER)); 363 } 364 365 @Test testQueriesAction_NoMatchingAction_Filters()366 public void testQueriesAction_NoMatchingAction_Filters() throws Exception { 367 final AppsFilter appsFilter = 368 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 369 mMockExecutor); 370 simulateAddBasicAndroid(appsFilter); 371 appsFilter.onSystemReady(); 372 373 PackageSetting target = simulateAddPackage(appsFilter, 374 pkg("com.some.package"), DUMMY_TARGET_APPID); 375 PackageSetting calling = simulateAddPackage(appsFilter, 376 pkg("com.some.other.package", new Intent("TEST_ACTION")), DUMMY_CALLING_APPID); 377 378 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 379 SYSTEM_USER)); 380 } 381 382 @Test testQueriesAction_NoMatchingActionFilterLowSdk_DoesntFilter()383 public void testQueriesAction_NoMatchingActionFilterLowSdk_DoesntFilter() throws Exception { 384 final AppsFilter appsFilter = 385 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 386 mMockExecutor); 387 simulateAddBasicAndroid(appsFilter); 388 appsFilter.onSystemReady(); 389 390 PackageSetting target = simulateAddPackage(appsFilter, 391 pkg("com.some.package"), DUMMY_TARGET_APPID); 392 ParsingPackage callingPkg = pkg("com.some.other.package", 393 new Intent("TEST_ACTION")) 394 .setTargetSdkVersion(Build.VERSION_CODES.P); 395 PackageSetting calling = simulateAddPackage(appsFilter, callingPkg, 396 DUMMY_CALLING_APPID); 397 398 399 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 400 SYSTEM_USER)); 401 } 402 403 @Test testNoQueries_Filters()404 public void testNoQueries_Filters() throws Exception { 405 final AppsFilter appsFilter = 406 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 407 mMockExecutor); 408 simulateAddBasicAndroid(appsFilter); 409 appsFilter.onSystemReady(); 410 411 PackageSetting target = simulateAddPackage(appsFilter, 412 pkg("com.some.package"), DUMMY_TARGET_APPID); 413 PackageSetting calling = simulateAddPackage(appsFilter, 414 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 415 416 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 417 SYSTEM_USER)); 418 } 419 420 @Test testNoUsesLibrary_Filters()421 public void testNoUsesLibrary_Filters() throws Exception { 422 final AppsFilter appsFilter = new AppsFilter(mStateProvider, mFeatureConfigMock, 423 new String[]{}, /* systemAppsQueryable */ false, /* overlayProvider */ null, 424 mMockExecutor); 425 426 simulateAddBasicAndroid(appsFilter); 427 appsFilter.onSystemReady(); 428 429 final Signature mockSignature = Mockito.mock(Signature.class); 430 final SigningDetails mockSigningDetails = new SigningDetails( 431 new Signature[]{mockSignature}, 432 SigningDetails.SignatureSchemeVersion.SIGNING_BLOCK_V2); 433 434 final PackageSetting target = simulateAddPackage(appsFilter, 435 pkgWithSharedLibrary("com.some.package", "com.some.shared_library"), 436 DUMMY_TARGET_APPID, 437 setting -> setting.setSigningDetails(mockSigningDetails) 438 .setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 439 final PackageSetting calling = simulateAddPackage(appsFilter, 440 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 441 442 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 443 SYSTEM_USER)); 444 } 445 446 @Test testUsesLibrary_DoesntFilter()447 public void testUsesLibrary_DoesntFilter() throws Exception { 448 final AppsFilter appsFilter = new AppsFilter(mStateProvider, mFeatureConfigMock, 449 new String[]{}, /* systemAppsQueryable */ false, /* overlayProvider */ null, 450 mMockExecutor); 451 452 simulateAddBasicAndroid(appsFilter); 453 appsFilter.onSystemReady(); 454 455 final Signature mockSignature = Mockito.mock(Signature.class); 456 final SigningDetails mockSigningDetails = new SigningDetails( 457 new Signature[]{mockSignature}, 458 SigningDetails.SignatureSchemeVersion.SIGNING_BLOCK_V2); 459 460 final PackageSetting target = simulateAddPackage(appsFilter, 461 pkgWithSharedLibrary("com.some.package", "com.some.shared_library"), 462 DUMMY_TARGET_APPID, 463 setting -> setting.setSigningDetails(mockSigningDetails) 464 .setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 465 final PackageSetting calling = simulateAddPackage(appsFilter, 466 pkg("com.some.other.package").addUsesLibrary("com.some.shared_library"), 467 DUMMY_CALLING_APPID); 468 469 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 470 SYSTEM_USER)); 471 } 472 473 @Test testUsesOptionalLibrary_DoesntFilter()474 public void testUsesOptionalLibrary_DoesntFilter() throws Exception { 475 final AppsFilter appsFilter = new AppsFilter(mStateProvider, mFeatureConfigMock, 476 new String[]{}, /* systemAppsQueryable */ false, /* overlayProvider */ null, 477 mMockExecutor); 478 479 simulateAddBasicAndroid(appsFilter); 480 appsFilter.onSystemReady(); 481 482 final Signature mockSignature = Mockito.mock(Signature.class); 483 final SigningDetails mockSigningDetails = new SigningDetails( 484 new Signature[]{mockSignature}, 485 SigningDetails.SignatureSchemeVersion.SIGNING_BLOCK_V2); 486 487 final PackageSetting target = simulateAddPackage(appsFilter, 488 pkgWithSharedLibrary("com.some.package", "com.some.shared_library"), 489 DUMMY_TARGET_APPID, 490 setting -> setting.setSigningDetails(mockSigningDetails) 491 .setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 492 final PackageSetting calling = simulateAddPackage(appsFilter, 493 pkg("com.some.other.package").addUsesOptionalLibrary("com.some.shared_library"), 494 DUMMY_CALLING_APPID); 495 496 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 497 SYSTEM_USER)); 498 } 499 500 @Test testUsesLibrary_ShareUid_DoesntFilter()501 public void testUsesLibrary_ShareUid_DoesntFilter() throws Exception { 502 final AppsFilter appsFilter = new AppsFilter(mStateProvider, mFeatureConfigMock, 503 new String[]{}, /* systemAppsQueryable */ false, /* overlayProvider */ null, 504 mMockExecutor); 505 506 simulateAddBasicAndroid(appsFilter); 507 appsFilter.onSystemReady(); 508 509 final Signature mockSignature = Mockito.mock(Signature.class); 510 final SigningDetails mockSigningDetails = new SigningDetails( 511 new Signature[]{mockSignature}, 512 SigningDetails.SignatureSchemeVersion.SIGNING_BLOCK_V2); 513 514 final PackageSetting target = simulateAddPackage(appsFilter, 515 pkgWithSharedLibrary("com.some.package", "com.some.shared_library"), 516 DUMMY_TARGET_APPID, 517 setting -> setting.setSigningDetails(mockSigningDetails) 518 .setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 519 final PackageSetting calling = simulateAddPackage(appsFilter, 520 pkg("com.some.other.package_a").setSharedUserId("com.some.uid"), 521 DUMMY_CALLING_APPID); 522 simulateAddPackage(appsFilter, pkg("com.some.other.package_b") 523 .setSharedUserId("com.some.uid").addUsesLibrary("com.some.shared_library"), 524 DUMMY_CALLING_APPID); 525 526 // Although package_a doesn't use library, it should be granted visibility. It's because 527 // package_a shares userId with package_b, and package_b uses that shared library. 528 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 529 SYSTEM_USER)); 530 } 531 532 @Test testForceQueryable_SystemDoesntFilter()533 public void testForceQueryable_SystemDoesntFilter() throws Exception { 534 final AppsFilter appsFilter = 535 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 536 mMockExecutor); 537 simulateAddBasicAndroid(appsFilter); 538 appsFilter.onSystemReady(); 539 540 PackageSetting target = simulateAddPackage(appsFilter, 541 pkg("com.some.package").setForceQueryable(true), DUMMY_TARGET_APPID, 542 setting -> setting.setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 543 PackageSetting calling = simulateAddPackage(appsFilter, 544 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 545 546 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 547 SYSTEM_USER)); 548 } 549 550 551 @Test testForceQueryable_NonSystemFilters()552 public void testForceQueryable_NonSystemFilters() throws Exception { 553 final AppsFilter appsFilter = 554 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 555 mMockExecutor); 556 simulateAddBasicAndroid(appsFilter); 557 appsFilter.onSystemReady(); 558 559 PackageSetting target = simulateAddPackage(appsFilter, 560 pkg("com.some.package").setForceQueryable(true), DUMMY_TARGET_APPID); 561 PackageSetting calling = simulateAddPackage(appsFilter, 562 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 563 564 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 565 SYSTEM_USER)); 566 } 567 568 @Test testForceQueryableByDevice_SystemCaller_DoesntFilter()569 public void testForceQueryableByDevice_SystemCaller_DoesntFilter() throws Exception { 570 final AppsFilter appsFilter = 571 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{"com.some.package"}, 572 false, null, mMockExecutor); 573 simulateAddBasicAndroid(appsFilter); 574 appsFilter.onSystemReady(); 575 576 PackageSetting target = simulateAddPackage(appsFilter, 577 pkg("com.some.package"), DUMMY_TARGET_APPID, 578 setting -> setting.setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 579 PackageSetting calling = simulateAddPackage(appsFilter, 580 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 581 582 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 583 SYSTEM_USER)); 584 } 585 586 587 @Test testSystemSignedTarget_DoesntFilter()588 public void testSystemSignedTarget_DoesntFilter() throws CertificateException { 589 final AppsFilter appsFilter = 590 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 591 mMockExecutor); 592 appsFilter.onSystemReady(); 593 594 final Signature frameworkSignature = Mockito.mock(Signature.class); 595 final PackageParser.SigningDetails frameworkSigningDetails = 596 new PackageParser.SigningDetails(new Signature[]{frameworkSignature}, 1); 597 598 final Signature otherSignature = Mockito.mock(Signature.class); 599 final PackageParser.SigningDetails otherSigningDetails = 600 new PackageParser.SigningDetails(new Signature[]{otherSignature}, 1); 601 602 simulateAddPackage(appsFilter, pkg("android"), 1000, 603 b -> b.setSigningDetails(frameworkSigningDetails)); 604 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 605 DUMMY_TARGET_APPID, 606 b -> b.setSigningDetails(frameworkSigningDetails) 607 .setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 608 PackageSetting calling = simulateAddPackage(appsFilter, 609 pkg("com.some.other.package"), DUMMY_CALLING_APPID, 610 b -> b.setSigningDetails(otherSigningDetails)); 611 612 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 613 SYSTEM_USER)); 614 } 615 616 @Test testForceQueryableByDevice_NonSystemCaller_Filters()617 public void testForceQueryableByDevice_NonSystemCaller_Filters() throws Exception { 618 final AppsFilter appsFilter = 619 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{"com.some.package"}, 620 false, null, mMockExecutor); 621 simulateAddBasicAndroid(appsFilter); 622 appsFilter.onSystemReady(); 623 624 PackageSetting target = simulateAddPackage(appsFilter, 625 pkg("com.some.package"), DUMMY_TARGET_APPID); 626 PackageSetting calling = simulateAddPackage(appsFilter, 627 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 628 629 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 630 SYSTEM_USER)); 631 } 632 633 634 @Test testSystemQueryable_DoesntFilter()635 public void testSystemQueryable_DoesntFilter() throws Exception { 636 final AppsFilter appsFilter = 637 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, 638 true /* system force queryable */, null, mMockExecutor); 639 simulateAddBasicAndroid(appsFilter); 640 appsFilter.onSystemReady(); 641 642 PackageSetting target = simulateAddPackage(appsFilter, 643 pkg("com.some.package"), DUMMY_TARGET_APPID, 644 setting -> setting.setPkgFlags(ApplicationInfo.FLAG_SYSTEM)); 645 PackageSetting calling = simulateAddPackage(appsFilter, 646 pkg("com.some.other.package"), DUMMY_CALLING_APPID); 647 648 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 649 SYSTEM_USER)); 650 } 651 652 @Test testQueriesPackage_DoesntFilter()653 public void testQueriesPackage_DoesntFilter() throws Exception { 654 final AppsFilter appsFilter = 655 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 656 mMockExecutor); 657 simulateAddBasicAndroid(appsFilter); 658 appsFilter.onSystemReady(); 659 660 PackageSetting target = simulateAddPackage(appsFilter, 661 pkg("com.some.package"), DUMMY_TARGET_APPID); 662 PackageSetting calling = simulateAddPackage(appsFilter, 663 pkg("com.some.other.package", "com.some.package"), DUMMY_CALLING_APPID); 664 665 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 666 SYSTEM_USER)); 667 } 668 669 @Test testNoQueries_FeatureOff_DoesntFilter()670 public void testNoQueries_FeatureOff_DoesntFilter() throws Exception { 671 when(mFeatureConfigMock.packageIsEnabled(any(AndroidPackage.class))) 672 .thenReturn(false); 673 final AppsFilter appsFilter = 674 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 675 mMockExecutor); 676 simulateAddBasicAndroid(appsFilter); 677 appsFilter.onSystemReady(); 678 679 PackageSetting target = simulateAddPackage( 680 appsFilter, pkg("com.some.package"), DUMMY_TARGET_APPID); 681 PackageSetting calling = simulateAddPackage( 682 appsFilter, pkg("com.some.other.package"), DUMMY_CALLING_APPID); 683 684 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 685 SYSTEM_USER)); 686 } 687 688 @Test testSystemUid_DoesntFilter()689 public void testSystemUid_DoesntFilter() throws Exception { 690 final AppsFilter appsFilter = 691 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 692 mMockExecutor); 693 simulateAddBasicAndroid(appsFilter); 694 appsFilter.onSystemReady(); 695 696 PackageSetting target = simulateAddPackage(appsFilter, 697 pkg("com.some.package"), DUMMY_TARGET_APPID); 698 699 assertFalse(appsFilter.shouldFilterApplication(SYSTEM_USER, null, target, SYSTEM_USER)); 700 assertFalse(appsFilter.shouldFilterApplication(Process.FIRST_APPLICATION_UID - 1, 701 null, target, SYSTEM_USER)); 702 } 703 704 @Test testSystemUidSecondaryUser_DoesntFilter()705 public void testSystemUidSecondaryUser_DoesntFilter() throws Exception { 706 final AppsFilter appsFilter = 707 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 708 mMockExecutor); 709 simulateAddBasicAndroid(appsFilter); 710 appsFilter.onSystemReady(); 711 712 PackageSetting target = simulateAddPackage(appsFilter, 713 pkg("com.some.package"), DUMMY_TARGET_APPID); 714 715 assertFalse(appsFilter.shouldFilterApplication(0, null, target, SECONDARY_USER)); 716 assertFalse(appsFilter.shouldFilterApplication( 717 UserHandle.getUid(SECONDARY_USER, Process.FIRST_APPLICATION_UID - 1), 718 null, target, SECONDARY_USER)); 719 } 720 721 @Test testNonSystemUid_NoCallingSetting_Filters()722 public void testNonSystemUid_NoCallingSetting_Filters() throws Exception { 723 final AppsFilter appsFilter = 724 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 725 mMockExecutor); 726 simulateAddBasicAndroid(appsFilter); 727 appsFilter.onSystemReady(); 728 729 PackageSetting target = simulateAddPackage(appsFilter, 730 pkg("com.some.package"), DUMMY_TARGET_APPID); 731 732 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, null, target, 733 SYSTEM_USER)); 734 } 735 736 @Test testNoTargetPackage_filters()737 public void testNoTargetPackage_filters() throws Exception { 738 final AppsFilter appsFilter = 739 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 740 mMockExecutor); 741 simulateAddBasicAndroid(appsFilter); 742 appsFilter.onSystemReady(); 743 744 PackageSetting target = new PackageSettingBuilder() 745 .setAppId(DUMMY_TARGET_APPID) 746 .setName("com.some.package") 747 .setCodePath("/") 748 .setPVersionCode(1L) 749 .build(); 750 PackageSetting calling = simulateAddPackage(appsFilter, 751 pkg("com.some.other.package", new Intent("TEST_ACTION")), DUMMY_CALLING_APPID); 752 753 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 754 SYSTEM_USER)); 755 } 756 757 @Test testActsOnTargetOfOverlay()758 public void testActsOnTargetOfOverlay() throws Exception { 759 final String actorName = "overlay://test/actorName"; 760 761 ParsingPackage target = pkg("com.some.package.target") 762 .addOverlayable("overlayableName", actorName); 763 ParsingPackage overlay = pkg("com.some.package.overlay") 764 .setOverlay(true) 765 .setOverlayTarget(target.getPackageName()) 766 .setOverlayTargetName("overlayableName"); 767 ParsingPackage actor = pkg("com.some.package.actor"); 768 769 final AppsFilter appsFilter = new AppsFilter( 770 mStateProvider, 771 mFeatureConfigMock, 772 new String[]{}, 773 false, 774 new OverlayReferenceMapper.Provider() { 775 @Nullable 776 @Override 777 public String getActorPkg(String actorString) { 778 if (actorName.equals(actorString)) { 779 return actor.getPackageName(); 780 } 781 return null; 782 } 783 784 @NonNull 785 @Override 786 public Map<String, Set<String>> getTargetToOverlayables( 787 @NonNull AndroidPackage pkg) { 788 if (overlay.getPackageName().equals(pkg.getPackageName())) { 789 Map<String, Set<String>> map = new ArrayMap<>(); 790 Set<String> set = new ArraySet<>(); 791 set.add(overlay.getOverlayTargetName()); 792 map.put(overlay.getOverlayTarget(), set); 793 return map; 794 } 795 return Collections.emptyMap(); 796 } 797 }, 798 mMockExecutor); 799 simulateAddBasicAndroid(appsFilter); 800 appsFilter.onSystemReady(); 801 802 // Packages must be added in actor -> overlay -> target order so that the implicit 803 // visibility of the actor into the overlay can be tested 804 805 PackageSetting actorSetting = simulateAddPackage(appsFilter, actor, DUMMY_ACTOR_APPID); 806 PackageSetting overlaySetting = 807 simulateAddPackage(appsFilter, overlay, DUMMY_OVERLAY_APPID); 808 809 // Actor can not see overlay (yet) 810 assertTrue(appsFilter.shouldFilterApplication(DUMMY_ACTOR_APPID, actorSetting, 811 overlaySetting, SYSTEM_USER)); 812 813 PackageSetting targetSetting = simulateAddPackage(appsFilter, target, DUMMY_TARGET_APPID); 814 815 // Actor can see both target and overlay 816 assertFalse(appsFilter.shouldFilterApplication(DUMMY_ACTOR_APPID, actorSetting, 817 targetSetting, SYSTEM_USER)); 818 assertFalse(appsFilter.shouldFilterApplication(DUMMY_ACTOR_APPID, actorSetting, 819 overlaySetting, SYSTEM_USER)); 820 821 // But target/overlay can't see each other 822 assertTrue(appsFilter.shouldFilterApplication(DUMMY_TARGET_APPID, targetSetting, 823 overlaySetting, SYSTEM_USER)); 824 assertTrue(appsFilter.shouldFilterApplication(DUMMY_OVERLAY_APPID, overlaySetting, 825 targetSetting, SYSTEM_USER)); 826 827 // And can't see the actor 828 assertTrue(appsFilter.shouldFilterApplication(DUMMY_TARGET_APPID, targetSetting, 829 actorSetting, SYSTEM_USER)); 830 assertTrue(appsFilter.shouldFilterApplication(DUMMY_OVERLAY_APPID, overlaySetting, 831 actorSetting, SYSTEM_USER)); 832 833 appsFilter.removePackage(targetSetting); 834 835 // Actor loses visibility to the overlay via removal of the target 836 assertTrue(appsFilter.shouldFilterApplication(DUMMY_ACTOR_APPID, actorSetting, 837 overlaySetting, SYSTEM_USER)); 838 } 839 840 @Test testActsOnTargetOfOverlayThroughSharedUser()841 public void testActsOnTargetOfOverlayThroughSharedUser() throws Exception { 842 // Debug.waitForDebugger(); 843 844 final String actorName = "overlay://test/actorName"; 845 846 ParsingPackage target = pkg("com.some.package.target") 847 .addOverlayable("overlayableName", actorName); 848 ParsingPackage overlay = pkg("com.some.package.overlay") 849 .setOverlay(true) 850 .setOverlayTarget(target.getPackageName()) 851 .setOverlayTargetName("overlayableName"); 852 ParsingPackage actorOne = pkg("com.some.package.actor.one"); 853 ParsingPackage actorTwo = pkg("com.some.package.actor.two"); 854 855 final AppsFilter appsFilter = new AppsFilter( 856 mStateProvider, 857 mFeatureConfigMock, 858 new String[]{}, 859 false, 860 new OverlayReferenceMapper.Provider() { 861 @Nullable 862 @Override 863 public String getActorPkg(String actorString) { 864 // Only actorOne is mapped as a valid actor 865 if (actorName.equals(actorString)) { 866 return actorOne.getPackageName(); 867 } 868 return null; 869 } 870 871 @NonNull 872 @Override 873 public Map<String, Set<String>> getTargetToOverlayables( 874 @NonNull AndroidPackage pkg) { 875 if (overlay.getPackageName().equals(pkg.getPackageName())) { 876 Map<String, Set<String>> map = new ArrayMap<>(); 877 Set<String> set = new ArraySet<>(); 878 set.add(overlay.getOverlayTargetName()); 879 map.put(overlay.getOverlayTarget(), set); 880 return map; 881 } 882 return Collections.emptyMap(); 883 } 884 }, 885 mMockExecutor); 886 simulateAddBasicAndroid(appsFilter); 887 appsFilter.onSystemReady(); 888 889 PackageSetting targetSetting = simulateAddPackage(appsFilter, target, DUMMY_TARGET_APPID); 890 SharedUserSetting actorSharedSetting = new SharedUserSetting("actorSharedUser", 891 targetSetting.pkgFlags, targetSetting.pkgPrivateFlags); 892 PackageSetting overlaySetting = 893 simulateAddPackage(appsFilter, overlay, DUMMY_OVERLAY_APPID); 894 simulateAddPackage(appsFilter, actorOne, DUMMY_ACTOR_APPID, 895 null /*settingBuilder*/, actorSharedSetting); 896 simulateAddPackage(appsFilter, actorTwo, DUMMY_ACTOR_APPID, 897 null /*settingBuilder*/, actorSharedSetting); 898 899 900 // actorTwo can see both target and overlay 901 assertFalse(appsFilter.shouldFilterApplication(DUMMY_ACTOR_APPID, actorSharedSetting, 902 targetSetting, SYSTEM_USER)); 903 assertFalse(appsFilter.shouldFilterApplication(DUMMY_ACTOR_APPID, actorSharedSetting, 904 overlaySetting, SYSTEM_USER)); 905 } 906 907 @Test testInitiatingApp_DoesntFilter()908 public void testInitiatingApp_DoesntFilter() throws Exception { 909 final AppsFilter appsFilter = 910 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 911 mMockExecutor); 912 simulateAddBasicAndroid(appsFilter); 913 appsFilter.onSystemReady(); 914 915 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 916 DUMMY_TARGET_APPID); 917 PackageSetting calling = simulateAddPackage(appsFilter, pkg("com.some.other.package"), 918 DUMMY_CALLING_APPID, withInstallSource(target.name, null, null, null, false)); 919 920 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 921 SYSTEM_USER)); 922 } 923 924 @Test testUninstalledInitiatingApp_Filters()925 public void testUninstalledInitiatingApp_Filters() throws Exception { 926 final AppsFilter appsFilter = 927 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 928 mMockExecutor); 929 simulateAddBasicAndroid(appsFilter); 930 appsFilter.onSystemReady(); 931 932 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 933 DUMMY_TARGET_APPID); 934 PackageSetting calling = simulateAddPackage(appsFilter, pkg("com.some.other.package"), 935 DUMMY_CALLING_APPID, withInstallSource(target.name, null, null, null, true)); 936 937 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 938 SYSTEM_USER)); 939 } 940 941 @Test testOriginatingApp_Filters()942 public void testOriginatingApp_Filters() throws Exception { 943 final AppsFilter appsFilter = 944 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 945 mMockExecutor); 946 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 947 watcher.register(); 948 simulateAddBasicAndroid(appsFilter); 949 watcher.verifyChangeReported("addBasicAndroid"); 950 appsFilter.onSystemReady(); 951 watcher.verifyChangeReported("systemReady"); 952 953 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 954 DUMMY_TARGET_APPID); 955 watcher.verifyChangeReported("add package"); 956 PackageSetting calling = simulateAddPackage(appsFilter, pkg("com.some.other.package"), 957 DUMMY_CALLING_APPID, withInstallSource(null, target.name, null, null, false)); 958 watcher.verifyChangeReported("add package"); 959 960 assertTrue(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 961 SYSTEM_USER)); 962 watcher.verifyNoChangeReported("shouldFilterAplication"); 963 } 964 965 @Test testInstallingApp_DoesntFilter()966 public void testInstallingApp_DoesntFilter() throws Exception { 967 final AppsFilter appsFilter = 968 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 969 mMockExecutor); 970 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 971 watcher.register(); 972 simulateAddBasicAndroid(appsFilter); 973 watcher.verifyChangeReported("addBasicAndroid"); 974 appsFilter.onSystemReady(); 975 watcher.verifyChangeReported("systemReady"); 976 977 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 978 DUMMY_TARGET_APPID); 979 watcher.verifyChangeReported("add package"); 980 PackageSetting calling = simulateAddPackage(appsFilter, pkg("com.some.other.package"), 981 DUMMY_CALLING_APPID, withInstallSource(null, null, target.name, null, false)); 982 watcher.verifyChangeReported("add package"); 983 984 assertFalse(appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, calling, target, 985 SYSTEM_USER)); 986 watcher.verifyNoChangeReported("shouldFilterAplication"); 987 } 988 989 @Test testInstrumentation_DoesntFilter()990 public void testInstrumentation_DoesntFilter() throws Exception { 991 final AppsFilter appsFilter = 992 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 993 mMockExecutor); 994 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 995 watcher.register(); 996 simulateAddBasicAndroid(appsFilter); 997 watcher.verifyChangeReported("addBasicAndroid"); 998 appsFilter.onSystemReady(); 999 watcher.verifyChangeReported("systemReady"); 1000 1001 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 1002 DUMMY_TARGET_APPID); 1003 watcher.verifyChangeReported("add package"); 1004 PackageSetting instrumentation = simulateAddPackage(appsFilter, 1005 pkgWithInstrumentation("com.some.other.package", "com.some.package"), 1006 DUMMY_CALLING_APPID); 1007 watcher.verifyChangeReported("add package"); 1008 1009 assertFalse( 1010 appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, instrumentation, target, 1011 SYSTEM_USER)); 1012 assertFalse( 1013 appsFilter.shouldFilterApplication(DUMMY_TARGET_APPID, target, instrumentation, 1014 SYSTEM_USER)); 1015 watcher.verifyNoChangeReported("shouldFilterAplication"); 1016 } 1017 1018 @Test testWhoCanSee()1019 public void testWhoCanSee() throws Exception { 1020 final AppsFilter appsFilter = 1021 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 1022 mMockExecutor); 1023 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 1024 watcher.register(); 1025 simulateAddBasicAndroid(appsFilter); 1026 watcher.verifyChangeReported("addBasicAndroid"); 1027 appsFilter.onSystemReady(); 1028 watcher.verifyChangeReported("systemReady"); 1029 1030 final int systemAppId = Process.FIRST_APPLICATION_UID - 1; 1031 final int seesNothingAppId = Process.FIRST_APPLICATION_UID; 1032 final int hasProviderAppId = Process.FIRST_APPLICATION_UID + 1; 1033 final int queriesProviderAppId = Process.FIRST_APPLICATION_UID + 2; 1034 1035 PackageSetting system = simulateAddPackage(appsFilter, pkg("some.system.pkg"), systemAppId); 1036 watcher.verifyChangeReported("add package"); 1037 PackageSetting seesNothing = simulateAddPackage(appsFilter, pkg("com.some.package"), 1038 seesNothingAppId); 1039 watcher.verifyChangeReported("add package"); 1040 PackageSetting hasProvider = simulateAddPackage(appsFilter, 1041 pkgWithProvider("com.some.other.package", "com.some.authority"), hasProviderAppId); 1042 watcher.verifyChangeReported("add package"); 1043 PackageSetting queriesProvider = simulateAddPackage(appsFilter, 1044 pkgQueriesProvider("com.yet.some.other.package", "com.some.authority"), 1045 queriesProviderAppId); 1046 watcher.verifyChangeReported("add package"); 1047 1048 final SparseArray<int[]> systemFilter = 1049 appsFilter.getVisibilityAllowList(system, USER_ARRAY, mExisting); 1050 watcher.verifyNoChangeReported("getVisibility"); 1051 assertThat(toList(systemFilter.get(SYSTEM_USER)), 1052 contains(seesNothingAppId, hasProviderAppId, queriesProviderAppId)); 1053 watcher.verifyNoChangeReported("getVisibility"); 1054 1055 final SparseArray<int[]> seesNothingFilter = 1056 appsFilter.getVisibilityAllowList(seesNothing, USER_ARRAY, mExisting); 1057 watcher.verifyNoChangeReported("getVisibility"); 1058 assertThat(toList(seesNothingFilter.get(SYSTEM_USER)), 1059 contains(seesNothingAppId)); 1060 watcher.verifyNoChangeReported("getVisibility"); 1061 assertThat(toList(seesNothingFilter.get(SECONDARY_USER)), 1062 contains(seesNothingAppId)); 1063 watcher.verifyNoChangeReported("getVisibility"); 1064 1065 final SparseArray<int[]> hasProviderFilter = 1066 appsFilter.getVisibilityAllowList(hasProvider, USER_ARRAY, mExisting); 1067 assertThat(toList(hasProviderFilter.get(SYSTEM_USER)), 1068 contains(hasProviderAppId, queriesProviderAppId)); 1069 1070 SparseArray<int[]> queriesProviderFilter = 1071 appsFilter.getVisibilityAllowList(queriesProvider, USER_ARRAY, mExisting); 1072 watcher.verifyNoChangeReported("getVisibility"); 1073 assertThat(toList(queriesProviderFilter.get(SYSTEM_USER)), 1074 contains(queriesProviderAppId)); 1075 watcher.verifyNoChangeReported("getVisibility"); 1076 1077 // provider read 1078 appsFilter.grantImplicitAccess(hasProviderAppId, queriesProviderAppId); 1079 watcher.verifyChangeReported("grantImplicitAccess"); 1080 1081 // ensure implicit access is included in the filter 1082 queriesProviderFilter = 1083 appsFilter.getVisibilityAllowList(queriesProvider, USER_ARRAY, mExisting); 1084 watcher.verifyNoChangeReported("getVisibility"); 1085 assertThat(toList(queriesProviderFilter.get(SYSTEM_USER)), 1086 contains(hasProviderAppId, queriesProviderAppId)); 1087 watcher.verifyNoChangeReported("getVisibility"); 1088 } 1089 1090 @Test testOnChangeReport()1091 public void testOnChangeReport() throws Exception { 1092 final AppsFilter appsFilter = 1093 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 1094 mMockExecutor); 1095 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange"); 1096 watcher.register(); 1097 simulateAddBasicAndroid(appsFilter); 1098 watcher.verifyChangeReported("addBasic"); 1099 appsFilter.onSystemReady(); 1100 watcher.verifyChangeReported("systemReady"); 1101 1102 final int systemAppId = Process.FIRST_APPLICATION_UID - 1; 1103 final int seesNothingAppId = Process.FIRST_APPLICATION_UID; 1104 final int hasProviderAppId = Process.FIRST_APPLICATION_UID + 1; 1105 final int queriesProviderAppId = Process.FIRST_APPLICATION_UID + 2; 1106 1107 PackageSetting system = simulateAddPackage(appsFilter, pkg("some.system.pkg"), systemAppId); 1108 watcher.verifyChangeReported("addPackage"); 1109 PackageSetting seesNothing = simulateAddPackage(appsFilter, pkg("com.some.package"), 1110 seesNothingAppId); 1111 watcher.verifyChangeReported("addPackage"); 1112 PackageSetting hasProvider = simulateAddPackage(appsFilter, 1113 pkgWithProvider("com.some.other.package", "com.some.authority"), hasProviderAppId); 1114 watcher.verifyChangeReported("addPackage"); 1115 PackageSetting queriesProvider = simulateAddPackage(appsFilter, 1116 pkgQueriesProvider("com.yet.some.other.package", "com.some.authority"), 1117 queriesProviderAppId); 1118 watcher.verifyChangeReported("addPackage"); 1119 1120 final SparseArray<int[]> systemFilter = 1121 appsFilter.getVisibilityAllowList(system, USER_ARRAY, mExisting); 1122 assertThat(toList(systemFilter.get(SYSTEM_USER)), 1123 contains(seesNothingAppId, hasProviderAppId, queriesProviderAppId)); 1124 watcher.verifyNoChangeReported("get"); 1125 1126 final SparseArray<int[]> seesNothingFilter = 1127 appsFilter.getVisibilityAllowList(seesNothing, USER_ARRAY, mExisting); 1128 assertThat(toList(seesNothingFilter.get(SYSTEM_USER)), 1129 contains(seesNothingAppId)); 1130 assertThat(toList(seesNothingFilter.get(SECONDARY_USER)), 1131 contains(seesNothingAppId)); 1132 watcher.verifyNoChangeReported("get"); 1133 1134 final SparseArray<int[]> hasProviderFilter = 1135 appsFilter.getVisibilityAllowList(hasProvider, USER_ARRAY, mExisting); 1136 assertThat(toList(hasProviderFilter.get(SYSTEM_USER)), 1137 contains(hasProviderAppId, queriesProviderAppId)); 1138 watcher.verifyNoChangeReported("get"); 1139 1140 SparseArray<int[]> queriesProviderFilter = 1141 appsFilter.getVisibilityAllowList(queriesProvider, USER_ARRAY, mExisting); 1142 assertThat(toList(queriesProviderFilter.get(SYSTEM_USER)), 1143 contains(queriesProviderAppId)); 1144 watcher.verifyNoChangeReported("get"); 1145 1146 // provider read 1147 appsFilter.grantImplicitAccess(hasProviderAppId, queriesProviderAppId); 1148 watcher.verifyChangeReported("grantImplicitAccess"); 1149 1150 // ensure implicit access is included in the filter 1151 queriesProviderFilter = 1152 appsFilter.getVisibilityAllowList(queriesProvider, USER_ARRAY, mExisting); 1153 assertThat(toList(queriesProviderFilter.get(SYSTEM_USER)), 1154 contains(hasProviderAppId, queriesProviderAppId)); 1155 watcher.verifyNoChangeReported("get"); 1156 1157 // remove a package 1158 appsFilter.removePackage(seesNothing); 1159 watcher.verifyChangeReported("removePackage"); 1160 } 1161 1162 @Test testOnChangeReportedFilter()1163 public void testOnChangeReportedFilter() throws Exception { 1164 final AppsFilter appsFilter = 1165 new AppsFilter(mStateProvider, mFeatureConfigMock, new String[]{}, false, null, 1166 mMockExecutor); 1167 simulateAddBasicAndroid(appsFilter); 1168 appsFilter.onSystemReady(); 1169 final WatchableTester watcher = new WatchableTester(appsFilter, "onChange filter"); 1170 watcher.register(); 1171 1172 PackageSetting target = simulateAddPackage(appsFilter, pkg("com.some.package"), 1173 DUMMY_TARGET_APPID); 1174 PackageSetting instrumentation = simulateAddPackage(appsFilter, 1175 pkgWithInstrumentation("com.some.other.package", "com.some.package"), 1176 DUMMY_CALLING_APPID); 1177 watcher.verifyChangeReported("addPackage"); 1178 1179 assertFalse( 1180 appsFilter.shouldFilterApplication(DUMMY_CALLING_APPID, instrumentation, target, 1181 SYSTEM_USER)); 1182 assertFalse( 1183 appsFilter.shouldFilterApplication(DUMMY_TARGET_APPID, target, instrumentation, 1184 SYSTEM_USER)); 1185 watcher.verifyNoChangeReported("shouldFilterApplication"); 1186 } 1187 toList(int[] array)1188 private List<Integer> toList(int[] array) { 1189 ArrayList<Integer> ret = new ArrayList<>(array.length); 1190 for (int i = 0; i < array.length; i++) { 1191 ret.add(i, array[i]); 1192 } 1193 return ret; 1194 } 1195 1196 private interface WithSettingBuilder { withBuilder(PackageSettingBuilder builder)1197 PackageSettingBuilder withBuilder(PackageSettingBuilder builder); 1198 } 1199 simulateAddBasicAndroid(AppsFilter appsFilter)1200 private void simulateAddBasicAndroid(AppsFilter appsFilter) throws Exception { 1201 final Signature frameworkSignature = Mockito.mock(Signature.class); 1202 final PackageParser.SigningDetails frameworkSigningDetails = 1203 new PackageParser.SigningDetails(new Signature[]{frameworkSignature}, 1); 1204 final ParsingPackage android = pkg("android"); 1205 simulateAddPackage(appsFilter, android, 1000, 1206 b -> b.setSigningDetails(frameworkSigningDetails)); 1207 } 1208 simulateAddPackage(AppsFilter filter, ParsingPackage newPkgBuilder, int appId)1209 private PackageSetting simulateAddPackage(AppsFilter filter, 1210 ParsingPackage newPkgBuilder, int appId) { 1211 return simulateAddPackage(filter, newPkgBuilder, appId, null /*settingBuilder*/); 1212 } 1213 simulateAddPackage(AppsFilter filter, ParsingPackage newPkgBuilder, int appId, @Nullable WithSettingBuilder action)1214 private PackageSetting simulateAddPackage(AppsFilter filter, 1215 ParsingPackage newPkgBuilder, int appId, @Nullable WithSettingBuilder action) { 1216 return simulateAddPackage(filter, newPkgBuilder, appId, action, null /*sharedUserSetting*/); 1217 } 1218 simulateAddPackage(AppsFilter filter, ParsingPackage newPkgBuilder, int appId, @Nullable WithSettingBuilder action, @Nullable SharedUserSetting sharedUserSetting)1219 private PackageSetting simulateAddPackage(AppsFilter filter, 1220 ParsingPackage newPkgBuilder, int appId, @Nullable WithSettingBuilder action, 1221 @Nullable SharedUserSetting sharedUserSetting) { 1222 AndroidPackage newPkg = ((ParsedPackage) newPkgBuilder.hideAsParsed()).hideAsFinal(); 1223 1224 final PackageSettingBuilder settingBuilder = new PackageSettingBuilder() 1225 .setPackage(newPkg) 1226 .setAppId(appId) 1227 .setName(newPkg.getPackageName()) 1228 .setCodePath("/") 1229 .setPVersionCode(1L); 1230 final PackageSetting setting = 1231 (action == null ? settingBuilder : action.withBuilder(settingBuilder)).build(); 1232 mExisting.put(newPkg.getPackageName(), setting); 1233 if (sharedUserSetting != null) { 1234 sharedUserSetting.addPackage(setting); 1235 setting.sharedUser = sharedUserSetting; 1236 } 1237 filter.addPackage(setting); 1238 return setting; 1239 } 1240 withInstallSource(String initiatingPackageName, String originatingPackageName, String installerPackageName, String installerAttributionTag, boolean isInitiatingPackageUninstalled)1241 private WithSettingBuilder withInstallSource(String initiatingPackageName, 1242 String originatingPackageName, String installerPackageName, 1243 String installerAttributionTag, boolean isInitiatingPackageUninstalled) { 1244 final InstallSource installSource = InstallSource.create(initiatingPackageName, 1245 originatingPackageName, installerPackageName, installerAttributionTag, 1246 /* isOrphaned= */ false, isInitiatingPackageUninstalled); 1247 return setting -> setting.setInstallSource(installSource); 1248 } 1249 } 1250