Java 执行与Runtime.getRuntime（）.exec（cmd）等效的命令行；在JNIC中

我正在开发一个需要实现根检测逻辑的应用程序，所以通过研究，我在JAVA中找到了一些检测逻辑，并实现了以下类

class RootDetection {

    public boolean isDeviceRooted() {

        return checkForBinary("su") || checkForBinary("busybox") || checkForMaliciousPaths() || checkSUonPath()
                || detectRootManagementApps() || detectPotentiallyDangerousApps() || detectRootCloakingApps()
                || checkForDangerousProps() || checkForRWPaths()
                || detectTestKeys() || checkSuExists();
    }

    private boolean detectTestKeys() {
        String buildTags = android.os.Build.TAGS;
        String buildFinger = Build.FINGERPRINT;
        String product = Build.PRODUCT;
        String hardware = Build.HARDWARE;
        String display = Build.DISPLAY;
        System.out.println("Java: build: " + buildTags + "\nFingerprint: " + buildFinger + "\n Product: " + product + "\n Hardware: " + hardware + "\nDisplay: " + display);
        return (buildTags != null) && (buildTags.contains("test-keys") || buildFinger.contains("genric.*test-keys") || product.contains("generic") || product.contains("sdk") || hardware.contains("goldfish") || display.contains(".*test-keys"));
    }


    private boolean detectRootManagementApps() {
        return detectRootManagementApps(null);
    }


    private boolean detectRootManagementApps(String[] additionalRootManagementApps) {


        ArrayList<String> packages = new ArrayList<>();
        packages.addAll(Arrays.asList(knownRootAppsPackages));
        if (additionalRootManagementApps != null && additionalRootManagementApps.length > 0) {
            packages.addAll(Arrays.asList(additionalRootManagementApps));
        }

        return isAnyPackageFromListInstalled(packages);
    }


    private boolean detectPotentiallyDangerousApps() {
        return detectPotentiallyDangerousApps(null);
    }

    private boolean detectPotentiallyDangerousApps(String[] additionalDangerousApps) {


        ArrayList<String> packages = new ArrayList<>();
        packages.addAll(Arrays.asList(knownDangerousAppsPackages));
        if (additionalDangerousApps != null && additionalDangerousApps.length > 0) {
            packages.addAll(Arrays.asList(additionalDangerousApps));
        }

        return isAnyPackageFromListInstalled(packages);
    }


    private boolean detectRootCloakingApps() {
        return detectRootCloakingApps(null);
    }


    private boolean detectRootCloakingApps(String[] additionalRootCloakingApps) {


        ArrayList<String> packages = new ArrayList<>();
        packages.addAll(Arrays.asList(knownRootCloakingPackages));
        if (additionalRootCloakingApps != null && additionalRootCloakingApps.length > 0) {
            packages.addAll(Arrays.asList(additionalRootCloakingApps));
        }

        return isAnyPackageFromListInstalled(packages);
    }

    private boolean checkForBinary(String filename) {

        for (String path : suPaths) {
            String completePath = path + filename;
            File f = new File(completePath);
            boolean fileExists = f.exists();
            if (fileExists) {
                return true;
            }
        }

        return false;
    }

    private boolean checkForMaliciousPaths() {
        for (String path : maliciousPaths) {
            File f = new File(path);
            boolean fileExists = f.exists();
            if (fileExists) {
                return true;
            }
        }

        return false;
    }

    private static boolean checkSUonPath() {
        for (String pathDir : System.getenv("PATH").split(":")) {
            if (new File(pathDir, "su").exists()) {
                return true;
            }
        }
        return false;
    }

