21.1 Python 使用PEfile分析PE文件

李品一

PeFile模块是Python中一个强大的便携式第三方PE格式分析工具，用于解析和处理Windows可执行文件。该模块提供了一系列的API接口，使得用户可以通过Python脚本来读取和分析PE文件的结构，包括文件头、节表、导入表、导出表、资源表、重定位表等等。此外，PEfile模块还可以帮助用户进行一些恶意代码分析，比如提取样本中的字符串、获取函数列表、重构导入表、反混淆等等。PEfile模块是Python中处理PE文件的重要工具之一，广泛应用于二进制分析、安全研究和软件逆向工程等领域。
由于该模块为第三方模块，在使用之前读者需要在命令行下执行pip install pefile命令安装第三方库，当安装成功后即可正常使用，如下所示则是该模块的基本使用方法，读者可自行学习理解。
21.1.1 打开并加载PE文件

如下这段代码封装并实现了OpenPeFile函数，可用于打开一个PE文件，在其内部首先判断了可执行文件是否被压缩如果被压缩则会通过zipfile模块将压缩包读入内存并调用C2BIP3函数将数据集转换为2字节，接着再执行pefile.PE()函数，该函数可用于将可执行文件载入，至此读者可在主函数内通过pe.dump_dict()的方式输出该PE文件的所有参数，由于输出的是字典，读者可以使用字典与列表的方式灵活的提取出该程序的所有参数信息。

1. import sys
2. import zipfile
3. import pefile
5. # 如果是Python3则转换为2字节
6. def C2BIP3(string):
7.     if sys.version_info[0] > 2:
8.         return bytes([ord(x) for x in string])
9.     else:
10.         return string
12. # 打开文件
13. def OpenPeFile(filename):
15.     # 判断是否是ZIP压缩包
16.     if filename.lower().endswith('.zip'):
17.         try:
18.             oZipfile = zipfile.ZipFile(filename, 'r')
19.             file = oZipfile.open(oZipfile.infolist()[0], 'r', C2BIP3('infected'))
20.         except Exception:
21.             print(sys.exc_info()[1])
22.             sys.exit()
23.         oPE = pefile.PE(data=file.read())
24.         file.close()
25.         oZipfile.close()
27.     # 如果是空则
28.     elif filename == '':
29.         oPE = False
30.         return oPE
31.     # 否则直接打开文件
32.     else:
33.         oPE = pefile.PE(filename)
34.     return oPE
36. if __name__ == "__main__":
37.     pe = OpenPeFile("d://lyshark.exe")
38.     print(pe.FILE_HEADER.dump())
39.     print(pe.dump_dict())

复制代码

21.1.2 解析PE头部数据

如下代码实现了解析PE结构中头部基本数据，在GetHeader函数内，我们首先通过pe.FILE_HEADER.Machine成员判断当前读入的文件的位数信息，通过pe.FILE_HEADER.Characteristics可判断PE文件的类型，通常为EXE可执行文件或DLL动态链接库文件，通过AddressOfEntryPoint加上ImageBase则可获取到程序的实际装载地址，压缩数据的计算可通过hashlib模块对PE文件字节数据进行计算摘要获取，最后是附加数据，通过get_overlay_data_start_offset则可获取到，并依次循环即可输出所有附加数据。

