Windows 中的重要工件 - I

上一页
下一页

本章将解释 Microsoft Windows 取证中涉及的各种概念以及调查人员可以从调查过程中获得的重要工件。

简介

工件是计算机系统中包含与计算机用户执行的活动相关的重要信息的物体或区域。此信息类型和位置取决于操作系统。在取证分析过程中，这些工件在批准或不批准调查人员的观察结果方面发挥着非常重要的作用。

Windows 工件对取证的重要性

由于以下原因，Windows 工件具有重要意义：

  • 全世界约 90% 的流量来自使用 Windows 作为操作系统的计算机。这就是为什么对于数字取证检查员来说，Windows 工件非常重要。

  • Windows 操作系统存储与计算机系统上用户活动相关的不同类型的证据。这是另一个表明 Windows 工件对数字取证的重要性。

  • 许多时候，调查人员会围绕用户创建的数据等旧的和传统的领域进行调查。Windows 工件可以将调查引向非传统领域，例如系统创建的数据或工件。

  • Windows 提供了大量工件，这对调查人员以及执行非正式调查的公司和个人都有帮助。

  • 近年来网络犯罪的增加是 Windows 工件很重要的另一个原因。

Windows 工件及其 Python 脚本

在本节中，我们将讨论一些 Windows 工件和 Python 脚本，以从中获取信息。

回收站

它是取证调查中重要的 Windows 工件之一。Windows 回收站包含用户已删除但系统尚未物理删除的文件。即使用户从系统中完全删除了文件，它也仍然是重要的调查来源。这是因为检查员可以从已删除的文件中提取有价值的信息，例如原始文件路径以及将其发送到回收站的时间。

请注意，回收站证据的存储取决于 Windows 的版本。在以下 Python 脚本中，我们将处理 Windows 7，它创建两个文件：包含已回收文件实际内容的$R文件和包含原始文件名、路径、文件大小以及文件删除时间的$I文件。

对于 Python 脚本，我们需要安装第三方模块，即pytsk3、pyewf和unicodecsv。我们可以使用pip来安装它们。我们可以按照以下步骤从回收站中提取信息：

  • 首先，我们需要使用递归方法扫描$Recycle.bin文件夹，并选择所有以$I开头的文件。

  • 接下来，我们将读取文件内容并解析可用的元数据结构。

  • 现在，我们将搜索关联的 $R 文件。

  • 最后，我们将结果写入 CSV 文件以供审查。

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

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

from __future__ import print_function
from argparse import ArgumentParser

import datetime
import os
import struct

from utility.pytskutil import TSKUtil
import unicodecsv as csv

接下来，我们需要为命令行处理程序提供参数。请注意，这里它将接受三个参数 - 第一个是证据文件路径，第二个是证据文件类型，第三个是所需的 CSV 报告输出路径，如下所示：

if __name__ == '__main__':
   parser = argparse.ArgumentParser('Recycle Bin evidences')
   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)

现在，定义main()函数，该函数将处理所有处理过程。它将如下搜索$I文件：

def main(evidence, image_type, report_file):
   tsk_util = TSKUtil(evidence, image_type)
   dollar_i_files = tsk_util.recurse_files("$I", path = '/$Recycle.bin',logic = "startswith")
   
   if dollar_i_files is not None:
      processed_files = process_dollar_i(tsk_util, dollar_i_files)
      write_csv(report_file,['file_path', 'file_size', 'deleted_time','dollar_i_file', 'dollar_r_file', 'is_directory'],processed_files)
   else:
      print("No $I files found")

现在，如果我们找到了$I文件，则必须将其发送到process_dollar_i()函数，该函数将接受tsk_util对象以及$I文件列表，如下所示：

def process_dollar_i(tsk_util, dollar_i_files):
   processed_files = []
   
   for dollar_i in dollar_i_files:
      file_attribs = read_dollar_i(dollar_i[2])
      if file_attribs is None:
         continue
      file_attribs['dollar_i_file'] = os.path.join('/$Recycle.bin', dollar_i[1][1:])

现在，搜索 $R 文件，如下所示：

