使用Frida对Windows平台的程序进行逆向分析

 Frida由于使用JavaScript语言安装钩子的便利性而在最近变得越来越流行。我看到许多研究都将Frida用于移动平台，但最近Windows似乎在使用方面有了更多的吸引力。在DarunGrim，我们正在研究安全研究人员可以用于日常工作的新方法。Frida是我们认为可用于Windows逆向工程的工具之一。但是，在我们的测试过程中，我们发现符号查找功能是该工具广泛使用的限制因素。我们进行了改进，现在Frida 12.9.8中可以使用它。我们非常感谢OleAndréVadlaRavnås在合并变更方面的帮助。

创新互联公司服务项目包括曲靖网站建设、曲靖网站制作、曲靖网页制作以及曲靖网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，曲靖网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到曲靖省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

我们将简要介绍一下所做的更改，并说明如何在现实世界中解决问题时使用改进的符号查找功能。

0x01 对Frida 12.9.8 的改进

Frida使用dbghelp.dll API在Windows平台中查找符号。但是它缺少符号服务器支持。我们增加了对符号服务器的支持，并改进了Windows中传递符号字符串的方式。在较旧的Frida实现中，查找每个符号花费了一些时间，因为它使用通配符模块名称查找任何符号。现在，你可以指定模块名称以加快符号查找的速度。

新的Frida将随symsrv.dll和dbghelp.dll一起提供，以支持包括Microsoft符号服务器在内的符号服务器。

这些是我们在Ole的帮助下所做的更改。

 
 
 
 
    
  
  
  
  
  1. · Add load_symbols() and improve the DbgHelp backend
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. · Migrate agent to new DbgHelp layout on Windows
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. · Frida 12.9.8
    6.

0x02 分析office的恶意宏

使用改进的Frida对一个Office Macro恶意软件进行分析，我们希望将其应用到Frida中进行深度分析。

代码注入

下图显示了Frida通常如何安装hook并从已安装的hook中获取消息。

此过程中涉及frida，session，脚本对象，以管理hook安装。hook回调是用JavaScript编写的。

以下代码显示了如何使用这些对象来安装分配给self.script_text变量的JavaScript hook代码以使用process_id变量进行处理的示例。

 
 
 
 
    
  
  
  
  
  1. https://github.com/ohjeongwook/Frida.examples.vbe/blob/master/code.py
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. 
  
  
  
  
  4. import os
    5. 
  
  
  
  
  5. import sys
    6. 
  
  
  
  
  6. import frida
    7. 
  
  
  
  
  7. import process
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. class Instrumenter:
    10. 
  
  
  
  
  10.     def __init__(self, script_text):
    11. 
  
  
  
  
  11.         self.sessions = []
    12. 
  
  
  
  
  12.         self.script_text = script_text
    13. 
  
  
  
  
  13.         self._device = frida.get_local_device()
    14. 
  
  
  
  
  14.         self._device.on("child-added", self._on_child_added)
    15. 
  
  
  
  
  15.         self._device.on("child-removed", self._on_child_removed)
    16. 
  
  
  
  
  16.         self._device.on("output", self._on_output)
    17. 
  
  
  
  
  17.         
    18. 
  
  
  
  
  18.     def __del__(self):
    19. 
  
  
  
  
  19.         for session in self.sessions:
    20. 
  
  
  
  
  20.             session.detach()
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.     def run(self, process_name):
    23. 
  
  
  
  
  23.         proc = process.Runner(process_name, suspended = True)
    24. 
  
  
  
  
  24.         if not proc.create():
    25. 
  
  
  
  
  25.             return
    26. 
  
  
  
  
  26.         process_id = proc.get_id()
    27. 
  
  
  
  
  27. 
  
  
  
  
  28.         self.instrument(process_id)
    29. 
  
  
  
  
  29. 
  
  
  
  
  30.         if proc:
    31. 
  
  
  
  
  31.             proc.resume()
    32. 
  
  
  
  
  32. 
  
  
  
  
  33.     def instrument(self, process_id):
    34. 
  
  
  
  
  34.         session = frida.attach(process_id)
    35. 
  
  
  
  
  35.         self.sessions.append(session)
    36. 
  
  
  
  
  36.         session.enable_child_gating()
    37. 
  
  
  
  
  37.         script = session.create_script(self.script_text)
    38. 
  
  
  
  
  38.         script.on('message', self.on_message)
    39. 
  
  
  
  
  39.         script.load()
    40. 
  
  
  
  
  40. 
  
  
  
  
  41.     def on_message(self, message, data):
    42. 
  
  
  
  
  42.         print("[%s] => %s" % (message, data))
    43. 
  
  
  
  
  43. 
  
  
  
  
  44.     def _on_child_added(self, child):
    45. 
  
  
  
  
  45.         print(" new child: {}".format(child))
    46. 
  
  
  
  
  46.         self.instrument(child.pid)
    47. 
  
  
  
  
  47. 
  
  
  
  
  48.     def _on_child_removed(self, child):
    49. 
  
  
  
  
  49.         print(" child terminated: {}".format(child))
    50. 
  
  
  
  
  50. 
  
  
  
  
  51.     def _on_output(self, pid, fd, data):
    52. 
  
  
  
  
  52.         print(" output: pid={}, fd={}, data={}".format(pid, fd, repr(data)))
    53. 
  
  
  
  
  53. 符号查找：resolveName
    54. 
  
  
  
  
  54. 
  
  
  
  
  55. Frida JavaScript API在API文档中有很好的描述。
    56. 
  
  
  
  
  56. 
  
  
  
  
  57. 使用Frida进行hook的第一步是找到目标函数。
    58. 
  
  
  
  
  58. 
  
  
  
  
  59. 如果函数已导出，则只需使用导出的函数名和DLL名称调用Module.findExportByName方法。
    60. 
  
  
  
  
  60. 
  
  
  
  
  61. Module.findExportByName(dllName, name)
    62. 
  
  
  
  
  62. 但是，如果该函数未导出并且仅记录在例如PDB符号文件中，则可以调用DebugSymbol.getFunctionByName方法。使用Frida 12.9.8，你可以传递“ DLLName！FunctionName”符号，以在指定特定功能时提高准确性，并在定位它们时获得更好的性能。
    63. 
  
  
  
  
  63. 
  
  
  
  
  64. 有时，为模块加载符号可能很慢，因为它可能来自远程符号服务器。因此，你需要调用DebugSymbol.load方法来启动符号的加载，以便我们加载最少数量的符号。
    65. 
  
  
  
  
  65. 
  
  
  
  
  66. 下面是一个示例代码，该示例代码使用Module.findExportByName和DebugSymbol方法查找任何带符号或导出的函数。它使用字典来缓存其发现，以删除所有重复的信息。如果你要hook大量函数，则可以节省整个符号查找时间。
    67. 
  
  
  
  
  67. 
  
  
  
  
  68. vbe.js
    69. 
  
  
  
  
  69. 
  
  
  
  
  70. https://github.com/ohjeongwook/Frida.examples.vbe/blob/master/vbe.js
    71. 
  
  
  
  
  71. 
  
  
  
  
  72. var loadedModules = {}
    73. 
  
  
  
  
  73. var resolvedAddresses = {}
    74. 
  
  
  
  
  74. 
  
  
  
  
  75. function resolveName(dllName, name) {
    76. 
  
  
  
  
  76.   var moduleName = dllName.split('.')[0]
    77. 
  
  
  
  
  77.   var functionName = moduleName + "!" + name
    78. 
  
  
  
  
  78. 
  
  
  
  
  79.   if (functionName in resolvedAddresses) {
    80. 
  
  
  
  
  80.     return resolvedAddresses[functionName]
    81. 
  
  
  
  
  81.   }
    82. 
  
  
  
  
  82. 
  
  
  
  
  83.   log("resolveName " + functionName);
    84. 
  
  
  
  
  84.   log("Module.findExportByName " + dllName + " " + name);
    85. 
  
  
  
  
  85.   var addr = Module.findExportByName(dllName, name)
    86. 
  
  
  
  
  86. 
  
  
  
  
  87.   if (!addr || addr.isNull()) {
    88. 
  
  
  
  
  88.     if (!(dllName in loadedModules)) {
    89. 
  
  
  
  
  89.       log(" DebugSymbol.loadModule " + dllName);
    90. 
  
  
  
  
  90. 
  
  
  
  
  91.       try {
    92. 
  
  
  
  
  92.         DebugSymbol.load(dllName)
    93. 
  
  
  
  
  93.       } catch (err) {
    94. 
  
  
  
  
  94.         return 0;
    95. 
  
  
  
  
  95.       }
    96. 
  
  
  
  
  96. 
  
  
  
  
  97.       log(" DebugSymbol.load finished");
    98. 
  
  
  
  
  98.       loadedModules[dllName] = 1
    99. 
  
  
  
  
  99.     }
    100. 
  
  
  
  
  100. 
  
  
  
  
  101.     try {
    102. 
  
  
  
  
  102.       log(" DebugSymbol.getFunctionByName: " + functionName);
    103. 
  
  
  
  
  103.       addr = DebugSymbol.getFunctionByName(moduleName + '!' + name)
    104. 
  
  
  
  
  104.       log(" DebugSymbol.getFunctionByName: addr = " + addr);
    105. 
  
  
  
  
  105.     } catch (err) {
    106. 
  
  
  
  
  106.       log(" DebugSymbol.getFunctionByName: Exception")
    107. 
  
  
  
  
  107.     }
    108. 
  
  
  
  
  108.   }
    109. 
  
  
  
  
  109. 
  
  
  
  
  110.   resolvedAddresses[functionName] = addr
    111. 
  
  
  
  
  111.   return addr
    112. 
  
  
  
  
  112. }
    113. 
  
  
  
  
  113. 
  
  
  
  
  114. function loadModuleForAddress(address) {
    115. 
  
  
  
  
  115.   var modules = Process.enumerateModules()
    116. 
  
  
  
  
  116. 
  
  
  
  
  117.   var i
    118. 
  
  
  
  
  118.   for (i = 0; i < modules.length; i++) {
    119. 
  
  
  
  
  119.     if (address >= modules[i].base && address <= modules[i].base.add(modules[i].size)) {
    120. 
  
  
  
  
  120.       log(" " + modules[i].name + ": " + modules[i].base + " " + modules[i].size + " " + modules[i].path)
    121. 
  
  
  
  
  121. 
  
  
  
  
  122.       var modName = modules[i].path
    123. 
  
  
  
  
  123.       if (!(modName in loadedModules)) {
    124. 
  
  
  
  
  124.         log("  DebugSymbol.loadModule " + modName);
    125. 
  
  
  
  
  125. 
  
  
  
  
  126.         try {
    127. 
  
  
  
  
  127.           DebugSymbol.load(modName)
    128. 
  
  
  
  
  128.         } catch (err) {
    129. 
  
  
  
  
  129.           return 0;
    130. 
  
  
  
  
  130.         }
    131. 
  
  
  
  
  131. 
  
  
  
  
  132.         loadedModules[modName] = 1
    133. 
  
  
  
  
  133.       }
    134. 
  
  
  
  
  134.       break
    135. 
  
  
  
  
  135.     }
    136. 
  
  
  
  
  136.   }
    137. 
  
  
  
  
  137. }
    138. 
  
  
  
  
  138. 
  
  
  
  
  139. var hookedFunctions = {}
    140. 
  
  
  
  
  140. var addressToFunctions = {}
    141. 
  
  
  
  
  141. var blackListedFunctions = {
    142. 
  
  
  
  
  142.   'I_RpcClearMutex': 1
    143. 
  
  
  
  
  143. }
    144. 
  
  
  
  
  144. 
  
  
  
  
  145. function hookFunction(dllName, funcName, callback) {
    146. 
  
  
  
  
  146.   if (funcName in blackListedFunctions) {
    147. 
  
  
  
  
  147.     return
    148. 
  
  
  
  
  148.   }
    149. 
  
  
  
  
  149.   var symbolName = dllName + "!" + funcName
    150. 
  
  
  
  
  150.   if (symbolName in hookedFunctions) {
    151. 
  
  
  
  
  151.     return
    152. 
  
  
  
  
  152.   }
    153. 
  
  
  
  
  153.   hookedFunctions[symbolName] = 1
    154. 
  
  
  
  
  154. 
  
  
  
  
  155.   var addr = resolveName(dllName, funcName)
    156. 
  
  
  
  
  156.   if (!addr || addr.isNull()) {
    157. 
  
  
  
  
  157.     return
    158. 
  
  
  
  
  158.   }
    159. 
  
  
  
  
  159. 
  
  
  
  
  160.   if (addr in hookedFunctions) {
    161. 
  
  
  
  
  161.     return
    162. 
  
  
  
  
  162.   }
    163. 
  
  
  
  
  163.   hookedFunctions[addr] = 1
    164. 
  
  
  
  
  164. 
  
  
  
  
  165.   addressToFunctions[addr] = symbolName
    166. 
  
  
  
  
  166.   log('Interceptor.attach: ' + symbolName + '@' + addr);
    167. 
  
  
  
  
  167.   Interceptor.attach(addr, callback)
    168. 
  
  
  
  
  168. }
    169. 
  
  
  
  
  169. 
  
  
  
  
  170. function hookPointers(address, count) {
    171. 
  
  
  
  
  171.   if (address.isNull())
    172. 
  
  
  
  
  172.     return
    173. 
  
  
  
  
  173. 
  
  
  
  
  174.   var currentAddress = address
    175. 
  
  
  
  
  175.   for (var i = 0; i < count; i++) {
    176. 
  
  
  
  
  176.     var readAddress = ptr(currentAddress).readPointer();
    177. 
  
  
  
  
  177.     readAddress = ptr(readAddress)
    178. 
  
  
  
  
  178.     var symbolInformation = DebugSymbol.fromAddress(readAddress)
    179. 
  
  
  
  
  179. 
  
  
  
  
  180.     var name = readAddress
    181. 
  
  
  
  
  181.     if (symbolInformation && symbolInformation.name) {
    182. 
  
  
  
  
  182.       name = symbolInformation.name
    183. 
  
  
  
  
  183.     }
    184. 
  
  
  
  
  184. 
  
  
  
  
  185.     log('Hooking ' + readAddress + ": " + name)
    186. 
  
  
  
  
  186. 
  
  
  
  
  187.     try {
    188. 
  
  
  
  
  188.       Interceptor.attach(readAddress, {
    189. 
  
  
  
  
  189.         onEnter: function (args) {
    190. 
  
  
  
  
  190.           log('[+] ' + name)
    191. 
  
  
  
  
  191.         }
    192. 
  
  
  
  
  192.       })
    193. 
  
  
  
  
  193.     } catch (err) {}
    194. 
  
  
  
  
  194.     currentAddress = currentAddress.add(4)
    195. 
  
  
  
  
  195.   }
    196. 
  
  
  
  
  196. }
    197. 
  
  
  
  
  197. 
  
  
  
  
  198. function hookFunctionNames(moduleName, funcNames) {
    199. 
  
  
  
  
  199.   for (var i = 0; i < funcNames.length; i++) {
    200. 
  
  
  
  
  200.     var funcName = funcNames[i]
    201. 
  
  
  
  
  201. 
  
  
  
  
  202.     try {
    203. 
  
  
  
  
  203.       hookFunction(moduleName, funcName, {
    204. 
  
  
  
  
  204.         onEnter: function (args) {
    205. 
  
  
  
  
  205.           var name = ''
    206. 
  
  
  
  
  206.           if (this.context.pc in addressToFunctions) {
    207. 
  
  
  
  
  207.             name = addressToFunctions[this.context.pc]
    208. 
  
  
  
  
  208.           }
    209. 
  
  
  
  
  209.           log("[+] " + name + " (" + this.context.pc + ")")
    210. 
  
  
  
  
  210.         }
    211. 
  
  
  
  
  211.       })
    212. 
  
  
  
  
  212.     } catch (err) {
    213. 
  
  
  
  
  213.       log("Failed to hook " + funcName)
    214. 
  
  
  
  
  214.     }
    215. 
  
  
  
  
  215.   }
    216. 
  
  
  
  
  216. }
    217. 
  
  
  
  
  217. 
  
  
  
  
  218. function BytesToCLSID(address) {
    219. 
  
  
  
  
  219.   if (address.isNull())
    220. 
  
  
  
  
  220.     return
    221. 
  
  
  
  
  221. 
  
  
  
  
  222.   var data = new Uint8Array(ptr(address).readByteArray(0x10))
    223. 
  
  
  
  
  223.   var clsid = "{" + getHexString(data[3]) + getHexString(data[2]) + getHexString(data[1]) + getHexString(data[0])
    224. 
  
  
  
  
  224.   clsid += '-' + getHexString(data[5]) + getHexString(data[4])
    225. 
  
  
  
  
  225.   clsid += '-' + getHexString(data[7]) + getHexString(data[6])
    226. 
  
  
  
  
  226.   clsid += '-' + getHexString(data[8]) + getHexString(data[9])
    227. 
  
  
  
  
  227.   clsid += '-' + getHexString(data[10]) + getHexString(data[11]) + getHexString(data[12]) + getHexString(data[13]) + getHexString(data[14]) + getHexString(data[15])
    228. 
  
  
  
  
  228.   clsid += '}'
    229. 
  
  
  
  
  229. 
  
  
  
  
  230.   return clsid
    231. 
  
  
  
  
  231. }
    232. 
  
  
  
  
  232. 
  
  
  
  
  233. function log(message) {
    234. 
  
  
  
  
  234.   console.log(message)
    235. 
  
  
  
  
  235. }
    236. 
  
  
  
  
  236. 
  
  
  
  
  237. function dumpAddress(address) {
    238. 
  
  
  
  
  238.   log('[+] address: ' + address);
    239. 
  
  
  
  
  239. 
  
  
  
  
  240.   if (address.isNull())
    241. 
  
  
  
  
  241.     return
    242. 
  
  
  
  
  242.   var data = ptr(address).readByteArray(50);
    243. 
  
  
  
  
  243.   log(hexdump(data, {
    244. 
  
  
  
  
  244.     offset: 0,
    245. 
  
  
  
  
  245.     length: 50,
    246. 
  
  
  
  
  246.     header: true,
    247. 
  
  
  
  
  247.     ansi: false
    248. 
  
  
  
  
  248.   }));
    249. 
  
  
  
  
  249. }
    250. 
  
  
  
  
  250. 
  
  
  
  
  251. function dumpBytes(address, length) {
    252. 
  
  
  
  
  252.   if (address.isNull())
    253. 
  
  
  
  
  253.     return
    254. 
  
  
  
  
  254.   var data = ptr(address).readByteArray(length);
    255. 
  
  
  
  
  255.   log(hexdump(data, {
    256. 
  
  
  
  
  256.     offset: 0,
    257. 
  
  
  
  
  257.     length: length,
    258. 
  
  
  
  
  258.     header: true,
    259. 
  
  
  
  
  259.     ansi: false
    260. 
  
  
  
  
  260.   }));
    261. 
  
  
  
  
  261. }
    262. 
  
  
  
  
  262. 
  
  
  
  
  263. function dumpSymbols(address, count) {
    264. 
  
  
  
  
  264.   if (address.isNull())
    265. 
  
  
  
  
  265.     return
    266. 
  
  
  
  
  266. 
  
  
  
  
  267.   var currentAddress = address
    268. 
  
  
  
  
  268.   for (var i = 0; i < count; i++) {
    269. 
  
  
  
  
  269.     var readAddress = ptr(currentAddress).readPointer();
    270. 
  
  
  
  
  270.     readAddress = ptr(readAddress)
    271. 
  
  
  
  
  271.     var symbolInformation = DebugSymbol.fromAddress(readAddress)
    272. 
  
  
  
  
  272. 
  
  
  
  
  273.     if (symbolInformation && symbolInformation.name) {
    274. 
  
  
  
  
  274.       log(currentAddress + ":\t" + readAddress + " " + symbolInformation.name)
    275. 
  
  
  
  
  275.     } else {
    276. 
  
  
  
  
  276.       log(currentAddress + ":\t" + readAddress)
    277. 
  
  
  
  
  277.     }
    278. 
  
  
  
  
  278.     currentAddress = currentAddress.add(4)
    279. 
  
  
  
  
  279.   }
    280. 
  
  
  
  
  280. }
    281. 
  
  
  
  
  281. 
  
  
  
  
  282. function dumpBSTR(address) {
    283. 
  
  
  
  
  283.   log('[+] address: ' + address);
    284. 
  
  
  
  
  284. 
  
  
  
  
  285.   if (address.isNull())
    286. 
  
  
  
  
  286.     return
    287. 
  
  
  
  
  287. 
  
  
  
  
  288.   var length = ptr(address - 4).readULong(4);
    289. 
  
  
  
  
  289.   log("length: " + length)
    290. 
  
  
  
  
  290.   var data = ptr(address).readByteArray(length);
    291. 
  
  
  
  
  291.   log(hexdump(data, {
    292. 
  
  
  
  
  292.     offset: 0,
    293. 
  
  
  
  
  293.     length: length,
    294. 
  
  
  
  
  294.     header: true,
    295. 
  
  
  
  
  295.     ansi: false
    296. 
  
  
  
  
  296.   }));
    297. 
  
  
  
  
  297. }
    298. 
  
  
  
  
  298. 
  
  
  
  
  299. function getString(address) {
    300. 
  
  
  
  
  300.   if (address.isNull())
    301. 
  
  
  
  
  301.     return
    302. 
  
  
  
  
  302. 
  
  
  
  
  303.   var dataString = ''
    304. 
  
  
  
  
  304. 
  
  
  
  
  305.   var offset = 0
    306. 
  
  
  
  
  306.   var stringEnded = false
    307. 
  
  
  
  
  307.   while (!stringEnded) {
    308. 
  
  
  
  
  308.     var data = new Uint8Array(ptr(address.add(offset)).readByteArray(10));
    309. 
  
  
  
  
  309. 
  
  
  
  
  310.     if (data.length <= 0) {
    311. 
  
  
  
  
  311.       break
    312. 
  
  
  
  
  312.     }
    313. 
  
  
  
  
  313. 
  
  
  
  
  314.     var i;
    315. 
  
  
  
  
  315.     for (i = 0; i < data.length; i++) {
    316. 
  
  
  
  
  316.       if (data[i] == 0x0) {
    317. 
  
  
  
  
  317.         stringEnded = true
    318. 
  
  
  
  
  318.         break
    319. 
  
  
  
  
  319.       }
    320. 
  
  
  
  
  320.       dataString += String.fromCharCode(data[i])
    321. 
  
  
  
  
  321.     }
    322. 
  
  
  
  
  322.     offset += data.length
    323. 
  
  
  
  
  323.   }
    324. 
  
  
  
  
  324. 
  
  
  
  
  325.   log("dataString: " + dataString)
    326. 
  
  
  
  
  326.   return dataString;
    327. 
  
  
  
  
  327. }
    328. 
  
  
  
  
  328. 
  
  
  
  
  329. function dumpWSTR(address) {
    330. 
  
  
  
  
  330.   if (address.isNull())
    331. 
  
  
  
  
  331.     return
    332. 
  
  
  
  
  332. 
  
  
  
  
  333.   var dataString = ''
    334. 
  
  
  
  
  334. 
  
  
  
  
  335.   var offset = 0
    336. 
  
  
  
  
  336.   var stringEnded = false
    337. 
  
  
  
  
  337.   while (!stringEnded) {
    338. 
  
  
  
  
  338.     var data = new Uint8Array(ptr(address.add(offset)).readByteArray(20));
    339. 
  
  
  
  
  339. 
  
  
  
  
  340.     if (data.length <= 0) {
    341. 
  
  
  
  
  341.       break
    342. 
  
  
  
  
  342.     }
    343. 
  
  
  
  
  343. 
  
  
  
  
  344.     var i;
    345. 
  
  
  
  
  345.     for (i = 0; i < data.length; i += 2) {
    346. 
  
  
  
  
  346.       if (data[i] == 0x0 && data[i + 1] == 0x0) {
    347. 
  
  
  
  
  347.         stringEnded = true
    348. 
  
  
  
  
  348.         break
    349. 
  
  
  
  
  349.       }
    350. 
  
  
  
  
  350.       dataString += String.fromCharCode(data[i])
    351. 
  
  
  
  
  351.     }
    352. 
  
  
  
  
  352.     offset += data.length
    353. 
  
  
  
  
  353.   }
    354. 
  
  
  
  
  354. 
  
  
  
  
  355.   log("dataString: " + dataString)
    356. 
  
  
  
  
  356.   return dataString;
    357. 
  
  
  
  
  357. }
    358. 
  
  
  
  
  358. 
  
  
  
  
  359. function hookRtcShell(moduleName) {
    360. 
  
  
  
  
  360.   hookFunction(moduleName, "rtcShell", {
    361. 
  
  
  
  
  361.     onEnter: function (args) {
    362. 
  
  
  
  
  362.       log("[+] rtcShell")
    363. 
  
  
  
  
  363.       var variantArg = ptr(args[0])
    364. 
  
  
  
  
  364.       dumpAddress(variantArg);
    365. 
  
  
  
  
  365.       var bstrPtr = ptr(variantArg.add(8).readULong())
    366. 
  
  
  
  
  366.       dumpBSTR(bstrPtr);
    367. 
  
  
  
  
  367.     }
    368. 
  
  
  
  
  368.   })
    369. 
  
  
  
  
  369. }
    370. 
  
  
  
  
  370. 
  
  
  
  
  371. function hookVBAStrCat(moduleName) {
    372. 
  
  
  
  
  372.   hookFunction(moduleName, "__vbaStrCat", {
    373. 
  
  
  
  
  373.     onEnter: function (args) {
    374. 
  
  
  
  
  374.       log("[+] __vbaStrCat")
    375. 
  
  
  
  
  375.       // log('[+] ' + name);
    376. 
  
  
  
  
  376.       // dumpBSTR(args[0]);
    377. 
  
  
  
  
  377.       // dumpBSTR(args[1]);
    378. 
  
  
  
  
  378.     },
    379. 
  
  
  
  
  379.     onLeave: function (retval) {
    380. 
  
  
  
  
  380.       dumpBSTR(retval);
    381. 
  
  
  
  
  381.     }
    382. 
  
  
  
  
  382.   })
    383. 
  
  
  
  
  383. }
    384. 
  
  
  
  
  384. 
  
  
  
  
  385. function hookVBAStrComp(moduleName) {
    386. 
  
  
  
  
  386.   hookFunction(moduleName, "__vbaStrComp", {
    387. 
  
  
  
  
  387.     onEnter: function (args) {
    388. 
  
  
  
  
  388.       log('[+] __vbaStrComp');
    389. 
  
  
  
  
  389.       log(ptr(args[1]).readUtf16String())
    390. 
  
  
  
  
  390.       log(ptr(args[2]).readUtf16String())
    391. 
  
  
  
  
  391.     }
    392. 
  
  
  
  
  392.   })
    393. 
  
  
  
  
  393. }
    394. 
  
  
  
  
  394. 
  
  
  
  
  395. function hookRtcCreateObject(moduleName) {
    396. 
  
  
  
  
  396.   hookFunction(moduleName, "rtcCreateObject", {
    397. 
  
  
  
  
  397.     onEnter: function (args) {
    398. 
  
  
  
  
  398.       log('[+] rtcCreateObject');
    399. 
  
  
  
  
  399.       dumpAddress(args[0]);
    400. 
  
  
  
  
  400.       dumpBSTR(args[0]);
    401. 
  
  
  
  
  401.       log(ptr(args[0]).readUtf16String())
    402. 
  
  
  
  
  402.     },
    403. 
  
  
  
  
  403.     onLeave: function (retval) {
    404. 
  
  
  
  
  404.       dumpAddress(retval);
    405. 
  
  
  
  
  405.     }
    406. 
  
  
  
  
  406.   })
    407. 
  
  
  
  
  407. }
    408. 
  
  
  
  
  408. 
  
  
  
  
  409. function hookRtcCreateObject2(moduleName) {
    410. 
  
  
  
  
  410.   hookFunction(moduleName, "rtcCreateObject2", {
    411. 
  
  
  
  
  411.     onEnter: function (args) {
    412. 
  
  
  
  
  412.       log('[+] rtcCreateObject2');
    413. 
  
  
  
  
  413.       dumpAddress(args[0]);
    414. 
  
  
  
  
  414.       dumpBSTR(args[1]);
    415. 
  
  
  
  
  415.       log(ptr(args[2]).readUtf16String())
    416. 
  
  
  
  
  416.     },
    417. 
  
  
  
  
  417.     onLeave: function (retval) {
    418. 
  
  
  
  
  418.       dumpAddress(retval);
    419. 
  
  
  
  
  419.     }
    420. 
  
  
  
  
  420.   })
    421. 
  
  
  
  
  421. }
    422. 
  
  
  
  
  422. 
  
  
  
  
  423. //  int __stdcall CVbeProcs::CallMacro(CVbeProcs *this, const wchar_t *)
    424. 
  
  
  
  
  424. function hookCVbeProcsCallMacro(moduleName) {
    425. 
  
  
  
  
  425.   hookFunction(moduleName, "CVbeProcs::CallMacro", {
    426. 
  
  
  
  
  426.     onEnter: function (args) {
    427. 
  
  
  
  
  427.       log('[+] CVbeProcs::CallMacro');
    428. 
  
  
  
  
  428.       dumpAddress(args[0]);
    429. 
  
  
  
  
  429.       dumpWSTR(args[1]);
    430. 
  
  
  
  
  430.     },
    431. 
  
  
  
  
  431.     onLeave: function (retval) {
    432. 
  
  
  
  
  432.       dumpAddress(retval);
    433. 
  
  
  
  
  433.     }
    434. 
  
  
  
  
  434.   })
    435. 
  
  
  
  
  435. }
    436. 
  
  
  
  
  436. 
  
  
  
  
  437. function hookDispCall(moduleName) {
    438. 
  
  
  
  
  438.   hookFunction(moduleName, "DispCallFunc", {
    439. 
  
  
  
  
  439.     onEnter: function (args) {
    440. 
  
  
  
  
  440.       log("[+] DispCallFunc")
    441. 
  
  
  
  
  441.       var pvInstance = args[0]
    442. 
  
  
  
  
  442.       var oVft = args[1]
    443. 
  
  
  
  
  443.       var instance = ptr(ptr(pvInstance).readULong());
    444. 
  
  
  
  
  444. 
  
  
  
  
  445.       log(' instance:' + instance);
    446. 
  
  
  
  
  446.       log(' oVft:' + oVft);
    447. 
  
  
  
  
  447.       var vftbPtr = instance.add(oVft)
    448. 
  
  
  
  
  448.       log(' vftbPtr:' + vftbPtr);
    449. 
  
  
  
  
  449.       var functionAddress = ptr(ptr(vftbPtr).readULong())
    450. 
  
  
  
  
  450. 
  
  
  
  
  451.       loadModuleForAddress(functionAddress)
    452. 
  
  
  
  
  452.       var functionName = DebugSymbol.fromAddress(functionAddress)
    453. 
  
  
  
  
  453. 
  
  
  
  
  454.       if (functionName) {
    455. 
  
  
  
  
  455.         log(' functionName:' + functionName);
    456. 
  
  
  
  
  456.       }
    457. 
  
  
  
  
  457. 
  
  
  
  
  458.       dumpAddress(functionAddress);
    459. 
  
  
  
  
  459. 
  
  
  
  
  460.       var currentAddress = functionAddress
    461. 
  
  
  
  
  461.       for (var i = 0; i < 10; i++) {
    462. 
  
  
  
  
  462.         try {
    463. 
  
  
  
  
  463.           var instruction = Instruction.parse(currentAddress)
    464. 
  
  
  
  
  464.           log(instruction.address + ': ' + instruction.mnemonic + ' ' + instruction.opStr)
    465. 
  
  
  
  
  465.           currentAddress = instruction.next
    466. 
  
  
  
  
  466.         } catch (err) {
    467. 
  
  
  
  
  467.           break
    468. 
  
  
  
  
  468.         }
    469. 
  
  
  
  
  469.       }
    470. 
  
  
  
  
  470.     }
    471. 
  
  
  
  
  471.   })
    472. 
  
  
  
  
  472. }
    473. 
  
  
  
  
  473. 
  
  
  
  
  474. hookRtcShell('vbe7')
    475. 
  
  
  
  
  475. hookVBAStrCat('vbe7')
    476. 
  
  
  
  
  476. hookVBAStrComp('vbe7')
    477. 
  
  
  
  
  477. hookRtcCreateObject('vbe7')
    478. 
  
  
  
  
  478. hookRtcCreateObject2('vbe7')
    479. 
  
  
  
  
  479. hookCVbeProcsCallMacro('vbe7')
    480. 
  
  
  
  
  480. hookDispCall('oleaut32')
    481.

设置符号路径

在Windows环境下设置符号服务器有多种方法，建议你从命令行设置_NT_SYMBOL_PATH变量。Windows调试器的符号路径对变量的用法有很好的描述。

https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/symbol-path
以下将使用“ c：\ symbols”作为其本地符号存储来缓存正式的Microsoft符号服务器。

setx _NT_SYMBOL_PATH SRV*c:\symbols*https://msdl.microsoft.com/download/symbols
以下命令将使系统使用默认的符号存储目录。

setx _NT_SYMBOL_PATH SRV*https://msdl.microsoft.com/download/symbols
运行恶意软件并观察行为

我们使用以下示例测试Frida的符号查找功能。恶意样本做了一些混淆，可以使用Frida hook轻松分析。

我们在此处提供的代码可从以下GitHub存储库中找到。

 
 
 
 
    
  
  
  
  
  1. https://github.com/ohjeongwook/Frida.examples.vbe
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. var loadedModules = {}
    4. 
  
  
  
  
  4. var resolvedAddresses = {}
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. function resolveName(dllName, name) {
    7. 
  
  
  
  
  7.   var moduleName = dllName.split('.')[0]
    8. 
  
  
  
  
  8.   var functionName = moduleName + "!" + name
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.   if (functionName in resolvedAddresses) {
    11. 
  
  
  
  
  11.     return resolvedAddresses[functionName]
    12. 
  
  
  
  
  12.   }
    13. 
  
  
  
  
  13. 
  
  
  
  
  14.   log("resolveName " + functionName);
    15. 
  
  
  
  
  15.   log("Module.findExportByName " + dllName + " " + name);
    16. 
  
  
  
  
  16.   var addr = Module.findExportByName(dllName, name)
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.   if (!addr || addr.isNull()) {
    19. 
  
  
  
  
  19.     if (!(dllName in loadedModules)) {
    20. 
  
  
  
  
  20.       log(" DebugSymbol.loadModule " + dllName);
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.       try {
    23. 
  
  
  
  
  23.         DebugSymbol.load(dllName)
    24. 
  
  
  
  
  24.       } catch (err) {
    25. 
  
  
  
  
  25.         return 0;
    26. 
  
  
  
  
  26.       }
    27. 
  
  
  
  
  27. 
  
  
  
  
  28.       log(" DebugSymbol.load finished");
    29. 
  
  
  
  
  29.       loadedModules[dllName] = 1
    30. 
  
  
  
  
  30.     }
    31. 
  
  
  
  
  31. 
  
  
  
  
  32.     try {
    33. 
  
  
  
  
  33.       log(" DebugSymbol.getFunctionByName: " + functionName);
    34. 
  
  
  
  
  34.       addr = DebugSymbol.getFunctionByName(moduleName + '!' + name)
    35. 
  
  
  
  
  35.       log(" DebugSymbol.getFunctionByName: addr = " + addr);
    36. 
  
  
  
  
  36.     } catch (err) {
    37. 
  
  
  
  
  37.       log(" DebugSymbol.getFunctionByName: Exception")
    38. 
  
  
  
  
  38.     }
    39. 
  
  
  
  
  39.   }
    40. 
  
  
  
  
  40. 
  
  
  
  
  41.   resolvedAddresses[functionName] = addr
    42. 
  
  
  
  
  42.   return addr
    43. 
  
  
  
  
  43. }
    44.

因此，当你启动Word进程且进程ID为3064时，可以使用以下命令从存储库中包含的vbe.js安装hook。安装hook之后，你可以打开恶意文档以观察其行为

 
 
 
 
    
  
  
  
  
  1. > python inject.py -p 3064 vbe.js
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. resolveName vbe7!rtcShell
    4. 
  
  
  
  
  4. Module.findExportByName vbe7 rtcShell
    5. 
  
  
  
  
  5. Interceptor.attach: vbe7!rtcShell@0x652a2b76
    6. 
  
  
  
  
  6. resolveName vbe7!__vbaStrCat
    7. 
  
  
  
  
  7. Module.findExportByName vbe7 __vbaStrCat
    8. 
  
  
  
  
  8.  DebugSymbol.loadModule vbe7
    9. 
  
  
  
  
  9.  DebugSymbol.load finished
    10. 
  
  
  
  
  10.  DebugSymbol.getFunctionByName: vbe7!__vbaStrCat
    11. 
  
  
  
  
  11.  DebugSymbol.getFunctionByName: addr = 0x651e53e6
    12. 
  
  
  
  
  12. Interceptor.attach: vbe7!__vbaStrCat@0x651e53e6
    13. 
  
  
  
  
  13. resolveName vbe7!__vbaStrComp
    14. 
  
  
  
  
  14. Module.findExportByName vbe7 __vbaStrComp
    15. 
  
  
  
  
  15.  DebugSymbol.getFunctionByName: vbe7!__vbaStrComp
    16. 
  
  
  
  
  16.  DebugSymbol.getFunctionByName: addr = 0x651e56a2
    17. 
  
  
  
  
  17. Interceptor.attach: vbe7!__vbaStrComp@0x651e56a2
    18. 
  
  
  
  
  18. resolveName vbe7!rtcCreateObject
    19. 
  
  
  
  
  19. Module.findExportByName vbe7 rtcCreateObject
    20. 
  
  
  
  
  20. Interceptor.attach: vbe7!rtcCreateObject@0x653e6e4c
    21. 
  
  
  
  
  21. resolveName vbe7!rtcCreateObject2
    22. 
  
  
  
  
  22. Module.findExportByName vbe7 rtcCreateObject2
    23. 
  
  
  
  
  23. Interceptor.attach: vbe7!rtcCreateObject2@0x653e6ece
    24. 
  
  
  
  
  24. resolveName vbe7!CVbeProcs::CallMacro
    25. 
  
  
  
  
  25. Module.findExportByName vbe7 CVbeProcs::CallMacro
    26. 
  
  
  
  
  26.  DebugSymbol.getFunctionByName: vbe7!CVbeProcs::CallMacro
    27. 
  
  
  
  
  27.  DebugSymbol.getFunctionByName: addr = 0x6529019b
    28. 
  
  
  
  
  28. Interceptor.attach: vbe7!CVbeProcs::CallMacro@0x6529019b
    29. 
  
  
  
  
  29. resolveName oleaut32!DispCallFunc
    30. 
  
  
  
  
  30. Module.findExportByName oleaut32 DispCallFunc
    31. 
  
  
  
  
  31. Interceptor.attach: oleaut32!DispCallFunc@0x747995b0
    32. 
  
  
  
  
  32. [!] Ctrl+D on UNIX, Ctrl+Z on Windows/cmd.exe to detach from instrumented program.
    33.

hook监控office的宏行为

vbe.js很少有hook来监视恶意Office文档的行为。

__vbaStrCat

vbe7.dll是已找到Visual Basic运行时引擎的DLL，里面有很多有趣的函数。但是首先，我们想观察字符串去混淆操作

vbe7！__ vbaStrCat是在Visual Basic中串联字符串时调用的函数。

.text:651E53E6 ; __stdcall __vbaStrCat(x, x)
.text:651E53E6 ___vbaStrCat@8 proc near ; CODE XREF: _lblEX_ConcatStr↑p
许多基于宏的恶意软件文档都使用基于字符串的混淆。通过观察字符串的动作，你可以观察最终的去混淆字符串的构造。

以下hook代码将为每个调用打印出连接的字符串。

 
 
 
 
    
  
  
  
  
  1. https://github.com/ohjeongwook/Frida.examples.vbe/blob/master/vbe.js
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. 
  
  
  
  
  4. var loadedModules = {}
    5. 
  
  
  
  
  5. var resolvedAddresses = {}
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. function resolveName(dllName, name) {
    8. 
  
  
  
  
  8.   var moduleName = dllName.split('.')[0]
    9. 
  
  
  
  
  9.   var functionName = moduleName + "!" + name
    10. 
  
  
  
  
  10. 
  
  
  
  
  11.   if (functionName in resolvedAddresses) {
    12. 
  
  
  
  
  12.     return resolvedAddresses[functionName]
    13. 
  
  
  
  
  13.   }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.   log("resolveName " + functionName);
    16. 
  
  
  
  
  16.   log("Module.findExportByName " + dllName + " " + name);
    17. 
  
  
  
  
  17.   var addr = Module.findExportByName(dllName, name)
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.   if (!addr || addr.isNull()) {
    20. 
  
  
  
  
  20.     if (!(dllName in loadedModules)) {
    21. 
  
  
  
  
  21.       log(" DebugSymbol.loadModule " + dllName);
    22. 
  
  
  
  
  22. 
  
  
  
  
  23.       try {
    24. 
  
  
  
  
  24.         DebugSymbol.load(dllName)
    25. 
  
  
  
  
  25.       } catch (err) {
    26. 
  
  
  
  
  26.         return 0;
    27. 
  
  
  
  
  27.       }
    28. 
  
  
  
  
  28. 
  
  
  
  
  29.       log(" DebugSymbol.load finished");
    30. 
  
  
  
  
  30.       loadedModules[dllName] = 1
    31. 
  
  
  
  
  31.     }
    32. 
  
  
  
  
  32. 
  
  
  
  
  33.     try {
    34. 
  
  
  
  
  34.       log(" DebugSymbol.getFunctionByName: " + functionName);
    35. 
  
  
  
  
  35.       addr = DebugSymbol.getFunctionByName(moduleName + '!' + name)
    36. 
  
  
  
  
  36.       log(" DebugSymbol.getFunctionByName: addr = " + addr);
    37. 
  
  
  
  
  37.     } catch (err) {
    38. 
  
  
  
  
  38.       log(" DebugSymbol.getFunctionByName: Exception")
    39. 
  
  
  
  
  39.     }
    40. 
  
  
  
  
  40.   }
    41. 
  
  
  
  
  41. 
  
  
  
  
  42.   resolvedAddresses[functionName] = addr
    43. 
  
  
  
  
  43.   return addr
    44. 
  
  
  
  
  44. }
    45. 
  
  
  
  
  45. 
  
  
  
  
  46. function loadModuleForAddress(address) {
    47. 
  
  
  
  
  47.   var modules = Process.enumerateModules()
    48. 
  
  
  
  
  48. 
  
  
  
  
  49.   var i
    50. 
  
  
             
    
                名称栏目：使用Frida对Windows平台的程序进行逆向分析
                
    
                URL分享：http://www.hantingmc.com/qtweb/news49/273549.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

网站制作知识

行业网站建设

成都做网站　　 　四川平武网站建设　　 　达州网站建设　　 　四川雅安服务器托管　　 　成都服务器托管　　 　西云服务器托管　　 　成都木托盘　　 　江油网站建设　　 　子晨木包装箱　　 　成都移动服务器托管　　 　seo优化　　 　成都托管服务器　　 　达州主机托管　　 　网站报价方案　　 　成都响应式网站建设　　 　h5响应式网站　　 　重庆托管服务器　　 　seo优化　　 　乐山服务器托管　　 　成都口碑营销公司