Revisore dei conti

Catena di integrità

Il processo di auditing utilizzato auditorsi basa sul concetto di catena di integrità , fornita da file di audit che memorizzano informazioni sull'integrità.

I termini coinvolti in questo processo sono:
Audit_FullList: È il file di controllo che contiene le informazioni sull'integrità di ciascun file di dati originale elaborato.

Stamp: Sono le informazioni sull'integrità effettiva del Audit_FullListfile. StampVengono sempre ricalcolate e visualizzate quando si eseguono azioni rilevanti.

Audit_Stamp: È il file di controllo che memorizza i dati Stampdi Audit_FullList, quando è stato creato.

La catena di integrità viene prodotta nel seguente ordine (nel comportamento predefinito):

I file di dati al loro interno input_pathvengono elaborati e generano informazioni di integrità (hash, dimensione, percorso relativo del file, ecc.) che vengono memorizzate in Audit_FullList.

Audit_FullListviene anche elaborato, generando Stamp, che viene stampato nel terminale e memorizzato in Audit_Stamp.

Il controllo della catena di integrità viene eseguito nell'ordine inverso rispetto al processo descritto sopra, rielaborando i file e verificandone l'integrità rispetto ai file di audit. StampViene inoltre ricalcolato, stampato nel terminale e confrontato con quello memorizzato in Audit_Stamp, per verificare se corrisponde.

Per procedere con la generazione dei file di audit e garantire che la futura verifica della catena di integrità venga eseguita correttamente e in modo sicuro, seguire i passaggi sottostanti:

Organizza i file di dati in una cartella specifica (denominata input_path). Con Auditor installato, apri un terminale di comando ed esegui auditor hash input_path. Per impostazione predefinita, questo comando creerà i file di audit Audit_FullListe Audit_Stampall'interno della radice della cartella input_path. (Se necessario, è possibile modificare questa impostazione.)
Salvare tutti i dati, inclusi i file di audit, e stamparne il contenuto Audit_Stampo firmarlo digitalmente .
Saltando questo passaggio, chiunque potrebbe alterare i dati e generare nuovi file di audit, compromettendo la verifica dell'integrità. Se al momento non si dispone di una stampante o di un certificato digitale, è possibile utilizzare un'autorità di marcatura temporale gratuita per firmare il file online, come freetsa.org (utilizzando la firma online) .
Facoltativamente, puoi creare un pacchetto (ad esempio un file ZIP, TAR o un altro contenitore) che includa sia i file di dati che i file di audit. Crea più copie di backup di questo pacchetto su supporti diversi.
Successivamente, quando qualcuno esegue un controllo con auditor check, viene eseguita la catena di integrità descritta sopra. Al termine del processo, i dati di integrità da Audit_FullListvengono ricalcolati e stampati nel terminale e DEVONO corrispondere esattamente al valore stampato o firmato digitalmente nel passaggio precedente. In caso contrario, il controllo di integrità non è valido .
È anche possibile verificare l'integrità dei singoli file di dati originali utilizzando i dati in Audit_FullList. Vedere gli esempi nella sezione sull'utilizzo di auditor check.

Utilizzo

Consulta qui un breve manuale.

Una volta auditorinstallato nel tuo sistema, puoi utilizzarlo come segue:

auditor subcommands:

hash

lock

check

info

clone

chkcopy

hashè il primo passo dell'audit forense. Genera file di audit che consentono di verificare l'integrità dei file.

Utilizzo di base dell'hash del sottocomando

auditor hash input_path

Ciò:

