google/hashrGénère des ensembles de hachages de fichiers forensiques à partir d'images disque, de paquets et d'archives provenant de sources GCP, AWS et locales, avec déduplication et export PostgreSQL/Spanner pour les flux de travail DFIR.
HashR vous permet de créer vos propres ensembles de hachages à partir de vos sources de données. C'est un outil qui extrait des fichiers et des hachages de sources d'entrée (par exemple, image de disque brute, image de disque GCE, fichier ISO, package de mise à jour Windows, fichier .tar.gz, etc.).
HashR se compose des composants suivants :
Importeurs actuellement implémentés :
Une fois les fichiers extraits et hachés, les résultats sont transmis aux exportateurs ; exportateurs actuellement implémentés :
Vous pouvez choisir les importeurs que vous souhaitez exécuter ; chacun a des exigences différentes. Vous trouverez plus de détails dans les sections ci-dessous.
HashR nécessite un système d'exploitation Linux pour fonctionner ; il peut s'agir d'une machine physique, virtuelle ou cloud. Voici les exigences matérielles optimales :
HashR peut probablement fonctionner sur des machines avec des spécifications inférieures, mais cela n'a pas été testé en profondeur.
Pour compiler le binaire hashr, exécutez la commande suivante :``` shell env GOOS=linux GOARCH=amd64 go build hashr.go
Pour exécuter les tests du package hashR principal, vous devez exécuter l'émulateur Spanner :``` shell
gcloud emulators spanner start
Ensuite, pour exécuter tous les tests, lancez la commande suivante :``` shell go test -timeout 2m ./...
## Configuration de HashR
### HashR dans l'infrastructure OSDFIR
Vous pouvez déployer HashR dans le cadre du [projet OSDFIR Infrastructure](https://github.com/google/osdfir-infrastructure/tree/main/charts/hashr)
Ce déploiement exécutera HashR sous forme de cronjobs Kubernetes et permet une intégration facile avec Timesketch.
### HashR avec Docker
Pour exécuter HashR dans un conteneur Docker, consultez le [guide spécifique à Docker](https://github.com/google/hashr/blob/main/docker/README.md)
### Configuration du système d'exploitation et outils tiers requis
HashR s'occupe du gros du travail (analyse d'images disque, de volumes, de systèmes de fichiers) en utilisant Plaso. Vous devez récupérer le conteneur Docker Plaso à l'aide de la commande suivante :``` shell
docker pull log2timeline/plaso
Nous avons également besoin que 7z, qui est utilisé par l'importateur WSUS pour l'extraction récursive des paquets Windows Update, soit installé sur la machine exécutant HashR :``` shell sudo apt install p7zip-full
Vous devez autoriser l'utilisateur sous lequel HashR s'exécutera à exécuter certaines commandes via sudo. En supposant que votre utilisateur est `hashr`, créez un fichier `/etc/sudoers.d/hashr` et insérez-y :``` shell
hashr ALL = (root) NOPASSWD: /bin/mount,/bin/umount,/sbin/losetup,/bin/rm
L'utilisateur sous lequel HashR sera exécuté devra également être en mesure d'exécuter docker. En supposant que votre utilisateur est hashr, ajoutez-le au groupe docker comme ceci :``` shell
sudo usermod -aG docker hashr
### Configuration du stockage pour les tâches de traitement
HashR doit stocker des informations sur les sources traitées. Il stocke également des données de télémétrie supplémentaires sur les tâches de traitement : temps de traitement, nombre de fichiers extraits, etc. Vous pouvez choisir entre :
1. PostgreSQL
1. Cloud (GCP) Spanner
#### Configuration du stockage PostgreSQL
Il existe de nombreuses façons d'exécuter et de maintenir votre instance PostgreSQL. L'une des façons les plus simples serait de l'exécuter dans un conteneur Docker. Suivez les étapes ci-dessous pour configurer un conteneur Docker PostgreSQL.
Étape 1 : Tirez l'image Docker de PostgreSQL.``` shell
docker pull postgres
Étape 2 : Initialisez et exécutez le conteneur PostgreSQL en arrière-plan. Assurez-vous de modifier le mot de passe.``` shell docker run -itd -e POSTGRES_DB=hashr -e POSTGRES_USER=hashr -e POSTGRES_PASSWORD=hashr -p 5432:5432 -v /data:/var/lib/postgresql/data --name hashr_postgresql postgres
Étape 3: Créez une table qui sera utilisée pour stocker les tâches de traitement.``` shell
cat scripts/CreateJobsTable.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Afin d'utiliser PostgreSQL pour stocker des informations sur les tâches de traitement, vous devez spécifier les options suivantes : -storage postgres -postgres_host <host> -postgres_port <port> -postgres_user <user> -postgres_password <pass> -postgres_db <db_name>
Vous pouvez choisir de stocker les données concernant les tâches de traitement dans Cloud Spanner. Vous aurez besoin d'un projet Google Cloud pour cela. Le principal avantage de cette configuration est que vous pouvez facilement créer des tableaux de bord à l'aide de Google Data Studio et vous connecter directement à l'instance Cloud Spanner, ce qui permet la surveillance et le débogage sans exécuter de requêtes sur votre instance PostgreSQL.
En supposant que votre outil gcloud soit configuré avec votre projet GCP cible hashr, vous devrez suivre les étapes ci-dessous pour activer Cloud Spanner.
Créez le compte de service HashR :``` shell gcloud iam service-accounts create hashr --description="HashR SA key." --display-name="hashr"
Créez une clé de compte de service et stockez-la dans votre répertoire personnel. Définissez *<project_name>* sur le nom de votre projet.``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS sur votre clé de compte de service :``` shell export GOOGLE_APPLICATION_CREDENTIALS=/home/hashr/hashr-sa-private-key.json
Créez une instance Spanner, ajustez la configuration et la valeur de processing-units si nécessaire :``` shell
gcloud spanner instances create hashr --config=regional-us-central1 --description="hashr" --processing-units=100
Créer la base de données Spanner :``` shell gcloud spanner databases create hashr --instance=hashr
Autorisez le compte de service à utiliser la base de données Spanner, définissez *<project_name>* sur le nom de votre projet :``` shell
gcloud spanner databases add-iam-policy-binding hashr --instance hashr --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/spanner.databaseUser"
Mettre à jour le schéma de la base de données Spanner:``` shell gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateJobsTable.ddl
Afin d'utiliser Cloud Spanner pour stocker des informations sur les tâches de traitement, vous devez spécifier les options suivantes : `-jobStorage cloudspanner -spannerDBPath <spanner_db_path>`
### Configuration des importateurs
Afin de spécifier l'importateur que vous souhaitez exécuter, vous devez utiliser l'option `-importers`. Valeurs possibles : `GCP,targz,windows,wsus,deb,rpm,zip,gcr,iso9660`
#### GCP (Google Cloud Platform)```shell
-importers GCP
Cet importateur peut extraire des fichiers des images de disque GCP. Cela se fait en quelques étapes :
La liste des projets GCP contenant des images GCP publiques est disponible ici. Pour utiliser cet importateur, vous devez disposer d'un projet GCP et suivre ces étapes :
Étape 1 : Créez le compte de service HashR, si cela a déjà été fait lors de la configuration de Cloud Spanner, veuillez passer à l'étape 4.``` shell gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Étape 2: Créez une clé de compte de service et stockez-la dans votre répertoire personnel. Assurez-vous de définir *<project_name>* sur le nom de votre projet:``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Étape 3 : Pointez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS vers votre clé de compte de service :``` shell export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Étape 4 : Créez un bucket GCS qui sera utilisé pour stocker les images disque au format .tar.gz, définissez *<project_name>* sur votre nom de projet et *<gcs_bucket_name>* sur le nom de votre nouveau bucket GCS :``` shell
gcloud storage buckets create gs://<gcs_bucket_name> --project=<project_name>
Étape 5: Rendre le compte de service administrateur de ce bucket:``` shell gcloud storage buckets add-iam-policy-binding gs://<gcs_bucket_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/storage.objectAdmin"
Étape 6: Activer l'API Compute:``` shell
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com
Étape 7 : Créer un rôle IAM et lui attribuer les autorisations requises :``` shell gcloud iam roles create hashr --project=<project_name> --title=hashr --description="Permissions required to run hashR" --permissions compute.images.create,compute.images.delete,compute.globalOperations.get
Étape 8 : Lier le rôle IAM au compte de service :``` shell
gcloud projects add-iam-policy-binding <project_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="projects/<project_name>/roles/hashr"
Étape 9a : Activer l'API cloudbuild``` shell gcloud services enable cloudbuild.googleapis.com --project <project_name>
Étape 9b: Obtenez votre project_number```shell
gcloud projects list --filter="mlegin-testing-things" --format="value(PROJECT_NUMBER)"
Step 9c : Accordez aux comptes de service les accès nécessaires pour exécuter Cloud Build, assurez-vous de modifier les valeurs <project_name> et <project_number> :``` shell gcloud projects add-iam-policy-binding <project_name> --member='serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com' --role='roles/storage.admin'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com'
--role='roles/viewer'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com'
--role='roles/resourcemanager.projectIamAdmin'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com'
--role='roles/cloudbuild.builds.editor'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>@cloudbuild.gserviceaccount.com'
--role='roles/compute.admin'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>@cloudbuild.gserviceaccount.com'
--role='roles/iam.serviceAccountUser'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>@cloudbuild.gserviceaccount.com'
--role='roles/iam.serviceAccountTokenCreator'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>@cloudbuild.gserviceaccount.com'
--role='roles/compute.networkUser'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>[email protected]'
--role='roles/compute.storageAdmin'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>[email protected]'
--role='roles/storage.objectViewer'
gcloud projects add-iam-policy-binding <project_name>
--member='serviceAccount:<project_number>[email protected]'
--role='roles/storage.objectAdmin'
Pour utiliser cet importateur, vous devez spécifier le(s) indicateur(s) suivant(s) :
1. `-gcp_projects` qui est une liste de projets cloud séparés par des virgules contenant des images disque. Si vous souhaitez importer des images publiques, consultez [ici](https://cloud.google.com/compute/docs/images/os-details#general-info)
1. `-hashr_gcp_project` Projet GCP qui sera utilisé pour stocker une copie des images disque pour traitement et également exécuter Cloud Build
1. `-hashr_gcs_bucket` Bucket GCS qui sera utilisé pour stocker la sortie de Cloud Build (images disque au format .tar.gz)
#### AWS
Cet importateur traite les AMI appartenant à Amazon et génère des hashs. L'importateur nécessite au moins un worker HashR (une instance EC2).
##### AWS HashR Workers
Le worker HashR AWS est une instance EC2 où le volume de l'AMI est attaché, l'archive disque est créée, puis téléchargée vers le bucket S3. Il est recommandé d'avoir au moins deux workers HashR AWS. Si votre configuration utilise un seul worker AWS, utilisez `-processing_worker_count 1`.
Un worker HashR AWS doit satisfaire aux exigences suivantes :
- Les instances EC2 doivent avoir la balise `InUse: false`. Si la valeur est `true`, le worker n'est pas utilisé pour le traitement.```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Tags’
Le système exécutant hashr doit pouvoir se connecter en SSH à l'instance EC2 en utilisant :
Keyname. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’Vers le FQDN comme décrit dans PublicDnsName. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].PublicDnsName’
scripts/hashr-archive doit être copié vers le worker AWS HashR dans /usr/local/sbin/hashr-archive
Un compte AWS avec l'autorisation de téléverser des fichiers vers le bucket HashR. La configuration et les identifiants AWS doivent être stockés dans le répertoire $HOME/.aws/.```shell
aws configure
##### Application HashR
Sur le système qui exécute `hashr`, les éléments suivants sont requis.
- Un compte AWS avec les autorisations nécessaires pour appeler les API suivantes :
- EC2
- AttachVolume
- CopyImage
- CreateTags
- CreateVolume
- DeleteVolume
- DescribeAvailabilityZones
- DescribeImages
- DescribeInstances
- DescribeSnapshots
- DescribeVolumes
- DetachVolume
- S3
- DeleteObject
- La configuration du compte AWS et le fichier d'identification doivent être situés dans le répertoire `$HOME/.aws/`.
- La clé privée SSH utilisée pour AWS HashR doit être située dans le répertoire `$HOME/.ssh/`. Elle doit correspondre à la valeur de `Keyname` comme décrit dans `aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’`
##### Configuration de l'instance AWS EC2
Cette section décrit comment créer des instances EC2 à utiliser avec HashR. Idéalement, nous voulons deux comptes AWS : `hashr.uploader` et `hashr.worker`.
`hashr.uploader` est utilisé sur les instances EC2 et nécessite des autorisations pour téléverser les images de disque archivées vers le bucket S3. `scripts/aws/AwsHashrUploaderPolicy.json` contient un exemple de politique pour le bucket S3 `hashr-bucket`.
`hashr.worker` est utilisé sur l'ordinateur qui exécute les commandes HashR. Le compte nécessite des autorisations EC2 et S3. `scripts/aws/AwsHashrWorkerPolicy.json` contient un exemple de politique pour le compte `hashr.worker`.
`hashr_setup.sh` est un script qui aide à créer des instances EC2. Modifiez `hashr_setup.sh`, puis examinez et mettez à jour les champs suivants selon vos besoins :
- `AWS_PROFILE`
- `AWS_REGION`
- `SECURITY_SOURCE_CIDR`
- `WORKER_AWS_CONFIG_FILE`
**Remarque** : Le fichier spécifié par `WORKER_AWS_CONFIG_FILE` doit exister dans le répertoire contenant `hashr_setup.sh`.
**Remarque** : `hashr_setup.sh` doit être exécuté depuis le même répertoire que `hashr_setup.sh`.
Exécutez les commandes suivantes pour créer et configurer les instances EC2.```shell
$ git clone https://github.com/google/hashr
$ cd hashr/scripts/aws
$ aws configure
$ cp -r ~/.aws ./
$ tar -zcf hashr.uploader.tar.gz .aws
$ hash_setup.sh setup
L'importateur AWS effectue les étapes de haut niveau suivantes :
La commande ci-dessous traite les images debian-12 et les stocke dans une base de données PostgreSQL.```shell
hashr -storage postgres -exporters postgres -importers aws -aws_bucket aws-hashr-bucket -aws_os_filter debian-12
**Remarque**: Amazon Linux (al2023-*) a été utilisé comme worker lors du développement de l'importateur. Ainsi, la valeur par défaut de `-aws_ssh_user` est définie sur `ec2-user`. Une distribution différente peut avoir un utilisateur SSH par défaut différent, utilisez `-aws_ssh_user` pour définir l'utilisateur SSH approprié.
#### GCR (Google Container Registry)
Cet importateur extrait les fichiers des images de conteneurs stockées dans les dépôts GCR. Pour le configurer, suivez ces étapes:
Étape 1: Créez le compte de service HashR, passez à l'étape 4 si cela a été fait lors de la configuration d'autres composants dépendants de GCP.``` shell
gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Étape 2 : Créez une clé de compte de service et stockez-la dans votre répertoire personnel. Assurez-vous de définir <project_name> sur le nom de votre projet :``` shell gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Étape 3: Pointez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS vers votre clé de compte de service:``` shell
export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Étape 4 : Accorder à la clé de compte de service hashR les autorisations requises pour accéder au dépôt GCR donné.``` shell gcloud storage buckets add-iam-policy-binding gs://artifacts.<project_name_hosting_gcr_repo>.appspot.com --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/storage.objectViewer"
Pour utiliser cet importateur, vous devez spécifier la ou les options suivantes :
1. `-gcr_repos` qui doit contenir une liste de dépôts GCR séparés par des virgules, depuis lesquels vous souhaitez importer les images de conteneurs.
#### Windows
Cet importateur extrait les fichiers des médias d'installation Windows officiels au format ISO-13346, par exemple ceux que vous pouvez télécharger depuis le [site Web](https://www.microsoft.com/en-gb/software-download/windows10ISO) officiel de Microsoft.
Un fichier ISO peut contenir plusieurs images WIM :
1. Windows10ProEducation
1. Windows10Education
1. Windows10EducationN
1. Windows10ProN
1. etc.
Cet importateur extraira les fichiers de toutes les images qu'il peut trouver dans le fichier `install.wim`.
#### WSUS
Cet importateur utilise 7z pour extraire récursivement le contenu des packages Windows Update. Il recherchera les fichiers Windows Update dans le bucket GCS fourni ; le moyen le plus simple de mettre à jour automatiquement le bucket GCS avec de nouvelles mises à jour serait de procéder comme suit :
1. Configurez une VM GCE exécutant Windows Server dans le projet GCP hashr.
1. Configurez-la avec le rôle WSUS, sélectionnez les packages Windows Update que vous souhaitez traiter.
1. Configurez WSUS pour approuver automatiquement et télécharger les mises à jour vers le stockage local.
1. Configurez une tâche Windows pour synchroniser automatiquement le contenu du stockage local vers le bucket GCS : `gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/` (n'oubliez pas d'ajuster les chemins).
1. Si vous souhaitez utiliser le nom de fichier du package de mise à jour (qui contient généralement le numéro KB) comme ID (par défaut, c'est sha1, c'est ainsi que MS stocke les mises à jour WSUS) ainsi que sa description, cela peut être extrait de la base de données WID interne de WSUS. Vous pouvez utiliser le script Power Shell suivant et l'exécuter en tant que tâche :```
#SQL Query
$delimiter = ";"
$SqlQuery = 'select DISTINCT CONVERT([varchar](https://github.com/google/hashr/blob/main/512), tbfile.FileDigest, 2) as sha1, tbfile.[FileName], vu.[KnowledgebaseArticle], vu.[DefaultTitle] from [SUSDB].[dbo].[tbFile] tbfile
left join [SUSDB].[dbo].[tbFileForRevision] ffrev
on tbfile.FileDigest = ffrev.FileDigest
left join [SUSDB].[dbo].[tbRevision] rev
on ffrev.RevisionID = rev.RevisionID
left join [SUSDB].[dbo].[tbUpdate] u
on rev.LocalUpdateID = u.LocalUpdateID
left join [SUSDB].[PUBLIC_VIEWS].[vUpdate] vu
on u.UpdateID = vu.UpdateId'
$SqlConnection = New-Object System.Data.SqlClient.SqlConnection
$SqlConnection.ConnectionString = 'server=\\.\pipe\MICROSOFT##WID\tsql\query;database=SUSDB;trusted_connection=true;'
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand
$SqlCmd.CommandText = $SqlQuery
$SqlCmd.Connection = $SqlConnection
$SqlCmd.CommandTimeout = 0
$SqlAdapter = New-Object System.Data.SqlClient.SqlDataAdapter
$SqlAdapter.SelectCommand = $SqlCmd
#Creating Dataset
$DataSet = New-Object System.Data.DataSet
$SqlAdapter.Fill($DataSet)
$DataSet.Tables[0] | export-csv -Delimiter $delimiter -Path "D:\WSUS\WsusContent\export.csv" -NoTypeInformation
gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/
Ceci permettra de vider les informations pertinentes de la base de données WSUS, de les stocker dans le fichier export.csv et de synchroniser le contenu du dossier WSUS avec le bucket GCS. L’importateur WSUS vérifiera si le fichier export.csv est présent à la racine du dépôt WSUS ; si c’est le cas, il l’utilisera.
Il s’agit d’un importateur simple qui parcourt les dépôts et recherche les fichiers .tar.gz. Une fois qu’un fichier est trouvé, il hache les 10 premiers et les 10 derniers Mo du fichier pour vérifier s’il a déjà été traité. Cette opération permet d’éviter de hacher l’intégralité du fichier à chaque analyse du dépôt à la recherche de nouvelles sources. Pour utiliser cet importateur, vous devez spécifier le(s) drapeau(x) suivant(s) :
-targz_repo_path qui doit pointer vers le chemin, sur le système de fichiers local, contenant les fichiers .tar.gzCet importateur est très similaire à celui de TarGz, sauf qu’il recherche les paquets .deb. Une fois qu’un fichier est trouvé, il hache les 10 premiers et les 10 derniers Mo du fichier pour vérifier s’il a déjà été traité. Cette opération permet d’éviter de hacher l’intégralité du fichier à chaque analyse du dépôt à la recherche de nouvelles sources. Pour utiliser cet importateur, vous devez spécifier le(s) drapeau(x) suivant(s) :
-deb_repo_path qui doit pointer vers le chemin, sur le système de fichiers local, contenant les fichiers .debCet importateur est très similaire à celui de TarGz, sauf qu’il recherche les paquets .rpm. Une fois qu’un fichier est trouvé, il hache les 10 premiers et les 10 derniers Mo du fichier pour vérifier s’il a déjà été traité. Cette opération permet d’éviter de hacher l’intégralité du fichier à chaque analyse du dépôt à la recherche de nouvelles sources. Pour utiliser cet importateur, vous devez spécifier le(s) drapeau(x) suivant(s) :
-rpm_repo_path qui doit pointer vers le chemin, sur le système de fichiers local, contenant les fichiers .rpmCet importateur est très similaire à celui de TarGz, sauf qu’il recherche les archives .zip. Une fois qu’un fichier est trouvé, il hache les 10 premiers et les 10 derniers Mo du fichier pour vérifier s’il a déjà été traité. Cette opération permet d’éviter de hacher l’intégralité du fichier à chaque analyse du dépôt à la recherche de nouvelles sources. Pour utiliser cet importateur, vous devez spécifier le(s) drapeau(x) suivant(s) :
-zip_repo_path qui doit pointer vers le chemin, sur le système de fichiers local, contenant les fichiers .zipVous pouvez également définir, de manière facultative, le(s) drapeau(x) suivant(s) :
-zip_file_exts liste de extensions de fichiers séparées par des virgules à traiter comme des fichiers zip, p. ex. « zip,whl,jar ». Défaut : « zip »Cet importateur est très similaire à celui de TarGz, sauf qu’il recherche les fichiers .iso. Une fois qu’un fichier est trouvé, il hache les 10 premiers et les 10 derniers Mo du fichier pour vérifier s’il a déjà été traité. Cette opération permet d’éviter de hacher l’intégralité du fichier à chaque analyse du dépôt à la recherche de nouvelles sources. Pour utiliser cet importateur, vous devez spécifier le(s) drapeau(x) suivant(s) :
-iso_repo_path qui doit pointer vers le chemin, sur le système de fichiers local, contenant les fichiers .isoL’exportateur Postgres permet d’envoyer les hashs, les métadonnées des fichiers et le contenu réel du fichier vers une instance PostgreSQL. Pour des performances optimales, il est conseillé de l’installer sur une machine dédiée et séparée. Si vous avez configuré PostgreSQL lors du choix du stockage des tâches de traitement, vous êtes presque prêt, il vous suffit d’exécuter la commande suivante pour créer les tables requises :``` shell cat scripts/CreatePostgresExporterTables.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Si vous n'avez pas choisi Postgres pour le stockage des tâches de traitement, suivez les étapes 1 et 2 de la section [Configurer le stockage PostgreSQL](####setting-up-postgresql-storage).
Il s'agit actuellement de l'exportateur par défaut, vous n'avez pas besoin de l'activer explicitement. Par défaut, le contenu des fichiers réels n'est pas téléversé vers la base de données PostgreSQL ; si vous souhaitez modifier cela, utilisez l'option `-upload_payloads true`.
Pour que l'exportateur Postgres fonctionne, vous devez définir les options suivantes : `-exporters postgres -postgresHost <host> -postgresPort <port> -postgresUser <user> -postgresPassword <pass> -postgresDBName <db_name>`
#### Configurer l'exportateur GCP
L'exportateur GCP permet d'envoyer des hachages et des métadonnées de fichiers vers une instance GCP Spanner. Vous pouvez éventuellement téléverser les fichiers extraits vers un bucket GCS. Si vous n'avez pas configuré Cloud Spanner pour stocker les tâches de traitement, suivez les étapes de [Configurer Cloud Spanner](####setting-up-cloud-spanner) et, au lieu de la dernière étape, exécutez la commande suivante pour créer les tables nécessaires :``` shell
gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateCloudSpannerExporterTables.ddl
Si vous avez déjà configuré Cloud Spanner pour stocker les données des jobs, il vous suffit d'exécuter la commande ci-dessus et vous êtes prêt.
Si vous souhaitez téléverser les fichiers extraits vers GCS, vous devez créer le bucket GCS :
Étape 1 : définissez le compte de service comme administrateur de ce bucket :``` shell gcloud storage buckets create gs://<gcs_bucket_name> --project=project_name>
Étape 2: Faire du compte de service un administrateur de ce bucket:``` shell
gcloud storage buckets add-iam-policy-binding gs://<gcs_bucket_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/storage.objectAdmin"
Pour utiliser cet exportateur, vous devez fournir les indicateurs suivants : -exporters GCP -gcp_exporter_gcs_bucket <gcs_bucket_name>
-processing_worker_count : Cet indicateur contrôle le nombre de workers de traitement parallèles. Le traitement est intense en CPU et en E/S ; lors de mes tests, j'ai constaté que 2 workers constituent la solution la plus optimale.-cache_dir : Emplacement du cache local utilisé pour la déduplication ; il est conseillé de le changer de /tmp vers, par exemple, le répertoire personnel de l'utilisateur qui exécutera hashr.-export : Lorsqu'il est défini sur false, hashr enregistre les résultats sur le disque en contournant l'exportateur.-export_path : Si export est défini sur false, il s'agit du dossier dans lequel les échantillons seront enregistrés.-reprocess : Permet de retraiter une source donnée (par exemple en cas d'erreur) en fonction de la valeur sha256 stockée dans la table des jobs.-upload_payloads : Contrôle si le contenu réel du fichier sera téléversé par les exportateurs définis.-gcp_exporter_worker_count : Nombre de workers/goroutines que l'exportateur GCP utilisera pour téléverser les données.Ceci n'est pas un produit Google officiellement pris en charge.