Python取證 - 快速指南

---

---

Python取證 - 簡介

Python是一種通用程式語言，具有簡單易讀的程式碼，專業開發人員和新手程式設計師都易於理解。Python包含許多可與任何堆疊框架一起使用的實用庫。許多實驗室依靠Python來構建預測的基本模型並執行實驗。它還有助於控制關鍵的作業系統。

Python具有內建的功能來支援數字調查並在調查期間保護證據的完整性。在本教程中，我們將解釋在數字或計算取證中應用Python的基本概念。

什麼是計算取證？

計算取證是一個新興的研究領域。它處理使用數字方法解決取證問題。它利用計算科學來研究數字證據。

計算取證涵蓋廣泛的學科，其物件、物質和過程主要基於模式證據，例如工具痕跡、指紋、鞋印、檔案等，還包括生理和行為模式、DNA以及犯罪現場的數字證據。

下圖顯示了計算取證涵蓋的廣泛學科。

計算取證藉助於一些演算法實現。這些演算法用於訊號和影像處理、計算機視覺和圖形學。它還包括資料探勘、機器學習和機器人技術。

計算取證涉及多種數字方法。簡化取證中所有數字方法的最佳解決方案是使用Python這樣的通用程式語言。

Python取證 - Python的安裝

由於我們需要Python來進行計算取證的所有活動，讓我們一步一步地瞭解如何安裝它。

步驟1 - 訪問https://python.club.tw/downloads/並根據系統上的作業系統下載Python的安裝檔案。

步驟2 - 下載軟體包/安裝程式後，單擊exe檔案以啟動安裝過程。

安裝完成後，您將看到以下螢幕。

步驟3 - 下一步是在系統中設定Python的環境變數。

步驟4 - 設定環境變數後，在命令提示符下鍵入命令“python”以驗證安裝是否成功。

如果安裝成功，您將在控制檯上獲得以下輸出。

Python取證 - Python概述

Python編寫的程式碼看起來與其他傳統程式語言（如C或Pascal）編寫的程式碼非常相似。也有人說Python的語法大量借鑑了C語言。這包括許多與C語言類似的Python關鍵字。

Python包含條件和迴圈語句，可用於準確地提取取證資料。為了進行流程控制，它提供了if/else、while以及一個高階for語句，該語句迴圈遍歷任何“可迭代”物件。

if a < b: 
   max = b 
else: 
   max = a

Python與其他程式語言的主要區別在於它使用了動態型別。它使用引用物件的變數名。這些變數不需要宣告。

資料型別

Python包含一組內建資料型別，例如字串、布林值、數字等。還有一些不可變型別，這意味著在執行過程中無法更改的值。

Python還具有複合內建資料型別，包括元組（不可變陣列）、列表和字典（雜湊表）。所有這些都用於數字取證中儲存收集證據時的值。

第三方模組和包

Python支援模組和/或包的組，也稱為第三方模組（相關程式碼組合在一個原始檔中）用於組織程式。

Python包含一個廣泛的標準庫，這是它在計算取證中流行的主要原因之一。

Python程式碼的生命週期

• 首先，當您執行Python程式碼時，直譯器會檢查程式碼是否存在語法錯誤。如果直譯器發現任何語法錯誤，則會立即將其顯示為錯誤訊息。

• 如果沒有語法錯誤，則程式碼會被編譯以生成位元組碼併發送到PVM（Python虛擬機器）。

• PVM檢查位元組碼是否存在任何執行時或邏輯錯誤。如果PVM發現任何執行時錯誤，則會立即將其報告為錯誤訊息。

• 如果位元組碼沒有錯誤，則程式碼將被處理，並獲得其輸出。

下圖以圖形方式顯示了Python程式碼如何首先被解釋以生成位元組碼，以及位元組碼如何被PVM處理以生成輸出。

Python取證 - 基本取證應用

為了根據取證指南建立應用程式，瞭解並遵循其命名約定和模式非常重要。

命名約定

在開發Python取證應用程式期間，將在下表中描述要遵循的規則和約定。

讓我們以一個場景來了解命名約定在計算取證中的重要性。假設我們有一個雜湊演算法，通常用於加密資料。單向雜湊演算法將輸入作為二進位制資料的流；這可以是密碼、檔案、二進位制資料或任何數字資料。然後，雜湊演算法會生成一個關於輸入中接收到的資料的訊息摘要(md)。

實際上不可能建立一個新的二進位制輸入來生成給定的訊息摘要。即使二進位制輸入資料的單個位發生更改，也會生成一個與之前不同的唯一訊息。

示例

檢視以下遵循上述約定的示例程式。

import sys, string, md5   # necessary libraries
print "Please enter your full name"
line = sys.stdin.readline()
line = line.rstrip()
md5_object = md5.new()
md5_object.update(line)
print md5_object.hexdigest()   # Prints the output as per the hashing algorithm i.e. md5
exit

上述程式產生以下輸出。

