上一篇讲解了如何加载一个Luac文件到IDA Pro当中，加载进入idb数据库的内容犹如切好洗净的食材，并不能粗暴的直接展示给用户，还需要IDA Pro中的处理器模块对内容进行下一步的反汇编渲染与指令功能注释，才能最终装盘食用。

处理器模块的工作就是：解析不同段的内容，确定代码段后，通过指定的指令格式解析与构造指令；确定指令使用的数据类型、寄存器与助记符；执行代码段的线性式代码反汇编；为指令标记注释与交叉引用等。

处理器模块架构

IDA Pro没有详细的文档描述如何开发处理器模块，最有效的学习途径是阅读IDA Pro程序中自带的开源的处理器模块代码。IDA Pro的处理器模块比文件加载器在架构上要更加晦涩难懂，实现起来也要复杂得多。

本篇写作时，对应的IDA Pro版本为国内众所周知的IDA Pro版本7.0，实验环境为macOS 10.12平台，处理器模块的开发选择使用Python。在IDA Pro软件的加载器目录(macOS平台)：/Applications/IDAPro7.0/ida.app/Contents/MacOS/procs中，有着3个Python编写的处理器模块代码，分别是spu.py、ebc.py、msp430.py，如果安装了IDA Pro的开发SDK，在其中的module/script目录下也会找到这些模块，另外，还会包含一个proctemplate.py模板。

理论上，本节编写的Luac处理器模块，放到Windows等其他平台上，不需要进行任何的修改，也可以很好的工作。 本次参考使用到的代码是ebc.py模块，因为它的实现代码量不算最少，但在指令的解码处理上，代码更加直观。

处理器模块要求py中有一个定义为PROCESSOR_ENTRY()的方法，它的返回值是一个processor_t类型的类结构，IDA Pro通过检查这个类的字段，与回调它的方法，来完成指令的处理。一个精简的代码架构如下：

class ebc_processor_t(processor_t):

...

# ----------------------------------------------------------------------

def __init__(self):

processor_t.__init__(self)

self.PTRSZ = 4 # Assume PTRSZ = 4 by default

self.init_instructions()

self.init_registers()

...

...

def PROCESSOR_ENTRY():

return ebc_processor_t()

ebc_processor_t类中有很多的回调函数，它们都会在特定的场景下触发执行，所有的回调方法，可以在当前版本的IDA Pro的ida_idp.py文件中，查看processor_t的类型声明得知，不过可以发现，processor_t的声明是由swig自动生成的桥接到C的代码，看不出任何有价值的地方，在实际编写代码时，可能需要查看Python编写的处理器模块的回调函数注释，来理解回调的参数与使用场景，也可以直接查看processor_t类型在C语言中的声明，它的定义可以在SDK的include目录下的idp.hpp头文件中找到，在实现上，SDK中也包含了很多C语言编写的处理器模块，代码也很有参考价值。

这里的ebc_processor_t的__init__()方法中，会调用init_instructions()初始化处理器模块用到的指令，以及调用init_registers()初始化处理器模块用到的寄存器信息，这是一种通用的设置流程，我们在下面的代码中也采用这种方式完成Luac的相关初始化。

Luac处理器模块的实现

下面来动手实现Luac的处理器模块，同样的，它只支持基于Lua 5.2生成的Luac文件。 将ebc.py模块复制一份改名为loacproc.py。并修改ebc_processor_t为lua_processor_t，它的`_init()`代码不需要进行修改，代码如下：

def __init__(self):

processor_t.__init__(self)

self.PTRSZ = 4 # Assume PTRSZ = 4 by default

self.init_instructions()

self.init_registers()

self.PTRSZ描述了使用到的指针类型所占的字节大小，对于32位的Luac来说，它的值为4，通常只有在编写64位的程序处理器模块时，它的值才是8。init_instructions()与init_registers()分别用来初始化指令与寄存器列表，我们需要修改它的方法的实现部分。

在开始讲解指令与寄存器的修改前，我们先看看processor_t中需要修改的一些字段，它们的片断如下：

PLFM_LUAC = 99

class lua_processor_t(processor_t):

# IDP id ( Numbers above 0x8000 are reserved for the third-party modules)

id = PLFM_LUAC

# Processor features

flag = PR_DEFSEG32 | PR_USE64 | PRN_HEX | PR_RNAMESOK | PR_NO_SEGMOVE | PR_TYPEINFO

# Number of bits in a byte for code segments (usually 8)

# IDA supports values up to 32 bits

cnbits = 8

# Number of bits in a byte for non-code segments (usually 8)

# IDA supports values up to 32 bits

dnbits = 8

# short processor names

# Each name should be shorter than 9 characters

psnames = ['Luac']

# long processor names

# No restriction on name lengthes.

plnames = ['Lua Byte code']

