Wichtige Artefakte in Windows-III
In diesem Kapitel werden weitere Artefakte erläutert, die ein Ermittler während der forensischen Analyse unter Windows erhalten kann.
Ereignisprotokolle
Windows-Ereignisprotokolldateien sind als Namensempfehlungen spezielle Dateien, in denen wichtige Ereignisse gespeichert werden, z. B. wenn sich Benutzer am Computer anmelden, wenn ein Programmfehler auftritt, Systemänderungen, RDP-Zugriff, anwendungsspezifische Ereignisse usw. Cyber-Ermittler sind immer an Ereignissen interessiert Protokollinformationen, da sie viele nützliche historische Informationen zum Zugriff auf das System enthalten. Im folgenden Python-Skript werden sowohl ältere als auch aktuelle Windows-Ereignisprotokollformate verarbeitet.
Für Python-Skripte müssen wir nämlich Module von Drittanbietern installieren pytsk3, pyewf, unicodecsv, pyevt and pyevtx. Wir können die folgenden Schritte ausführen, um Informationen aus Ereignisprotokollen zu extrahieren.
Suchen Sie zunächst nach allen Ereignisprotokollen, die dem Eingabeargument entsprechen.
Führen Sie dann die Überprüfung der Dateisignatur durch.
Verarbeiten Sie nun jedes gefundene Ereignisprotokoll mit der entsprechenden Bibliothek.
Zuletzt schreiben Sie die Ausgabe in eine Tabelle.
Python-Code
Lassen Sie uns sehen, wie Python-Code für diesen Zweck verwendet wird -
Importieren Sie zunächst die folgenden Python-Bibliotheken:
from __future__ import print_function
import argparse
import unicodecsv as csv
import os
import pytsk3
import pyewf
import pyevt
import pyevtx
import sys
from utility.pytskutil import TSKUtilGeben Sie nun die Argumente für den Befehlszeilenhandler an. Beachten Sie, dass hier drei Argumente akzeptiert werden: Erstens der Pfad zur Beweisdatei, zweitens der Typ der Beweisdatei und drittens der Name des zu verarbeitenden Ereignisprotokolls.
if __name__ == "__main__":
parser = argparse.ArgumentParser('Information from Event Logs')
parser.add_argument("EVIDENCE_FILE", help = "Evidence file path")
parser.add_argument("TYPE", help = "Type of Evidence",choices = ("raw", "ewf"))
parser.add_argument(
"LOG_NAME",help = "Event Log Name (SecEvent.Evt, SysEvent.Evt, ""etc.)")
parser.add_argument(
"-d", help = "Event log directory to scan",default = "/WINDOWS/SYSTEM32/WINEVT")
parser.add_argument(
"-f", help = "Enable fuzzy search for either evt or"" evtx extension", action = "store_true")
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.LOG_NAME, args.d, args.f)
else:
print("[-] Supplied input file {} does not exist or is not a ""file".format(args.EVIDENCE_FILE))
sys.exit(1)Interagieren Sie jetzt mit Ereignisprotokollen, um die Existenz des vom Benutzer angegebenen Pfads abzufragen, indem Sie unseren erstellen TSKUtilObjekt. Dies kann mit Hilfe von geschehenmain() Methode wie folgt -
def main(evidence, image_type, log, win_event, fuzzy):
tsk_util = TSKUtil(evidence, image_type)
event_dir = tsk_util.query_directory(win_event)
if event_dir is not None:
if fuzzy is True:
event_log = tsk_util.recurse_files(log, path=win_event)
else:
event_log = tsk_util.recurse_files(log, path=win_event, logic="equal")
if event_log is not None:
event_data = []
for hit in event_log:
event_file = hit[2]
temp_evt = write_file(event_file)Jetzt müssen wir eine Signaturüberprüfung durchführen und anschließend eine Methode definieren, mit der der gesamte Inhalt in das aktuelle Verzeichnis geschrieben wird.
def write_file(event_file):
with open(event_file.info.name.name, "w") as outfile:
outfile.write(event_file.read_random(0, event_file.info.meta.size))
return event_file.info.name.name
if pyevt.check_file_signature(temp_evt):
evt_log = pyevt.open(temp_evt)
print("[+] Identified {} records in {}".format(
evt_log.number_of_records, temp_evt))
for i, record in enumerate(evt_log.records):
strings = ""
for s in record.strings:
if s is not None:
strings += s + "\n"
event_data.append([
i, hit[0], record.computer_name,
record.user_security_identifier,
record.creation_time, record.written_time,
record.event_category, record.source_name,
record.event_identifier, record.event_type,
strings, "",
os.path.join(win_event, hit[1].lstrip("//"))
])
elif pyevtx.check_file_signature(temp_evt):
evtx_log = pyevtx.open(temp_evt)
print("[+] Identified {} records in {}".format(
evtx_log.number_of_records, temp_evt))
for i, record in enumerate(evtx_log.records):
strings = ""
for s in record.strings:
if s is not None:
strings += s + "\n"
event_data.append([
i, hit[0], record.computer_name,
record.user_security_identifier, "",
record.written_time, record.event_level,
record.source_name, record.event_identifier,
"", strings, record.xml_string,
os.path.join(win_event, hit[1].lstrip("//"))
])
else:
print("[-] {} not a valid event log. Removing temp" file...".format(temp_evt))
os.remove(temp_evt)
continue
write_output(event_data)
else:
print("[-] {} Event log not found in {} directory".format(log, win_event))
sys.exit(3)
else:
print("[-] Win XP Event Log Directory {} not found".format(win_event))
sys.exit(2Definieren Sie abschließend eine Methode zum Schreiben der Ausgabe in eine Tabelle wie folgt:
def write_output(data):
output_name = "parsed_event_logs.csv"
print("[+] Writing {} to current working directory: {}".format(
output_name, os.getcwd()))
with open(output_name, "wb") as outfile:
writer = csv.writer(outfile)
writer.writerow([
"Index", "File name", "Computer Name", "SID",
"Event Create Date", "Event Written Date",
"Event Category/Level", "Event Source", "Event ID",
"Event Type", "Data", "XML Data", "File Path"
])
writer.writerows(data)Sobald Sie das obige Skript erfolgreich ausgeführt haben, erhalten wir die Informationen zum Ereignisprotokoll in der Tabelle.
Internet-Geschichte
Die Internet-Historie ist für forensische Analysten sehr nützlich. da die meisten Cyber-Verbrechen nur über das Internet geschehen. Lassen Sie uns sehen, wie Sie den Internetverlauf aus dem Internet Explorer extrahieren, während wir uns mit Windows-Forensik befassen. Internet Explorer wird standardmäßig mit Windows geliefert.
Im Internet Explorer wird der Internetverlauf in gespeichert index.datDatei. Schauen wir uns ein Python-Skript an, aus dem die Informationen extrahiert werdenindex.dat Datei.
Wir können die folgenden Schritte ausführen, um Informationen daraus zu extrahieren index.dat Dateien -
Suchen Sie zunächst nach index.dat Dateien innerhalb des Systems.
Extrahieren Sie dann die Informationen aus dieser Datei, indem Sie sie durchlaufen.
Schreiben Sie nun alle diese Informationen in einen CSV-Bericht.
Python-Code
Lassen Sie uns sehen, wie Python-Code für diesen Zweck verwendet wird -
Importieren Sie zunächst die folgenden Python-Bibliotheken:
from __future__ import print_function
import argparse
from datetime import datetime, timedelta
import os
import pytsk3
import pyewf
import pymsiecf
import sys
import unicodecsv as csv
from utility.pytskutil import TSKUtilGeben Sie nun Argumente für den Befehlszeilenhandler an. Beachten Sie, dass hier zwei Argumente akzeptiert werden - erstens der Pfad zur Beweisdatei und zweitens der Typ der Beweisdatei -
if __name__ == "__main__":
parser = argparse.ArgumentParser('getting information from internet history')
parser.add_argument("EVIDENCE_FILE", help = "Evidence file path")
parser.add_argument("TYPE", help = "Type of Evidence",choices = ("raw", "ewf"))
parser.add_argument("-d", help = "Index.dat directory to scan",default = "/USERS")
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.d)
else:
print("[-] Supplied input file {} does not exist or is not a ""file".format(args.EVIDENCE_FILE))
sys.exit(1)Interpretieren Sie nun die Beweisdatei, indem Sie ein Objekt von erstellen TSKUtilund iterieren Sie durch das Dateisystem, um index.dat-Dateien zu finden. Dies kann durch Definieren dermain() Funktion wie folgt -
def main(evidence, image_type, path):
tsk_util = TSKUtil(evidence, image_type)
index_dir = tsk_util.query_directory(path)
if index_dir is not None:
index_files = tsk_util.recurse_files("index.dat", path = path,logic = "equal")
if index_files is not None:
print("[+] Identified {} potential index.dat files".format(len(index_files)))
index_data = []
for hit in index_files:
index_file = hit[2]
temp_index = write_file(index_file)Definieren Sie nun eine Funktion, mit deren Hilfe wir die Informationen der Datei index.dat in das aktuelle Arbeitsverzeichnis kopieren und später von einem Drittanbieter-Modul verarbeiten können -
def write_file(index_file):
with open(index_file.info.name.name, "w") as outfile:
outfile.write(index_file.read_random(0, index_file.info.meta.size))
return index_file.info.name.nameVerwenden Sie nun den folgenden Code, um die Signaturüberprüfung mit Hilfe der integrierten Funktion durchzuführen check_file_signature() - -
if pymsiecf.check_file_signature(temp_index):
index_dat = pymsiecf.open(temp_index)
print("[+] Identified {} records in {}".format(
index_dat.number_of_items, temp_index))
for i, record in enumerate(index_dat.items):
try:
data = record.data
if data is not None:
data = data.rstrip("\x00")
except AttributeError:
if isinstance(record, pymsiecf.redirected):
index_data.append([
i, temp_index, "", "", "", "", "",record.location, "", "", record.offset,os.path.join(path, hit[1].lstrip("//"))])
elif isinstance(record, pymsiecf.leak):
index_data.append([
i, temp_index, record.filename, "","", "", "", "", "", "", record.offset,os.path.join(path, hit[1].lstrip("//"))])
continue
index_data.append([
i, temp_index, record.filename,
record.type, record.primary_time,
record.secondary_time,
record.last_checked_time, record.location,
record.number_of_hits, data, record.offset,
os.path.join(path, hit[1].lstrip("//"))
])
else:
print("[-] {} not a valid index.dat file. Removing "
"temp file..".format(temp_index))
os.remove("index.dat")
continue
os.remove("index.dat")
write_output(index_data)
else:
print("[-] Index.dat files not found in {} directory".format(path))
sys.exit(3)
else:
print("[-] Directory {} not found".format(win_event))
sys.exit(2)Definieren Sie nun eine Methode, mit der die Ausgabe in einer CSV-Datei gedruckt wird (siehe unten).
def write_output(data):
output_name = "Internet_Indexdat_Summary_Report.csv"
print("[+] Writing {} with {} parsed index.dat files to current "
"working directory: {}".format(output_name, len(data),os.getcwd()))
with open(output_name, "wb") as outfile:
writer = csv.writer(outfile)
writer.writerow(["Index", "File Name", "Record Name",
"Record Type", "Primary Date", "Secondary Date",
"Last Checked Date", "Location", "No. of Hits",
"Record Data", "Record Offset", "File Path"])
writer.writerows(data)Nachdem wir das obige Skript ausgeführt haben, erhalten wir die Informationen aus der Datei index.dat in der CSV-Datei.
Volumenschattenkopien
Eine Schattenkopie ist die in Windows enthaltene Technologie zum manuellen oder automatischen Erstellen von Sicherungskopien oder Schnappschüssen von Computerdateien. Es wird auch als Volume Snapshot Service oder Volume Shadow Service (VSS) bezeichnet.
Mithilfe dieser VSS-Dateien können Forensiker historische Informationen darüber erhalten, wie sich das System im Laufe der Zeit geändert hat und welche Dateien auf dem Computer vorhanden waren. Für die Schattenkopiertechnologie muss das Dateisystem NTFS sein, um Schattenkopien erstellen und speichern zu können.
In diesem Abschnitt sehen wir ein Python-Skript, mit dessen Hilfe Sie auf alle im forensischen Bild vorhandenen Schattenkopien zugreifen können.
Für Python-Skripte müssen wir nämlich Module von Drittanbietern installieren pytsk3, pyewf, unicodecsv, pyvshadow und vss. Wir können die folgenden Schritte ausführen, um Informationen aus VSS-Dateien zu extrahieren
Greifen Sie zunächst auf das Volume des Rohabbilds zu und identifizieren Sie alle NTFS-Partitionen.
Extrahieren Sie dann die Informationen aus diesen Schattenkopien, indem Sie sie durchlaufen.
Jetzt müssen wir endlich eine Dateiliste mit Daten innerhalb der Snapshots erstellen.
Python-Code
Lassen Sie uns sehen, wie Python-Code für diesen Zweck verwendet wird -
Importieren Sie zunächst die folgenden Python-Bibliotheken:
from __future__ import print_function
import argparse
from datetime import datetime, timedelta
import os
import pytsk3
import pyewf
import pyvshadow
import sys
import unicodecsv as csv
from utility import vss
from utility.pytskutil import TSKUtil
from utility import pytskutilGeben Sie nun Argumente für den Befehlszeilenhandler an. Hier werden zwei Argumente akzeptiert - erstens der Pfad zur Beweisdatei und zweitens die Ausgabedatei.
if __name__ == "__main__":
parser = argparse.ArgumentParser('Parsing Shadow Copies')
parser.add_argument("EVIDENCE_FILE", help = "Evidence file path")
parser.add_argument("OUTPUT_CSV", help = "Output CSV with VSS file listing")
args = parser.parse_args()Überprüfen Sie nun die Existenz des Eingabedateipfads und trennen Sie das Verzeichnis von der Ausgabedatei.
directory = os.path.dirname(args.OUTPUT_CSV)
if not os.path.exists(directory) and directory != "":
os.makedirs(directory)
if os.path.exists(args.EVIDENCE_FILE) and \ os.path.isfile(args.EVIDENCE_FILE):
main(args.EVIDENCE_FILE, args.OUTPUT_CSV)
else:
print("[-] Supplied input file {} does not exist or is not a "
"file".format(args.EVIDENCE_FILE))
sys.exit(1)Interagieren Sie jetzt mit dem Volume der Beweisdatei, indem Sie das erstellen TSKUtilObjekt. Dies kann mit Hilfe von geschehenmain() Methode wie folgt -
def main(evidence, output):
tsk_util = TSKUtil(evidence, "raw")
img_vol = tsk_util.return_vol()
if img_vol is not None:
for part in img_vol:
if tsk_util.detect_ntfs(img_vol, part):
print("Exploring NTFS Partition for VSS")
explore_vss(evidence, part.start * img_vol.info.block_size,output)
else:
print("[-] Must be a physical preservation to be compatible ""with this script")
sys.exit(2)Definieren Sie nun eine Methode zum Durchsuchen der analysierten Volume-Schattendatei wie folgt:
def explore_vss(evidence, part_offset, output):
vss_volume = pyvshadow.volume()
vss_handle = vss.VShadowVolume(evidence, part_offset)
vss_count = vss.GetVssStoreCount(evidence, part_offset)
if vss_count > 0:
vss_volume.open_file_object(vss_handle)
vss_data = []
for x in range(vss_count):
print("Gathering data for VSC {} of {}".format(x, vss_count))
vss_store = vss_volume.get_store(x)
image = vss.VShadowImgInfo(vss_store)
vss_data.append(pytskutil.openVSSFS(image, x))
write_csv(vss_data, output)Definieren Sie abschließend die Methode zum Schreiben des Ergebnisses in eine Tabelle wie folgt:
def write_csv(data, output):
if data == []:
print("[-] No output results to write")
sys.exit(3)
print("[+] Writing output to {}".format(output))
if os.path.exists(output):
append = True
with open(output, "ab") as csvfile:
csv_writer = csv.writer(csvfile)
headers = ["VSS", "File", "File Ext", "File Type", "Create Date",
"Modify Date", "Change Date", "Size", "File Path"]
if not append:
csv_writer.writerow(headers)
for result_list in data:
csv_writer.writerows(result_list)Sobald Sie dieses Python-Skript erfolgreich ausgeführt haben, erhalten wir die in VSS enthaltenen Informationen in einer Tabelle.