Auditeur

Chaîne d'intégrité

Le processus d'audit utilisé auditorest basé sur le concept de chaîne d'intégrité , fournie par des fichiers d'audit qui stockent les informations d'intégrité.

Les termes impliqués dans ce processus sont les suivants :
Audit_FullList: Le fichier d'audit contient les informations d'intégrité de chaque fichier de données original traité.

Stamp: Les informations d'intégrité actuelles du Audit_FullListfichier Stampsont systématiquement recalculées et affichées lors de l'exécution des actions concernées.

Audit_Stamp: Le fichier d'audit stocke Stampla Audit_FullListdate de création du fichier.

La chaîne d'intégrité est produite dans l'ordre suivant (comportement par défaut) :

Les fichiers de données à l'intérieur input_pathsont traités et génèrent des informations d'intégrité (hachage, taille, chemin d'accès relatif, etc.) qui sont stockées dans Audit_FullList.

Audit_FullListest également traité, générant Stamp, qui est imprimé dans le terminal et stocké dans Audit_Stamp.

La vérification de la chaîne d'intégrité s'effectue dans l'ordre inverse du processus décrit ci-dessus : les fichiers sont retraités et leur intégrité est comparée aux fichiers d'audit. La valeur Stampest également recalculée, affichée dans le terminal et comparée à celle stockée dans le répertoire spécifié Audit_Stampafin de vérifier sa correspondance.

Pour procéder à la génération des fichiers d'audit et garantir que la vérification future de la chaîne d'intégrité soit effectuée correctement et en toute sécurité, suivez les étapes ci-dessous :

Organisez vos fichiers de données dans un dossier spécifique (appelé « chemin_entréeinput_path »). Une fois Auditor installé, ouvrez un terminal et exécutez la commande suivante : `auditor --version` auditor hash input_path. Par défaut, cette commande créera les fichiers d'audit Audit_FullListà Audit_Stampla racine du dossier `input_path`. (Vous pouvez modifier ce comportement si nécessaire.)
Sauvegardez toutes les données, y compris les fichiers d'audit, et imprimez -les Audit_Stampou signez-les numériquement .
Si vous omettez cette étape, n'importe qui pourrait modifier les données et générer de nouveaux fichiers d'audit, compromettant ainsi la vérification d'intégrité. Si vous n'avez pas accès à une imprimante ou à un certificat numérique, vous pouvez utiliser un service d'horodatage gratuit pour signer le fichier en ligne, tel que freetsa.org (via la signature en ligne) .
Vous pouvez également créer un package (fichier ZIP, TAR ou autre) contenant vos fichiers de données et les fichiers d'audit. Effectuez plusieurs copies de sauvegarde de ce package sur différents supports.
Par la suite, lorsqu'une vérification est effectuée auditor check, la chaîne d'intégrité décrite précédemment est exécutée. À la fin du processus, les données d'intégrité Audit_FullListsont recalculées et affichées dans le terminal ; elles DOIVENT correspondre exactement à la valeur affichée ou signée numériquement à l'étape précédente. En cas de non-correspondance, la vérification d'intégrité est invalide .
Vous pouvez également vérifier l'intégrité des fichiers de données originaux individuels à l'aide des données contenues dans Audit_FullList. Voir les exemples dans la section utilisation de auditor check.

Usage

Consultez un manuel abrégé ici.

Une fois auditorinstallé sur votre système, vous pouvez l'utiliser comme suit :

auditor subcommands: info

hash

lock

check

info

clone

chkcopy

hashIl s'agit de la première étape de l'audit forensique. Elle génère des fichiers d'audit permettant de vérifier l'intégrité des fichiers.

Utilisation de base de la sous-commande hash

auditor hash input_path

Cela permettra de :

Hacher les fichiers input_pathavec l'algorithme par défaut ( sha256)
Générer les fichiers d'audit (Chemin par défaut : à la racine de input_path) :
- Audit_FullList: contient les données d'intégrité (hachage, taille, nom) des fichiers dans input_path. Nom par défaut : _auditor_hashes.txt
- Audit_Stamp: contient uniquement les données d'intégrité de Audit_FullList. Nom par défaut : _auditor_stamp.txt. Il s'agit du fichier qui doit être imprimé ou signé numériquement pour garantir la vérification de toute la chaîne d'intégrité.
Afficher les données d'intégrité deAudit_FullList

hashVous pouvez ensuite exécuter checkune commande pour vérifier l'intégrité. Pour garantir un contrôle d'intégrité optimal à l'avenir, consultez la section « Chaîne d'intégrité » et suivez les conseils qui y sont donnés.

Autres exemples :

Générer uniquement des hachages, sans créer de fichiers (-l)
```
auditor hash input_path -l
```
Écraser les fichiers d'audit (-o), en utilisant un disque rapide (-z) avec l'algorithme par défaut (utile avec les disques SSD, pour plus de rapidité) :
```
auditor hash input_path -o -z 
```
Même chose que ci-dessus, mais avec le mode strict activé, pour garantir que TOUS les fichiers dans input_path sont hachés :
```
auditor hash input_path -o -z --strict
```
Écraser les fichiers d'audit (-o), sans utiliser la méthode thash (-d) :
```
auditor hash input_path -o -d 
```
Écraser les fichiers d'audit (-o), inclure uniquement les fichiers txt (-i "**/*.txt") uniquement dans le dossier racine (-u 1) (les options -i et -e utilisent un modèle glob, voir les notes pour plus de détails).
```
auditor hash input_path -o -i "**/*.txt" -u 1
```
Écraser les fichiers d'audit (-o), inclure tous les fichiers, sauf les fichiers txt (-e "**/*.txt")
```
auditor hash input_path -o -e "**/*.txt" 
```
Écraser les fichiers d'audit (-o), inclure uniquement les fichiers nommés « file1.doc » (-i « **/*/file1.doc ») et « file2.xls » (-i « **/*/file2.xls »).
```
auditor hash input_path -o -i "**/*/file1.doc"  -i "**/*/file2.xls" 
```
Écraser les fichiers d'audit (-o), inclure TOUS les fichiers, sauf ceux contenus dans les dossiers $RECYCLE.BIN et « System Volume Information ». Remarque : le caractère $ dans $RECYCLE.BIN appartient au nom et doit être précédé d'une barre oblique inverse (\) pour être correctement interprété.
```
auditor hash input_path -o -e "**/\$RECYCLE.BIN/**" -e "**/System Volume Information/**" 
```
Écraser les fichiers d'audit (-o), inclure tous les fichiers txt (-i "**/*/*.txt"), sauf ceux du répertoire nommé folder1 (-e "**/*/folder1/*")
```
auditor hash input_path -z -o -a blake3 -i "**/*/*.txt" -e "**/*/folder1/*" 
```
Écraser les fichiers d'audit (-o), utiliser le disque rapide (-z) et l'algorithme 'blake3' (très rapide) :
```
auditor hash input_path -o -z -a blake3
```
Écraser les fichiers d'audit (-o), utiliser une taille de bloc de 10 Mo et la fonction de hachage « whirlpool ».
```
auditor hash input_path -o -b 10MB -a whirlpool
```

)

