一文入门 soot

命令行使用

参考实现:Introduction: Soot as a command line tool

下载地址:https://soot-build.cs.uni-paderborn.de/public/origin/master/soot/soot-master/

输入以下命令验证一下即可,会有一些提示信息

java -cp sootclasses-trunk-jar-with-dependencies.jar soot.Main

Jimple

生成

示例代码

public class ForLoop {
    public static void main(String[] args) {
        int x = 0;
        for(int i = 0; i<10; i++){
            x = x + 1;
        }
    }
}

编译class文件,测试的大概目录如下:

图片[1]-一文入门 soot-NGC660 安全实验室

命令:

java -cp sootclasses-trunk-jar-with-dependencies.jar soot.Main -cp . -pp -process-dir examples/ForLoop/ -f J

参数的一些解释

  • -cp .:soot有自己的classpath且默认classpath为空,所以使用的时候需要添加一下当前路径
  • -pp:soot的工作需要类型信息、类的完整层次结构,所以需要java.lang.Object,使用该参数可以自动包含所需的jar文件
  • -process-dir:处理的目录
  • -f J:生成Jimple类型的文件,默认在soot.jar的目录下的sootOutput下,也可以用-d指定输出文件夹
    • S:shimple
    • G:grimple
  • 默认解析class文件,也可以用-src-prec解析指定类型

生成的Jimple文件如下:

public class ForLoop extends java.lang.Object
{

    public void <init>()
    {
        ForLoop r0;

        r0 := @this: ForLoop;

        specialinvoke r0.<java.lang.Object: void <init>()>();

        return;
    }

    public static void main(java.lang.String[])
    {
        java.lang.String[] r0;
        int i1;

        r0 := @parameter0: java.lang.String[];

        i1 = 0;

     label1:
        if i1 >= 10 goto label2;

        i1 = i1 + 1;

        goto label1;

     label2:
        return;
    }
}

基本概念

Soot — 中间代码Jimple介绍

Day 2 Intermediate Representation

jimple是soot分析用到的中间代码(Intermediate Representation),是有类型的三地址码(typed 3-address code)

先从main方法看:

图片[2]-一文入门 soot-NGC660 安全实验室

关于这个identity_stmt:

图片[3]-一文入门 soot-NGC660 安全实验室

另,如果声明的变量有$标记则理解为临时变量(和opcode的内部可重用变量蛮像的)

对于我们这个FoorLoop类,Jimple中的<init>是默认生成的构造函数(源代码没写也会自动加进去),r0会指向this,然后就会调用父类(Object)的构造函数。

图片[4]-一文入门 soot-NGC660 安全实验室

(invokespecial就是specialinvoke)

public class MethodCall {

    String foo(String para1, String para2) {
        return  para1 + " " + para2;
    }

    public static void main(String[] args) {
        MethodCall mc = new MethodCall();
        String result = mc.foo("hello", "world");
    }
}

它的foo方法的jimple代码如下:

java.lang.String foo(java.lang.String, java.lang.String)
    {
        java.lang.StringBuilder $r0, $r2, $r3, $r5;
        java.lang.String r1, r4, $r6;
        MethodCall r7;

        r7 := @this: MethodCall;

        r1 := @parameter0: java.lang.String;

        r4 := @parameter1: java.lang.String;

        $r0 = new java.lang.StringBuilder;

        specialinvoke $r0.<java.lang.StringBuilder: void <init>()>();

        $r2 = virtualinvoke $r0.<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>(r1);

        $r3 = virtualinvoke $r2.<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>(" ");

        $r5 = virtualinvoke $r3.<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>(r4);

        $r6 = virtualinvoke $r5.<java.lang.StringBuilder: java.lang.String toString()>();

        return $r6;
    }

CFG

java -cp sootclasses-trunk-jar-with-dependencies.jar soot.tools.CFGViewer -cp . -pp -process-dir examples/ForLoop/

会在sootOutput下生成dot文件,输入以下命令安装graphviz来处理dot文件

apt-get install graphviz
sudo apt-get install graphviz graphviz-doc

生成png

dot -Tpng ForLoopMain.dot -o ForLoop.png
图片[5]-一文入门 soot-NGC660 安全实验室

IDEA使用

我们先了解一下soot的处理流程

图片[6]-一文入门 soot-NGC660 安全实验室

Jimple为输入起点,后面的矩形方块内:

  • 第一个字母:
    • s:Shimple
    • j:Jimple
    • b:Baf
    • g:Grimp
  • 第二个字母:
    • t:transformation(用户定义的处理阶段)
    • o:optimizations(优化)
    • a:attribute generation(属性生成)
    • b:body(方法体创建阶段)
  • 第三个字母
    • p:pack(处理阶段,可见soot的执行被划分成了很多阶段)

突然发现不如一张图来得实在…

图片[7]-一文入门 soot-NGC660 安全实验室

关于这个全局模式,阶段的组装需要用到

用户可以在转化阶段加入一些自己的分析相关的操作,即在jtp阶段实现。

a easy case