在此程式中，Python指令碼接受輸入（您的全名）並根據md5雜湊演算法將其轉換為相應的格式。它加密資料並根據需要保護資訊。根據取證指南，證據或任何其他證明的名稱可以以這種模式進行保護。

Python取證 - 雜湊函式

雜湊函式定義為將大量資料對映到具有指定長度的固定值的函式。此函式確保相同的輸入產生相同的輸出，這實際上定義為雜湊值。雜湊值包含具有特定資訊的特徵。

此函式實際上無法反轉。因此，任何第三方攻擊（如暴力破解攻擊）實際上都是不可能的。此外，這種演算法稱為單向加密演算法。

理想的加密雜湊函式具有四個主要屬性 -

• 必須易於計算任何給定輸入的雜湊值。
• 必須難以從其雜湊值生成原始輸入。
• 必須難以修改輸入而不更改雜湊值。
• 必須難以找到兩個具有相同雜湊值的不同的輸入。

示例

考慮以下示例，它有助於使用十六進位制格式的字元匹配密碼。

import uuid
import hashlib
  
def hash_password(password):
   # userid is used to generate a random number
   salt = uuid.uuid4().hex #salt is stored in hexadecimal value
   return hashlib.sha256(salt.encode() + password.encode()).hexdigest() + ':' + salt
     
def check_password(hashed_password, user_password):
   # hexdigest is used as an algorithm for storing passwords
   password, salt = hashed_password.split(':')
   return password == hashlib.sha256(salt.encode()
      + user_password.encode()).hexdigest()

new_pass = raw_input('Please enter required password ')
hashed_password = hash_password(new_pass)
print('The string to store in the db is: ' + hashed_password)
old_pass = raw_input('Re-enter new password ')

if check_password(hashed_password, old_pass):
   print('Yuppie!! You entered the right password')
else:
   print('Oops! I am sorry but the password does not match')

流程圖

我們藉助以下流程圖解釋了此程式的邏輯 -

輸出

我們的程式碼將產生以下輸出 -

兩次輸入的密碼與雜湊函式匹配。這確保了兩次輸入的密碼是準確的，這有助於收集有用的資料並以加密格式儲存它們。

Python取證 - 破解加密

在本章中，我們將學習如何破解在分析和證據期間獲取的文字資料。

在密碼學中，明文是一些普通的可讀文字，例如訊息。另一方面，密文是在您輸入明文後獲取的加密演算法的輸出。

我們將明文訊息轉換為密文的簡單演算法是凱撒密碼，由尤利烏斯·凱撒發明，用於將其敵人保密。此密碼涉及將訊息中的每個字母在字母表中“向前”移動三個位置。

以下是一個演示說明。

a → D

b → E

c → F

....

w → Z

x → A

y → B

z → C

示例

執行Python指令碼時輸入的訊息提供所有字元的可能性，用於模式證據。

使用的模式證據型別如下 -

• 輪胎痕跡和標記
• 印記
• 指紋

每個生物識別資料都包含向量資料，我們需要破解這些資料以收集確鑿的證據。

以下 Python 程式碼展示瞭如何從純文字生成密文：

import sys

def decrypt(k,cipher): 
   plaintext = '' 
   
   for each in cipher: 
      p = (ord(each)-k) % 126 
      
      if p < 32: 
         p+=95 
         plaintext += chr(p) 
         print plaintext 

def main(argv):
   if (len(sys.argv) != 1): 
      sys.exit('Usage: cracking.py') 
      cipher = raw_input('Enter message: ') 
      
      for i in range(1,95,1): 
         decrypt(i,cipher)
         
if __name__ == "__main__": 
   main(sys.argv[1:])

輸出

現在，檢查此程式碼的輸出。當我們輸入簡單的文字“Radhika”時，程式將生成以下密文。

Python取證 - 虛擬化

虛擬化是指模擬 IT 系統（如伺服器、工作站、網路和儲存）的過程。它只不過是建立任何作業系統的虛擬版本，而不是實際版本，包括伺服器、儲存裝置或網路程序。

幫助模擬虛擬硬體的主要元件定義為管理程式。

下圖解釋了兩種主要型別的系統虛擬化。

虛擬化已在計算取證中以多種方式使用。它以這樣一種方式幫助分析師，即工作站可以在每次調查中都處於經過驗證的狀態。可以透過將驅動器的 dd 映像作為虛擬機器上的輔助驅動器來恢復資料，尤其如此。同一臺機器可以用作恢復軟體來收集證據。

以下示例有助於理解如何在 Python 程式語言的幫助下建立虛擬機器。

步驟 1 - 假設虛擬機器的名稱為“dummy1”。

每個虛擬機器至少必須具有 512 MB 的記憶體，以位元組表示。

vm_memory = 512 * 1024 * 1024

步驟 2 - 虛擬機器必須連線到已計算出的預設群集。

vm_cluster = api.clusters.get(name = "Default")

步驟 3 - 虛擬機器必須從虛擬硬碟驅動器啟動。

vm_os = params.OperatingSystem(boot = [params.Boot(dev = "hd")])

