一文入门 soot

2022-08-24

字数统计: 1.8k字 | 阅读时长≈ 7分

暂无简介

命令行使用

参考实现：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文件，测试的大概目录如下：

命令：

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方法看：

关于这个identity_stmt：

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

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

（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

IDEA使用

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

Jimple为输入起点，后面的矩形方块内：

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

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

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

用户可以在转化阶段加入一些自己的分析相关的操作，即在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

步骤如下：

实现BodyTransformer或者SceneTransformer，其实也就是internalTransform方法实现了转换
选择阶段（pack），通常是jtp
写入自己的方法并添加到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（我们可以随便起的）

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

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

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

最后就到了我们的代码处

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

flow analysis framework

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

继承自*FlowAnalysis，backword就是BackwardFlowAnalysis<Unit, FlowSet>，forward就是ForwardFlowAnalysis<Unit, FlowSet>
一些抽象的实现：
- 值域的抽象（FlowSet）：Soot里有一些默认的，如ArrayPackedSet（其实就是课上提到的bitvector），我们也可以自己实现
- copy()：其实就是把IN的值给OUT或者OUT给IN （取决于forward或backword）
- merge()：不难理解，就是Transform Function干的事（可以回忆下那两行算法）
- flowThrough()：是流分析的核心，brain of analysis
  - 处理式子（等式右边是表达式）
  - 处理从IN到OUT或者OUT到IN到底发生了什么
```
protected void flowThrough(FlowSet src, Unit u, FlowSet dest)
```
我们还需要补充下Soot中Box的概念

用上面(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
本文来源： 先知社区
原文链接： https://xz.aliyun.com/t/11643
版权声明： 除特别声明外，本文各项权利归原文作者和发表平台所有。转载请注明出处！