pin使用小记-函数分析

概述

相关：pin是什么 pin可以做什么 pin examples

此次使用pin目的，是为了能够应用pin在函数分析方面的功能，以及XXXInsertCall的功能

由于此前对pin了解不够深入，以为可以实现相应功能，哪知撞了南墙才知道pin也有些许局限。

下面将我对了解到的pin可以实现以及不能实现的各种坑写作笔记。

函数分析

RTN

1
PIN_CALLBACK 	LEVEL_PINCLIENT::RTN_AddInstrumentFunction (RTN_INSTRUMENT_CALLBACK fun, VOID *val)

使用RTN_AddInstrumentFunction即可对分析目标添加函数级插桩，在设置的回调中可以获取函数的各种信息。

1
typedef VOID(*) LEVEL_PINCLIENT::RTN_INSTRUMENT_CALLBACK(RTN rtn, VOID *v)

回调函数中rtn就表示被插桩的该函数，通过RTN_XXX相关函数可以获取函数的名字、地址、大小、范围等等

1
2
3
4
const string & 	LEVEL_PINCLIENT::RTN_Name (RTN x)
ADDRINT 	LEVEL_PINCLIENT::RTN_Address (RTN rtn)
USIZE 	LEVEL_PINCLIENT::RTN_Size (RTN rtn)
USIZE 	LEVEL_PINCLIENT::RTN_Range (RTN rtn)

不得不提一个函数，RTN_FindByName类似于GetProcAddress，可以获取img(模块对象)中指定名字的rtn对象。

1
RTN 	LEVEL_PINCLIENT::RTN_FindByName (IMG img, const CHAR *name)

也可以通过地址来获取对应的rtn对象，但是如果对应函数没有符号信息，获取到的rtn是不对的，会找到最小范围内满足的rtn对象

1
RTN 	LEVEL_PINCLIENT::RTN_FindByAddress (ADDRINT address)

函数

初以为RTN表示所有函数对象，像IDA一样能将基本所有函数分析出来，哪知吃了不看文档的亏(虽然知道使用RTN之前需要调用符号相关初始化)。

A RTN represents the functions/routines/procedures typically produced by a compiler for a procedural programming language such as C. Pin finds routines by using the symbol table information. You must call PIN_InitSymbols() so that symbol table information will be available. Can be accessed at instrumentation time and analysis time.

也就是说pin是根据符号信息来分析函数，生成RTN对象。那么没有符号信息的函数，像IDA中的是那么sub_xxxx也就没有可能这么方便的使用了。

当然，如果需求是对有符号信息的函数，比如对系统函数的分析，那么RTN还是能够提供相当nb的功能的。记得调用PIN_InitSymbols()初始化符号信息。

maybe hook

pin可以实现类似于对函数hook的功能，有两类，第一类用在JIT模式下，另一类用在Probe模式下。

先说JIT模式下使用的RTN_InsertCall。

1
2
3
4
5
VOID LEVEL_PINCLIENT::RTN_InsertCall	(	RTN 	rtn,
IPOINT 	action,
AFUNPTR 	funptr,
 	...	 
)

Insert call relative to a rtn.

使用这个函数注册一个回调函数，该回调函数可以在rtn调用前（IPOINT_BEFORE）或者调用后（IPOINT_AFTER）被调用。可以给回调函数传递各种信息，使用第三个参数之后的内容传递。

pin中各种XXX_InsertCall传递参数有一个统一的类型IARG_TYPE。这里简单说一下传递方法，具体要根据IARG_TYPE说明来使用，大致分为两种：

  1. 只需要指定IARG_XXX类型，pin自己传递具体值给回调函数
  2. 指定IARG_XXX类型，开发者传递类型对应的具体值

必须以IARG_END表示参数结束。

