Skip to main content
Be Bitwise

Permission & Privilege Models Compared

Mobile vs Desktop Comparison · Mobile Internals track

6 min read

In this module

Two Philosophies

Mobile and desktop permission models grew out of two completely different security philosophies. Desktop systems were drawn up in an era when the headline threat was multi-user access: keeping Alice's files safe from Bob. Mobile systems were designed from day one to protect the user from the applications they themselves chose to install.

Desktop: The User Is the Boundary

On traditional desktop operating systems (Windows, macOS, Linux), the security boundary has historically been the user account. A classic program runs with the full permissions of whoever launched it. On a typical Linux desktop or with an unsandboxed Windows Win32 app, that program can:

  • Read, write, and delete any file you own.
  • Access your webcam and microphone.
  • Record your keystrokes.
  • Read your browser history and saved passwords.
  • Connect to any network resource.
  • Launch other programs.

For those apps there's no granular permission system: the application inherits everything the user can do, and the operating system can't tell your trusted text editor from a binary you just downloaded from a sketchy forum. macOS is the main exception, and a partial one. Its TCC prompts gate the camera, microphone, screen recording and several protected folders per app, and Mac App Store apps must run in the App Sandbox, but an unsandboxed Mac app still reads most of your files freely, as the section below covers.

bash
# On desktop Linux, any program you run can access your files
$ ./downloaded_program
# This program can now:
# cat ~/.ssh/id_rsa (read your SSH keys)
# cat ~/.config/chrome/cookies (read browser cookies)
# rm -rf ~/Documents (delete your documents)
# All without any additional permission prompt
Desktop Permission Model

On desktop operating systems, applications inherit the full permissions of the user who runs them. There is no per-resource permission system. A downloaded program can access files, network, camera, and peripherals without asking. The security boundary is between users, not between applications.

Mobile: The App Is the Boundary

Mobile operating systems flip the model on its head. The security boundary sits between applications, not between users. Every app starts in a sandbox with minimal permissions and has to explicitly ask for access to each sensitive resource.

iOS Permission Model

On iOS, the sandbox denies all sensitive access by default. Apps must:

  1. Declare required capabilities in their Info.plist (and sometimes via entitlements).
  2. Request permission from the user at runtime via system-controlled dialogs.
  3. Receive only the specific access the user grants.

The user sees plain, contextual prompts: "MyApp would like to access your camera." Decline, and the app has to soldier on without that capability. Permissions can be yanked back at any time from Settings.

Android Permission Model

Android categorises permissions by protection level (as covered in module 109). Dangerous permissions require runtime user approval since Android 6.0. The system enforces these permissions at multiple levels:

  • Framework level: APIs check permissions before granting access.
  • Binder level: System services verify the caller's UID against the permission database.
  • Kernel level: SELinux policies restrict access to device nodes and system resources.

Practical Consequences

This architectural difference has concrete security implications.

Malware Impact

On desktop, a single malicious application can hoover up all user data, drop a keylogger, and dig in for persistence, because it has every privilege the user has. On mobile, a malicious app is locked inside its sandbox. It can only touch what the user has explicitly granted. It can't read other apps' data, can't install system-level hooks, and can't go editing the operating system.

Follow one malicious app trying to read the user's contacts on each platform. On desktop Linux or Windows it opens the address-book file and nothing asks any questions. On iOS and Android the request has to pass through a system service that checks a per-app grant first.

Supply Chain Risk

Desktop software distribution is essentially the wild west. Users download executables from websites, and those executables get full user permissions the second they run. Mobile app stores (App Store, Google Play) layer on a review process, and even sideloaded apps still run inside the permission model.

Lateral Movement

On desktop, popping one application is more or less popping the whole user environment. On mobile, compromising one app gives you nothing about another app's data. Moving sideways means a separate exploit: a sandbox escape, or a kernel vulnerability.

Desktop Mitigation Efforts

Desktop operating systems are gradually adopting mobile-style permission models:

  • macOS: Since Mojave (10.14), apps must request permission for camera, microphone, screen recording, accessibility, and full disk access. The TCC (Transparency, Consent, and Control) framework manages these permissions.
  • Windows: apps packaged to run in an AppContainer (originally UWP apps, now usually MSIX-packaged apps, with Win32 app isolation as the newer option for classic desktop code) declare capabilities in a model much like the mobile one. UWP itself is largely legacy. Most traditional Win32 apps, though, still run with full user permissions, and camera, microphone and location are the main resources Windows gates per app for them.
  • Linux: Flatpak and Snap containerise desktop applications with permission controls, though adoption is patchy at best.
Converging Models

Desktop operating systems are converging towards the mobile permission model. macOS TCC enforces per-app resource access. Windows AppContainer (MSIX) apps declare capabilities. Linux Flatpak/Snap containers restrict app access. However, traditional desktop applications still run with unrestricted user-level permissions, and the transition is incomplete.

The Root/Administrator Exception

Both worlds have root (Unix) or Administrator (Windows) as the ladder to elevated privileges. The interesting question is how easy that ladder is to climb:

  • Desktop: Users routinely run as Administrator or reach for sudo. Plenty of applications ask for elevation during installation or normal operation.
  • iOS: Root access doesn't exist for the user. Getting root means a jailbreak: exploiting a vulnerability to dodge the security model.
  • Android: Root access isn't on the menu by default. Reaching it means unlocking the bootloader (which wipes the device) and installing something like Magisk, or going the exploit route.

The mobile approach treats root access as a security boundary to be defended, not a convenience for users to lean on. That falls straight out of the app-as-boundary model: if apps are the threat, the system has to be protected from both the apps themselves and from users who might inadvertently hand them the keys.