recycle_file_path = os.path.join('/$Recycle.bin',dollar_i[1].rsplit("/", 1)[0][1:])
dollar_r_files = tsk_util.recurse_files(
   "$R" + dollar_i[0][2:],path = recycle_file_path, logic = "startswith")
   
   if dollar_r_files is None:
      dollar_r_dir = os.path.join(recycle_file_path,"$R" + dollar_i[0][2:])
      dollar_r_dirs = tsk_util.query_directory(dollar_r_dir)
   
   if dollar_r_dirs is None:
      file_attribs['dollar_r_file'] = "Not Found"
      file_attribs['is_directory'] = 'Unknown'
   
   else:
      file_attribs['dollar_r_file'] = dollar_r_dir
      file_attribs['is_directory'] = True
   
   else:
      dollar_r = [os.path.join(recycle_file_path, r[1][1:])for r in dollar_r_files]
      file_attribs['dollar_r_file'] = ";".join(dollar_r)
      file_attribs['is_directory'] = False
      processed_files.append(file_attribs)
   return processed_files

现在，定义read_dollar_i()方法来读取$I文件，换句话说，解析元数据。我们将使用read_random()方法读取签名的前八个字节。如果签名不匹配，这将返回 None。之后，如果这是一个有效的文件，我们将不得不从$I文件中读取和解包值。

def read_dollar_i(file_obj):
   if file_obj.read_random(0, 8) != '\x01\x00\x00\x00\x00\x00\x00\x00':
      return None
   raw_file_size = struct.unpack('<q', file_obj.read_random(8, 8))
   raw_deleted_time = struct.unpack('<q',   file_obj.read_random(16, 8))
   raw_file_path = file_obj.read_random(24, 520)

现在，在提取这些文件后，我们需要使用sizeof_fmt()函数将整数解释为人类可读的值，如下所示：

file_size = sizeof_fmt(raw_file_size[0])
deleted_time = parse_windows_filetime(raw_deleted_time[0])

file_path = raw_file_path.decode("utf16").strip("\x00")
return {'file_size': file_size, 'file_path': file_path,'deleted_time': deleted_time}

现在，我们需要定义sizeof_fmt()函数，如下所示：

def sizeof_fmt(num, suffix = 'B'):
   for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
      if abs(num) < 1024.0:
         return "%3.1f%s%s" % (num, unit, suffix)
      num /= 1024.0
   return "%.1f%s%s" % (num, 'Yi', suffix)

现在，定义一个函数将解释的整数转换为格式化的日期和时间，如下所示：

def parse_windows_filetime(date_value):
   microseconds = float(date_value) / 10
   ts = datetime.datetime(1601, 1, 1) + datetime.timedelta(
      microseconds = microseconds)
   return ts.strftime('%Y-%m-%d %H:%M:%S.%f')

现在，我们将定义write_csv()方法将处理后的结果写入 CSV 文件，如下所示：

def write_csv(outfile, fieldnames, data):
   with open(outfile, 'wb') as open_outfile:
      csvfile = csv.DictWriter(open_outfile, fieldnames)
      csvfile.writeheader()
      csvfile.writerows(data)

运行上述脚本后，我们将从 $I 和 $R 文件中获取数据。

便签

Windows 便签取代了用笔和纸书写的现实世界习惯。这些便签用于在桌面上浮动，并提供不同的颜色、字体等选项。在 Windows 7 中，便签文件存储为 OLE 文件，因此在以下 Python 脚本中，我们将调查此 OLE 文件以从便签中提取元数据。

对于此 Python 脚本，我们需要安装第三方模块，即olefile、pytsk3、pyewf和 unicodecsv。我们可以使用命令pip来安装它们。

我们可以按照以下讨论的步骤从名为StickyNote.sn的便签文件中提取信息：

  • 首先，打开证据文件并找到所有 StickyNote.snt 文件。

  • 然后，从 OLE 流中解析元数据和内容，并将 RTF 内容写入文件。

  • 最后，创建此元数据的 CSV 报告。

Python 代码

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

首先，导入以下 Python 库：

from __future__ import print_function
from argparse import ArgumentParser

import unicodecsv as csv
import os
import StringIO

from utility.pytskutil import TSKUtil
import olefile

接下来，定义一个将在整个脚本中使用的全局变量：

