idapython常用api记录7.0

2019-02-13 idapython常用api记录

以下代码片段可以在ida的output窗口中测试用，需要引入相关的模块即可。

import idaapi
import idc
import idautils

后续需要使用的程序代码指令

0017C24                 CODE32
LOAD:00017C24
LOAD:00017C24 ; =============== S U B R O U T I N E =======================================
LOAD:00017C24
LOAD:00017C24 ; Attributes: thunk
LOAD:00017C24
LOAD:00017C24 ; int fstat(int fd, struct stat *buf)
LOAD:00017C24 fstat                                   ; CODE XREF: sub_136A44+64↓p
LOAD:00017C24                 ADRL            R12, 0x1C1C2C
LOAD:00017C2C                 LDR             PC, [R12,#(off_1C2B20 - 0x1C1C2C)]! ; __imp_fstat
LOAD:00017C2C ; End of function fstat
LOAD:00017C2C
....

0017C30
LOAD:00017C30 ; =============== S U B R O U T I N E =======================================
LOAD:00017C30
LOAD:00017C30
LOAD:00017C30                 EXPORT start
LOAD:00017C30 start                                   ; DATA XREF: LOAD:00000018↑o
LOAD:00017C30                                         ; LOAD:stru_66C↑o
LOAD:00017C30                 LDR             R0, =(unk_1C3000 - 0x17C3C)
LOAD:00017C34                 ADD             R0, PC, R0 ; unk_1C3000
LOAD:00017C38                 B               __cxa_finalize
LOAD:00017C38 ; End of function start
LOAD:00017C38
LOAD:00017C38 ; ---------------------------------------------------------------------------
LOAD:00017C3C off_17C3C       DCD unk_1C3000 - 0x17C3C
LOAD:00017C3C                                         ; DATA XREF: start↑r


0017C3C                                         ; DATA XREF: start↑r
LOAD:00017C40 ; ---------------------------------------------------------------------------
LOAD:00017C40
LOAD:00017C40 loc_17C40                               ; DATA XREF: LOAD:00017C5C↓o
LOAD:00017C40                                         ; LOAD:off_17C68↓o
LOAD:00017C40                 CMP             R0, #0
LOAD:00017C44                 BXEQ            LR
LOAD:00017C48                 BX              R0
LOAD:00017C4C ; ---------------------------------------------------------------------------
LOAD:00017C4C                 MOV             R1, R0
LOAD:00017C50                 LDR             R2, =(unk_1C3000 - 0x17C60)
LOAD:00017C54                 LDR             R0, =(loc_17C40 - 0x17C64)
LOAD:00017C58                 ADD             R2, PC, R2 ; unk_1C3000
LOAD:00017C5C                 ADD             R0, PC, R0 ; loc_17C40
LOAD:00017C60                 B               __cxa_atexit
LOAD:00017C60 ; ---------------------------------------------------------------------------
LOAD:00017C64 off_17C64       DCD unk_1C3000 - 0x17C60
LOAD:00017C64                                         ; DATA XREF: LOAD:00017C50↑r
LOAD:00017C68 off_17C68       DCD loc_17C40 - 0x17C64 ; DATA XREF: LOAD:00017C54↑r
LOAD:00017C6C                 CODE16
LOAD:00017C6C
LOAD:00017C6C ; =============== S U B R O U T I N E =======================================
LOAD:00017C6C
LOAD:00017C6C ; Attributes: bp-based frame
LOAD:00017C6C
LOAD:00017C6C sub_17C6C                               ; CODE XREF: sub_1BC30+8↓p
LOAD:00017C6C                                         ; LOAD:000303A6↓p ...
LOAD:00017C6C                 PUSH            {R7,LR}
LOAD:00017C6E                 ADD             R7, SP, #0
LOAD:00017C70                 BL              sub_17580
LOAD:00017C74                 POP             {R7,PC}
LOAD:00017C74 ; End of function sub_17C6C
LOAD:00017C74

获取当前光标位置地址

ea=here()
ea=ScreenEA()

遍历当前模块的segment

import idautils
import idc 

def loop_through_segments():
    '''
    遍历出所有的segment
    '''
    # ea=ScreenEA() ##获取当前光标指向的地址
    # print(hex(ea))
    for seg in idautils.Segments():
        print('segName:%s  0x%x-0x%x ' %(idc.SegName(seg),idc.SegStart(seg),idc.SegEnd(seg)))

segmentName:idc.SegName(seg) ##段名称
segmentStart:idc.SegStart(seg) ##段起始位置
segmentEnd:idc.SegEnd(seg) ## 段结束位置

获取段信息的其他api

idc.NextSeg(ea) ##获取当前段的下一个段
idc.SegByName(segname) ##根据名称获取段的地址，实际在测试的时候，调用这个函数只能返回的是segment的个数segment

输出：
Python>idc.SegByName('LOAD') 
2 ##表示有两个LOAD段

获取当前模块的导出所有函数

import idautils
import idc

def loop_module_funcs():
	for func in idautils.Functions(): ##获取所有的导出函数
		'''
		idautils.Functions列举出已知的函数，返回一个list对象，每个item是一个函数的首地址，
		通过idc.GetFunctionName(funcAddr)获取函数名称
		'''
		print(hex(func),idc.GetFunctionName(func))
		
		
idautils.Functions():返回所有的导出函数的函数地址，可以通过for来循环迭代每个函数

idautils.GetFuncntionName(ea):根据当前的函数地址，返回函数名称。
		

获取函数的起始和结束地址

有时候我们在读取一个函数的指令的时候，需要知道函数的起始地址和结束地址，使用idaapi.get_func(faddr)

def get_func_boundaries(ea):
	func=idaapi.get_func(ea)
	start = func.start_ea
	end	  =func.end_ea
	print('start: 0x%x end:0x%x' %(start,end))
	
def loop_module_funcs():
	for func in idautils.Functions():
		'''
		idautils.Functions列举出已知的函数，返回一个list对象，每个item是一个函数的首地址，
		通过idc.GetFunctionName(funcAddr)获取函数名称
		'''
		print(hex(func),idc.GetFunctionName(func))
		get_func_boundaries(func)
loop_module_funcs() 


idaapi.get_func(ea):返回一个func_t对象，其中包含了函数的起始地址和结束地址


使用dir函数查看func_t对象，如下
Python>func = idaapi.get_func(0x17C30)
Python>type(func)
<class 'ida_funcs.func_t'>
Python>dir(func)
['__class__', '__del__', '__delattr__', 
'__dict__', '__doc__', '__eq__', '__format__',
 '__getattribute__', '__gt__', '__hash__', '__init__',
  '__lt__', '__module__', '__ne__', '__new__', '__reduce__', 
  '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', 
  '__str__', '__subclasshook__', '__swig_destroy__', 
  '__weakref__', '_print', 'analyzed_sp', 'argsize', 
  'clear', 'color', 'compare', 'contains', 'does_return', 
  'empty', 'endEA', 'end_ea', 'extend', 'flags', 'fpd', 
  'frame', 'frregs', 'frsize', 'intersect', 'is_far', 
  'llabelqty', 'llabels', 'overlaps', 'owner', 'pntqty',
   'points', 'referers', 'refqty', 'regargqty', 'regargs',
    'regvarqty', 'regvars', 'size', 'startEA', 'start_ea', 
    'tailqty', 'tails', 'this', 'thisown']


其中的startEA,start_ea 和endEA ,end_ea表示函数的边界值

在ida中执行上述脚本，输出如下：

('0x173c4L', 'strerror')
start: 0x173c4 end:0x173d0
('0x173d0L', 'memcpy')
start: 0x173d0 end:0x173dc
('0x173dcL', 'sub_173DC')
start: 0x173dc end:0x173de
	

列出指定地址范围内的所有函数

有时候可能模块的很多区域的函数我们不需要，只需要指定一定范围内的并列举出该范围内的函数,如果全部列出可能会花费很大时间见，可以使用idautils.Functions(start_addr,end_addr)来读取

def loop_module_funcs(start_addr,end_addr):
	for func in idautils.Functions(start_addr,end_addr):
		print(hex(func),idc.GetFunctionName(func))
		get_func_boundaries(func)

loop_module_funcs(0x17514L,0x17560L)

idc.GetFunctionName(func):获取函数地址处的函数名称

上述脚本表述只列出了0x17514L~0x17560L之间的函数，如下

('0x17514L', '__aeabi_memset4')
start: 0x17514 end:0x17520
('0x17520L', 'j_clock_gettime')
start: 0x17520 end:0x17524
('0x17524L', 'clock_gettime')
start: 0x17524 end:0x17530
('0x17530L', 'sub_17530')
start: 0x17530 end:0x17532
('0x17534L', 'readlink')
start: 0x17534 end:0x17540
('0x17540L', 'j_sscanf')
start: 0x17540 end:0x17544
('0x17544L', 'sscanf')
start: 0x17544 end:0x17550
('0x17550L', 'sub_17550')
start: 0x17550 end:0x17552
('0x17554L', 'free')
start: 0x17554 end:0x17560

其他常用获取模块函数的api

可以对应查看开始处的代码片段

##获取下一个函数
idc.NextFunction(addr)

nfc=idc.NextFunction(0x17C30)
Python>idc.GetFunctionName(nfc)
sub_17C6C

---------------------
获取上一个函数
idc.PrevFunction(addr)

Python>pre = idc.PrevFunction(0x17C30)
Python>idc.GetFunctionName(pre)
fstat

获取函数的指令

• 读取函数的起始地址和结束地址
• 读取函数内的指令，包括 汇编指令 操作数

#coding:utf8

import idaapi
import idc
import idautils


def get_func_boundaries(ea):
	func=idaapi.get_func(ea)
	start = func.start_ea
	end	  =func.end_ea
	# print('start: 0x%x end:0x%x' %(start,end))
	return start,end

def get_disassm(addr):

	'''
	这里读取start函数内的指令即可
	'''
	start,end = get_func_boundaries(addr)
	while True: ##
		print('start: 0x%x' %start)
		mnemonic=idc.GetMnem(start)##获取指令的助记符
		op1=idc.GetOpnd(start,0) ###获取指令的操作数1，
		op2 = idc.GetOpnd(start,1) ### 获取指令的操作数2
		# print('mnemonic:%s  op1:%s op2:%s ' %(mnemonic,op1,op2))
		##完整的一条指令 
		print('disasm:')
		disasm = idc.GetDisasm(start) ###获取程序指令
		print(disasm)
		start +=4 ##每次地址递增4个字节
		if start>=end:
			break
		

get_disassm(0x17C30)

输出：

start: 0x17c30
disasm:
LDR             R0, =(unk_1C3000 - 0x17C3C)
start: 0x17c34
disasm:
ADD             R0, PC, R0; unk_1C3000
start: 0x17c38
disasm:
B               __cxa_finalize

以上就将start出的函数所有指令都提取出来

读取函数指令2

在上面的程序中，利用现有的知识点来读取指定函数的指令，当然，ida还提供来另一种方式来读取指定函数地址出的指令，如下

def get_disasm2(addr):
	'''
	读取指令的另一种方式
	'''
	start = idc.GetFunctionAttr(addr,FUNCATTR_START) ## 通过idc.GetFunctionAttr来获取函数的起始地址，起中第二个参数使用FUNCATTR_START表示起始
	end=idc.GetFunctionAttr(addr,FUNCATTR_END) ## 通过idc.GetFunctionAttr来获取函数的起始地址，起中第二个参数使用FUNCATTR_END表示结束
	cur_start=start
	print('start22: 0x%x end:0x%x' %(start,end))
	while cur_start<=end: ###结束条件为当前指令地址大于函数的结束地址
		print('addr2:0x%x'%cur_start)
		disasm = idc.GetDisasm(cur_start)
		print(disasm)
		cur_start=idc.NextHead(cur_start,end) ###读取下一个指令的地址，类似于我们的start+=4
		
运行后，输出结果为：

start22: 0x17c30 end:0x17c3c
addr2:0x17c30
LDR             R0, =(unk_1C3000 - 0x17C3C)
addr2:0x17c34
ADD             R0, PC, R0; unk_1C3000
addr2:0x17c38
B               __cxa_finalize		

读取指令3

使用idautils.FuncItems(addr)来获取函数的所有指令地址，这里比较好的是不用去判断某个指令地址大于函数的结束地址，如下指令

def get_disasm33(addr):

	'''
	使用idc.FuncItems(addr)函数类读取一个函数的指令和边界值，idc.FuncItems(addr)返回一个可迭代对象
	将这个对象转为了list即可。这个list内部是一个顺序的地址值，从函数的起始地址到结束地址开始
	'''
	pass
	disasm_addrs = list(idautils.FuncItems(addr))
	for d  in disasm_addrs:
		print(idc.GetDisasm(d))
		
输出：
LDR             R0, =(unk_1C3000 - 0x17C3C)
ADD             R0, PC, R0; unk_1C3000
B               __cxa_finalize
		

读取指令需要注意的问题

• 有些地址不存在，需要处理，使用idaapi.BADADDR来做对比

Python>if n != idaapi.BADADDR:print ('valid addr ')
valid addr 

• 上述两个遍历指令的方式缺点为：
  1、只能读取包括在函数边界边内的，如果存在跳转指令，则有可能导致结束地址小于跳转指令，那么将会导致不能全部读取指令值。
  2、当出现跳转地址大于函数的边界值时，这种在代码混淆中常常存在。

判断指令类型

通常在读取指令的时候，可能需要判断一下指令的操作数类型，是否是寄存器还是常数函数指向内存的指针等

• idc.GetOpType(addr,index) 表示要获取的操作数类型，index表示第一个还是第二个
• 常用的类型包括了

o_void     = ida_ua.o_void      # No Operand                           ----------
o_reg      = ida_ua.o_reg       # General Register (al,ax,es,ds...)    reg
o_mem      = ida_ua.o_mem       # Direct Memory Reference  (DATA)      addr
o_phrase   = ida_ua.o_phrase    # Memory Ref [Base Reg + Index Reg]    phrase
o_displ    = ida_ua.o_displ     # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr
o_imm      = ida_ua.o_imm       # Immediate Value                      value
o_far      = ida_ua.o_far       # Immediate Far Address  (CODE)        addr
o_near     = ida_ua.o_near      # Immediate Near Address (CODE)        addr
o_idpspec0 = ida_ua.o_idpspec0  # Processor specific type
o_idpspec1 = ida_ua.o_idpspec1  # Processor specific type
o_idpspec2 = ida_ua.o_idpspec2  # Processor specific type
o_idpspec3 = ida_ua.o_idpspec3  # Processor specific type
o_idpspec4 = ida_ua.o_idpspec4  # Processor specific type
o_idpspec5 = ida_ua.o_idpspec5  # Processor specific type
                                # There can be more processor specific types

# x86
o_trreg  =       ida_ua.o_idpspec0      # trace register
o_dbreg  =       ida_ua.o_idpspec1      # debug register
o_crreg  =       ida_ua.o_idpspec2      # control register
o_fpreg  =       ida_ua.o_idpspec3      # floating point register
o_mmxreg  =      ida_ua.o_idpspec4      # mmx register
o_xmmreg  =      ida_ua.o_idpspec5      # xmm register

# arm
o_reglist  =     ida_ua.o_idpspec1      # Register list (for LDM/STM)
o_creglist  =    ida_ua.o_idpspec2      # Coprocessor register list (for CDP)
o_creg  =        ida_ua.o_idpspec3      # Coprocessor register (for LDC/STC)
o_fpreglist  =   ida_ua.o_idpspec4      # Floating point register list
o_text  =        ida_ua.o_idpspec5      # Arbitrary text stored in the operand
o_cond  =        (ida_ua.o_idpspec5+1)  # ARM condition as an operand

# ppc
o_spr  =         ida_ua.o_idpspec0      # Special purpose register
o_twofpr  =      ida_ua.o_idpspec1      # Two FPRs
o_shmbme  =      ida_ua.o_idpspec2      # SH & MB & ME
o_crf  =         ida_ua.o_idpspec3      # crfield      x.reg
o_crb  =         ida_ua.o_idpspec4      # crbit        x.reg
o_dcr  =    

如何获取当前指令的上一个指令和下一个指令

有时候我们只有同一个地址值并且能读取到当前地址的指令，为了能获取到当前指令的上一个或者下一个指令，通过idc,PrevHead(addr)和idc.NextHead(addr)来
获取。如下

我们引用的是0x17C34处的地址，实际得到的是指令为

ADD             R0, PC, R0 
上一条指令为：
Python>pre = idc.PrevHead(0x17C34 )
Python>idc.GetDisasm(pre)
LDR             R0, =(unk_1C3000 - 0x17C3C)
------------------------------------------
读取下一条指令为：
Python>nt = idc.NextHead(0x17C34)
Python>idc.GetDisasm(nt)
B               __cxa_finalize

总结

• 在ida的高版本中,6.95 -7.0以后，有一些api发生了变化。我们使用inspect查看函数

如下

Python>import inspect
Python>inspect.getsource(SegByName)
def SegByName(segname): return selector_by_name(segname) 

---

读取光标所在的位置：ScreenEA(),here()

读取段：

• 读取段名称：idc.SegName(addr)
• 遍历段：idautils.Segments()返回一个可迭代对象，通过这个对象来获取模块的segment，
• 获取段首地址：idc.SegStart(seg)
• 获取段结束地址：idc.SegEnd(seg)
• 读取下一个段:idc.NextSeg(seg)
• 根据段名称获取段个数:idc.SegByName(segname)

读取函数：

• 获取所有导出的函数：idc.Functions()返回一个可迭代对象,利用for来迭代，每次返回一个函数地址func_addr

• 获取指定返回的导出函数：idc.Functions(start,end) 会将start和end之间的函数迭代出来

• 获取函数名称：idc.GetFunctionName(func_addr)

• 获取函数的首地址和结束地址：

• func=idaapi.get_func(func_addr)

• 这里的func是一个func_t对象，

• 可以通过访问start_ea和end_ea来获取到函数的起始地址和结束地址
  start=func.start_ea
  end=func.end_ea

• 获取下一个函数：idc.NextFunction(addr)

• 获取上一个函数:idc.PrevFunction(addr)

• 读取函数的起始地址：idc.GetFunctionAttr(addr,FUNCATTR_START)

• 读取函数的结束地址：idc.GetFunctionAttr(addr,FUNCATTR_END)

读取指令：

• 读取助记符：idc.GetMnem(addr)
• 读取操作数1：idc.GetOpnd(addr,0)
• 读取操作数2：idc.GetOpnd(addr,1)
• 读取操作数1的类型:idc.GetOpType(addr,0)
• 读取操作数2的类型:idc.GetOpType(addr,1)
• 读取汇编指令：idc.GetDisasm(addr)
• 读取函数的所有指令地址：idautils.FuncItems(addr) 可以通过将得到的是强转为一个list对象，也可以直接迭代，推荐使用此方法来读取指令
• 读取当前指令的上一条指令地址：idc.PrevHead(addr)
• 读取当前指令的下一条指令地址：idc.NextHead(addr)

未完…