What can you do with an Android application with no permissions?
leviathansecurity.com
leviathansecurity.com
However, I feel that these default permissions are really not that awful. There's always a balance between giving fine-grained control to the user over permissions and ease of use and these are not orthogonal issues, as the user suddenly ends up with more choices to make. What the user really wants to know ... is this mallware? Is this going to delete my files? Is this going to violate my privacy? ... and that's about it.
If Android required separate permissions for absolutely everything you could do in an app, you know what the average user would do if presented with a list of 30 permissions requested, amongst which there would be phrases like "allow the app to open the web browser"?
The average user would just click "Yes, please" without reading it (I'm even doing that myself from time to time). And that seems better for technical inclined folks like us, but it really isn't for average users, because it trains them to blindly accept anything while giving the impression of security - and I feel that's worse than no security at all.
This is happening most of the times anyway. There is no way to see from the installer screen, why an app requests a certain permission. One example: most launcher replacements require the CALL_PHONE permission, which comes with a big warning. This is technically required if you want to place a contact shortcut on your desktop.
A better, security-wise, solution would have been to ask on-demand, when the app actually performs a permissions-requiring action, like it is done in J2ME. I suppose this was not done in Android either for software patent or for convenience reasons. Or maybe it would have gone against the usability of ad networks if you could deny the virtual Golf app access to GPS and internet...
There are plenty of places where permissions should be more fine-grained, but doing that in a usable way is not easy. Personally, I'd like to see a distinction between "required" and "optional" permissions (with always deny, prompt and always grant alternatives for optional ones). Of course, there would still be a lot of tricky issues to sort out (e.g. how do you encourage developers to expose some permissions as optional not required?), but I think that exposing more permissions for direct user management, while trying to minimize the effort required might might strike a better balance over the long run.
Please let me clarify: a properly designed system should allow the user to "always grant" that one permission to that one app, so the total number of permissions dialog goes from 1 per app to N per app with N=number of required permissions. The advantage would be, that opposed to Windows (where you only grant one rather opaque "Administrator" permission) you will see how your current action caused the permission request.
To come back to my example: you tap on the contact shortcut on your desktop, and Android asks you:
"Launcher requests the permission to perform a (possibly billed) phone call. [Grant] [Grant always] [Deny] [Deny always]"
Of course this model does not work for all possible permissions and applications, but it is still a vast improvement over what we have now.
That's pretty much the model I was trying to suggest as well, with the extra detail that users only get that prompt for "optional" permissions. "required" permissions (e.g. a browser accessing the Internet) would still be take-it-or-leave-it at installation.
Though, thinking back to a Google+ post by a member of the Android team that I don't have at hand right now, there's also a place for self-certifying UI elements. IIRC, their example was a system-provided Contacts widget (where if you selected a contact using that widget from within an app, you were clearly giving the app access to that contact data). My favorite example is the crash reporter. If click the "Send Crash Report" button, you're clearly giving permission to share some, potentially private, data about the crash (and sharing even more if you also check off sending the crash log). When you can pull off those sorts of UI elements, it is ideal, but they're not general enough for everything.
I own a cheap feature phone with MIDP app support. (J2ME) I don't think that's a wise choice. In Opera Mini I press through the "allow network access" screen every single time I use it, because, presumably for security reasons, I can't choose "always allow" (maybe because app isn't signed by carrier certificate??)
It's even worse than asking once as you train yourself to click/tap/press through the prompt whenever you use the app, so if it suddenly changed from "access internet" to "make phone calls", I might not notice.
Yes. And unfortunately the permissions don't do anything, at all, to help you with that.
Permissions for a really useful, non-malware app: access address book, internet, blah-blah.
Permissions for a really terrible, malware app: access address book, internet, blah-blah.
Permissions are security theatre. The app store management may continue to use them but they should be hidden from the user - they are completely useless to the end user.
I wouldn't say that. They aren't just there just to be there, they do restrict access. It allows me to choose if I want an app based on what the app wants to know about me. Yes, it can't tell me if an app is malware, but it does tell me if some photo editing app needs to see my address book.
Would people reasonably expect that the contents of their SD card and a list of all their purchases could be silently uploaded by an app they'd given no permissions to?
If not, this is clearly not delivering control to the user.
From here you can pretty much do anything, since the average handset is shipped with an ancient buggy kernel.
The short answer remains: treat software on Play with the same distrustful contempt you would treat random no-name desktop software found in the dark corners of the Internet.
But surely you will provide some compelling citations.
https://github.com/saurik/mempodroid
Regardless, it is true: most of the exploits that have been used (Rage Against the Cage, GingerBreak, zergRush) have been in user-land components (adbd, vold, libsysutils), not in the kernel. On Android 1.x, though: kernel bugs FTW.
It is not too hard to leverage the same exploit used by rooting tools to circumvent the UID based sandbox and to access the data of other applications, including the phone book, security tokens / passwords stored in SharedPreferences etc.
Most if not all rooting tools work via the debug interface. One rather clever app -- if you have USB debugging turned on -- would essentially do a localhost debug connection to exploit this, but generally these are ADB exploits. This has nothing to do with native versus managed, and native provides no additional opportunity than managed.
I replied to the original post because there is a pretty prolific belief that native=crazy dangerous. Yet of course the iPhone has entirely native apps, and we've had native sandboxing and rights restrictions since...what...the creation of UNIX?
http://en.wikipedia.org/wiki/Linux_kernel#Timeline
From these two it is fairly easy to tell how current the kernel is for any rev of android out there. A quick cross comparison shows that it was more or less current at time of release but isn't updated afterwards. This means there are quite a few three or four year old kernels out there since most devices are in the 2.x range. I am not sure what qualifies as ancient, but I never really had a problem with the 2.6 kernel line.
Reminds me of ping tunnels: http://en.wikipedia.org/wiki/ICMP_tunnel
"Some previous work had been demonstrated by Thomas Cannon of viaForensics. I wanted to develop that work further through a discussion backed by source code."
While it would be great to have more secure apps everywhere, panicking about it, as has been so common in the media lately, is pointless.
http://www.defcon.org/images/defcon-18/dc-18-presentations/L...
See page 32
Also, I'd like to add that saying the ability to list packages on the device is a security risk is just silly. That's like saying a Linux box is vulnerable because I can list /usr.
Android has no "Trust Links" permission?