File hash input_pathcon algoritmo predefinito ( sha256)
Genera file di audit (percorso predefinito: all'interno della radice di input_path):
- Audit_FullList: contiene i dati di integrità (hash, dimensione, nome) dei file in input_path. Nome predefinito: _auditor_hashes.txt
- Audit_Stamp: contiene solo i dati di integrità di Audit_FullList. Nome predefinito: _auditor_stamp.txt. Questo è il file che deve essere stampato o firmato digitalmente per garantire il controllo dell'intera catena di integrità.
Mostra i dati di integrità diAudit_FullList

Dopodiché hash, puoi eseguire checkil comando per verificare l'integrità. Per garantire un controllo di integrità adeguato in futuro, leggi la sezione " Catena di integrità" e segui i consigli ivi contenuti.

Altri esempi:

Genera solo hash, ma non creare alcun file (-l)
```
auditor hash input_path -l
```
Sovrascrivi i file di controllo (-o), utilizzando un disco veloce (-z) con algoritmo predefinito (utile con i dischi SSD, per essere veloci):
```
auditor hash input_path -o -z 
```
Come sopra, ma con la modalità rigorosa abilitata, per garantire che TUTTI i file in input_path siano sottoposti a hash:
```
auditor hash input_path -o -z --strict
```
Sovrascrivi i file di audit (-o), senza utilizzare il metodo thash (-d):
```
auditor hash input_path -o -d 
```
Sovrascrivi i file di controllo (-o), includi solo i file txt (-i "**/*.txt") solo nella cartella radice (-u 1) (i flag -i e -e usano il modello glob, vedi Note per i dettagli).
```
auditor hash input_path -o -i "**/*.txt" -u 1
```
Sovrascrivi i file di controllo (-o), includi tutti i file, tranne i file txt (-e "**/*.txt")
```
auditor hash input_path -o -e "**/*.txt" 
```
Sovrascrivi i file di controllo (-o), includi solo i file con nome "file1.doc" (-i "**/*/file1.doc") e "file2.xls" (-i "**/*/file2.xls")
```
auditor hash input_path -o -i "**/*/file1.doc"  -i "**/*/file2.xls" 
```
Sovrascrivi i file di controllo (-o), includi TUTTI i file, tranne quelli nelle cartelle $RECYCLE.BIN e "System Volume Information". Nota: il carattere $ in $RECYCLE.BIN appartiene a name e deve essere preceduto dal carattere \ per essere analizzato correttamente!
```
auditor hash input_path -o -e "**/\$RECYCLE.BIN/**" -e "**/System Volume Information/**" 
```
Sovrascrivi i file di controllo (-o), includi tutti i file txt (-i "**/*/*.txt"), eccetto quello all'interno della directory denominata cartella1 (-e "**/*/cartella1/*")
```
auditor hash input_path -z -o -a blake3 -i "**/*/*.txt" -e "**/*/folder1/*" 
```
Sovrascrivi i file di controllo (-o), usa fast-disk (-z) e l'algoritmo 'blake3' (molto veloce):
```
auditor hash input_path -o -z -a blake3
```
Sovrascrivi i file di controllo (-o), usa blockSize 10 MB e la funzione hash 'whirlpool'
```
auditor hash input_path -o -b 10MB -a whirlpool
```

)

lockÈ utile quando è necessario preservare i file di audit esistenti. Può essere utilizzato dopo il comando hash e impedire la generazione accidentale di nuovi file di audit in input_path.

Utilizzo di base del blocco del sottocomando

auditor lock input_path

Ciò:

Crea un file _auditor_lock.txtcon input_path timestamp di creazione.
Il sottocomando hash non verrà eseguito su un oggetto input_pathbloccato.

Per sbloccare input_path, è necessario eliminare manualmente il file_auditor_lock.txt

)

checkÈ il secondo passaggio dell'audit forense. Verifica l'integrità dei dati utilizzando le informazioni contenute nei file di audit e può essere utilizzato dopo l'esecuzione dell'hash.

Utilizzo di base del sottocomando Check

auditor check input_path

Ciò:

Ottieni i file di controllo (percorso predefinito: all'interno della radice di input_path):
Utilizzare i dati di integrità elencati in Audit_Stampe verificarli Audit_FullList.
Utilizzare i dati di integrità elencati in Audit_FullListe confrontarli con i file originali in input_path.
Mostra i dati di integrità ricalcolati di Audit_FullList.

Altri esempi:

Controllare in modalità disco veloce (-z), utilizzando i file di controllo predefiniti.
```
auditor check input_path -z 
```
Come sopra, ma con la modalità rigorosa abilitata, per garantire che TUTTI i file in input_path vengano verificati.
```
auditor check input_path -z --strict
```
Controlla solo i file txt (-i "**/*.txt"), utilizzando i file di controllo predefiniti (i flag -i e -e utilizzano il modello glob, vedere le Note per i dettagli).
```
auditor check input_path -i "**/*.txt"
```
Esegui il controllo in modalità silenziosa (-q) e interrompi al primo errore (-x), utilizzando i file di controllo predefiniti.
```
auditor check input_path -q -x
```
Controllare F:\data_path utilizzando file di controllo con nomi specifici. (-f per <Audit_FullList> e -s per <Audit_Stamp>)
```
auditor check F:\data_path -f C:\other_path\personal_fullList.txt -s C:\other_path\personal_stamp.txt -q -x 
```
Controlla l'integrità di un solo file in <input_path> rispetto a un file di audit
```
auditor check F:\data_path\file1.txt -f C:\other_path\some_audit.txt -q -x 
```

Nota: il controllo dell'auditor è compatibile con il formato fsum.

)