# size of a segment register in bytes

segreg_size = 0

# Array of typical code start sequences (optional)

# codestart = ['\x60\x00'] # 60 00 xx xx: MOVqw SP, SP-delta

# Array of 'return' instruction opcodes (optional)

# retcodes = ['\x04\x00'] # 04 00: RET

# You should define 2 virtual segment registers for CS and DS.

# Let's call them rVcs and rVds.

# icode of the first instruction

instruc_start = 0

#

# Size of long double (tbyte) for this processor

# (meaningful only if ash.a_tbyte != NULL)

#

tbyte_size = 0

segstarts = {}

segends = {}

...

id字段是一个数值的ID值，用来标识处理器模块，IDA Pro中定义了一些已经存在的id，它们的定义在ida_idp.py中可以找到，如下所示：

# processor_t.id

PLFM_386 = 0 # Intel 80x86

PLFM_Z80 = 1 # 8085, Z80

PLFM_I860 = 2 # Intel 860

...

PLFM_EBC = 57 # EFI Bytecode

PLFM_MSP430 = 58 # Texas Instruments MSP430

PLFM_SPU = 59 # Cell Broadband Engine Synergistic Processor Unit

我们这里将其设置为PLFM_LUAC，只要定义它为一个与系统上不冲突的数值即可。

flag字段描述了处理器用到的一些特性，用样可以在ida_idp.py中可以查看processor_t.flag小节中的可选值，例如PR_USE64表示支持64位的寻址方式，PR_NO_SEGMOVE表示不支持段移动，即不允许调用move_segm()接口，PR_TYPEINFO表示支持类型信息，即支持在IDA Pro中载入til中的类型。

cnbits字段与dnbits字段表示对于代码段与非代码段，一个字节占用多少位，通常取值8。

psnames字段用来设置处理器模块的短名称，这里设置为”Luac”。还记得上一节如下的代码么：

idaapi.set_processor_type("Luac", SETPROC_ALL|SETPROC_FATAL)

当注册了该名称后，文件加载器就可以通过idaapi.set_processor_type()来设置该处理器模块了。

plnames字段是长名称，起到描述性的作用。

segreg_size字段描述段寄存器的大小，当前面的flag字段包含了PR_SEGS标志，则需要设置它的值，这里取值为0。

codestart与retcodes用于描述函数的开始与结束的指令特征，用于IDA Pro线性扫描时，自动生成函数信息。

instruc_start为指令列表的起始索引。

tbyte_size字段描述long double类型的字节大小，这里没有用到，设置为0即可。

segstarts与segends用来记录段的开始与结束地址，这两个字段在其他的代码回调处很有用。

接下来还需要设置一个assembler字段，描述了反汇编的一些信息。包括设置反汇编器的名称，各种数据类型的助记符，比如字节、字、双字通常设置为db、dw、dd，这在其他的处理器模块中常见。然后是各种保留关键字与逻辑操作的助记符，这些内容在luac_proc中，可以选择保留或者删除。

在init_instructions()的内部实现中，被要求设置一个class idef，该类型用于描述指令的具体信息，包括：指令的名称、解码回调程序、规犯标志、注释等。当然，也可以选择不实现它。在本例中，选择了使用idef辅助进行指令处理，它的定义如下：

class idef:

"""

Internal class that describes an instruction by:

- instruction name

- instruction decoding routine

- canonical flags used by IDA

"""

def __init__(self, name, cf, d, cmt = None):

self.name = name

self.cf = cf

self.d = d

self.cmt = cmt

为了方便解码指令，这里定义了一张指令表self.itable，它列出了Luac中涉及到的所有指令，如下所示：

self.itable = {

0x00: idef(name='MOVE', d=self.decode_MOVE, cf=CF_USE1 | CF_USE2, cmt=''),

0x01: idef(name='LOADK', d=self.decode_LOADK, cf=CF_USE1 | CF_USE2, cmt=self.cmt_LOADK),

0x02: idef(name='LOADKX', d=self.decode_LOADKX, cf=CF_USE1 | CF_USE2, cmt=''),

0x03: idef(name='LOADBOOL', d=self.decode_LOADBOOL, cf=CF_USE1 | CF_USE2 | CF_USE3, cmt=''),

0x04: idef(name='LOADNIL', d=self.decode_LOADNIL, cf=CF_USE1 | CF_USE2, cmt=''),

0x05: idef(name='GETUPVAL', d=self.decode_GETUPVAL, cf=CF_USE1 | CF_USE2, cmt=''),

...

0x26: idef(name='VARARG', d=self.decode_VARARG, cf=CF_USE1 | CF_USE2, cmt=''),

0x27: idef(name='EXTRAARG', d=self.decode_EXTRAARG, cf=CF_USE1, cmt=''),

}

