1 /*
2  * Copyright (C) 2015 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.permission;
18 
19 import static android.os.Process.FIRST_APPLICATION_UID;
20 
21 import android.Manifest;
22 import android.annotation.NonNull;
23 import android.annotation.Nullable;
24 import android.app.ActivityManager;
25 import android.app.DownloadManager;
26 import android.app.SearchManager;
27 import android.app.admin.DevicePolicyManager;
28 import android.companion.CompanionDeviceManager;
29 import android.content.Context;
30 import android.content.Intent;
31 import android.content.pm.ApplicationInfo;
32 import android.content.pm.PackageInfo;
33 import android.content.pm.PackageManager;
34 import android.content.pm.PackageManager.NameNotFoundException;
35 import android.content.pm.PackageManagerInternal;
36 import android.content.pm.PermissionInfo;
37 import android.content.pm.ProviderInfo;
38 import android.content.pm.ResolveInfo;
39 import android.media.RingtoneManager;
40 import android.media.midi.MidiManager;
41 import android.net.Uri;
42 import android.os.Build;
43 import android.os.Environment;
44 import android.os.Handler;
45 import android.os.HandlerThread;
46 import android.os.Message;
47 import android.os.Process;
48 import android.os.UserHandle;
49 import android.os.storage.StorageManager;
50 import android.permission.PermissionManager;
51 import android.print.PrintManager;
52 import android.provider.CalendarContract;
53 import android.provider.ContactsContract;
54 import android.provider.MediaStore;
55 import android.provider.Telephony.Sms.Intents;
56 import android.security.Credentials;
57 import android.speech.RecognitionService;
58 import android.telephony.TelephonyManager;
59 import android.text.TextUtils;
60 import android.util.ArrayMap;
61 import android.util.ArraySet;
62 import android.util.Log;
63 import android.util.Slog;
64 import android.util.SparseArray;
65 import android.util.TypedXmlPullParser;
66 import android.util.Xml;
67 
68 import com.android.internal.R;
69 import com.android.internal.util.ArrayUtils;
70 import com.android.internal.util.XmlUtils;
71 import com.android.server.LocalServices;
72 import com.android.server.ServiceThread;
73 import com.android.server.pm.permission.LegacyPermissionManagerInternal.PackagesProvider;
74 import com.android.server.pm.permission.LegacyPermissionManagerInternal.SyncAdapterPackagesProvider;
75 
76 import org.xmlpull.v1.XmlPullParser;
77 import org.xmlpull.v1.XmlPullParserException;
78 
79 import java.io.File;
80 import java.io.FileInputStream;
81 import java.io.IOException;
82 import java.io.InputStream;
83 import java.util.ArrayList;
84 import java.util.Arrays;
85 import java.util.Collections;
86 import java.util.List;
87 import java.util.Map;
88 import java.util.Set;
89 
90 /**
91  * This class is the policy for granting runtime permissions to
92  * platform components and default handlers in the system such
93  * that the device is usable out-of-the-box. For example, the
94  * shell UID is a part of the system and the Phone app should
95  * have phone related permission by default.
96  * <p>
97  * NOTE: This class is at the wrong abstraction level. It is a part of the package manager
98  * service but knows about lots of higher level subsystems. The correct way to do this is
99  * to have an interface defined in the package manager but have the impl next to other
100  * policy stuff like PhoneWindowManager
101  */
102 final class DefaultPermissionGrantPolicy {
103     private static final String TAG = "DefaultPermGrantPolicy"; // must be <= 23 chars
104     private static final boolean DEBUG = false;
105 
106     @PackageManager.ResolveInfoFlags
107     private static final int DEFAULT_INTENT_QUERY_FLAGS =
108             PackageManager.MATCH_DIRECT_BOOT_AWARE | PackageManager.MATCH_DIRECT_BOOT_UNAWARE
109                     | PackageManager.MATCH_UNINSTALLED_PACKAGES;
110 
111     @PackageManager.PackageInfoFlags
112     private static final int DEFAULT_PACKAGE_INFO_QUERY_FLAGS =
113             PackageManager.MATCH_UNINSTALLED_PACKAGES
114                     | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
115                     | PackageManager.MATCH_HIDDEN_UNTIL_INSTALLED_COMPONENTS
116                     | PackageManager.GET_PERMISSIONS;
117 
118     private static final String AUDIO_MIME_TYPE = "audio/mpeg";
119 
120     private static final String TAG_EXCEPTIONS = "exceptions";
121     private static final String TAG_EXCEPTION = "exception";
122     private static final String TAG_PERMISSION = "permission";
123     private static final String ATTR_PACKAGE = "package";
124     private static final String ATTR_NAME = "name";
125     private static final String ATTR_FIXED = "fixed";
126     private static final String ATTR_WHITELISTED = "whitelisted";
127 
128     private static final Set<String> PHONE_PERMISSIONS = new ArraySet<>();
129 
130 
131     static {
132         PHONE_PERMISSIONS.add(Manifest.permission.READ_PHONE_STATE);
133         PHONE_PERMISSIONS.add(Manifest.permission.CALL_PHONE);
134         PHONE_PERMISSIONS.add(Manifest.permission.READ_CALL_LOG);
135         PHONE_PERMISSIONS.add(Manifest.permission.WRITE_CALL_LOG);
136         PHONE_PERMISSIONS.add(Manifest.permission.ADD_VOICEMAIL);
137         PHONE_PERMISSIONS.add(Manifest.permission.USE_SIP);
138         PHONE_PERMISSIONS.add(Manifest.permission.PROCESS_OUTGOING_CALLS);
139     }
140 
141     private static final Set<String> CONTACTS_PERMISSIONS = new ArraySet<>();
142     static {
143         CONTACTS_PERMISSIONS.add(Manifest.permission.READ_CONTACTS);
144         CONTACTS_PERMISSIONS.add(Manifest.permission.WRITE_CONTACTS);
145         CONTACTS_PERMISSIONS.add(Manifest.permission.GET_ACCOUNTS);
146     }
147 
148     private static final Set<String> ALWAYS_LOCATION_PERMISSIONS = new ArraySet<>();
149     static {
150         ALWAYS_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
151         ALWAYS_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
152         ALWAYS_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_BACKGROUND_LOCATION);
153     }
154 
155     private static final Set<String> FOREGROUND_LOCATION_PERMISSIONS = new ArraySet<>();
156     static {
157         FOREGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
158         FOREGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
159     }
160 
161     private static final Set<String> COARSE_BACKGROUND_LOCATION_PERMISSIONS = new ArraySet<>();
162     static {
163         COARSE_BACKGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
164         COARSE_BACKGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_BACKGROUND_LOCATION);
165     }
166 
167     private static final Set<String> ACTIVITY_RECOGNITION_PERMISSIONS = new ArraySet<>();
168     static {
169         ACTIVITY_RECOGNITION_PERMISSIONS.add(Manifest.permission.ACTIVITY_RECOGNITION);
170     }
171 
172     private static final Set<String> CALENDAR_PERMISSIONS = new ArraySet<>();
173     static {
174         CALENDAR_PERMISSIONS.add(Manifest.permission.READ_CALENDAR);
175         CALENDAR_PERMISSIONS.add(Manifest.permission.WRITE_CALENDAR);
176     }
177 
178     private static final Set<String> SMS_PERMISSIONS = new ArraySet<>();
179     static {
180         SMS_PERMISSIONS.add(Manifest.permission.SEND_SMS);
181         SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_SMS);
182         SMS_PERMISSIONS.add(Manifest.permission.READ_SMS);
183         SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_WAP_PUSH);
184         SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_MMS);
185         SMS_PERMISSIONS.add(Manifest.permission.READ_CELL_BROADCASTS);
186     }
187 
188     private static final Set<String> MICROPHONE_PERMISSIONS = new ArraySet<>();
189     static {
190         MICROPHONE_PERMISSIONS.add(Manifest.permission.RECORD_AUDIO);
191     }
192 
193     private static final Set<String> CAMERA_PERMISSIONS = new ArraySet<>();
194     static {
195         CAMERA_PERMISSIONS.add(Manifest.permission.CAMERA);
196     }
197 
198     private static final Set<String> SENSORS_PERMISSIONS = new ArraySet<>();
199     static {
200         SENSORS_PERMISSIONS.add(Manifest.permission.BODY_SENSORS);
201     }
202 
203     private static final Set<String> STORAGE_PERMISSIONS = new ArraySet<>();
204     static {
205         STORAGE_PERMISSIONS.add(Manifest.permission.READ_EXTERNAL_STORAGE);
206         STORAGE_PERMISSIONS.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
207         STORAGE_PERMISSIONS.add(Manifest.permission.ACCESS_MEDIA_LOCATION);
208     }
209 
210     private static final Set<String> NEARBY_DEVICES_PERMISSIONS = new ArraySet<>();
211     static {
212         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.BLUETOOTH_ADVERTISE);
213         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.BLUETOOTH_CONNECT);
214         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.BLUETOOTH_SCAN);
215         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.UWB_RANGING);
216     }
217 
218     private static final int MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS = 1;
219 
220     private static final String ACTION_TRACK = "com.android.fitness.TRACK";
221 
222     private final Handler mHandler;
223 
224     private PackagesProvider mLocationPackagesProvider;
225     private PackagesProvider mLocationExtraPackagesProvider;
226     private PackagesProvider mVoiceInteractionPackagesProvider;
227     private PackagesProvider mSmsAppPackagesProvider;
228     private PackagesProvider mDialerAppPackagesProvider;
229     private PackagesProvider mSimCallManagerPackagesProvider;
230     private PackagesProvider mUseOpenWifiAppPackagesProvider;
231     private SyncAdapterPackagesProvider mSyncAdapterPackagesProvider;
232 
233     private ArrayMap<String, List<DefaultPermissionGrant>> mGrantExceptions;
234     private final Context mContext;
235     private final Object mLock = new Object();
236     private final PackageManagerInternal mServiceInternal;
237 
238     /** Directly interact with the PackageManger */
239     private final PackageManagerWrapper NO_PM_CACHE = new PackageManagerWrapper() {
240         @Override
241         public int getPermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
242                 @NonNull UserHandle user) {
243             return mContext.getPackageManager().getPermissionFlags(permission, pkg.packageName,
244                     user);
245         }
246 
247         @Override
248         public void updatePermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
249                 int flagMask, int flagValues, @NonNull UserHandle user) {
250             mContext.getPackageManager().updatePermissionFlags(permission, pkg.packageName,
251                     flagMask, flagValues, user);
252         }
253 
254         @Override
255         public void grantPermission(@NonNull String permission, @NonNull PackageInfo pkg,
256                 @NonNull UserHandle user) {
257             mContext.getPackageManager().grantRuntimePermission(pkg.packageName, permission,
258                     user);
259         }
260 
261         @Override
262         public void revokePermission(@NonNull String permission, @NonNull PackageInfo pkg,
263                 @NonNull UserHandle user) {
264             mContext.getPackageManager().revokeRuntimePermission(pkg.packageName, permission,
265                     user);
266         }
267 
268         @Override
269         public boolean isGranted(@NonNull String permission, @NonNull PackageInfo pkg,
270                 @NonNull UserHandle user) {
271             return mContext.createContextAsUser(user, 0).getPackageManager().checkPermission(
272                     permission, pkg.packageName) == PackageManager.PERMISSION_GRANTED;
273         }
274 
275         @Override
276         public @Nullable PermissionInfo getPermissionInfo(@NonNull String permissionName) {
277             if (permissionName == null) {
278                 return null;
279             }
280 
281             try {
282                 return mContext.getPackageManager().getPermissionInfo(permissionName, 0);
283             } catch (NameNotFoundException e) {
284                 Slog.w(TAG, "Permission not found: " + permissionName);
285                 return null;
286             }
287         }
288 
289         @Override
290         public @Nullable PackageInfo getPackageInfo(@NonNull String pkg) {
291             if (pkg == null) {
292                 return null;
293             }
294 
295             try {
296                 return mContext.getPackageManager().getPackageInfo(pkg,
297                         DEFAULT_PACKAGE_INFO_QUERY_FLAGS);
298             } catch (NameNotFoundException e) {
299                 Slog.e(TAG, "Package not found: " + pkg);
300                 return null;
301             }
302         }
303     };
304 
DefaultPermissionGrantPolicy(@onNull Context context)305     DefaultPermissionGrantPolicy(@NonNull Context context) {
306         mContext = context;
307         HandlerThread handlerThread = new ServiceThread(TAG,
308                 Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
309         handlerThread.start();
310         mHandler = new Handler(handlerThread.getLooper()) {
311             @Override
312             public void handleMessage(Message msg) {
313                 if (msg.what == MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS) {
314                     synchronized (mLock) {
315                         if (mGrantExceptions == null) {
316                             mGrantExceptions = readDefaultPermissionExceptionsLocked(NO_PM_CACHE);
317                         }
318                     }
319                 }
320             }
321         };
322         mServiceInternal = LocalServices.getService(PackageManagerInternal.class);
323     }
324 
setLocationPackagesProvider(PackagesProvider provider)325     public void setLocationPackagesProvider(PackagesProvider provider) {
326         synchronized (mLock) {
327             mLocationPackagesProvider = provider;
328         }
329     }
330 
331     /** Sets the provider for loction extra packages. */
setLocationExtraPackagesProvider(PackagesProvider provider)332     public void setLocationExtraPackagesProvider(PackagesProvider provider) {
333         synchronized (mLock) {
334             mLocationExtraPackagesProvider = provider;
335         }
336     }
337 
setVoiceInteractionPackagesProvider(PackagesProvider provider)338     public void setVoiceInteractionPackagesProvider(PackagesProvider provider) {
339         synchronized (mLock) {
340             mVoiceInteractionPackagesProvider = provider;
341         }
342     }
343 
setSmsAppPackagesProvider(PackagesProvider provider)344     public void setSmsAppPackagesProvider(PackagesProvider provider) {
345         synchronized (mLock) {
346             mSmsAppPackagesProvider = provider;
347         }
348     }
349 
setDialerAppPackagesProvider(PackagesProvider provider)350     public void setDialerAppPackagesProvider(PackagesProvider provider) {
351         synchronized (mLock) {
352             mDialerAppPackagesProvider = provider;
353         }
354     }
355 
setSimCallManagerPackagesProvider(PackagesProvider provider)356     public void setSimCallManagerPackagesProvider(PackagesProvider provider) {
357         synchronized (mLock) {
358             mSimCallManagerPackagesProvider = provider;
359         }
360     }
361 
setUseOpenWifiAppPackagesProvider(PackagesProvider provider)362     public void setUseOpenWifiAppPackagesProvider(PackagesProvider provider) {
363         synchronized (mLock) {
364             mUseOpenWifiAppPackagesProvider = provider;
365         }
366     }
367 
setSyncAdapterPackagesProvider(SyncAdapterPackagesProvider provider)368     public void setSyncAdapterPackagesProvider(SyncAdapterPackagesProvider provider) {
369         synchronized (mLock) {
370             mSyncAdapterPackagesProvider = provider;
371         }
372     }
373 
grantDefaultPermissions(int userId)374     public void grantDefaultPermissions(int userId) {
375         DelayingPackageManagerCache pm = new DelayingPackageManagerCache();
376 
377         grantPermissionsToSysComponentsAndPrivApps(pm, userId);
378         grantDefaultSystemHandlerPermissions(pm, userId);
379         grantDefaultPermissionExceptions(pm, userId);
380 
381         // Apply delayed state
382         pm.apply();
383     }
384 
grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm, int userId, PackageInfo pkg)385     private void grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm,
386             int userId, PackageInfo pkg) {
387         Set<String> permissions = new ArraySet<>();
388         for (String permission : pkg.requestedPermissions) {
389             final PermissionInfo perm = pm.getPermissionInfo(permission);
390             if (perm == null) {
391                 continue;
392             }
393             if (perm.isRuntime()) {
394                 permissions.add(permission);
395             }
396         }
397         if (!permissions.isEmpty()) {
398             grantRuntimePermissions(pm, pkg, permissions, true /*systemFixed*/, userId);
399         }
400     }
401 
scheduleReadDefaultPermissionExceptions()402     public void scheduleReadDefaultPermissionExceptions() {
403         mHandler.sendEmptyMessage(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);
404     }
405 
grantPermissionsToSysComponentsAndPrivApps(DelayingPackageManagerCache pm, int userId)406     private void grantPermissionsToSysComponentsAndPrivApps(DelayingPackageManagerCache pm,
407             int userId) {
408         Log.i(TAG, "Granting permissions to platform components for user " + userId);
409         List<PackageInfo> packages = mContext.getPackageManager().getInstalledPackagesAsUser(
410                 DEFAULT_PACKAGE_INFO_QUERY_FLAGS, UserHandle.USER_SYSTEM);
411         for (PackageInfo pkg : packages) {
412             if (pkg == null) {
413                 continue;
414             }
415 
416             // Package info is already loaded, cache it
417             pm.addPackageInfo(pkg.packageName, pkg);
418 
419             if (!pm.isSysComponentOrPersistentPlatformSignedPrivApp(pkg)
420                     || !doesPackageSupportRuntimePermissions(pkg)
421                     || ArrayUtils.isEmpty(pkg.requestedPermissions)) {
422                 continue;
423             }
424             grantRuntimePermissionsForSystemPackage(pm, userId, pkg);
425         }
426 
427         // Re-grant READ_PHONE_STATE as non-fixed to all system apps that have
428         // READ_PRIVILEGED_PHONE_STATE and READ_PHONE_STATE granted -- this is to undo the fixed
429         // grant from R.
430         for (PackageInfo pkg : packages) {
431             if (pkg == null
432                     || !doesPackageSupportRuntimePermissions(pkg)
433                     || ArrayUtils.isEmpty(pkg.requestedPermissions)
434                     || !pm.isGranted(Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
435                             pkg, UserHandle.of(userId))
436                     || !pm.isGranted(Manifest.permission.READ_PHONE_STATE, pkg,
437                             UserHandle.of(userId))
438                     || pm.isSysComponentOrPersistentPlatformSignedPrivApp(pkg)) {
439                 continue;
440             }
441 
442             pm.updatePermissionFlags(Manifest.permission.READ_PHONE_STATE, pkg,
443                     PackageManager.FLAG_PERMISSION_SYSTEM_FIXED,
444                     0,
445                     UserHandle.of(userId));
446         }
447 
448     }
449 
450     @SafeVarargs
grantIgnoringSystemPackage(PackageManagerWrapper pm, String packageName, int userId, Set<String>... permissionGroups)451     private final void grantIgnoringSystemPackage(PackageManagerWrapper pm, String packageName,
452             int userId, Set<String>... permissionGroups) {
453         grantPermissionsToPackage(pm, packageName, userId, true /* ignoreSystemPackage */,
454                 true /*whitelistRestrictedPermissions*/, permissionGroups);
455     }
456 
457     @SafeVarargs
grantSystemFixedPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName, int userId, Set<String>... permissionGroups)458     private final void grantSystemFixedPermissionsToSystemPackage(PackageManagerWrapper pm,
459             String packageName, int userId, Set<String>... permissionGroups) {
460         grantPermissionsToSystemPackage(pm, packageName, userId, true /* systemFixed */,
461                 permissionGroups);
462     }
463 
464     @SafeVarargs
grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName, int userId, Set<String>... permissionGroups)465     private final void grantPermissionsToSystemPackage(PackageManagerWrapper pm,
466             String packageName, int userId, Set<String>... permissionGroups) {
467         grantPermissionsToSystemPackage(pm, packageName, userId, false /* systemFixed */,
468                 permissionGroups);
469     }
470 
471     @SafeVarargs
grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName, int userId, boolean systemFixed, Set<String>... permissionGroups)472     private final void grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName,
473             int userId, boolean systemFixed, Set<String>... permissionGroups) {
474         if (!pm.isSystemPackage(packageName)) {
475             return;
476         }
477         grantPermissionsToPackage(pm, pm.getSystemPackageInfo(packageName),
478                 userId, systemFixed, false /* ignoreSystemPackage */,
479                 true /*whitelistRestrictedPermissions*/, permissionGroups);
480     }
481 
482     @SafeVarargs
grantPermissionsToPackage(PackageManagerWrapper pm, String packageName, int userId, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions, Set<String>... permissionGroups)483     private final void grantPermissionsToPackage(PackageManagerWrapper pm, String packageName,
484             int userId, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions,
485             Set<String>... permissionGroups) {
486         grantPermissionsToPackage(pm, pm.getPackageInfo(packageName),
487                 userId, false /* systemFixed */, ignoreSystemPackage,
488                 whitelistRestrictedPermissions, permissionGroups);
489     }
490 
491     @SafeVarargs
grantPermissionsToPackage(PackageManagerWrapper pm, PackageInfo packageInfo, int userId, boolean systemFixed, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions, Set<String>... permissionGroups)492     private final void grantPermissionsToPackage(PackageManagerWrapper pm, PackageInfo packageInfo,
493             int userId, boolean systemFixed, boolean ignoreSystemPackage,
494             boolean whitelistRestrictedPermissions, Set<String>... permissionGroups) {
495         if (packageInfo == null) {
496             return;
497         }
498         if (doesPackageSupportRuntimePermissions(packageInfo)) {
499             for (Set<String> permissionGroup : permissionGroups) {
500                 grantRuntimePermissions(pm, packageInfo, permissionGroup, systemFixed,
501                         ignoreSystemPackage, whitelistRestrictedPermissions, userId);
502             }
503         }
504     }
505 
grantDefaultSystemHandlerPermissions(PackageManagerWrapper pm, int userId)506     private void grantDefaultSystemHandlerPermissions(PackageManagerWrapper pm, int userId) {
507         Log.i(TAG, "Granting permissions to default platform handlers for user " + userId);
508 
509         final PackagesProvider locationPackagesProvider;
510         final PackagesProvider locationExtraPackagesProvider;
511         final PackagesProvider voiceInteractionPackagesProvider;
512         final PackagesProvider smsAppPackagesProvider;
513         final PackagesProvider dialerAppPackagesProvider;
514         final PackagesProvider simCallManagerPackagesProvider;
515         final PackagesProvider useOpenWifiAppPackagesProvider;
516         final SyncAdapterPackagesProvider syncAdapterPackagesProvider;
517 
518         synchronized (mLock) {
519             locationPackagesProvider = mLocationPackagesProvider;
520             locationExtraPackagesProvider = mLocationExtraPackagesProvider;
521             voiceInteractionPackagesProvider = mVoiceInteractionPackagesProvider;
522             smsAppPackagesProvider = mSmsAppPackagesProvider;
523             dialerAppPackagesProvider = mDialerAppPackagesProvider;
524             simCallManagerPackagesProvider = mSimCallManagerPackagesProvider;
525             useOpenWifiAppPackagesProvider = mUseOpenWifiAppPackagesProvider;
526             syncAdapterPackagesProvider = mSyncAdapterPackagesProvider;
527         }
528 
529         String[] voiceInteractPackageNames = (voiceInteractionPackagesProvider != null)
530                 ? voiceInteractionPackagesProvider.getPackages(userId) : null;
531         String[] locationPackageNames = (locationPackagesProvider != null)
532                 ? locationPackagesProvider.getPackages(userId) : null;
533         String[] locationExtraPackageNames = (locationExtraPackagesProvider != null)
534                 ? locationExtraPackagesProvider.getPackages(userId) : null;
535         String[] smsAppPackageNames = (smsAppPackagesProvider != null)
536                 ? smsAppPackagesProvider.getPackages(userId) : null;
537         String[] dialerAppPackageNames = (dialerAppPackagesProvider != null)
538                 ? dialerAppPackagesProvider.getPackages(userId) : null;
539         String[] simCallManagerPackageNames = (simCallManagerPackagesProvider != null)
540                 ? simCallManagerPackagesProvider.getPackages(userId) : null;
541         String[] useOpenWifiAppPackageNames = (useOpenWifiAppPackagesProvider != null)
542                 ? useOpenWifiAppPackagesProvider.getPackages(userId) : null;
543         String[] contactsSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
544                 syncAdapterPackagesProvider.getPackages(ContactsContract.AUTHORITY, userId) : null;
545         String[] calendarSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
546                 syncAdapterPackagesProvider.getPackages(CalendarContract.AUTHORITY, userId) : null;
547 
548         // Installer
549         grantSystemFixedPermissionsToSystemPackage(pm,
550                 ArrayUtils.firstOrNull(getKnownPackages(
551                         PackageManagerInternal.PACKAGE_INSTALLER, userId)),
552                 userId, STORAGE_PERMISSIONS);
553 
554         // Verifier
555         final String verifier = ArrayUtils.firstOrNull(getKnownPackages(
556                 PackageManagerInternal.PACKAGE_VERIFIER, userId));
557         grantSystemFixedPermissionsToSystemPackage(pm, verifier, userId, STORAGE_PERMISSIONS);
558         grantPermissionsToSystemPackage(pm, verifier, userId, PHONE_PERMISSIONS, SMS_PERMISSIONS);
559 
560         // SetupWizard
561         final String setupWizardPackage = ArrayUtils.firstOrNull(getKnownPackages(
562                 PackageManagerInternal.PACKAGE_SETUP_WIZARD, userId));
563         grantPermissionsToSystemPackage(pm, setupWizardPackage, userId, PHONE_PERMISSIONS,
564                 CONTACTS_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS, CAMERA_PERMISSIONS);
565         if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, 0)) {
566             grantPermissionsToSystemPackage(
567                     pm, setupWizardPackage, userId, NEARBY_DEVICES_PERMISSIONS);
568         }
569 
570         // Camera
571         grantPermissionsToSystemPackage(pm,
572                 getDefaultSystemHandlerActivityPackage(pm, MediaStore.ACTION_IMAGE_CAPTURE, userId),
573                 userId, CAMERA_PERMISSIONS, MICROPHONE_PERMISSIONS, STORAGE_PERMISSIONS);
574 
575         // Sound recorder
576         grantPermissionsToSystemPackage(pm,
577                 getDefaultSystemHandlerActivityPackage(pm,
578                         MediaStore.Audio.Media.RECORD_SOUND_ACTION, userId),
579                 userId, MICROPHONE_PERMISSIONS);
580 
581         // Media provider
582         grantSystemFixedPermissionsToSystemPackage(pm,
583                 getDefaultProviderAuthorityPackage(MediaStore.AUTHORITY, userId), userId,
584                 STORAGE_PERMISSIONS);
585 
586         // Downloads provider
587         grantSystemFixedPermissionsToSystemPackage(pm,
588                 getDefaultProviderAuthorityPackage("downloads", userId), userId,
589                 STORAGE_PERMISSIONS);
590 
591         // Downloads UI
592         grantSystemFixedPermissionsToSystemPackage(pm,
593                 getDefaultSystemHandlerActivityPackage(pm,
594                         DownloadManager.ACTION_VIEW_DOWNLOADS, userId),
595                 userId, STORAGE_PERMISSIONS);
596 
597         // Storage provider
598         grantSystemFixedPermissionsToSystemPackage(pm,
599                 getDefaultProviderAuthorityPackage("com.android.externalstorage.documents", userId),
600                 userId, STORAGE_PERMISSIONS);
601 
602         // CertInstaller
603         grantSystemFixedPermissionsToSystemPackage(pm,
604                 getDefaultSystemHandlerActivityPackage(pm, Credentials.INSTALL_ACTION, userId),
605                 userId, STORAGE_PERMISSIONS);
606 
607         // Dialer
608         if (dialerAppPackageNames == null) {
609             String dialerPackage =
610                     getDefaultSystemHandlerActivityPackage(pm, Intent.ACTION_DIAL, userId);
611             grantDefaultPermissionsToDefaultSystemDialerApp(pm, dialerPackage, userId);
612         } else {
613             for (String dialerAppPackageName : dialerAppPackageNames) {
614                 grantDefaultPermissionsToDefaultSystemDialerApp(pm, dialerAppPackageName, userId);
615             }
616         }
617 
618         // Sim call manager
619         if (simCallManagerPackageNames != null) {
620             for (String simCallManagerPackageName : simCallManagerPackageNames) {
621                 grantDefaultPermissionsToDefaultSystemSimCallManager(pm,
622                         simCallManagerPackageName, userId);
623             }
624         }
625 
626         // Use Open Wifi
627         if (useOpenWifiAppPackageNames != null) {
628             for (String useOpenWifiPackageName : useOpenWifiAppPackageNames) {
629                 grantDefaultPermissionsToDefaultSystemUseOpenWifiApp(pm,
630                         useOpenWifiPackageName, userId);
631             }
632         }
633 
634         // SMS
635         if (smsAppPackageNames == null) {
636             String smsPackage = getDefaultSystemHandlerActivityPackageForCategory(pm,
637                     Intent.CATEGORY_APP_MESSAGING, userId);
638             grantDefaultPermissionsToDefaultSystemSmsApp(pm, smsPackage, userId);
639         } else {
640             for (String smsPackage : smsAppPackageNames) {
641                 grantDefaultPermissionsToDefaultSystemSmsApp(pm, smsPackage, userId);
642             }
643         }
644 
645         // Cell Broadcast Receiver
646         grantSystemFixedPermissionsToSystemPackage(pm,
647                 getDefaultSystemHandlerActivityPackage(pm, Intents.SMS_CB_RECEIVED_ACTION, userId),
648                 userId, SMS_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS);
649 
650         // Carrier Provisioning Service
651         grantPermissionsToSystemPackage(pm,
652                 getDefaultSystemHandlerServicePackage(pm, Intents.SMS_CARRIER_PROVISION_ACTION,
653                         userId),
654                 userId, SMS_PERMISSIONS);
655 
656         // Calendar
657         grantPermissionsToSystemPackage(pm,
658                 getDefaultSystemHandlerActivityPackageForCategory(pm,
659                         Intent.CATEGORY_APP_CALENDAR, userId),
660                 userId, CALENDAR_PERMISSIONS, CONTACTS_PERMISSIONS);
661 
662         // Calendar provider
663         String calendarProvider =
664                 getDefaultProviderAuthorityPackage(CalendarContract.AUTHORITY, userId);
665         grantPermissionsToSystemPackage(pm, calendarProvider, userId,
666                 CONTACTS_PERMISSIONS, STORAGE_PERMISSIONS);
667         grantSystemFixedPermissionsToSystemPackage(pm, calendarProvider, userId,
668                 CALENDAR_PERMISSIONS);
669 
670         // Calendar provider sync adapters
671         if (calendarSyncAdapterPackages != null) {
672             grantPermissionToEachSystemPackage(pm,
673                     getHeadlessSyncAdapterPackages(pm, calendarSyncAdapterPackages, userId),
674                     userId, CALENDAR_PERMISSIONS);
675         }
676 
677         // Contacts
678         grantPermissionsToSystemPackage(pm,
679                 getDefaultSystemHandlerActivityPackageForCategory(pm,
680                         Intent.CATEGORY_APP_CONTACTS, userId),
681                 userId, CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
682 
683         // Contacts provider sync adapters
684         if (contactsSyncAdapterPackages != null) {
685             grantPermissionToEachSystemPackage(pm,
686                     getHeadlessSyncAdapterPackages(pm, contactsSyncAdapterPackages, userId),
687                     userId, CONTACTS_PERMISSIONS);
688         }
689 
690         // Contacts provider
691         String contactsProviderPackage =
692                 getDefaultProviderAuthorityPackage(ContactsContract.AUTHORITY, userId);
693         grantSystemFixedPermissionsToSystemPackage(pm, contactsProviderPackage, userId,
694                 CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
695         grantPermissionsToSystemPackage(pm, contactsProviderPackage, userId, STORAGE_PERMISSIONS);
696 
697         // Device provisioning
698         grantPermissionsToSystemPackage(pm,
699                 getDefaultSystemHandlerActivityPackage(pm,
700                         DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE, userId),
701                 userId, CONTACTS_PERMISSIONS);
702 
703         // Email
704         grantPermissionsToSystemPackage(pm,
705                 getDefaultSystemHandlerActivityPackageForCategory(pm,
706                         Intent.CATEGORY_APP_EMAIL, userId),
707                 userId, CONTACTS_PERMISSIONS, CALENDAR_PERMISSIONS);
708 
709         // Browser
710         String browserPackage = ArrayUtils.firstOrNull(getKnownPackages(
711                 PackageManagerInternal.PACKAGE_BROWSER, userId));
712         if (browserPackage == null) {
713             browserPackage = getDefaultSystemHandlerActivityPackageForCategory(pm,
714                     Intent.CATEGORY_APP_BROWSER, userId);
715             if (!pm.isSystemPackage(browserPackage)) {
716                 browserPackage = null;
717             }
718         }
719         grantPermissionsToPackage(pm, browserPackage, userId, false /* ignoreSystemPackage */,
720                 true /*whitelistRestrictedPermissions*/, FOREGROUND_LOCATION_PERMISSIONS);
721 
722         // Voice interaction
723         if (voiceInteractPackageNames != null) {
724             for (String voiceInteractPackageName : voiceInteractPackageNames) {
725                 grantPermissionsToSystemPackage(pm, voiceInteractPackageName, userId,
726                         CONTACTS_PERMISSIONS, CALENDAR_PERMISSIONS, MICROPHONE_PERMISSIONS,
727                         PHONE_PERMISSIONS, SMS_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS,
728                         NEARBY_DEVICES_PERMISSIONS);
729             }
730         }
731 
732         if (ActivityManager.isLowRamDeviceStatic()) {
733             // Allow voice search on low-ram devices
734             grantPermissionsToSystemPackage(pm,
735                     getDefaultSystemHandlerActivityPackage(pm,
736                             SearchManager.INTENT_ACTION_GLOBAL_SEARCH, userId),
737                     userId, MICROPHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS);
738         }
739 
740         // Voice recognition
741         Intent voiceRecoIntent = new Intent(RecognitionService.SERVICE_INTERFACE)
742                 .addCategory(Intent.CATEGORY_DEFAULT);
743         grantPermissionsToSystemPackage(pm,
744                 getDefaultSystemHandlerServicePackage(pm, voiceRecoIntent, userId), userId,
745                 MICROPHONE_PERMISSIONS);
746 
747         // Location
748         if (locationPackageNames != null) {
749             for (String packageName : locationPackageNames) {
750                 grantPermissionsToSystemPackage(pm, packageName, userId,
751                         CONTACTS_PERMISSIONS, CALENDAR_PERMISSIONS, MICROPHONE_PERMISSIONS,
752                         PHONE_PERMISSIONS, SMS_PERMISSIONS, CAMERA_PERMISSIONS,
753                         SENSORS_PERMISSIONS, STORAGE_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS);
754                 grantSystemFixedPermissionsToSystemPackage(pm, packageName, userId,
755                         ALWAYS_LOCATION_PERMISSIONS, ACTIVITY_RECOGNITION_PERMISSIONS);
756             }
757         }
758         if (locationExtraPackageNames != null) {
759             // Also grant location and activity recognition permission to location extra packages.
760             for (String packageName : locationExtraPackageNames) {
761                 grantPermissionsToSystemPackage(pm, packageName, userId,
762                         ALWAYS_LOCATION_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS);
763                 grantSystemFixedPermissionsToSystemPackage(pm, packageName, userId,
764                         ACTIVITY_RECOGNITION_PERMISSIONS);
765             }
766         }
767 
768         // Music
769         Intent musicIntent = new Intent(Intent.ACTION_VIEW)
770                 .addCategory(Intent.CATEGORY_DEFAULT)
771                 .setDataAndType(Uri.fromFile(new File("foo.mp3")), AUDIO_MIME_TYPE);
772         grantPermissionsToSystemPackage(pm,
773                 getDefaultSystemHandlerActivityPackage(pm, musicIntent, userId), userId,
774                 STORAGE_PERMISSIONS);
775 
776         // Home
777         Intent homeIntent = new Intent(Intent.ACTION_MAIN)
778                 .addCategory(Intent.CATEGORY_HOME)
779                 .addCategory(Intent.CATEGORY_LAUNCHER_APP);
780         grantPermissionsToSystemPackage(pm,
781                 getDefaultSystemHandlerActivityPackage(pm, homeIntent, userId), userId,
782                 ALWAYS_LOCATION_PERMISSIONS);
783 
784         // Watches
785         if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH, 0)) {
786             // Home application on watches
787 
788             String wearPackage = getDefaultSystemHandlerActivityPackageForCategory(pm,
789                     Intent.CATEGORY_HOME_MAIN, userId);
790             grantPermissionsToSystemPackage(pm, wearPackage, userId,
791                     CONTACTS_PERMISSIONS, MICROPHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS);
792             grantSystemFixedPermissionsToSystemPackage(pm, wearPackage, userId, PHONE_PERMISSIONS);
793 
794             // Fitness tracking on watches
795             if (mContext.getResources().getBoolean(R.bool.config_trackerAppNeedsPermissions)) {
796                 Log.d(TAG, "Wear: Skipping permission grant for Default fitness tracker app : "
797                         + wearPackage);
798             } else {
799                 grantPermissionsToSystemPackage(pm,
800                     getDefaultSystemHandlerActivityPackage(pm, ACTION_TRACK, userId), userId,
801                     SENSORS_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS);
802             }
803         }
804 
805         // Print Spooler
806         grantSystemFixedPermissionsToSystemPackage(pm, PrintManager.PRINT_SPOOLER_PACKAGE_NAME,
807                 userId, ALWAYS_LOCATION_PERMISSIONS);
808 
809         // EmergencyInfo
810         grantSystemFixedPermissionsToSystemPackage(pm,
811                 getDefaultSystemHandlerActivityPackage(pm,
812                         TelephonyManager.ACTION_EMERGENCY_ASSISTANCE, userId),
813                 userId, CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
814 
815         // NFC Tag viewer
816         Intent nfcTagIntent = new Intent(Intent.ACTION_VIEW)
817                 .setType("vnd.android.cursor.item/ndef_msg");
818         grantPermissionsToSystemPackage(pm,
819                 getDefaultSystemHandlerActivityPackage(pm, nfcTagIntent, userId), userId,
820                 CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
821 
822         // Storage Manager
823         grantSystemFixedPermissionsToSystemPackage(pm,
824                 getDefaultSystemHandlerActivityPackage(pm,
825                         StorageManager.ACTION_MANAGE_STORAGE, userId),
826                 userId, STORAGE_PERMISSIONS);
827 
828         // Companion devices
829         grantSystemFixedPermissionsToSystemPackage(pm,
830                 CompanionDeviceManager.COMPANION_DEVICE_DISCOVERY_PACKAGE_NAME, userId,
831                 ALWAYS_LOCATION_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS);
832 
833         // Ringtone Picker
834         grantSystemFixedPermissionsToSystemPackage(pm,
835                 getDefaultSystemHandlerActivityPackage(pm,
836                         RingtoneManager.ACTION_RINGTONE_PICKER, userId),
837                 userId, STORAGE_PERMISSIONS);
838 
839         // TextClassifier Service
840         for (String textClassifierPackage :
841                 getKnownPackages(PackageManagerInternal.PACKAGE_SYSTEM_TEXT_CLASSIFIER, userId)) {
842             grantPermissionsToSystemPackage(pm, textClassifierPackage, userId,
843                     COARSE_BACKGROUND_LOCATION_PERMISSIONS, CONTACTS_PERMISSIONS);
844         }
845 
846         // Content capture
847         String contentCapturePackageName =
848                 mContext.getPackageManager().getContentCaptureServicePackageName();
849         if (!TextUtils.isEmpty(contentCapturePackageName)) {
850             grantPermissionsToSystemPackage(pm, contentCapturePackageName, userId,
851                     PHONE_PERMISSIONS, SMS_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS,
852                     CONTACTS_PERMISSIONS, STORAGE_PERMISSIONS);
853         }
854 
855         // Attention Service
856         String attentionServicePackageName =
857                 mContext.getPackageManager().getAttentionServicePackageName();
858         if (!TextUtils.isEmpty(attentionServicePackageName)) {
859             grantPermissionsToSystemPackage(pm, attentionServicePackageName, userId,
860                     CAMERA_PERMISSIONS);
861         }
862 
863         // There is no real "marker" interface to identify the shared storage backup, it is
864         // hardcoded in BackupManagerService.SHARED_BACKUP_AGENT_PACKAGE.
865         grantSystemFixedPermissionsToSystemPackage(pm, "com.android.sharedstoragebackup", userId,
866                 STORAGE_PERMISSIONS);
867 
868         // System Captions Service
869         String systemCaptionsServicePackageName =
870                 mContext.getPackageManager().getSystemCaptionsServicePackageName();
871         if (!TextUtils.isEmpty(systemCaptionsServicePackageName)) {
872             grantPermissionsToSystemPackage(pm, systemCaptionsServicePackageName, userId,
873                     MICROPHONE_PERMISSIONS);
874         }
875 
876         // Bluetooth MIDI Service
877         grantSystemFixedPermissionsToSystemPackage(pm,
878                 MidiManager.BLUETOOTH_MIDI_SERVICE_PACKAGE, userId,
879                 NEARBY_DEVICES_PERMISSIONS);
880     }
881 
getDefaultSystemHandlerActivityPackageForCategory(PackageManagerWrapper pm, String category, int userId)882     private String getDefaultSystemHandlerActivityPackageForCategory(PackageManagerWrapper pm,
883             String category, int userId) {
884         return getDefaultSystemHandlerActivityPackage(pm,
885                 new Intent(Intent.ACTION_MAIN).addCategory(category), userId);
886     }
887 
888     @SafeVarargs
grantPermissionToEachSystemPackage(PackageManagerWrapper pm, ArrayList<String> packages, int userId, Set<String>... permissions)889     private final void grantPermissionToEachSystemPackage(PackageManagerWrapper pm,
890             ArrayList<String> packages, int userId, Set<String>... permissions) {
891         if (packages == null) return;
892         final int count = packages.size();
893         for (int i = 0; i < count; i++) {
894             grantPermissionsToSystemPackage(pm, packages.get(i), userId, permissions);
895         }
896     }
897 
getKnownPackages(int knownPkgId, int userId)898     private @NonNull String[] getKnownPackages(int knownPkgId, int userId) {
899         return mServiceInternal.getKnownPackageNames(knownPkgId, userId);
900     }
901 
grantDefaultPermissionsToDefaultSystemDialerApp(PackageManagerWrapper pm, String dialerPackage, int userId)902     private void grantDefaultPermissionsToDefaultSystemDialerApp(PackageManagerWrapper pm,
903             String dialerPackage, int userId) {
904         if (dialerPackage == null) {
905             return;
906         }
907         boolean isPhonePermFixed =
908                 mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH, 0);
909         if (isPhonePermFixed) {
910             grantSystemFixedPermissionsToSystemPackage(pm, dialerPackage, userId,
911                     PHONE_PERMISSIONS);
912         } else {
913             grantPermissionsToSystemPackage(pm, dialerPackage, userId, PHONE_PERMISSIONS);
914         }
915         grantPermissionsToSystemPackage(pm, dialerPackage, userId,
916                 CONTACTS_PERMISSIONS, SMS_PERMISSIONS, MICROPHONE_PERMISSIONS, CAMERA_PERMISSIONS);
917         boolean isAndroidAutomotive =
918                 mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, 0);
919         if (isAndroidAutomotive) {
920             grantPermissionsToSystemPackage(pm, dialerPackage, userId, NEARBY_DEVICES_PERMISSIONS);
921         }
922     }
923 
grantDefaultPermissionsToDefaultSystemSmsApp(PackageManagerWrapper pm, String smsPackage, int userId)924     private void grantDefaultPermissionsToDefaultSystemSmsApp(PackageManagerWrapper pm,
925             String smsPackage, int userId) {
926         grantPermissionsToSystemPackage(pm, smsPackage, userId,
927                 PHONE_PERMISSIONS, CONTACTS_PERMISSIONS, SMS_PERMISSIONS,
928                 STORAGE_PERMISSIONS, MICROPHONE_PERMISSIONS, CAMERA_PERMISSIONS);
929     }
930 
grantDefaultPermissionsToDefaultSystemUseOpenWifiApp(PackageManagerWrapper pm, String useOpenWifiPackage, int userId)931     private void grantDefaultPermissionsToDefaultSystemUseOpenWifiApp(PackageManagerWrapper pm,
932             String useOpenWifiPackage, int userId) {
933         grantPermissionsToSystemPackage(pm, useOpenWifiPackage, userId,
934                 ALWAYS_LOCATION_PERMISSIONS);
935     }
936 
grantDefaultPermissionsToDefaultUseOpenWifiApp(String packageName, int userId)937     public void grantDefaultPermissionsToDefaultUseOpenWifiApp(String packageName, int userId) {
938         Log.i(TAG, "Granting permissions to default Use Open WiFi app for user:" + userId);
939         grantIgnoringSystemPackage(NO_PM_CACHE, packageName, userId, ALWAYS_LOCATION_PERMISSIONS);
940     }
941 
grantDefaultPermissionsToDefaultSimCallManager(String packageName, int userId)942     public void grantDefaultPermissionsToDefaultSimCallManager(String packageName, int userId) {
943         grantDefaultPermissionsToDefaultSimCallManager(NO_PM_CACHE, packageName, userId);
944     }
945 
grantDefaultPermissionsToDefaultSimCallManager(PackageManagerWrapper pm, String packageName, int userId)946     private void grantDefaultPermissionsToDefaultSimCallManager(PackageManagerWrapper pm,
947             String packageName, int userId) {
948         if (packageName == null) {
949             return;
950         }
951         Log.i(TAG, "Granting permissions to sim call manager for user:" + userId);
952         grantPermissionsToPackage(pm, packageName, userId, false /* ignoreSystemPackage */,
953                 true /*whitelistRestrictedPermissions*/, PHONE_PERMISSIONS, MICROPHONE_PERMISSIONS);
954     }
955 
grantDefaultPermissionsToDefaultSystemSimCallManager(PackageManagerWrapper pm, String packageName, int userId)956     private void grantDefaultPermissionsToDefaultSystemSimCallManager(PackageManagerWrapper pm,
957             String packageName, int userId) {
958         if (pm.isSystemPackage(packageName)) {
959             grantDefaultPermissionsToDefaultSimCallManager(pm, packageName, userId);
960         }
961     }
962 
grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId)963     public void grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId) {
964         Log.i(TAG, "Granting permissions to enabled carrier apps for user:" + userId);
965         if (packageNames == null) {
966             return;
967         }
968         for (String packageName : packageNames) {
969             grantPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
970                     PHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS, SMS_PERMISSIONS);
971         }
972     }
973 
grantDefaultPermissionsToEnabledImsServices(String[] packageNames, int userId)974     public void grantDefaultPermissionsToEnabledImsServices(String[] packageNames, int userId) {
975         Log.i(TAG, "Granting permissions to enabled ImsServices for user:" + userId);
976         if (packageNames == null) {
977             return;
978         }
979         for (String packageName : packageNames) {
980             grantPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
981                     PHONE_PERMISSIONS, MICROPHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS,
982                     CAMERA_PERMISSIONS, CONTACTS_PERMISSIONS);
983         }
984     }
985 
grantDefaultPermissionsToEnabledTelephonyDataServices( String[] packageNames, int userId)986     public void grantDefaultPermissionsToEnabledTelephonyDataServices(
987             String[] packageNames, int userId) {
988         Log.i(TAG, "Granting permissions to enabled data services for user:" + userId);
989         if (packageNames == null) {
990             return;
991         }
992         for (String packageName : packageNames) {
993             // Grant these permissions as system-fixed, so that nobody can accidentally
994             // break cellular data.
995             grantSystemFixedPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
996                     PHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS);
997         }
998     }
999 
revokeDefaultPermissionsFromDisabledTelephonyDataServices( String[] packageNames, int userId)1000     public void revokeDefaultPermissionsFromDisabledTelephonyDataServices(
1001             String[] packageNames, int userId) {
1002         Log.i(TAG, "Revoking permissions from disabled data services for user:" + userId);
1003         if (packageNames == null) {
1004             return;
1005         }
1006         for (String packageName : packageNames) {
1007             PackageInfo pkg = NO_PM_CACHE.getSystemPackageInfo(packageName);
1008             if (NO_PM_CACHE.isSystemPackage(pkg) && doesPackageSupportRuntimePermissions(pkg)) {
1009                 revokeRuntimePermissions(NO_PM_CACHE, packageName, PHONE_PERMISSIONS, true,
1010                         userId);
1011                 revokeRuntimePermissions(NO_PM_CACHE, packageName, ALWAYS_LOCATION_PERMISSIONS,
1012                         true, userId);
1013             }
1014         }
1015     }
1016 
grantDefaultPermissionsToActiveLuiApp(String packageName, int userId)1017     public void grantDefaultPermissionsToActiveLuiApp(String packageName, int userId) {
1018         Log.i(TAG, "Granting permissions to active LUI app for user:" + userId);
1019         grantSystemFixedPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
1020                 CAMERA_PERMISSIONS);
1021     }
1022 
revokeDefaultPermissionsFromLuiApps(String[] packageNames, int userId)1023     public void revokeDefaultPermissionsFromLuiApps(String[] packageNames, int userId) {
1024         Log.i(TAG, "Revoke permissions from LUI apps for user:" + userId);
1025         if (packageNames == null) {
1026             return;
1027         }
1028         for (String packageName : packageNames) {
1029             PackageInfo pkg = NO_PM_CACHE.getSystemPackageInfo(packageName);
1030             if (NO_PM_CACHE.isSystemPackage(pkg) && doesPackageSupportRuntimePermissions(pkg)) {
1031                 revokeRuntimePermissions(NO_PM_CACHE, packageName, CAMERA_PERMISSIONS, true,
1032                         userId);
1033             }
1034         }
1035     }
1036 
getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm, String intentAction, int userId)1037     private String getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm,
1038             String intentAction, int userId) {
1039         return getDefaultSystemHandlerActivityPackage(pm, new Intent(intentAction), userId);
1040     }
1041 
getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm, Intent intent, int userId)1042     private String getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm, Intent intent,
1043             int userId) {
1044         ResolveInfo handler = mContext.getPackageManager().resolveActivityAsUser(
1045                 intent, DEFAULT_INTENT_QUERY_FLAGS, userId);
1046         if (handler == null || handler.activityInfo == null) {
1047             return null;
1048         }
1049         if (mServiceInternal.isResolveActivityComponent(handler.activityInfo)) {
1050             return null;
1051         }
1052         String packageName = handler.activityInfo.packageName;
1053         return pm.isSystemPackage(packageName) ? packageName : null;
1054     }
1055 
getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm, String intentAction, int userId)1056     private String getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm,
1057             String intentAction, int userId) {
1058         return getDefaultSystemHandlerServicePackage(pm, new Intent(intentAction), userId);
1059     }
1060 
getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm, Intent intent, int userId)1061     private String getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm,
1062             Intent intent, int userId) {
1063         List<ResolveInfo> handlers = mContext.getPackageManager().queryIntentServicesAsUser(
1064                 intent, DEFAULT_INTENT_QUERY_FLAGS, userId);
1065         if (handlers == null) {
1066             return null;
1067         }
1068         final int handlerCount = handlers.size();
1069         for (int i = 0; i < handlerCount; i++) {
1070             ResolveInfo handler = handlers.get(i);
1071             String handlerPackage = handler.serviceInfo.packageName;
1072             if (pm.isSystemPackage(handlerPackage)) {
1073                 return handlerPackage;
1074             }
1075         }
1076         return null;
1077     }
1078 
getHeadlessSyncAdapterPackages(PackageManagerWrapper pm, String[] syncAdapterPackageNames, int userId)1079     private ArrayList<String> getHeadlessSyncAdapterPackages(PackageManagerWrapper pm,
1080             String[] syncAdapterPackageNames, int userId) {
1081         ArrayList<String> syncAdapterPackages = new ArrayList<>();
1082 
1083         Intent homeIntent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER);
1084 
1085         for (String syncAdapterPackageName : syncAdapterPackageNames) {
1086             homeIntent.setPackage(syncAdapterPackageName);
1087 
1088             ResolveInfo homeActivity = mContext.getPackageManager().resolveActivityAsUser(
1089                     homeIntent, DEFAULT_INTENT_QUERY_FLAGS, userId);
1090             if (homeActivity != null) {
1091                 continue;
1092             }
1093 
1094             if (pm.isSystemPackage(syncAdapterPackageName)) {
1095                 syncAdapterPackages.add(syncAdapterPackageName);
1096             }
1097         }
1098 
1099         return syncAdapterPackages;
1100     }
1101 
getDefaultProviderAuthorityPackage(String authority, int userId)1102     private String getDefaultProviderAuthorityPackage(String authority, int userId) {
1103         ProviderInfo provider = mContext.getPackageManager().resolveContentProviderAsUser(
1104                 authority, DEFAULT_INTENT_QUERY_FLAGS, userId);
1105         if (provider != null) {
1106             return provider.packageName;
1107         }
1108         return null;
1109     }
1110 
grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg, Set<String> permissions, boolean systemFixed, int userId)1111     private void grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg,
1112             Set<String> permissions, boolean systemFixed, int userId) {
1113         grantRuntimePermissions(pm, pkg, permissions, systemFixed, false,
1114                 true /*whitelistRestrictedPermissions*/, userId);
1115     }
1116 
revokeRuntimePermissions(PackageManagerWrapper pm, String packageName, Set<String> permissions, boolean systemFixed, int userId)1117     private void revokeRuntimePermissions(PackageManagerWrapper pm, String packageName,
1118             Set<String> permissions, boolean systemFixed, int userId) {
1119         PackageInfo pkg = pm.getSystemPackageInfo(packageName);
1120         if (pkg == null || ArrayUtils.isEmpty(pkg.requestedPermissions)) {
1121             return;
1122         }
1123         Set<String> revokablePermissions = new ArraySet<>(Arrays.asList(pkg.requestedPermissions));
1124 
1125         for (String permission : permissions) {
1126             // We can't revoke what wasn't requested.
1127             if (!revokablePermissions.contains(permission)) {
1128                 continue;
1129             }
1130 
1131             UserHandle user = UserHandle.of(userId);
1132             final int flags = pm.getPermissionFlags(permission, pm.getPackageInfo(packageName),
1133                     user);
1134 
1135             // We didn't get this through the default grant policy. Move along.
1136             if ((flags & PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT) == 0) {
1137                 continue;
1138             }
1139             // We aren't going to clobber device policy with a DefaultGrant.
1140             if ((flags & PackageManager.FLAG_PERMISSION_POLICY_FIXED) != 0) {
1141                 continue;
1142             }
1143             // Do not revoke system fixed permissions unless caller set them that way;
1144             // there is no refcount for the number of sources of this, so there
1145             // should be at most one grantor doing SYSTEM_FIXED for any given package.
1146             if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0 && !systemFixed) {
1147                 continue;
1148             }
1149             pm.revokePermission(permission, pkg, user);
1150 
1151             if (DEBUG) {
1152                 Log.i(TAG, "revoked " + (systemFixed ? "fixed " : "not fixed ")
1153                         + permission + " to " + packageName);
1154             }
1155 
1156             // Remove the GRANTED_BY_DEFAULT flag without touching the others.
1157             // Note that we do not revoke FLAG_PERMISSION_SYSTEM_FIXED. That bit remains
1158             // sticky once set.
1159             pm.updatePermissionFlags(permission, pkg,
1160                     PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT, 0, user);
1161         }
1162     }
1163 
1164     /**
1165      * Check if a permission is already fixed or is set by the user.
1166      *
1167      * <p>A permission should not be set by the default policy if the user or other policies already
1168      * set the permission.
1169      *
1170      * @param flags The flags of the permission
1171      *
1172      * @return {@code true} iff the permission can be set without violating a policy of the users
1173      *         intention
1174      */
isFixedOrUserSet(int flags)1175     private boolean isFixedOrUserSet(int flags) {
1176         return (flags & (PackageManager.FLAG_PERMISSION_USER_SET
1177                 | PackageManager.FLAG_PERMISSION_USER_FIXED
1178                 | PackageManager.FLAG_PERMISSION_POLICY_FIXED
1179                 | PackageManager.FLAG_PERMISSION_SYSTEM_FIXED)) != 0;
1180     }
1181 
grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg, Set<String> permissionsWithoutSplits, boolean systemFixed, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions, int userId)1182     private void grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg,
1183             Set<String> permissionsWithoutSplits, boolean systemFixed, boolean ignoreSystemPackage,
1184             boolean whitelistRestrictedPermissions, int userId) {
1185         UserHandle user = UserHandle.of(userId);
1186         if (pkg == null) {
1187             return;
1188         }
1189 
1190         String[] requestedPermissions = pkg.requestedPermissions;
1191         if (ArrayUtils.isEmpty(requestedPermissions)) {
1192             return;
1193         }
1194 
1195         // Intersect the requestedPermissions for a factory image with that of its current update
1196         // in case the latter one removed a <uses-permission>
1197         String[] requestedByNonSystemPackage = pm.getPackageInfo(pkg.packageName)
1198                 .requestedPermissions;
1199         int size = requestedPermissions.length;
1200         for (int i = 0; i < size; i++) {
1201             if (!ArrayUtils.contains(requestedByNonSystemPackage, requestedPermissions[i])) {
1202                 requestedPermissions[i] = null;
1203             }
1204         }
1205         requestedPermissions = ArrayUtils.filterNotNull(requestedPermissions, String[]::new);
1206 
1207         final ArraySet<String> permissions = new ArraySet<>(permissionsWithoutSplits);
1208         ApplicationInfo applicationInfo = pkg.applicationInfo;
1209 
1210         int newFlags = PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;
1211         if (systemFixed) {
1212             newFlags |= PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
1213         }
1214 
1215         // Automatically attempt to grant split permissions to older APKs
1216         final List<PermissionManager.SplitPermissionInfo> splitPermissions =
1217                 mContext.getSystemService(PermissionManager.class).getSplitPermissions();
1218         final int numSplitPerms = splitPermissions.size();
1219         for (int splitPermNum = 0; splitPermNum < numSplitPerms; splitPermNum++) {
1220             final PermissionManager.SplitPermissionInfo splitPerm =
1221                     splitPermissions.get(splitPermNum);
1222 
1223             if (applicationInfo != null
1224                     && applicationInfo.targetSdkVersion < splitPerm.getTargetSdk()
1225                     && permissionsWithoutSplits.contains(splitPerm.getSplitPermission())) {
1226                 permissions.addAll(splitPerm.getNewPermissions());
1227             }
1228         }
1229 
1230         Set<String> grantablePermissions = null;
1231 
1232         // In some cases, like for the Phone or SMS app, we grant permissions regardless
1233         // of if the version on the system image declares the permission as used since
1234         // selecting the app as the default for that function the user makes a deliberate
1235         // choice to grant this app the permissions needed to function. For all other
1236         // apps, (default grants on first boot and user creation) we don't grant default
1237         // permissions if the version on the system image does not declare them.
1238         if (!ignoreSystemPackage
1239                 && applicationInfo != null
1240                 && applicationInfo.isUpdatedSystemApp()) {
1241             final PackageInfo disabledPkg = pm.getSystemPackageInfo(
1242                     mServiceInternal.getDisabledSystemPackageName(pkg.packageName));
1243             if (disabledPkg != null) {
1244                 if (ArrayUtils.isEmpty(disabledPkg.requestedPermissions)) {
1245                     return;
1246                 }
1247                 if (!Arrays.equals(requestedPermissions, disabledPkg.requestedPermissions)) {
1248                     grantablePermissions = new ArraySet<>(Arrays.asList(requestedPermissions));
1249                     requestedPermissions = disabledPkg.requestedPermissions;
1250                 }
1251             }
1252         }
1253 
1254         final int numRequestedPermissions = requestedPermissions.length;
1255 
1256         // Sort requested permissions so that all permissions that are a foreground permission (i.e.
1257         // permissions that have a background permission) are before their background permissions.
1258         final String[] sortedRequestedPermissions = new String[numRequestedPermissions];
1259         int numForeground = 0;
1260         int numOther = 0;
1261         for (int i = 0; i < numRequestedPermissions; i++) {
1262             String permission = requestedPermissions[i];
1263             if (pm.getBackgroundPermission(permission) != null) {
1264                 sortedRequestedPermissions[numForeground] = permission;
1265                 numForeground++;
1266             } else {
1267                 sortedRequestedPermissions[numRequestedPermissions - 1 - numOther] =
1268                         permission;
1269                 numOther++;
1270             }
1271         }
1272 
1273         for (int requestedPermissionNum = 0; requestedPermissionNum < numRequestedPermissions;
1274                 requestedPermissionNum++) {
1275             String permission = requestedPermissions[requestedPermissionNum];
1276 
1277             // If there is a disabled system app it may request a permission the updated
1278             // version ot the data partition doesn't, In this case skip the permission.
1279             if (grantablePermissions != null && !grantablePermissions.contains(permission)) {
1280                 continue;
1281             }
1282 
1283             if (permissions.contains(permission)) {
1284                 final int flags = pm.getPermissionFlags(permission, pkg, user);
1285 
1286                 // If we are trying to grant as system fixed and already system fixed
1287                 // then the system can change the system fixed grant state.
1288                 final boolean changingGrantForSystemFixed = systemFixed
1289                         && (flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0;
1290 
1291                 // Certain flags imply that the permission's current state by the system or
1292                 // device/profile owner or the user. In these cases we do not want to clobber the
1293                 // current state.
1294                 //
1295                 // Unless the caller wants to override user choices. The override is
1296                 // to make sure we can grant the needed permission to the default
1297                 // sms and phone apps after the user chooses this in the UI.
1298                 if (!isFixedOrUserSet(flags) || ignoreSystemPackage
1299                         || changingGrantForSystemFixed) {
1300                     // Never clobber policy fixed permissions.
1301                     // We must allow the grant of a system-fixed permission because
1302                     // system-fixed is sticky, but the permission itself may be revoked.
1303                     if ((flags & PackageManager.FLAG_PERMISSION_POLICY_FIXED) != 0) {
1304                         continue;
1305                     }
1306 
1307                     // Preserve allowlisting flags.
1308                     newFlags |= (flags & PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT);
1309 
1310                     // If we are allowlisting the permission, update the exempt flag before grant.
1311                     if (whitelistRestrictedPermissions && pm.isPermissionRestricted(permission)) {
1312                         pm.updatePermissionFlags(permission, pkg,
1313                                 PackageManager.FLAG_PERMISSION_RESTRICTION_SYSTEM_EXEMPT,
1314                                 PackageManager.FLAG_PERMISSION_RESTRICTION_SYSTEM_EXEMPT, user);
1315                     }
1316 
1317                     // If the system tries to change a system fixed permission from one fixed
1318                     // state to another we need to drop the fixed flag to allow the grant.
1319                     if (changingGrantForSystemFixed) {
1320                         pm.updatePermissionFlags(permission, pkg, flags,
1321                                 flags & ~PackageManager.FLAG_PERMISSION_SYSTEM_FIXED, user);
1322                     }
1323 
1324                     if (!pm.isGranted(permission, pkg, user)) {
1325                         pm.grantPermission(permission, pkg, user);
1326                     }
1327 
1328                     pm.updatePermissionFlags(permission, pkg, newFlags, newFlags, user);
1329                 }
1330 
1331                 // If a component gets a permission for being the default handler A
1332                 // and also default handler B, we grant the weaker grant form.
1333                 if ((flags & PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0
1334                         && (flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0
1335                         && !systemFixed) {
1336                     if (DEBUG) {
1337                         Log.i(TAG, "Granted not fixed " + permission + " to default handler "
1338                                 + pkg);
1339                     }
1340                     pm.updatePermissionFlags(permission, pkg,
1341                             PackageManager.FLAG_PERMISSION_SYSTEM_FIXED, 0, user);
1342                 }
1343             }
1344         }
1345     }
1346 
grantDefaultPermissionExceptions(PackageManagerWrapper pm, int userId)1347     private void grantDefaultPermissionExceptions(PackageManagerWrapper pm, int userId) {
1348         mHandler.removeMessages(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);
1349 
1350         synchronized (mLock) {
1351             // mGrantExceptions is null only before the first read and then
1352             // it serves as a cache of the default grants that should be
1353             // performed for every user. If there is an entry then the app
1354             // is on the system image and supports runtime permissions.
1355             if (mGrantExceptions == null) {
1356                 mGrantExceptions = readDefaultPermissionExceptionsLocked(pm);
1357             }
1358         }
1359 
1360         Set<String> permissions = null;
1361         final int exceptionCount = mGrantExceptions.size();
1362         for (int i = 0; i < exceptionCount; i++) {
1363             String packageName = mGrantExceptions.keyAt(i);
1364             PackageInfo pkg = pm.getSystemPackageInfo(packageName);
1365             List<DefaultPermissionGrant> permissionGrants = mGrantExceptions.valueAt(i);
1366             final int permissionGrantCount = permissionGrants.size();
1367             for (int j = 0; j < permissionGrantCount; j++) {
1368                 DefaultPermissionGrant permissionGrant = permissionGrants.get(j);
1369                 if (!pm.isPermissionDangerous(permissionGrant.name)) {
1370                     Log.w(TAG, "Ignoring permission " + permissionGrant.name
1371                             + " which isn't dangerous");
1372                     continue;
1373                 }
1374                 if (permissions == null) {
1375                     permissions = new ArraySet<>();
1376                 } else {
1377                     permissions.clear();
1378                 }
1379                 permissions.add(permissionGrant.name);
1380 
1381 
1382                 grantRuntimePermissions(pm, pkg, permissions, permissionGrant.fixed,
1383                         permissionGrant.whitelisted, true /*whitelistRestrictedPermissions*/,
1384                         userId);
1385             }
1386         }
1387     }
1388 
getDefaultPermissionFiles()1389     private File[] getDefaultPermissionFiles() {
1390         ArrayList<File> ret = new ArrayList<File>();
1391         File dir = new File(Environment.getRootDirectory(), "etc/default-permissions");
1392         if (dir.isDirectory() && dir.canRead()) {
1393             Collections.addAll(ret, dir.listFiles());
1394         }
1395         dir = new File(Environment.getVendorDirectory(), "etc/default-permissions");
1396         if (dir.isDirectory() && dir.canRead()) {
1397             Collections.addAll(ret, dir.listFiles());
1398         }
1399         dir = new File(Environment.getOdmDirectory(), "etc/default-permissions");
1400         if (dir.isDirectory() && dir.canRead()) {
1401             Collections.addAll(ret, dir.listFiles());
1402         }
1403         dir = new File(Environment.getProductDirectory(), "etc/default-permissions");
1404         if (dir.isDirectory() && dir.canRead()) {
1405             Collections.addAll(ret, dir.listFiles());
1406         }
1407         dir = new File(Environment.getSystemExtDirectory(), "etc/default-permissions");
1408         if (dir.isDirectory() && dir.canRead()) {
1409             Collections.addAll(ret, dir.listFiles());
1410         }
1411         // For IoT devices, we check the oem partition for default permissions for each app.
1412         if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_EMBEDDED, 0)) {
1413             dir = new File(Environment.getOemDirectory(), "etc/default-permissions");
1414             if (dir.isDirectory() && dir.canRead()) {
1415                 Collections.addAll(ret, dir.listFiles());
1416             }
1417         }
1418         return ret.isEmpty() ? null : ret.toArray(new File[0]);
1419     }
1420 
1421     private @NonNull ArrayMap<String, List<DefaultPermissionGrant>>
readDefaultPermissionExceptionsLocked(PackageManagerWrapper pm)1422             readDefaultPermissionExceptionsLocked(PackageManagerWrapper pm) {
1423         File[] files = getDefaultPermissionFiles();
1424         if (files == null) {
1425             return new ArrayMap<>(0);
1426         }
1427 
1428         ArrayMap<String, List<DefaultPermissionGrant>> grantExceptions = new ArrayMap<>();
1429 
1430         // Iterate over the files in the directory and scan .xml files
1431         for (File file : files) {
1432             if (!file.getPath().endsWith(".xml")) {
1433                 Slog.i(TAG, "Non-xml file " + file
1434                         + " in " + file.getParent() + " directory, ignoring");
1435                 continue;
1436             }
1437             if (!file.canRead()) {
1438                 Slog.w(TAG, "Default permissions file " + file + " cannot be read");
1439                 continue;
1440             }
1441             try (InputStream str = new FileInputStream(file)) {
1442                 TypedXmlPullParser parser = Xml.resolvePullParser(str);
1443                 parse(pm, parser, grantExceptions);
1444             } catch (XmlPullParserException | IOException e) {
1445                 Slog.w(TAG, "Error reading default permissions file " + file, e);
1446             }
1447         }
1448 
1449         return grantExceptions;
1450     }
1451 
parse(PackageManagerWrapper pm, TypedXmlPullParser parser, Map<String, List<DefaultPermissionGrant>> outGrantExceptions)1452     private void parse(PackageManagerWrapper pm, TypedXmlPullParser parser,
1453             Map<String, List<DefaultPermissionGrant>> outGrantExceptions)
1454             throws IOException, XmlPullParserException {
1455         final int outerDepth = parser.getDepth();
1456         int type;
1457         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1458                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
1459             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1460                 continue;
1461             }
1462             if (TAG_EXCEPTIONS.equals(parser.getName())) {
1463                 parseExceptions(pm, parser, outGrantExceptions);
1464             } else {
1465                 Log.e(TAG, "Unknown tag " + parser.getName());
1466             }
1467         }
1468     }
1469 
parseExceptions(PackageManagerWrapper pm, TypedXmlPullParser parser, Map<String, List<DefaultPermissionGrant>> outGrantExceptions)1470     private void parseExceptions(PackageManagerWrapper pm, TypedXmlPullParser parser,
1471             Map<String, List<DefaultPermissionGrant>> outGrantExceptions)
1472             throws IOException, XmlPullParserException {
1473         final int outerDepth = parser.getDepth();
1474         int type;
1475         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1476                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
1477             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1478                 continue;
1479             }
1480             if (TAG_EXCEPTION.equals(parser.getName())) {
1481                 String packageName = parser.getAttributeValue(null, ATTR_PACKAGE);
1482 
1483                 List<DefaultPermissionGrant> packageExceptions =
1484                         outGrantExceptions.get(packageName);
1485                 if (packageExceptions == null) {
1486                     // The package must be on the system image
1487                     PackageInfo packageInfo = pm.getSystemPackageInfo(packageName);
1488 
1489                     if (packageInfo == null) {
1490                         Log.w(TAG, "No such package:" + packageName);
1491                         XmlUtils.skipCurrentTag(parser);
1492                         continue;
1493                     }
1494 
1495                     if (!pm.isSystemPackage(packageInfo)) {
1496                         Log.w(TAG, "Unknown system package:" + packageName);
1497                         XmlUtils.skipCurrentTag(parser);
1498                         continue;
1499                     }
1500 
1501                     // The package must support runtime permissions
1502                     if (!doesPackageSupportRuntimePermissions(packageInfo)) {
1503                         Log.w(TAG, "Skipping non supporting runtime permissions package:"
1504                                 + packageName);
1505                         XmlUtils.skipCurrentTag(parser);
1506                         continue;
1507                     }
1508                     packageExceptions = new ArrayList<>();
1509                     outGrantExceptions.put(packageName, packageExceptions);
1510                 }
1511 
1512                 parsePermission(parser, packageExceptions);
1513             } else {
1514                 Log.e(TAG, "Unknown tag " + parser.getName() + "under <exceptions>");
1515             }
1516         }
1517     }
1518 
parsePermission(TypedXmlPullParser parser, List<DefaultPermissionGrant> outPackageExceptions)1519     private void parsePermission(TypedXmlPullParser parser, List<DefaultPermissionGrant>
1520             outPackageExceptions) throws IOException, XmlPullParserException {
1521         final int outerDepth = parser.getDepth();
1522         int type;
1523         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1524                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
1525             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1526                 continue;
1527             }
1528 
1529             if (TAG_PERMISSION.contains(parser.getName())) {
1530                 String name = parser.getAttributeValue(null, ATTR_NAME);
1531                 if (name == null) {
1532                     Log.w(TAG, "Mandatory name attribute missing for permission tag");
1533                     XmlUtils.skipCurrentTag(parser);
1534                     continue;
1535                 }
1536 
1537                 final boolean fixed =
1538                         parser.getAttributeBoolean(null, ATTR_FIXED, false);
1539                 final boolean whitelisted =
1540                         parser.getAttributeBoolean(null, ATTR_WHITELISTED, false);
1541 
1542                 DefaultPermissionGrant exception = new DefaultPermissionGrant(
1543                         name, fixed, whitelisted);
1544                 outPackageExceptions.add(exception);
1545             } else {
1546                 Log.e(TAG, "Unknown tag " + parser.getName() + "under <exception>");
1547             }
1548         }
1549     }
1550 
doesPackageSupportRuntimePermissions(PackageInfo pkg)1551     private static boolean doesPackageSupportRuntimePermissions(PackageInfo pkg) {
1552         return pkg.applicationInfo != null
1553                 && pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1;
1554     }
1555 
1556     /**
1557      * A wrapper for package manager calls done by this class
1558      */
1559     private abstract class PackageManagerWrapper {
getPermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1560         abstract int getPermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1561                 @NonNull UserHandle user);
1562 
updatePermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, int flagMask, int flagValues, @NonNull UserHandle user)1563         abstract void updatePermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1564                 int flagMask, int flagValues, @NonNull UserHandle user);
1565 
grantPermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1566         abstract void grantPermission(@NonNull String permission, @NonNull PackageInfo pkg,
1567                 @NonNull UserHandle user);
1568 
revokePermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1569         abstract void revokePermission(@NonNull String permission, @NonNull PackageInfo pkg,
1570                 @NonNull UserHandle user);
1571 
isGranted(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1572         abstract boolean isGranted(@NonNull String permission, @NonNull PackageInfo pkg,
1573                 @NonNull UserHandle user);
1574 
getPermissionInfo(@onNull String permissionName)1575         abstract @Nullable PermissionInfo getPermissionInfo(@NonNull String permissionName);
1576 
getPackageInfo(@onNull String pkg)1577         abstract @Nullable PackageInfo getPackageInfo(@NonNull String pkg);
1578 
getSystemPackageInfo(@onNull String pkg)1579         @Nullable PackageInfo getSystemPackageInfo(@NonNull String pkg) {
1580             PackageInfo pi = getPackageInfo(pkg);
1581             if (pi == null || !pi.applicationInfo.isSystemApp()) {
1582                 return null;
1583             }
1584             return pi;
1585         }
1586 
isPermissionRestricted(@onNull String name)1587         boolean isPermissionRestricted(@NonNull String name) {
1588             PermissionInfo pi = getPermissionInfo(name);
1589             if (pi == null) {
1590                 return false;
1591             }
1592 
1593             return pi.isRestricted();
1594         }
1595 
isPermissionDangerous(@onNull String name)1596         boolean isPermissionDangerous(@NonNull String name) {
1597             PermissionInfo pi = getPermissionInfo(name);
1598             if (pi == null) {
1599                 return false;
1600             }
1601 
1602             return pi.getProtection() == PermissionInfo.PROTECTION_DANGEROUS;
1603         }
1604 
1605         /**
1606          * Return the background permission for a permission.
1607          *
1608          * @param permission The name of the foreground permission
1609          *
1610          * @return The name of the background permission or {@code null} if the permission has no
1611          *         background permission
1612          */
getBackgroundPermission(@onNull String permission)1613         @Nullable String getBackgroundPermission(@NonNull String permission) {
1614             PermissionInfo pi = getPermissionInfo(permission);
1615             if (pi == null) {
1616                 return null;
1617             }
1618 
1619             return pi.backgroundPermission;
1620         }
1621 
isSystemPackage(@ullable String packageName)1622         boolean isSystemPackage(@Nullable String packageName) {
1623             return isSystemPackage(getPackageInfo(packageName));
1624         }
1625 
isSystemPackage(@ullable PackageInfo pkg)1626         boolean isSystemPackage(@Nullable PackageInfo pkg) {
1627             if (pkg == null) {
1628                 return false;
1629             }
1630             return pkg.applicationInfo.isSystemApp()
1631                     && !isSysComponentOrPersistentPlatformSignedPrivApp(pkg);
1632         }
1633 
isSysComponentOrPersistentPlatformSignedPrivApp(@onNull PackageInfo pkg)1634         boolean isSysComponentOrPersistentPlatformSignedPrivApp(@NonNull PackageInfo pkg) {
1635             if (UserHandle.getAppId(pkg.applicationInfo.uid) < FIRST_APPLICATION_UID) {
1636                 return true;
1637             }
1638             if (!pkg.applicationInfo.isPrivilegedApp()) {
1639                 return false;
1640             }
1641             final PackageInfo disabledPkg = getSystemPackageInfo(
1642                     mServiceInternal.getDisabledSystemPackageName(pkg.applicationInfo.packageName));
1643             if (disabledPkg != null) {
1644                 ApplicationInfo disabledPackageAppInfo = disabledPkg.applicationInfo;
1645                 if (disabledPackageAppInfo != null
1646                         && (disabledPackageAppInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
1647                     return false;
1648                 }
1649             } else if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
1650                 return false;
1651             }
1652             return mServiceInternal.isPlatformSigned(pkg.packageName);
1653         }
1654     }
1655 
1656     /**
1657      * Do package manager calls but cache state and delay any change until {@link #apply()} is
1658      * called
1659      */
1660     private class DelayingPackageManagerCache extends PackageManagerWrapper {
1661         /** uid -> permission -> isGranted, flags */
1662         private SparseArray<ArrayMap<String, PermissionState>> mDelayedPermissionState =
1663                 new SparseArray<>();
1664         /** userId -> context */
1665         private SparseArray<Context> mUserContexts = new SparseArray<>();
1666         /** Permission name -> info */
1667         private ArrayMap<String, PermissionInfo> mPermissionInfos = new ArrayMap<>();
1668         /** Package name -> info */
1669         private ArrayMap<String, PackageInfo> mPackageInfos = new ArrayMap<>();
1670 
1671         /**
1672          * Apply the cached state
1673          */
apply()1674         void apply() {
1675             PackageManager.corkPackageInfoCache();
1676             for (int uidIdx = 0; uidIdx < mDelayedPermissionState.size(); uidIdx++) {
1677                 for (int permIdx = 0; permIdx < mDelayedPermissionState.valueAt(uidIdx).size();
1678                         permIdx++) {
1679                     try {
1680                         mDelayedPermissionState.valueAt(uidIdx).valueAt(permIdx).apply();
1681                     } catch (IllegalArgumentException e) {
1682                         Slog.w(TAG, "Cannot set permission " + mDelayedPermissionState.valueAt(
1683                                 uidIdx).keyAt(permIdx) + " of uid " + mDelayedPermissionState.keyAt(
1684                                 uidIdx), e);
1685                     }
1686                 }
1687             }
1688             PackageManager.uncorkPackageInfoCache();
1689         }
1690 
addPackageInfo(@onNull String packageName, @NonNull PackageInfo pkg)1691         void addPackageInfo(@NonNull String packageName, @NonNull PackageInfo pkg) {
1692             mPackageInfos.put(packageName, pkg);
1693         }
1694 
createContextAsUser(@onNull UserHandle user)1695         private @NonNull Context createContextAsUser(@NonNull UserHandle user) {
1696             int index = mUserContexts.indexOfKey(user.getIdentifier());
1697             if (index >= 0) {
1698                 return mUserContexts.valueAt(index);
1699             }
1700 
1701             Context uc = mContext.createContextAsUser(user, 0);
1702 
1703             mUserContexts.put(user.getIdentifier(), uc);
1704 
1705             return uc;
1706         }
1707 
getPermissionState(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1708         private @NonNull PermissionState getPermissionState(@NonNull String permission,
1709                 @NonNull PackageInfo pkg, @NonNull UserHandle user) {
1710             int uid = UserHandle.getUid(user.getIdentifier(),
1711                     UserHandle.getAppId(pkg.applicationInfo.uid));
1712             int uidIdx = mDelayedPermissionState.indexOfKey(uid);
1713 
1714             ArrayMap<String, PermissionState> uidState;
1715             if (uidIdx >= 0) {
1716                 uidState = mDelayedPermissionState.valueAt(uidIdx);
1717             } else {
1718                 uidState = new ArrayMap<>();
1719                 mDelayedPermissionState.put(uid, uidState);
1720             }
1721 
1722             int permIdx = uidState.indexOfKey(permission);
1723 
1724             PermissionState permState;
1725             if (permIdx >= 0) {
1726                 permState = uidState.valueAt(permIdx);
1727             } else {
1728                 permState = new PermissionState(permission, pkg, user);
1729                 uidState.put(permission, permState);
1730             }
1731 
1732             return permState;
1733         }
1734 
1735         @Override
getPermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1736         public int getPermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1737                 @NonNull UserHandle user) {
1738             PermissionState state = getPermissionState(permission, pkg, user);
1739             state.initFlags();
1740             return state.newFlags;
1741         }
1742 
1743         @Override
updatePermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, int flagMask, int flagValues, @NonNull UserHandle user)1744         public void updatePermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1745                 int flagMask, int flagValues, @NonNull UserHandle user) {
1746             PermissionState state = getPermissionState(permission, pkg, user);
1747             state.initFlags();
1748             state.newFlags = (state.newFlags & ~flagMask) | (flagValues & flagMask);
1749         }
1750 
1751         @Override
grantPermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1752         public void grantPermission(@NonNull String permission, @NonNull PackageInfo pkg,
1753                 @NonNull UserHandle user) {
1754             if (PermissionManager.DEBUG_TRACE_GRANTS
1755                     && PermissionManager.shouldTraceGrant(
1756                     pkg.packageName, permission, user.getIdentifier())) {
1757                 Log.i(PermissionManager.LOG_TAG_TRACE_GRANTS,
1758                         "PregrantPolicy is granting " + pkg.packageName + " "
1759                                 + permission + " for user " + user.getIdentifier(),
1760                         new RuntimeException());
1761             }
1762             PermissionState state = getPermissionState(permission, pkg, user);
1763             state.initGranted();
1764             state.newGranted = true;
1765         }
1766 
1767         @Override
revokePermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1768         public void revokePermission(@NonNull String permission, @NonNull PackageInfo pkg,
1769                 @NonNull UserHandle user) {
1770             PermissionState state = getPermissionState(permission, pkg, user);
1771             state.initGranted();
1772             state.newGranted = false;
1773         }
1774 
1775         @Override
isGranted(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1776         public boolean isGranted(@NonNull String permission, @NonNull PackageInfo pkg,
1777                 @NonNull UserHandle user) {
1778             PermissionState state = getPermissionState(permission, pkg, user);
1779             state.initGranted();
1780             return state.newGranted;
1781         }
1782 
1783         @Override
getPermissionInfo(@onNull String permissionName)1784         public @Nullable PermissionInfo getPermissionInfo(@NonNull String permissionName) {
1785             int index = mPermissionInfos.indexOfKey(permissionName);
1786             if (index >= 0) {
1787                 return mPermissionInfos.valueAt(index);
1788             }
1789 
1790             PermissionInfo pi = NO_PM_CACHE.getPermissionInfo(permissionName);
1791             mPermissionInfos.put(permissionName, pi);
1792 
1793             return pi;
1794         }
1795 
1796         @Override
getPackageInfo(@onNull String pkg)1797         public @Nullable PackageInfo getPackageInfo(@NonNull String pkg) {
1798             int index = mPackageInfos.indexOfKey(pkg);
1799             if (index >= 0) {
1800                 return mPackageInfos.valueAt(index);
1801             }
1802 
1803             PackageInfo pi = NO_PM_CACHE.getPackageInfo(pkg);
1804             mPackageInfos.put(pkg, pi);
1805 
1806             return pi;
1807         }
1808 
1809         /**
1810          * State of a single permission belonging to a single uid
1811          */
1812         private class PermissionState {
1813             private final @NonNull String mPermission;
1814             private final @NonNull PackageInfo mPkgRequestingPerm;
1815             private final @NonNull UserHandle mUser;
1816 
1817             /** Permission flags when the state was created */
1818             private @Nullable Integer mOriginalFlags;
1819             /** Altered permission flags or {@code null} if no change was requested */
1820             @Nullable Integer newFlags;
1821 
1822             /** Grant state when the state was created */
1823             private @Nullable Boolean mOriginalGranted;
1824             /** Altered grant state or {@code null} if no change was requested */
1825             @Nullable Boolean newGranted;
1826 
PermissionState(@onNull String permission, @NonNull PackageInfo pkgRequestingPerm, @NonNull UserHandle user)1827             private PermissionState(@NonNull String permission,
1828                     @NonNull PackageInfo pkgRequestingPerm, @NonNull UserHandle user) {
1829                 mPermission = permission;
1830                 mPkgRequestingPerm = pkgRequestingPerm;
1831                 mUser = user;
1832             }
1833 
1834             /**
1835              * Apply the changes to the permission to the system
1836              */
apply()1837             void apply() {
1838                 if (DEBUG) {
1839                     Slog.i(TAG, "Granting " + mPermission + " to user " + mUser.getIdentifier()
1840                             + " pkg=" + mPkgRequestingPerm.packageName + " granted=" + newGranted
1841                             + " flags=" + Integer.toBinaryString(newFlags));
1842                 }
1843 
1844                 int flagsToAdd = 0;
1845                 int flagsToRemove = 0;
1846                 if (newFlags != null) {
1847                     flagsToAdd = newFlags & ~mOriginalFlags;
1848                     flagsToRemove = mOriginalFlags & ~newFlags;
1849                 }
1850 
1851                 // Need to remove e.g. SYSTEM_FIXED flags first as otherwise permission cannot be
1852                 // changed
1853                 if (flagsToRemove != 0) {
1854                     NO_PM_CACHE.updatePermissionFlags(mPermission, mPkgRequestingPerm,
1855                             flagsToRemove, 0, mUser);
1856                 }
1857 
1858                 // Need to unrestrict first as otherwise permission grants might fail
1859                 if ((flagsToAdd & PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT) != 0) {
1860                     int newRestrictionExcemptFlags =
1861                             flagsToAdd & PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT;
1862 
1863                     NO_PM_CACHE.updatePermissionFlags(mPermission,
1864                             mPkgRequestingPerm, newRestrictionExcemptFlags, -1, mUser);
1865                 }
1866 
1867                 if (newGranted != null && newGranted != mOriginalGranted) {
1868                     if (newGranted) {
1869                         NO_PM_CACHE.grantPermission(mPermission, mPkgRequestingPerm, mUser);
1870                     } else {
1871                         NO_PM_CACHE.revokePermission(mPermission, mPkgRequestingPerm, mUser);
1872                     }
1873                 }
1874 
1875                 if ((flagsToAdd & ~PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT) != 0) {
1876                     int newFlags =
1877                             flagsToAdd & ~PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT;
1878 
1879                     NO_PM_CACHE.updatePermissionFlags(mPermission, mPkgRequestingPerm, newFlags,
1880                             -1, mUser);
1881                 }
1882             }
1883 
1884             /**
1885              * Load the state of the flags before first use
1886              */
initFlags()1887             void initFlags() {
1888                 if (newFlags == null) {
1889                     mOriginalFlags = NO_PM_CACHE.getPermissionFlags(mPermission, mPkgRequestingPerm,
1890                             mUser);
1891                     newFlags = mOriginalFlags;
1892                 }
1893             }
1894 
1895             /**
1896              * Load the grant state before first use
1897              */
initGranted()1898             void initGranted() {
1899                 if (newGranted == null) {
1900                     // Don't call NO_PM_CACHE here so that contexts are reused
1901                     mOriginalGranted = createContextAsUser(mUser).getPackageManager()
1902                             .checkPermission(mPermission, mPkgRequestingPerm.packageName)
1903                             == PackageManager.PERMISSION_GRANTED;
1904                     newGranted = mOriginalGranted;
1905                 }
1906             }
1907         }
1908     }
1909 
1910     private static final class DefaultPermissionGrant {
1911         final String name;
1912         final boolean fixed;
1913         final boolean whitelisted;
1914 
DefaultPermissionGrant(String name, boolean fixed, boolean whitelisted)1915         public DefaultPermissionGrant(String name, boolean fixed,
1916                 boolean whitelisted) {
1917             this.name = name;
1918             this.fixed = fixed;
1919             this.whitelisted = whitelisted;
1920         }
1921     }
1922 }
1923