lockCette fonction est utile lorsque les fichiers d'audit existants doivent être conservés. Elle peut être utilisée après la commande de hachage et empêcher la génération accidentelle de nouveaux fichiers d'audit input_path.

Utilisation de base de la sous-commande lock

auditor lock input_path

Cela permettra de :

Créer un fichier _auditor_lock.txtavec input_path un horodatage de création.
La sous-commande Hash ne sera pas exécutée sur un input_pathélément verrouillé.

Pour déverrouiller input_path, vous devez supprimer manuellement le fichier_auditor_lock.txt

)

checkIl s'agit de la deuxième étape de l'audit forensique. Elle vérifie l'intégrité des données à l'aide des informations contenues dans les fichiers d'audit et peut être utilisée après le hachage.

Utilisation de base de la sous-commande Vérifier

auditor check input_path

Cela permettra de :

Récupérer les fichiers d'audit (chemin par défaut : à la racine de input_path) :
Utilisez les données d'intégrité listées dans Audit_Stampet vérifiez-les par rapport à Audit_FullList.
Utilisez les données d'intégrité répertoriées dans Audit_FullListet vérifiez-les par rapport aux fichiers originaux dans input_path.
Afficher les données d'intégrité recalculées de Audit_FullList.

Autres exemples :

Vérifier en mode disque rapide (-z), en utilisant les fichiers d'audit par défaut.
```
auditor check input_path -z 
```
Même procédure que ci-dessus, mais avec le mode strict activé, afin de garantir que TOUS les fichiers du répertoire input_path soient vérifiés.
```
auditor check input_path -z --strict
```
Vérifier uniquement les fichiers txt (-i "**/*.txt"), en utilisant les fichiers d'audit par défaut (les options -i et -e utilisent le modèle glob, voir les notes pour plus de détails).
```
auditor check input_path -i "**/*.txt"
```
Vérifier en mode silencieux (-q) et s'arrêter à la première erreur (-x), en utilisant les fichiers d'audit par défaut.
```
auditor check input_path -q -x
```
Vérifiez le chemin d'accès aux données dans F:\data_path à l'aide des fichiers d'audit portant des noms spécifiques. (-f pour <Audit_FullList> et -s pour <Audit_Stamp>)
```
auditor check F:\data_path -f C:\other_path\personal_fullList.txt -s C:\other_path\personal_stamp.txt -q -x 
```
Vérifier l'intégrité d'un seul fichier dans <input_path> par rapport à un fichier d'audit
```
auditor check F:\data_path\file1.txt -f C:\other_path\some_audit.txt -q -x 
```

Remarque : Le contrôle d'audit est compatible avec le format fsum.

)

cloneest utilisé pour copier les données internes input_pathet dest_path, simultanément, vérifier l'intégrité des données copiées.

Utilisation de base de la sous-commande clone

auditor clone input_path dest_path

Cela permettra de :

Récupérer les fichiers depuis input_path, générer des données d'intégrité (hash, taille, nom) ;
Copier les fichiers vers dest_path;
Vérifier l'intégrité des fichiers par dest_pathrapport aux données d'intégrité générées dans input_path.
Si les fichiers d'audit n'existent pas, vous pouvez les créer dans input_pathet/ou dest_pathavec l'option -g. S'ils existent déjà, vous ne pouvez pas en créer de nouveaux.

En cas d'erreur, il réessayera (3 fois par défaut, ce nombre peut être modifié).

Autres exemples :

En mode disque rapide (-z).
```
auditor clone input_path dest_path -z 
```
Même procédure que ci-dessus, mais avec le mode strict activé, afin de garantir que TOUS les fichiers du répertoire input_path soient clonés :
```
auditor clone input_path dest_path --strict
```
En mode silencieux (-q) et arrêt à la première erreur (-x).
```
auditor clone input_path dest_path -q -x
```
Clonage avec génération de fichiers d'audit dans input_path et dest_path (Voir les notes !).
```
auditor clone input_path dest_path -g both 
```
Clonage avec génération de fichiers d'audit uniquement dans dest_path.
```
auditor clone input_path dest_path -g dest 
```
Clonage avec génération de fichiers d'audit uniquement dans input_path.
```
auditor clone input_path dest_path -g input 
```
Vous pouvez utiliser -i et/ou -e pour inclure ou exclure des fichiers du processus (ne peut pas être utilisé avec --strict).
```
auditor clone input_path dest_path -q -x -i "**/*.txt" -e "**/dir1/**/*
```

Remarques : Pour générer des fichiers d’audit, input_pathles fichiers d’audit (Audit_FullList et Audit_Stamp) ne doivent pas être présents ! Ceci afin d’éviter toute confusion avec les fichiers d’audit existants.

Afficher toutes les options avec auditor clone --help

)

chkcopyest utilisé pour vérifier les données internes input_pathpar rapport aux fichiers d'audit et les copier vers dest_path, et en même temps vérifier l'intégrité des données copiées dans dest_path.

Utilisation de base de la sous-commande chkcopy

auditor chkcopy input_path dest_path

Cela permettra de :

Récupérez les fichiers input_pathet vérifiez leur intégrité par rapport aux données des fichiers d'audit ;
Copier les fichiers vers dest_path;
Vérifier l'intégrité des fichiers par dest_pathrapport aux données d'intégrité des fichiers d'audit.
Remarque : chkcopy ne génère pas de fichiers d'audit !

En cas d'erreur, il réessayera (3 fois par défaut, ce nombre peut être modifié).

Autres exemples :

En mode disque rapide (-z) pour les disques rapides comme les SSD, m.2, etc.
```
auditor chkcopy input_path dest_path -z 
```
Même procédure que ci-dessus, mais avec le mode strict activé, afin de garantir que TOUS les fichiers du répertoire input_path soient vérifiés et copiés :
```
auditor chkcopy input_path dest_path --strict
```
En mode silencieux (-q) et arrêt à la première erreur (-x).
```
auditor chkcopy input_path dest_path -q -x
```
Vous pouvez utiliser -i et/ou -e pour inclure ou exclure des fichiers du processus (ne peut pas être utilisé avec --strict).
```
auditor clone input_path dest_path -q -x -i "**/*.txt" -e "**/dir1/**/*
```

Remarque : input_path les fichiers d'audit (Audit_FullList / Audit_Stamp) sont indispensables !

)

infoN'effectue pas de vérification d'intégrité du hachage. Teste uniquement les fichiers d'audit et leur contenu, input_pathet affiche des informations utiles. Peut être utilisé après le calcul du hachage.

Exemple d'informations médico-légales

auditor info input_path

Cela permettra de :

Récupérer les fichiers d'audit (chemin par défaut : à la racine de input_path) :
Vérifiez si les fichiers d'audit Audit_Stampexistent Audit_FullList.
Vérifiez si les fichiers listés dans Audit_Stampet Audit_FullListexistent et si la taille indiquée est la même que dans input_path.
Vérifiez si tous les fichiers du répertoire input_pathsont répertoriés dans Audit_FullList.
Recalculez les données d'intégrité Audit_FullList et comparez-les au fichier d'audit.Audit_Stamp
Fournissez un rapport sur la taille des fichiers et de tous les chemins d'entrée.

)

Notes

1 : Dans Windows PowerShell, les chemins d'accès contenant des espaces doivent être placés entre guillemets sans un seul point final \. Si vous le souhaitez, utilisez une double barre oblique inverse (\\) \\. En effet, une seule barre oblique inverse échappe les guillemets finaux, et le terminal ne peut pas interpréter correctement le chemin.

Cela fonctionne : "C:\My Data Path" ou"C:\My Data Path\\"

Cela échoue : "C:\My Data Path\"

2 : Les options -i et -e (inclure et exclure des motifs) utilisent la syntaxe glob. Consultez un bref manuel ici !

Télécharger

Téléchargement et données d'intégrité des fichiers binaires (dans l'archive zip) :

Avertissement : Cette version auditorest fournie en tant que logiciel en développement, sans aucune garantie ni assistance , et est gratuite uniquement pour un usage non commercial . Son utilisation se fait à vos propres risques.

Licence : Cette version auditorest concédée sous licence pour un usage non commercial uniquement . Veuillez consulter l’ intégralité des conditions de la licence pour plus de détails.

Extras

Format des fichiers d'audit

Le format des fichiers d'audit est simple. Chaque ligne contient :

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

où les crochets [ ] sont facultatifs :

hash_value: valeur du hachage.

ALGORITHM[<THASH-BlockSize>]L'algorithme de hachage utilisé est indiqué en majuscules pour assurer la compatibilité avec certains outils. Le paramètre <THASH-BlockSize> est facultatif et précise la méthode de hachage et la taille de bloc (BlockSize) utilisées. BlockSize doit être exprimé en Ko, Mo, Go ou To. Exemple : 10 Mo.

file_sizeTaille du fichier original au moment du hachage. Utile pour vérifier et améliorer la vitesse lorsque la taille ne correspond pas. Pourquoi hacher un fichier volumineux si l'on sait déjà que sa taille diffère de celle de l'original ?

[:hex]Indicateur optionnel permettant de spécifier que les chemins d'accès aux fichiers sont au format hexadécimal. Ceci est nécessaire car certains systèmes d'exploitation autorisent les caractères tels que « \n », « \r » ou « \0 », et l'hexadécimal évite les problèmes de formatage des résultats.

relative_filepath: Le chemin relatif du fichier haché.

Exemple 1 : utilisation de la méthode thashavec l'algorithme sha256 et une taille de bloc de 50 Mo :

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

Exemple 2 : en utilisant la méthode normale, avec l’algorithme blake3, avec le chemin d’accès au format hexadécimal.

7357b67824d086dc53f5e1ded565f500456bea1812783f1fbcddc08fddc3944c ?BLAKE3|2233:hex*1aCb344356e4e2b2b6

D'autres formats pourront être mis en œuvre ultérieurement.

Points de référence

En utilisant hyperfine , des tests entre auditorLes opérations fsum, rhash et hashdeep64 ont été effectuées et les résultats sont présentés ci-dessous.

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: