Add permission flags persistence and drop invalid entries.

We now pass the entire state when reading/writing, so that the read code can inspect the app ID or package states in the system and drop entries that don't exist. Bug: 182523293 Test: presubmit Change-Id: I4d8b0f2643b58c7e47dc333e9883beecf4a45d55
2022-12-15 00:13:11 -08:00
parent 9043314199
commit 1930303513
8 changed files with 185 additions and 67 deletions
--- a/services/permission/java/com/android/server/permission/access/AccessPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/AccessPersistence.kt
@@ -33,24 +33,23 @@ class AccessPersistence(
    private val policy: AccessPolicy
 ) {
    fun read(state: AccessState) {
-        readSystemState(state.systemState)
-        val userStates = state.userStates
+        readSystemState(state)
        state.systemState.userIds.forEachIndexed { _, userId ->
-            readUserState(userId, userStates[userId])
+            readUserState(state, userId)
        }
    }

-    private fun readSystemState(systemState: SystemState) {
+    private fun readSystemState(state: AccessState) {
        systemFile.parse {
            // This is the canonical way to call an extension function in a different class.
            // TODO(b/259469752): Use context receiver for this when it becomes stable.
-            with(policy) { parseSystemState(systemState) }
+            with(policy) { parseSystemState(state) }
        }
    }

-    private fun readUserState(userId: Int, userState: UserState) {
+    private fun readUserState(state: AccessState, userId: Int) {
        getUserFile(userId).parse {
-            with(policy) { parseUserState(userId, userState) }
+            with(policy) { parseUserState(state, userId) }
        }
    }

@@ -65,30 +64,30 @@ class AccessPersistence(
    }

    fun write(state: AccessState) {
-        writeState(state.systemState, ::writeSystemState)
+        writeState(state.systemState) { writeSystemState(state) }
        state.userStates.forEachIndexed { _, userId, userState ->
-            writeState(userState) { writeUserState(userId, it) }
+            writeState(userState) { writeUserState(state, userId) }
        }
    }

-    private inline fun <T : WritableState> writeState(state: T, write: (T) -> Unit) {
+    private inline fun <T : WritableState> writeState(state: T, write: () -> Unit) {
        when (val writeMode = state.writeMode) {
            WriteMode.NONE -> {}
-            WriteMode.SYNC -> write(state)
+            WriteMode.SYNC -> write()
            WriteMode.ASYNC -> TODO()
            else -> error(writeMode)
        }
    }

-    private fun writeSystemState(systemState: SystemState) {
+    private fun writeSystemState(state: AccessState) {
        systemFile.serialize {
-            with(policy) { serializeSystemState(systemState) }
+            with(policy) { serializeSystemState(state) }
        }
    }

-    private fun writeUserState(userId: Int, userState: UserState) {
+    private fun writeUserState(state: AccessState, userId: Int) {
        getUserFile(userId).serialize {
-            with(policy) { serializeUserState(userId, userState) }
+            with(policy) { serializeUserState(state, userId) }
        }
    }

--- a/services/permission/java/com/android/server/permission/access/AccessPolicy.kt
+++ b/services/permission/java/com/android/server/permission/access/AccessPolicy.kt
@@ -202,13 +202,13 @@ class AccessPolicy private constructor(
        }
    }

-    fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {
+    fun BinaryXmlPullParser.parseSystemState(state: AccessState) {
        forEachTag {
            when (tagName) {
                TAG_ACCESS -> {
                    forEachTag {
                        forEachSchemePolicy {
-                            with(it) { parseSystemState(systemState) }
+                            with(it) { parseSystemState(state) }
                        }
                    }
                }
@@ -217,21 +217,21 @@ class AccessPolicy private constructor(
        }
    }

-    fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {
+    fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {
        tag(TAG_ACCESS) {
            forEachSchemePolicy {
-                with(it) { serializeSystemState(systemState) }
+                with(it) { serializeSystemState(state) }
            }
        }
    }

-    fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
+    fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
        forEachTag {
            when (tagName) {
                TAG_ACCESS -> {
                    forEachTag {
                        forEachSchemePolicy {
-                            with(it) { parseUserState(userId, userState) }
+                            with(it) { parseUserState(state, userId) }
                        }
                    }
                }
@@ -245,10 +245,10 @@ class AccessPolicy private constructor(
        }
    }

-    fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
+    fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
        tag(TAG_ACCESS) {
            forEachSchemePolicy {
-                with(it) { serializeUserState(userId, userState) }
+                with(it) { serializeUserState(state, userId) }
            }
        }
    }
@@ -305,11 +305,11 @@ abstract class SchemePolicy {

    open fun MutateStateScope.onPackageUninstalled(packageName: String, appId: Int, userId: Int) {}

-    open fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {}
+    open fun BinaryXmlPullParser.parseSystemState(state: AccessState) {}

-    open fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {}
+    open fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {}

-    open fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {}
+    open fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {}

-    open fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {}
+    open fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {}
 }
--- a/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPersistence.kt
@@ -19,7 +19,7 @@ package com.android.server.permission.access.appop
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
-import com.android.server.permission.access.UserState
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attributeInt
 import com.android.server.permission.access.util.attributeInterned
@@ -30,9 +30,9 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName

 abstract class BaseAppOpPersistence {
-    abstract fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState)
+    abstract fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int)

-    abstract fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState)
+    abstract fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int)

    protected fun BinaryXmlPullParser.parseAppOps(appOpModes: IndexedMap<String, Int>) {
        forEachTag {
@@ -67,7 +67,7 @@ abstract class BaseAppOpPersistence {

        private const val TAG_APP_OP = "app-op"

-        private const val ATTR_NAME = "name"
        private const val ATTR_MODE = "mode"
+        private const val ATTR_NAME = "name"
    }
 }
--- a/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPolicy.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPolicy.kt
@@ -18,9 +18,9 @@ package com.android.server.permission.access.appop

 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.AppOpUri
 import com.android.server.permission.access.SchemePolicy
-import com.android.server.permission.access.UserState

 abstract class BaseAppOpPolicy(
    private val persistence: BaseAppOpPersistence
@@ -28,11 +28,11 @@ abstract class BaseAppOpPolicy(
    override val objectScheme: String
        get() = AppOpUri.SCHEME

-    override fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
-        with(persistence) { this@parseUserState.parseUserState(userId, userState) }
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@parseUserState.parseUserState(state, userId) }
    }

-    override fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
-        with(persistence) { this@serializeUserState.serializeUserState(userId, userState) }
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@serializeUserState.serializeUserState(state, userId) }
    }
 }
--- a/services/permission/java/com/android/server/permission/access/appop/PackageAppOpPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/PackageAppOpPersistence.kt
@@ -19,6 +19,7 @@ package com.android.server.permission.access.appop
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.UserState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attributeInterned
@@ -28,20 +29,28 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName

 class PackageAppOpPersistence : BaseAppOpPersistence() {
-    override fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
        when (tagName) {
-            TAG_PACKAGE_APP_OPS -> parsePackageAppOps(userState)
+            TAG_PACKAGE_APP_OPS -> parsePackageAppOps(state, userId)
            else -> {}
        }
    }

-    private fun BinaryXmlPullParser.parsePackageAppOps(userState: UserState) {
+    private fun BinaryXmlPullParser.parsePackageAppOps(state: AccessState, userId: Int) {
+        val userState = state.userStates[userId]
        forEachTag {
            when (tagName) {
                TAG_PACKAGE -> parsePackage(userState)
                else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing app-op state")
            }
        }
+        userState.packageAppOpModes.retainAllIndexed { _, packageName, _ ->
+            val hasPackage = packageName in state.systemState.packageStates
+            if (!hasPackage) {
+                Log.w(LOG_TAG, "Dropping unknown package $packageName when parsing app-op state")
+            }
+            hasPackage
+        }
    }

    private fun BinaryXmlPullParser.parsePackage(userState: UserState) {
@@ -51,8 +60,8 @@ class PackageAppOpPersistence : BaseAppOpPersistence() {
        parseAppOps(appOpModes)
    }

-    override fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
-        serializePackageAppOps(userState)
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        serializePackageAppOps(state.userStates[userId])
    }

    private fun BinaryXmlSerializer.serializePackageAppOps(userState: UserState) {
@@ -76,8 +85,8 @@ class PackageAppOpPersistence : BaseAppOpPersistence() {
    companion object {
        private val LOG_TAG = PackageAppOpPersistence::class.java.simpleName

-        private const val TAG_PACKAGE_APP_OPS = "package-app-ops"
        private const val TAG_PACKAGE = "package"
+        private const val TAG_PACKAGE_APP_OPS = "package-app-ops"

        private const val ATTR_NAME = "name"
    }
--- a/services/permission/java/com/android/server/permission/access/appop/UidAppOpPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/UidAppOpPersistence.kt
@@ -19,6 +19,7 @@ package com.android.server.permission.access.appop
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.UserState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attributeInt
@@ -28,44 +29,55 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName

 class UidAppOpPersistence : BaseAppOpPersistence() {
-    override fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
        when (tagName) {
-            TAG_UID_APP_OPS -> parseUidAppOps(userState)
+            TAG_UID_APP_OPS -> parseUidAppOps(state, userId)
            else -> {}
        }
    }

-    private fun BinaryXmlPullParser.parseUidAppOps(userState: UserState) {
+    private fun BinaryXmlPullParser.parseUidAppOps(state: AccessState, userId: Int) {
+        val userState = state.userStates[userId]
        forEachTag {
            when (tagName) {
-                TAG_UID -> parseUid(userState)
+                TAG_APP_ID -> parseAppId(userState)
                else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing app-op state")
            }
        }
+        userState.uidAppOpModes.retainAllIndexed { _, appId, _ ->
+            val hasAppId = appId in state.systemState.appIds
+            if (!hasAppId) {
+                Log.w(LOG_TAG, "Dropping unknown app ID $appId when parsing app-op state")
+            }
+            hasAppId
+        }
    }

-    private fun BinaryXmlPullParser.parseUid(userState: UserState) {
-        val uid = getAttributeIntOrThrow(ATTR_UID)
+    private fun BinaryXmlPullParser.parseAppId(userState: UserState) {
+        val appId = getAttributeIntOrThrow(ATTR_ID)
        val appOpModes = IndexedMap<String, Int>()
-        userState.uidAppOpModes[uid] = appOpModes
+        userState.uidAppOpModes[appId] = appOpModes
        parseAppOps(appOpModes)
    }

-    override fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
-        serializeUidAppOps(userState)
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        serializeUidAppOps(state.userStates[userId])
    }

    private fun BinaryXmlSerializer.serializeUidAppOps(userState: UserState) {
        tag(TAG_UID_APP_OPS) {
-            userState.uidAppOpModes.forEachIndexed { _, uid, appOpModes ->
-                serializeUid(uid, appOpModes)
+            userState.uidAppOpModes.forEachIndexed { _, appId, appOpModes ->
+                serializeAppId(appId, appOpModes)
            }
        }
    }

-    private fun BinaryXmlSerializer.serializeUid(uid: Int, appOpModes: IndexedMap<String, Int>) {
-        tag(TAG_UID) {
-            attributeInt(ATTR_UID, uid)
+    private fun BinaryXmlSerializer.serializeAppId(
+        appId: Int,
+        appOpModes: IndexedMap<String, Int>
+    ) {
+        tag(TAG_APP_ID) {
+            attributeInt(ATTR_ID, appId)
            serializeAppOps(appOpModes)
        }
    }
@@ -73,9 +85,9 @@ class UidAppOpPersistence : BaseAppOpPersistence() {
    companion object {
        private val LOG_TAG = UidAppOpPersistence::class.java.simpleName

+        private const val TAG_APP_ID = "app-id"
        private const val TAG_UID_APP_OPS = "uid-app-ops"
-        private const val TAG_UID = "uid"

-        private const val ATTR_UID = "uid"
+        private const val ATTR_ID = "id"
    }
 }
--- a/services/permission/java/com/android/server/permission/access/permission/UidPermissionPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/permission/UidPermissionPersistence.kt
@@ -20,7 +20,8 @@ import android.content.pm.PermissionInfo
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
-import com.android.server.permission.access.SystemState
+import com.android.server.permission.access.AccessState
+import com.android.server.permission.access.UserState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attribute
 import com.android.server.permission.access.util.attributeInt
@@ -37,7 +38,8 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName

 class UidPermissionPersistence {
-    fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {
+    fun BinaryXmlPullParser.parseSystemState(state: AccessState) {
+        val systemState = state.systemState
        when (tagName) {
            TAG_PERMISSION_TREES -> parsePermissions(systemState.permissionTrees)
            TAG_PERMISSIONS -> parsePermissions(systemState.permissions)
@@ -84,7 +86,8 @@ class UidPermissionPersistence {
        permissions[name] = permission
    }

-    fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {
+    fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {
+        val systemState = state.systemState
        serializePermissions(TAG_PERMISSION_TREES, systemState.permissionTrees)
        serializePermissions(TAG_PERMISSIONS, systemState.permissions)
    }
@@ -121,14 +124,102 @@ class UidPermissionPersistence {
        }
    }

+    fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
+        when (tagName) {
+            TAG_PERMISSIONS -> parsePermissionFlags(state, userId)
+            else -> {}
+        }
+    }
+
+    private fun BinaryXmlPullParser.parsePermissionFlags(state: AccessState, userId: Int) {
+        val userState = state.userStates[userId]
+        forEachTag {
+            when (tagName) {
+                TAG_APP_ID -> parseAppId(userState)
+                else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing permission state")
+            }
+        }
+        userState.uidPermissionFlags.retainAllIndexed { _, appId, _ ->
+            val hasAppId = appId in state.systemState.appIds
+            if (!hasAppId) {
+                Log.w(LOG_TAG, "Dropping unknown app ID $appId when parsing permission state")
+            }
+            hasAppId
+        }
+    }
+
+    private fun BinaryXmlPullParser.parseAppId(userState: UserState) {
+        val appId = getAttributeIntOrThrow(ATTR_ID)
+        val permissionFlags = IndexedMap<String, Int>()
+        userState.uidPermissionFlags[appId] = permissionFlags
+        parseAppIdPermissions(permissionFlags)
+    }
+
+    private fun BinaryXmlPullParser.parseAppIdPermissions(
+        permissionFlags: IndexedMap<String, Int>
+    ) {
+        forEachTag {
+            when (tagName) {
+                TAG_PERMISSION -> parseAppIdPermission(permissionFlags)
+                else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing permission state")
+            }
+        }
+    }
+
+    private fun BinaryXmlPullParser.parseAppIdPermission(permissionFlags: IndexedMap<String, Int>) {
+        val name = getAttributeValueOrThrow(ATTR_NAME).intern()
+        val flags = getAttributeIntOrThrow(ATTR_FLAGS)
+        permissionFlags[name] = flags
+    }
+
+    fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        serializePermissionFlags(state.userStates[userId])
+    }
+
+    private fun BinaryXmlSerializer.serializePermissionFlags(userState: UserState) {
+        tag(TAG_PERMISSIONS) {
+            userState.uidPermissionFlags.forEachIndexed { _, appId, permissionFlags ->
+                serializeAppId(appId, permissionFlags)
+            }
+        }
+    }
+
+    private fun BinaryXmlSerializer.serializeAppId(
+        appId: Int,
+        permissionFlags: IndexedMap<String, Int>
+    ) {
+        tag(TAG_APP_ID) {
+            attributeInt(ATTR_ID, appId)
+            serializeAppIdPermissions(permissionFlags)
+        }
+    }
+
+    private fun BinaryXmlSerializer.serializeAppIdPermissions(
+        permissionFlags: IndexedMap<String, Int>
+    ) {
+        permissionFlags.forEachIndexed { _, name, flags ->
+            serializeAppIdPermission(name, flags)
+        }
+    }
+
+    private fun BinaryXmlSerializer.serializeAppIdPermission(name: String, flags: Int) {
+        tag(TAG_PERMISSION) {
+            attributeInterned(ATTR_NAME, name)
+            attributeInt(ATTR_FLAGS, flags)
+        }
+    }
+
    companion object {
        private val LOG_TAG = UidPermissionPersistence::class.java.simpleName

+        private const val TAG_APP_ID = "app-id"
        private const val TAG_PERMISSION = "permission"
-        private const val TAG_PERMISSION_TREES = "permission-trees"
        private const val TAG_PERMISSIONS = "permissions"
+        private const val TAG_PERMISSION_TREES = "permission-trees"

+        private const val ATTR_FLAGS = "flags"
        private const val ATTR_ICON = "icon"
+        private const val ATTR_ID = "id"
        private const val ATTR_LABEL = "label"
        private const val ATTR_NAME = "name"
        private const val ATTR_PACKAGE_NAME = "packageName"
--- a/services/permission/java/com/android/server/permission/access/permission/UidPermissionPolicy.kt
+++ b/services/permission/java/com/android/server/permission/access/permission/UidPermissionPolicy.kt
@@ -33,7 +33,6 @@ import com.android.server.permission.access.GetStateScope
 import com.android.server.permission.access.MutateStateScope
 import com.android.server.permission.access.PermissionUri
 import com.android.server.permission.access.SchemePolicy
-import com.android.server.permission.access.SystemState
 import com.android.server.permission.access.UidUri
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.andInv
@@ -821,12 +820,20 @@ class UidPermissionPolicy : SchemePolicy() {
        }
    }

-    override fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {
-        with(persistence) { this@parseSystemState.parseSystemState(systemState) }
+    override fun BinaryXmlPullParser.parseSystemState(state: AccessState) {
+        with(persistence) { this@parseSystemState.parseSystemState(state) }
    }

-    override fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {
-        with(persistence) { this@serializeSystemState.serializeSystemState(systemState) }
+    override fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {
+        with(persistence) { this@serializeSystemState.serializeSystemState(state) }
+    }
+
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@parseUserState.parseUserState(state, userId) }
+    }
+
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@serializeUserState.serializeUserState(state, userId) }
    }

    fun GetStateScope.getPermissionGroup(permissionGroupName: String): PermissionGroupInfo? =