当前位置：极客教程 > Python > Python 数字取证 > Python数字移动设备取证

Python数字移动设备取证

Python数字移动设备取证

本章将解释移动设备上的Python数字取证和所涉及的概念。

简介

移动设备取证是数字取证的一个分支，涉及获取和分析移动设备以恢复调查所需的数字证据。这个分支与计算机取证不同，因为移动设备有一个内置的通信系统，可以提供与位置有关的有用信息。

虽然智能手机在数字取证中的使用与日俱增，但由于其异质性，它仍然被认为是非标准的。另一方面，计算机硬件，如硬盘，也被认为是标准的，并作为一个稳定的学科发展。在数字取证行业中，对用于非标准设备的技术有很多争论，这些设备具有短暂的证据，如智能手机。

可从移动设备中提取的人工制品

与只有通话记录或短信的旧手机相比，现代移动设备拥有大量的数字信息。因此，移动设备可以为调查人员提供很多关于其用户的信息。一些可以从移动设备中提取的人工制品如下所示

  • 信息 – 这些是有用的人工制品，可以揭示所有者的思想状态，甚至可以向调查员提供一些以前未知的信息。

  • 位置历史 – 位置历史数据是一个有用的人工制品，调查人员可以用它来验证一个人的特定位置。

  • 安装的应用程序 – 通过访问安装的应用程序的种类，调查员可以深入了解移动用户的习惯和想法。

证据来源和Python的处理

智能手机有SQLite数据库和PLIST文件作为证据的主要来源。在本节中，我们将用Python来处理证据来源。

分析PLIST文件

PLIST（属性列表）是一种灵活方便的格式，用于存储应用程序的数据，特别是在iPhone设备上。它使用的扩展名是 .plist 。 这类文件用来存储关于捆绑和应用程序的信息。它可以有两种格式： XML 和 二进制。 下面的Python代码将打开并读取PLIST文件。注意，在进入这个过程之前，我们必须创建我们自己的 Info.plist 文件。

首先，通过下面的命令安装一个名为 biplist 的第三方库– biplist 。

Pip install biplist

现在，导入一些有用的库来处理plist文件 —

import biplist
import os
import sys

现在，在main方法下使用以下命令，可以用来将plist文件读入一个变量–

def main(plist):
   try:
      data = biplist.readPlist(plist)
   except (biplist.InvalidPlistException,biplist.NotBinaryPlistException) as e:
print("[-] Invalid PLIST file - unable to be opened by biplist")
sys.exit(1)

现在，我们可以从这个变量中读取控制台中的数据或直接打印。

SQLite数据库

SQLite是移动设备上的主要数据存储库。SQLite是一个进程中的库，实现了一个独立的、无服务器的、零配置的、事务性的SQL数据库引擎。它是一个数据库，是零配置的，你不需要在你的系统中配置它，这与其他数据库不同。

如果你是一个新手或不熟悉SQLite数据库，你可以按照链接www.tutorialspoint.com/sqlite/index.htm，此外 ，如果你想用Python详细了解SQLite，你可以按照链接www.tutorialspoint.com/sqlite/sqlite_python.htm 。

在移动取证过程中，我们可以与移动设备的 sms.db 文件进行交互，并可以从 信息 表中提取有价值的信息。Python有一个名为 sqlite3 的内置库，用于与SQLite数据库连接。你可以用下面的命令导入同样的东西

import sqlite3

现在，在以下命令的帮助下，我们可以连接到数据库，在移动设备的情况下称为 sms.db。

Conn = sqlite3.connect(‘sms.db’)
C = conn.cursor()

这里，C是游标对象，在它的帮助下我们可以与数据库交互。

现在，假设我们想执行一个特定的命令，比如说从 abc表中 获取详细信息，可以通过以下命令来完成

c.execute(“Select * from abc”)
c.close()

上述命令的结果将被存储在 游标 对象中。同样的，我们可以使用 fetchall() 方法将结果转储到一个我们可以操作的变量中。

我们可以使用下面的命令来获取 sms.db 中消息表的列名数据—-。