1
2
3
4
5
6
7
8
9
10
11
12
//pin传递值，只需要指定类型即可
IARG_RETURN_IP 	Type: ADDRINT. Return address for function call, valid only at the function entry point.
IARG_ORIG_FUNCPTR 	Type: AFUNPTR. Function pointer to the relocated entry of the original uninstrumented function.
IARG_PROTOTYPE 	Type: PROTO. The function prototype of the application function. See Prototypes.
IARG_THREAD_ID 	Type: THREADID. Application thread id.
//开发者需要自己传递具体值
IARG_ADDRINT 	Type: ADDRINT. Constant value (additional arg required).
IARG_PTR 	Type: "VOID *". Constant value (additional pointer arg required).
IARG_BOOL 	Type: BOOL. Constant (additional BOOL arg required).
IARG_UINT32 	Type: UINT32. Constant (additional integer arg required).
IARG_INST_PTR 	Type: ADDRINT. The address of the instrumented instruction. This value does not change at IPOINT_AFTER. This is simply shorthand for IARG_ADDRINT, INS_Address(ins).
IARG_REG_VALUE 	Type: ADDRINT for integer register. Value of a register (additional register arg required) REG: Register Object Basically, this cannot be used to retrieve the value of registers whose size is different than ADDRINT's (i.e.: x87/XMM/YMM/ZMM registers) or registeres which are not architectural (REG_PIN_*), but there are some exceptions for this rule.

举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
char* p = "this is log info.";
BOOL log_falg = TRUE;
ADDRINT addr = RTN_Address(rtn);
RTN_InsertCall(rtn, IPOINT_BEFORE, RtnClk, 
                IARG_ORIG_FUNCPTR, 
                IARG_RETURN_IP, 
                IARG_ADDRINT, addr, 
                IARG_PTR, p,
                IARG_BOOL, log_falg,
                IARG_END);
                
VOID RtnClk(ADDRINT OrigFunc, ADDRINT retIp, ADDRINT addr, void* log, BOOL log_falg)
{
}

Probe模式下使用下面两个函数，其实没有弄明白这两个函数和JIT模式下RTN_InserCall的区别，暂时就不做深入了。

1
2
VOID 	LEVEL_PINCLIENT::RTN_InsertCallProbed (RTN orgRtn, IPOINT action, AFUNPTR funptr,...)
VOID 	LEVEL_PINCLIENT::RTN_InsertCallProbedEx (RTN orgRtn, IPOINT action, PROBE_MODE mode, AFUNPTR funptr,...)

Insert a call to an analysis routine relative to a RTN.

其他

1
2
RTN_ReplaceProbed
RTN_ReplaceProbedEx

下面一个示例，可能更符合对函数hook的理解，这里使用到的是RTN_ReplaceSignatureProbed

这种方式需要向函数hook一样指定函数原型，也就是需要知道函数需要哪些参数，调用方式等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
typedef VOID * ( *FP_MALLOC )( size_t );

// This is the replacement routine.
//
VOID * NewMalloc( FP_MALLOC orgFuncptr, UINT32 arg0, ADDRINT returnIp )
{
    // Normally one would do something more interesting with this data.
    //
    cout << "NewMalloc ("
         << hex << ADDRINT ( orgFuncptr ) << ", " 
         << dec << arg0 << ", " 
         << hex << returnIp << ")"
         << endl << flush;

    // Call the relocated entry point of the original (replaced) routine.
    //
    VOID * v = orgFuncptr( arg0 );

    return v;
}


// Pin calls this function every time a new img is loaded.
// It is best to do probe replacement when the image is loaded,
// because only one thread knows about the image at this time.
//
VOID ImageLoad( IMG img, VOID *v )
{
    // See if malloc() is present in the image.  If so, replace it.
    //
    RTN rtn = RTN_FindByName( img, "malloc" );
    
    if (RTN_Valid(rtn))
    {
        cout << "Replacing malloc in " << IMG_Name(img) << endl;
        
        // Define a function prototype that describes the application routine
        // that will be replaced.
        //
        PROTO proto_malloc = PROTO_Allocate( PIN_PARG(void *), CALLINGSTD_DEFAULT,
                                             "malloc", PIN_PARG(int), PIN_PARG_END() );
        
        // Replace the application routine with the replacement function.
        // Additional arguments have been added to the replacement routine.
        //
        RTN_ReplaceSignatureProbed(rtn, AFUNPTR(NewMalloc),
                                   IARG_PROTOTYPE, proto_malloc,
                                   IARG_ORIG_FUNCPTR,
                                   IARG_FUNCARG_ENTRYPOINT_VALUE, 0,
                                   IARG_RETURN_IP,
                                   IARG_END);

        // Free the function prototype.
        //
        PROTO_Free( proto_malloc );
    }
}