1. import hashlib
2. import pefile
4. # 计算得到数据长度,自动使用推荐大小
5. def NumberOfBytesHumanRepresentation(value):
6.     if value <= 1024:
7.         return '%s bytes' % value
8.     elif value < 1024 * 1024:
9.         return '%.1f KB' % (float(value) / 1024.0)
10.     elif value < 1024 * 1024 * 1024:
11.         return '%.1f MB' % (float(value) / 1024.0 / 1024.0)
12.     else:
13.         return '%.1f GB' % (float(value) / 1024.0 / 1024.0 / 1024.0)
15. # 获取PE头部基本信息
16. def GetHeader(pe):
17.     raw = pe.write()
19.     # 扫描基本信息
20.     print("-" * 50)
21.     print("程序基本信息")
22.     print("-" * 50)
23.     if (hex(pe.FILE_HEADER.Machine) == "0x14c"):
24.         print("程序位数: {}".format("x86"))
25.     if (hex(pe.FILE_HEADER.Machine) == "0x8664"):
26.         print("程序位数: {}".format("x64"))
28.     if (hex(pe.FILE_HEADER.Characteristics) == "0x102"):
29.         print("程序类型: Executable")
30.     elif (hex(pe.FILE_HEADER.Characteristics) == "0x2102"):
31.         print("程序类型: Dynamic link library")
33.     if pe.OPTIONAL_HEADER.AddressOfEntryPoint:
34.         oep = pe.OPTIONAL_HEADER.AddressOfEntryPoint + pe.OPTIONAL_HEADER.ImageBase
35.         print("实际入口: {}".format(hex(oep)))
37.     print("映像基址: {}".format(hex(pe.OPTIONAL_HEADER.ImageBase)))
38.     print("虚拟入口: {}".format(hex(pe.OPTIONAL_HEADER.AddressOfEntryPoint)))
39.     print("映像大小: {}".format(hex(pe.OPTIONAL_HEADER.SizeOfImage)))
40.     print("区段对齐: {}".format(hex(pe.OPTIONAL_HEADER.SectionAlignment)))
41.     print("文件对齐: {}".format(hex(pe.OPTIONAL_HEADER.FileAlignment)))
42.     print("区块数量: {}".format(int(pe.FILE_HEADER.NumberOfSections + 1)))
43.     print('熵值比例: %f (Min=0.0, Max=8.0)' % pe.sections[0].entropy_H(raw))
45.     # 计算压缩数据
46.     print("-" * 50)
47.     print("计算压缩数据")
48.     print("-" * 50)
49.     print('MD5     : %s' % hashlib.md5(raw).hexdigest())
50.     print('SHA-1   : %s' % hashlib.sha1(raw).hexdigest())
51.     print('SHA-256 : %s' % hashlib.sha256(raw).hexdigest())
52.     print('SHA-512 : %s' % hashlib.sha512(raw).hexdigest())
54.     # 扫描文件末尾是否存在附加数据
55.     print("-" * 50)
56.     print("扫描附加数据")
57.     print("-" * 50)
58.     overlayOffset = pe.get_overlay_data_start_offset()
59.     if overlayOffset != None:
60.         print("起始文件位置: 0x%08x"%overlayOffset)
61.         overlaySize = len(raw[overlayOffset:])
62.         print("长度: 0x%08x %s %.2f%%"%(overlaySize, NumberOfBytesHumanRepresentation(overlaySize), float(overlaySize) / float(len(raw)) * 100.0))
63.         print("MD5: %s" %hashlib.md5(raw[overlayOffset:]).hexdigest())
64.         print("SHA-256: %s" %hashlib.sha256(raw[overlayOffset:]).hexdigest())
66. if __name__ == "__main__":
67.     pe = pefile.PE("d://lyshark.exe")
68.     GetHeader(pe)

复制代码

21.1.5 解析数据为Hex格式

如下代码片段实现了对PE文件的各种十六进制操作功能，封装cDump()类，该类内由多个类函数可以使用，其中HexDump()可用于将读入的PE文件以16进制方式输出，HexAsciiDump()则可用于输出十六进制以及所对应的ASCII格式，GetSectionHex()用于找到PE文件的.text节，并将此节内的数据读入到内存中，这段代码可以很好的实现对PE文件的十六进制输出与解析，读者可在实际开发中使用。

1. import hashlib
2. import pefile
4. # 计算得到数据长度,自动使用推荐大小
5. def NumberOfBytesHumanRepresentation(value):
6.     if value <= 1024:
7.         return '%s bytes' % value
8.     elif value < 1024 * 1024:
9.         return '%.1f KB' % (float(value) / 1024.0)
10.     elif value < 1024 * 1024 * 1024:
11.         return '%.1f MB' % (float(value) / 1024.0 / 1024.0)
12.     else:
13.         return '%.1f GB' % (float(value) / 1024.0 / 1024.0 / 1024.0)
15. # 输出所有的节
16. def ScanSection(pe):
17.     print("-" * 100)
18.     print("{:10s}{:10s}{:10s}{:10s}{:10s}{:10s}{:10s}{:10s}".
19.           format("序号","节区名称","虚拟偏移","虚拟大小","实际偏移","实际大小","节区属性","熵值"))
20.     print("-" * 100)
21.     section_count = int(pe.FILE_HEADER.NumberOfSections + 1)
23.     for count,item in zip(range(1,section_count),pe.sections):
24.         print("%d\t\t\t%-10s\t0x%.8X\t0x%.8X\t0x%.8X\t0x%.8X\t0x%.8X\t%f"
25.               %(count,(item.Name).decode("utf-8"),item.VirtualAddress,item.Misc_VirtualSize,item.PointerToRawData,item.SizeOfRawData,item.Characteristics,item.get_entropy()))
26.     print("-" * 100)
28. # 计算所有节的MD5
29. def CheckSection(pe):
30.     print("-" * 100)
31.     print("序号\t\t节名称\t\t文件偏移\t\t大小\t\tMD5\t\t\t\t\t\t\t\t\t\t节大小")
32.     print("-" * 100)
34.     # 读取PE文件到内存
35.     image_data = pe.get_memory_mapped_image()
37.     section_count = int(pe.FILE_HEADER.NumberOfSections + 1)
38.     for count,item in zip(range(1,section_count),pe.sections):
40.         section_data = image_data[item.PointerToRawData: item.PointerToRawData + item.SizeOfRawData - 1]
41.         data_size = NumberOfBytesHumanRepresentation(len(section_data))
42.         hash_value = hashlib.md5(section_data).hexdigest()
43.         print("{}\t{:10s}\t{:10X}\t{:10X}\t{:30s}\t{}".format(count,(item.Name).decode("utf-8"),item.PointerToRawData,item.SizeOfRawData,hash_value,data_size))
44.     print("-" * 100)
46. if __name__ == "__main__":
47.     pe = pefile.PE("d://lyshark.exe")
48.     ScanSection(pe)
49.     CheckSection(pe)

