Android漏洞扫描工具Code Arbiter

时间 2019-11-29

标签 android 漏洞扫描工具 code arbiter 栏目 Android 繁體版

原文原文链接

本文转自美团点评技术学院，未经做者许可，不容许私自转载。
美团云知乎机构帐号每日分享云计算产品，技术内容。欢迎关注！
加入美团云技术交流群（QQ群：469243579），每日分享更多精彩技术文章。

目前Android应用代码漏洞扫描工具种类繁多，效果参差不齐，这些工具备一个共同的特色，都是在应用打包完成后对应用进行解包扫描。这种扫描有很是明显的缺点，扫描周期较长，不能向开发者实时反馈代码中存在的安全问题，而且对于问题代码的定位须要手动搜索匹配源码，这样就更不利于开发者对问题代码进行及时的修改。Code Arbiter正是为解决上述两个问题而开发的，专门对Android Studio中的源码进行安全扫描。

1 背景介绍

为实现对Android Studio中的源码进行扫描，最方便的方式即是将扫描工具以IDE插件的形式进行工做。此时一个很天然的想法即是从头构建一个Android Studio插件，可是进行仔细的评估后会发现，这样作难度并不小：

工做量大，许多知识须要学习，如IDE开放API接口、插件UI构建等，同时许多底层模块须要从头构建；
插件的稳定性、检测问题的准确性上都不必定可以达到已有开源工具的效果。

所以咱们转而考虑在已有漏洞检测插件的基础上进行扩展，以知足需求。通过调研，最终入围的两款检测插件是PMD和FindBugs，其中PMD是对Java源码进行扫描，而FindBugs则是对Java源码编译后的class文件进行扫描。考虑到可扩展性及检测的准确性，最终选定了FindBugs。FindBugs是一个静态分析工具，它检查类或者JAR文件，将字节码与一组缺陷模式进行对比来发现可能的问题，能够以独立的JAR包形式运行，也能够做为集成开发工具的插件形式存在。

扩展优化

那么，怎么扩展FindBugs呢？调研发现FindBugs插件具备着极强的可扩展性，只须要将扩展的JAR包导入FindBugs插件，重启，便可完成相关功能的扩展。

下面的问题是如何构建可安装的JAR包。继续调研，发现FindBugs有一款专门对安全问题进行检测的扩展插件Find Security Bugs，该插件主要用于对Web安全问题进行检测，也有极少对Android相关安全问题的检测规则。考虑如下几个缘由，须要对该插件的源码进行重构。

对Android安全问题的检测太少，只包含外部文件使用、Webview、Broadcast使用等寥寥几项；
检测的细粒度上考虑不够彻底，会形成大量的误报，没法知足检测精度的要求；
检测问题的上报只支持英文模式，且问题展现的逻辑性不够严谨，不便于开发者进行问题排查。

基于以上三个缘由，咱们须要对Find Security Bugs的源码进行重写、优化，经过增长检测项来检测尽量多的安全问题，经过优化检测规则来减小检测的误报，问题展现使用中文进行描述，同时优化问题描述的逻辑性，使得开发者可以更易理解并修改相关问题，至此插件实现及优化的方案肯定。

2 工具实现介绍

FindBugs检测的是class文件，所以当待检测的源码未生成编译文件时，FindBugs会先将源码编译生成.class文件，而后对这个class文件进行分析。FindBugs会完成对class文件的自动建模，在此模型的基础上对代码进行分析。按照在实际编写检测代码过程当中的总结，把检测的实现方式分红四种方式，下面分别进行介绍。

2.1 逐行检查

逐行检查主要是针对代码中使用的一些不安全方法或参数进行检测，其实现方式是重写sawOpcode()方法，下面以Android中使用外部存储问题做为示例进行讲解。

Android中获取外部存储文件夹地址的方法主要包括下面这些方法：

getExternalCacheDir()
getExternalCacheDirs()
getExternalFilesDir()
getExternalFilesDirs()
getExternalMediaDirs()
Environment.getExternalStorageDirectory()
Environment.getExternalStoragePublicDirectory()复制代码

