android root检测_android如何防root、xposed的检测 - CSDN
  • 详细介绍:http://blog.csdn.net/kangear/article/details/51872653
  • import android.text.TextUtils; import java.io.BufferedReader; import java.io.File; import java.io.InputStreamReader; /** * 使用 boolean isRoot = PACheckSysUtils.isRoot(); * 检测手机是否被Root */...
    import android.text.TextUtils;
    
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.InputStreamReader;
    
    /**
     * 使用 boolean isRoot = PACheckSysUtils.isRoot();
     * 检测手机是否被Root
     */
    public class CheckSysUtils {
        private static final String TAG = "PACheckSysUtils";
    
        /**
         * 检测是否root
         * modify by hiyi 20180928,移除雁联SDK的root检测,重新开发
         *
         * @param
         * @return
         */
        public static boolean isRoot() {
            String[] paths = {
                    "/system/xbin/su",
                    "/system/bin/su",
                    "/system/sbin/su",
                    "/sbin/su",
                    "/vendor/bin/su",
                    "/su/bin/su"
            };
            try {
                for (String path : paths) {
                    if (new File(path).exists()) {
                        String execResult = exec(new String[]{"ls", "-l", path});
                        Log.d(TAG, "isRooted = " + execResult);
                        //形如(rooted):-rwxr-xr-x root     root        75348 1970-01-01 08:32 su
                        if (TextUtils.isEmpty(execResult)
                                || execResult.indexOf("root") == execResult.lastIndexOf("root")) {
                            return false;
                        }
                        return true;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
    
        private static String exec(String[] exec) {
            if (exec == null || exec.length <= 0) {
                return null;
            }
            StringBuilder ret = new StringBuilder();
            ProcessBuilder processBuilder = new ProcessBuilder(exec);
            try {
                Process process = processBuilder.start();
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String line;
                while ((line = bufferedReader.readLine()) != null) {
                    ret.append(line);
                }
                process.getInputStream().close();
                process.destroy();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return ret.toString();
        }
    }
    

     

    展开全文
  • root 检测原理已经root设备,会增加一些特殊包或文件,所以可以通过检测这些包(如Superuser.apk、检测su命令)、activity、文件是否存在来判断。app检测是否可以执行在root下才能运行的命令。检测busybox工具是否存在...


    root 检测原理


    1. 已经root设备,会增加一些特殊包或文件,所以可以通过检测这些包(如Superuser.apk、检测su命令)、activity、文件是否存在来判断。
    2. app检测是否可以执行在root下才能运行的命令。
    3. 检测busybox工具是否存在,关于busybox的知识google上一大堆,简单的说BusyBox
      是很多标准 Linux 工具的一个单个可执行实现。BusyBox
      包含了一些简单的工具,例如 cat 和 echo,还包含了一些更大、更复杂的工具,例如 grep、find、moun)
    4. 运行su命令
    5. 检测Android 沙盒目录文件或文件夹读取权限(在Android系统中,有些目录是普通用户不能访问的,例如 /data、/system、/etc 等;比如微信沙盒目录下的文件或文件夹权限是否正常)


    分析环境

    小米手机刷机系统

    adb环境

    顶部Activity


    打开root权限的步骤

    设置/授权管理/root权限管理


    查看手机的授权管理(主要是包名)




    检测无需root权限

    查看进程信息

    ls -l /system/app |grep permcenter
    
    复制代码



    查看是否有安卓root的apk

     pm list packages |grep permcenter
    
    复制代码



    当然还有就是查看com.xxx.xxxx包下是否有XXXActivity

    adb shell dumpsys activity top复制代码



    android 代码解析apk的常用包是net.dongliu:apk-parser:2.2.0

    https://mvnrepository.com/artifact/net.dongliu.apk-parser
    
    复制代码


    检测busybox

    xposed内携带有busybox



    BusyBox是一个不简单的应用中,它的可执行二进制,按说应该被定位在系统/system/xbin表示。安装正确的BusyBox的二进制拷贝包括并创建符号链接。

    # busybox pwd
    
    cd /system/xbin
    ls -l busybox复制代码



    busybox top复制代码




    检测su

    cd  /system/xbin
    ls -l su复制代码








    用which命令查看是否有su 和busybox命令

    $ which su
    #与
    $ which busybox复制代码





    wechat root检测

    在root授权管理没有看到过wechat的授权请求,可以认为微信不会主动去尝试获取root权限,也即不会直接运行 “su”命令


    在wechat代码种有对系统path环境下的su文件进行检查,有代码为证


    第一个位置


    第2个位置


    展开全文
  • android手机root检测

    2020-07-25 23:33:05
    android手机root检测,不弹窗 参考http://www.cnblogs.com/waylife/p/3846440.html
  • 系统Root检测 - /system/bin/su &amp; /system/xbin/su一、API【1】破解手机ROOT权限的原理,就是在手机的/system/bin和/system/xbin目录下放置一个可执行文件“su”【2】判断手机是否具有Root权限的代码示例【3...

    系统Root检测 - /system/bin/su & /system/xbin/su


    一、API


    【1】破解手机ROOT权限的原理,就是在手机的/system/bin/system/xbin目录下放置一个可执行文件“su”


    【2】判断手机是否具有Root权限的代码示例




    【3】参考链接


    http://blog.csdn.net/u010355144/article/details/49723777


    二、触发条件


    1. 定位/system/bin/su文件


    【1】对应到smali语句中的特征

    r'const-string.+, "/system/bin/su"'


    2. 定位/system/xbin/su文件


    【1】对应到smali语句中的特征

    r'const-string.+, "/system/xbin/su"'


    3. 定位File.exists方法


    【1】对应到smali语句中的特征

    'Ljava/io/File;->exists()Z'


    三、漏洞原理


    【1】APP在Android设备被Root的环境下,没有进行安全检测并采取保护措施,导致系统安全性大大降低


    四、修复建议


    【1】在APP运行的时候,应该对Android设备Root环境进行检测,并提示用户注意潜在的安全漏洞


    【2】参考链接


    展开全文
  • 一 为什么要进行root检测? 出于安全原因,我们的应用程序不建议在已经root的设备上运行,所以需要检测是否设备已经root,以提示用户若继续使用会存在风险。 二 root了会有什么风险? 在Linux操作系统中,root的...

    一 为什么要进行root检测?

    出于安全原因,我们的应用程序不建议在已经root的设备上运行,所以需要检测是否设备已经root,以提示用户若继续使用会存在风险。

    二 root了会有什么风险?

    在Linux操作系统中,root的权限是最高的,也被称为超级权限的拥有者。 
    在系统中,每个文件、目录和进程,都归属于某一个用户,没有用户许可其它普通用户是无法操作的,但对root除外。

    root用户的特权性还表现在:root可以超越任何用户和用户组来对文件或目录进行读取、修改或删除(在系统正常的许可范围内);对可执行程序的执行、终止;对硬件设备的添加、创建和移除等;也可以对文件和目录进行属主和权限进行修改,以适合系统管理的需要(因为root是系统中权限最高的特权用户);root是超越任何用户和用户组的,基于用户ID的权限机制的沙盒是隔离不了它的。

    三 不root为什么就安全了呢?

    Android安全架构是基于Linux多用户机制的访问控制。应用程序在默认的情况下不可以执行其他应用程序,包括读或写用户的私有数据(如联系人数据或email数据),读或写另一个应用程序的文件。

    一个应用程序的进程就是一个安全的沙盒(在受限的安全环境中运行应用程序,在沙盒中的所有改动对操作系统不会造成任何危害)。它不能干扰其它应用程序,除非显式地声明了“permissions”,以便它能够获取基本沙盒所不具备的额外的能力。 
    每一个Android应用程序都会在安装时就分配一个独有的Linux用户ID,这就为它建立了一个沙盒,使其不能与其他应用程序进行接触。这个用户ID会在安装时分配给它,并在该设备上一直保持同一个数值。

     所有的Android应用程序必须用证书进行签名认证,而这个证书的私钥是由开发者保有的。该证书可以用以识别应用程序的作者。签名影响安全性的最重要的方式是通过决定谁可以进入基于签名的permisssions,以及谁可以share 用户IDs。通过这样的机制,在不考虑root用户的情况下,每个应用都是相互隔离的,实现了一定的安全。

    四 root的方式有哪些?

    通常可以分为2种,不完全Root和完全Root 

    目前获取Android root 权限常用方法是通过各种系统漏洞,替换或添加SU程序到设备,获取Root权限,而在获取root权限以后,会装一个程序用以提醒用户是否给予程序最高权限,可以一定程度上防止恶意软件,通常会使用Superuser或者 SuperSU ,这种方法通常叫做“不完全Root”。

    而 “完全ROOT”是指,替换设备原有的ROM,以实现取消secure设置。

    五 检测Android设备是否root有哪些方法?

    1、查看系统是否是测试版

    我们可以查看发布的系统版本,是test-keys(测试版),还是release-keys(正式版)。 
    可以先在adb shell中运行下命令查看:

    root@android:/ # cat /system/build.prop | grep ro.build.tags
    ro.build.tags=release-keys

    这个返回结果“release-keys”,代表此系统是正式版。 
    在代码中的检测方法如下:

    public static boolean checkDeviceDebuggable() {
            String buildTags = android.os.Build.TAGS;
            if (buildTags != null && buildTags.contains("test-keys")) {
                Log.i(LOG_TAG, "buildTags=" + buildTags);
                return true;
            }
            return false;
        }

    若是非官方发布版,很可能是完全root的版本,存在使用风险。 
    可是在实际情况下,我遇到过某些厂家的正式发布版本,也是test-keys,可能大家对这个标识也不是特别注意吧。所以具体是否使用,还要多考虑考虑呢。也许能解决问题,也许会给自己带来些麻烦。

    2、检查是否存在Superuser.apk

    Superuser.apk是一个被广泛使用的用来root安卓设备的软件,所以可以检查这个app是否存在。 
    检测方法如下:

    public static boolean checkSuperuserApk() {
            try {
                File file = new File("/system/app/Superuser.apk");
                if (file.exists()) {
                    Log.i(LOG_TAG, "/system/app/Superuser.apk exist");
                    return true;
                }
            } catch (Exception e) {
            }
            return false;
        }

    3、检查su命令

    su是Linux下切换用户的命令,在使用时不带参数,就是切换到超级用户。通常我们获取root权限,就是使用su命令来实现的,所以可以检查这个命令是否存在。这样,系统就会在PATH路径中搜索su,如果找到,就会执行,执行成功后,就是获取到真正的超级权限了。 

    public static synchronized boolean checkGetRootAuth() {
            Process process = null;
            DataOutputStream os = null;
            try {
                Log.i(LOG_TAG, "to exec su");
                process = Runtime.getRuntime().exec("su");
                os = new DataOutputStream(process.getOutputStream());
                os.writeBytes("exit\n");
                os.flush();
                int exitValue = process.waitFor();
                Log.i(LOG_TAG, "exitValue=" + exitValue);
                if (exitValue == 0) {
                    return true;
                } else {
                    return false;
                }
            } catch (Exception e) {
                Log.i(LOG_TAG, "Unexpected error - Here is what I know: "
                        + e.getMessage());
                return false;
            } finally {
                try {
                    if (os != null) {
                        os.close();
                    }
                    process.destroy();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    这种检测su的方法,应该是最靠谱的,不过,也有个问题,就是在已经root的设备上,会弹出提示框,请求给app开启root权限。这个提示不太友好,可能用户会不喜欢。 
    如果想安静的检测,可以用上两种方法的组合;如果需要尽量安全的检测到,还是执行su吧。

    4、执行busybox

    Android是基于Linux系统的,可是在终端Terminal中操作,会发现一些基本的命令都找不到。这是由于Android系统为了安全,将可能带来风险的命令都去掉了,最典型的,例如su,还有find、mount等。对于一个已经获取了超级权限的人来讲,这是很不爽的事情,所以,便要想办法加上自己需要的命令了。一个个添加命令也麻烦,有一个很方便的方法,就是使用被称为“嵌入式Linux中的瑞士军刀”的Busybox。简单的说BusyBox就好像是个大工具箱,它集成压缩了 Linux 的许多工具和命令。 
    所以若设备root了,很可能Busybox也被安装上了。这样我们运行busybox测试也是一个好的检测方法。
     

    public static synchronized boolean checkBusybox() {
            try {
                Log.i(LOG_TAG, "to exec busybox df");
                String[] strCmd = new String[]{"busybox", "df"};
                ArrayList<String> execResult = executeCommand(strCmd);
                if (execResult != null) {
                    Log.i(LOG_TAG, "execResult=" + execResult.toString());
                    return true;
                } else {
                    Log.i(LOG_TAG, "execResult=null");
                    return false;
                }
            } catch (Exception e) {
                Log.i(LOG_TAG, "Unexpected error - Here is what I know: "
                        + e.getMessage());
                return false;
            }
        }

    5、访问/data目录,查看读写权限

    在Android系统中,有些目录是普通用户不能访问的,例如 /data、/system、/etc 等。 
    我们就已/data为例,来进行读写访问。本着谨慎的态度,我是先写入一个文件,然后读出,查看内容是否匹配,若匹配,才认为系统已经root了。

    public static synchronized boolean checkAccessRootData() {
            try {
                Log.i(LOG_TAG, "to write /data");
                String fileContent = "test_ok";
                Boolean writeFlag = writeFile("/data/su_test", fileContent);
                if (writeFlag) {
                    Log.i(LOG_TAG, "write ok");
                } else {
                    Log.i(LOG_TAG, "write failed");
                }
    
                Log.i(LOG_TAG, "to read /data");
                String strRead = readFile("/data/su_test");
                Log.i(LOG_TAG, "strRead=" + strRead);
                if (fileContent.equals(strRead)) {
                    return true;
                } else {
                    return false;
                }
            } catch (Exception e) {
                Log.i(LOG_TAG, "Unexpected error - Here is what I know: "
                        + e.getMessage());
                return false;
            }
        }

    六、具体如何使用?

    只需调用以下代码即可

    CheckRoot.isDeviceRooted()
    其中CheckRoot.java的完整代码如下:
    import android.util.Log;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.ByteArrayOutputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.util.ArrayList;
    
    public class CheckRoot {
        private static String LOG_TAG = CheckRoot.class.getName();
    
        public static boolean isDeviceRooted() {
            if (checkDeviceDebuggable()) {
                return true;
            }//check buildTags
            if (checkSuperuserApk()) {
                return true;
            }//Superuser.apk
            //if (checkRootPathSU()){return true;}//find su in some path
            //if (checkRootWhichSU()){return true;}//find su use 'which'
            if (checkBusybox()) {
                return true;
            }//find su use 'which'
            if (checkAccessRootData()) {
                return true;
            }//find su use 'which'
            if (checkGetRootAuth()) {
                return true;
            }//exec su
    
            return false;
        }
    
        public static boolean checkDeviceDebuggable() {
            String buildTags = android.os.Build.TAGS;
            if (buildTags != null && buildTags.contains("test-keys")) {
                Log.i(LOG_TAG, "buildTags=" + buildTags);
                return true;
            }
            return false;
        }
    
        public static boolean checkSuperuserApk() {
            try {
                File file = new File("/system/app/Superuser.apk");
                if (file.exists()) {
                    Log.i(LOG_TAG, "/system/app/Superuser.apk exist");
                    return true;
                }
            } catch (Exception e) {
            }
            return false;
        }
    
        public static synchronized boolean checkGetRootAuth() {
            Process process = null;
            DataOutputStream os = null;
            try {
                Log.i(LOG_TAG, "to exec su");
                process = Runtime.getRuntime().exec("su");
                os = new DataOutputStream(process.getOutputStream());
                os.writeBytes("exit\n");
                os.flush();
                int exitValue = process.waitFor();
                Log.i(LOG_TAG, "exitValue=" + exitValue);
                if (exitValue == 0) {
                    return true;
                } else {
                    return false;
                }
            } catch (Exception e) {
                Log.i(LOG_TAG, "Unexpected error - Here is what I know: "
                        + e.getMessage());
                return false;
            } finally {
                try {
                    if (os != null) {
                        os.close();
                    }
                    process.destroy();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static synchronized boolean checkBusybox() {
            try {
                Log.i(LOG_TAG, "to exec busybox df");
                String[] strCmd = new String[]{"busybox", "df"};
                ArrayList<String> execResult = executeCommand(strCmd);
                if (execResult != null) {
                    Log.i(LOG_TAG, "execResult=" + execResult.toString());
                    return true;
                } else {
                    Log.i(LOG_TAG, "execResult=null");
                    return false;
                }
            } catch (Exception e) {
                Log.i(LOG_TAG, "Unexpected error - Here is what I know: "
                        + e.getMessage());
                return false;
            }
        }
    
        public static ArrayList<String> executeCommand(String[] shellCmd) {
            String line = null;
            ArrayList<String> fullResponse = new ArrayList<String>();
            Process localProcess = null;
            try {
                Log.i(LOG_TAG, "to shell exec which for find su :");
                localProcess = Runtime.getRuntime().exec(shellCmd);
            } catch (Exception e) {
                return null;
            }
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(localProcess.getOutputStream()));
            BufferedReader in = new BufferedReader(new InputStreamReader(localProcess.getInputStream()));
            try {
                while ((line = in.readLine()) != null) {
                    Log.i(LOG_TAG, "–> Line received: " + line);
                    fullResponse.add(line);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            Log.i(LOG_TAG, "–> Full response was: " + fullResponse);
            return fullResponse;
        }
    
        public static synchronized boolean checkAccessRootData() {
            try {
                Log.i(LOG_TAG, "to write /data");
                String fileContent = "test_ok";
                Boolean writeFlag = writeFile("/data/su_test", fileContent);
                if (writeFlag) {
                    Log.i(LOG_TAG, "write ok");
                } else {
                    Log.i(LOG_TAG, "write failed");
                }
    
                Log.i(LOG_TAG, "to read /data");
                String strRead = readFile("/data/su_test");
                Log.i(LOG_TAG, "strRead=" + strRead);
                if (fileContent.equals(strRead)) {
                    return true;
                } else {
                    return false;
                }
            } catch (Exception e) {
                Log.i(LOG_TAG, "Unexpected error - Here is what I know: "
                        + e.getMessage());
                return false;
            }
        }
    
        //写文件
        public static Boolean writeFile(String fileName, String message) {
            try {
                FileOutputStream fout = new FileOutputStream(fileName);
                byte[] bytes = message.getBytes();
                fout.write(bytes);
                fout.close();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        //读文件
        public static String readFile(String fileName) {
            File file = new File(fileName);
            try {
                FileInputStream fis = new FileInputStream(file);
                byte[] bytes = new byte[1024];
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                int len;
                while ((len = fis.read(bytes)) > 0) {
                    bos.write(bytes, 0, len);
                }
                String result = new String(bos.toByteArray());
                Log.i(LOG_TAG, result);
                return result;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }

    ​​​​

    展开全文
  • 出于安全原因,我们的应用程序不建议在已经root的设备上运行,所以需要检测是否设备已经root,以提示用户若继续使用会存在风险。那么root了会有什么风险呢,为什么不root就没有风险,又怎么来检查手机是否root了?...
  • 判断Android设备Root方法总结 ##**先说结论没有办法完全检测出设备是否被root,因为root权限拥有系统的最高权限。**已经root的设备可以通过修改系统文件,和Hook来躲避检查。我们只能增加他躲避检查的难度来检测...
  • 当进入APP的时候检测提示用户 /** * Is rooted boolean. * * @return the boolean */ public static boolean isRooted() { // nexus 5x "/su/bin/" String[] paths = {"/syste...
  • app发布后,一些root用户可能会修改我们应用的一些信息,如传感器获得...下面是检测Android设备是否被root的4种方法: 1.判断Build标志String buildTags = android.os.Build.TAGS; if (buildTags != null && buildTags
  • Android (linux)很多命令需要root权限才能执行,比如说查看系统目录文件等,如果我们的程序需要用到查看此类文件或执行系统命令,就必须先获取Root权限。 [java] view plain copy
  • root权限是安卓最高的操作权限,俗称superuser,简称su,一般来说root过的手机,系统目录会有su目录和系统app目录中有Superuser.apk,或者kingroot、360RootRoot精灵、等apk。当然了,在安卓8系列中会使用magisk,...
  • 封装了一个类,代码如下: public class ShellCommand { private Boolean can_su; public SH sh; public SH su; public ShellCommand() { sh = new SH("sh"); su = new SH("su");...retur
  • Android Root分析及防范

    2018-04-29 12:43:36
    Android Root分析及防范 课程名称:信息信息系统安全课堂作业 众所周知,Android系统由于其开源、开放、灵活的特征让智能手机产业有了飞速的进步,Android平台作为目前最流行的流量平台,由于它的开源使得大量的...
  • 该技术可以通过root权限,绕过权限检测机制, 在后台实现静默地自动授予任意app的任意权限, 没错: 自动授予[任意]app 的 [任意] 权限, 就是这么可怕! 以悬浮窗权限为例, 下面来说下我的研究的过程和最终解决方案: ...
  • 现在Android手机root权限可以说是轻松就获取得到的,而关于判断手机是否已经root的方法,你了解吗?如果app有一些特殊功能需要root权限,则需要判断是否root。不知道root是不是意味着手机不安全?说到底还是...
  • 本文介绍了android中获取root权限的方法以及原理,让大家对android玩家中常说的“越狱”有一个更深层次的认识。   二、 Root的介绍 1.  Root 的目的 可以让我们拥有掌控手机系统的权限,比如删除一些system/app...
  • 本文章由Jack_Jia编写,转载请注明出处。  文章链接:http://blog.csdn.net/jiazhijun/article/details/8660226 ... ... 到目前为止Android已被发现大量的提权漏洞,虽然这些提权漏洞随着系统版本的升级已
  • 第1章 Root的基本原理Android的内核就是Linux,所以Android获取root其实和Linux获取root权限是一回事儿。你想在Linux下获取root权限的时候就是执行sudo或者su,接下来系统会提示你输入root用户的密码,密码正确就...
  • 一般来说, Android 下的应用程序可以“直接”得到的最大的权限为 system ,但是如果我们需要在程序中执行某些需要 root 权限的命令,如 ifconfig 等,就需要root 权限了。按照 Simon 的文章中提到的,...
1 2 3 4 5 ... 20
收藏数 19,051
精华内容 7,620
关键字:

android root检测