can be hook

另外pin还提供对任意地址做hook的函数，也就是PIN_InsertCallProbed。

显然这也是用于Probe模式下的函数，顺便就说一下Probe模式下需要注意，调用PIN_StartProgramProbed()启动目标进程，这样子之后，JIT模式的很多函数就不能使用了。正是因为这个，如RTN、INS、Trace插桩函数不能使用，只能通过IMG插桩，在回调中进行函数的分析，想下面的实例代码中一样。

这样就给我要实现的功能带来了麻烦，无法通过INS插桩分析call xxx的目标地址，更别说后续的使用PIN_InsertCallProbed来对函数hook了，这样子PIN_InsertCallProbed对我来说显得很鸡肋。

PIN_StartProgramProbed() must be used when using this API.
Use RTN_IsSafeForProbedInsertion() to determine if a function is a suitable candidate for probed function insertion.

不过，我觉得这种模式更类似于函数hook，不会像上面指定IPOINT_BEFORE，它更像hook一样只是对函数进行inline hook（或者其他方式）。

使用示例(代码来自于pin例子源码source\tools\Probes\insert_call_probed.cpp)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
void Notification(ADDRINT val)
{
    char buff[80];

    if (!writeFun)
    {
        fprintf(stderr, "Write Function was not initialized ...\n");
        exit(1);
    }

    sprintf(buff, "Notification value: %p", Addrint2VoidStar(val));
    writeFun(buff);
}

VOID ImageLoad(IMG img, VOID *v)
{
    const ANNOTATION *ann = 0;
    USIZE num = 0;

    printf("Processing %s\n", IMG_Name(img).c_str());
    
    for (SEC sec = IMG_SecHead(img); SEC_Valid(sec); sec = SEC_Next(sec))
    {
        if (SEC_Name(sec) == "MyAnnot")
        {
            ann = reinterpret_cast<const ANNOTATION*>(SEC_Data(sec));
            num = SEC_Size(sec) / sizeof(ANNOTATION);
        }
    }

    if (ann)
    {
        printf("Found annotations: \n");
        for (UINT32 i = 0; i < num; i++)
        {
            ADDRINT addr = ann[i].addr + IMG_LoadOffset(img);
            ADDRINT val = ann[i].value;
            printf("\t%p %p\t", Addrint2VoidStar(addr), Addrint2VoidStar(val));
            if (PIN_IsSafeForProbedInsertion(addr)) //检查addr对应指令是否可以做hook
            {
                PIN_InsertCallProbed(addr, AFUNPTR(Notification), IARG_ADDRINT, val, IARG_END);
                printf(" - OK\n");
            }
            else
            {
                printf(" - Failed\n");
            }
        }

        // Set the write line function, from the image of the annotations (i.e. the main executable).
        RTN writeRtn = RTN_FindByName(img, "write_line");
        if (RTN_Valid(writeRtn))
        {
            writeFun = (void (*)(char *))RTN_Funptr(writeRtn);
        }
    }

    printf("Completed %s\n", IMG_Name(img).c_str());
}

INS

INS表示某地址对应的指令对象，通过INS_XXX函数可以获取指令对应汇编代码，可以判断指令时什么类型，也可以对INS进行插桩。

An INS represents an instruction. Can only be accessed at instrumentation time.

下面列出一部分函数，看名字就知道干什么的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
string 	LEVEL_CORE::INS_Disassemble (INS ins)
BOOL 	LEVEL_CORE::INS_IsLea (INS ins)
BOOL 	LEVEL_CORE::INS_IsNop (INS ins)
BOOL 	LEVEL_CORE::INS_IsCall (INS ins)
BOOL 	LEVEL_CORE::INS_IsProcedureCall (INS ins)
BOOL 	LEVEL_CORE::INS_IsRet (INS ins)
BOOL 	LEVEL_CORE::INS_IsSysret (INS ins)
BOOL 	LEVEL_CORE::INS_IsSyscall (INS ins)