检测的方式即是，若是发现存在该方法的调用，则做为一个问题进行上报，实现完整代码以下所示：

public class ExternalFileAccessDetector extends OpcodeStackDetector {

    private static final String ANDROID_EXTERNAL_FILE_ACCESS_TYPE = "ANDROID_EXTERNAL_FILE_ACCESS";
    private BugReporter bugReporter;
    public ExternalFileAccessDetector(BugReporter bugReporter) {
        this.bugReporter = bugReporter;
    }

    @Override
 public void sawOpcode(int seen) {
        //printOpCode(seen);
 if (seen == Constants.INVOKEVIRTUAL && (
        getNameConstantOperand().equals("getExternalCacheDir") ||
        getNameConstantOperand().equals("getExternalCacheDirs") ||
        getNameConstantOperand().equals("getExternalFilesDir") ||
        getNameConstantOperand().equals("getExternalFilesDirs") ||
        getNameConstantOperand().equals("getExternalMediaDirs")
            )) {
// System.out.println(getSigConstantOperand());
 bugReporter.reportBug(new BugInstance(this, ANDROID_EXTERNAL_FILE_ACCESS_TYPE, Priorities.NORMAL_PRIORITY).addClass(this).addMethod(this).addSourceLine(this));
        }
        else if(seen == Constants.INVOKESTATIC && getClassConstantOperand().equals("android/os/Environment") && (getNameConstantOperand().equals("getExternalStorageDirectory") || getNameConstantOperand().equals("getExternalStoragePublicDirectory"))) {
            bugReporter.reportBug(new BugInstance(this, ANDROID_EXTERNAL_FILE_ACCESS_TYPE, Priorities.NORMAL_PRIORITY).addClass(this).addMethod(this).addSourceLine(this));
        }
    }
}复制代码

该类的实现是继承OpcodeStackDetector类，是FindBugs中的一个抽象类，封装了对于获取代码特定参数的方法调用。sawOpcode方法参数能够理解为待检测代码行的行号，经过printOpCode(seen)能够打印该代码行的具体内容。Constants.INVOKEVIRTUAL表示该行调用类的实例方法，Constants.INVOKESTATIC表示调用类的静态方法。getNameConstantOperand方法表示获取被调用方法的名称，getClassConstantOperand方法表示获取调用类的名称，getSigConstantOperand方法表示获取方法的全部参数。bugReporter.reportBug用于上报检测到的漏洞信息，其中BugInstance的三个参数分别表示：检测器、漏洞类型、漏洞等级，其中漏洞等级分为五个级别，以下表所示：

名称  参数  含义
HIGH_PRIORITY  1  高危风险
NORMAL_PRIORITY  2  中危风险
LOW_PRIORITY  3  低危风险
EXP_PRIORITY  4  安全提醒
IGNORE_PRIORITY  5  可忽略风险复制代码

addClass、addMethod、addSourceLine用于指定该漏洞所在的类、方法、行，方便报告漏洞时定位关键代码。

2.2 逐方法检查

逐方法检查首先获取待检测类的全部内容，而后对类中的方法进行逐个检查，多用于对方法体进行检测，其实现的方法主要是经过重写visitClassContext方法，下面以对Android TrustManager的空实现的检测为例进行说明。

TrustManager的空实现，主要是指对于检测Server端证书是否可信的方法checkServerTrusted，是不是空实现。下面展现问题代码，若是是空实现那么将致使客户端接收任意证书，从而形成加密后的HTTPS消息被中间人解密。

@Override
public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

}复制代码

检测的方式是经过遍历类中的全部方法，找到checkServerTrusted方法，对方法总体进行检测，肯定其是否为空实现，部分代码以下所示：

public class WeakTrustManagerDetector implements Detector {
...
public WeakTrustManagerDetector(BugReporter bugReporter) {
        this.bugReporter = bugReporter;
    }