c.execute(“pragma table_info(message)”)
table_data = c.fetchall()
columns = [x[1] for x in table_data

请注意，这里我们使用的是SQLite PRAGMA命令，它是用来控制SQLite环境中各种环境变量和状态标志的特殊命令。在上述命令中， fetchall() 方法返回一个结果的元组。每一列的名称被存储在每个元组的第一个索引中。

现在，在以下命令的帮助下，我们可以查询该表的所有数据，并将其存储在名为 data_msg 的变量中。

c.execute(“Select * from message”)
data_msg = c.fetchall()

上述命令将把数据存储在变量中，而且我们还可以通过使用 csv.writer() 方法把上述数据写入CSV文件中。

iTunes备份

iPhone手机取证可以通过iTunes的备份来进行。鉴证人员依靠分析通过iTunes获得的iPhone逻辑备份。AFC（苹果文件连接）协议是由iTunes使用来进行备份的。此外，除了托管密钥记录，备份过程不会修改iPhone上的任何东西。

现在，问题来了，为什么数字取证专家必须了解iTunes备份的技术？这对我们进入犯罪嫌疑人的电脑而不是直接进入iPhone很重要，因为当电脑被用来与iPhone同步时，iPhone上的大部分信息都有可能被备份到电脑上了。

备份的过程和位置

每当苹果产品被备份到电脑上时，它就会与iTunes同步，并且会有一个带有设备独特ID的特定文件夹。在最新的备份格式中，文件被存储在包含文件名前两个十六进制字符的子文件夹中。从这些备份文件中，有一些文件，如info.plist，与名为Manifest.db的数据库一起是很有用的。The following table shows the backup locations, that vary with operating systems of iTunes backups −

操作系统 备份位置
Win7 C:\Users\[用户名]\AppData\Roaming\AppleComputer\MobileSync\Backup\
MAC OS X ~/Library/Application Suport/MobileSync/Backup/ 仓库。

对于用Python处理iTunes的备份，我们首先需要根据我们的操作系统识别备份位置的所有备份。然后，我们将遍历每个备份并读取数据库Manifest.db。

Now, with the help of following Python code we can do the same −

首先，导入必要的库，如下所示

from __future__ import print_function
import argparse
import logging
import os

from shutil import copyfile
import sqlite3
import sys
logger = logging.getLogger(__name__)

现在，提供两个位置参数，即 INPUT_DIR 和 OUTPUT_DIR，代表 iTunes 的备份和所需的输出文件夹。

if __name__ == "__main__":
   parser.add_argument("INPUT_DIR",help = "Location of folder containing iOS backups, ""e.g. ~\Library\Application Support\MobileSync\Backup folder")
   parser.add_argument("OUTPUT_DIR", help = "Output Directory")
   parser.add_argument("-l", help = "Log file path",default = __file__[:-2] + "log")
   parser.add_argument("-v", help = "Increase verbosity",action = "store_true") args = parser.parse_args()

现在，按以下方式设置日志—

if args.v:
   logger.setLevel(logging.DEBUG)
else:
   logger.setLevel(logging.INFO)

现在，为该日志设置信息格式，如下所示

msg_fmt = logging.Formatter("%(asctime)-15s %(funcName)-13s""%(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 iBackup Visualizer")
logger.debug("Supplied arguments: {}".format(" ".join(sys.argv[1:])))
logger.debug("System: " + sys.platform)
logger.debug("Python Version: " + sys.version)

下面这行代码将通过使用 os.makedirs( )函数为所需的输出目录创建必要的文件夹。

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

现在，将提供的输入和输出目录传递给main()函数，如下所示

if os.path.exists(args.INPUT_DIR) and os.path.isdir(args.INPUT_DIR):
   main(args.INPUT_DIR, args.OUTPUT_DIR)
else:
   logger.error("Supplied input directory does not exist or is not ""a directory")
   sys.exit(1)

现在，编写 main( )函数，它将进一步调用 backup_summary() 函数，以确定输入文件夹中存在的所有备份。

def main(in_dir, out_dir):
   backups = backup_summary(in_dir)
def backup_summary(in_dir):
   logger.info("Identifying all iOS backups in {}".format(in_dir))
   root = os.listdir(in_dir)
   backups = {}

   for x in root:
      temp_dir = os.path.join(in_dir, x)
      if os.path.isdir(temp_dir) and len(x) == 40:
         num_files = 0
         size = 0

         for root, subdir, files in os.walk(temp_dir):
            num_files += len(files)
            size += sum(os.path.getsize(os.path.join(root, name))
               for name in files)
         backups[x] = [temp_dir, num_files, size]
   return backups

现在，将每个备份的摘要打印到控制台，如下所示 –

print("Backup Summary")
print("=" * 20)

if len(backups) > 0:
   for i, b in enumerate(backups):
      print("Backup No.: {} \n""Backup Dev. Name: {} \n""# Files: {} \n""Backup Size (Bytes): {}\n".format(i, b, backups[b][1], backups[b][2]))

现在，将Manifest.db文件的内容转储到名为db_items的变量中。

try:
   db_items = process_manifest(backups[b][0])
   except IOError:
      logger.warn("Non-iOS 10 backup encountered or " "invalid backup. Continuing to next backup.")
continue

现在，让我们定义一个函数，它将获取备份的目录路径：

def process_manifest(backup):
   manifest = os.path.join(backup, "Manifest.db")

   if not os.path.exists(manifest):
      logger.error("Manifest DB not found in {}".format(manifest))
      raise IOError

现在，使用SQLite3，我们将通过名为c的游标连接到数据库—-。

c = conn.cursor()
items = {}

for row in c.execute("SELECT * from Files;"):
   items[row[0]] = [row[2], row[1], row[3]]
return items

create_files(in_dir, out_dir, b, db_items)
   print("=" * 20)
else:
   logger.warning("No valid backups found. The input directory should be
      " "the parent-directory immediately above the SHA-1 hash " "iOS device backups")
      sys.exit(2)

现在，定义 create_files( )方法，如下所示

def create_files(in_dir, out_dir, b, db_items):
   msg = "Copying Files for backup {} to {}".format(b, os.path.join(out_dir, b))
   logger.info(msg)

现在，遍历 db_items 字典中的每个键—-。

for x, key in enumerate(db_items):
   if db_items[key][0] is None or db_items[key][0] == "":
      continue
   else:
      dirpath = os.path.join(out_dir, b,
os.path.dirname(db_items[key][0]))
   filepath = os.path.join(out_dir, b, db_items[key][0])

   if not os.path.exists(dirpath):
      os.makedirs(dirpath)
      original_dir = b + "/" + key[0:2] + "/" + key
   path = os.path.join(in_dir, original_dir)

   if os.path.exists(filepath):
      filepath = filepath + "_{}".format(x)

现在，使用 shutil.copyfile( )方法来复制备份的文件，如下所示

try:
   copyfile(path, filepath)
   except IOError:
      logger.debug("File not found in backup: {}".format(path))
         files_not_found += 1
   if files_not_found > 0:
      logger.warning("{} files listed in the Manifest.db not" "found in
backup".format(files_not_found))
   copyfile(os.path.join(in_dir, b, "Info.plist"), os.path.join(out_dir, b,
"Info.plist"))
   copyfile(os.path.join(in_dir, b, "Manifest.db"), os.path.join(out_dir, b,
"Manifest.db"))
   copyfile(os.path.join(in_dir, b, "Manifest.plist"), os.path.join(out_dir, b,
"Manifest.plist"))
   copyfile(os.path.join(in_dir, b, "Status.plist"),os.path.join(out_dir, b,
"Status.plist"))

通过上述Python脚本，我们可以在输出文件夹中获得更新的备份文件结构。我们可以使用 pycrypto python库来解密备份。

Wi – Fi

移动设备可以通过随处可见的Wi-Fi网络连接到外部世界。有时，设备会自动连接到这些开放的网络。

在iPhone的情况下，设备已经连接的开放Wi-Fi连接列表存储在一个名为 com.apple.wifi.plist的 PLIST文件中 。 这个文件将包含Wi-Fi SSID、BSSID和连接时间。

我们需要使用Python从标准的Cellebrite XML报告中提取Wi-Fi细节。为此，我们需要使用无线地理记录引擎（WIGLE）的API，这是一个流行的平台，可用于使用Wi-Fi网络的名称找到设备的位置。

我们可以使用名为 request 的Python库来访问WIGLE的API。它可以按以下方式安装

pip install requests

来自WIGLE的API

我们需要在WIGLE的网站https://wigle.net/account，以便 从WIGLE获得免费的API。下面讨论通过WIGEL的API获得用户设备及其连接信息的Python脚本：

首先，导入以下库来处理不同的事情：

from __future__ import print_function

import argparse
import csv
import os
import sys
import xml.etree.ElementTree as ET
import requests

现在，提供两个位置参数，即 INPUT_FILE 和 OUTPUT_CSV ，它们将分别代表带有Wi-Fi MAC地址的输入文件和所需的输出CSV文件。

if __name__ == "__main__":
   parser.add_argument("INPUT_FILE", help = "INPUT FILE with MAC Addresses")
   parser.add_argument("OUTPUT_CSV", help = "Output CSV File")
   parser.add_argument("-t", help = "Input type: Cellebrite XML report or TXT
file",choices = ('xml', 'txt'), default = "xml")
   parser.add_argument('--api', help = "Path to API key
   file",default = os.path.expanduser("~/.wigle_api"),
   type = argparse.FileType('r'))
   args = parser.parse_args()

现在下面几行代码将检查输入文件是否存在并且是一个文件。如果不存在，它将退出脚本 –

if not os.path.exists(args.INPUT_FILE) or \ not os.path.isfile(args.INPUT_FILE):
   print("[-] {} does not exist or is not a
file".format(args.INPUT_FILE))
   sys.exit(1)
directory = os.path.dirname(args.OUTPUT_CSV)
if directory != '' and not os.path.exists(directory):
   os.makedirs(directory)
api_key = args.api.readline().strip().split(":")

Now, pass the argument to main as follows −

main(args.INPUT_FILE, args.OUTPUT_CSV, args.t, api_key)
def main(in_file, out_csv, type, api_key):
   if type == 'xml':
      wifi = parse_xml(in_file)
   else:
      wifi = parse_txt(in_file)
query_wigle(wifi, out_csv, api_key)

现在，我们将解析XML文件，如下图所示

def parse_xml(xml_file):
   wifi = {}
   xmlns = "{http://pa.cellebrite.com/report/2.0}"
   print("[+] Opening {} report".format(xml_file))

   xml_tree = ET.parse(xml_file)
   print("[+] Parsing report for all connected WiFi addresses")

   root = xml_tree.getroot()

现在，通过根的子元素进行迭代，如下所示：

for child in root.iter():
   if child.tag == xmlns + "model":
      if child.get("type") == "Location":
         for field in child.findall(xmlns + "field"):
            if field.get("name") == "TimeStamp":
               ts_value = field.find(xmlns + "value")
               try:
               ts = ts_value.text
               except AttributeError:
continue

现在，我们将检查’sid’字符串是否存在于该值的文本中。

if "SSID" in value.text:
   bssid, ssid = value.text.split("\t")
   bssid = bssid[7:]
   ssid = ssid[6:]

现在，我们需要将BSSID、SSID和时间戳添加到wifi字典中，如下图所示

if bssid in wifi.keys():

wifi[bssid]["Timestamps"].append(ts)
   wifi[bssid]["SSID"].append(ssid)
else:
   wifi[bssid] = {"Timestamps": [ts], "SSID":
[ssid],"Wigle": {}}
return wifi

文本分析器比XML分析器简单得多，如下图所示。

def parse_txt(txt_file):
   wifi = {}
   print("[+] Extracting MAC addresses from {}".format(txt_file))

   with open(txt_file) as mac_file:
      for line in mac_file:
         wifi[line.strip()] = {"Timestamps": ["N/A"], "SSID":
["N/A"],"Wigle": {}}
return wifi

现在，让我们使用requests模块来进行 WIGLE API 调用，并需要转到 query_wigle( )方法。

def query_wigle(wifi_dictionary, out_csv, api_key):
   print("[+] Querying Wigle.net through Python API for {} "
"APs".format(len(wifi_dictionary)))
   for mac in wifi_dictionary:

   wigle_results = query_mac_addr(mac, api_key)
def query_mac_addr(mac_addr, api_key):

   query_url = "https://api.wigle.net/api/v2/network/search?" \
"onlymine = false&freenet = false&paynet = false" \ "&netid = {}".format(mac_addr)
   req = requests.get(query_url, auth = (api_key[0], api_key[1]))
   return req.json()

实际上，每天的WIGLE API调用是有限制的，如果超过了这个限制，那么它必须显示一个错误，如下所示

try:
   if wigle_results["resultCount"] == 0:
      wifi_dictionary[mac]["Wigle"]["results"] = []
         continue
   else:
      wifi_dictionary[mac]["Wigle"] = wigle_results
except KeyError:
   if wigle_results["error"] == "too many queries today":
      print("[-] Wigle daily query limit exceeded")
      wifi_dictionary[mac]["Wigle"]["results"] = []
      continue
   else:
      print("[-] Other error encountered for " "address {}: {}".format(mac,
wigle_results['error']))
   wifi_dictionary[mac]["Wigle"]["results"] = []
   continue
prep_output(out_csv, wifi_dictionary)

现在，我们将使用 prep_output( )方法将字典平铺成容易写入的小块。

def prep_output(output, data):
   csv_data = {}
   google_map = https://www.google.com/maps/search/

Now, access all the data we have collected so far as follows −

for x, mac in enumerate(data):
   for y, ts in enumerate(data[mac]["Timestamps"]):
      for z, result in enumerate(data[mac]["Wigle"]["results"]):
         shortres = data[mac]["Wigle"]["results"][z]
         g_map_url = "{}{},{}".format(google_map, shortres["trilat"],shortres["trilong"])

现在，我们可以使用 write_csv() 函数将输出写入CSV文件，正如我们在本章前面的脚本中所做的那样。

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Python 数字取证