ADDRINT 	LEVEL_PINCLIENT::INS_Address (INS ins)
USIZE 	LEVEL_PINCLIENT::INS_Size (INS ins)
RTN 	LEVEL_PINCLIENT::INS_Rtn (INS x)

BOOL 	LEVEL_CORE::INS_IsBranch (INS ins)
BOOL 	LEVEL_CORE::INS_IsDirectBranch (INS ins)
BOOL 	LEVEL_CORE::INS_IsDirectCall (INS ins)
BOOL 	LEVEL_CORE::INS_IsDirectBranchOrCall (INS ins)
BOOL 	LEVEL_CORE::INS_IsBranchOrCall (INS ins)
BOOL 	LEVEL_CORE::INS_IsIndirectBranchOrCall (INS ins)

ADDRINT 	LEVEL_PINCLIENT::INS_DirectBranchOrCallTargetAddress (INS ins)

下面主要对用到的几个函数，对其理解做一下笔记。

call/branch

上面提到我要对call xxx中xxx的信息进行获取，就需要用到对INS的分析，进而通过插桩来获取地址。

用到了下面几个函数对指令进行判断，是否是call。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
BOOL 	LEVEL_CORE::INS_IsCall (INS ins)
//call，不管目标是不是地址，或者寄存器等

BOOL 	LEVEL_CORE::INS_IsBranch (INS ins) 
//jmp,jz,jnz等等，不管目标是不是地址，或者寄存器等

BOOL 	LEVEL_CORE::INS_IsDirectBranch (INS ins)
//jmp,jz,jnz等等，目标是地址

BOOL 	LEVEL_CORE::INS_IsDirectCall (INS ins)
//call xxx，目标是地址

BOOL 	LEVEL_CORE::INS_IsDirectBranchOrCall (INS ins)
//call,jmp,jz,jnz等等，目标是地址

BOOL 	LEVEL_CORE::INS_IsBranchOrCall (INS ins)
//call,jmp,jz,jnz等等，不管目标是不是地址，或者寄存器等

BOOL 	LEVEL_CORE::INS_IsIndirectBranchOrCall (INS ins)
//call,jmp,jz,jnz等等，目标是寄存器

目标地址

如果INS满足INS_IsDirectBranchOrCall，可以直接通过INS_DirectBranchOrCallTargetAddress获取到目标地址。

如果INS是INS_IsIndirectBranchOrCall，那么只有通过插桩来获取目标地址。插桩是必须使用IPOINT_TAKEN_BRANCH类型的action，然后再回调函数中可以通过寄存器来获取目标地址。

如下所示代码：

1
2
3
4
5
6
7
INS_InsertCall(ins, IPOINT_TAKEN_BRANCH, (AFUNPTR)RttiCall, IARG_CONTEXT, IARG_INST_PTR, IARG_END);

void RttiCall(CONTEXT* ctx, ADDRINT addr)
{
    ADDRINT TakenIP = (ADDRINT)PIN_GetContextReg(ctx, REG_INST_PTR);
	ADDRINT RIP = (ADDRINT)PIN_GetContextReg(ctx, REG_RIP);
}

总结

通过上面对RNT，INS使用的相关总结，已经可以拿到call xxx的目标地址，也可以对任意地址进行插桩（hook），但是就在JIT\Probe两个模式中找不到可以以结合的地方。

  1. JIT模式下，可以通过INS拿到目标地址，但是不能对目标地址进行插桩
  2. Probe模式下，可以对目标地址插桩，但是拿不到目标地址

不知道pin是否可以满足这种需求，但在我目前看到的东西里，是没法实现了。

如果有过路的高人，想可以指点一二，不甚感激。

另外总结一下pin中各对象的关系：

1
IMG->SEC->BBL->RTN->INS

完结。

赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Windows Kernel/Rootkit/Reverse Engineer/Expolit<br/>内核研究/逆向分析/漏洞分析挖掘