Python数字网络取证-II

上一页
下一页

上一章讨论了使用Python进行网络取证的一些概念。在本章中，让我们更深入地了解使用Python进行网络取证。

使用Beautiful Soup保存网页

万维网（WWW）是一个独特的的信息资源。然而，由于内容以惊人的速度丢失，其遗产面临着巨大的风险。许多文化遗产和学术机构、非营利组织和私营企业都探索了所涉及的问题，并为网页归档的技术解决方案的开发做出了贡献。

网页保存或网页归档是从万维网上收集数据，确保数据保存在档案中，并使其可供未来的研究人员、历史学家和公众使用。在进一步探讨网页保存之前，让我们讨论一些与网页保存相关的重要问题，如下所示：

  • 网页资源的变化 - 网页资源每天都在变化，这对网页保存提出了挑战。

  • 大量资源 - 网页保存相关的另一个问题是需要保存的大量资源。

  • 完整性 - 网页必须受到保护，防止未经授权的修改、删除或移除，以保护其完整性。

  • 处理多媒体数据 - 在保存网页时，我们也需要处理多媒体数据，这可能会在处理过程中导致问题。

  • 提供访问 - 除了保存之外，还需要解决提供对网页资源的访问以及处理所有权问题等问题。

在本章中，我们将使用名为Beautiful Soup的Python库来保存网页。

什么是Beautiful Soup？

Beautiful Soup是一个用于从HTML和XML文件中提取数据的Python库。它可以与urlib一起使用，因为它需要一个输入（文档或URL）来创建soup对象，因为它本身无法获取网页。您可以在www.crummy.com/software/BeautifulSoup/bs4/doc/详细了解。

请注意，在使用它之前，我们必须使用以下命令安装第三方库：

pip install bs4

接下来，使用Anaconda包管理器，我们可以如下安装Beautiful Soup：

conda install -c anaconda beautifulsoup4

保存网页的Python脚本

这里讨论了使用名为Beautiful Soup的第三方库保存网页的Python脚本：

首先，导入所需的库，如下所示：

from __future__ import print_function
import argparse

from bs4 import BeautifulSoup, SoupStrainer
from datetime import datetime

import hashlib
import logging
import os
import ssl
import sys
from urllib.request import urlopen

import urllib.error
logger = logging.getLogger(__name__)

请注意，此脚本将接受两个位置参数，一个是将要保存的URL，另一个是所需的输出目录，如下所示：

if __name__ == "__main__":
   parser = argparse.ArgumentParser('Web Page preservation')
   parser.add_argument("DOMAIN", help="Website Domain")
   parser.add_argument("OUTPUT_DIR", help="Preservation Output Directory")
   parser.add_argument("-l", help="Log file path",
   default=__file__[:-3] + ".log")
   args = parser.parse_args()

现在，通过指定一个文件和流处理程序来设置脚本的日志记录，以便循环并记录采集过程，如下所示：

logger.setLevel(logging.DEBUG)
msg_fmt = logging.Formatter("%(asctime)-15s %(funcName)-10s""%(levelname)-8s %(message)s")
strhndl = logging.StreamHandler(sys.stderr)
strhndl.setFormatter(fmt=msg_fmt)
fhndl = logging.FileHandler(args.l, mode='a')
fhndl.setFormatter(fmt=msg_fmt)

logger.addHandler(strhndl)
logger.addHandler(fhndl)
logger.info("Starting BS Preservation")
logger.debug("Supplied arguments: {}".format(sys.argv[1:]))
logger.debug("System " + sys.platform)
logger.debug("Version " + sys.version)

现在，让我们对所需的输出目录进行输入验证，如下所示：

if not os.path.exists(args.OUTPUT_DIR):
   os.makedirs(args.OUTPUT_DIR)
main(args.DOMAIN, args.OUTPUT_DIR)

现在，我们将定义main()函数，该函数将通过删除实际名称之前的非必要元素来提取网站的基本名称，以及对输入URL进行其他验证，如下所示：

def main(website, output_dir):
   base_name = website.replace("https://", "").replace("http://", "").replace("www.", "")
   link_queue = set()
   
   if "http://" not in website and "https://" not in website:
      logger.error("Exiting preservation - invalid user input: {}".format(website))
      sys.exit(1)
   logger.info("Accessing {} webpage".format(website))
   context = ssl._create_unverified_context()

