soot实现Android Apps插桩（二）

译者注：

上篇介绍了在apk中插入System.out.println(“HELLO”)句子。但是，利用soot插桩java/apk，其实都可以插入类、方法等。soot的分析/插桩等都是在Jimple中间语言上进行的，因此，本文介绍利用soot生成一个完整类的过程，希望能够从中受到启发。

首先，我们需要创建一个将methods放入的class，下述步骤是整个创建类文件的必须过程。

加载java.lang.Object和库类

         加载java.lang.Object，它是Java class层次的根结点。

         在扩展soot框架的代码中，这一步是不需要的；在扩展soot框架时，当用户代码被调用时，类文件的加载已经完成了。  

Scene.v().loadClassAndSupport(“java.lang.Object”);

这行代码将使Soot加载java.lang.Object类，并且创建合适的SootClass对象，为它的字段创建SootMethod和SootFields。当然，其他对象都是继承于java.lang.Object。loadClassAndSupprt将加载这个特殊类的传递包，以至于所有需要java.lang.Object类型的类能够自己加载。

这个过程就是Resolution.

因为我们知道HelloWorld程序将使用到标准类库，因此我们必须resolve:

Scene.v().loadClassAndSupport(“java.lang.System”);

这行引用了Scene.v()。Scene是一个程序中所有SootClass的容器，并且提供了很多有用的方法。通过Scene.v()可以得到一个Scene对象。

注释：Soot加载类一般从classfiles/.Jimple两种输入文件，当是前一种时，Soot将加载每个类文件中常量池引用的所有类，当从.Jimple文件中加载时，soot将只加载需要的类型。

创建一个新的SootClass对象

创建HelloWorldSootClass，并且设置它的父类为java.lang.Object

sClass = newSootClass(“HelloWorld”,Modifier.PUBLIC);

这行代码表示创建一个SootClass对象，代表一个public类HelloWorld。

sClass.setSuperClass(Scene.v().getSootClass(“java.lang.Object”));

这是设置新创建的SootClass对象的父类为java.lang.Object。注意：在Scene中getSootClass方法的使用（译者加：getSootClass将String表示的类转换为SootClass）。

Scene.v().addClass(sClass);

这是将新创建的HelloWorld类加到Scene中。一旦类创建它都应该属于Scene。

向SootClasses中添加方法：

给HelloWorld穿件一个main()方法

现在，我们已经有一个SootClass，我们需要向SootClass中添加方法。

method=new SootMethod("main",Arrays.asList(newType[]{ArrayType.v(RefType.v("java.lang.String"), 1)}),VoidType.v(),Modifier.PUBLIC|Modifier.STATIC);

我们创建了一个新的publicstatic方法mian，并且它的参数是java.lang.String对象，返回类型为void。

SootMethod的构造携带一个list，因此，我们利用Java方法Arrays.asList去创建一个列表，这个列表来自于利用new Type[]生成的一元数组。在list中，我们put一个数组，并且数组类型是java.lang.String的一元数组类型。其中RefType的调用是返回与java.lang.String类对应的类型。

Types：每个SootClass代表一个Java对象，我们可以通过一个给定类型的对象去初始化class，type和class是紧密相关却又独立的。如果要通过java.lang.String类名得到它的类型，可以通过RefType.v(“java.lang.String”)，如果给定一个SootClass对象sc，也可以通过调用sc.getType()得到匹配的类型。 

sClass.addMethod(method);

这行代码向类中添加方法。

向方法中添加代码：

译者加：上篇就是直接向方法中添加System.out.println(“HELLO”)。如果向某个apk/java中添加类，就需要从本篇的《创建一个新的SootClass对象》开始；如果向某个apk/java中添加方法，则应该从本篇的《向SootClasses中添加方法》开始。

如果一个方法没有包含任何的代码，那么它就是无用的。我们将向main方法中添加一些代码。为了达到目的，我们必须选择一种中间语言（Jimple、Baf、Shample等）添加到代码中。

创建JimpleBody：
在soot中，我们将Body依附于一个SootMethod去关联代码和方法。每个Body它与哪个SootMethod对应，但是一个SootMethod仅有一个active Body对应（可以通过SootMethod.getActiveBody()来获取）。多种Intermediate representations（中间语言）提供了Body的不同类型；Soot有JimpleBody、ShimpleBody、BafBody和GrimpBody。
一个Body有三个重要的属性：Local S链、Trap S链和Unit S链，链就相当于列表结构，提供O(1)的复杂度来插入和删除元素。Locals是Body中的局部变量；Trap表示哪个units捕捉哪种异常；Unit S表示句子本身。
注意：Unit在Jimple表示statemetns，而在Baf中表示instructions。
给main类创建一个Jimple Body，并给Body增加locals/instructions。

JimpleBody body = Jimple.v().newBody(method);
Method.setActiveBody(body);

增加Local：

units.add(Jimple.v().newIdentityStmt(arg,Jimple.v().newParameterRef(ArrayType.v(RefType.v(“java.lang.String”),1),0)));

SootMethod声明了它的参数，but these arenot bound to the Local S of the Body.IdentityStmt将第一个参数的值赋给arg，第一个参数类型为string数组。

//insert “tmpRef.println(“Hello world!”)”
{
    SootMethod toCall = 
Scene.v().getMethod(“<java.io.PrintStream:  void println(java.lang.String)>”);
    units.add(Jimple.v().newInvokeStmt(
    Jimple.v().newVirtualInvokeExpr(tmpRef,toCall.makeRef(),StringConstant.v(“Hello World!”))));
}