新建一个maven项目导入soot的依赖

<dependency>
    <groupId>org.soot-oss</groupId>
    <artifactId>soot</artifactId>
    <version>4.2.1</version>
</dependency>

初始化配置

@Before
    public void init(){
        soot.G.reset();//re-initializes all of soot
        Options.v().set_src_prec(Options.src_prec_class);//设置处理文件的类型,当然默认也是class文件
        Options.v().set_process_dir(Arrays.asList("target/classes/com/examples"));//处理路径
        Options.v().set_whole_program(true);//开启全局模式
        Options.v().set_prepend_classpath(true);//对应命令行的 -pp
        Options.v().set_output_format(Options.output_format_jimple);//输出jimple文件
        Scene.v().loadNecessaryClasses();//加载所有需要的类
    }

然后就是测试一下:

@Test
    public void test(){
        PackManager.v().runPacks();//运行(要有,不然下面没有输出...坑了好久,加上后运行好慢)
        PackManager.v().writeOutput();//输出jimple到sootOutput目录中
    }

add a transformation

步骤如下:

  1. 实现BodyTransformer或者SceneTransformer,其实也就是internalTransform方法实现了转换
  2. 选择阶段(pack),通常是jtp
  3. 写入自己的方法并添加到pack中,运行即可

我们新建一个Transformer

package com.examples;

import soot.Body;
import soot.BodyTransformer;

import java.util.Map;

public class TransformerTest extends BodyTransformer {
    @Override
    protected void internalTransform(Body body, String s, Map<String, String> map) {
        System.out.println(body.getMethod().getName());//输出下程序方法的名字
    }
}

Test里这么写即可:

@Test
    public void test(){
        PackManager.v().getPack("jtp").add(new Transform("jtp.TT", new TransformerTest()));
        for (SootClass appClazz : Scene.v().getApplicationClasses()) {
            for (SootMethod method : appClazz.getMethods()) {
                Body body = method.retrieveActiveBody();
                PackManager.v().getPack("jtp").apply(body);
            }
        }//只分析应用类,运行速度明显快了
    }

这里有几点需要记录一下:

  • jtp是packPhaseName
  • jtp.TT是transformerPhaseName(我们可以随便起的)
图片[8]-一文入门 soot-NGC660 安全实验室

稍微跟一下上面分析应用类的代码,其中Scene.v().getApplicationClasses()得到所有应用类

图片[9]-一文入门 soot-NGC660 安全实验室

可以看到body是什么内容,然后直接跟进到apply方法中

图片[10]-一文入门 soot-NGC660 安全实验室
图片[11]-一文入门 soot-NGC660 安全实验室

这里猜上面add transformer应该是把jtp.TT名字和我们的transformer绑定在一起,然后根据jtp.TT来找我们的transformer(真的是我猜的,没验证)跟进到apply处,发现找到了

图片[12]-一文入门 soot-NGC660 安全实验室

最后就到了我们的代码处

图片[13]-一文入门 soot-NGC660 安全实验室

确实分析起来节省时间,PackManager.v().runPacks()这个都要跑20多s

flow analysis framework

soot自己有个流分析框架,我们要实现的主要流程

  1. 继承自*FlowAnalysis,backword就是BackwardFlowAnalysis<Unit, FlowSet>,forward就是ForwardFlowAnalysis<Unit, FlowSet>
  2. 一些抽象的实现:
    • 值域的抽象(FlowSet):Soot里有一些默认的,如ArrayPackedSet(其实就是课上提到的bitvector),我们也可以自己实现
    • copy():其实就是把IN的值给OUT或者OUT给IN (取决于forward或backword)
图片[14]-一文入门 soot-NGC660 安全实验室
  • merge():不难理解,就是Transform Function干的事(可以回忆下那两行算法)
  • flowThrough():是流分析的核心,brain of analysis
    • 处理式子(等式右边是表达式)
    • 处理从IN到OUT或者OUT到IN到底发生了什么
protected void flowThrough(FlowSet src, Unit u, FlowSet dest)

我们还需要补充下Soot中Box的概念

图片[15]-一文入门 soot-NGC660 安全实验室

用上面(Unit)u的方法即可得到Box了,如u.getUseBoxes(),u.getDefBoxes(),那么也就不难理解Unit是啥了,上图中的s其实也是一个Unit

我们还要再补充一点点,soot.Local:代表了Jimple中的本地变量

初始化IN和OUT(边界和每个BB的值):newInitialFlow(),entryInitialFlow()

实现构造函数,且必须要调用doAnalysis

super(graph);
super.doAnalysis();

查看结果:(就在本类里测试,当然也可以将我们这个类加入jtp当中)

OurAnalysis analysis = new OurAnalysis(graph);
analysis.getFlowBefore(s);//Unit s
analysis.getFlowAfter(s);

把这些基础的用法都了解,才能在后面更加关注静态分析核心的算法部分(加油)

本文作者:cyanm0un

本文转载于先知社区,如有侵权请联系删除

© 版权声明
THE END
喜欢就支持一下吧
点赞10 分享