REPORT_COLS = ['note_id', 'created', 'modified', 'note_text', 'note_file']

接下来，我们需要为命令行处理程序提供参数。请注意，这里它将接受三个参数 - 第一个是证据文件路径，第二个是证据文件类型，第三个是所需的输出路径，如下所示：

if __name__ == '__main__':
   parser = argparse.ArgumentParser('Evidence from Sticky Notes')
   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_FOLDER', help="Path to report folder")
   args = parser.parse_args()
   main(args.EVIDENCE_FILE, args.IMAGE_TYPE, args.REPORT_FOLDER)

现在，我们将定义main()函数，它将类似于前面的脚本，如下所示：

def main(evidence, image_type, report_folder):
   tsk_util = TSKUtil(evidence, image_type)
   note_files = tsk_util.recurse_files('StickyNotes.snt', '/Users','equals')

现在，让我们遍历结果文件。然后，我们将调用parse_snt_file()函数来处理文件，然后我们将使用write_note_rtf()方法写入 RTF 文件，如下所示：

report_details = []
for note_file in note_files:
   user_dir = note_file[1].split("/")[1]
   file_like_obj = create_file_like_obj(note_file[2])
   note_data = parse_snt_file(file_like_obj)
   
   if note_data is None:
      continue
   write_note_rtf(note_data, os.path.join(report_folder, user_dir))
   report_details += prep_note_report(note_data, REPORT_COLS,"/Users" + note_file[1])
   write_csv(os.path.join(report_folder, 'sticky_notes.csv'), REPORT_COLS,report_details)

接下来，我们需要定义此脚本中使用的各种函数。

首先，我们将为读取文件大小定义create_file_like_obj()函数，方法是获取pytsk文件对象。然后，我们将定义parse_snt_file()函数，该函数将文件类对象作为其输入，并用于读取和解释便签文件。

def parse_snt_file(snt_file):
   
   if not olefile.isOleFile(snt_file):
      print("This is not an OLE file")
      return None
   ole = olefile.OleFileIO(snt_file)
   note = {}
   
   for stream in ole.listdir():
      if stream[0].count("-") == 3:
         if stream[0] not in note:
            note[stream[0]] = {"created": ole.getctime(stream[0]),"modified": ole.getmtime(stream[0])}
         content = None
         if stream[1] == '0':
            content = ole.openstream(stream).read()
         elif stream[1] == '3':
            content = ole.openstream(stream).read().decode("utf-16")
         if content:
            note[stream[0]][stream[1]] = content
	return note

现在，通过定义write_note_rtf()函数创建一个 RTF 文件，如下所示

def write_note_rtf(note_data, report_folder):
   if not os.path.exists(report_folder):
      os.makedirs(report_folder)
   
   for note_id, stream_data in note_data.items():
      fname = os.path.join(report_folder, note_id + ".rtf")
      with open(fname, 'w') as open_file:
         open_file.write(stream_data['0'])

现在，我们将嵌套字典转换为字典的扁平列表，这些字典更适合 CSV 电子表格。这将通过定义prep_note_report()函数来完成。最后，我们将定义write_csv()函数。

def prep_note_report(note_data, report_cols, note_file):
   report_details = []
   
   for note_id, stream_data in note_data.items():
      report_details.append({
         "note_id": note_id,
         "created": stream_data['created'],
         "modified": stream_data['modified'],
         "note_text": stream_data['3'].strip("\x00"),
         "note_file": note_file
      })
   return report_details
def write_csv(outfile, fieldnames, data):
   with open(outfile, 'wb') as open_outfile:
      csvfile = csv.DictWriter(open_outfile, fieldnames)
      csvfile.writeheader()
      csvfile.writerows(data)

运行上述脚本后，我们将从便签文件中获取元数据。

注册表文件

Windows 注册表文件包含许多重要的详细信息，对于取证分析师来说，这些详细信息就像一个信息宝库。它是一个分层数据库，包含与操作系统配置、用户活动、软件安装等相关的信息。在以下 Python 脚本中，我们将从SYSTEM和SOFTWARE配置单元访问常见的基线信息。

对于此 Python 脚本，我们需要安装第三方模块，即pytsk3、pyewf和registry。我们可以使用pip来安装它们。

