赛博空间，攻防之战，此起彼伏

矛与盾的对决，攻与守的碰撞

在这里，我们一起来看

道德黑客使用了哪些杀手锏

正义蓝军如何见招拆招

#pragma once

// symbol包含所有的字符串，它的内部实现是一个ordinal number
// 我们可以使用 .type <new-type> <: <other-type> 自定义一个类型
.type Insn <: symbol
.type Var <: symbol
.type Heap <: symbol
.type Field <: symbol
.type Method <: symbol
.type Class <: symbol

// load data from facts
// class section
.decl ClassModifier(mod:symbol, class:Class)
.input ClassModifier

.decl ClassType(class:Class)
.input ClassType

.decl InterfaceType(interface:Class)
.input InterfaceType

.decl ApplicationClass(class:Class)
.input ApplicationClass

.decl DirectSuperclass(child:Class, parent:Class)
.input DirectSuperclass

.decl DirectSuperinterface(child:Class, parent:Class)
.input DirectSuperinterface

// method section
// 这个arity指的是方法的参数个数
.decl MethodInfo(method:Method, simplename:symbol, param:symbol, class:Class, return:Class, jvmDescriptor:symbol, arity:number)
.input MethodInfo(IO=file, filename="Method.facts", delimiter="t")

.decl MethodModifier(mod:symbol, method:Method)
.input MethodModifier(IO=file, filename="Method-Modifier.facts", delimiter="t")

// fact格式：<com.xx.XXX: java.util.Map getParams()>	<com.xx.XXX: java.util.Map getParams()>/@this
// 实际上，soot-fact-genertator会遍历每一个方法，然后生成 method method/@this 格式的ThisVar.fact
.decl ThisVar(method:Method, this:Var)
.input ThisVar

// 这个谓词代表方法的形参，number代表第几个形参，从0开始，fact格式：0	<com.xx.XXX: void setParams(java.util.Map)>	<com.xx.XXX: void setParams(java.util.Map)>/@parameter0
.decl FormalParam(n:number, method:Method, param:Var)
.input FormalParam

// insn格式：method/指令/当前指令是当前方法内相同类型指令的第几个（从0开始）；index代表当前指令在方法内的唯一索引；var代表生成IR时方法内的局部变量；method代表是哪个方法内的指令；
// fact的格式为：<com.xx.XXX: java.util.Map getParams()>/return/0	2	<com.xx.XXX: java.util.Map getParams()>/$stack1	<com.xx.XXX: java.util.Map getParams()>
.decl Return(insn:Insn, index:number, var:Var, method:Method)
.input Return

// insn格式：InvokeExpr/insnIndex，例如:<xx.xxx.XX: java.util.Map execute(xx.xxx.AA)>/java.util.Map.get/0，index就是指令在方法内的唯一索引；recerver就是生成IR时方法内的局部变量；
.decl VirtualMethodInvocation(insn:Insn, index:number, callee:Method, receiver:Var, caller:Method)
.input VirtualMethodInvocation

.decl StaticMethodInvocation(insn:Insn, index:number, callee:Method, caller:Method)
.input StaticMethodInvocation

.decl SpecialMethodInvocation(insn:Insn, index:number, callee:Method, receiver:Var, caller:Method)
.input SpecialMethodInvocation

// 这里就是代表方法实参传入方法调用，insn就是invokeExpr，var就是传入方法调用的实参（实际是IR生成的局部变量）
.decl ActualParam(n:number, insn:Insn, var:Var)
.input ActualParam

// 这里就是函数返回值赋值给局部变量，var就是IR中的局部变量，insn就是InvokeExpr；
.decl AssignReturnValue(insn:Insn, var:Var)
.input AssignReturnValue

// Field section

.decl FieldInfo(field:Field, declaringType:Class, simplename:symbol, type:Class)
.input FieldInfo(IO=file, filename="Field.facts", delimiter="t")

.decl FieldModifier(modifier:symbol, field:Field)
.input FieldModifier(IO=file, filename="Field-Modifier.facts", delimiter="t")

// 这里是加载实例的属性，insn格式：<xx.xxx.XXX: java.util.Map getParams()>/read-field-params/0；base就是IR中的局部变量，从这个局部变量中加载属性；var就是加载的属性赋值给了var；inMethod就是发生在哪个方法中；
.decl LoadInstanceField(insn:Insn, index:number, var:Var, base:Var, field:Field, inMethod:Method)
.input LoadInstanceField

.decl StoreInstanceField(insn:Insn, index:number, var:Var, base:Var, field:Field, inMethod:Method)
.input StoreInstanceField

.decl LoadStaticField(insn:Insn, index:number, var:Var, field:Field, inMethod:Method)
.input LoadStaticField

.decl StoreStaticField(insn:Insn, index:number, var:Var, field:Field, inMethod:Method)
.input StoreStaticField

// Array section
// insn格式：<xx.xxx.XXX: void init(java.lang.String)>/read-array-idx/0；array就是代表数组的局部变量；to就是取出来的元素赋值给to；
.decl LoadArrayIndex(insn:Insn, index:number, to:Var, array:Var, inMethod:Method)
.input LoadArrayIndex

.decl StoreArrayIndex(insn:Insn, index:number, from:Var, array:Var, inMethod:Method)
.input StoreArrayIndex

// 这里其实就是字面意思，arrayType就是数组类型，componentType就是数组元素类型；
.decl ComponentType(arrayType:Class, componentType:Class)
.input ComponentType

// others section
// 字面意思，变量的类型，var就是IR中的局部变量，格式为：<xx.xxx.XXX: java.util.Map getParams()>/l0#_0；class就是变量的类型
.decl VarType(var:Var, class:Class)
.input VarType(IO=file, filename="Var-Type.facts", delimiter="t")

// 字面意思，对应赋值指令
.decl AssignLocal(insn:Insn, index:number, from:Var, to:Var, inMethod: Method)
.input AssignLocal

.decl AssignCast(insn:Insn, index:number, from:Var, to:Var, type:Class, inMethod:Method)
.input AssignCast(IO=file, filename="AssignCast.facts", delimiter="t")

// 堆分配，heap代表new指令产生的对象，格式为：<xx.xxx.XXX: void <init>()>/new xx.xxx.AAA/0；var就是new出来的对象赋值给var；linenumber就是指令所在的代码行，是实际class中的代码行，而不是IR中的；
// 此外，堆对象不一定是new指令产生，可能是直接的字符字面量等等
.decl AssignHeapAllocation(insn:Insn, index:number, heap:Heap, var:Var, inMethod:Method, linenumber:number)
.input AssignHeapAllocation

// 这里指的是new指令产生的对象及对象的类型，格式为：<xx.xxx.XXX: void <init>()>/new xx.xxx.AAA/0	xx.xxx.AAA
.decl NormalHeap(value:Heap, class:Class)
.input NormalHeap

// 这里指的是new指令产生的对象及对象的类型，格式为：<xx.xxx.XXX: void <init>()>/new xx.xxx.AAA/0 xx.xxx.AAA
.decl NormalHeap(value:Heap, class:Class)
.input NormalHeap

#pragma once
#include "utils.dl"

// 入口点，也就是CHA分析的入口点
.decl EntryPoint(simplename:symbol, descriptor:symbol, class:Class)
// 从入口点开始，能调用到的方法
.decl Reachable(method:Method, step:number)
// 想要寻找的sink方法
.decl SinkDesc(simplename:symbol, class:Class)
.decl SinkMethod(method:Method)
// 入口函数，和入口点对应
.decl EntryMethod(method:Method)
// 这个地方主要是定义一个调用链黑名单节点，如果调用链到了这个节点，则断开
.decl BanCaller(method:Method)

// 声明call-graph谓词
.decl CallGraph(insn:Insn, caller:Method, callee:Method)

// SinkMethod谓词推导，SinkMethod不能为抽象方法，可以是SinkDesc中指定的class的子类中的方法
SinkMethod(method) :-
    SinkDesc(simplename, class),
    SubEqClass(subeqclass, class),
    !MethodModifier("abstract", method),
    MethodInfo(method, simplename, _, subeqclass, _, _, _).

// Dispatch谓词表明了class能调用到的实际方法（即class中不存在方法，则会调用从class父类继承而来的方法）
// 这里就是初始化入口方法，且经过Dispatch谓词限定，表明入口方法不是抽象方法
// 同时入口方法也需要加入到Reachable中，并且设置其深度为0（这个深度是为了限制call-graph的深度过大）
EntryMethod(method),
Reachable(method, 0) :- 
    EntryPoint(simplename, descriptor, class),
    Dispatch(simplename, descriptor, class, method).

