From 0c4db149e17d45325a88ff90529959f828f3fd9a Mon Sep 17 00:00:00 2001 From: Tad Date: Tue, 18 Oct 2022 17:13:17 -0400 Subject: [PATCH] 20.0: Network & Sensors permission from GrapheneOS This revokes the permissions to all user installed apps on update. Likely an expected quirk of being on 20.0 without the permission. 19.1 upgrades and new 20.0 installs should be fine. TODO: update 19.1 with the SpecialRuntimePermAppUtils too Signed-off-by: Tad --- Misc/Features/GrapheneOS.txt | 49 +++- .../0001-Network_Permission-4.patch | 48 ---- .../0005-User_Logout-a1.patch | 28 +++ .../0013-Special_Permissions-1.patch | 137 +++++++++++ .../0013-Special_Permissions-10.patch | 25 ++ .../0013-Special_Permissions-11.patch | 231 ++++++++++++++++++ .../0013-Special_Permissions-12.patch | 33 +++ .../0013-Special_Permissions-13.patch | 144 +++++++++++ .../0013-Special_Permissions-2.patch | 81 ++++++ .../0013-Special_Permissions-3.patch | 113 +++++++++ .../0013-Special_Permissions-4.patch | 118 +++++++++ .../0013-Special_Permissions-5.patch | 189 ++++++++++++++ .../0013-Special_Permissions-6.patch | 165 +++++++++++++ .../0013-Special_Permissions-7.patch | 48 ++++ .../0013-Special_Permissions-8.patch | 38 +++ .../0013-Special_Permissions-9.patch | 36 +++ .../0026-Crash_Details.patch | 4 +- .../0027-Installer_Glitch.patch | 89 +++++++ .../0001-Sensors_Permission-a1.patch | 54 ++++ .../0001-Sensors_Permission.patch | 22 ++ .../0001-Network_Permission.patch | 32 +++ .../0001-Network_Permission-1.patch | 34 +++ .../0001-Network_Permission-2.patch | 208 ++++++++++++++++ .../0001-Network_Permission-3.patch | 54 ++++ .../0004-Special_Permissions-1.patch | 179 ++++++++++++++ .../0004-Special_Permissions-2.patch | 54 ++++ .../0001-Network_Permission.patch | 21 ++ PrebuiltApps | 2 +- Scripts/LineageOS-17.1/Functions.sh | 3 +- Scripts/LineageOS-18.1/Functions.sh | 3 +- Scripts/LineageOS-19.1/Functions.sh | 1 - Scripts/LineageOS-19.1/Patch.sh | 1 - Scripts/LineageOS-20.0/Patch.sh | 32 ++- 33 files changed, 2211 insertions(+), 65 deletions(-) delete mode 100644 Patches/LineageOS-19.1/android_packages_modules_Connectivity/0001-Network_Permission-4.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0005-User_Logout-a1.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-1.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-10.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-11.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-12.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-13.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-2.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-3.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-4.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-5.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-6.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-7.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-8.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-9.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_base/0027-Installer_Glitch.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_native/0001-Sensors_Permission-a1.patch create mode 100644 Patches/LineageOS-20.0/android_frameworks_native/0001-Sensors_Permission.patch create mode 100644 Patches/LineageOS-20.0/android_libcore/0001-Network_Permission.patch create mode 100644 Patches/LineageOS-20.0/android_packages_modules_Connectivity/0001-Network_Permission-1.patch create mode 100644 Patches/LineageOS-20.0/android_packages_modules_Connectivity/0001-Network_Permission-2.patch create mode 100644 Patches/LineageOS-20.0/android_packages_modules_Connectivity/0001-Network_Permission-3.patch create mode 100644 Patches/LineageOS-20.0/android_packages_modules_Permission/0004-Special_Permissions-1.patch create mode 100644 Patches/LineageOS-20.0/android_packages_modules_Permission/0004-Special_Permissions-2.patch create mode 100644 Patches/LineageOS-20.0/android_packages_providers_DownloadProvider/0001-Network_Permission.patch diff --git a/Misc/Features/GrapheneOS.txt b/Misc/Features/GrapheneOS.txt index f335b638..c4d753e1 100644 --- a/Misc/Features/GrapheneOS.txt +++ b/Misc/Features/GrapheneOS.txt @@ -3,7 +3,6 @@ RQ3A.211001.001.2021100606 QQ3A.200805.001.2020.09.11.14 PQ3B.190801.002.2019.08.25.15 - https time 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/1d4e3f495b7b544f6314f04243e9d47b3f8e7102 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/2c04a077ec9f3ac6857885199f49f4845b70ec2e @@ -35,9 +34,6 @@ power animation preferred network mode 11 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/286910c6cbc8c77153e7e230a4d02bea745ea571 -auto-var-init -10 https://github.com/GrapheneOS/platform_build_soong/commit/e1b0c965952c47663d4266293b5d0e3f95121260 - nojit 11 https://github.com/GrapheneOS/platform_build/commit/8c9183f29406a93cb596ebd76ca27eb8c5f8bbe8 11 https://github.com/GrapheneOS/platform_build/commit/904c1e837a2dd9b251d57c2e064186d5af047df0 @@ -63,6 +59,10 @@ nojit 9 https://github.com/GrapheneOS/platform_build/commit/5b9927197e63593b9220d1a9280021252ef205e9 9 https://github.com/GrapheneOS/platform_build/commit/e36c7aefaa78a1ed5b94c7f51d29277008eea232 +[implemented] auto-var-init +10 https://github.com/GrapheneOS/platform_build_soong/commit/e1b0c965952c47663d4266293b5d0e3f95121260 +10 https://github.com/GrapheneOS-Archive/platform_prebuilts_abi-dumps_vndk/commit/f2bd5eaae6a72a07c6be92cbaf2f9defa30fcf38 + [implemented] captive portal toggle 13 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/d700613896eb60972f8fd9df466218a06be36f1f 12 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/2a0b0b9193195c360260a3ef7094e45c44b79a24 @@ -72,13 +72,14 @@ nojit 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/e740f4b78344c5671d022dfe90bed9e2dacd3db6 [implemented] monet toggle -13 https://github.com/GrapheneOS/platform_frameworks_base/commit/42d81724ba40b7ea91331f2695e4e07be21f5333 +13xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/42d81724ba40b7ea91331f2695e4e07be21f5333 13xhttps://github.com/GrapheneOS/platform_packages_apps_ThemePicker/commit/5ac22ffc1ac27c7bad6995a9b1d1cc63404f2470 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/e77f8f544c8c6e826d8497be6ebbc69d72d2f1a5 12 https://github.com/GrapheneOS/platform_packages_apps_ThemePicker/commit/a287544b550887ea646277d78cde80b19e1ca9af [implemented] user logout 13 https://github.com/GrapheneOS/platform_frameworks_base/commit/ff39e8de7f61b75f9221ad342e7f18d9f904c079 +13 https://github.com/GrapheneOS/platform_frameworks_base/commit/70d2092894b14725d1d7bd0aa884e5ac17438d47 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/93838b55c9b6460249a22be42f04026d8780fefc [implemented] recovery serial number @@ -86,10 +87,13 @@ nojit 12 https://github.com/GrapheneOS/platform_bootable_recovery/commit/bf7fe6fb6bf8211b0c5e1259fe5f6eee644fbf3a [implemented] google contacts +13 https://github.com/GrapheneOS/platform_packages_apps_Contacts/commit/99f7ebccadffc4e389a027d0cb030c5e954ab06a +13 https://github.com/GrapheneOS/platform_packages_apps_Contacts/commit/d1ef72f117a5838897b4d0aa948e9692eb40aa14 12 https://github.com/GrapheneOS/platform_packages_apps_Contacts/commit/0911fca3386016a506308e0b1e1ecc527153194b 12 https://github.com/GrapheneOS/platform_packages_apps_Contacts/commit/2e86c9a6e73bbaa26354ac04340c14643774e662 [implemented] keyboard personalization +13 https://github.com/GrapheneOS/platform_packages_inputmethods_LatinIME/commit/1def84d1d9e7ab01060407513d4d2d298a23be1f 12 https://github.com/GrapheneOS/platform_packages_inputmethods_LatinIME/commit/37abf03503ec25d62f3e38d24b5ef4ba31e94ae3 [implemented] location indicators @@ -108,6 +112,34 @@ nojit 13 https://github.com/GrapheneOS/platform_system_extras/commit/9adf4750630c15a1975ef8667e3e4ca50c84d1c0 12 https://github.com/GrapheneOS/platform_system_extras/commit/144930183585cec74882a5c0ffa321354ad9eb7e +hidden package installer ui glitch +13 https://github.com/GrapheneOS/platform_frameworks_base/commit/a0704cece37e347c6cb7562c8c9ea0382b2a6c01 + +[implemented] special/network/sensors permission 13 +https://github.com/GrapheneOS/platform_packages_providers_DownloadProvider/commit/203758368528fab3ded8dfd3d69cb940046fa5fc +https://github.com/GrapheneOS/platform_packages_modules_Permission/commit/17ae52ff3e9d78e6123b47a583d80f5c88e618a3 +https://github.com/GrapheneOS/platform_packages_modules_Permission/commit/bb3c25ab5088aa61e27d8091072ce4da972caaaf +https://github.com/GrapheneOS/platform_packages_modules_Permission/commit/cad030b9209013e85ffd824396d5fb31fdb7a293 +https://github.com/GrapheneOS/platform_packages_modules_Connectivity/commit/971c2f626eb46091e2ccb7c4cd99528c5de9f52e +https://github.com/GrapheneOS/platform_packages_modules_Connectivity/commit/b4dd65754ec11015006f2e692ae60bc257dafc8c +https://github.com/GrapheneOS/platform_packages_modules_Connectivity/commit/bc9fdc9c5b9dd4da42ce04280a9386011d721e8c +https://github.com/GrapheneOS/platform_frameworks_native/commit/e68b533c4fb6708dc06a3d021a1e5290a0c6ed7e +https://github.com/GrapheneOS/platform_frameworks_native/commit/d7dad9cf45d469629dae690450b902c017b48e1d +https://github.com/GrapheneOS/platform_libcore/commit/f22344e73dc8d1999246d53324e298116ec892d5 +https://github.com/GrapheneOS/platform_frameworks_base/commit/2bea9ac7ded28ad2cc08ac0d4794a5cbe54e142a +https://github.com/GrapheneOS/platform_frameworks_base/commit/51f155c1e9113c5b87734d53f808acc2873c4580 +https://github.com/GrapheneOS/platform_frameworks_base/commit/64e32600a9e4a6d595cfd027ba8144dbae360580 +https://github.com/GrapheneOS/platform_frameworks_base/commit/141f5fca9fc0dcb6588c53b72d0da4aa177de374 +https://github.com/GrapheneOS/platform_frameworks_base/commit/900ab583992814d54143d238e3379188dc9a33f5 +https://github.com/GrapheneOS/platform_frameworks_base/commit/5ccaaabc906aa15222317d3935637d7dad2944b5 +https://github.com/GrapheneOS/platform_frameworks_base/commit/54c07c79905dbaf2b81a1f6ebffc74f1501556b9 +https://github.com/GrapheneOS/platform_frameworks_base/commit/0f7cd0e2288a76f49154e8342036cea3e536e94c +https://github.com/GrapheneOS/platform_frameworks_base/commit/e41b3e0da93dfda0e16c82767863b0610a8576cc +https://github.com/GrapheneOS/platform_frameworks_base/commit/7208688690f8f4a4b904f1498123c8302cb74b69 +https://github.com/GrapheneOS/platform_frameworks_base/commit/35d517569aed194010fda7f19182acd5bf265024 +https://github.com/GrapheneOS/platform_frameworks_base/commit/44bece55f469254587d74b4327c9746e393d91fa +https://github.com/GrapheneOS/platform_frameworks_base/commit/de207d6020c459bc07b3c0c7ffc00e7c9cc90c95 + [implemented] special permissions 13xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/2bea9ac7ded28ad2cc08ac0d4794a5cbe54e142a 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/5bbbffa0d89d19a87a8de83b185cd8d58db31915 @@ -123,7 +155,6 @@ nojit 9 https://github.com/GrapheneOS/platform_frameworks_base/commit/09632b10185b9133949a431e27089f72b5cfeefa [implemented] sensors permission -13xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/64e32600a9e4a6d595cfd027ba8144dbae360580 12 https://github.com/GrapheneOS/platform_packages_modules_Permission/commit/452c474dfae9a312f6e01db5b28de308dbb14cc2 12 https://github.com/GrapheneOS/platform_packages_modules_Permission/commit/daed8c4e3ff8bf94a2a9aa319d32ec2ff5653c8f 12 https://github.com/GrapheneOS/platform_frameworks_native/commit/dcef490d7cab7bb9f96f8bfe19a8779ac140b26d @@ -143,7 +174,6 @@ nojit 9 https://github.com/GrapheneOS/platform_frameworks_base/commit/899441075ddbfc945cff97e433c9e1c9d6bde7af [implemented] network permission -13xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/51f155c1e9113c5b87734d53f808acc2873c4580 12xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/30370e36ac6945d4c837fb217ea747f66a6a7361 12xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/3dbe45681a043d44080e8c579e36a3a4562e75a1 12xhttps://github.com/GrapheneOS/platform_frameworks_base/commit/fdf369f81209a9dea42ad0f4eff8e3912d48b8af @@ -181,6 +211,8 @@ nojit [implemented] protected fifo/regular 13 https://github.com/GrapheneOS/platform_system_sepolicy/commit/d51e7878fbce05a0740de63edfee1dd41148f990 +13 https://github.com/GrapheneOS/platform_system_core/commit/9241d67e29e3436e72b94b4081a988d04deff58d +13 https://github.com/GrapheneOS/platform_system_core/commit/5ee6b5f4ad5c29818bf917b61e897fde4bce0a94 12 https://github.com/GrapheneOS/platform_system_core/commit/ddf48612c160b13552588af4d64bc7bb55571618 12 https://github.com/GrapheneOS/platform_system_core/commit/fc8f654d4f905ee88c3cdd3494c6a65b2de6d5a1 12 https://github.com/GrapheneOS/platform_system_sepolicy/commit/452bfdca38a4ffc3d3a2df9439694fcb8d0f9def @@ -318,10 +350,13 @@ nojit [implemented] Wi-Fi auto turn off (partial CalyxOS) 13 https://github.com/GrapheneOS/platform_frameworks_base/commit/edc426dd2fb8cc519bfbb934ee58d7e95eae0ebe 13 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/1f9ca051a9960fa82e9e172d1a571d1596404c3d +[ADD ME] 13 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/8b5186597593e48b4b8ec182d6c40c6edd6b3e42 12 https://github.com/GrapheneOS/platform_frameworks_base/commit/b008fb6e05af55577bad6046af4a91af4fccaeca 12 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/0f8a16323cfe431da8146e5ae58972c42b4d32d6 +[ADD ME] 12 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/2bdd6edb8a2c85d59aff681748c72d820c1d1057 11 https://github.com/GrapheneOS/platform_frameworks_base/commit/423f3e151beae0c608881d4bf16b8dff22b5efc6 11 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/ff9e9e0abf72b4df05d21bb462a305c8c09a8ba0 +[BACKPORT ME] 11 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/2bdd6edb8a2c85d59aff681748c72d820c1d1057 [implemented] ptrace scope 13 https://github.com/GrapheneOS/platform_packages_apps_Settings/commit/426ace8bd191266138b47929cea2c179550910c2 diff --git a/Patches/LineageOS-19.1/android_packages_modules_Connectivity/0001-Network_Permission-4.patch b/Patches/LineageOS-19.1/android_packages_modules_Connectivity/0001-Network_Permission-4.patch deleted file mode 100644 index 7aebb6df..00000000 --- a/Patches/LineageOS-19.1/android_packages_modules_Connectivity/0001-Network_Permission-4.patch +++ /dev/null @@ -1,48 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Dmitry Muhomor -Date: Fri, 29 Jul 2022 20:45:30 +0300 -Subject: [PATCH] bugfix: reportNetworkConnectivity() wasn't switched to - isInternetCompatEnabled() - ---- - framework/src/android/net/ConnectivityManager.java | 11 +++++------ - 1 file changed, 5 insertions(+), 6 deletions(-) - -diff --git a/framework/src/android/net/ConnectivityManager.java b/framework/src/android/net/ConnectivityManager.java -index 8857b7996..0fa34a46b 100644 ---- a/framework/src/android/net/ConnectivityManager.java -+++ b/framework/src/android/net/ConnectivityManager.java -@@ -25,7 +25,6 @@ import static android.net.NetworkRequest.Type.TRACK_DEFAULT; - import static android.net.NetworkRequest.Type.TRACK_SYSTEM_DEFAULT; - import static android.net.QosCallback.QosCallbackRegistrationException; - --import android.Manifest; - import android.annotation.CallbackExecutor; - import android.annotation.IntDef; - import android.annotation.NonNull; -@@ -43,7 +42,7 @@ import android.compat.annotation.UnsupportedAppUsage; - import android.content.ComponentName; - import android.content.Context; - import android.content.Intent; --import android.content.pm.PackageManager; -+import android.content.pm.SpecialRuntimePermAppUtils; - import android.net.ConnectivityDiagnosticsManager.DataStallReport.DetectionMethod; - import android.net.IpSecManager.UdpEncapsulationSocket; - import android.net.SocketKeepalive.Callback; -@@ -3141,12 +3140,12 @@ public class ConnectivityManager { - */ - public void reportNetworkConnectivity(@Nullable Network network, boolean hasConnectivity) { - printStackTrace(); -- if (mContext.checkSelfPermission(Manifest.permission.INTERNET) != PackageManager.PERMISSION_GRANTED) { -- // ConnectivityService enforces this by throwing an unexpected SecurityException, -- // which puts GMS into a crash loop. Also useful for other apps that don't expect that -- // INTERNET permission might get revoked. -+ -+ if (SpecialRuntimePermAppUtils.isInternetCompatEnabled()) { -+ // caller doesn't have INTERNET, but expects to always have it - return; - } -+ - try { - mService.reportNetworkConnectivity(network, hasConnectivity); - } catch (RemoteException e) { diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0005-User_Logout-a1.patch b/Patches/LineageOS-20.0/android_frameworks_base/0005-User_Logout-a1.patch new file mode 100644 index 00000000..1bffb4ad --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0005-User_Logout-a1.patch @@ -0,0 +1,28 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Thu, 18 Aug 2022 10:04:46 +0300 +Subject: [PATCH] fix DevicePolicyManager#logoutUser() never succeeding + +To succeed, userId to switch to needs to be set with setLogoutUserIdLocked(), but this is not done +in both callers of this method (both of which are "End session" buttons), making them no-ops. +--- + .../server/devicepolicy/DevicePolicyManagerService.java | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java +index 4be9c1a1d54a..a33f4fa55b53 100644 +--- a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java ++++ b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java +@@ -11155,6 +11155,12 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager { + Preconditions.checkCallAuthorization(canManageUsers(caller) + || hasCallingOrSelfPermission(permission.INTERACT_ACROSS_USERS)); + ++ synchronized (getLockObject()) { ++ if (getLogoutUserIdUnchecked() == UserHandle.USER_NULL) { ++ setLogoutUserIdLocked(UserHandle.USER_SYSTEM); ++ } ++ } ++ + int currentUserId = getCurrentForegroundUserId(); + if (VERBOSE_LOG) { + Slogf.v(LOG_TAG, "logout() called by uid %d; current user is %d", caller.getUid(), diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-1.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-1.patch new file mode 100644 index 00000000..733ebb80 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-1.patch @@ -0,0 +1,137 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: inthewaves +Date: Sat, 12 Sep 2020 22:28:34 +0300 +Subject: [PATCH] support new special runtime permissions + +Ported from 12: b294a2ce1d0d185dbc438ac3c06c90386d5f5949 +--- + .../PermissionManagerServiceImpl.java | 39 ++++++++++++++----- + 1 file changed, 30 insertions(+), 9 deletions(-) + +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +index d34682df3413..1d974b980f6e 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +@@ -1409,7 +1409,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + // their permissions as always granted runtime ones since we need + // to keep the review required permission flag per user while an + // install permission's state is shared across all users. +- if (pkg.getTargetSdkVersion() < Build.VERSION_CODES.M && bp.isRuntime()) { ++ if (pkg.getTargetSdkVersion() < Build.VERSION_CODES.M && bp.isRuntime() && ++ !isSpecialRuntimePermission(permName)) { + return; + } + +@@ -1452,7 +1453,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + + " for package " + packageName); + } + +- if (pkg.getTargetSdkVersion() < Build.VERSION_CODES.M) { ++ if (pkg.getTargetSdkVersion() < Build.VERSION_CODES.M && ++ !isSpecialRuntimePermission(permName)) { + Slog.w(TAG, "Cannot grant runtime permission to a legacy app"); + return; + } +@@ -1598,7 +1600,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + // their permissions as always granted runtime ones since we need + // to keep the review required permission flag per user while an + // install permission's state is shared across all users. +- if (pkg.getTargetSdkVersion() < Build.VERSION_CODES.M && bp.isRuntime()) { ++ if (pkg.getTargetSdkVersion() < Build.VERSION_CODES.M && bp.isRuntime() && ++ !isSpecialRuntimePermission(permName)) { + return; + } + +@@ -1784,7 +1787,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + // permission as requiring a review as this is the initial state. + final int uid = mPackageManagerInt.getPackageUid(packageName, 0, userId); + final int targetSdk = mPackageManagerInt.getUidTargetSdkVersion(uid); +- final int flags = (targetSdk < Build.VERSION_CODES.M && isRuntimePermission) ++ final int flags = (targetSdk < Build.VERSION_CODES.M && isRuntimePermission ++ && !isSpecialRuntimePermission(permName)) + ? FLAG_PERMISSION_REVIEW_REQUIRED | FLAG_PERMISSION_REVOKED_COMPAT + : 0; + +@@ -1804,7 +1808,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + + // If this permission was granted by default or role, make sure it is. + if ((oldFlags & FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0 +- || (oldFlags & FLAG_PERMISSION_GRANTED_BY_ROLE) != 0) { ++ || (oldFlags & FLAG_PERMISSION_GRANTED_BY_ROLE) != 0 ++ || isSpecialRuntimePermission(permName)) { + // PermissionPolicyService will handle the app op for runtime permissions later. + grantRuntimePermissionInternal(packageName, permName, false, + Process.SYSTEM_UID, userId, delayingPermCallback); +@@ -2477,6 +2482,10 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + } + } + ++ public static boolean isSpecialRuntimePermission(final String permission) { ++ return false; ++ } ++ + /** + * Restore the permission state for a package. + * +@@ -2601,6 +2610,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + synchronized (mLock) { + for (final int userId : userIds) { + final UserPermissionState userState = mState.getOrCreateUserState(userId); ++ // "replace" parameter is set to true even when the app is first installed ++ final boolean uidStateWasPresent = userState.getUidState(ps.getAppId()) != null; + final UidPermissionState uidState = userState.getOrCreateUidState(ps.getAppId()); + + if (uidState.isMissing()) { +@@ -2617,7 +2628,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + FLAG_PERMISSION_RESTRICTION_UPGRADE_EXEMPT, + FLAG_PERMISSION_RESTRICTION_UPGRADE_EXEMPT); + } +- if (uidTargetSdkVersion < Build.VERSION_CODES.M) { ++ if (uidTargetSdkVersion < Build.VERSION_CODES.M && !isSpecialRuntimePermission(permissionName)) { + uidState.updatePermissionFlags(permission, + PackageManager.FLAG_PERMISSION_REVIEW_REQUIRED + | PackageManager.FLAG_PERMISSION_REVOKED_COMPAT, +@@ -2823,7 +2834,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + boolean restrictionApplied = (origState.getPermissionFlags( + bp.getName()) & FLAG_PERMISSION_APPLY_RESTRICTION) != 0; + +- if (appSupportsRuntimePermissions) { ++ if (appSupportsRuntimePermissions || isSpecialRuntimePermission(bp.getName())) { + // If hard restricted we don't allow holding it + if (permissionPolicyInitialized && hardRestricted) { + if (!restrictionExempt) { +@@ -2877,6 +2888,16 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + } + } + } ++ ++ if (isSpecialRuntimePermission(permName) && ++ origPermState == null && ++ // don't grant special runtime permission after update, ++ // unless app comes from the system image ++ (!uidStateWasPresent || ps.isSystem())) { ++ if (uidState.grantPermission(bp)) { ++ wasChanged = true; ++ } ++ } + } else { + if (origPermState == null) { + // New permission +@@ -2911,7 +2932,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + if (restrictionApplied) { + flags &= ~FLAG_PERMISSION_APPLY_RESTRICTION; + // Dropping restriction on a legacy app implies a review +- if (!appSupportsRuntimePermissions) { ++ if (!appSupportsRuntimePermissions && !isSpecialRuntimePermission(bp.getName())) { + flags |= FLAG_PERMISSION_REVIEW_REQUIRED; + } + wasChanged = true; +@@ -3642,7 +3663,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + if (shouldGrantPermission) { + final int flags = getPermissionFlagsInternal(pkg.getPackageName(), permission, + myUid, userId); +- if (supportsRuntimePermissions) { ++ if (supportsRuntimePermissions || isSpecialRuntimePermission(permission)) { + // Installer cannot change immutable permissions. + if ((flags & immutableFlags) == 0) { + grantRuntimePermissionInternal(pkg.getPackageName(), permission, false, diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-10.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-10.patch new file mode 100644 index 00000000..eeb09b2d --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-10.patch @@ -0,0 +1,25 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Fri, 7 Oct 2022 20:12:26 +0300 +Subject: [PATCH] srt permissions: don't auto-grant denied ones when + permissions are reset + +--- + .../server/pm/permission/PermissionManagerServiceImpl.java | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +index da832f59671d..2204ad6721c8 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +@@ -1809,7 +1809,9 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + // If this permission was granted by default or role, make sure it is. + if ((oldFlags & FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0 + || (oldFlags & FLAG_PERMISSION_GRANTED_BY_ROLE) != 0 +- || isSpecialRuntimePermission(permName)) { ++ || (isSpecialRuntimePermission(permName) ++ && checkPermission(packageName, permName, userId) == PERMISSION_GRANTED) ++ ) { + // PermissionPolicyService will handle the app op for runtime permissions later. + grantRuntimePermissionInternal(packageName, permName, false, + Process.SYSTEM_UID, userId, delayingPermCallback); diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-11.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-11.patch new file mode 100644 index 00000000..f9feaacd --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-11.patch @@ -0,0 +1,231 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Fri, 7 Oct 2022 20:15:14 +0300 +Subject: [PATCH] srt permissions: fix auto granting after package install + +Previous approach to auto-granting is not compatible with ability to disable auto-grants: +special runtime permissions were auto-granted for all users, including those that didn't have +the package installed. +--- + .../server/pm/InstallPackageHelper.java | 10 +++-- + .../PermissionManagerServiceImpl.java | 43 +++++++++++++------ + .../PermissionManagerServiceInternal.java | 20 ++++++++- + 3 files changed, 55 insertions(+), 18 deletions(-) + +diff --git a/services/core/java/com/android/server/pm/InstallPackageHelper.java b/services/core/java/com/android/server/pm/InstallPackageHelper.java +index 7da5f51bcbc2..f7fa93bce4cb 100644 +--- a/services/core/java/com/android/server/pm/InstallPackageHelper.java ++++ b/services/core/java/com/android/server/pm/InstallPackageHelper.java +@@ -599,6 +599,7 @@ final class InstallPackageHelper { + permissionParamsBuilder.setAllowlistedRestrictedPermissions( + pkgSetting.getPkg().getRequestedPermissions()); + } ++ permissionParamsBuilder.setNewlyInstalledInUserId(userId); + mPm.mPermissionManager.onPackageInstalled(pkgSetting.getPkg(), + Process.INVALID_UID /* previousAppId */, + permissionParamsBuilder.build(), userId); +@@ -2118,6 +2119,10 @@ final class InstallPackageHelper { + } + } + ++ final PermissionManagerServiceInternal.PackageInstalledParams.Builder ++ permissionParamsBuilder = ++ new PermissionManagerServiceInternal.PackageInstalledParams.Builder(); ++ + // Set install reason for users that are having the package newly installed. + final int[] allUsersList = mPm.mUserManager.getUserIds(); + if (userId == UserHandle.USER_ALL) { +@@ -2125,10 +2130,12 @@ final class InstallPackageHelper { + if (!previousUserIds.contains(currentUserId) + && ps.getInstalled(currentUserId)) { + ps.setInstallReason(installReason, currentUserId); ++ permissionParamsBuilder.setNewlyInstalledInUserId(currentUserId); + } + } + } else if (!previousUserIds.contains(userId)) { + ps.setInstallReason(installReason, userId); ++ permissionParamsBuilder.setNewlyInstalledInUserId(userId); + } + + // TODO(b/169721400): generalize Incremental States and create a Callback object +@@ -2149,9 +2156,6 @@ final class InstallPackageHelper { + + mPm.mSettings.writeKernelMappingLPr(ps); + +- final PermissionManagerServiceInternal.PackageInstalledParams.Builder +- permissionParamsBuilder = +- new PermissionManagerServiceInternal.PackageInstalledParams.Builder(); + final boolean grantPermissions = (installArgs.mInstallFlags + & PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS) != 0; + if (grantPermissions) { +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +index 2204ad6721c8..0fcd067142f5 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +@@ -136,6 +136,7 @@ import com.android.server.pm.parsing.pkg.AndroidPackage; + import com.android.server.pm.parsing.pkg.AndroidPackageUtils; + import com.android.server.pm.pkg.AndroidPackageApi; + import com.android.server.pm.pkg.PackageStateInternal; ++import com.android.server.pm.pkg.PackageUserStateUtils; + import com.android.server.pm.pkg.component.ComponentMutateUtils; + import com.android.server.pm.pkg.component.ParsedPermission; + import com.android.server.pm.pkg.component.ParsedPermissionGroup; +@@ -2611,9 +2612,10 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + + synchronized (mLock) { + for (final int userId : userIds) { ++ final boolean isNotInstalledUserApp = !ps.isSystem() ++ && !PackageUserStateUtils.isAvailable(ps.getUserStateOrDefault(userId), 0); ++ + final UserPermissionState userState = mState.getOrCreateUserState(userId); +- // "replace" parameter is set to true even when the app is first installed +- final boolean uidStateWasPresent = userState.getUidState(ps.getAppId()) != null; + final UidPermissionState uidState = userState.getOrCreateUidState(ps.getAppId()); + + if (uidState.isMissing()) { +@@ -2891,13 +2893,23 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + } + } + +- if (isSpecialRuntimePermission(permName) && +- origPermState == null && +- // don't grant special runtime permission after update, +- // unless app comes from the system image +- (!uidStateWasPresent || ps.isSystem())) { +- if (uidState.grantPermission(bp)) { +- wasChanged = true; ++ if (isSpecialRuntimePermission(permName)) { ++ if (origPermState == null && ps.isSystem()) { ++ // always grant special runtime permissions to system packages ++ if (uidState.grantPermission(bp)) { ++ wasChanged = true; ++ } ++ } ++ ++ if (isNotInstalledUserApp) { ++ // Previously, special runtime permissions were granted in users ++ // that didn't have the package installed, which breaks the code ++ // that allows to skip granting these permissions at install time. ++ // (if UidPermissionState is already present at install time, it's ++ // reused as is). ++ if (uidState.revokePermission(bp)) { ++ wasChanged = true; ++ } + } + } + } else { +@@ -3639,7 +3651,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + } + + private void grantRequestedRuntimePermissionsInternal(@NonNull AndroidPackage pkg, +- @Nullable List permissions, int userId) { ++ @Nullable List permissions, int userId, boolean newlyInstalled) { + final int immutableFlags = PackageManager.FLAG_PERMISSION_SYSTEM_FIXED + | PackageManager.FLAG_PERMISSION_POLICY_FIXED; + +@@ -3654,6 +3666,9 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + final int myUid = Process.myUid(); + + for (String permission : pkg.getRequestedPermissions()) { ++ final boolean isPregrantedSpecialRuntimePermission = newlyInstalled && ++ SpecialRuntimePermUtils.shouldAutoGrant(pkg.getPackageName(), userId, permission); ++ + final boolean shouldGrantPermission; + synchronized (mLock) { + final Permission bp = mRegistry.getPermission(permission); +@@ -3662,10 +3677,11 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + && (supportsRuntimePermissions || !bp.isRuntimeOnly()) + && (permissions == null || permissions.contains(permission)); + } +- if (shouldGrantPermission) { ++ ++ if (shouldGrantPermission || isPregrantedSpecialRuntimePermission) { + final int flags = getPermissionFlagsInternal(pkg.getPackageName(), permission, + myUid, userId); +- if (supportsRuntimePermissions || isSpecialRuntimePermission(permission)) { ++ if (supportsRuntimePermissions || isPregrantedSpecialRuntimePermission) { + // Installer cannot change immutable permissions. + if ((flags & immutableFlags) == 0) { + grantRuntimePermissionInternal(pkg.getPackageName(), permission, false, +@@ -5016,7 +5032,8 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + addAllowlistedRestrictedPermissionsInternal(pkg, + params.getAllowlistedRestrictedPermissions(), + FLAG_PERMISSION_WHITELIST_INSTALLER, userId); +- grantRequestedRuntimePermissionsInternal(pkg, params.getGrantedPermissions(), userId); ++ grantRequestedRuntimePermissionsInternal(pkg, params.getGrantedPermissions(), userId, ++ params.isNewlyInstalledInUserId(userId)); + } + } + +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceInternal.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceInternal.java +index 95badb31f324..d17c0697ff7a 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceInternal.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceInternal.java +@@ -22,6 +22,7 @@ import android.annotation.UserIdInt; + import android.app.AppOpsManager; + import android.content.pm.PermissionInfo; + import android.permission.PermissionManagerInternal; ++import android.util.SparseBooleanArray; + + import com.android.server.pm.parsing.pkg.AndroidPackage; + +@@ -322,13 +323,17 @@ public interface PermissionManagerServiceInternal extends PermissionManagerInter + private final List mAllowlistedRestrictedPermissions; + @NonNull + private final int mAutoRevokePermissionsMode; ++ @NonNull ++ private final SparseBooleanArray mNewlyInstalledInUserIds; + + private PackageInstalledParams(@NonNull List grantedPermissions, + @NonNull List allowlistedRestrictedPermissions, +- int autoRevokePermissionsMode) { ++ int autoRevokePermissionsMode, ++ SparseBooleanArray newlyInstalledInUserIds) { + mGrantedPermissions = grantedPermissions; + mAllowlistedRestrictedPermissions = allowlistedRestrictedPermissions; + mAutoRevokePermissionsMode = autoRevokePermissionsMode; ++ mNewlyInstalledInUserIds = newlyInstalledInUserIds; + } + + /** +@@ -360,6 +365,10 @@ public interface PermissionManagerServiceInternal extends PermissionManagerInter + return mAutoRevokePermissionsMode; + } + ++ public boolean isNewlyInstalledInUserId(int userId) { ++ return mNewlyInstalledInUserIds.get(userId, false); ++ } ++ + /** + * Builder class for {@link PackageInstalledParams}. + */ +@@ -370,6 +379,8 @@ public interface PermissionManagerServiceInternal extends PermissionManagerInter + private List mAllowlistedRestrictedPermissions = Collections.emptyList(); + @NonNull + private int mAutoRevokePermissionsMode = AppOpsManager.MODE_DEFAULT; ++ @NonNull ++ private final SparseBooleanArray mNewlyInstalledInUserIds = new SparseBooleanArray(); + + /** + * Set the permissions to be granted. +@@ -419,6 +430,10 @@ public interface PermissionManagerServiceInternal extends PermissionManagerInter + mAutoRevokePermissionsMode = autoRevokePermissionsMode; + } + ++ public void setNewlyInstalledInUserId(int userId) { ++ mNewlyInstalledInUserIds.put(userId, true); ++ } ++ + /** + * Build a new instance of {@link PackageInstalledParams}. + * +@@ -427,7 +442,8 @@ public interface PermissionManagerServiceInternal extends PermissionManagerInter + @NonNull + public PackageInstalledParams build() { + return new PackageInstalledParams(mGrantedPermissions, +- mAllowlistedRestrictedPermissions, mAutoRevokePermissionsMode); ++ mAllowlistedRestrictedPermissions, mAutoRevokePermissionsMode, ++ mNewlyInstalledInUserIds); + } + } + } diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-12.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-12.patch new file mode 100644 index 00000000..d4f7e127 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-12.patch @@ -0,0 +1,33 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Sun, 16 Oct 2022 17:13:03 +0300 +Subject: [PATCH] srt permissions: don't auto-revoke from "hidden" packages + +Special runtime permissions are auto-revoked in users that don't have the package installed, as a +workaround to a bug in previous OS versions that granted these permissions automatically in all +user profiles, including the ones that don't have this package installed, which interfered with +configurable auto-grants. + +PackageUserStateUtils.isAvailable() is not the right check for this, it returns false for apps +which are "hidden" with DevicePolicyManager#setApplicationHidden(). This method is used by work +profile managers (in particular, Shelter) to implement "app freezing" functionality. + +This led to special runtime permission being auto-revoked from "hidden" packages after OS reboot +and in a few other cases. +--- + .../server/pm/permission/PermissionManagerServiceImpl.java | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +index 0fcd067142f5..d546ee0db05f 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +@@ -2613,7 +2613,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + synchronized (mLock) { + for (final int userId : userIds) { + final boolean isNotInstalledUserApp = !ps.isSystem() +- && !PackageUserStateUtils.isAvailable(ps.getUserStateOrDefault(userId), 0); ++ && !ps.getUserStateOrDefault(userId).isInstalled(); + + final UserPermissionState userState = mState.getOrCreateUserState(userId); + final UidPermissionState uidState = userState.getOrCreateUidState(ps.getAppId()); diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-13.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-13.patch new file mode 100644 index 00000000..89951fc4 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-13.patch @@ -0,0 +1,144 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Fri, 7 Oct 2022 20:47:48 +0300 +Subject: [PATCH] PackageInstallerUI: an option to skip auto-grant of INTERNET + permission + +--- + .../res/layout/install_content_view.xml | 25 ++++++++++--- + .../PackageInstaller/res/values/strings.xml | 2 ++ + .../PackageInstallerActivity.java | 35 +++++++++++++++++++ + 3 files changed, 58 insertions(+), 4 deletions(-) + +diff --git a/packages/PackageInstaller/res/layout/install_content_view.xml b/packages/PackageInstaller/res/layout/install_content_view.xml +index 2ecd2d55ac71..4db24fffd7ea 100644 +--- a/packages/PackageInstaller/res/layout/install_content_view.xml ++++ b/packages/PackageInstaller/res/layout/install_content_view.xml +@@ -70,13 +70,30 @@ + + + +- ++ android:orientation="vertical" ++ android:visibility="invisible"> ++ ++ ++ ++ ++ ++ + + + Successfully installed \u201c%1$s\u201d ++ ++ Allow Network permission + +diff --git a/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java b/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java +index 10eefebadeff..7ecd02e47852 100644 +--- a/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java ++++ b/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java +@@ -44,16 +44,19 @@ import android.content.pm.PackageManager.NameNotFoundException; + import android.net.Uri; + import android.os.Bundle; + import android.os.Process; ++import android.os.RemoteException; + import android.os.UserManager; + import android.provider.Settings; + import android.util.Log; + import android.view.View; + import android.widget.Button; ++import android.widget.CheckBox; + + import com.android.internal.app.AlertActivity; + + import java.io.File; + import java.util.ArrayList; ++import java.util.Arrays; + import java.util.List; + + /** +@@ -132,6 +135,8 @@ public class PackageInstallerActivity extends AlertActivity { + private boolean mPermissionResultWasSet; + private boolean mAllowNextOnPause; + ++ private CheckBox mGrantInternetPermission; ++ + private void startInstallConfirm() { + View viewToEnable; + +@@ -141,6 +146,14 @@ public class PackageInstallerActivity extends AlertActivity { + } else { + // This is a new application with no permissions. + viewToEnable = requireViewById(R.id.install_confirm_question); ++ ++ if (mPkgInfo != null) { ++ String[] perms = mPkgInfo.requestedPermissions; ++ if (perms != null && Arrays.asList(perms).contains(Manifest.permission.INTERNET)) { ++ mGrantInternetPermission = requireViewById(R.id.install_allow_INTERNET_permission); ++ mGrantInternetPermission.setVisibility(View.VISIBLE); ++ } ++ } + } + + viewToEnable.setVisibility(View.VISIBLE); +@@ -438,6 +451,8 @@ public class PackageInstallerActivity extends AlertActivity { + mAlert.setButton(DialogInterface.BUTTON_POSITIVE, getString(R.string.install), + (ignored, ignored2) -> { + if (mOk.isEnabled()) { ++ handleSpecialRuntimePermissionAutoGrants(); ++ + if (mSessionId != -1) { + mInstaller.setPermissionsResult(mSessionId, true); + mPermissionResultWasSet = true; +@@ -894,4 +909,24 @@ public class PackageInstallerActivity extends AlertActivity { + getActivity().finish(); + } + } ++ ++ void handleSpecialRuntimePermissionAutoGrants() { ++ var skipPermissionAutoGrants = new ArrayList(); ++ ++ if (mGrantInternetPermission != null) { ++ if (!mGrantInternetPermission.isChecked()) { ++ skipPermissionAutoGrants.add(Manifest.permission.INTERNET); ++ } ++ } ++ ++ var pm = AppGlobals.getPackageManager(); ++ var pkgName = mPkgInfo.packageName; ++ int userId = getUserId(); ++ try { ++ pm.skipSpecialRuntimePermissionAutoGrantsForPackage(pkgName, ++ userId, skipPermissionAutoGrants); ++ } catch (RemoteException e) { ++ throw e.rethrowFromSystemServer(); ++ } ++ } + } diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-2.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-2.patch new file mode 100644 index 00000000..b5ed2076 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-2.patch @@ -0,0 +1,81 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Micay +Date: Sun, 17 Mar 2019 17:59:15 +0200 +Subject: [PATCH] make INTERNET into a special runtime permission + +Ported from 12: a980a4c3d6b6906eb0ee5fb07ca4cf0bae052d00 +--- + core/api/current.txt | 1 + + core/res/AndroidManifest.xml | 10 +++++++++- + core/res/res/values/strings.xml | 5 +++++ + .../pm/permission/PermissionManagerServiceImpl.java | 2 +- + 4 files changed, 16 insertions(+), 2 deletions(-) + +diff --git a/core/api/current.txt b/core/api/current.txt +index c8a43db2f9c2..f229b6e25126 100644 +--- a/core/api/current.txt ++++ b/core/api/current.txt +@@ -225,6 +225,7 @@ package android { + field public static final String LOCATION = "android.permission-group.LOCATION"; + field public static final String MICROPHONE = "android.permission-group.MICROPHONE"; + field public static final String NEARBY_DEVICES = "android.permission-group.NEARBY_DEVICES"; ++ field public static final String NETWORK = "android.permission-group.NETWORK"; + field public static final String NOTIFICATIONS = "android.permission-group.NOTIFICATIONS"; + field public static final String PHONE = "android.permission-group.PHONE"; + field public static final String READ_MEDIA_AURAL = "android.permission-group.READ_MEDIA_AURAL"; +diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml +index 6e48de5ba31f..371a036e284a 100644 +--- a/core/res/AndroidManifest.xml ++++ b/core/res/AndroidManifest.xml +@@ -1971,13 +1971,21 @@ + + + ++ ++ ++ + + ++ android:protectionLevel="dangerous|instant" /> + + + show notifications + ++ ++ Network ++ ++ access the network ++ + + Retrieve window content + +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +index 1d974b980f6e..7c76d55d7ae4 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +@@ -2483,7 +2483,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + } + + public static boolean isSpecialRuntimePermission(final String permission) { +- return false; ++ return Manifest.permission.INTERNET.equals(permission); + } + + /** diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-3.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-3.patch new file mode 100644 index 00000000..ba580a24 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-3.patch @@ -0,0 +1,113 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Daniel Micay +Date: Sat, 7 Oct 2017 22:54:42 +0300 +Subject: [PATCH] add special runtime permission for other sensors + +Ported from 12: 9d5a62ed573bc3c7be8b19445b372fed13533d0e +--- + core/api/current.txt | 2 ++ + core/res/AndroidManifest.xml | 12 ++++++++++++ + core/res/res/values/strings.xml | 12 ++++++++++++ + .../pm/permission/PermissionManagerServiceImpl.java | 2 +- + .../server/pm/pkg/parsing/ParsingPackageUtils.java | 2 ++ + 5 files changed, 29 insertions(+), 1 deletion(-) + +diff --git a/core/api/current.txt b/core/api/current.txt +index f229b6e25126..773d77422d9f 100644 +--- a/core/api/current.txt ++++ b/core/api/current.txt +@@ -122,6 +122,7 @@ package android { + field public static final String NFC = "android.permission.NFC"; + field public static final String NFC_PREFERRED_PAYMENT_INFO = "android.permission.NFC_PREFERRED_PAYMENT_INFO"; + field public static final String NFC_TRANSACTION_EVENT = "android.permission.NFC_TRANSACTION_EVENT"; ++ field public static final String OTHER_SENSORS = "android.permission.OTHER_SENSORS"; + field public static final String OVERRIDE_WIFI_CONFIG = "android.permission.OVERRIDE_WIFI_CONFIG"; + field public static final String PACKAGE_USAGE_STATS = "android.permission.PACKAGE_USAGE_STATS"; + field @Deprecated public static final String PERSISTENT_ACTIVITY = "android.permission.PERSISTENT_ACTIVITY"; +@@ -227,6 +228,7 @@ package android { + field public static final String NEARBY_DEVICES = "android.permission-group.NEARBY_DEVICES"; + field public static final String NETWORK = "android.permission-group.NETWORK"; + field public static final String NOTIFICATIONS = "android.permission-group.NOTIFICATIONS"; ++ field public static final String OTHER_SENSORS = "android.permission-group.OTHER_SENSORS"; + field public static final String PHONE = "android.permission-group.PHONE"; + field public static final String READ_MEDIA_AURAL = "android.permission-group.READ_MEDIA_AURAL"; + field public static final String READ_MEDIA_VISUAL = "android.permission-group.READ_MEDIA_VISUAL"; +diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml +index 371a036e284a..eb64b68836f4 100644 +--- a/core/res/AndroidManifest.xml ++++ b/core/res/AndroidManifest.xml +@@ -1732,6 +1732,18 @@ + android:protectionLevel="dangerous|instant" /> + + ++ ++ ++ ++ + + + +diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml +index 42922a094cd7..b153a36f65db 100644 +--- a/core/res/res/values/strings.xml ++++ b/core/res/res/values/strings.xml +@@ -931,6 +931,11 @@ + + show notifications + ++ ++ Sensors ++ ++ access sensor data about orientation, movement, etc. ++ + + Network + +@@ -1261,6 +1266,13 @@ + + Allows the app to access body sensor data, such as heart rate, temperature, and blood oxygen percentage, while the app is in the background. + ++ ++ access sensors (like the compass) ++ ++ ++ Allows the app to access data from sensors ++ monitoring orientation, movement, vibration (including low frequency sound) and environmental data ++ + + Read calendar events and details + +diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +index 7c76d55d7ae4..da832f59671d 100644 +--- a/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java ++++ b/services/core/java/com/android/server/pm/permission/PermissionManagerServiceImpl.java +@@ -2483,7 +2483,7 @@ public class PermissionManagerServiceImpl implements PermissionManagerServiceInt + } + + public static boolean isSpecialRuntimePermission(final String permission) { +- return Manifest.permission.INTERNET.equals(permission); ++ return Manifest.permission.INTERNET.equals(permission) || Manifest.permission.OTHER_SENSORS.equals(permission); + } + + /** +diff --git a/services/core/java/com/android/server/pm/pkg/parsing/ParsingPackageUtils.java b/services/core/java/com/android/server/pm/pkg/parsing/ParsingPackageUtils.java +index 9bfb40fe11f7..ca3b9e5bda95 100644 +--- a/services/core/java/com/android/server/pm/pkg/parsing/ParsingPackageUtils.java ++++ b/services/core/java/com/android/server/pm/pkg/parsing/ParsingPackageUtils.java +@@ -2203,6 +2203,8 @@ public class ParsingPackageUtils { + + pkg.setHasDomainUrls(hasDomainURLs(pkg)); + ++ pkg.addUsesPermission(new ParsedUsesPermissionImpl(android.Manifest.permission.OTHER_SENSORS, 0)); ++ + return input.success(pkg); + } + diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-4.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-4.patch new file mode 100644 index 00000000..8c916552 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-4.patch @@ -0,0 +1,118 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Sun, 31 Jul 2022 18:24:34 +0300 +Subject: [PATCH] infrastructure for spoofing self permission checks + +--- + .../app/ApplicationPackageManager.java | 13 ++++++++- + core/java/android/app/ContextImpl.java | 18 ++++++++++-- + .../content/pm/AppPermissionUtils.java | 29 +++++++++++++++++++ + 3 files changed, 57 insertions(+), 3 deletions(-) + create mode 100644 core/java/android/content/pm/AppPermissionUtils.java + +diff --git a/core/java/android/app/ApplicationPackageManager.java b/core/java/android/app/ApplicationPackageManager.java +index 475e0f4cb05b..73dcd39a2837 100644 +--- a/core/java/android/app/ApplicationPackageManager.java ++++ b/core/java/android/app/ApplicationPackageManager.java +@@ -47,6 +47,7 @@ import android.content.IntentFilter; + import android.content.IntentSender; + import android.content.pm.ActivityInfo; + import android.content.pm.ApkChecksum; ++import android.content.pm.AppPermissionUtils; + import android.content.pm.ApplicationInfo; + import android.content.pm.ChangedPackages; + import android.content.pm.Checksum; +@@ -835,7 +836,17 @@ public class ApplicationPackageManager extends PackageManager { + + @Override + public int checkPermission(String permName, String pkgName) { +- return PermissionManager.checkPackageNamePermission(permName, pkgName, getUserId()); ++ int res = PermissionManager.checkPackageNamePermission(permName, pkgName, getUserId()); ++ ++ if (res != PERMISSION_GRANTED) { ++ if (pkgName.equals(ActivityThread.currentPackageName()) ++ && AppPermissionUtils.shouldSpoofSelfCheck(permName)) ++ { ++ return PERMISSION_GRANTED; ++ } ++ } ++ ++ return res; + } + + @Override +diff --git a/core/java/android/app/ContextImpl.java b/core/java/android/app/ContextImpl.java +index 6d982ced385c..b50cd115382d 100644 +--- a/core/java/android/app/ContextImpl.java ++++ b/core/java/android/app/ContextImpl.java +@@ -45,6 +45,7 @@ import android.content.ReceiverCallNotAllowedException; + import android.content.ServiceConnection; + import android.content.SharedPreferences; + import android.content.pm.ActivityInfo; ++import android.content.pm.AppPermissionUtils; + import android.content.pm.ApplicationInfo; + import android.content.pm.IPackageManager; + import android.content.pm.PackageManager; +@@ -2165,12 +2166,25 @@ class ContextImpl extends Context { + if (permission == null) { + throw new IllegalArgumentException("permission is null"); + } ++ ++ final boolean selfCheck = pid == android.os.Process.myPid() && uid == android.os.Process.myUid(); ++ + if (mParams.isRenouncedPermission(permission) +- && pid == android.os.Process.myPid() && uid == android.os.Process.myUid()) { ++ && selfCheck) { + Log.v(TAG, "Treating renounced permission " + permission + " as denied"); + return PERMISSION_DENIED; + } +- return PermissionManager.checkPermission(permission, pid, uid); ++ int res = PermissionManager.checkPermission(permission, pid, uid); ++ ++ if (res != PERMISSION_GRANTED) { ++ if (selfCheck) { ++ if (AppPermissionUtils.shouldSpoofSelfCheck(permission)) { ++ return PERMISSION_GRANTED; ++ } ++ } ++ } ++ ++ return res; + } + + /** @hide */ +diff --git a/core/java/android/content/pm/AppPermissionUtils.java b/core/java/android/content/pm/AppPermissionUtils.java +new file mode 100644 +index 000000000000..7dc20eec8485 +--- /dev/null ++++ b/core/java/android/content/pm/AppPermissionUtils.java +@@ -0,0 +1,29 @@ ++/* ++ * Copyright (C) 2022 GrapheneOS ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package android.content.pm; ++ ++import android.Manifest; ++ ++/** @hide */ ++public class AppPermissionUtils { ++ ++ // android.app.ApplicationPackageManager#checkPermission(String permName, String pkgName) ++ // android.app.ContextImpl#checkPermission(String permission, int pid, int uid) ++ public static boolean shouldSpoofSelfCheck(String permName) { ++ return false; ++ } ++} diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-5.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-5.patch new file mode 100644 index 00000000..536f274e --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-5.patch @@ -0,0 +1,189 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Sun, 31 Jul 2022 18:10:28 +0300 +Subject: [PATCH] app-side infrastructure for special runtime permissions + +--- + core/api/system-current.txt | 3 ++ + .../android/content/pm/IPackageManager.aidl | 2 + + .../pm/SpecialRuntimePermAppUtils.java | 54 +++++++++++++++++++ + .../server/pm/PackageManagerService.java | 19 +++++++ + .../permission/SpecialRuntimePermUtils.java | 46 ++++++++++++++++ + 5 files changed, 124 insertions(+) + create mode 100644 core/java/android/content/pm/SpecialRuntimePermAppUtils.java + create mode 100644 services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java + +diff --git a/core/api/system-current.txt b/core/api/system-current.txt +index 0126199add0c..531b03cd7c0c 100644 +--- a/core/api/system-current.txt ++++ b/core/api/system-current.txt +@@ -3546,6 +3546,9 @@ package android.content.pm { + field @NonNull public static final android.os.Parcelable.Creator CREATOR; + } + ++ public class SpecialRuntimePermAppUtils { ++ } ++ + public final class SuspendDialogInfo implements android.os.Parcelable { + method public int describeContents(); + method public void writeToParcel(android.os.Parcel, int); +diff --git a/core/java/android/content/pm/IPackageManager.aidl b/core/java/android/content/pm/IPackageManager.aidl +index 54d57a1b24d9..0e4ca05f3c1d 100644 +--- a/core/java/android/content/pm/IPackageManager.aidl ++++ b/core/java/android/content/pm/IPackageManager.aidl +@@ -803,4 +803,6 @@ interface IPackageManager { + void setKeepUninstalledPackages(in List packageList); + + boolean canPackageQuery(String sourcePackageName, String targetPackageName, int userId); ++ ++ int getSpecialRuntimePermissionFlags(String packageName); + } +diff --git a/core/java/android/content/pm/SpecialRuntimePermAppUtils.java b/core/java/android/content/pm/SpecialRuntimePermAppUtils.java +new file mode 100644 +index 000000000000..efd48cb49aa3 +--- /dev/null ++++ b/core/java/android/content/pm/SpecialRuntimePermAppUtils.java +@@ -0,0 +1,54 @@ ++/* ++ * Copyright (C) 2022 GrapheneOS ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package android.content.pm; ++ ++import android.Manifest; ++import android.annotation.SystemApi; ++import android.app.AppGlobals; ++import android.os.Binder; ++import android.os.Process; ++import android.os.RemoteException; ++import android.permission.PermissionManager; ++ ++/** @hide */ ++@SystemApi ++public class SpecialRuntimePermAppUtils { ++ private static final int FLAG_INITED = 1; ++ ++ private static volatile int cachedFlags; ++ ++ private static int getFlags() { ++ int cache = cachedFlags; ++ if (cache != 0) { ++ return cache; ++ } ++ ++ IPackageManager pm = AppGlobals.getPackageManager(); ++ String pkgName = AppGlobals.getInitialPackage(); ++ ++ final long token = Binder.clearCallingIdentity(); // in case this method is called in the system_server ++ try { ++ return (cachedFlags = pm.getSpecialRuntimePermissionFlags(pkgName) | FLAG_INITED); ++ } catch (RemoteException e) { ++ throw e.rethrowFromSystemServer(); ++ } finally { ++ Binder.restoreCallingIdentity(token); ++ } ++ } ++ ++ private SpecialRuntimePermAppUtils() {} ++} +diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java +index a638f8cfcb25..dc20b6ccaa3f 100644 +--- a/services/core/java/com/android/server/pm/PackageManagerService.java ++++ b/services/core/java/com/android/server/pm/PackageManagerService.java +@@ -213,6 +213,7 @@ import com.android.server.pm.permission.LegacyPermissionManagerInternal; + import com.android.server.pm.permission.LegacyPermissionManagerService; + import com.android.server.pm.permission.PermissionManagerService; + import com.android.server.pm.permission.PermissionManagerServiceInternal; ++import com.android.server.pm.permission.SpecialRuntimePermUtils; + import com.android.server.pm.pkg.PackageStateInternal; + import com.android.server.pm.pkg.PackageUserState; + import com.android.server.pm.pkg.PackageUserStateInternal; +@@ -6048,6 +6049,24 @@ public class PackageManagerService implements PackageSender, TestUtilityService + getPerUidReadTimeouts(snapshot) + ).doDump(snapshot, fd, pw, args); + } ++ ++ @Override ++ public int getSpecialRuntimePermissionFlags(String packageName) { ++ final int callingUid = Binder.getCallingUid(); ++ ++ synchronized (mLock) { ++ AndroidPackage pkg = mPackages.get(packageName); ++ if (pkg == null) { ++ throw new IllegalStateException(); ++ } ++ ++ if (UserHandle.getAppId(callingUid) != pkg.getUid()) { // getUid() confusingly returns appId ++ throw new SecurityException(); ++ } ++ ++ return SpecialRuntimePermUtils.getFlags(pkg); ++ } ++ } + } + + private class PackageManagerLocalImpl implements PackageManagerLocal { +diff --git a/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java b/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java +new file mode 100644 +index 000000000000..fe946ff5d5ca +--- /dev/null ++++ b/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java +@@ -0,0 +1,46 @@ ++/* ++ * Copyright (C) 2022 GrapheneOS ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package com.android.server.pm.permission; ++ ++import android.Manifest; ++import android.os.Bundle; ++ ++import com.android.internal.annotations.GuardedBy; ++import com.android.server.pm.parsing.pkg.AndroidPackage; ++import com.android.server.pm.pkg.component.ParsedUsesPermission; ++ ++import static android.content.pm.SpecialRuntimePermAppUtils.*; ++ ++public class SpecialRuntimePermUtils { ++ ++ @GuardedBy("PackageManagerService.mLock") ++ public static int getFlags(AndroidPackage pkg) { ++ int flags = 0; ++ ++ for (ParsedUsesPermission perm : pkg.getUsesPermissions()) { ++ String name = perm.getName(); ++ switch (name) { ++ default: ++ continue; ++ } ++ } ++ ++ return flags; ++ } ++ ++ private SpecialRuntimePermUtils() {} ++} diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-6.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-6.patch new file mode 100644 index 00000000..a80ef54f --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-6.patch @@ -0,0 +1,165 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Sun, 31 Jul 2022 18:00:35 +0300 +Subject: [PATCH] improve compatibility of INTERNET special runtime permission + +There are apps that refuse to work when they detect that INTERNET is revoked, usually because of +a library check that reminds the app developer to add INTERNET uses-permission element to app's +AndroidManifest. +Always report that INTERNET is granted unless the app has + +declaration inside element in its AndroidManifest, or is a system app. +--- + core/api/system-current.txt | 5 +++++ + core/java/android/app/DownloadManager.java | 13 ++++++++++++ + .../content/pm/AppPermissionUtils.java | 7 +++++++ + .../pm/SpecialRuntimePermAppUtils.java | 20 +++++++++++++++++++ + .../permission/SpecialRuntimePermUtils.java | 17 ++++++++++++++++ + 5 files changed, 62 insertions(+) + +diff --git a/core/api/system-current.txt b/core/api/system-current.txt +index 531b03cd7c0c..64115f76caf4 100644 +--- a/core/api/system-current.txt ++++ b/core/api/system-current.txt +@@ -3547,6 +3547,11 @@ package android.content.pm { + } + + public class SpecialRuntimePermAppUtils { ++ method public static boolean awareOfRuntimeInternetPermission(); ++ method public static boolean isInternetCompatEnabled(); ++ method public static boolean requestsInternetPermission(); ++ field public static final int FLAG_AWARE_OF_RUNTIME_INTERNET_PERMISSION = 4; // 0x4 ++ field public static final int FLAG_REQUESTS_INTERNET_PERMISSION = 2; // 0x2 + } + + public final class SuspendDialogInfo implements android.os.Parcelable { +diff --git a/core/java/android/app/DownloadManager.java b/core/java/android/app/DownloadManager.java +index c209660f4197..ee412eb50064 100644 +--- a/core/java/android/app/DownloadManager.java ++++ b/core/java/android/app/DownloadManager.java +@@ -34,6 +34,7 @@ import android.content.Context; + import android.database.Cursor; + import android.database.CursorWrapper; + import android.database.DatabaseUtils; ++import android.database.MatrixCursor; + import android.net.ConnectivityManager; + import android.net.NetworkPolicyManager; + import android.net.Uri; +@@ -53,6 +54,8 @@ import android.util.LongSparseArray; + import android.util.Pair; + import android.webkit.MimeTypeMap; + ++import android.content.pm.SpecialRuntimePermAppUtils; ++ + import java.io.File; + import java.io.FileNotFoundException; + import java.util.ArrayList; +@@ -1123,6 +1126,11 @@ public class DownloadManager { + * calls related to this download. + */ + public long enqueue(Request request) { ++ if (SpecialRuntimePermAppUtils.isInternetCompatEnabled()) { ++ // invalid id (DownloadProvider uses SQLite and returns a row id) ++ return -1; ++ } ++ + ContentValues values = request.toContentValues(mPackageName); + Uri downloadUri = mResolver.insert(Downloads.Impl.CONTENT_URI, values); + long id = Long.parseLong(downloadUri.getLastPathSegment()); +@@ -1170,6 +1178,11 @@ public class DownloadManager { + + /** @hide */ + public Cursor query(Query query, String[] projection) { ++ if (SpecialRuntimePermAppUtils.isInternetCompatEnabled()) { ++ // underlying provider is protected by the INTERNET permission ++ return new MatrixCursor(projection); ++ } ++ + Cursor underlyingCursor = query.runQuery(mResolver, projection, mBaseUri); + if (underlyingCursor == null) { + return null; +diff --git a/core/java/android/content/pm/AppPermissionUtils.java b/core/java/android/content/pm/AppPermissionUtils.java +index 7dc20eec8485..6a96f70dcfcf 100644 +--- a/core/java/android/content/pm/AppPermissionUtils.java ++++ b/core/java/android/content/pm/AppPermissionUtils.java +@@ -24,6 +24,13 @@ public class AppPermissionUtils { + // android.app.ApplicationPackageManager#checkPermission(String permName, String pkgName) + // android.app.ContextImpl#checkPermission(String permission, int pid, int uid) + public static boolean shouldSpoofSelfCheck(String permName) { ++ if (Manifest.permission.INTERNET.equals(permName) ++ && SpecialRuntimePermAppUtils.requestsInternetPermission() ++ && !SpecialRuntimePermAppUtils.awareOfRuntimeInternetPermission()) ++ { ++ return true; ++ } ++ + return false; + } + } +diff --git a/core/java/android/content/pm/SpecialRuntimePermAppUtils.java b/core/java/android/content/pm/SpecialRuntimePermAppUtils.java +index efd48cb49aa3..2f973a585d5c 100644 +--- a/core/java/android/content/pm/SpecialRuntimePermAppUtils.java ++++ b/core/java/android/content/pm/SpecialRuntimePermAppUtils.java +@@ -28,9 +28,29 @@ import android.permission.PermissionManager; + @SystemApi + public class SpecialRuntimePermAppUtils { + private static final int FLAG_INITED = 1; ++ public static final int FLAG_REQUESTS_INTERNET_PERMISSION = 1 << 1; ++ public static final int FLAG_AWARE_OF_RUNTIME_INTERNET_PERMISSION = 1 << 2; + + private static volatile int cachedFlags; + ++ private static boolean hasInternetPermission() { ++ // checkSelfPermission() is spoofed, query the underlying API directly ++ return PermissionManager.checkPermission(Manifest.permission.INTERNET, Process.myPid(), Process.myUid()) ++ == PackageManager.PERMISSION_GRANTED; ++ } ++ ++ public static boolean requestsInternetPermission() { ++ return (getFlags() & FLAG_REQUESTS_INTERNET_PERMISSION) != 0; ++ } ++ ++ public static boolean awareOfRuntimeInternetPermission() { ++ return (getFlags() & FLAG_AWARE_OF_RUNTIME_INTERNET_PERMISSION) != 0; ++ } ++ ++ public static boolean isInternetCompatEnabled() { ++ return !hasInternetPermission() && requestsInternetPermission() && !awareOfRuntimeInternetPermission(); ++ } ++ + private static int getFlags() { + int cache = cachedFlags; + if (cache != 0) { +diff --git a/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java b/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java +index fe946ff5d5ca..6f5cabb8a8fc 100644 +--- a/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java ++++ b/services/core/java/com/android/server/pm/permission/SpecialRuntimePermUtils.java +@@ -34,11 +34,28 @@ public class SpecialRuntimePermUtils { + for (ParsedUsesPermission perm : pkg.getUsesPermissions()) { + String name = perm.getName(); + switch (name) { ++ case Manifest.permission.INTERNET: ++ flags |= FLAG_REQUESTS_INTERNET_PERMISSION; ++ continue; + default: + continue; + } + } + ++ if ((flags & FLAG_REQUESTS_INTERNET_PERMISSION) != 0) { ++ if (pkg.isSystem()) { ++ flags |= FLAG_AWARE_OF_RUNTIME_INTERNET_PERMISSION; ++ } else { ++ Bundle metadata = pkg.getMetaData(); ++ if (metadata != null) { ++ String key = Manifest.permission.INTERNET + ".mode"; ++ if ("runtime".equals(metadata.getString(key))) { ++ flags |= FLAG_AWARE_OF_RUNTIME_INTERNET_PERMISSION; ++ } ++ } ++ } ++ } ++ + return flags; + } + diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-7.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-7.patch new file mode 100644 index 00000000..fea5ec44 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-7.patch @@ -0,0 +1,48 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Wed, 17 Aug 2022 10:12:42 +0300 +Subject: [PATCH] mark UserHandle#get{Uid, UserId} as module SystemApi + +Needed by packages_modules_Connectivity -> +"enforce INTERNET permission per-uid instead of per-appId". +--- + core/api/module-lib-current.txt | 5 +++++ + core/java/android/os/UserHandle.java | 2 ++ + 2 files changed, 7 insertions(+) + +diff --git a/core/api/module-lib-current.txt b/core/api/module-lib-current.txt +index b9522163b5d0..5e8bfd4dff61 100644 +--- a/core/api/module-lib-current.txt ++++ b/core/api/module-lib-current.txt +@@ -392,6 +392,11 @@ package android.os { + field public static final long TRACE_TAG_NETWORK = 2097152L; // 0x200000L + } + ++ public final class UserHandle implements android.os.Parcelable { ++ method public static int getUid(int, int); ++ method public static int getUserId(int); ++ } ++ + } + + package android.os.storage { +diff --git a/core/java/android/os/UserHandle.java b/core/java/android/os/UserHandle.java +index 3d5abb3b8a2f..e6326bb0ad8b 100644 +--- a/core/java/android/os/UserHandle.java ++++ b/core/java/android/os/UserHandle.java +@@ -275,6 +275,7 @@ public final class UserHandle implements Parcelable { + * Returns the user id for a given uid. + * @hide + */ ++ @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES) + @UnsupportedAppUsage + @TestApi + public static @UserIdInt int getUserId(int uid) { +@@ -365,6 +366,7 @@ public final class UserHandle implements Parcelable { + * Returns the uid that is composed from the userId and the appId. + * @hide + */ ++ @SystemApi(client = SystemApi.Client.MODULE_LIBRARIES) + @UnsupportedAppUsage + @TestApi + public static int getUid(@UserIdInt int userId, @AppIdInt int appId) { diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-8.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-8.patch new file mode 100644 index 00000000..82820369 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-8.patch @@ -0,0 +1,38 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Tue, 30 Aug 2022 12:37:03 +0300 +Subject: [PATCH] improve compatibility with revoked INTERNET in + DownloadManager + +--- + core/java/android/app/DownloadManager.java | 10 ++++++++++ + 1 file changed, 10 insertions(+) + +diff --git a/core/java/android/app/DownloadManager.java b/core/java/android/app/DownloadManager.java +index ee412eb50064..f1bda3d1a81f 100644 +--- a/core/java/android/app/DownloadManager.java ++++ b/core/java/android/app/DownloadManager.java +@@ -1163,6 +1163,11 @@ public class DownloadManager { + * @return the number of downloads actually removed + */ + public int remove(long... ids) { ++ if (SpecialRuntimePermAppUtils.isInternetCompatEnabled()) { ++ // underlying provider is protected by the INTERNET permission ++ return 0; ++ } ++ + return markRowDeleted(ids); + } + +@@ -1589,6 +1594,11 @@ public class DownloadManager { + throw new IllegalArgumentException(" invalid value for param: totalBytes"); + } + ++ if (SpecialRuntimePermAppUtils.isInternetCompatEnabled()) { ++ // underlying provider is protected by the INTERNET permission ++ return -1; ++ } ++ + // if there is already an entry with the given path name in downloads.db, return its id + Request request; + if (uri != null) { diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-9.patch b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-9.patch new file mode 100644 index 00000000..f99cd354 --- /dev/null +++ b/Patches/LineageOS-20.0/android_frameworks_base/0013-Special_Permissions-9.patch @@ -0,0 +1,36 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Dmitry Muhomor +Date: Thu, 15 Sep 2022 13:58:34 +0300 +Subject: [PATCH] ignore pid when spoofing permission checks + +Permissions are enforced per-uid, checking pid may break spoofing for multi-process apps. +--- + core/java/android/app/ContextImpl.java | 8 +++----- + 1 file changed, 3 insertions(+), 5 deletions(-) + +diff --git a/core/java/android/app/ContextImpl.java b/core/java/android/app/ContextImpl.java +index b50cd115382d..58d3702c7356 100644 +--- a/core/java/android/app/ContextImpl.java ++++ b/core/java/android/app/ContextImpl.java +@@ -2166,18 +2166,16 @@ class ContextImpl extends Context { + if (permission == null) { + throw new IllegalArgumentException("permission is null"); + } +- +- final boolean selfCheck = pid == android.os.Process.myPid() && uid == android.os.Process.myUid(); +- + if (mParams.isRenouncedPermission(permission) +- && selfCheck) { ++ && pid == android.os.Process.myPid() && uid == android.os.Process.myUid()) { + Log.v(TAG, "Treating renounced permission " + permission + " as denied"); + return PERMISSION_DENIED; + } ++ + int res = PermissionManager.checkPermission(permission, pid, uid); + + if (res != PERMISSION_GRANTED) { +- if (selfCheck) { ++ if (uid == android.os.Process.myUid()) { + if (AppPermissionUtils.shouldSpoofSelfCheck(permission)) { + return PERMISSION_GRANTED; + } diff --git a/Patches/LineageOS-20.0/android_frameworks_base/0026-Crash_Details.patch b/Patches/LineageOS-20.0/android_frameworks_base/0026-Crash_Details.patch index c833f802..fce40a94 100644 --- a/Patches/LineageOS-20.0/android_frameworks_base/0026-Crash_Details.patch +++ b/Patches/LineageOS-20.0/android_frameworks_base/0026-Crash_Details.patch @@ -110,10 +110,10 @@ index c3b149a1e295..a47b82018377 100644