Artefatti importanti in Windows-III
Questo capitolo illustrerà gli ulteriori artefatti che un investigatore può ottenere durante l'analisi forense su Windows.
Registri degli eventi
I file di registro degli eventi di Windows, come nome –suggerito, sono file speciali che memorizzano eventi significativi come quando l'utente accede al computer, quando il programma incontra un errore, su modifiche al sistema, accesso RDP, eventi specifici dell'applicazione ecc. Gli investigatori informatici sono sempre interessati all'evento informazioni di registro perché fornisce molte informazioni storiche utili sull'accesso al sistema. Nel seguente script Python elaboreremo sia i formati legacy che quelli attuali del registro eventi di Windows.
Per lo script Python, dobbiamo installare moduli di terze parti, vale a dire pytsk3, pyewf, unicodecsv, pyevt and pyevtX. Possiamo seguire i passaggi indicati di seguito per estrarre le informazioni dai registri degli eventi:
Innanzitutto, cerca tutti i registri eventi che corrispondono all'argomento di input.
Quindi, eseguire la verifica della firma del file.
Ora, elabora ogni registro eventi trovato con la libreria appropriata.
Infine, scrivi l'output sul foglio di calcolo.
Codice Python
Vediamo come utilizzare il codice Python per questo scopo -
Innanzitutto, importa le seguenti librerie Python:
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 TSKUtilFornisci ora gli argomenti per il gestore della riga di comando. Nota che qui accetterà tre argomenti: il primo è il percorso del file delle prove, il secondo è il tipo di file delle prove e il terzo è il nome del registro degli eventi da elaborare.
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)Ora, interagisci con i log degli eventi per interrogare l'esistenza del percorso fornito dall'utente creando il nostro TSKUtiloggetto. Può essere fatto con l'aiuto dimain() metodo come segue -
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)Ora, dobbiamo eseguire la verifica della firma seguita dalla definizione di un metodo che scriverà l'intero contenuto nella directory corrente -
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(2Infine, definire un metodo per scrivere l'output su un foglio di calcolo come segue:
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)Una volta eseguito correttamente lo script sopra, otterremo le informazioni sugli eventi nel foglio di calcolo.
Storia di Internet
La storia di Internet è molto utile per gli analisti forensi; poiché la maggior parte dei crimini informatici si verifica solo su Internet. Vediamo come estrarre la cronologia di Internet da Internet Explorer, mentre discutiamo di analisi forense di Windows e Internet Explorer viene fornito per impostazione predefinita con Windows.
In Internet Explorer, la cronologia di Internet viene salvata in index.datfile. Esaminiamo uno script Python, che estrarrà le informazioni daindex.dat file.
Possiamo seguire i passaggi indicati di seguito per estrarre le informazioni da index.dat file -
Innanzitutto, cerca index.dat file all'interno del sistema.
Quindi, estrai le informazioni da quel file scorrendole.
Ora scrivi tutte queste informazioni in un rapporto CSV.
Codice Python
Vediamo come utilizzare il codice Python per questo scopo -
Innanzitutto, importa le seguenti librerie Python:
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 TSKUtilFornisci ora argomenti per il gestore della riga di comando. Nota che qui accetterà due argomenti: il primo sarebbe il percorso del file delle prove e il secondo sarebbe il tipo di file delle prove -
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)Ora, interpreta il file delle prove creando un oggetto di TSKUtile scorrere il file system per trovare i file index.dat. Può essere fatto definendo il filemain() funzionare come segue:
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)Ora, definisci una funzione con l'aiuto della quale possiamo copiare le informazioni del file index.dat nella directory di lavoro corrente e in seguito possono essere elaborate da un modulo di terze parti -
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.nameOra, usa il seguente codice per eseguire la convalida della firma con l'aiuto della funzione integrata, vale a dire 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)Ora, definisci un metodo che stamperà l'output nel file CSV, come mostrato di seguito -
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)Dopo aver eseguito lo script precedente, otterremo le informazioni dal file index.dat nel file CSV.
Copie shadow del volume
Una copia shadow è la tecnologia inclusa in Windows per eseguire manualmente o automaticamente copie di backup o istantanee dei file del computer. È anche chiamato servizio snapshot del volume o servizio shadow del volume (VSS).
Con l'aiuto di questi file VSS, gli esperti forensi possono avere alcune informazioni storiche su come il sistema è cambiato nel tempo e quali file esistevano sul computer. La tecnologia delle copie shadow richiede che il file system sia NTFS per la creazione e l'archiviazione delle copie shadow.
In questa sezione, vedremo uno script Python, che aiuta ad accedere a qualsiasi volume di copie shadow presenti nell'immagine forense.
Per lo script Python dobbiamo installare moduli di terze parti, vale a dire pytsk3, pyewf, unicodecsv, pyvshadow e vss. Possiamo seguire i passaggi indicati di seguito per estrarre informazioni dai file VSS
Innanzitutto, accedi al volume dell'immagine raw e identifica tutte le partizioni NTFS.
Quindi, estrai le informazioni da quelle copie shadow scorrendole.
Ora, finalmente, dobbiamo creare un elenco di file di dati all'interno degli snapshot.
Codice Python
Vediamo come utilizzare il codice Python per questo scopo -
Innanzitutto, importa le seguenti librerie Python:
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 pytskutilFornisci ora argomenti per il gestore della riga di comando. Qui accetterà due argomenti: il primo è il percorso del file di prova e il secondo è il file di output.
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()Ora convalida l'esistenza del percorso del file di input e separa anche la directory dal file di output.
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)Ora interagisci con il volume del file delle prove creando il file TSKUtiloggetto. Può essere fatto con l'aiuto dimain() metodo come segue -
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)Ora, definisci un metodo per esplorare il file shadow del volume analizzato come segue:
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)Infine, definire il metodo per scrivere il risultato nel foglio di calcolo come segue:
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)Una volta eseguito con successo questo script Python, otterremo le informazioni che risiedono in VSS in un foglio di calcolo.