// SpecialMethodInvocation可以直接确定为一个call-graph，当然，需要能Reachable到对应的caller
Reachable(callee, n+1),
CallGraph(insn, caller, callee) :-
    Reachable(caller, n),
    !BanCaller(caller),
    n < MAXSTEP,
    SpecialMethodInvocation(insn, _, callee, _, caller).

// StaticMethodInvocation可以直接确定为一个call-graph，当然，需要能Reachable到对应的caller
Reachable(callee, n+1),
CallGraph(insn, caller, callee) :-
    Reachable(caller, n),
    !BanCaller(caller),
    n < MAXSTEP,
    StaticMethodInvocation(insn, _, callee, caller).

// CHA算法的关键,计算多态（Virtual Call）的callee
Reachable(callee, n+1),
CallGraph(insn, caller, callee) :-
    Reachable(caller, n),
    !BanCaller(caller),
    n < MAXSTEP,
		// 根据caller拿到对应的callee对应的VirtualInvoke
    VirtualMethodInvocation(insn, _, method, receiver, caller),
		// 根据method（也就是callee）得到callee的simplename和descriptor
    MethodInfo(method, simplename, _, _, _, descriptor, _),
		// 拿到receiver的声明类型
    VarType(receiver, class),
		// 拿到receiver的声明类型的子类（包含自身）
    SubEqClass(subeqclass, class),
		// 必须是非抽象类
    !ClassModifier("abstract", subeqclass),
		// 找到真正的运行时callee
    Dispatch(simplename, descriptor, subeqclass, callee).

// 这里是手动把java.security.AccessController#doPrivileged的call-graph连起来了
// 也就是callee就是java.security.AccessController#doPrivileged方法的第0个参数的run()方法
Reachable(callee, n+1),
CallGraph(insn, caller, callee) :- 
    Reachable(caller, n),
    !BanCaller(caller),
    n < MAXSTEP,
    StaticMethodInvocation(insn, _, method, caller),
    MethodInfo(method, "doPrivileged", _, "java.security.AccessController", _, _, _),
    ActualParam(0, insn, param),
    VarType(param, class),
    MethodInfo(callee, "run", _, class, _, _, 0).

// 如果定义了CHAO宏，并且大于0，才会启动下面的谓词推导
// CHAO is CHA OPTIMIZATION LEVEL
#if CHAO > 0

// SinkReachable就是把callee是sink的Call-Graph链形成一个叫做SinkReachable的谓词
// 代表method经过step步长后能到达sink方法
.decl SinkReachable(method:Method, sink:Method, step:number)

SinkReachable(sink, sink, 0) :-
    SinkMethod(sink).

SinkReachable(caller, sink, n+1) :-
    n < MAXSTEP,
    SinkReachable(callee, sink, n),
    CallGraph(_, caller, callee).

#endif

// 如果定义了CHAO宏，并且大于1，才会启动下面的谓词推导
// CHAO is CHA OPTIMIZATION LEVEL
#if CHAO > 1

// 这个谓词代表了能到达sink，且步长最短的caller
.decl ShortestPathToSink(caller:Method, sink:Method, step:number)

// 代表从EntryMethod到sink的最短路径
ShortestPathToSink(entry, sink, n) :-
		// SinkReachable(entry, sink, step)代表了从entry到sink所需要step步长
		// 而 min step : {SinkReachable(entry, sink, step)} 则代表了所有的这些组合中，步长最短的组合
    n = min step : {SinkReachable(entry, sink, step)},
    SinkMethod(sink),
    EntryMethod(entry).

// 找到从EntryMethod到sink的最短路径后，从EntryMethod开始往下找污点链路上的callee（也就是callee经过n-1步长后可达sink），形成一个新的ShortestPathToSink
// 前面我们计算的SinkReachable，代表的是从entry到达sink的最短路径
// 现在我们要在这条最短路径上，把路径上的各个节点到sink的路径也加入到SinkReachable
// 比如entry到sink最短需要3步，这条最短路径为：entry->a->b->sink
// 那么我们就可以得到SinkReachable(entry, sink, 3)
// 然后经过下面的推导，我们就可以继续得到：SinkReachable(a, sink, 2)、SinkReachable(b, sink, 1)
ShortestPathToSink(callee, sink, n-1) :-
    n < MAXSTEP + 1,
    ShortestPathToSink(caller, sink, n),
    SinkReachable(callee, sink, n-1),
    CallGraph(_, caller, callee).