复制代码

21.1.6 解析数据目录表

数据目录表用于记录可执行文件的数据目录项在文件中的位置和大小。数据目录表共有16个条目，每个条目都对应着一个数据目录项，每个数据目录项都描述了可执行文件中某一部分的位置和大小。
数据目录表的解析可以使用pe.OPTIONAL_HEADER.NumberOfRvaAndSizes首先获取到数据目录表的个数，接着二通过循环个数依次解包OPTIONAL_HEADER.DATA_DIRECTORY里面的每一个列表，在循环列表时依次解包输出即可。

1. import pefile
3. # 将RVA转换为FOA的函数
4. def RVAToFOA(pe,rva):
5.     for item in pe.sections:
6.         Section_Start = item.VirtualAddress
7.         Section_Ends = item.VirtualAddress + item.SizeOfRawData
8.         if rva >= Section_Start and rva < Section_Ends:
9.             return rva - item.VirtualAddress + item.PointerToRawData
10.     return -1
12. # 将FOA文件偏移转换为RVA相对地址
13. def FOAToRVA(pe,foa):
14.     ImageBase = pe.OPTIONAL_HEADER.ImageBase
15.     NumberOfSectionsCount = pe.FILE_HEADER.NumberOfSections
17.     for index in range(0,NumberOfSectionsCount):
18.         PointerRawStart = pe.sections[index].PointerToRawData
19.         PointerRawEnds = pe.sections[index].PointerToRawData + pe.sections[index].SizeOfRawData
21.         if foa >= PointerRawStart and foa <= PointerRawEnds:
22.             rva = pe.sections[index].VirtualAddress + (foa - pe.sections[index].PointerToRawData)
23.             return rva
24.     return -1
26. # 内部功能实现FOA->RVA互转
27. def inside(pe):
28.     # 从FOA获取RVA 传入十进制
29.     rva = pe.get_rva_from_offset(3952)
30.     print("对应内存RVA: {}".format(hex(rva)))
32.     # 从RVA获取FOA 传入十进制
33.     foa = pe.get_offset_from_rva(rva)
34.     print("对应文件FOA: {}".format(foa))
36. if __name__ == "__main__":
37.     pe = pefile.PE("d://lyshark.exe")
38.     ref = RVAToFOA(pe,4128)
39.     print("RVA转FOA => 输出十进制: {}".format(ref))
41.     ref = FOAToRVA(pe,1056)
42.     print("FOA转RVA => 输出十进制: {}".format(ref))

复制代码

21.1.7 解析导入导出表

导入表和导出表都是PE文件中的重要数据结构，分别记录着一个模块所导入和导出的函数和数据，如下所示则是使用PeFile模块实现对导入表与导出表的解析工作，对于导入表ScanImport的解析需要通过pe.DIRECTORY_ENTRY_IMPORT获取到完整的导入目录，并通过循环的方式输出x.imports中的数据即可，而对于导出表ScanExport则需要在pe.DIRECTORY_ENTRY_EXPORT.symbols导出符号中解析获取。