在使用 vms 集合的 add 方法將虛擬機器新增到虛擬機器之前，所有選項都組合到一個虛擬機器引數物件中。

示例

以下是新增虛擬機器的完整 Python 指令碼。

from ovirtsdk.api import API #importing API library
from ovirtsdk.xml import params

try: #Api credentials is required for virtual machine
   api = API(url = "https://HOST", 
      username = "Radhika", 
      password = "a@123", 
      ca_file = "ca.crt")
      
   vm_name = "dummy1"
   vm_memory = 512 * 1024 * 1024 #calculating the memory in bytes
   vm_cluster = api.clusters.get(name = "Default")
   vm_template = api.templates.get(name = "Blank")
   
   #assigning the parameters to operating system
   vm_os = params.OperatingSystem(boot = [params.Boot(dev = "hd")])
   
   vm_params = params.VM(name = vm_name,
      memory = vm_memory,
      cluster = vm_cluster,
      template = vm_template
      os = vm_os)

   try: 
      api.vms.add(vm = vm_params) 
      print "Virtual machine '%s' added." % vm_name #output if it is successful. 
   except Exception as ex: 
      print "Adding virtual machine '%s' failed: %s" % (vm_name, ex) 
      api.disconnect()
      
except Exception as ex: 
   print "Unexpected error: %s" % ex

輸出

我們的程式碼將產生以下輸出 -

Python取證 - 網路取證

現代網路環境的場景是這樣的，由於許多困難，調查可能會充滿挑戰。無論您是在響應違規支援、調查內部人員活動、執行漏洞評估還是驗證法規遵從性，都可能發生這種情況。

網路程式設計的概念

以下定義用於網路程式設計。

• 客戶端 - 客戶端是網路程式設計的客戶端-伺服器架構的一部分，它在個人電腦和工作站上執行。

• 伺服器 - 伺服器是客戶端-伺服器架構的一部分，它為同一臺或其他計算機中的其他計算機程式提供服務。

• WebSocket - WebSocket 在客戶端和伺服器之間提供一個協議，該協議在持久 TCP 連線上執行。透過此協議，可以在 TCP 套接字連線之間（同時）傳送雙向訊息。

WebSocket 出現在許多其他允許伺服器向客戶端傳送資訊的技術之後。除了握手升級標頭之外，WebSocket 與 HTTP 無關。

這些協議用於驗證第三方使用者傳送或接收的資訊。由於加密是用於保護訊息的方法之一，因此透過傳輸訊息的通道來確保安全也很重要。

考慮以下 Python 程式，客戶端使用它進行握手。

示例

# client.py
import socket

# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# get local machine name
host = socket.gethostname()
port = 8080

# connection to hostname on the port.
s.connect((host, port))

# Receive no more than 1024 bytes
tm = s.recv(1024)
print("The client is waiting for connection")
s.close()

輸出

它將產生以下輸出：

接受通訊通道請求的伺服器將包含以下指令碼。

# server.py
import socket
import time

# create a socket object
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# get local machine name 
host = socket.gethostname()
port = 8080

# bind to the port
serversocket.bind((host, port))

# queue up to 5 requests 
serversocket.listen(5)

while True:
   # establish a connection 
   clientsocket,addr = serversocket.accept()
   print("Got a connection from %s" % str(addr))
   currentTime = time.ctime(time.time()) + "\r\n"
   clientsocket.send(currentTime.encode('ascii'))
   clientsocket.close()

使用 Python 程式設計建立的客戶端和伺服器偵聽主機號。最初，客戶端向伺服器傳送有關主機號中傳送資料的請求，伺服器接受該請求並立即傳送響應。這樣，我們就可以擁有一個安全的通訊通道。

Python取證 - Python 模組

Python 程式中的模組有助於組織程式碼。它們有助於將相關程式碼分組到單個模組中，這使得更容易理解和使用。它包含任意命名的值，可用於繫結和引用。簡單來說，模組是一個包含 Python 程式碼的檔案，其中包含函式、類和變數。

模組（檔案）的 Python 程式碼以.py副檔名儲存，並在需要時進行編譯。

示例

def print_hello_func( par ): 
   print "Hello : ", par 
   return

匯入語句

透過執行import語句，可以將 Python 原始檔用作模組，該語句匯入其他包或第三方庫。使用的語法如下：

import module1[, module2[,... moduleN]

當 Python 直譯器遇到 import 語句時，它會匯入指定的模組，該模組位於搜尋路徑中。

示例

考慮以下示例。

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Radhika")

它將產生以下輸出：

模組僅載入一次，無論 Python 程式碼已匯入多少次。

From...import 語句

From屬性有助於將模組中的特定屬性匯入到當前名稱空間中。以下是其語法。

from modname import name1[, name2[, ... nameN]]

示例

要從模組fib匯入函式fibonacci，請使用以下語句。

from fib import fibonacci

查詢模組

匯入模組時，Python 直譯器會搜尋以下序列：

• 當前目錄。

• 如果模組不存在，則 Python 會搜尋 shell 變數 PYTHONPATH 中的每個目錄。

• 如果 shell 變數位置失敗，則 Python 會檢查預設路徑。

計算取證使用 Python 模組和第三方模組來獲取資訊並更輕鬆地提取證據。後面的章節重點介紹模組的實現以獲取必要的輸出。

Python取證 - Dshell 和 Scapy

DShell

Dshell是一個基於 Python 的網路取證分析工具包。該工具包由美國陸軍研究實驗室開發。此開源工具包於 2014 年釋出。該工具包的主要重點是簡化取證調查。

該工具包包含大量解碼器，如下表所示。

美國陸軍實驗室已在 GitHub 中維護克隆儲存庫，連結如下：

https://github.com/USArmyResearchLab/Dshell

克隆包含一個用於安裝此工具包的指令碼install-ubuntu.py ()。

安裝成功後，它將自動構建稍後將使用的可執行檔案和依賴項。

依賴項如下：

dependencies = { 
   "Crypto": "crypto", 
   "dpkt": "dpkt", 
   "IPy": "ipy", 
   "pcap": "pypcap" 
}

此工具包可用於 pcap（資料包捕獲）檔案，這些檔案通常在事件期間或警報期間記錄。這些 pcap 檔案是由 Linux 平臺上的 libpcap 或 Windows 平臺上的 WinPcap 建立的。

Scapy

Scapy 是一個基於 Python 的工具，用於分析和操作網路流量。以下是 Scapy 工具包的連結：

http://www.secdev.org/projects/scapy/

此工具包用於分析資料包操作。它非常能夠解碼大量協議的資料包並捕獲它們。Scapy 與 Dshell 工具包的不同之處在於，它為調查人員提供了有關網路流量的詳細描述。這些描述已即時記錄。

Scapy 能夠使用第三方工具或作業系統指紋進行繪圖。

考慮以下示例。

import scapy, GeoIP #Imports scapy and GeoIP toolkit 
from scapy import * 
geoIp = GeoIP.new(GeoIP.GEOIP_MEMORY_CACHE) #locates the Geo IP address 
def locatePackage(pkg): 
src = pkg.getlayer(IP).src #gets source IP address 
dst = pkg.getlayer(IP).dst #gets destination IP address 
srcCountry = geoIp.country_code_by_addr(src) #gets Country details of source 
dstCountry = geoIp.country_code_by_addr(dst) #gets country details of destination 
print src+"("+srcCountry+") >> "+dst+"("+dstCountry+")\n"

此指令碼詳細描述了網路資料包中相互通訊的國家/地區的詳細資訊。

上述指令碼將產生以下輸出。

Python取證 - 搜尋

搜尋無疑是取證調查的支柱之一。如今，搜尋的質量取決於執行證據的調查員。

從訊息中搜索關鍵字在取證中起著至關重要的作用，當我們使用關鍵字搜尋證據時。瞭解在特定檔案中以及已刪除檔案中需要搜尋的內容，需要經驗和知識。

Python 具有各種內建機制以及標準庫模組來支援搜尋操作。從根本上說，調查人員使用搜索操作來查詢諸如“誰”、“什麼”、“在哪裡”、“何時”等問題的答案。

示例

在以下示例中，我們聲明瞭兩個字串，然後使用 find 函式檢查第一個字串是否包含第二個字串。

# Searching a particular word from a message
str1 = "This is a string example for Computational forensics of gathering evidence!";
str2 = "string";

print str1.find(str2)
print str1.find(str2, 10)
print str1.find(str2, 40)

上述指令碼將產生以下輸出。

Python 中的“find”函式有助於在訊息或段落中搜索關鍵字。這對於收集適當的證據至關重要。

Python取證 - 索引

索引實際上使調查員能夠全面檢視檔案並從中收集潛在的證據。證據可能包含在檔案、磁碟映像、記憶體快照或網路跟蹤中。

索引有助於減少耗時任務（如關鍵字搜尋）的時間。取證調查還涉及互動式搜尋階段，其中索引用於快速定位關鍵字。

索引還有助於將關鍵字列在排序列表中。

示例

以下示例顯示瞭如何在 Python 中使用索引。

aList = [123, 'sample', 'zara', 'indexing'];

print "Index for sample : ", aList.index('sample')
print "Index for indexing : ", aList.index('indexing')

str1 = "This is sample message for forensic investigation indexing";
str2 = "sample";

print "Index of the character keyword found is " 
print str1.index(str2)

上述指令碼將產生以下輸出。

Python取證 - Python 影像庫

從可用資源中提取有價值的資訊是數字取證的重要組成部分。訪問所有可用資訊對於調查過程至關重要，因為它有助於檢索適當的證據。

包含資料的資源可以是簡單的資料庫等資料結構，也可以是複雜的 JPEG 影像等資料結構。簡單的結構可以使用簡單的桌面工具輕鬆訪問，而從複雜的資料結構中提取資訊則需要複雜的程式設計工具。

Python影像庫

Python 影像處理庫 (PIL) 為您的 Python 直譯器添加了影像處理功能。該庫支援多種檔案格式，並提供了強大的影像處理和圖形功能。您可以從以下網址下載 PIL 的原始檔：http://www.pythonware.com/products/pil/

下圖顯示了使用 PIL 從影像（複雜資料結構）中提取資料的完整流程圖。

示例

現在，讓我們透過一個程式設計示例來了解它是如何工作的。

步驟 1 − 假設我們有以下影像，我們需要從中提取資訊。

步驟 2 − 當我們使用 PIL 開啟此影像時，它首先會記錄提取證據所需的關鍵點，包括各種畫素值。以下是開啟影像並記錄其畫素值的程式碼 −

from PIL import Image
im = Image.open('Capture.jpeg', 'r')
pix_val = list(im.getdata())
pix_val_flat = [x for sets in pix_val for x in sets]
print pix_val_flat

步驟 3 − 在提取影像的畫素值後，我們的程式碼將產生以下輸出。

提供的輸出表示 RGB 組合的畫素值，這更清楚地說明了證據所需的資料。提取的資料以陣列的形式表示。

Python 取證 - 移動取證

對標準計算機硬體（如硬碟）進行取證調查和分析已經發展成為一個穩定的學科，並透過分析非標準硬體或瞬態證據的技術來實現。

儘管智慧手機在數字調查中越來越普遍，但它們仍然被視為非標準的。

取證分析

取證調查搜尋諸如從智慧手機接收或撥打的電話、簡訊、照片或任何其他可能構成犯罪證據的資料。大多數智慧手機都具有使用密碼或字母數字字元的螢幕鎖定功能。

在這裡，我們將舉一個例子來說明 Python 如何幫助破解螢幕鎖定密碼以檢索智慧手機中的資料。

手動檢查

Android 支援使用 PIN 碼或字母數字密碼進行密碼鎖定。兩種密碼的長度都要求在 4 到 16 位數字或字元之間。智慧手機的密碼儲存在 Android 系統中的一個名為 password.key 的特殊檔案中，位於 /data/system 目錄下。

Android 儲存密碼的加鹽 SHA1 雜湊和 MD5 雜湊。這些密碼可以使用以下程式碼進行處理。

public byte[] passwordToHash(String password) {

   if (password == null) { 
      return null; 
   }

   String algo = null;
   byte[] hashed = null;

   try { 
      byte[] saltedPassword = (password + getSalt()).getBytes(); 
      byte[] sha1 = MessageDigest.getInstance(algo = "SHA-1").digest(saltedPassword);
      byte[] md5 = MessageDigest.getInstance(algo = "MD5").digest(saltedPassword); 
      hashed = (toHex(sha1) + toHex(md5)).getBytes(); 
   } catch (NoSuchAlgorithmException e) { 
      Log.w(TAG, "Failed to encode string because of missing algorithm: " + algo); 
   }
   
   return hashed;
}

由於雜湊密碼儲存在 salt 檔案中，因此無法使用 字典攻擊來破解密碼。此 salt 是一個 64 位隨機整數的十六進位制表示字串。使用 Root 智慧手機或 JTAG 介面卡可以輕鬆訪問 salt。

Root 智慧手機

檔案 /data/system/password.key 的轉儲儲存在 SQLite 資料庫中，位於 lockscreen.password_salt 金鑰下。在 settings.db 中，儲存了密碼，並且其值在以下螢幕截圖中清晰可見。

JTAG 介面卡

可以使用稱為 JTAG（聯合測試行動組）介面卡的特殊硬體來訪問 salt。類似地，Riff-Box 或 JIG-介面卡也可以用於相同的功能。

使用從 Riff-box 獲得的資訊，我們可以找到加密資料的所在位置，即 salt。規則如下 −

• 搜尋關聯字串“lockscreen.password_salt”。

• 位元組表示鹽的實際寬度，即它的 長度。

• 這實際上是搜尋以獲取智慧手機儲存的密碼/PIN 的長度。

這套規則有助於獲取正確的 salt 資料。

Python 取證 - 網路時間協議

網路時間協議 (NTP) 是最廣泛使用的用於時間同步的協議，並且已被廣泛接受為一種實踐。

NTP 使用使用者資料報協議 (UDP)，該協議使用最少的時間在希望與給定時間源同步的伺服器和客戶端之間通訊資料包。

網路時間協議的功能如下 −

• 預設伺服器埠為 123。

• 該協議包含許多與國家實驗室同步的可訪問時間伺服器。

• NTP 協議標準由 IETF 監管，建議標準為 RFC 5905，標題為“網路時間協議版本 4：協議和演算法規範”[NTP RFC]

• 作業系統、程式和應用程式使用 NTP 以正確的方式同步時間。

在本章中，我們將重點關注 NTP 與 Python 的用法，這可以透過第三方 Python 庫 ntplib 實現。該庫有效地處理了繁重的工作，並將結果與我的本地系統時鐘進行比較。

安裝 NTP 庫

ntplib 可從 https://pypi.python.org/pypi/ntplib/ 下載，如下圖所示。

該庫為 NTP 伺服器提供了簡單的介面，並提供了可以轉換 NTP 協議欄位的方法。這有助於訪問其他關鍵值，例如閏秒。

以下 Python 程式有助於理解 NTP 的用法。

import ntplib
import time

NIST = 'nist1-macon.macon.ga.us'
ntp = ntplib.NTPClient()
ntpResponse = ntp.request(NIST)

if (ntpResponse):
   now = time.time()
   diff = now-ntpResponse.tx_time
   print diff;

上述程式將產生以下輸出。

上述程式計算了時間差。這些計算有助於取證調查。獲得的網路資料與硬碟上發現的資料分析從根本上不同。

時區的差異或獲取準確的時區可以幫助收集透過此協議捕獲訊息的證據。

Python 取證 - 多處理支援

取證專家通常發現很難應用數字解決方案來分析普通犯罪中大量數字證據。大多數數字調查工具都是單執行緒的，一次只能執行一個命令。

在本章中，我們將重點關注 Python 的多處理功能，這與常見的取證挑戰相關。

多處理

多處理定義為計算機系統支援多個程序的能力。支援多處理的作業系統允許多個程式併發執行。

有多種型別的多處理，例如 對稱和 非對稱處理。下圖指的是對稱多處理系統，這通常在取證調查中遵循。

示例

以下程式碼顯示了 Python 程式設計中如何在內部列出不同的程序。

import random
import multiprocessing

def list_append(count, id, out_list): 
   #appends the count of number of processes which takes place at a time
   for i in range(count):
      out_list.append(random.random())
         
   if __name__ == "__main__": 
      size = 999  
      procs = 2
      # Create a list of jobs and then iterate through 
      # the number of processes appending each process to 
      # the job list  
      jobs = []
         
   for i in range(0, procs): 
      out_list = list() #list of processes 
      process1 = multiprocessing.Process(
         target = list_append, args = (size, i, out_list))

      # appends the list of processes
      jobs.append(process)

   # Calculate the random number of processes
   for j in jobs:
      j.start()  #initiate the process

   # After the processes have finished execution
   for j in jobs:
      j.join()
      print "List processing complete."

這裡，函式 list_append() 用於列出系統中的程序集。

輸出

我們的程式碼將產生以下輸出 -

Python 取證 - 記憶體和取證

在本章中，我們將重點關注使用 Volatility（一個基於 Python 的取證框架，適用於以下平臺：Android 和 Linux）調查易失性記憶體。

易失性記憶體

易失性記憶體是一種儲存型別，當系統電源關閉或中斷時，其內容將被擦除。RAM 是易失性記憶體的最佳示例。這意味著，如果您正在處理尚未儲存到非易失性記憶體（例如硬碟）的文件，並且計算機斷電，則所有資料都將丟失。

通常，易失性記憶體取證遵循與其他取證調查相同的模式 −

• 選擇調查目標
• 獲取取證資料
• 取證分析

用於 Android 的基本 volatility 外掛收集 RAM 轉儲以進行分析。一旦收集了 RAM 轉儲以進行分析，就必須開始在 RAM 中搜索惡意軟體。

YARA 規則

YARA 是一種流行的工具，它提供了一種強大的語言，與基於 Perl 的正則表示式相容，並且用於檢查可疑檔案/目錄並匹配字串。

在本節中，我們將使用基於模式匹配實現的 YARA 並將其與實用程式功能結合起來。整個過程將有利於取證分析。

示例

考慮以下程式碼。此程式碼有助於提取程式碼。

import operator
import os
import sys

sys.path.insert(0, os.getcwd())
import plyara.interp as interp

# Plyara is a script that lexes and parses a file consisting of one more Yara
# rules into a python dictionary representation.
if __name__ == '__main__': 
   file_to_analyze = sys.argv[1] 
   rulesDict = interp.parseString(open(file_to_analyze).read()) 
   authors = {} 
   imps = {} 
   meta_keys = {} 
   max_strings = [] 
   max_string_len = 0 
   tags = {} 
   rule_count = 0  

   for rule in rulesDict: 
      rule_count += 1  
   
   # Imports 
   if 'imports' in rule: 
      for imp in rule['imports']: 
         imp = imp.replace('"','') 
         
         if imp in imps: 
            imps[imp] += 1 
         else: 
            imps[imp] = 1  
   # Tags 
   if 'tags' in rule: 
      for tag in rule['tags']: 
         if tag in tags: 
            tags[tag] += 1 
         else: 
            tags[tag] = 1
            
   # Metadata 
   if 'metadata' in rule: 
      for key in rule['metadata']: 
         if key in meta_keys: 
            meta_keys[key] += 1
         else: 
            meta_keys[key] = 1 
         
         if key in ['Author', 'author']: 
            if rule['metadata'][key] in authors: 
               authors[rule['metadata'][key]] += 1 
            else: 
               authors[rule['metadata'][key]] = 1  

   #Strings 
   if 'strings' in rule: 
      for strr in rule['strings']: 
         if len(strr['value']) > max_string_len: 
            max_string_len = len(strr['value']) 
            max_strings = [(rule['rule_name'], strr['name'], strr['value'])] 
         elif len(strr['value']) == max_string_len: 
            max_strings.append((rule['rule_name'], strr['key'], strr['value']))  
   
   print("\nThe number of rules implemented" + str(rule_count))
   ordered_meta_keys = sorted(meta_keys.items(), key = operator.itemgetter(1),
      reverse = True)
   ordered_authors = sorted(authors.items(), key = operator.itemgetter(1), 
      reverse = True)
   ordered_imps = sorted(imps.items(), key = operator.itemgetter(1), reverse = True)
   ordered_tags = sorted(tags.items(), key = operator.itemgetter(1), reverse = True)

上述程式碼將產生以下輸出。

實施的 YARA 規則數量有助於更好地瞭解可疑檔案。間接地，可疑檔案的列表有助於收集取證所需的資訊。

以下是 github 中的原始碼：https://github.com/radhikascs/Python_yara

Linux 中的 Python 取證

數字調查的主要關注點是使用加密或任何其他格式來保護重要證據或資料。最基本的例子是儲存密碼。因此，有必要了解 Linux 作業系統的用法，以便在數字取證實施中保護這些寶貴的資料。

所有本地使用者的資訊主要儲存在以下兩個檔案中 −

• /etc/passwd
• etc/shadow

第一個檔案是強制性的，它儲存所有密碼。第二個檔案是可選的，它儲存有關本地使用者的資訊，包括雜湊密碼。

將密碼資訊儲存在每個使用者都可以讀取的檔案中會引發安全問題。因此，雜湊密碼儲存在 /etc/passwd 中，其中內容被替換為特殊值“x”。

相應的雜湊必須在 /etc/shadow 中查詢。/etc/passwd 中的設定可能會覆蓋 /etc/shadow 中的詳細資訊。

Linux 中的這兩個文字檔案每行包含一個條目，並且條目由多個欄位組成，用冒號分隔。

/etc/passwd 的格式如下 −

如果雜湊密碼儲存為空，則相應的使用者無需任何密碼即可登入系統。如果此欄位包含無法由雜湊演算法生成的的值，例如感嘆號，則使用者無法使用密碼登入。

具有鎖定密碼的使用者仍然可以使用其他身份驗證機制登入，例如 SSH 金鑰。如前所述，特殊值“x”表示必須在 shadow 檔案中查詢密碼雜湊。

密碼雜湊包含以下內容 −

• 加密鹽 − 加密鹽有助於維護螢幕鎖定、PIN 碼和密碼。

• 數值使用者 ID − 此欄位表示使用者的 ID。Linux 核心將此使用者 ID 分配給系統。

• 數值組 ID − 此欄位指的是使用者的首要組。

• 主目錄 − 新程序以對該目錄的引用啟動。

• 命令 shell − 此可選欄位表示在成功登入系統後要啟動的預設 shell。

數字取證包括收集與跟蹤證據相關的資訊。因此，使用者 ID 有助於維護記錄。

使用 Python，可以自動分析所有這些資訊以獲取分析指標，重建最近的系統活動。透過 Linux Shell 的實現，跟蹤變得簡單易行。

Python 與 Linux 程式設計

示例

import sys
import hashlib
import getpass

def main(argv):
   print '\nUser & Password Storage Program in Linux for forensic detection v.01\n' 
  
   if raw_input('The file ' + sys.argv[1] + ' will be erased or overwrite if 
         it exists .\nDo you wish to continue (Y/n): ') not in ('Y','y') : 
   sys.exit('\nChanges were not recorded\n') 
  
   user_name = raw_input('Please Enter a User Name: ')
   password = hashlib.sha224(getpass.getpass('Please Enter a Password:')).hexdigest()
   
   # Passwords which are hashed  
   try: 
      file_conn = open(sys.argv[1],'w') 
      file_conn.write(user_name + '\n') 
      file_conn.write(password + '\n') 
      file_conn.close() 
   except: 
      sys.exit('There was a problem writing the passwords to file!')
      
if __name__ == "__main__": 
   main(sys.argv[1:])

輸出

密碼以十六進位制格式儲存在 pass_db.txt 中，如下面的螢幕截圖所示。文字檔案被儲存以供在計算取證中進一步使用。

Python 取證 - 妥協指標

妥協指標 (IOC) 定義為“取證資料片段，其中包括在系統日誌條目或檔案中找到的資料，這些資料識別系統或網路上可能存在惡意活動的活動”。

透過監控 IOC，組織可以檢測攻擊並迅速採取行動，防止此類違規行為發生或透過在早期階段阻止攻擊來限制損害。

有一些用例允許查詢取證工件，例如 −

• 按 MD5 查詢特定檔案
• 搜尋儲存在記憶體中的特定實體
• 儲存在 Windows 登錄檔中的特定條目或條目集

上述所有方法的結合在搜尋工件方面提供了更好的結果。如上所述，Windows登錄檔為生成和維護IOC提供了完美的平臺，這直接有助於計算取證。

方法

• 查詢檔案系統中的位置，特別是現在Windows登錄檔中的位置。

• 搜尋由取證工具設計的工件集。

• 尋找任何不利活動的跡象。

調查生命週期

調查生命週期遵循IOC，並在登錄檔中搜索特定條目。

• 階段1：初始證據 - 在主機或網路上檢測到入侵的證據。響應者將調查並確定確切的解決方案，這是一個具體的取證指標。

• 階段2：為主機和網路建立IOC - 遵循收集的資料，建立IOC，這可以透過Windows登錄檔輕鬆實現。OpenIOC的靈活性為如何構建指標提供了無限數量的排列組合。

• 階段3：在企業中部署IOC - 建立指定的IOC後，調查人員將在Windows登錄檔中藉助API部署這些技術。

• 階段4：識別嫌疑人 - IOC的部署有助於以正常方式識別嫌疑人。甚至會識別出其他系統。

• 階段5：收集和分析證據 - 針對嫌疑人的證據會被收集並相應地進行分析。

• 階段6：完善和建立新的IOC - 調查小組可以根據他們在企業中發現的證據和資料以及其他情報建立新的IOC，並繼續完善他們的迴圈。

下圖顯示了調查生命週期的階段 -

Python取證 - 雲的實現

雲計算可以定義為透過網際網路向用戶提供的一組託管服務。它使組織能夠使用或甚至計算資源，包括虛擬機器（VM）、儲存或應用程式作為實用程式。

使用Python程式語言構建應用程式最重要的優勢之一是它包括能夠在任何平臺上虛擬部署應用程式的能力，其中也包括雲。這意味著Python可以在雲伺服器上執行，也可以在方便的裝置上啟動，例如桌面、平板電腦或智慧手機。

一個有趣的視角是建立基於雲的彩虹表生成。它有助於整合應用程式的單處理和多處理版本，這需要一些考慮。

Pi雲

Pi雲是一個雲計算平臺，它將Python程式語言與Amazon Web Services的計算能力相結合。

讓我們來看一個使用彩虹表實現Pi雲的示例。

彩虹表

彩虹表定義為特定雜湊演算法加密密碼的所有可能的明文排列的列表。

• 彩虹表遵循一個標準模式，該模式建立了一個雜湊密碼列表。

• 一個文字檔案用於生成密碼，其中包括要加密的密碼的字元或明文。

• Pi雲使用該檔案，呼叫要儲存的主函式。

• 雜湊密碼的輸出也儲存在文字檔案中。

此演算法也可用於將密碼儲存到資料庫中，並在雲系統中擁有備份儲存。

以下內建程式在文字檔案中建立加密密碼列表。

示例

import os
import random
import hashlib
import string
import enchant    #Rainbow tables with enchant 
import cloud      #importing pi-cloud

def randomword(length): 
   return ''.join(random.choice(string.lowercase) for i in range(length))

print('Author- Radhika Subramanian')

def mainroutine():
   engdict = enchant.Dict("en_US")
   fileb = open("password.txt","a+")

   # Capture the values from the text file named password
   while True:
      randomword0 = randomword(6)
      if engdict.check(randomword0) == True:
         randomkey0 = randomword0+str(random.randint(0,99))
      elif engdict.check(randomword0) == False:
         englist = engdict.suggest(randomword0)
         if len(englist) > 0:
            randomkey0 = englist[0]+str(random.randint(0,99))
         else:
            randomkey0 = randomword0+str(random.randint(0,99))

      randomword3 = randomword(5)
      if engdict.check(randomword3) == True:
         randomkey3 = randomword3+str(random.randint(0,99))
      elif engdict.check(randomword3) == False:
         englist = engdict.suggest(randomword3)
         if len(englist) > 0:
            randomkey3 = englist[0]+str(random.randint(0,99))
         else:
            randomkey3 = randomword3+str(random.randint(0,99))
      
      if 'randomkey0' and 'randomkey3' and 'randomkey1' in locals():
         whasher0 = hashlib.new("md5")
         whasher0.update(randomkey0)
         whasher3 = hashlib.new("md5")
         whasher3.update(randomkey3)
         whasher1 = hashlib.new("md5")
         whasher1.update(randomkey1)
         print(randomkey0+" + "+str(whasher0.hexdigest())+"\n")
         print(randomkey3+" + "+str(whasher3.hexdigest())+"\n")
         print(randomkey1+" + "+str(whasher1.hexdigest())+"\n")
         fileb.write(randomkey0+" + "+str(whasher0.hexdigest())+"\n") 
         fileb.write(randomkey3+" + "+str(whasher3.hexdigest())+"\n")
         fileb.write(randomkey1+" + "+str(whasher1.hexdigest())+"\n")

jid = cloud.call(randomword)  #square(3) evaluated on PiCloud
cloud.result(jid)
print('Value added to cloud')
print('Password added')
mainroutine()

輸出

此程式碼將產生以下輸出 -

密碼儲存在文字檔案中，如以下螢幕截圖所示。