现在，我们需要使用urlopen()方法打开与URL的连接。让我们使用try-except块，如下所示：

try:
   index = urlopen(website, context=context).read().decode("utf-8")
except urllib.error.HTTPError as e:
   logger.error("Exiting preservation - unable to access page: {}".format(website))
   sys.exit(2)
logger.debug("Successfully accessed {}".format(website))

接下来的几行代码包含三个函数，如下所述：

  • write_output() 将第一个网页写入输出目录

  • find_links() 函数识别此网页上的链接

  • recurse_pages() 函数迭代并发现网页上的所有链接。

write_output(website, index, output_dir)
link_queue = find_links(base_name, index, link_queue)
logger.info("Found {} initial links on webpage".format(len(link_queue)))
recurse_pages(website, link_queue, context, output_dir)
logger.info("Completed preservation of {}".format(website))

现在，让我们定义write_output()方法，如下所示：

def write_output(name, data, output_dir, counter=0):
   name = name.replace("http://", "").replace("https://", "").rstrip("//")
   directory = os.path.join(output_dir, os.path.dirname(name))
   
   if not os.path.exists(directory) and os.path.dirname(name) != "":
      os.makedirs(directory)

我们需要记录有关网页的一些详细信息，然后我们使用hash_data()方法记录数据的哈希值，如下所示：

logger.debug("Writing {} to {}".format(name, output_dir)) logger.debug("Data Hash: {}".format(hash_data(data)))
path = os.path.join(output_dir, name)
path = path + "_" + str(counter)
with open(path, "w") as outfile:
   outfile.write(data)
logger.debug("Output File Hash: {}".format(hash_file(path)))

现在，定义hash_data()方法，借助该方法，我们读取UTF-8编码的数据，然后生成其SHA-256哈希值，如下所示：

def hash_data(data):
   sha256 = hashlib.sha256()
   sha256.update(data.encode("utf-8"))
   return sha256.hexdigest()
def hash_file(file):
   sha256 = hashlib.sha256()
   with open(file, "rb") as in_file:
      sha256.update(in_file.read())
return sha256.hexdigest()

现在，让我们在find_links()方法下从网页数据创建一个Beautifulsoup对象，如下所示：

def find_links(website, page, queue):
   for link in BeautifulSoup(page, "html.parser",parse_only = SoupStrainer("a", href = True)):
      if website in link.get("href"):
         if not os.path.basename(link.get("href")).startswith("#"):
            queue.add(link.get("href"))
   return queue

现在，我们需要定义recurse_pages()方法，并向其提供网站URL、当前链接队列、未经验证的SSL上下文和输出目录的输入，如下所示：

def recurse_pages(website, queue, context, output_dir):
   processed = []
   counter = 0
   
   while True:
      counter += 1
      if len(processed) == len(queue):
         break
      for link in queue.copy(): if link in processed:
         continue
	   processed.append(link)
      try:
      page = urlopen(link,      context=context).read().decode("utf-8")
      except urllib.error.HTTPError as e:
         msg = "Error accessing webpage: {}".format(link)
         logger.error(msg)
         continue

现在，通过传递链接名称、页面数据、输出目录和计数器，将每个访问的网页的输出写入文件中，如下所示：

write_output(link, page, output_dir, counter)
queue = find_links(website, page, queue)
logger.info("Identified {} links throughout website".format(
   len(queue)))

现在，当我们通过提供网站的URL、输出目录和日志文件的路径来运行此脚本时，我们将获得有关该网页的详细信息，这些信息可用于将来使用。

病毒狩猎

您是否曾经想过取证分析师、安全研究人员和事件响应人员如何了解有用软件和恶意软件之间的区别？答案就在问题本身中，因为如果不研究黑客快速生成的恶意软件，研究人员和专家几乎不可能分辨有用软件和恶意软件之间的区别。在本节中，让我们讨论VirusShare，这是一个完成此任务的工具。

了解VirusShare

VirusShare 是最大的私人拥有的恶意软件样本集合，为安全研究人员、事件响应人员和取证分析师提供活动恶意代码样本。它包含超过 3000 万个样本。