    private String[] propsReader() {
        InputStream inputstream = null;
        try {
            inputstream = Runtime.getRuntime().exec("getprop").getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
        String propval = "";
        try {
            propval = new Scanner(inputstream).useDelimiter("\\A").next();

        } catch (NoSuchElementException e) {

        }

        return propval.split("\n");
    }

    private String[] mountReader() {
        InputStream inputstream = null;
        try {
            inputstream = Runtime.getRuntime().exec("mount").getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }


        if (inputstream == null) return null;

        String propval = "";
        try {
            propval = new Scanner(inputstream).useDelimiter("\\A").next();
        } catch (NoSuchElementException e) {
            e.printStackTrace();
        }

        return propval.split("\n");
    }

    private boolean isAnyPackageFromListInstalled(List<String> packages) {

        PackageManager pm = activity.getPackageManager();

        for (String packageName : packages) {
            try {
                pm.getPackageInfo(packageName, 0);
                return true;
            } catch (PackageManager.NameNotFoundException e) {

            }
        }
        return false;
    }

    private boolean checkForDangerousProps() {

        final Map<String, String> dangerousProps = new HashMap<>();
        dangerousProps.put("ro.debuggable", "1");
        dangerousProps.put("ro.secure", "0");

        String[] lines = propsReader();
        for (String line : lines) {
            for (String key : dangerousProps.keySet()) {
                if (line.contains(key)) {
                    String badValue = dangerousProps.get(key);
                    badValue = "[" + badValue + "]";
                    if (line.contains(badValue)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private boolean checkForRWPaths() {

        String[] lines = mountReader();
        for (String line : lines) {
            String[] args = line.split(" ");

            if (args.length < 4) {
                continue;
            }

            String mountPoint = args[1];
            String mountOptions = args[3];

            for (String pathToCheck : pathsThatShouldNotBeWrtiable) {
                if (mountPoint.equalsIgnoreCase(pathToCheck)) {
                    for (String option : mountOptions.split(",")) {

                        if (option.equalsIgnoreCase("rw")) {
                            return true;
                        }
                    }
                }
            }
        }

        return false;
    }

    private boolean checkSuExists() {
        Process process = null;
        try {
            process = Runtime.getRuntime().exec(new String[]{"which", "su"});
            BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream()));
            return in.readLine() != null;
        } catch (Throwable t) {
            return false;
        } finally {
            if (process != null) process.destroy();
        }
    }

}

类根检测{
公共布尔值isDeviceRooted（）{
返回checkForBinary（“su”）| checkForBinary（“busybox”）| | checkForMaliciousPaths（）| | checkSUonPath（））
||detectRootManagementApps（）| | detectPotentiallyDangerousApps（）| | DetectRootLoakingApps（）
||CheckForDangerProps（）| | CheckForrWpath（）
||detectTestKeys（）| | ChecksExists（）；
}
私有布尔值detectTestKeys（）{
String buildTags=android.os.Build.TAGS；
字符串buildFinger=Build.FINGERPRINT；
字符串product=Build.product；
字符串hardware=Build.hardware；
字符串显示=Build.display；
System.out.println（“Java:build:+buildTags+”\nFingerprint:+buildFinger+”\n产品：+Product+“\n硬件：+Hardware+”\n显示：+display”）；
return（buildTags！=null）和&（buildTags.contains（“测试键”）| | buildFinger.contains（“genric.*测试键”）| | product.contains（“generic”）| | product.contains（“sdk”）| hardware.contains（“goldfish”）| display.contains（“测试键”）；
}
专用布尔值DetectroutManagementApps（）{
返回DetectroutManagementApps（空）；
}
专用布尔DetectorotManagementApps（字符串[]additionalRootManagementApps）{
ArrayList packages=新的ArrayList（）；
packages.addAll（Arrays.asList（knownrootapspackages））；
if（additionalRootManagementApps！=null&&additionalRootManagementApps.length>0）{
packages.addAll（Arrays.asList（additionalRootManagementApps））；
}
返回isAnyPackageFromListInstalled（软件包）；
}
私有布尔检测潜在危险应用程序（）{
返回DetectPotentialLangerousApps（null）；
}
私有布尔检测潜在危险应用程序（字符串[]其他危险应用程序）{
ArrayList packages=新的ArrayList（）；
packages.addAll（Arrays.asList（knowndagerousappspackages））；
if（additionalDangerousApps！=null&&additionalDangerousApps.length>0）{
packages.addAll（Arrays.asList（additionalDangerousApps））；
}
返回isAnyPackageFromListInstalled（软件包）；
}
私有布尔DetectrootLoakingApps（）{
返回DetectrootLoakingApps（空）；
}
专用布尔DetectrootLoakingApps（字符串[]AdditionalRootClookingApps）{
ArrayList packages=新的ArrayList（）；
packages.addAll（Arrays.asList（knownRootCloakingPackages））；
if（AdditionalRootClothingApps！=null&&AdditionalRootClothingApps.length>0）{
packages.addAll（Arrays.asList（AdditionalRootCoveringApps））；
}
返回isAnyPackageFromListInstalled（软件包）；
}
私有布尔checkForBinary（字符串文件名）{
用于（字符串路径：suPaths）{
字符串completePath=路径+文件名；
文件f=新文件（completePath）；
布尔fileExists=f.exists（）；
如果（文件存在）{
返回true；
}
}
返回false；
}
私有布尔检查形式路径（）{
for（字符串路径：恶意路径）{
文件f=新文件（路径）；
布尔fileExists=f.exists（）；
如果（文件存在）{
返回true；
}
}
返回false；
}
私有静态布尔checkSUonPath（）{
for（字符串pathDir:System.getenv（“路径”）.split（“：”）{
if（新文件（pathDir，“su”）.exists（））{
返回true；
}
}
返回false；
}
私有字符串[]propsReader（）{
InputStream InputStream=null；
试一试{
inputstream=Runtime.getRuntime（）.exec（“getprop”）.getInputStream（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
字符串propval=“”；
试一试{
propval=新扫描仪（inputstream）。使用分隔符（\\A”）.next（）；
}捕获（无接触元素例外e）{
}
返回按比例拆分（“\n”）；
}
私有字符串[]mountReader（）{
InputStream InputStream=null；
试一试{
inputstream=Runtime.getRuntime（）.exec（“mount”）.getInputStream（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
if（inputstream==null）返回null；
字符串propval=“”；
试一试{
propval=新扫描仪（inputstream）。使用分隔符（\\A”）.next（）；
}捕获（无接触元素例外e）{
e、 printStackTrace（）；
}
返回按比例拆分（“\n”）；
}
私有布尔值isAnyPackageFromListInstalled（列出软件包）{
PackageManager pm=activity.getPackageManager（）；
用于（字符串packageName:packages）{
试一试{
pm.getPackageInfo（packageName，0）；
返回true；
}捕获（PackageManager.NameNotFounde异常）{
}
}
返回false；
}
私有布尔checkfordangeruprops（）{
final Map dangerousProps=new HashMap（）；
危险道具放置（“ro.可调试”，“1”）；
危险道具。放置（“旋转安全”，“0”）；
字符串[]行=propsReader（）；
用于（字符串行：行）{
for（字符串键：dangerousProps.keySet（））{
if（行包含（键））{
字符串badValue=dangerousProps.get（key）；
badValue=“[”+badValue+“]”；
if（行包含（badValue））{
返回true；
}
}
}
}
返回false；
}
私有布尔checkForrWpath（）{
字符串[]行=mountReader（）；
用于（字符串行：行）