copia-forense 1.0.0__tar.gz

copia_forense-1.0.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: copia-forense
+Version: 1.0.0
+Summary: Forensic Logical Acquisition Tool with SHA-256 validation.
+Author: Mathias Nesci
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: fpdf2
+
+# Forensic Logical Acquisition Tool
+
+This project is a portable application developed in Python for the logical acquisition of data and files for forensic purposes. It is designed to ensure the chain of custody, data immutability, and the repeatability of the operation, solving common issues that occur during mass copying across heterogeneous file systems.
+
+## 🚀 Key Features
+
+- **Cryptographic Integrity:** Automatic pre- and post-copy **SHA-256** hash calculation. The 1:1 validation ensures absolute correspondence between the original evidence and the copy.
+- **MAC Times Extraction:** Preservation and reporting of the original temporal metadata (Modification, Access, and Creation Dates) via `os.stat`, bypassing the limitations of destination file systems (e.g., FAT32).
+- **Sandboxing & Exception Handling:** The copy engine intercepts Operating System locks (files in use) and `PermissionError`s, recording them in the report without interrupting the operational flow (No Crash).
+- **MAX_PATH Bypass (Windows):** Dynamic implementation of the `\\?\` prefix to bypass the historical 260-character path limit on Windows.
+- **Anti-Inception Security:** Algorithmic check based on `os.path.commonpath` to prevent selecting a destination nested within the source (prevents recursion loops).
+- **Pre-flight Check:** Calculation of required disk space (with a 10% buffer) before interacting with the original media.
+- **Dual Reporting and Signature:** Automatic generation of a *Human-Readable* report (PDF) and a *Machine-Readable* one (JSON). The tool concludes the operation by generating a SHA-256 signature of the reports themselves to certify their immutability.
+
+## 📦 Standalone Executables
+The binary files attached to the GitHub Releases (automatically generated via GitHub Actions) do not require Python or other dependencies to be installed. Download the appropriate version for your operating system and CPU architecture:
+- **Windows (Intel/AMD/ARM):** `CopiaForense-windows-x64.zip`
+- **macOS (Intel):** `CopiaForense-macos-intel.zip`
+- **macOS (Apple Silicon):** `CopiaForense-macos-silicon.zip`
+- **Linux (Intel/AMD):** `CopiaForense-linux-x64.zip`
+- **Linux (ARM64):** `CopiaForense-linux-arm64.zip`
+
+## ⚠️ Running the Executables (macOS & Windows)
+
+Because this tool is an independent open-source project and not digitally signed by a paid commercial certificate, your Operating System might initially block its execution. This is normal and expected behavior.
+
+**For macOS Users (Gatekeeper):**
+If you see an "Apple could not verify..." warning:
+1. Go to **System Settings** -> **Privacy & Security**.
+2. Scroll down to the security section and click **Open Anyway** next to the blocked app notification.
+3. Alternatively, in Finder, **Right-Click** the executable and select **Open**.
+
+**For Windows Users (SmartScreen):**
+If you see a "Windows protected your PC" blue screen warning:
+1. Click on **More info**.
+2. Click the **Run anyway** button that appears at the bottom.
+
+## 🛠️ Development Requirements
+
+The project mainly uses modules from the Python Standard Library (`os`, `shutil`, `hashlib`, `tkinter`).
+The only external dependency required for generating the PDF report is:
+- `fpdf2`
+
+To install the dependencies in a development environment:
+```bash
+pip install -r requirements.txt
+```

copia_forense-1.0.0/README.md

@@ -0,0 +1,47 @@
+# Forensic Logical Acquisition Tool
+
+This project is a portable application developed in Python for the logical acquisition of data and files for forensic purposes. It is designed to ensure the chain of custody, data immutability, and the repeatability of the operation, solving common issues that occur during mass copying across heterogeneous file systems.
+
+## 🚀 Key Features
+
+- **Cryptographic Integrity:** Automatic pre- and post-copy **SHA-256** hash calculation. The 1:1 validation ensures absolute correspondence between the original evidence and the copy.
+- **MAC Times Extraction:** Preservation and reporting of the original temporal metadata (Modification, Access, and Creation Dates) via `os.stat`, bypassing the limitations of destination file systems (e.g., FAT32).
+- **Sandboxing & Exception Handling:** The copy engine intercepts Operating System locks (files in use) and `PermissionError`s, recording them in the report without interrupting the operational flow (No Crash).
+- **MAX_PATH Bypass (Windows):** Dynamic implementation of the `\\?\` prefix to bypass the historical 260-character path limit on Windows.
+- **Anti-Inception Security:** Algorithmic check based on `os.path.commonpath` to prevent selecting a destination nested within the source (prevents recursion loops).
+- **Pre-flight Check:** Calculation of required disk space (with a 10% buffer) before interacting with the original media.
+- **Dual Reporting and Signature:** Automatic generation of a *Human-Readable* report (PDF) and a *Machine-Readable* one (JSON). The tool concludes the operation by generating a SHA-256 signature of the reports themselves to certify their immutability.
+
+## 📦 Standalone Executables
+The binary files attached to the GitHub Releases (automatically generated via GitHub Actions) do not require Python or other dependencies to be installed. Download the appropriate version for your operating system and CPU architecture:
+- **Windows (Intel/AMD/ARM):** `CopiaForense-windows-x64.zip`
+- **macOS (Intel):** `CopiaForense-macos-intel.zip`
+- **macOS (Apple Silicon):** `CopiaForense-macos-silicon.zip`
+- **Linux (Intel/AMD):** `CopiaForense-linux-x64.zip`
+- **Linux (ARM64):** `CopiaForense-linux-arm64.zip`
+
+## ⚠️ Running the Executables (macOS & Windows)
+
+Because this tool is an independent open-source project and not digitally signed by a paid commercial certificate, your Operating System might initially block its execution. This is normal and expected behavior.
+
+**For macOS Users (Gatekeeper):**
+If you see an "Apple could not verify..." warning:
+1. Go to **System Settings** -> **Privacy & Security**.
+2. Scroll down to the security section and click **Open Anyway** next to the blocked app notification.
+3. Alternatively, in Finder, **Right-Click** the executable and select **Open**.
+
+**For Windows Users (SmartScreen):**
+If you see a "Windows protected your PC" blue screen warning:
+1. Click on **More info**.
+2. Click the **Run anyway** button that appears at the bottom.
+
+## 🛠️ Development Requirements
+
+The project mainly uses modules from the Python Standard Library (`os`, `shutil`, `hashlib`, `tkinter`).
+The only external dependency required for generating the PDF report is:
+- `fpdf2`
+
+To install the dependencies in a development environment:
+```bash
+pip install -r requirements.txt
+```

copia_forense-1.0.0/copia_forense.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: copia-forense
+Version: 1.0.0
+Summary: Forensic Logical Acquisition Tool with SHA-256 validation.
+Author: Mathias Nesci
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: fpdf2
+
+# Forensic Logical Acquisition Tool
+
+This project is a portable application developed in Python for the logical acquisition of data and files for forensic purposes. It is designed to ensure the chain of custody, data immutability, and the repeatability of the operation, solving common issues that occur during mass copying across heterogeneous file systems.
+
+## 🚀 Key Features
+
+- **Cryptographic Integrity:** Automatic pre- and post-copy **SHA-256** hash calculation. The 1:1 validation ensures absolute correspondence between the original evidence and the copy.
+- **MAC Times Extraction:** Preservation and reporting of the original temporal metadata (Modification, Access, and Creation Dates) via `os.stat`, bypassing the limitations of destination file systems (e.g., FAT32).
+- **Sandboxing & Exception Handling:** The copy engine intercepts Operating System locks (files in use) and `PermissionError`s, recording them in the report without interrupting the operational flow (No Crash).
+- **MAX_PATH Bypass (Windows):** Dynamic implementation of the `\\?\` prefix to bypass the historical 260-character path limit on Windows.
+- **Anti-Inception Security:** Algorithmic check based on `os.path.commonpath` to prevent selecting a destination nested within the source (prevents recursion loops).
+- **Pre-flight Check:** Calculation of required disk space (with a 10% buffer) before interacting with the original media.
+- **Dual Reporting and Signature:** Automatic generation of a *Human-Readable* report (PDF) and a *Machine-Readable* one (JSON). The tool concludes the operation by generating a SHA-256 signature of the reports themselves to certify their immutability.
+
+## 📦 Standalone Executables
+The binary files attached to the GitHub Releases (automatically generated via GitHub Actions) do not require Python or other dependencies to be installed. Download the appropriate version for your operating system and CPU architecture:
+- **Windows (Intel/AMD/ARM):** `CopiaForense-windows-x64.zip`
+- **macOS (Intel):** `CopiaForense-macos-intel.zip`
+- **macOS (Apple Silicon):** `CopiaForense-macos-silicon.zip`
+- **Linux (Intel/AMD):** `CopiaForense-linux-x64.zip`
+- **Linux (ARM64):** `CopiaForense-linux-arm64.zip`
+
+## ⚠️ Running the Executables (macOS & Windows)
+
+Because this tool is an independent open-source project and not digitally signed by a paid commercial certificate, your Operating System might initially block its execution. This is normal and expected behavior.
+
+**For macOS Users (Gatekeeper):**
+If you see an "Apple could not verify..." warning:
+1. Go to **System Settings** -> **Privacy & Security**.
+2. Scroll down to the security section and click **Open Anyway** next to the blocked app notification.
+3. Alternatively, in Finder, **Right-Click** the executable and select **Open**.
+
+**For Windows Users (SmartScreen):**
+If you see a "Windows protected your PC" blue screen warning:
+1. Click on **More info**.
+2. Click the **Run anyway** button that appears at the bottom.
+
+## 🛠️ Development Requirements
+
+The project mainly uses modules from the Python Standard Library (`os`, `shutil`, `hashlib`, `tkinter`).
+The only external dependency required for generating the PDF report is:
+- `fpdf2`
+
+To install the dependencies in a development environment:
+```bash
+pip install -r requirements.txt
+```

copia_forense-1.0.0/copia_forense.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+forensic_copier.py
+forensic_hasher.py
+logger_pdf.py
+main.py
+pyproject.toml
+copia_forense.egg-info/PKG-INFO
+copia_forense.egg-info/SOURCES.txt
+copia_forense.egg-info/dependency_links.txt
+copia_forense.egg-info/entry_points.txt
+copia_forense.egg-info/requires.txt
+copia_forense.egg-info/top_level.txt

copia_forense-1.0.0/copia_forense.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

copia_forense-1.0.0/copia_forense.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+copia-forense = main:main

copia_forense-1.0.0/copia_forense.egg-info/requires.txt

@@ -0,0 +1 @@
+fpdf2

copia_forense-1.0.0/copia_forense.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+forensic_copier
+forensic_hasher
+logger_pdf
+main

copia_forense-1.0.0/forensic_copier.py

@@ -0,0 +1,25 @@
+import shutil
+
+class ForensicCopier:
+    """Gestisce la clonazione fisica dei dati e la preservazione dei metadati."""
+    
+    def copy_file_with_metadata(self, source_path: str, dest_path: str) -> tuple[bool, str]:
+        """
+        Esegue la copia bit-a-bit e tenta di trasferire i metadati (MAC times).
+        Restituisce una tupla contenente l'esito (bool) e un messaggio diagnostico.
+        """
+        try:
+            shutil.copyfile(source_path, dest_path)
+            
+            try:
+                shutil.copystat(source_path, dest_path)
+                return True, ""
+            except OSError:
+                return True, "Copiato (Metadati originali non supportati dal File System di destinazione)"
+                
+        except PermissionError:
+            return False, "Accesso negato in lettura (PermissionError)"
+        except OSError:
+            return False, "File bloccato o in uso dall'OS"
+        except Exception as e:
+            return False, f"Errore generico di copia: {e}"

copia_forense-1.0.0/forensic_hasher.py

@@ -0,0 +1,27 @@
+import hashlib
+
+class ForensicHasher:
+    """Gestisce il calcolo degli hash crittografici per l'integrità dei reperti."""
+    
+    def __init__(self, chunk_size: int = 4194304):
+        self.chunk_size = chunk_size
+
+    def calculate_sha256(self, file_path: str) -> str:
+        """
+        Calcola l'hash SHA-256 di un file leggendolo a blocchi per ottimizzare la RAM.
+        Restituisce la stringa esadecimale o un codice di errore in caso di fallimento I/O.
+        """
+        try:
+            sha256_hash = hashlib.sha256()
+            
+            with open(file_path, "rb") as f:
+                # Itera sul file stream via chunk per contenere l'impronta in RAM
+                for chunk in iter(lambda: f.read(self.chunk_size), b""):
+                    sha256_hash.update(chunk)
+                    
+            return sha256_hash.hexdigest()
+            
+        except PermissionError:
+            return "ERRORE_PERMESSI"
+        except Exception as e:
+            return f"ERRORE_GENERICO: {e}"

copia_forense-1.0.0/logger_pdf.py

@@ -0,0 +1,61 @@
+from fpdf import FPDF
+from datetime import datetime, timezone
+
+class ForensicReport:
+    """Genera il verbale PDF riassuntivo (Executive Summary) dell'acquisizione."""
+    
+    def __init__(self, operatore: str = "Agente Operante"):
+        self.operatore = operatore
+        self.data_acquisizione = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+
+    def genera_pdf_riassuntivo(self, registro_dati: list[dict], percorso_salvataggio: str) -> None:
+        """Crea un PDF di singola pagina con le statistiche globali, omettendo la lista file."""
+        pdf = FPDF(orientation="P", unit="mm", format="A4")
+        pdf.add_page()
+        
+        # INTESTAZIONE
+        pdf.set_font("helvetica", style="B", size=16)
+        pdf.cell(0, 10, "VERBALE DI ACQUISIZIONE LOGICA FORENSE", align="C", new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(5) 
+        
+        # METADATI OPERAZIONE
+        pdf.set_font("helvetica", style="B", size=12)
+        pdf.cell(0, 8, "DETTAGLI OPERAZIONE", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_font("helvetica", size=11)
+        pdf.cell(0, 8, f"Data Acquisizione: {self.data_acquisizione}", new_x="LMARGIN", new_y="NEXT")
+        pdf.cell(0, 8, f"Operatore: {self.operatore}", new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(5)
+
+        # STATISTICHE
+        totale = len(registro_dati)
+        successi = sum(1 for f in registro_dati if f.get("esito") == "SUCCESSO")
+        anomalie = totale - successi
+        
+        pdf.set_font("helvetica", style="B", size=12)
+        pdf.cell(0, 8, "STATISTICHE DI ACQUISIZIONE", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_font("helvetica", size=11)
+        pdf.cell(0, 8, f"Totale File Rilevati : {totale}", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_text_color(0, 128, 0)
+        pdf.cell(0, 8, f"Copie con Successo   : {successi}", new_x="LMARGIN", new_y="NEXT")
+        
+        if anomalie > 0:
+            pdf.set_text_color(200, 0, 0)
+        else:
+            pdf.set_text_color(0, 0, 0)
+            
+        pdf.cell(0, 8, f"Anomalie / Saltati   : {anomalie}", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_text_color(0, 0, 0)
+        pdf.ln(10)
+
+        # DICHIARAZIONE ALLEGATI
+        pdf.set_font("helvetica", style="I", size=10)
+        nota = (
+            "NOTA: Per garantire la leggibilita' del verbale e gestire moli di dati massive, "
+            "l'elenco dettagliato dei file acquisiti, inclusivi di percorsi originari, "
+            "dimensioni, timestamp (MAC times) e firme crittografiche SHA-256 pre/post copia, "
+            "e' demandato esclusivamente agli allegati strutturati (File JSON/Testuali) "
+            "inclusi nel supporto di destinazione."
+        )
+        pdf.multi_cell(0, 6, nota)
+            
+        pdf.output(percorso_salvataggio)

copia_forense-1.0.0/main.py

@@ -0,0 +1,224 @@
+import os
+import json
+import shutil
+import platform
+from datetime import datetime, timezone
+import tkinter as tk
+from tkinter import filedialog, messagebox
+
+from forensic_hasher import ForensicHasher
+from forensic_copier import ForensicCopier
+from logger_pdf import ForensicReport
+
+# --- UTILITIES E CONTROLLI PRE-VOLO ---
+
+def prompt_directory_selection() -> tuple[str, str]:
+    """Inizializza l'interfaccia grafica e acquisisce i percorsi operativi."""
+    root = tk.Tk()
+    root.withdraw()
+    messagebox.showinfo(
+        "Acquisizione Forense", 
+        "Premi OK per selezionare:\n\n1. La cartella SORGENTE (Reperto)\n2. La cartella di DESTINAZIONE (Pendrive)"
+    )
+    sorgente = filedialog.askdirectory(title="1. Seleziona la cartella SORGENTE (Reperto)")
+    destinazione = filedialog.askdirectory(title="2. Seleziona la cartella di DESTINAZIONE (Pendrive)")
+    
+    # Distrugge la root di Tkinter per prevenire l'hanging del thread UI su macOS (WindowServer beach balling)
+    root.destroy()
+    
+    return sorgente, destinazione
+
+def is_safe_path(source: str, dest: str) -> bool:
+    """Valida che il path di destinazione non sia annidato all'interno della sorgente."""
+    source_abs = os.path.abspath(source)
+    dest_abs = os.path.abspath(dest)
+    return os.path.commonpath([source_abs, dest_abs]) != source_abs
+
+def check_disk_space(source: str, dest: str) -> bool:
+    """Verifica che la destinazione abbia spazio sufficiente (+10% di buffer) per ospitare il reperto."""
+    total_size = 0
+    for dirpath, _, filenames in os.walk(source):
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            if not os.path.islink(fp):
+                total_size += os.path.getsize(fp)
+                
+    required_space = total_size * 1.10 # 10% di margine per i log forensi
+    free_space = shutil.disk_usage(dest).free
+    return free_space >= required_space
+
+def format_mac_time(timestamp: float) -> str:
+    """Converte un timestamp Unix in formato UTC leggibile."""
+    return datetime.fromtimestamp(timestamp, timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+
+
+# --- CORE LOGIC ---
+CHUNK_SIZE = 4194304  # 4MB
+
+def process_directories(source_dir: str, dest_dir: str) -> list[dict]:
+    """
+    Orchestra l'estrazione metadati, l'esplorazione del file system, l'hashing e la copia logica.
+    Restituisce la struttura dati completa contenente il registro delle operazioni.
+    """
+    hasher = ForensicHasher(chunk_size=CHUNK_SIZE)
+    copier = ForensicCopier()
+    registro = []
+    dir_metadata_to_copy = []
+
+    if not os.path.exists(dest_dir):
+        os.makedirs(dest_dir)
+
+    for root, _, files in os.walk(source_dir):
+        percorso_relativo = os.path.relpath(root, source_dir)
+        cartella_dest_corrente = os.path.join(dest_dir, percorso_relativo)
+        
+        if not os.path.exists(cartella_dest_corrente):
+            os.makedirs(cartella_dest_corrente)
+            
+        # Memorizza i path delle directory per ripristinare i MAC times originali post-copia
+        dir_metadata_to_copy.append((root, cartella_dest_corrente))
+
+        for nome_file in files:
+            percorso_sorgente = os.path.join(root, nome_file)
+            percorso_destinazione = os.path.join(cartella_dest_corrente, nome_file)
+            percorso_visivo = os.path.normpath(os.path.join(percorso_relativo, nome_file))
+
+            # Dizionario Dati Base
+            dati_file = {
+                "percorso": percorso_visivo,
+                "esito": "SALTATO",
+                "hash_sha256": "N/D",
+                "note_errore": "",
+                "dimensione_byte": 0,
+                "data_modifica": "N/D",
+                "data_accesso": "N/D",
+                "data_creazione": "N/D"
+            }
+
+            # ESTRAZIONE METADATI MAC TIMES E DIMENSIONE
+            try:
+                stat_info = os.stat(percorso_sorgente)
+                dati_file["dimensione_byte"] = stat_info.st_size
+                dati_file["data_modifica"] = format_mac_time(stat_info.st_mtime)
+                dati_file["data_accesso"] = format_mac_time(stat_info.st_atime)
+                dati_file["data_creazione"] = format_mac_time(stat_info.st_ctime)
+            except OSError as e:
+                dati_file["note_errore"] = f"Impossibile estrarre metadati originali: {e}"
+
+            # HASH PRE-COPIA
+            hash_originale = hasher.calculate_sha256(percorso_sorgente)
+            if hash_originale.startswith("ERRORE"):
+                dati_file["note_errore"] += f" | Errore I/O in lettura sorgente ({hash_originale})"
+                print(f"[⚠️ SALTATO] {percorso_visivo} (Accesso Negato)")
+                registro.append(dati_file)
+                continue 
+
+            # COPIA FORENSE E VALIDAZIONE POST-COPIA
+            successo, msg_errore = copier.copy_file_with_metadata(percorso_sorgente, percorso_destinazione)
+
+            if successo:
+                hash_copia = hasher.calculate_sha256(percorso_destinazione)
+                if hash_originale == hash_copia:
+                    dati_file["esito"] = "SUCCESSO"
+                    dati_file["hash_sha256"] = hash_originale
+                    print(f"[✅ OK] {percorso_visivo}")
+                else:
+                    dati_file["esito"] = "FALLITO"
+                    dati_file["note_errore"] = "Integrità compromessa: mismatch dell'hash post-copia"
+                    print(f"[❌ ALTERATO] {percorso_visivo}")
+            else:
+                dati_file["note_errore"] = msg_errore
+                print(f"[⚠️ ERRORE COPIA] {percorso_visivo} - {msg_errore}")
+            
+            registro.append(dati_file)
+
+    # Ripristina i metadati delle directory alla fine per evitare alterazioni dovute all'I/O
+    for src_dir, dst_dir in dir_metadata_to_copy:
+        try:
+            shutil.copystat(src_dir, dst_dir)
+        except OSError:
+            pass
+
+    return registro
+
+
+# --- GENERAZIONE REPORT E FIRME ---
+
+def genera_report_strutturato(registro: list[dict], path_destinazione: str, nome_sorgente: str = "") -> str:
+    """Serializza il registro in formato JSON per l'ingestione automatizzata (es. ElasticSearch/Splunk)."""
+    nome_file = f"Verbale_Strutturato_{nome_sorgente}.json" if nome_sorgente else "Verbale_Strutturato.json"
+    json_path = os.path.join(path_destinazione, nome_file)
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(registro, f, indent=4, ensure_ascii=False)
+    return json_path
+
+def firma_catena_custodia(paths_verbali: list[str], path_destinazione: str, nome_sorgente: str = ""):
+    """Calcola l'hash dei verbali generati per garantirne l'immodificabilità."""
+    hasher = ForensicHasher()
+    nome_file = f"Certificato_Firma_Verbali_{nome_sorgente}.txt" if nome_sorgente else "Certificato_Firma_Verbali.txt"
+    firma_path = os.path.join(path_destinazione, nome_file)
+    
+    with open(firma_path, 'w', encoding='utf-8') as f:
+        f.write("=== CERTIFICATO DI IMMODIFICABILITA' DEI VERBALI ===\n")
+        f.write(f"Data: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}\n\n")
+        for path in paths_verbali:
+            hash_val = hasher.calculate_sha256(path)
+            nome_file_verbale = os.path.basename(path)
+            f.write(f"{nome_file_verbale}\nSHA-256: {hash_val}\n\n")
+
+
+def main() -> None:
+    """Entry point dell'applicativo."""
+    print("Inizializzazione ambiente forense...")
+    cartella_sorgente, cartella_destinazione = prompt_directory_selection()
+
+    # 1. Controlli di Sicurezza
+    if not cartella_sorgente or not cartella_destinazione:
+        print("❌ Acquisizione annullata dall'operatore.")
+        return
+
+    if not is_safe_path(cartella_sorgente, cartella_destinazione):
+        msg = "ERRORE CRITICO: Destinazione interna alla sorgente. Rischio loop infinito."
+        messagebox.showerror("Violazione di Sicurezza", msg)
+        return
+
+    print("Verifica spazio su disco in corso...")
+    if not check_disk_space(cartella_sorgente, cartella_destinazione):
+        msg = "ERRORE CAPACITA': Spazio insufficiente sul disco di destinazione."
+        messagebox.showerror("Spazio Insufficiente", msg)
+        return
+
+    # 2. Acquisizione
+    print(f"📁 Target Acquisizione: {cartella_sorgente}")
+    print(f"💾 Storage Destinazione: {cartella_destinazione}\n")
+    print("Avvio procedura di estrazione logica...")
+    
+    # Inizializza la root dir di destinazione mantenendo il nome del volume/cartella sorgente
+    nome_sorgente = os.path.basename(os.path.normpath(cartella_sorgente))
+    if not nome_sorgente:
+        nome_sorgente = "Acquisizione_Reperto"
+        
+    cartella_acquisizione = os.path.join(cartella_destinazione, nome_sorgente)
+    
+    registro_operazioni = process_directories(cartella_sorgente, cartella_acquisizione)
+
+    # 3. Reportistica
+    print(f"\nOperazioni concluse. File processati: {len(registro_operazioni)}")
+    print("Generazione catena di custodia in corso...")
+    
+    # PDF
+    report_pdf = ForensicReport(operatore="Operatore PG")
+    path_pdf = os.path.join(cartella_destinazione, f"Verbale_Acquisizione_{nome_sorgente}.pdf")
+    report_pdf.genera_pdf_riassuntivo(registro_operazioni, path_pdf)
+    
+    # JSON Strutturato
+    path_json = genera_report_strutturato(registro_operazioni, cartella_destinazione, nome_sorgente)
+    
+    # Firma Verbali
+    firma_catena_custodia([path_pdf, path_json], cartella_destinazione, nome_sorgente)
+    
+    print(f"✅ Acquisizione completata e sigillata in: {cartella_destinazione}")
+
+
+if __name__ == "__main__":
+    main()

copia_forense-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "copia-forense"
+version = "1.0.0"
+authors = [
+  { name="Mathias Nesci" }
+]
+description = "Forensic Logical Acquisition Tool with SHA-256 validation."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "fpdf2",
+]
+
+[project.scripts]
+copia-forense = "main:main"
+
+[tool.setuptools]
+py-modules = ["main", "forensic_copier", "forensic_hasher", "logger_pdf"]

copia_forense-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+