cloneviene utilizzato per copiare i dati all'interno input_pathe dest_pathallo stesso tempo verificare l'integrità dei dati copiati.

Utilizzo di base del sottocomando clone

auditor clone input_path dest_path

Ciò:

Ottieni file da input_path, genera dati di integrità (hash, dimensione, nome);
Copia i file in dest_path;
Controlla l'integrità dei file dest_pathrispetto ai dati di integrità generati in input_path.
Se i file di audit NON esistono, è possibile crearli in input_pathe/o in dest_pathcon l'opzione -g. Se i file di audit esistono, non è possibile crearli.

In caso di errore, verrà effettuato un nuovo tentativo (il valore predefinito è 3 volte, ma può essere modificato).

Altri esempi:

In modalità disco veloce (-z).
```
auditor clone input_path dest_path -z 
```
Come sopra, ma con la modalità rigorosa abilitata, per garantire che TUTTI i file in input_path vengano clonati:
```
auditor clone input_path dest_path --strict
```
In modalità silenziosa (-q) e arresto al primo errore (-x).
```
auditor clone input_path dest_path -q -x
```
Clonazione con generazione di file di audit sia in input_path che in dest_path (vedere Note!).
```
auditor clone input_path dest_path -g both 
```
Clonazione con generazione di file di audit solo in dest_path.
```
auditor clone input_path dest_path -g dest 
```
Clonazione con generazione di file di audit solo in input_path.
```
auditor clone input_path dest_path -g input 
```
È possibile utilizzare -i e/o -e per includere o escludere i file del processo (non può essere utilizzato con --strict).
```
auditor clone input_path dest_path -q -x -i "**/*.txt" -e "**/dir1/**/*
```

Note: per generare file di audit, input_pathnon è possibile avere file di audit (Audit_FullList e Audit_Stamp)! Questo per evitare confusione con i file di audit esistenti.

Visualizza tutte le opzioni con auditor clone --help

)

chkcopyviene utilizzato per controllare i dati all'interno input_pathrispetto ai file di audit e copiarli in dest_path, e allo stesso tempo verificare l'integrità dei dati copiati in dest_path.

Utilizzo di base del sottocomando chkcopy

auditor chkcopy input_path dest_path

Ciò:

Ottenere file da input_pathe verificare i dati di integrità dai file di audit;
Copia i file in dest_path;
Verificare l'integrità dei file confrontandola dest_pathcon i dati di integrità dei file di audit.
Nota: chkcopy non genera file di audit!

In caso di errore, verrà effettuato un nuovo tentativo (il valore predefinito è 3 volte, ma può essere modificato).

Altri esempi:

In modalità disco veloce (-z) per dischi veloci come SSD, M.2, ecc.
```
auditor chkcopy input_path dest_path -z 
```
Come sopra, ma con la modalità rigorosa abilitata, per garantire che TUTTI i file in input_path vengano controllati e copiati:
```
auditor chkcopy input_path dest_path --strict
```
In modalità silenziosa (-q) e arresto al primo errore (-x).
```
auditor chkcopy input_path dest_path -q -x
```
È possibile utilizzare -i e/o -e per includere o escludere i file del processo (non può essere utilizzato con --strict).
```
auditor clone input_path dest_path -q -x -i "**/*.txt" -e "**/dir1/**/*
```

Nota: input_path è necessario disporre dei file di audit (Audit_FullList / Audit_Stamp)!

)

infoNon esegue il controllo di integrità dell'hash. Verifica solo i file di audit e il loro contenuto input_path, mostrando informazioni utili. Può essere utilizzato dopo l'esecuzione dell'hash.

