Software Lettura e Analisi MFT
Soluzione Python per leggere, analizzare e valutare i record MFT NTFS
Highlights
- Gestione completa dei record: Legge tutti i record da un file MFT, ricostruendo il percorso completo e visualizzando ogni attributo.
- Visualizzazione del progresso: Utilizzo di barre di avanzamento e logging per monitorare l'elaborazione dei record MFT.
- Valutazione del punteggio sospetto: Applicazione di test dettagliati per assegnare un punteggio di sospetto ai file in base a regole specifiche.
Introduzione
Questo software in Python è progettato per leggere e analizzare il file Master File Table (MFT) di una partizione NTFS. L’obiettivo è estrarre tutti i record presenti all’interno del file MFT, leggere e visualizzare tutti i campi, catturare eventuali errori durante la lettura e la decodifica dei dati, ricostruire il path completo per ogni file (utilizzando il nome lungo) e, infine, assegnare un punteggio di sospetto ad ogni file basato su criteri predefiniti.
I criteri per assegnare il punteggio di sospetto sono i seguenti:
- Se il file ha estensione .exe oppure .dll, si procede con ulteriori test.
- Se il file si trova nel path contenente “users\” viene aggiunto 5 punti.
- Se la lunghezza del nome del file (senza estensione) è minore o uguale a 3 caratteri vengono aggiunti 5 punti.
- Se il nome del file è lungo al massimo 8 caratteri e consiste in una sequenza casuale di caratteri (maiuscoli, minuscoli e numerici) vengono aggiunti 10 punti.
- Se il nome del file contiene 3 o più caratteri consecutivi uguali viene aggiunto un punteggio di 8.
Al termine dell'elaborazione, verranno visualizzati i dati dei 10 file ad alto punteggio di sospetto.
Implementazione del Software
Dipendenze e Setup
Per eseguire questo software è necessario utilizzare Python 3.x con alcune librerie esterne. In particolare, saranno impiegati i seguenti moduli:
- analyzeMFT: Una libreria per estrarre e decriptare i record MFT in un file NTFS.
- tqdm: Una libreria per generare barre di avanzamento e visualizzare il progresso dell’analisi.
- logging: Il modulo standard per la gestione dei log e il rilevamento degli errori in tempo reale.
- os e sys: Moduli Python per gestire operazioni di sistema, I/O e argomenti da linea di comando.
Installa le dipendenze necessarie con:
# Installa analyzeMFT e tqdm
pip install analyzeMFT tqdm
Struttura del Codice
Il codice è strutturato in classi e funzioni per organizzare l’analisi dei record MFT. La parte principale del software comprende:
1. Lettura ed Elaborazione del File MFT
Viene aperto il file MFT passato in input e i record vengono letti in modo sequenziale. Viene implementata una gestione completa degli errori per evitare eventuali crash del programma in caso di problematiche di lettura o parsing dei dati.
2. Ricostruzione del Percorso Completo
Per ogni record, il percorso completo del file viene ricostruito utilizzando i riferimenti genitore e il nome lungo del file. Questo avviene tramite funzioni ricorsive che risalgono la gerarchia dei file.
3. Estrazione degli Attributi
Una volta ottenuto il record, tutti i campi e attributi del file vengono estratti e visualizzati. Questi attributi possono includere i timestamp, le dimensioni, la data di creazione, modifica, accesso e altri metadati rilevanti.
4. Calcolo del Punoto di Sospetto
Il software esegue una serie di test sul nome del file (solo se si tratta di file con estensione .exe o .dll) e assegna un punteggio di sospetto in base alle regole specificate. Questo punteggio viene poi utilizzato per identificare i file più sospetti.
5. Visualizzazione dell’Output
Durante l'analisi viene mostrata una barra di avanzamento per fornire feedback all'utente. Infine, il programma visualizza le informazioni e gli attributi dei 10 file con il punteggio più alto in una tabella riepilogativa.
Codice Esempio
Di seguito viene fornito un esempio completo di implementazione in Python che svolge tutte le funzionalità descritte:
# importazioni necessarie
import os
import sys
import logging
import argparse
import re
from tqdm import tqdm
# Si utilizzino strumenti come analyzeMFT per leggere i record MFT
try:
import analyzeMFT
except ImportError:
print("Errore: Installare la libreria 'analyzeMFT' con 'pip install analyzeMFT'")
sys.exit(1)
# Impostazioni base del logging
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=logging.INFO)
logger = logging.getLogger("MFTAnalyzer")
class MFTAnalyzer:
def __init__(self, mft_file_path):
self.mft_file_path = mft_file_path
self.parent_paths = {} # Dizionario per mappare record e loro genitori
self.file_paths = {} # Dizionario per ricostruire percorso completo
self.suspicious_files = [] # Lista per memorizzare i file sospetti
def read_mft(self):
"""
Legge il file MFT, estrae i record e gestisce gli errori di lettura.
"""
try:
logger.info("Apertura del file MFT: %s", self.mft_file_path)
# Utilizza analyzeMFT per effettivamente leggere il file MFT
mft = analyzeMFT.AnalyzeMFT(self.mft_file_path)
records = mft.parse()
logger.info("Lettura completata: %d record trovati", len(records))
return records
except Exception as e:
logger.error("Errore durante la lettura del file MFT: %s", str(e))
sys.exit(1)
def reconstruct_all_paths(self, records):
"""
Ricostruisce il percorso completo per ogni file basato su riferimenti genitore.
"""
logger.info("Ricostruzione dei path completi dai record")
# Inizialmente, itera per raccogliere riferimento genitore e filename
for record in records:
try:
rec_number = record.record_number
parent_ref = record.parent_reference
# Utilizza il nome lungo se disponibile, altrimenti il nome breve
filename = record.long_filename if record.long_filename else record.filename
# Se il record non contiene un nome valido, saltalo
if not filename:
continue
self.parent_paths[rec_number] = (parent_ref, filename)
except Exception as e:
logger.warning("Errore nella ricostruzione per un record: %s", str(e))
continue
# ora, ricostruisci ricorsivamente il percorso completo
for rec_num in self.parent_paths:
self.file_paths[rec_num] = self.build_path(rec_num)
def build_path(self, rec_num):
"""
Funzione ricorsiva per costruire il percorso completo di un file.
"""
if rec_num not in self.parent_paths:
return ""
parent_ref, filename = self.parent_paths[rec_num]
# Se il record è la radice o se è lo stesso record, il path si arresta
if parent_ref == rec_num or parent_ref == 5:
return os.path.join(os.sep, filename)
parent_path = self.build_path(parent_ref)
return os.path.join(parent_path, filename)
def calculate_suspicion_score(self, filename, full_path):
"""
Calcola il punteggio di sospetto basato sui criteri specificati:
- Estensione '.exe' o '.dll'
- 'users\' presente nel path
- Lunghezza <= 3 caratteri del nome senza estensione
- Nome lungo <= 8 caratteri con combinazioni alfanumeriche miste
- 3 o più caratteri consecutivi uguali
"""
score = 0
# Controllo estensione
_, ext = os.path.splitext(filename)
ext = ext.lower()
if ext not in ['.exe', '.dll']:
return score
# Se il path contiene "users\" aggiunge 5 punti
if "users" in full_path.lower():
score += 5
# Rimuove l'estensione per analizzare il nome
name_only, _ = os.path.splitext(filename)
# Se il nome, senza estensione, è lungo <=3 caratteri aggiunge 5 punti
if len(name_only) <= 3:
score += 5
# Se il nome è lungo <=8 caratteri ed è una sequenza casuale alfanumerica, aggiunge 10 punti
if len(name_only) <= 8:
if re.match(r'^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)[A-Za-z0-9]+$', name_only):
score += 10
# Verifica presenza di 3 o più caratteri consecutivi uguali
for i in range(len(name_only) - 2):
if name_only[i] == name_only[i+1] == name_only[i+2]:
score += 8
break
return score
def analyze_records(self, records):
"""
Analizza ogni record, visualizza gli attributi e calcola il punteggio di sospetto.
"""
logger.info("Inizio analisi record MFT con visualizzazione del progresso")
for record in tqdm(records, desc="Analisi record MFT"):
try:
# Verifica che il record sia valido
if not record.is_valid:
continue
# Evita directory, si analizzano solo i file
if record.is_directory:
continue
# Estrae il nome (preferibilmente il nome lungo) e ricostruisce il percorso
filename = record.long_filename if record.long_filename else record.filename
if not filename:
continue
full_path = self.file_paths.get(record.record_number, filename)
# Calcola il punteggio di sospetto
suspicion_score = self.calculate_suspicion_score(filename, full_path)
# Se il punteggio è maggiore di 0, raccogli informazioni complete del record
if suspicion_score > 0:
attributes = self.extract_attributes(record)
self.suspicious_files.append({
"record_number": record.record_number,
"filename": filename,
"full_path": full_path,
"score": suspicion_score,
"attributes": attributes
})
except Exception as e:
logger.warning("Errore nell'analisi del record numero %s: %s", record.record_number, str(e))
continue
def extract_attributes(self, record):
"""
Estrae tutti i campi e gli attributi dal record MFT.
"""
attrs = {}
try:
attrs["Created Time"] = record.created_time
attrs["Modified Time"] = record.modified_time
attrs["MFT Changed Time"] = record.mft_changed_time
attrs["Access Time"] = record.access_time
attrs["File Size"] = record.file_size if not record.is_directory else 0
# Aggiunge ulteriori attributi se disponibili
for key, value in record.extra_attributes.items():
attrs[key] = value
except Exception as e:
logger.warning("Errore nell'estrazione degli attributi: %s", str(e))
return attrs
def display_top_suspicious(self, top_n=10):
"""
Visualizza in output i dati dei top N file con punteggio di sospetto maggiore.
"""
sorted_files = sorted(self.suspicious_files, key=lambda x: x["score"], reverse=True)[:top_n]
# Stampa i risultati in una tabella HTML per una visualizzazione ordinata
print("\n<table border='1' cellpadding='5' cellspacing='0'>")
print("<tr><th>Rank</th><th>Nome File</th><th>Percorso</th><th>Punteggio</th></tr>")
for idx, item in enumerate(sorted_files, start=1):
print(f"<tr><td>{idx}</td><td>{item['filename']}</td><td>{item['full_path']}</td><td>{item['score']}</td></tr>")
print("</table>")
def main():
parser = argparse.ArgumentParser(description="Software per analizzare il file MFT NTFS e assegnare punteggio sospetto")
parser.add_argument("-f", "--file", required=True, help="Percorso del file MFT di input")
args = parser.parse_args()
analyzer = MFTAnalyzer(args.file)
# Legge il file MFT ed estrae i record
records = analyzer.read_mft()
# Ricostruisce il percorso completo per ogni record rilevante
analyzer.reconstruct_all_paths(records)
# Analizza i record e raccoglie quelli sospetti
analyzer.analyze_records(records)
# Visualizza i 10 file con i punteggi di sospetto più alti
analyzer.display_top_suspicious(top_n=10)
if __name__ == "__main__":
main()
Spiegazione del Codice
Gestione degli Errori e Visualizzazione del Progresso
Nel codice, ogni operazione critica (lettura del file MFT, estrazione dei record, costruzione dei path e analisi dei record) è racchiusa in un blocco try/except per catturare e loggare eventuali errori. Questo approccio garantisce che in caso di record malformati o errori non critici, il processo continui senza interruzioni catastrofiche.
Ricostruzione del Path Completo
La funzione build_path utilizza una logica ricorsiva per risalire dalla radice della gerarchia fino a ogni file. I riferimenti genitore sono memorizzati in un dizionario che mappa il record numero al nome e al riferimento del genitore. In questo modo, per ogni file si ottiene il percorso completo in cui si trova.
Estrazione e Visualizzazione degli Attributi
Per ogni record analizzato, vengono estratti gli attributi fondamentali come le date di creazione, modifica, accesso, dimensione e altri metadati. Questi dati vengono poi visualizzati insieme al percorso del file nella tabella HTML finale.
Calcolo del Punteggio di Sospetto
Il punteggio di sospetto viene calcolato controllando:
- La presenza delle estensioni .exe o .dll.
- La presenza di “users” nel path.
- La lunghezza del nome del file senza estensione.
- Il pattern alfanumerico del nome (controllando se il nome è formato da una combinazione casuale di lettere maiuscole, minuscole e numeri).
- La presenza di tre o più caratteri consecutivi uguali.
Solo se il file soddisfa i requisiti iniziali (estensione .exe o .dll) vengono eseguiti gli ulteriori test per incrementare il punteggio.
Visualizzazione dei Risultati
Al termine dell'analisi, i file sospetti sono ordinati in base al punteggio e vengono visualizzati in una semplice tabella HTML, che mostra la classifica dei 10 file con il punteggio più alto.
Tabella Riassuntiva dei Passaggi
| Fase | Descrizione |
|---|---|
| 1. Lettura File MFT | Apertura del file MFT, estrazione dei record e gestione degli errori tramite logging. |
| 2. Ricostruzione Percorsi | Costruzione del percorso completo per ogni record usando l’algoritmo ricorsivo. |
| 3. Estrazione Attributi | Recupero di tutti i campi informativi per ogni file, inclusi timestamp e dimensioni. |
| 4. Calcolo Punteggio Sospetto | Applicazione dei criteri per assegnare un punteggio basato su posizione, lunghezza e pattern del nome. |
| 5. Visualizzazione Risultati | Ordinamento dei file in base al punteggio e presentazione dei 10 file più sospetti in formato tabellare. |
Conclusione e Considerazioni Finali
Il software presentato offre una soluzione robusta per l'analisi del file MFT di partizioni NTFS. Grazie all'uso di librerie esistenti e all'implementazione di algoritmi per la ricostruzione del path e il calcolo del punteggio sospetto, è possibile ottenere una panoramica dettagliata dei file presenti, identificando quelli potenzialmente sospetti.
La modularità del codice consente un'ulteriore espansione e personalizzazione in base a requisiti futuri, rendendo lo strumento utile per compiti di digital forensics, analisi dei sistemi e troubleshooting di file system. La gestione accurata degli errori e la visualizzazione del progresso mediante tqdm aiutano a mantenere trasparenza nell'esecuzione del processo, garantendo all'utente un controllo costante sullo stato dell'analisi.
In conclusione, la combinazione di un forte meccanismo di parsing e analisi, un sistema intelligente per la ricostruzione dei percorsi e l'adozione di criteri di sospetto ben definiti garantisce una soluzione efficace e scalabile per l’analisi forense dei file system NTFS.
References
- analyzeMFT - PyPI
- analyzeMFT - GitHub Repository
- Master File Table - Microsoft Learn
- AnalyzeMFT Discussion - Forensic Focus
Related Queries to Explore
integriography.wordpress.com
Last updated February 25, 2025