CF_USE1与CF_USE2标志表示使用了第一个操作数与第二个操作数，与之类似的还有CF_JUMP，表示这是一条跳转类型的指令，CF_CALL表示这是一条call类型的指令，所有支持的标志可以在ida_idp.py的instruc_t.feature小节查看。

完成这张表后，需要使用它来填充处理器模块的instruc字段，代码如下：

# Now create an instruction table compatible with IDA processor module requirements

Instructions = []

i = 0

for x in self.itable.values():

d = dict(name=x.name, feature=x.cf)

if x.cmt != None:

d['cmt'] = x.cmt

Instructions.append(d)

setattr(self, 'itype_' + x.name, i)

i += 1

# icode of the last instruction + 1

self.instruc_end = len(Instructions) + 1

# Array of instructions

self.instruc = Instructions

# Icode of return instruction. It is ok to give any of possible return

# instructions

self.icode_return = self.itype_RETURN

instruc_end字段为指令列表的结束索引，它对应着前面的instruc_start字段。

instruc字段通过Instructions进行设置，它只取了指令的名称与标志两个字段。

icode_return字段指明可能的返回指令，itype_RETURN是前面通过setattr()设置的RETURN指令。

下面看看指令的解码部分，即前面self.itable中定义的如self.decode_MOVE与self.decode_LOADK部分。

self.decode_MOVE的实现如下：

def decode_MOVE(self, insn, a, b, c, ax, bx, sbx):

"""

OP_MOVE,/* A B R(A) := R(B) */

"""

insn.Op1.type = o_reg

insn.Op1.reg = a

insn.Op1.dtype = dt_dword

insn.Op2.type = o_reg

insn.Op2.reg = b

insn.Op2.dtype = dt_dword

return True

可以看到，实现方法上，主要是填充inst指令的两个操作数，因为它的最终展示形式形如：

MOVE R(A), R(B)

在填充时，除了指定它是否为寄存器类型o_reg外，还需要设置它的具体值a与b，当a为2，b为1时，它生成的反汇编代码为：

MOVE R2, R1

然后以LOADK指令为例，它的解码回调为self.decode_LOADK，代码如下：

def decode_LOADK(self, insn, a, b, c, ax, bx, sbx):

"""

OP_LOADK,/* A Bx R(A) := Kst(Bx) */

"""

insn.Op1.type = o_reg

insn.Op1.reg = a

insn.Op1.dtype = dt_dword

insn.Op2.type = o_displ

insn.Op2.reg = bx

insn.Op2.dtype = dt_dword

return True

这一次，Op2的类型不为o_reg，而是o_displ，这是指针类型的数据，这里在最终解码时，我们会判断它操作的是否为Upvalue，来进一步确定它是UpValue，还是Constant常量，如果是前者，我们输出时会指定U开头，如果是后者，输出时会指定K开头。至于具体的判断方法，则是将指令的Op的specval值设置为1。如decode_SETUPVAL()的实现：

def decode_SETUPVAL(self, insn, a, b, c, ax, bx, sbx):

"""

OP_SETUPVAL,/* A B UpValue[B] := R(A) */

"""

insn.Op1.type = o_reg

insn.Op1.reg = a

insn.Op1.dtype = dt_dword

insn.Op2.type = o_displ

insn.Op2.reg = b

insn.Op2.dtype = dt_dword

insn.Op2.specval = 1

return True

接下来就是一条条的实现每一条指令的解码回调，这就是一个体力活。

接着是初始化寄存器的部分，代码如下：

def init_registers(self):

"""This function parses the register table and creates corresponding ireg_XXX constants"""

# Registers definition

self.reg_names = [

# General purpose registers

# #define MAXSTACK 250

# >>> for i in xrange(250):

# ... print("\"R%d\"," % i)

"R0",

"R1",

"R2",

"R3",

"R4",

"R5",

"R6",

"R7",

"R8",

...

# Fake segment registers

"CS",

"DS"

]

# Constants definition

self.constant_names = [

# #define MAXSTACK 250

# >>> for i in xrange(250):

# ... print("\"K%d\"," % i)

"K0",

"K1",

"K2",

"K3",

"K4",

"K5",

"K6",

"K7",

"K8",

...

]

# Upvalues definition

self.upvalue_names = [

# #define MAXSTACK 250

# >>> for i in xrange(250):

# ... print("\"U%d\"," % i)

"U0",

"U1",

"U2",

"U3",

"U4",

"U5",

"U6",

"U7",

"U8",

...

]

# Create the ireg_XXXX constants

for i in xrange(len(self.reg_names)):

setattr(self, 'ireg_' + self.reg_names[i], i)

# Create the iconst_XXXX constants

for i in xrange(len(self.constant_names)):

setattr(self, 'iconst_' + self.constant_names[i], i)

# Create the iupval_XXXX constants

for i in xrange(len(self.upvalue_names)):

setattr(self, 'iupval_' + self.upvalue_names[i], i)

# Segment register information (use virtual CS and DS registers if your

# processor doesn't have segment registers):

self.reg_first_sreg = self.ireg_CS

self.reg_last_sreg = self.ireg_DS

# number of CS register

self.reg_code_sreg = self.ireg_CS

# number of DS register

self.reg_data_sreg = self.ireg_DS

主要是定义了寄存器名称表reg_names，常量名称表constant_names，UpValue名称表upvalue_names。以及为这些表各自设置名称属性。

完成了这两卡的初始化，接着就是实现处理器模块的回调了。重要的有，notify_ana()，作用是解码每一条指令，它的实现代码如下：

def notify_ana(self, insn):

"""

Decodes an instruction into insn

"""

# take opcode byte

b = insn.get_next_dword()

# the 6bit opcode

opcode = b & 0x3F

arg_a = GET_BITS(b, 6, 13)

arg_b = GET_BITS(b, 23, 31)

arg_c = GET_BITS(b, 14, 22)

arg_ax = GET_BITS(b, 6, 31)

arg_bx = GET_BITS(b, 14, 31)

arg_sbx = GET_BITS(b, 14, 31) - 131071

print("opcode:%x, a:%x, b:%x, c:%x, ax:%x, bx:%x, sbx:%d" % (opcode, arg_a, arg_b, arg_c, arg_ax, arg_bx, arg_sbx))

# opcode supported?

try:

ins = self.itable[opcode]

# set default itype

insn.itype = getattr(self, 'itype_' + ins.name)

except:

return 4

# call the decoder

return insn.size if ins.d(insn, arg_a, arg_b, arg_c, arg_ax, arg_bx, arg_sbx) else 0

解析32位的指令，取它的opcode、arg_a、arg_b、arg_c、arg_ax、arg_bx、arg_cx等值，然后根据不同的opcode索引查表，设置指令的itype字段，最后返回指令的长度即可。

notify_out_insn()用于输出完整指令，out_mnem()用于输出助记符，notify_out_operand()用于输出操作数，后两个回调是前一个回调的两个拆分，这几个回调加在一起，可以处理指令输出的全部细节。notify_out_insn()与out_mnem()的实现对于多数的反汇编引擎部分是一样的，这里不去细究，主要看看notify_out_operand()，它的实现如下：

def notify_out_operand(self, ctx, op):

"""

Generate text representation of an instructon operand.

This function shouldn't change the database, flags or anything else.

All these actions should be performed only by u_emu() function.

The output text is placed in the output buffer initialized with init_output_buffer()

This function uses out_...() functions from ua.hpp to generate the operand text

Returns: 1-ok, 0-operand is hidden.

"""

#print("notify_out_operand called. op:%x" % op.type)

optype = op.type

fl = op.specval

def_arg = is_defarg(get_flags(ctx.insn.ea), op.n)

if optype == o_reg:

ctx.out_register(self.reg_names[op.reg])

elif optype == o_imm:

# for immediate loads, use the transfer width (type of first operand)

if op.n == 1:

width = self.dt_to_width(ctx.insn.Op1.dtype)

else:

width = OOFW_32 if self.PTRSZ == 4 else OOFW_64

ctx.out_value(op, OOFW_IMM | width)

elif optype in [o_near, o_mem]:

r = ctx.out_name_expr(op, op.addr, idc.BADADDR)

if not r:

ctx.out_tagon(COLOR_ERROR)

ctx.out_btoa(op.addr, 16)

ctx.out_tagoff(COLOR_ERROR)

remember_problem(PR_NONAME, ctx.insn.ea)

elif optype == o_displ:

is_upval = fl

if is_upval:

ctx.out_register(self.upvalue_names[op.reg]) #Upvalues

else:

ctx.out_register(self.constant_names[op.reg]) #Constants

#if op.addr != 0 or def_arg:

# ctx.out_value(op, OOF_ADDR | (OOFW_32 if self.PTRSZ == 4 else OOFW_64) | signed | OOFS_NEEDSIGN)

else:

return False

return True

根据不同的操作数类型，调用不同的方法进行输出。ctx.out_register负责输出寄存器；ctx.out_value负责输出立即数；而对于UpValue与Constant的输出，这里借用了ctx.out_register来输出，只是使用了不同的名称组。

取这里，指令的基本的反汇编就算完成了，IDA Pro在应用该处理器模块时，会线性的扫描所有的CODE类型的代码段，进行反汇编处理。由于篇幅的原因，这篇就到此这止了，有兴趣的读者，可以在此基础上，实现函数的创建、代码与数据的交叉引用、自动添加注释等功能。最终实现的效果如图所示：