How to check root access in android?

Question

I created a method for checking whether the android phone is rooted or not. This is done as follows

public int checkrootcommand(String string) {
    // TODO Auto-generated method stub
    Process exec;
    try {

        exec = Runtime.getRuntime().exec(new String[]{"su","-c"});

        final OutputStreamWriter out = new OutputStreamWriter(exec.getOutputStream());
        out.write("exit");
        out.flush();

        Log.i(SUPER_USER_COMMAND, "su command executed successfully");
        return 0; // returns zero when the command is executed successfully
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }  
    return 1; //returns one when the command execution fails
}

But the problem is that the method checkrootcommand() is executed first it works perfectly, but when the same method called again the superuser session is still running. Is there any way to end the superuser session once the method is executed??

Try putting a \n at the end of the exit. But this is not a reliable way to test if the phone is rooted. — antlersoft, Jul 18 '11 at 16:56
@antlersoft : Can you please suggest a suitable way to do the same? — Unnikrishnan, Jul 18 '11 at 17:05
http://code.google.com/p/roottools/ maybe you are interested in that instead — Badr Hari, Jul 18 '11 at 17:07
Not only is this unreliable, trying to use su for a check in an application that doesn't advertise itself as using root permission to do something beneficial to the user will likely lead users to report your app as nefarious. And even if they don't report it, they may use an su wrapper that will blacklist your app, while permitting the ones they want to have root access to do so - so you may falsely think its not rooted when it is not only rooted, but set up for rooted access in one of the most common ways. — Chris Stratton, Jul 18 '11 at 21:54
http://stackoverflow.com/questions/1101380/determine-if-running-on-a-rooted-device/8097801#8097801 — Kevin Parker, May 18 '12 at 16:53
You may not be able to universally detect whether phone is rooted or not but you should be able to request and then confirm is your app can access root by running `id` as root e.g., `su -c id` validate if the command executed successfully and the output contains `uid=0` i.e., the uid of the *root* user. — VPZ, May 31 '17 at 04:26

Chris Stratton · Answer 1 · 2011-07-18T17:51:31.177

There is no reliable means of detecting a rooted condition on a device where hardware protections have been overcome by exploiting software vulnerabilities.

At best you can detect the presence of particular toolsets or scan for things that aren't supposed to be there or changes in files that are - but that requires knowledge of what a given installation should look like, and assumes that the OS functionality you are using to make the checks hasn't been modified to hide the changes.

To reliably scan, you need to be sure trusted code runs at a lower level than untrusted code; a rooted device is one where this assurance has been fundamentally broken, or where the end user is trusted more than you the developer are.

score 1 · Answer 2 · 2017-06-24T06:43:24.200

Method 1 : Application asks for ROOT access :

Add this in your app-level gradle build file :

dependencies {
    compile 'eu.chainfire:libsuperuser:201501111220'
}

Now,

System.out.println(Shell.Su.available());
//Outputs true if user-granted else false

Method 2 : Application doesn't asks for ROOT :

boolean deviceisRooted() {
            String[] filespaths = {"/system/app/Superuser.apk","/sbin/su", "/system/bin/su","/system/xbin/su"};
            for (String xyz : filespaths) {
                if (new File(xyz).exists()) return true;
            }
            return false;
        }

System.out.prinln(deviceisRooted());

//Outputs true if device is ROOTED else false
//Doesn't asks user
//Also returns true IF NOT PROPERLY ROOTED (But ROOTED somehow)

score 1 · Answer 3 · answered May 31 '17 at 04:34

In your case, you should kill the process after executing it for the job which is done before returning. The following changes to your code should do the thing.

public int checkrootcommand(String string) {
    // TODO Auto-generated method stub
    Process exec = null;
    try {

        exec = Runtime.getRuntime().exec(new String[]{"su","-c"});

        final OutputStreamWriter out = new OutputStreamWriter(exec.getOutputStream());
        out.write("exit");
        out.flush();

        Log.i(SUPER_USER_COMMAND, "su command executed successfully");
        return 0; // returns zero when the command is executed successfully
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        if (exec != null) {
            try {
                exec.destroy();
            } catch (Exception ignored) {
            }
        }
    }
    return 1; //returns one when the command execution fails
}

You may not be able to universally detect whether phone is rooted or not but you should be able to request and then confirm is your app can access root by running id as root e.g., su -c id validate if the command executed successfully and the output contains uid=0 i.e., the uid of the root user.

score 0 · Answer 4 · edited Aug 13 '17 at 09:37

0

Use this code:

Process executor = Runtime.getRuntime().exec("su -c ls /data/data");
executor.waitFor();
int iabd = executor.exitValue();
if(iabd != 0){ /*process exit value is not 0, so user is not root*/ }else{ /* user is root*/ }

edited Aug 13 '17 at 09:37

answered Jul 18 '16 at 15:21

Xenon Raite

1
1

score 0 · Answer 5 · answered Feb 14 '20 at 12:03

You can achieve this from a terminal command and you can run terminal commands within an app.

if [ ! -z "$(/system/bin/ps -A | grep -v grep | grep -c daemonsu)" ]; then echo "device is rooted"; else echo "device is not rooted"; fi

Your application also doesn't require root access this way.

How to check root access in android?

5 Answers5

Linked