我们通过方法签名<java.io.PrintStream:void println(java.lang.String)>（方法名为println，属于类PrintStream，返回类型为void，并且携带一个String参数，这些数据足以识别一个方法）得到该方法，并且调用它，参数为StringConstant “Hello World!”。

写类文件：

为了使程序输出为.class文件，方法的body必须从Jimple转换成Jasmin，并且汇编成字节码。通过JasminOutputStream汇编成字节码。

我们先构造输出流（outputstream），将携带Jasmin源码并输出.class文件。我们可以自定义文件名，也可以让soot自己生成正确的文件名。

String fileName = SourceLocator.v().getFileNameFor(sClass,Options.output_format_class);
OutputStream streamOut = new JasminOutputStream(new FileOutputStream(fileName));
PrintWriter writerOut = new PrintWriter(new OutputStreamWriter(streamOut));

我们先将Jimple转化为Jasmin，并且将Jasmin类输到outputstream。

JasminClass jasminClass = new soot.jimple.JasminClass(sClass);
jasminClass.print(writerOut);
writerOut.flush();
streamOut.close();

如果希望输出类型为jimple，应该使用下面的代码：

String fileName = SourceLocator.v().getFileNameFor(sClass,Options.output_format_jimple);
OutputStream streamOut = new FileOutputStream(fileName);
PrintPriter writerOut = new PrintWriter(new OutputStreamWriter(streamOut));
Printer.v().printTo(sClss,writerOut);
writerOut.flush();
streamOut.close();

我们省略了JaminOutputStream，并且调用了方法的printTo。

下面是完整源码：

/* Soot - a J*va Optimization Framework
 * Copyright (C) 2008 Eric Bodden
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Map;

import soot.ArrayType;
import soot.Body;
import soot.BodyTransformer;
import soot.G;
import soot.Local;
import soot.PackManager;
import soot.Printer;
import soot.RefType;
import soot.Scene;
import soot.SootClass;
import soot.SootMethod;
import soot.SourceLocator;
import soot.Transform;
import soot.Type;
import soot.VoidType;
import soot.jimple.JasminClass;
import soot.jimple.Jimple;
import soot.jimple.JimpleBody;
import soot.jimple.StringConstant;
import soot.options.Options;
import soot.toolkits.graph.ExceptionalUnitGraph;
import soot.util.Chain;
import soot.util.JasminOutputStream;

public class MyMain {

	public static void main(String[] args) {
	
		SootClass sClass;
		SootMethod method;
		
		//Resolve dependencies
		Scene.v().loadClassAndSupport("java.lang.Object");
		Scene.v().loadClassAndSupport("java.lang.System");
		
		//Declare 'public class HelloWorld'
		sClass = new SootClass("HelloWorld", Modifier.PUBLIC);
		
		//extends Object
		sClass.setSuperclass(Scene.v().getSootClass("java.lang.Object"));
		Scene.v().addClass(sClass);
		
		//Create the method,public static void main(String[])
		method=new SootMethod("main",Arrays.asList(new Type[]{ArrayType.v(RefType.v("java.lang.String"), 1)}),
				VoidType.v(),Modifier.PUBLIC|Modifier.STATIC);
		
		sClass.addMethod(method);
		
		//Create the method body
		{
			//create emtpy body
			JimpleBody body = Jimple.v().newBody(method);
			method.setActiveBody(body);
			Chain units = body.getUnits();
			Local arg,tmpRef;
			
			//Add some locals,java.lang.String l0
			arg = Jimple.v().newLocal("l0", ArrayType.v(RefType.v("java.lang.String"), 1));
			body.getLocals().add(arg);
			
			//Add locals,java.io.printStream tmpRef
			tmpRef = Jimple.v().newLocal("tmpRef", RefType.v("java.io.PrintStream"));
			body.getLocals().add(tmpRef);
			
			//add "l0=@parameter0"
			units.add(Jimple.v().newIdentityStmt(arg,
					Jimple.v().newParameterRef(ArrayType.v(RefType.v("java.lang.String"), 1), 0)));
			
			//add "tmpRef = java.lang.System.out"
			units.add(Jimple.v().newAssignStmt(tmpRef, Jimple.v().newStaticFieldRef(
					Scene.v().getField("<java.lang.System: java.io.PrintStream out>").makeRef())));
			
			//insert "tmpRef.println("Hello world!")"
			{
				SootMethod toCall = Scene.v().getMethod("<java.io.PrintStream: void println(java.lang.String)>");
				units.add(Jimple.v().newInvokeStmt(Jimple.v().newVirtualInvokeExpr(tmpRef, toCall.makeRef(),StringConstant.v("Hello World!"))));
				
			}
			
			//insert "return"
			units.add(Jimple.v().newReturnVoidStmt());
		}
		
		try {
			String fileName = SourceLocator.v().getFileNameFor(sClass, Options.output_format_jimple);
			OutputStream streamOut = new FileOutputStream(fileName);
			PrintWriter writerOut = new PrintWriter(new OutputStreamWriter(streamOut));
			Printer.v().printTo(sClass, writerOut);
			writerOut.flush();
			streamOut.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

生成的Jimple表示的文件内容如下：

public class HelloWorld extends java.lang.Object
{

    public static void main(java.lang.String[])
    {
        java.lang.String[] l0;
        java.io.PrintStream tmpRef;

        l0 := @parameter0: java.lang.String[];
        tmpRef = <java.lang.System: java.io.PrintStream out>;
        virtualinvoke tmpRef.<java.io.PrintStream: void println(java.lang.String)>("Hello World!");
        return;
    }
}

原文地址

下篇博客将利用soot实现Android Apps插桩（一）（二）中的内容，实现一个较为复杂的插桩过程。