    @Override
 public void visitClassContext(ClassContext classContext) {
        JavaClass javaClass = classContext.getJavaClass();

        //The class extends X509TrustManager
  boolean isTrustManager = InterfaceUtils.isSubtype(javaClass,"javax.net.ssl.X509TrustManager");
        boolean isHostnameVerifier = InterfaceUtils.isSubtype(javaClass,"javax.net.ssl.HostnameVerifier");

// if (!isTrustManager && !isHostnameVerifier) return;
 if (!isTrustManager && !isHostnameVerifier){
            for (Method m : javaClass.getMethods()) {
                allow_All_Hostname_Verify(classContext, javaClass, m);
            }
        }

        Method[] methodList = javaClass.getMethods();

        for (Method m : methodList) {
            MethodGen methodGen = classContext.getMethodGen(m);

            if (DEBUG) System.out.println(">>> Method: " + m.getName());

            if (isTrustManager &&
                    (m.getName().equals("checkClientTrusted") ||
                     m.getName().equals("checkServerTrusted") ||
                     m.getName().equals("getAcceptedIssuers"))) {
                if(isEmptyImplementation(methodGen)) {
                    bugReporter.reportBug(new BugInstance(this, WEAK_TRUST_MANAGER_TYPE, Priorities.NORMAL_PRIORITY).addClassAndMethod(javaClass, m));
                }
......复制代码

classContext.getJavaClass用于获取整个类的全部内容；javaClass.getMethods用于获取该类中的全部方法，以一个方法列表的形式返回；classContext.getMethodGen用于获取该方法的内容；isEmptyImplementation将方法的内容导入该函数进行检测，用于肯定方法是不是空实现，该方法的代码以下所示：

private boolean isEmptyImplementation(MethodGen methodGen){
    boolean invokeInst = false;
    boolean loadField = false;

    for (Iterator itIns = methodGen.getInstructionList().iterator();itIns.hasNext();) {
        Instruction inst = ((InstructionHandle) itIns.next()).getInstruction();
        if (DEBUG)
            System.out.println(inst.toString(true));

        if (inst instanceof InvokeInstruction) {
            invokeInst = true;
        }
        if (inst instanceof GETFIELD) {
            loadField = true;
        }
    }
    return !invokeInst && !loadField;
}复制代码

该方法主要用于检测方法中是否包含方法调用、域操做，若是没有包含则认为是一个空实现的方法。所以该方法对于只包含 return true/false 语句的方法体一样认为是一个空实现。

2.3 污点分析

数据流分析主要用于分析特定方法加载的参数是否可以被用户控制，即进行污点分析。作污点分析首先须要定义污染源（source点），污染源能够理解为可以被用户控制的输入数据，这里定义的Android污染源主要包括用户的输入、Intent传入的数据，下面展现定义的部分污染源（source点）：

- EditText
android/widget/EditText.getText()Landroid/text/Editable;:TAINTED
- Intent
android/content/Intent.getAction()Ljava/lang/String;:TAINTED
android/content/Intent.getStringExtra(Ljava/lang/String;)Ljava/lang/String;:TAINTED
......
- Bundle
android/os/Bundle.get(Ljava/lang/String;)Ljava/lang/Object;:TAINTED
android/os/Bundle.getString(Ljava/lang/String;)Ljava/lang/String;:TAINTED
......复制代码

定义好污染源后就须要肯定污染的触发点（sink点），能够理解为会触发危险操做的函数。定义sink点的方式有两种，一种是直接从文件中导入，以命令注入为示例，代码以下：

public class CommandInjectionDetector extends BasicInjectionDetector {

    public CommandInjectionDetector(BugReporter bugReporter) {
        super(bugReporter);
        loadConfiguredSinks("command.txt", "COMMAND_INJECTION");
 }复制代码

从代码中能够清楚的看到其导入方式是继承BasicInjectionDetector类，而后再该类的构造方法中经过loadConfiguredSinks方法，导入包含sink点的文件，下面展现该示例文件中的内容：

java/lang/Runtime.exec(Ljava/lang/String;)Ljava/lang/Process;:0
java/lang/Runtime.exec([Ljava/lang/String;)Ljava/lang/Process;:0
java/lang/Runtime.exec(Ljava/lang/String;[Ljava/lang/String;)Ljava/lang/Process;:0,1
java/lang/Runtime.exec([Ljava/lang/String;[Ljava/lang/String;)Ljava/lang/Process;:0,1
java/lang/Runtime.exec(Ljava/lang/String;[Ljava/lang/String;Ljava/io/File;)Ljava/lang/Process;:1,2
java/lang/Runtime.exec([Ljava/lang/String;[Ljava/lang/String;Ljava/io/File;)Ljava/lang/Process;:1,2
java/lang/ProcessBuilder.<init>([Ljava/lang/String;)V:0
java/lang/ProcessBuilder.<init>(Ljava/util/List;)V:0
java/lang/ProcessBuilder.command([Ljava/lang/String;)Ljava/lang/ProcessBuilder;:0
java/lang/ProcessBuilder.command(Ljava/util/List;)Ljava/lang/ProcessBuilder;:0
dalvik/system/DexClassLoader.loadClass(Ljava/lang/String;)Ljava/lang/Class;:0复制代码

另外一种是自定义导入，其实现是经过覆盖BasicInjectionDetector类中的getInjectionPoint方法，以WebView.loadurl方法为例，示例代码以下所示：

@Override
 protected InjectionPoint getInjectionPoint(InvokeInstruction invoke, ConstantPoolGen cpg, InstructionHandle handle) {
        assert invoke != null && cpg != null;
        String method = invoke.getMethodName(cpg);
        String sig    = invoke.getSignature(cpg);
// System.out.println(invoke.getClassName(cpg));
 if(sig.contains("Ljava/lang/String;")) {
            if("loadUrl".equals(method)){
                if(sig.contains("Ljava/util/Map;")){
                    return new InjectionPoint(new int[]{1}, WEBVIEW_LOAD_DATA_URL_TYPE);
                }else{
                    return new InjectionPoint(new int[]{0}, WEBVIEW_LOAD_DATA_URL_TYPE);
                }
            }else if("loadData".equals(method)){
                return new InjectionPoint(new int[]{2}, WEBVIEW_LOAD_DATA_URL_TYPE);
            }else if("loadDataWithBaseURL".equals(method)){
                //BUG
 return new InjectionPoint(new int[]{4}, WEBVIEW_LOAD_DATA_URL_TYPE);
            }
        }
        return InjectionPoint.NONE;
    }复制代码

经过实例化InjectionPoint类构造新的sink点，其构造方法中的第一个参数表示该方法接收污染数据参数的位置，如方法为webView.loadUrl(url)，其第一个参数就是new int[]{0}，其它的以此类推。

上报发现漏洞的状况，则经过覆盖getPriorityFromTaintFrame方法的实现，示例代码以下所示：

@Override
 protected int getPriorityFromTaintFrame(TaintFrame fact, int offset)
            throws DataflowAnalysisException {
        Taint stringValue = fact.getStackValue(offset);
// System.out.println(stringValue.getConstantValue());
 if (stringValue.isTainted() || stringValue.isUnknown()) {
            return Priorities.NORMAL_PRIORITY;
        } else {
            return Priorities.IGNORE_PRIORITY;
        }
    }
通复制代码

过fact.getStackValue获取检测的函数变量，若是该变量被污染（isTainted）或变量是否被污染未知（可是是可控制变量），那么做为一个中危风险（Priorities.NORMAL_PRIORITY）进行上报，其它的状况则上报为可忽略风险（Priorities.IGNORE_PRIORITY）。

2.4 自定义代码检测

自定义代码检测实现的前半部分同2.2的逐方法检测相似，均是获取类的内容，而后遍历全部的方法，对方法的内容进行检测，可是在具体代码检测实现上是经过自定义分析进行。目前自定义检测只应用到Android中本地拒绝服务的检测。本地拒绝服务的被触发的重要缘由在于对经过Intent获取的参数未进行异常捕获，所以检测实现的方式即是检测获取参数的代码行是否被try catch包裹（这个存在偏差，待改进）。对于其代码分析，不能使用FindBugs模型进行分析，而是使用最原始的class代码进行分析，原始class代码的形式经过javap命令进行查看，下图展现示例代码。

对原始class文件进行分析存在的缺陷是没法定位具体的代码行，那么在进行问题上报时没法将问题定位到代码行，所以第一步须要在原有模型的基础上对全部包含Intent获取参数的方法的位置存储到一个Map结构中，方便后面对方法的定位，代码实现以下所示，获取方法所在的行，而后以方法名做为Key值，以代码行相关信息做为Value值，存储到Map中。

private Map<String, List<Location>> get_line_location(Method m, ClassContext classContext){
        HashMap<String, List<Location>> all_line_location = new HashMap<>();
        ConstantPoolGen cpg = classContext.getConstantPoolGen();
        CFG cfg = null;
        try {
            cfg = classContext.getCFG(m);
        } catch (CFGBuilderException e) {
            e.printStackTrace();
            return all_line_location;
        }
        for (Iterator<Location> i = cfg.locationIterator(); i.hasNext(); ) {
            Location loc = i.next();
            Instruction inst = loc.getHandle().getInstruction();
            if(inst instanceof INVOKEVIRTUAL) {
                INVOKEVIRTUAL invoke = (INVOKEVIRTUAL) inst;
 if(all_line_location.containsKey(invoke.getMethodName(cpg))){
                        all_line_location.get(invoke.getMethodName(cpg)).add(loc);
                    }else {
                        LinkedList<Location> loc_list = new LinkedList<>();
                        loc_list.add(loc);
                        all_line_location.put(invoke.getMethodName(cpg), loc_list);
                    }
// }
 }
        }
        return all_line_location;
    }复制代码

以后获取Exception包裹的范围，FindBugs中包含对Exception的建模，所以可以经过其模型可以直接获取其范围并存储到一个列表中，代码以下所示，其中exceptionTable[i].getStartPC用于获取try catch 的起始代码行，exceptionTable[i].getEndPC用于获取try catch 的结束代码行。

public int[] getExceptionScope(){
        try {
            CodeException[] exceptionTable = this.code.getExceptionTable();
            int[] exception_scop = new int[exceptionTable.length * 2];
            for (int i = 0; i < exceptionTable.length; i++) {
                exception_scop[i * 2] = exceptionTable[i].getStartPC();
                exception_scop[i * 2 + 1] = exceptionTable[i].getEndPC();
            }
            return exception_scop;
        }catch (Exception e){
 }
        return new int[0];
    }复制代码

在对代码进行逐行检查时，由于使用的是最原始class文件形式，所以须要限定其遍历的范围，限定的方式是经过代码的行号，即上图中每行代码的第一个数值。首先须要获取代码总行数的大小，获取的方式即是解析FindBugs建模后的第一行代码，找到关键词code-length后面的数值，即为代码的行数，解析代码以下所示：

public int get_Code_Length(String firstLineCode){
        try{
            String[] split1 = firstLineCode.split("code_length");
// System.out.println(split1[split1.length-1]);
 byte[] code_length_bytes = split1[split1.length-1].getBytes();
            byte[] new_code_bytes = new byte[code_length_bytes.length];
            for(int i=0; i<code_length_bytes.length; i++){
// System.out.println();
 if(code_length_bytes[i]<48 || code_length_bytes[i]>57){
                    new_code_bytes[i] = 32;
                }else{
                    new_code_bytes[i] = code_length_bytes[i];
                }
            }
            return Integer.parseInt(new String(new_code_bytes).trim());
        }catch(Exception e){
            e.printStackTrace();
        }
        return 0;
    }复制代码

最后对代码进行逐行遍历，遍历中为防止try catch块被遍历到，使用行号来限制遍历的范围。检测代码行是否包含经过Intent获取参数，及该行是否被try catch 包裹，若是上述两个条件均被触发，那么就做为一个问题进行上报。示例代码以下，其中get_code_line_index方法用于获取代码的行号，获取的方式是截取代码行的首字符的数值，以肯定是否在代码包裹的范围内。

private void analyzeMethod(JavaClass javaClass, Method m, ClassContext classContext) throws CFGBuilderException {
        HashMap<String, List<Location>> all_line_location = (HashMap<String, List<Location>>) get_line_location(m, classContext);
        Code code = m.getCode();
        StringCodeAnalysis sca = new StringCodeAnalysis(code);
        String[] codes = sca.codes_String_Array();
        int code_length = sca.get_Code_Length(sca.get_First_Code(codes));
        int[] exception_scop = sca.getExceptionScope();
        for(int i=1; i<codes.length; i++){
            int line_index = sca.get_code_line_index(codes[i]);
            if (line_index < code_length){
                if(codes[i].toLowerCase().contains("invokevirtual") &&
                        (codes[i].contains("android.content.Intent.get")  || codes[i].contains("android.os.Bundle.get"))){
                    if(exception_scop.length == 0){
                        ......
                    }else{
                        boolean is_scope = false;
                        for(int j=0; j<exception_scop.length; j+=2){
                            int start = exception_scop[j];
                            int end = exception_scop[j+1];
                            if(line_index >= start && line_index <= end){
                                is_scope = true;
                            }
                            if(is_scope){
                                break;
                            }
                        }
                        if(!is_scope){
                            String method_name = get_method_name(codes[i]);
                            if(all_line_location.containsKey(method_name)){
                                for(Location loc : all_line_location.get(method_name)){
                                    bugReporter.reportBug(new BugInstance(this, LOCAL_DENIAL_SERVICE_TYPE, Priorities.NORMAL_PRIORITY).addClass(javaClass).addMethod(javaClass, m).addSourceLine(classContext, m, loc));
                                }
                            }else {
                                bugReporter.reportBug(new BugInstance(this, LOCAL_DENIAL_SERVICE_TYPE, Priorities.NORMAL_PRIORITY).addClass(javaClass).addMethod(javaClass, m));
 }
                        }
                    }
                }
            }
        }
    }
复制代码

3 注册打包

上面详细叙述了如何构造本身的问题检测代码，完成检测方法的书写后，下一步就是在配置文件中对检测方法进行注册，才能使检测代码运转起来。

须要在两个文件中进行注册，第一个是findbugs.xml，注册示例以下：

<Detector class="com.h3xstream.findsecbugs.android.LocalDenialOfServiceDetector" reports="LOCAL_DENIAL_SERVICE"/>
<BugPattern type="LOCAL_DENIAL_SERVICE" abbrev="SECLDOS" category="Android安全问题" cweid="276"/>复制代码

其中Detector用于注册该检测方法的位置及其惟一标识，BugPattern用于对检测出的问题进行归类，方便展现，如此处归类到"Android安全问题"中，那么在生成报告的时候问题也将被归类到"Android安全问题"中。

第二个是messages.xml注册，注册示例以下，该注册主要是对该问题进行说明，包括问题的危害及修复方法。

<Detector class="com.h3xstream.findsecbugs.android.LocalDenialOfServiceDetector"> <Details>Local复制代码

一切完成就绪后使用Maven进行打包，就生产了供FindBugs集成开发工具插件使用的JAR包，完成安装并重启，便可使用自定义插件对特定问题进行检测。

4 结语

本文介绍了Android集成开发环境Android Studio的代码实时检测工具Code Arbiter的产生缘由及代码实现，最后展现了分析的效果。经过Code Arbiter在生产环境中的应用，其检测效果仍是至关不错，可以发现不少编码过程当中存在的问题。可是Code Arbiter仍然存在许多不足，须要优化。后续将在如下两个方面对工具进行改进：

扩大漏洞检测范围，使Code Arbiter可以囊括Android编码常见安全问题；
优化漏洞检测规则，提升检测的准确性，减小误报。