#endif

.decl RefinedReachable(method:Method)

#ifdef CHAO
    #if CHAO == 1
        RefinedReachable(method) :-
						// SinkReachable(method, _, _).代表method能到达sink，但是这个method不一定是最短的路径
            SinkReachable(method, _, _).
    #endif
    #if CHAO == 2
        RefinedReachable(method) :-
						// ShortestPathToSink(method, _, _).代表method能到达sink，且路径最短
            ShortestPathToSink(method, _, _).
    #endif
#else
    RefinedReachable(method) :-
				// Reachable(method, _).代表了能从entry访问到method，这个method不一定是污点路径上的节点
        Reachable(method, _).
#endif

.decl CallNode(node:Method, label:symbol)
.output CallNode

// 下面就是为RefinedReachable(node)中的节点打标签
CallNode(node, "method") :-
    !EntryMethod(node),
    !SinkMethod(node),
    RefinedReachable(node).

CallNode(node, "sink") :-
    RefinedReachable(node),
    SinkMethod(node).

CallNode(node, "entry") :-
    RefinedReachable(node),
    EntryMethod(node).

.decl CallEdge(caller:Method, callee:Method)
.output CallEdge

// CallEdge(caller, callee)中的caller和callee都需要在RefinedReachable(node)这个关系中
// RefinedReachable(node)具体的fact需要根据CHAO的值来确定
// 如果CHAO=1，则RefinedReachable(node)代表能到达sink的所有节点（不一定是最短路径上的节点）
// 如果CHAO=2，则RefinedReachable(node)代表能到达sink的所有节点，且这些节点都是最短路径上的节点
// 如果CHAO等于其他，则RefinedReachable(node)代表从Entry可达的所有节点，其中包含了能到达sink的节点，也包含了不能到达sink的节点，数量巨多，极其不推荐使用这种方式
CallEdge(caller, callee) :-
    RefinedReachable(caller),
    RefinedReachable(callee),
    CallGraph(_, caller, callee).

#define MAXSTEP 23
// 这里推荐使用CHAO 1，这个选项可以只输出source->sink链路上的节点，否则neo4j查询会很慢
#define CHAO 1

#include "../logic/cha.dl"


// 加载方法注解fact
// Method-Annotation.facts这个fact文件中包含了所有方法以及方法对应的注解
.decl MethodAnnotation(method:Method, annotation:symbol)
.input MethodAnnotation(IO=file, filename="Method-Annotation.facts", delimiter="t")

// init SinkDesc
// common sink
SinkDesc("exec", "java.lang.Runtime").
SinkDesc("<init>", "java.lang.ProcessBuilder").
SinkDesc("start", "java.lang.ProcessImpl").
SinkDesc("loadClass", "java.lang.ClassLoader").
SinkDesc("defineClass", "java.lang.ClassLoader").
SinkDesc("readObject", "java.io.ObjectInputStream").
SinkDesc("readExternal", "java.io.ObjectInputStream").

// SSTI sink
SinkDesc("evaluateString", "org.mozilla.javascript.Context").

// init entrypoint
// entry节点即为存在@javax.ws.rs.Path注解的方法
EntryPoint(simplename, descriptor, class) :-
    MethodAnnotation(method,"javax.ws.rs.Path"),
    MethodInfo(method, simplename, _, class, _, descriptor, _).

#!/bin/bash

dbname=$1$(date "+%m%d%H%M")

neo4j-admin import --relationships=Call="../neo4j/CallEdgeHeader.csv,../out_test/.*CallEdge.csv" --nodes="../neo4j/CallNodeHeader.csv,../out_test/.*CallNode.csv" --database=$dbname --delimiter="t"

if grep -q "dbms.default_database=" /Volumes/SSD/programs/neo4j/neo4j-community-4.4.12/conf/neo4j.conf; then
    sed -i -E "s/dbms.default_database=w+/dbms.default_database=$dbname/g" /Volumes/SSD/programs/neo4j/neo4j-community-4.4.12/conf/neo4j.conf
		echo "[!] replaced dbms.default_database=$dbname line in neo4j.conf"