Esempio di informazioni forensi

auditor info input_path

Ciò:

Ottieni i file di controllo (percorso predefinito: all'interno della radice di input_path):
Verificare se i file di audit Audit_Stampesistono Audit_FullList.
Verifica se i file elencati in Audit_Stampe Audit_FullListesistono e se la dimensione elencata è la stessa di quella in input_path.
Verificare se tutti i file input_pathsono elencati in Audit_FullList.
Ricalcola i dati di integrità Audit_FullList e verificali rispetto al file di auditAudit_Stamp
Fornisci un report delle dimensioni dei file e di tutti gli input_path.

)

Note

1: In Windows PowerShell, i percorsi con nomi che contengono spazi devono essere racchiusi tra virgolette senza la singola virgoletta finale \. Se lo si desidera, utilizzare una doppia barra rovesciata alla fine di \\. Questo perché la singola barra rovesciata evita le virgolette finali e il terminale non riesce a interpretare correttamente il percorso.

Funziona così: "C:\My Data Path" o"C:\My Data Path\\"

Questo fallisce: "C:\My Data Path\"

2: I flag -i e -e (pattern di inclusione ed esclusione) utilizzano la sintassi glob. Consulta un breve manuale qui!

Scaricamento

Scarica e controlla l'integrità dei dati binari (all'interno dello zip):

Disclaimer: Questa versione auditorè fornita come software in fase di sviluppo, SENZA alcuna garanzia o supporto di alcun tipo , ed è gratuita solo per uso non commerciale . Utilizzatela a vostro rischio e pericolo.

Licenza: Questa versione auditorè concessa in licenza esclusivamente per uso non commerciale . Per maggiori dettagli, consultare i termini di licenza completi .

Extra

Formato dei file di audit

Il formato dei file di audit è semplice. Ogni riga contiene:

hash_value ?ALGORITHM[<THASH-BlockSize>]|file_size[:hex]*relative_filepath

dove [ ] sono facoltativi:

hash_value: valore dell'hash.

ALGORITHM[<THASH-BlockSize>]: ALGORITMO utilizzato per l'hashing, memorizzato in lettere maiuscole per mantenere la compatibilità con altri strumenti. Il parametro con <THASH-BlockSize> è facoltativo, a indicare che sono stati utilizzati il metodo thash e BlockSize. BlockSize deve essere in KB, MB, GB o TB. Es: 10 MB.

file_size: Dimensione del file originale al momento dell'hashing. Utile per migliorare la velocità quando le dimensioni non corrispondono. Perché eseguire l'hashing di un file di grandi dimensioni quando si sa già che le sue dimensioni non corrispondono a quelle originali?

[:hex]: Flag facoltativo per indicare che i percorsi dei file sono in formato esadecimale. Questo è necessario perché caratteri come '\n', '\r' o '\0' sono consentiti in alcuni sistemi operativi e il formato esadecimale evita problemi di formattazione dei risultati.

relative_filepath: Il percorso relativo del file sottoposto ad hash.

Esempio 1: utilizzo del metodo thashcon algoritmo sha256 e BlockSize 50MB:

281d5d93464f1165ea7c403ca99d63ff4bf9a360864f8df4bd0e8e6c03774e98 ?SHA256<THASH-50MB>|500000*file_hashed.bin

Esempio 2: utilizzo del metodo normale, solo con l'algoritmo blake3, con percorso file in formato esadecimale.

7357b67824d086dc53f5e1ded565f500456bea1812783f1fbcddc08fddc3944c ?BLAKE3|2233:hex*1aCb344356e4e2b2b6

In futuro potranno essere implementati altri formati.

Punti di riferimento

Utilizzando iperfine , test tra auditorSono stati eseguiti fsum, rhash e hashdeep64 e i risultati sono mostrati di seguito.

Machine configs:

S.O.: Windows 11 Home 64bits
Processor: AMD Ryzen 7 (7800X3D 4.20 GHz)
RAM: 64 GB of RAM (Corsair Vengeance DDR5 64GB - 5200MHz)
Disk: SSD M.2 2TB (Corsair MP600 Pro NVMe)

Data Source 1:

Benchmarks using Data Source 1:

Data Source 2

Benchmarks using Data Source 2: