Windows-II 中的重要工件

---

---

本章讨论了 Windows 中一些更重要的工件及其使用 Python 的提取方法。

用户活动

Windows 使用NTUSER.DAT文件存储各种用户活动。每个用户配置文件都具有类似NTUSER.DAT的 hive，其中存储与该用户特有的信息和配置。因此，对于取证分析师的调查非常有用。

以下 Python 脚本将解析NTUSER.DAT 的一些键，以探索用户在系统上的操作。在继续进行 Python 脚本之前，我们需要安装第三方模块，即Registry、pytsk3、pyewf 和Jinja2。我们可以使用 pip 来安装它们。

我们可以按照以下步骤从NTUSER.DAT文件中提取信息：

• 首先，搜索系统中所有NTUSER.DAT文件。

• 然后，为每个NTUSER.DAT文件解析WordWheelQuery、TypePath 和 RunMRU键。

• 最后，我们将使用Jinja2模块将这些已处理的工件写入 HTML 报告。

Python 代码

让我们看看如何为此目的使用 Python 代码：

首先，我们需要导入以下 Python 模块：

from __future__ import print_function
from argparse import ArgumentParser

import os
import StringIO
import struct

from utility.pytskutil import TSKUtil
from Registry import Registry
import jinja2

现在，为命令行处理器提供参数。这里它将接受三个参数 - 第一个是证据文件的路径，第二个是证据文件的类型，第三个是 HTML 报告的所需输出路径，如下所示：

if __name__ == '__main__':
   parser = argparse.ArgumentParser('Information from user activities')
   parser.add_argument('EVIDENCE_FILE',help = "Path to evidence file")
   parser.add_argument('IMAGE_TYPE',help = "Evidence file format",choices = ('ewf', 'raw'))
   parser.add_argument('REPORT',help = "Path to report file")
   args = parser.parse_args()
   main(args.EVIDENCE_FILE, args.IMAGE_TYPE, args.REPORT)

现在，让我们定义main()函数来搜索所有NTUSER.DAT文件，如下所示：

def main(evidence, image_type, report):
   tsk_util = TSKUtil(evidence, image_type)
   tsk_ntuser_hives = tsk_util.recurse_files('ntuser.dat','/Users', 'equals')
   
   nt_rec = {
      'wordwheel': {'data': [], 'title': 'WordWheel Query'},
      'typed_path': {'data': [], 'title': 'Typed Paths'},
      'run_mru': {'data': [], 'title': 'Run MRU'}
   }

现在，我们将尝试在NTUSER.DAT文件中查找键，一旦找到，就定义用户处理函数，如下所示：

for ntuser in tsk_ntuser_hives:
   uname = ntuser[1].split("/")

open_ntuser = open_file_as_reg(ntuser[2])
try:
   explorer_key = open_ntuser.root().find_key("Software").find_key("Microsoft")
      .find_key("Windows").find_key("CurrentVersion").find_key("Explorer")
   except Registry.RegistryKeyNotFoundException:
      continue
   nt_rec['wordwheel']['data'] += parse_wordwheel(explorer_key, uname)
   nt_rec['typed_path']['data'] += parse_typed_paths(explorer_key, uname)
   nt_rec['run_mru']['data'] += parse_run_mru(explorer_key, uname)
   nt_rec['wordwheel']['headers'] = \ nt_rec['wordwheel']['data'][0].keys()
   nt_rec['typed_path']['headers'] = \ nt_rec['typed_path']['data'][0].keys()
   nt_rec['run_mru']['headers'] = \ nt_rec['run_mru']['data'][0].keys()

现在，将字典对象及其路径传递给write_html()方法，如下所示：

write_html(report, nt_rec)

现在，定义一个方法，该方法采用pytsk文件句柄并通过StringIO类将其读入 Registry 类。

def open_file_as_reg(reg_file):
   file_size = reg_file.info.meta.size
   file_content = reg_file.read_random(0, file_size)
   file_like_obj = StringIO.StringIO(file_content)
   return Registry.Registry(file_like_obj)

现在，我们将定义一个函数，该函数将解析和处理NTUSER.DAT文件中的WordWheelQuery键，如下所示：