else
    echo "dbms.default_database=$dbname" >> /Volumes/SSD/programs/neo4j/neo4j-community-4.4.12/conf/neo4j.conf
		echo "[!] appended dbms.default_database=$dbname to neo4j.conf"
fi

echo "[!] the target neo4j db is : $dbname"

// 建立一个Component，主要是为了解决命名冲突（这个是souffle支持的语法）
.comp ContextInsensitivePt{
    // 表示var变量指向heap这个对象
    .decl VarPointsTo(heap:Heap, var:Var)
    // 表示baseHeap这个对象的field指向heap这个对象
    .decl InstanceFieldPointsTo(heap:Heap, baseHeap:Heap, field:Field)
    // 表示静态field指向heap这个对象
    .decl StaticFieldPointsTo(heap:Heap, field:Field)
    // 表示baseHeap数组中，包含了heap对象
    .decl ArrayIndexPointsTo(heap:Heap, baseHeap:Heap)
    // 表示在insn指令中caller调用了callee
    .decl CallGraph(insn:Insn, caller:Method, callee:Method)
    // 表示方法可访问到
    .decl Reachable(method:Method)

    // new
    // 如果method方法可访问
    // 且 在method中，将创建好的heap对象赋值给了var变量
    // 那么能够推导出var变量指向heap对象
    VarPointsTo(heap, var) :-
        Reachable(method),
        AssignHeapAllocation(_, _, heap, var, method, _).

    // assign
    // 如果method方法可访问
    // 且form变量 指向heap对象
    // 且在method中，将from变量赋值给了to，即to=form
    // 那么能够推到出to变量也指向heap对象
    VarPointsTo(heap, to) :-
        Reachable(method),
        VarPointsTo(heap, from),
        AssignLocal(_, _, from, to, method).

    // cast
    // 如果method 方法可访问
    // 且form变量 指向heap对象
    // 且在method中，将from变量类型转换后赋值给了to，即to=(T)from
    // 那么能够推到出to变量也指向heap对象
    VarPointsTo(heap, to) :-
        Reachable(method),
        AssignCast(_, _, from, to, _, method),
        VarPointsTo(heap, from).

    // load field
    // 如果method方法可访问
    // 且在method中，将base变量的field取出赋值给了to，即to=base.field
    // 且base指向baseHeap对象
    // 且baseHeap对象的field指向heap对象
    // 那么能够推导出to也指向heap对象
    VarPointsTo(heap, to) :-
        Reachable(method),
        LoadInstanceField(_, _, to, base, field, method),
        VarPointsTo(baseHeap, base),
        InstanceFieldPointsTo(heap, baseHeap, field).

    // store field
    // 如果method方法可访问
    // 且在method中，将from存到了变量base的field，即base.field=from
    // 且from指向heap对象
    // 且base指向baseHeap对象
    // 那么能够推导出baseHeap对象的field也指向heap对象
    InstanceFieldPointsTo(heap, baseHeap, field) :-
        Reachable(method),
        StoreInstanceField(_, _, from, base, field, method),
        VarPointsTo(heap, from),
        VarPointsTo(baseHeap, base).

    // load staic field
    // 如果method 方法可访问
    // 且在method中，将静态field取出赋值给了to，即to = T.field
    // 且field 指向heap对象
    // 那么可以推导出to也指向heap对象
    VarPointsTo(heap, to) :-
        Reachable(method),
        LoadStaticField(_, _, to, field, method),
        StaticFieldPointsTo(heap, field).

    // store static field
    // 如果method方法可访问
    // 且在method中，将from存入静态field，即T.field = from
    // 且from指向heap对象
    // 那么可以推导出静态field指向heap对象
    StaticFieldPointsTo(heap, field) :-
        Reachable(method),
        StoreStaticField(_, _, from, field, method),
        VarPointsTo(heap, from).

    // load from array
    // 如果method可访问
    // 且从base数组中取出元素到to，即to = base[i]
    // 且base指向baseHeap数组对象
    // 且baseHeap数组对象中 包含 heap 对象
    // 那么to可能指向heap
    // 这里的实现未区分取第几个索引
    VarPointsTo(heap, to) :-
        Reachable(method),
        LoadArrayIndex(_, _, to, base, method),
        VarPointsTo(baseHeap, base),
        ArrayIndexPointsTo(heap, baseHeap).

    // store into array
    // 如果method可访问
    // 将form存到base数组中，即 base[i] = from
    // from指向heap对象
    // base指向baseHeap数组对象
    // 那么能推导出baseHeap数组对象，包含heap对象
    ArrayIndexPointsTo(heap, baseHeap) :-
        Reachable(method),
        StoreArrayIndex(_, _, from, base, method),
        VarPointsTo(heap, from),
        VarPointsTo(baseHeap, base).

    // 下面开始涉及到过程间的指针分析
    // 先构造调用图
    // Special和Static和CHA处理方式一样，编译时callee就确定，不需要再进行解析
    Reachable(callee),
    CallGraph(insn, caller, callee) :-
        Reachable(caller),
        SpecialMethodInvocation(insn, _, callee, _, caller).

    Reachable(callee),
    CallGraph(insn, caller, callee) :-
        Reachable(caller),
        StaticMethodInvocation(insn, _, callee, caller).

    // Virtual Call 需要根据base指向对象的类型进行dispatch
    // caller要可达
    // 在caller中virtual call了method
    // 调用时base指向baseHeap对象
    // baseHeap对象的类型为class
    // 根据method解析出被调函数的签名
    // 通过函数签名和实际类型解析出真正的被调函数callee
    Reachable(callee),
    CallGraph(insn, caller, callee) :-
        Reachable(caller),
        VirtualMethodInvocation(insn, _, method, base, caller),
        VarPointsTo(baseHeap, base),
        NormalHeap(baseHeap, class),
        MethodInfo(method, simplename, _, _, _, descriptor, _),
        Dispatch(simplename, descriptor, class, callee).

    // param
    // 调用图中存在调用insn
    // 调用时第n个实际参数传的是变量arg
    // 被调函数callee的第n个形式参数是param
    // 如果arg指向了heap对象
    // 那么param也指向heap对象
    VarPointsTo(heap, param) :-
        CallGraph(insn, _, callee),
        ActualParam(n, insn, arg),
        FormalParam(n, callee, param),
        VarPointsTo(heap, arg),
				// 这里需要注意，只传播正常的对象
				// 后续污点分析中，会继承本dl文件，污点分析中，形参->实参的传播不直接使用指针分析中的规则
				// 所以这里加上下面的这个限定，就只传播正常对象，不传播污点对象，污点分析中自己实现这部分的传播
				NormalHeap(heap, _).

    // return
    // 调用图中存在调用insn
    // 如果在callee中，返回语句返回的是var变量
    // 调用后的返回值赋值给了return变量
    // var变量指向heap对象
    // 那么return也指向heap对象
    VarPointsTo(heap, return) :-
        CallGraph(insn, _, callee),
        Return(_, _, var, callee),
        AssignReturnValue(insn, return),
        VarPointsTo(heap, var).

    // this
    // 调用图中存在调用insn
    // 调用时base指向heap
    // 那么调用时callee的this变量也指向heap对象
    VarPointsTo(heap, this) :-
        CallGraph(insn, _, callee),
        (
            VirtualMethodInvocation(insn, _, _, base, _);
            SpecialMethodInvocation(insn, _, _, base, _)
        ),
        ThisVar(callee, this),
        VarPointsTo(heap, base).
}