我们可以按照以下给出的步骤从 Windows 注册表中提取信息：

  • 首先，根据其名称和路径查找要处理的注册表配置单元。

  • 然后，我们使用 StringIO 和 Registry 模块打开这些文件。

  • 最后，我们需要处理每个配置单元并将解析后的值打印到控制台以供解释。

Python 代码

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

首先，导入以下 Python 库：

from __future__ import print_function
from argparse import ArgumentParser

import datetime
import StringIO
import struct

from utility.pytskutil import TSKUtil
from Registry import Registry

现在，为命令行处理程序提供参数。这里它将接受两个参数 - 第一个是证据文件路径，第二个是证据文件类型，如下所示：

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

现在，我们将定义main()函数，用于在/Windows/System32/config文件夹中搜索SYSTEM和SOFTWARE配置单元，如下所示：

def main(evidence, image_type):
   tsk_util = TSKUtil(evidence, image_type)
   tsk_system_hive = tsk_util.recurse_files('system', '/Windows/system32/config', 'equals')
   tsk_software_hive = tsk_util.recurse_files('software', '/Windows/system32/config', 'equals')
   system_hive = open_file_as_reg(tsk_system_hive[0][2])
   software_hive = open_file_as_reg(tsk_software_hive[0][2])
   process_system_hive(system_hive)
   process_software_hive(software_hive)

现在，定义打开注册表文件的函数。为此，我们需要从pytsk元数据中收集文件大小，如下所示：

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)

现在，借助以下方法，我们可以处理SYSTEM>配置单元：

def process_system_hive(hive):
   root = hive.root()
   current_control_set = root.find_key("Select").value("Current").value()
   control_set = root.find_key("ControlSet{:03d}".format(current_control_set))
   raw_shutdown_time = struct.unpack(
      '<Q', control_set.find_key("Control").find_key("Windows").value("ShutdownTime").value())
   
   shutdown_time = parse_windows_filetime(raw_shutdown_time[0])
   print("Last Shutdown Time: {}".format(shutdown_time))
   
   time_zone = control_set.find_key("Control").find_key("TimeZoneInformation")
      .value("TimeZoneKeyName").value()
   
   print("Machine Time Zone: {}".format(time_zone))
   computer_name = control_set.find_key("Control").find_key("ComputerName").find_key("ComputerName")
      .value("ComputerName").value()
   
   print("Machine Name: {}".format(computer_name))
   last_access = control_set.find_key("Control").find_key("FileSystem")
      .value("NtfsDisableLastAccessUpdate").value()
   last_access = "Disabled" if last_access == 1 else "enabled"
   print("Last Access Updates: {}".format(last_access))

现在，我们需要定义一个函数将解释的整数转换为格式化的日期和时间，如下所示：

def parse_windows_filetime(date_value):
   microseconds = float(date_value) / 10
   ts = datetime.datetime(1601, 1, 1) + datetime.timedelta(microseconds = microseconds)
   return ts.strftime('%Y-%m-%d %H:%M:%S.%f')

def parse_unix_epoch(date_value):
   ts = datetime.datetime.fromtimestamp(date_value)
   return ts.strftime('%Y-%m-%d %H:%M:%S.%f')

现在，借助以下方法，我们可以处理SOFTWARE配置单元：

def process_software_hive(hive):
   root = hive.root()
   nt_curr_ver = root.find_key("Microsoft").find_key("Windows NT")
      .find_key("CurrentVersion")
   
   print("Product name: {}".format(nt_curr_ver.value("ProductName").value()))
   print("CSD Version: {}".format(nt_curr_ver.value("CSDVersion").value()))
   print("Current Build: {}".format(nt_curr_ver.value("CurrentBuild").value()))
   print("Registered Owner: {}".format(nt_curr_ver.value("RegisteredOwner").value()))
   print("Registered Org: 
      {}".format(nt_curr_ver.value("RegisteredOrganization").value()))
   
   raw_install_date = nt_curr_ver.value("InstallDate").value()
   install_date = parse_unix_epoch(raw_install_date)
   print("Installation Date: {}".format(install_date))

运行上述脚本后，我们将获得存储在 Windows 注册表文件中的元数据。

打印页面
上一页
下一页
广告