def parse_wordwheel(explorer_key, username):
   try:
      wwq = explorer_key.find_key("WordWheelQuery")
   except Registry.RegistryKeyNotFoundException:
      return []
   mru_list = wwq.value("MRUListEx").value()
   mru_order = []
   
   for i in xrange(0, len(mru_list), 2):
      order_val = struct.unpack('h', mru_list[i:i + 2])[0]
   if order_val in mru_order and order_val in (0, -1):
      break
   else:
      mru_order.append(order_val)
   search_list = []
   
   for count, val in enumerate(mru_order):
      ts = "N/A"
      if count == 0:
         ts = wwq.timestamp()
      search_list.append({
         'timestamp': ts,
         'username': username,
         'order': count,
         'value_name': str(val),
         'search': wwq.value(str(val)).value().decode("UTF-16").strip("\x00")
})
   return search_list  

现在，我们将定义一个函数，该函数将解析和处理NTUSER.DAT文件中的TypedPaths键，如下所示：

def parse_typed_paths(explorer_key, username):
   try:
      typed_paths = explorer_key.find_key("TypedPaths")
   except Registry.RegistryKeyNotFoundException:
      return []
   typed_path_details = []
   
   for val in typed_paths.values():
      typed_path_details.append({
         "username": username,
         "value_name": val.name(),
         "path": val.value()
      })
   return typed_path_details

现在，我们将定义一个函数，该函数将解析和处理NTUSER.DAT文件中的RunMRU键，如下所示：

def parse_run_mru(explorer_key, username):
   try:
      run_mru = explorer_key.find_key("RunMRU")
   except Registry.RegistryKeyNotFoundException:
      return []
   
   if len(run_mru.values()) == 0:
      return []
   mru_list = run_mru.value("MRUList").value()
   mru_order = []
   
   for i in mru_list:
      mru_order.append(i)
   mru_details = []
   
   for count, val in enumerate(mru_order):
      ts = "N/A"
      if count == 0:
         ts = run_mru.timestamp()
      mru_details.append({
         "username": username,
         "timestamp": ts,
         "order": count,
         "value_name": val,
         "run_statement": run_mru.value(val).value()
      })
   return mru_details

现在，以下函数将处理 HTML 报告的创建：

def write_html(outfile, data_dict):
   cwd = os.path.dirname(os.path.abspath(__file__))
   env = jinja2.Environment(loader=jinja2.FileSystemLoader(cwd))
   template = env.get_template("user_activity.html")
   rendering = template.render(nt_data=data_dict)
   
   with open(outfile, 'w') as open_outfile:
      open_outfile.write(rendering)

最后，我们可以为报告编写 HTML 文档。运行上述脚本后，我们将获得 HTML 文档格式的 NTUSER.DAT 文件信息。

LINK 文件

当用户或操作系统为经常使用、双击或从系统驱动器（如附加存储）访问的文件创建快捷方式文件时，会创建快捷方式文件。此类快捷方式文件称为链接文件。通过访问这些链接文件，调查人员可以找到窗口的活动，例如访问这些文件的时间和位置。

让我们讨论一下我们可以用来从这些 Windows LINK 文件中获取信息的 Python 脚本。

对于 Python 脚本，请安装名为pylnk、pytsk3、pyewf的第三方模块。我们可以按照以下步骤从lnk文件中提取信息：

• 首先，搜索系统中的lnk文件。

• 然后，通过遍历它们来提取文件中的信息。

• 现在，最后我们需要将此信息写入 CSV 报告。

Python 代码

让我们看看如何为此目的使用 Python 代码：

首先，导入以下 Python 库：

from __future__ import print_function
from argparse import ArgumentParser

import csv
import StringIO

from utility.pytskutil import TSKUtil
import pylnk

现在，为命令行处理器提供参数。这里它将接受三个参数 - 第一个是证据文件的路径，第二个是证据文件的类型，第三个是 CSV 报告的所需输出路径，如下所示：

if __name__ == '__main__':
   parser = argparse.ArgumentParser('Parsing LNK files')
   parser.add_argument('EVIDENCE_FILE', help = "Path to evidence file")
   parser.add_argument('IMAGE_TYPE', help = "Evidence file format",choices = ('ewf', 'raw'))
   parser.add_argument('CSV_REPORT', help = "Path to CSV report")
   args = parser.parse_args()
   main(args.EVIDENCE_FILE, args.IMAGE_TYPE, args.CSV_REPORT)

现在，通过创建TSKUtil对象并遍历文件系统以查找以lnk结尾的文件来解释证据文件。这可以通过定义main()函数来完成，如下所示：

def main(evidence, image_type, report):
   tsk_util = TSKUtil(evidence, image_type)
   lnk_files = tsk_util.recurse_files("lnk", path="/", logic="endswith")
   
   if lnk_files is None:
      print("No lnk files found")
      exit(0)
   columns = [
      'command_line_arguments', 'description', 'drive_serial_number',
      'drive_type', 'file_access_time', 'file_attribute_flags',
      'file_creation_time', 'file_modification_time', 'file_size',
      'environmental_variables_location', 'volume_label',
      'machine_identifier', 'local_path', 'network_path',
      'relative_path', 'working_directory'
   ]

现在，借助以下代码，我们将通过创建如下所示的函数来遍历lnk文件：

parsed_lnks = []

for entry in lnk_files:
   lnk = open_file_as_lnk(entry[2])
   lnk_data = {'lnk_path': entry[1], 'lnk_name': entry[0]}
   
   for col in columns:
      lnk_data[col] = getattr(lnk, col, "N/A")
   lnk.close()
   parsed_lnks.append(lnk_data)
write_csv(report, columns + ['lnk_path', 'lnk_name'], parsed_lnks)

现在我们需要定义两个函数，一个将打开pytsk文件对象，另一个将用于写入 CSV 报告，如下所示：

def open_file_as_lnk(lnk_file):
   file_size = lnk_file.info.meta.size
   file_content = lnk_file.read_random(0, file_size)
   file_like_obj = StringIO.StringIO(file_content)
   lnk = pylnk.file()
   lnk.open_file_object(file_like_obj)
   return lnk
def write_csv(outfile, fieldnames, data):
   with open(outfile, 'wb') as open_outfile:
      csvfile = csv.DictWriter(open_outfile, fieldnames)
      csvfile.writeheader()
      csvfile.writerows(data)

运行上述脚本后，我们将获得已发现的lnk文件的 CSV 报告信息：

预取文件

每当从特定位置第一次运行应用程序时，Windows 都会创建预取文件。这些用于加快应用程序启动过程。这些文件的扩展名为.PF，并存储在“\Root\Windows\Prefetch”文件夹中。

数字取证专家可以揭示程序从特定位置执行的证据以及用户的详细信息。预取文件对于检查员来说是有用的工件，因为即使程序已被删除或卸载，它们的条目仍然存在。

让我们讨论一下将获取 Windows 预取文件信息的 Python 脚本，如下所示：

对于 Python 脚本，请安装名为pylnk、pytsk3和unicodecsv的第三方模块。回想一下，我们已经在前面章节中讨论过的 Python 脚本中使用过这些库。

我们必须按照以下步骤从prefetch文件中提取信息：

• 首先，扫描.pf扩展名文件或预取文件。

• 现在，执行签名验证以消除误报。

• 接下来，解析 Windows 预取文件格式。这与 Windows 版本不同。例如，对于 Windows XP，它是 17；对于 Windows Vista 和 Windows 7，它是 23；对于 Windows 8.1，它是 26；对于 Windows 10，它是 30。

• 最后，我们将解析的结果写入 CSV 文件。

Python 代码

让我们看看如何为此目的使用 Python 代码：

首先，导入以下 Python 库：

from __future__ import print_function
import argparse
from datetime import datetime, timedelta

import os
import pytsk3
import pyewf
import struct
import sys
import unicodecsv as csv
from utility.pytskutil import TSKUtil

现在，为命令行处理器提供参数。这里它将接受两个参数，第一个是证据文件的路径，第二个是证据文件的类型。它还接受一个可选参数，用于指定扫描预取文件的路径：

if __name__ == "__main__":
   parser = argparse.ArgumentParser('Parsing Prefetch files')
   parser.add_argument("EVIDENCE_FILE", help = "Evidence file path")
   parser.add_argument("TYPE", help = "Type of Evidence",choices = ("raw", "ewf"))
   parser.add_argument("OUTPUT_CSV", help = "Path to write output csv")
   parser.add_argument("-d", help = "Prefetch directory to scan",default = "/WINDOWS/PREFETCH")
   args = parser.parse_args()
   
   if os.path.exists(args.EVIDENCE_FILE) and \
      os.path.isfile(args.EVIDENCE_FILE):
   main(args.EVIDENCE_FILE, args.TYPE, args.OUTPUT_CSV, args.d)
else:
   print("[-] Supplied input file {} does not exist or is not a ""file".format(args.EVIDENCE_FILE))
   sys.exit(1)