1. import pefile
2. from io import StringIO
3. import sys
4. import re
6. dumplinelength = 16
8. def CIC(expression):
9.     if callable(expression):
10.         return expression()
11.     else:
12.         return expression
14. def IFF(expression, valueTrue, valueFalse):
15.     if expression:
16.         return CIC(valueTrue)
17.     else:
18.         return CIC(valueFalse)
20. class cDump():
21.     def __init__(self, data, prefix='', offset=0, dumplinelength=16):
22.         self.data = data
23.         self.prefix = prefix
24.         self.offset = offset
25.         self.dumplinelength = dumplinelength
27.     # 输出指定位置的十六进制格式
28.     def HexDump(self):
29.         oDumpStream = self.cDumpStream(self.prefix)
30.         hexDump = ''
31.         for i, b in enumerate(self.data):
32.             if i % self.dumplinelength == 0 and hexDump != '':
33.                 oDumpStream.Addline(hexDump)
34.                 hexDump = ''
35.             hexDump += IFF(hexDump == '', '', ' ') + '%02X' % self.C2IIP2(b)
36.         oDumpStream.Addline(hexDump)
37.         return oDumpStream.Content()
39.     def CombineHexAscii(self, hexDump, asciiDump):
40.         if hexDump == '':
41.             return ''
42.         countSpaces = 3 * (self.dumplinelength - len(asciiDump))
43.         if len(asciiDump) <= self.dumplinelength / 2:
44.             countSpaces += 1
45.         return hexDump + '  ' + (' ' * countSpaces) + asciiDump
47.     # 输出指定位置的十六进制格式以及ASCII字符串
48.     def HexAsciiDump(self):
49.         oDumpStream = self.cDumpStream(self.prefix)
50.         hexDump = ''
51.         asciiDump = ''
52.         for i, b in enumerate(self.data):
53.             b = self.C2IIP2(b)
54.             if i % self.dumplinelength == 0:
55.                 if hexDump != '':
56.                     oDumpStream.Addline(self.CombineHexAscii(hexDump, asciiDump))
57.                 hexDump = '%08X:' % (i + self.offset)
58.                 asciiDump = ''
59.             if i % self.dumplinelength == self.dumplinelength / 2:
60.                 hexDump += ' '
61.             hexDump += ' %02X' % b
62.             asciiDump += IFF(b >= 32 and b <= 128, chr(b), '.')
63.         oDumpStream.Addline(self.CombineHexAscii(hexDump, asciiDump))
64.         return oDumpStream.Content()
66.     class cDumpStream():
67.         def __init__(self, prefix=''):
68.             self.oStringIO = StringIO()
69.             self.prefix = prefix
71.         def Addline(self, line):
72.             if line != '':
73.                 self.oStringIO.write(self.prefix + line + '\n')
75.         def Content(self):
76.             return self.oStringIO.getvalue()
78.     @staticmethod
79.     def C2IIP2(data):
80.         if sys.version_info[0] > 2:
81.             return data
82.         else:
83.             return ord(data)
85. # 只输出十六进制数据
86. def HexDump(data):
87.     return cDump(data, dumplinelength=dumplinelength).HexDump()
89. # 输出十六进制与ASCII字符串
90. def HexAsciiDump(data):
91.     return cDump(data, dumplinelength=dumplinelength).HexAsciiDump()
93. # 找到指定节并读取hex数据
94. def GetSectionHex(pe):
95.     ImageBase = pe.OPTIONAL_HEADER.ImageBase
96.     for item in pe.sections:
97.         # 判断是否是.text节
98.         if str(item.Name.decode('UTF-8').strip(b'\x00'.decode())) == ".text":
99.             # print("虚拟地址: 0x%.8X 虚拟大小: 0x%.8X" %(item.VirtualAddress,item.Misc_VirtualSize))
100.             VirtualAddress = item.VirtualAddress
101.             VirtualSize = item.Misc_VirtualSize
102.             ActualOffset = item.PointerToRawData
104.             StartVA = hex(ImageBase + VirtualAddress)
105.             StopVA = hex(ImageBase + VirtualAddress + VirtualSize)
106.             print("[+] 代码段起始地址: {} 结束: {} 实际偏移:{} 长度: {}".format(StartVA, StopVA, ActualOffset, VirtualSize))
108.             # 获取到.text节区间内的数据
109.             hex_code = pe.write()[ActualOffset: VirtualSize]
110.             return hex_code
111.         else:
112.             print("程序中不存在.text节")
113.             return 0
114.     return 0
116. REGEX_STANDARD = '[\x09\x20-\x7E]'
118. def ExtractStringsASCII(data):
119.     regex = REGEX_STANDARD + '{%d,}'
120.     return re.findall(regex % 4, data)
122. def ExtractStringsUNICODE(data):
123.     regex = '((' + REGEX_STANDARD + '\x00){%d,})'
124.     return [foundunicodestring.replace('\x00', '') for foundunicodestring, dummy in re.findall(regex % 4, data)]
126. # 将传入Hex字符串以每16字符分割在一个列表内
127. def ExtractStrings(data):
128.     return ExtractStringsASCII(data) + ExtractStringsUNICODE(data)
130. if __name__ == "__main__":
131.     pe = pefile.PE("d://lyshark.exe")
133.     # 得到.text节内数据
134.     ref = GetSectionHex(pe)
136.     # 转为十六进制格式
137.     dump_hex = HexDump(ref)
138.     print(dump_hex)
140.     # 打包为每16字符一个列表
141.     dump_list = ExtractStrings(dump_hex)
143.     print(dump_list)

复制代码

本文作者： 王瑞
本文链接： https://www.lyshark.com/post/92a3370c.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

来源:https://www.cnblogs.com/LyShark/p/17775685.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！