VirusShare 的好处是可以免费获得恶意软件哈希列表。任何人都可以使用这些哈希值创建非常全面的哈希集，并使用它来识别潜在的恶意文件。但在使用 VirusShare 之前，我们建议您访问https://virusshare.com以获取更多详细信息。

使用Python从VirusShare创建换行符分隔的哈希列表

来自 VirusShare 的哈希列表可用于各种取证工具，例如 X-ways 和 EnCase。在下面讨论的脚本中，我们将自动化从 VirusShare 下载哈希列表的过程，以创建一个换行符分隔的哈希列表。

对于此脚本，我们需要一个名为tqdm的第三方Python库，可以如下下载：

pip install tqdm

请注意，在此脚本中，我们首先将读取 VirusShare 哈希页面并动态识别最新的哈希列表。然后，我们将初始化进度条并在所需的范围内下载哈希列表。

首先，导入以下库：

from __future__ import print_function

import argparse
import os
import ssl
import sys
import tqdm

from urllib.request import urlopen
import urllib.error

此脚本将接受一个位置参数，该参数将是哈希集所需的路径：

if __name__ == '__main__':
   parser = argparse.ArgumentParser('Hash set from VirusShare')
   parser.add_argument("OUTPUT_HASH", help = "Output Hashset")
   parser.add_argument("--start", type = int, help = "Optional starting location")
   args = parser.parse_args()

现在，我们将执行标准输入验证，如下所示：

directory = os.path.dirname(args.OUTPUT_HASH)
if not os.path.exists(directory):
   os.makedirs(directory)
if args.start:
   main(args.OUTPUT_HASH, start=args.start)
else:
   main(args.OUTPUT_HASH)

现在，我们需要定义main()函数，并使用**kwargs作为参数，因为这将创建一个字典，我们可以参考它来支持提供的键参数，如下所示：

def main(hashset, **kwargs):
   url = "https://virusshare.com/hashes.4n6"
   print("[+] Identifying hash set range from {}".format(url))
   context = ssl._create_unverified_context()

现在，我们需要使用urlib.request.urlopen()方法打开VirusShare哈希页面。我们将使用try-except块，如下所示：

try:
   index = urlopen(url, context = context).read().decode("utf-8")
except urllib.error.HTTPError as e:
   print("[-] Error accessing webpage - exiting..")
   sys.exit(1)

现在，从下载的页面中识别最新的哈希列表。您可以通过查找HTMLhref标记到VirusShare哈希列表的最后一个实例来执行此操作。可以使用以下代码行完成：

tag = index.rfind(r'a href = "hashes/VirusShare_')
stop = int(index[tag + 27: tag + 27 + 5].lstrip("0"))

if "start" not in kwa<rgs:
   start = 0
else:
   start = kwargs["start"]

if start < 0 or start > stop:
   print("[-] Supplied start argument must be greater than or equal ""to zero but less than the latest hash list, ""currently: {}".format(stop))
sys.exit(2)
print("[+] Creating a hashset from hash lists {} to {}".format(start, stop))
hashes_downloaded = 0

现在，我们将使用tqdm.trange()方法创建循环和进度条，如下所示：

for x in tqdm.trange(start, stop + 1, unit_scale=True,desc="Progress"):
   url_hash = "https://virusshare.com/hashes/VirusShare_"\"{}.md5".format(str(x).zfill(5))
   try:
      hashes = urlopen(url_hash, context=context).read().decode("utf-8")
      hashes_list = hashes.split("\n")
   except urllib.error.HTTPError as e:
      print("[-] Error accessing webpage for hash list {}"" - continuing..".format(x))
   continue

成功执行上述步骤后，我们将以a+模式打开哈希集文本文件，以追加到文本文件的底部。

with open(hashset, "a+") as hashfile:
   for line in hashes_list:
   if not line.startswith("#") and line != "":
      hashes_downloaded += 1
      hashfile.write(line + '\n')
   print("[+] Finished downloading {} hashes into {}".format(
      hashes_downloaded, hashset))

运行上述脚本后，您将获得最新的哈希列表，其中包含以文本格式表示的MD5哈希值。

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