#pragma once
#include "pt-noctx.dl"

.comp PTaint : ContextInsensitivePt{
		// 表示通过insn指令，创建的新的污点对象heap，包括污点源的生成，以及污点转移时的生成
    .decl TaintHeap(insn:Insn, heap:Heap)
		// 表示source函数，其返回值表示污点源
    .decl SourceMethod(method:Method)
		// 表示sink函数，其第n个实际参数如果指向污点对象，则表示可能存在安全风险
    .decl SinkMethod(method:Method, n:number)
		// 表示sanitize函数（净化函数），经过其处理的污点，将不再是污点，也就是说污点无法通过sanitize传播；
		// 后面的净化函数阻断，是在实际参数向形式参数传播时阻断的
    .decl SanitizeMethod(method:Method)

		// 污点转移相关
		// 这个代表receiver是污点，则强制把污点转移到返回值
    .decl BaseToRetTransfer(method:Method)
		// 这个代表methodCall的实参是污点，则强制把污点转移到返回值
    .decl ArgToRetTransfer(method:Method, n:number)
		// 将上面两个合并成一个，或者将污点转移抽象成from变量污染了to变量
    .decl IsTaintedFrom(insn:Insn, from:Var, to:Var)
		// heap对象污染了newHeap对象
    .decl TransferTaint(heap:Heap, newHeap:Heap)
    
    
    // taint arg to param
		// 指针分析里，形参->实参的对象传播中，存在NormalHeap(heap, _)限定，意思就是只传播正常对象，不传播污点对象
		// 所以污点分析中，我们需要额外多写一个形参->实参的传播规则，这里主要是添加了净化函数的阻断处理
		// 如果污点实参流入了净化函数对应的形参，则污点传播被阻断
    VarPointsTo(heap, param) :-
        CallGraph(insn, _, callee),
        ActualParam(n, insn, arg),
        FormalParam(n, callee, param),
        VarPointsTo(heap, arg),
        TaintHeap(_, heap),
        !SanitizeMethod(callee).
    
    // sourceMethod的返回值作为污点源
    TaintHeap(insn, heap),
    VarPointsTo(heap, to) :-
        SourceMethod(callee),
        CallGraph(insn, _, callee),
        AssignReturnValue(insn, to),
        heap = cat("NewTainted::", insn).

    IsTaintedFrom(insn, base, ret) :-
        CallGraph(insn, _, callee),
        BaseToRetTransfer(callee),
        (
            VirtualMethodInvocation(insn, _, _, base, _);
            SpecialMethodInvocation(insn, _, _, base, _)
        ),
        AssignReturnValue(insn, ret).
    
    IsTaintedFrom(insn, arg, ret) :-
        CallGraph(insn, _, callee),
        ArgToRetTransfer(callee, n),
        ActualParam(n, insn, arg),
        AssignReturnValue(insn, ret).


	// 污点转移
	// from指向了污点对象heap
	// 且from能污染to
	// 那么to也是污点对象，也要指向一个污点对象
	// 这里没有直接让to指向新创建的污点对象
	// 而是先找到to指向的正常对象oldHeap，oldHeap第一个流向的指针var，然后让newHeap也流向指针var，即var指向newHeap
	// 由于oldHeap流向var之后，通过PFG可以流到to，那么newHeap也能流到to，这样也把和var alias的指针一并污染了
    TaintHeap(insn, newHeap),
    TransferTaint(heap, newHeap),
    VarPointsTo(newHeap, var) :-
        IsTaintedFrom(insn, from, to),
        VarPointsTo(heap, from),
        TaintHeap(_, heap),
        newHeap = cat("TransferTaint::", insn),
        VarPointsTo(oldHeap, to),
        AssignHeapAllocation(_, _, oldHeap, var, _, _).
}