现在，通过创建TSKUtil对象并遍历文件系统以查找以.pf结尾的文件来解释证据文件。这可以通过定义main()函数来完成，如下所示：

def main(evidence, image_type, output_csv, path):
   tsk_util = TSKUtil(evidence, image_type)
   prefetch_dir = tsk_util.query_directory(path)
   prefetch_files = None
   
   if prefetch_dir is not None:
      prefetch_files = tsk_util.recurse_files(".pf", path=path, logic="endswith")
   
   if prefetch_files is None:
      print("[-] No .pf files found")
      sys.exit(2)
   print("[+] Identified {} potential prefetch files".format(len(prefetch_files)))
   prefetch_data = []
   
   for hit in prefetch_files:
      prefetch_file = hit[2]
      pf_version = check_signature(prefetch_file)

现在，定义一个方法来执行签名的验证，如下所示：

def check_signature(prefetch_file):
   version, signature = struct.unpack("^<2i", prefetch_file.read_random(0, 8))
   
   if signature == 1094927187:
      return version
   else:
      return None
   
   if pf_version is None:
      continue
   pf_name = hit[0]
   
   if pf_version == 17:
      parsed_data = parse_pf_17(prefetch_file, pf_name)
      parsed_data.append(os.path.join(path, hit[1].lstrip("//")))
      prefetch_data.append(parsed_data)

现在，开始处理 Windows 预取文件。这里我们以 Windows XP 预取文件为例：

def parse_pf_17(prefetch_file, pf_name):
   create = convert_unix(prefetch_file.info.meta.crtime)
   modify = convert_unix(prefetch_file.info.meta.mtime)
def convert_unix(ts):
   if int(ts) == 0:
      return ""
   return datetime.utcfromtimestamp(ts)
def convert_filetime(ts):
   if int(ts) == 0:
      return ""
   return datetime(1601, 1, 1) + timedelta(microseconds=ts / 10)

现在，使用 struct 提取嵌入在预取文件中的数据，如下所示：

pf_size, name, vol_info, vol_entries, vol_size, filetime, \
   count = struct.unpack("<i60s32x3iq16xi",prefetch_file.read_random(12, 136))
name = name.decode("utf-16", "ignore").strip("/x00").split("/x00")[0]

vol_name_offset, vol_name_length, vol_create, \
   vol_serial = struct.unpack("<2iqi",prefetch_file.read_random(vol_info, 20))
   vol_serial = hex(vol_serial).lstrip("0x")
   vol_serial = vol_serial[:4] + "-" + vol_serial[4:]
   vol_name = struct.unpack(
      "<{}s".format(2 * vol_name_length),
      prefetch_file.read_random(vol_info + vol_name_offset,vol_name_length * 2))[0]

vol_name = vol_name.decode("utf-16", "ignore").strip("/x00").split("/x00")[0]
return [
   pf_name, name, pf_size, create,
   modify, convert_filetime(filetime), count, vol_name,
   convert_filetime(vol_create), vol_serial ]

我们提供了 Windows XP 的预取版本，但如果遇到其他 Windows 的预取版本怎么办？那么它必须显示一条错误消息，如下所示：

elif pf_version == 23:
   print("[-] Windows Vista / 7 PF file {} -- unsupported".format(pf_name))
   continue
elif pf_version == 26:
   print("[-] Windows 8 PF file {} -- unsupported".format(pf_name))
   continue
elif pf_version == 30:
   print("[-] Windows 10 PF file {} -- unsupported".format(pf_name))
continue

else:
   print("[-] Signature mismatch - Name: {}\nPath: {}".format(hit[0], hit[1]))
continue
write_output(prefetch_data, output_csv)

现在，定义一个方法将结果写入 CSV 报告，如下所示：

def write_output(data, output_csv):
   print("[+] Writing csv report")
   with open(output_csv, "wb") as outfile:
      writer = csv.writer(outfile)
      writer.writerow([
         "File Name", "Prefetch Name", "File Size (bytes)",
         "File Create Date (UTC)", "File Modify Date (UTC)",
         "Prefetch Last Execution Date (UTC)",
         "Prefetch Execution Count", "Volume", "Volume Create Date",
         "Volume Serial", "File Path" ])
      writer.writerows(data)

运行上述脚本后，我们将获得 Windows XP 版本预取文件的电子表格信息。