Artefacts importants dans Windows-III
Ce chapitre explique les autres artefacts qu'un enquêteur peut obtenir lors d'une analyse médico-légale sous Windows.
Journaux d'événements
Les fichiers journaux d'événements Windows, en tant que nom –suggests, sont des fichiers spéciaux qui stockent des événements importants comme lorsque l'utilisateur se connecte à l'ordinateur, lorsque le programme rencontre une erreur, à propos des modifications du système, de l'accès RDP, des événements spécifiques à l'application, etc. Les cyber-enquêteurs sont toujours intéressés par l'événement informations de journal car il fournit de nombreuses informations historiques utiles sur l'accès au système. Dans le script Python suivant, nous allons traiter les formats de journaux d'événements Windows hérités et actuels.
Pour le script Python, nous devons installer des modules tiers, à savoir pytsk3, pyewf, unicodecsv, pyevt and pyevtX. Nous pouvons suivre les étapes ci-dessous pour extraire les informations des journaux d'événements -
Tout d'abord, recherchez tous les journaux d'événements qui correspondent à l'argument d'entrée.
Ensuite, effectuez la vérification de la signature du fichier.
Maintenant, traitez chaque journal des événements trouvé avec la bibliothèque appropriée.
Enfin, écrivez la sortie dans une feuille de calcul.
Code Python
Voyons comment utiliser le code Python à cette fin -
Tout d'abord, importez les bibliothèques Python suivantes -
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 TSKUtilMaintenant, fournissez les arguments pour le gestionnaire de ligne de commande. Notez qu'ici, il acceptera trois arguments - le premier est le chemin d'accès au fichier de preuves, le second est le type de fichier de preuves et le troisième est le nom du journal des événements à traiter.
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)Maintenant, interagissez avec les journaux d'événements pour interroger l'existence du chemin fourni par l'utilisateur en créant notre TSKUtilobjet. Cela peut être fait avec l'aide demain() méthode comme suit -
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)Maintenant, nous devons effectuer une vérification de signature suivie de la définition d'une méthode qui écrira tout le contenu dans le répertoire courant -
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(2Enfin, définissez une méthode pour écrire la sortie dans une feuille de calcul comme suit -
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)Une fois que vous avez exécuté avec succès le script ci-dessus, nous obtiendrons les informations du journal des événements dans une feuille de calcul.
Histoire d'Internet
L'histoire d'Internet est très utile pour les analystes médico-légaux; car la plupart des cybercrimes se produisent uniquement sur Internet. Voyons comment extraire l'historique Internet d'Internet Explorer, alors que nous discutons de la criminalistique Windows, et Internet Explorer est fourni par défaut avec Windows.
Sur Internet Explorer, l'historique Internet est enregistré dans index.datfichier. Examinons un script Python, qui extraira les informations deindex.dat fichier.
Nous pouvons suivre les étapes ci-dessous pour extraire des informations de index.dat fichiers -
Tout d'abord, recherchez index.dat fichiers dans le système.
Ensuite, extrayez les informations de ce fichier en les parcourant.
Maintenant, écrivez toutes ces informations dans un rapport CSV.
Code Python
Voyons comment utiliser le code Python à cette fin -
Tout d'abord, importez les bibliothèques Python suivantes -
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 TSKUtilMaintenant, fournissez des arguments pour le gestionnaire de ligne de commande. Notez qu'ici, il acceptera deux arguments - le premier serait le chemin d'accès au fichier de preuve et le second serait le type de fichier de preuve -
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)Maintenant, interprétez le fichier de preuves en créant un objet de TSKUtilet parcourez le système de fichiers pour trouver les fichiers index.dat. Cela peut être fait en définissant lemain() fonction comme suit -
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)Maintenant, définissez une fonction à l'aide de laquelle nous pouvons copier les informations du fichier index.dat dans le répertoire de travail actuel et plus tard, elles peuvent être traitées par un module tiers -
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.nameMaintenant, utilisez le code suivant pour effectuer la validation de signature à l'aide de la fonction intégrée à savoir 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)Maintenant, définissez une méthode qui imprimera la sortie dans un fichier CSV, comme indiqué ci-dessous -
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)Après avoir exécuté le script ci-dessus, nous obtiendrons les informations du fichier index.dat dans le fichier CSV.
Clichés instantanés de volume
Un cliché instantané est la technologie incluse dans Windows pour effectuer des copies de sauvegarde ou des instantanés de fichiers informatiques manuellement ou automatiquement. Il est également appelé service de cliché de volume ou service de cliché de volume (VSS).
À l'aide de ces fichiers VSS, les experts légistes peuvent avoir des informations historiques sur la façon dont le système a changé au fil du temps et quels fichiers existaient sur l'ordinateur. La technologie de cliché instantané nécessite que le système de fichiers soit NTFS pour créer et stocker des clichés instantanés.
Dans cette section, nous allons voir un script Python, qui aide à accéder à n'importe quel volume de clichés instantanés présents dans l'image médico-légale.
Pour le script Python, nous devons installer des modules tiers, à savoir pytsk3, pyewf, unicodecsv, pyvshadow et vss. Nous pouvons suivre les étapes ci-dessous pour extraire les informations des fichiers VSS
Tout d'abord, accédez au volume de l'image brute et identifiez toutes les partitions NTFS.
Ensuite, extrayez les informations de ces clichés instantanés en les parcourant.
Maintenant, nous devons enfin créer une liste de fichiers de données dans les instantanés.
Code Python
Voyons comment utiliser le code Python à cette fin -
Tout d'abord, importez les bibliothèques Python suivantes -
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 pytskutilMaintenant, fournissez des arguments pour le gestionnaire de ligne de commande. Ici, il acceptera deux arguments - le premier est le chemin d'accès au fichier de preuve et le second est le fichier de sortie.
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()Maintenant, validez l'existence du chemin du fichier d'entrée et séparez également le répertoire du fichier de sortie.
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)Maintenant, interagissez avec le volume du fichier de preuves en créant le TSKUtilobjet. Cela peut être fait avec l'aide demain() méthode comme suit -
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)Maintenant, définissez une méthode pour explorer le fichier d'ombre de volume analysé comme suit -
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)Enfin, définissez la méthode d'écriture du résultat dans une feuille de calcul comme suit -
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)Une fois que vous avez exécuté ce script Python avec succès, nous obtiendrons les informations résidant dans VSS dans une feuille de calcul.