package org.example;

public class App {

    private String bak;

    public static void main( String[] args )throws Exception{
        App app = new App();
        // source, new taint
        String exp = app.source();
        //  taint arg -> ret
        exp = app.addSuffix(exp);

        // transform taint arg to ret
        exp = app.transform(exp);

        app.sink(exp);
        app.sink(app.bak);
    }

    private String addSuffix(String original){
        return original + ";";
    }

    /**
     * 当我们制定了一个fact: ArgToRetTransfer("<org.example.App: java.lang.String transform(java.lang.String)>", 0).
     * 如果直接让ret指向newHeap，则不会处理过程内的污点传播了
     * 例如如下函数中，this.bak就不会指向newHeap，就少了一条污点传播路径
     */
    private String transform(String original){
        String tmp = new String(original.getBytes());
        this.bak = tmp;
        return tmp;
    }


    private void sink(String exp)throws Exception{
        Runtime.getRuntime().exec(new String[]{"/bin/sh","-c",exp});
    }

    private String source(){
        return "open -a calculator";
    }

}

public class org.example.App extends java.lang.Object
{
    private java.lang.String bak;

    public void <init>()
    {
        org.example.App this#_0;

        this#_0 := @this: org.example.App;

        specialinvoke this#_0.<java.lang.Object: void <init>()>();

        return;
    }

    public static void main(java.lang.String[]) throws java.lang.Exception
    {
        org.example.App $stack3, app#_8;
        java.lang.String $stack7, exp#_10, exp_$$A_1#_12, exp_$$A_2#_15;
        java.lang.String[] args#_0;

        args#_0 := @parameter0: java.lang.String[];

        $stack3 = new org.example.App;

        specialinvoke $stack3.<org.example.App: void <init>()>();

        app#_8 = $stack3;

        exp#_10 = specialinvoke app#_8.<org.example.App: java.lang.String source()>();

        exp_$$A_1#_12 = specialinvoke app#_8.<org.example.App: java.lang.String addSuffix(java.lang.String)>(exp#_10);

        exp_$$A_2#_15 = specialinvoke app#_8.<org.example.App: java.lang.String transform(java.lang.String)>(exp_$$A_1#_12);

        specialinvoke app#_8.<org.example.App: void sink(java.lang.String)>(exp_$$A_2#_15);

        $stack7 = app#_8.<org.example.App: java.lang.String bak>;

        specialinvoke app#_8.<org.example.App: void sink(java.lang.String)>($stack7);

        return;
    }

    private java.lang.String addSuffix(java.lang.String)
    {
        java.lang.StringBuilder $stack2, $stack3, $stack4;
        java.lang.String original#_0, $stack5;
        org.example.App this#_0;

        this#_0 := @this: org.example.App;

        original#_0 := @parameter0: java.lang.String;

        $stack2 = new java.lang.StringBuilder;

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

        $stack3 = virtualinvoke $stack2.<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>(original#_0);

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

        $stack5 = virtualinvoke $stack4.<java.lang.StringBuilder: java.lang.String toString()>();

        return $stack5;
    }

    private java.lang.String transform(java.lang.String)
    {
        java.lang.String $stack3, original#_0, tmp#_31;
        byte[] $stack4;
        org.example.App this#_0;

        this#_0 := @this: org.example.App;

        original#_0 := @parameter0: java.lang.String;

        $stack3 = new java.lang.String;

        $stack4 = virtualinvoke original#_0.<java.lang.String: byte[] getBytes()>();

        specialinvoke $stack3.<java.lang.String: void <init>(byte[])>($stack4);

        tmp#_31 = $stack3;

        this#_0.<org.example.App: java.lang.String bak> = tmp#_31;

        return tmp#_31;
    }

    private void sink(java.lang.String) throws java.lang.Exception
    {
        java.lang.Runtime $stack2;
        java.lang.String[] $stack3;
        java.lang.String exp#_0;
        org.example.App this#_0;

        this#_0 := @this: org.example.App;

        exp#_0 := @parameter0: java.lang.String;

        $stack2 = staticinvoke <java.lang.Runtime: java.lang.Runtime getRuntime()>();

        $stack3 = newarray (java.lang.String)[3];

        $stack3[0] = "/bin/sh";

        $stack3[1] = "-c";

        $stack3[2] = exp#_0;

        virtualinvoke $stack2.<java.lang.Runtime: java.lang.Process exec(java.lang.String[])>($stack3);

        return;
    }

    private java.lang.String source()
    {
        org.example.App this#_0;

        this#_0 := @this: org.example.App;

        return "open -a calculator";
    }
}

#include "../ptaint.dl"
.init ptaint = PTaint

// 定义入口函数
ptaint.Reachable("<org.example.App: void main(java.lang.String[])>").
// 定义污点源
ptaint.SourceMethod("<org.example.App: java.lang.String source()>").
// 定义sink函数
ptaint.SinkMethod("<org.example.App: void sink(java.lang.String)>", 0).
// 我们认为污点实参进入到transform函数的形参，一定能污染transform函数的返回值，所以定义如下ArgToRetTransfer
ptaint.ArgToRetTransfer("<org.example.App: java.lang.String transform(java.lang.String)>", 0).

// 
ptaint.BaseToRetTransfer("<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>").
ptaint.BaseToRetTransfer("<java.lang.StringBuilder: java.lang.String toString()>").
ptaint.ArgToRetTransfer("<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>", 0).

.output ptaint.SinkTaint
.output ptaint.TaintHeap
.output ptaint.TransferTaint
.output ptaint.VarPointsTo
.output ptaint.IsTaintedFrom