google/hashrCostruisce set di hash forensi di file da immagini disco, pacchetti e archivi su GCP, AWS e sorgenti locali, con deduplicazione ed esportazione verso PostgreSQL/Spanner per i flussi di lavoro DFIR.
HashR ti consente di creare i tuoi set di hash basati sulle tue fonti dati. È uno strumento che estrae file e hash dalle fonti di input (ad es. immagine disco raw, immagine disco GCE, file ISO, pacchetto di aggiornamento Windows, file .tar.gz, ecc.).
HashR è composto dai seguenti componenti:
Importatori attualmente implementati:
Una volta estratti e sottoposti a hashing, i risultati verranno passati agli esportatori. Esportatori attualmente implementati:
Puoi scegliere quali importatori eseguire; ognuno ha requisiti diversi. Maggiori informazioni al riguardo sono disponibili nelle sezioni seguenti.
HashR richiede un sistema operativo Linux per funzionare; può trattarsi di una macchina fisica, virtuale o cloud. Di seguito sono riportati i requisiti hardware ottimali:
HashR può probabilmente funzionare su macchine con specifiche inferiori, ma questo non è stato testato a fondo.
Per compilare un binario hashr, esegui il seguente comando:``` shell env GOOS=linux GOARCH=amd64 go build hashr.go
Per eseguire i test per il pacchetto core hashR è necessario eseguire l'emulatore Spanner:``` shell
gcloud emulators spanner start
Quindi, per eseguire tutti i test, esegui il seguente comando:``` shell go test -timeout 2m ./...
## Configurazione di HashR
### HashR in OSDFIR Infrastructure
Puoi distribuire HashR come parte del [progetto OSDFIR Infrastructure](https://github.com/google/osdfir-infrastructure/tree/main/charts/hashr)
Questa distribuzione eseguirà HashR come cronjob Kubernetes e consente una facile
integrazione con Timesketch.
### HashR usando docker
Per eseguire HashR in un container docker consulta la [guida specifica per docker](https://github.com/google/hashr/blob/main/docker/README.md)
### Configurazione del SO e strumenti di terze parti richiesti
HashR si occupa del lavoro pesante (analisi di immagini disco, volumi, file system) utilizzando Plaso. Devi eseguire il pull del container docker di Plaso usando il seguente comando:``` shell
docker pull log2timeline/plaso
Abbiamo anche bisogno che 7z, che viene utilizzato dall'importatore WSUS per l'estrazione ricorsiva dei pacchetti di Windows Update, sia installato sulla macchina che esegue HashR:``` shell sudo apt install p7zip-full
Devi consentire all'utente con cui HashR verrà eseguito di eseguire determinati comandi tramite sudo. Supponendo che il tuo utente sia `hashr`, crea un file `/etc/sudoers.d/hashr` e inserisci:``` shell
hashr ALL = (root) NOPASSWD: /bin/mount,/bin/umount,/sbin/losetup,/bin/rm
L'utente sotto cui verrà eseguito HashR dovrà anche poter eseguire docker. Supponendo che il tuo utente sia hashr, aggiungilo al gruppo docker in questo modo:``` shell
sudo usermod -aG docker hashr
### Configurazione dello storage per le attività di elaborazione
HashR deve memorizzare informazioni sulle fonti elaborate. Memorizza inoltre telemetria aggiuntiva sulle attività di elaborazione: tempi di elaborazione, numero di file estratti, ecc. Puoi scegliere tra:
1. PostgreSQL
1. Cloud (GCP) Spanner
#### Configurazione dello storage PostgreSQL
Ci sono molti modi per eseguire e mantenere la tua istanza PostgreSQL; uno dei più semplici è eseguirla in un contenitore Docker. Segui i passaggi seguenti per configurare un contenitore Docker PostgreSQL.
Passaggio 1: Esegui il pull dell'immagine docker di PostgreSQL.``` shell
docker pull postgres
Passaggio 2: Inizializza ed esegui il container PostgreSQL in background. Assicurati di modificare la password.``` 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
Fase 3: Creare una tabella che verrà utilizzata per memorizzare i processi di elaborazione.``` shell
cat scripts/CreateJobsTable.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Per utilizzare PostgreSQL per memorizzare le informazioni sui task di elaborazione è necessario specificare i seguenti flag: -storage postgres -postgres_host <host> -postgres_port <port> -postgres_user <user> -postgres_password <pass> -postgres_db <db_name>
Puoi scegliere di memorizzare i dati relativi ai job di elaborazione in Cloud Spanner. Avrai bisogno di un progetto Google Cloud per farlo. Il principale vantaggio di questa configurazione è che puoi creare facilmente dashboard utilizzando Google Data Studio e connetterti direttamente all'istanza Cloud Spanner, consentendo monitoraggio e debugging senza eseguire query sulla tua istanza PostgreSQL.
Supponendo che il tuo strumento gcloud sia configurato con il tuo progetto GCP di destinazione di HashR, dovrai seguire i passaggi seguenti per abilitare Cloud Spanner.
Crea l'account di servizio HashR:``` shell gcloud iam service-accounts create hashr --description="HashR SA key." --display-name="hashr"
Create service account key and store in your home directory. Set *<project_name>* to your project name.``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Punta la variabile d'ambiente GOOGLE_APPLICATION_CREDENTIALS alla tua chiave dell'account di servizio:``` shell export GOOGLE_APPLICATION_CREDENTIALS=/home/hashr/hashr-sa-private-key.json
Crea un'istanza Spanner, modifica la configurazione e il valore di processing-units se necessario:``` shell
gcloud spanner instances create hashr --config=regional-us-central1 --description="hashr" --processing-units=100
Crea un database Spanner:``` shell gcloud spanner databases create hashr --instance=hashr
Consenti all'account di servizio di utilizzare il database Spanner, imposta *<project_name>* al nome del tuo progetto:``` shell
gcloud spanner databases add-iam-policy-binding hashr --instance hashr --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/spanner.databaseUser"
Aggiorna lo schema del database Spanner:``` shell gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateJobsTable.ddl
Per utilizzare Cloud Spanner per archiviare informazioni sulle attività di elaborazione è necessario specificare i seguenti flag: `-jobStorage cloudspanner -spannerDBPath <spanner_db_path>`
### Configurazione degli importatori
Per specificare quale importatore si desidera eseguire, è necessario utilizzare il flag `-importers`. Valori possibili: `GCP,targz,windows,wsus,deb,rpm,zip,gcr,iso9660`
#### GCP (Google Cloud Platform)```shell
-importers GCP
Questo importatore può estrarre file dalle immagini dei dischi GCP. L'operazione viene eseguita in pochi passaggi:
L'elenco dei progetti GCP che contengono immagini GCP pubbliche è disponibile qui. Per utilizzare questo importatore devi disporre di un progetto GCP e seguire questi passaggi:
Passaggio 1: creare l'account di servizio HashR; se è già stato fatto durante la configurazione di Cloud Spanner, passa al passaggio 4.``` shell gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Passaggio 2: crea la chiave dell'account di servizio e salvala nella tua home directory. Assicurati di impostare *<project_name>* sul nome del tuo progetto:``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Passo 3: Imposta la variabile d'ambiente GOOGLE_APPLICATION_CREDENTIALS sulla chiave del tuo account di servizio:``` shell export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Passaggio 4: crea un bucket GCS che verrà utilizzato per archiviare le immagini disco in formato .tar.gz, imposta *<project_name>* sul nome del tuo progetto e *<gcs_bucket_name>* sul nome del nuovo bucket GCS del tuo progetto:``` shell
gcloud storage buckets create gs://<gcs_bucket_name> --project=<project_name>
Passaggio 5: rendi l'account di servizio amministratore di questo 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"
Fase 6: Abilita Compute API:``` shell
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com
Step 7: Crea il ruolo IAM e assegnagli le autorizzazioni richieste:``` 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
Passo 8: Associa il ruolo IAM all'account di servizio:``` shell
gcloud projects add-iam-policy-binding <project_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="projects/<project_name>/roles/hashr"
Step 9a: Abilita l'API cloudbuild``` shell gcloud services enable cloudbuild.googleapis.com --project <project_name>
Step 9b: Ottieni il tuo project_number```shell
gcloud projects list --filter="mlegin-testing-things" --format="value(PROJECT_NUMBER)"
Passo 9c: concedi agli account di servizio l'accesso necessario per eseguire Cloud Build, assicurati di modificare i valori <project_name> e <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'
Per utilizzare questo importatore è necessario specificare i seguenti flag:
1. `-gcp_projects` che è un elenco separato da virgole di progetti cloud contenenti immagini dei dischi. Se desideri importare immagini pubbliche, dai un'occhiata [qui](https://cloud.google.com/compute/docs/images/os-details#general-info)
1. `-hashr_gcp_project` progetto GCP che verrà utilizzato per conservare una copia delle immagini dei dischi per l'elaborazione ed eseguire anche Cloud Build
1. `-hashr_gcs_bucket` bucket GCS che verrà utilizzato per salvare l'output di Cloud Build (immagini dei dischi in formato .tar.gz)
#### AWS
Questo importatore elabora le AMI di proprietà di Amazon e genera hash. L'importatore richiede almeno un worker HashR (un'istanza EC2).
##### Worker HashR AWS
Un worker HashR AWS è un'istanza EC2 in cui viene collegato il volume dell'AMI, viene creato l'archivio del disco e poi caricato su un bucket S3. Si consiglia di avere almeno due worker HashR AWS. Se la tua configurazione utilizza un singolo worker AWS, usa `-processing_worker_count 1`.
Un worker HashR AWS deve soddisfare i seguenti requisiti:
- Le istanze EC2 devono avere il tag `InUse: false`. Se il valore è `true`, il worker non viene utilizzato per l'elaborazione.```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Tags’
Il sistema che esegue hashr deve essere in grado di connettersi via SSH all'istanza EC2 usando:
Keyname. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’Al FQDN come descritto in PublicDnsName. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].PublicDnsName’
scripts/hashr-archive deve essere copiato nel worker AWS HashR in /usr/local/sbin/hashr-archive
Un account AWS con autorizzazione a caricare file sul bucket HashR. La configurazione e le credenziali AWS devono essere memorizzate nella directory $HOME/.aws/.```shell
aws configure
##### Applicazione HashR
Sul sistema che esegue `hashr` è richiesto quanto segue.
- Un account AWS con i permessi per chiamare le seguenti API:
- EC2
- AttachVolume
- CopyImage
- CreateTags
- CreateVolume
- DeleteVolume
- DescribeAvailabilityZones
- DescribeImages
- DescribeInstances
- DescribeSnapshots
- DescribeVolumes
- DetachVolume
- S3
- DeleteObject
- Il file di configurazione e le credenziali dell'account AWS devono trovarsi nella directory `$HOME/.aws/`.
- La chiave privata SSH utilizzata per AWS HashR deve trovarsi nella directory `$HOME/.ssh/`. Deve corrispondere al valore di `Keyname` come descritto in `aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’`
##### Configurazione dell'istanza AWS EC2
Questa sezione descrive come creare istanze EC2 da usare con HashR. Idealmente vogliamo due account AWS: `hashr.uploader` e `hashr.worker`.
`hashr.uploader` viene utilizzato sulle istanze EC2 e necessita dei permessi per caricare le immagini disco archiviate nel bucket S3. `scripts/aws/AwsHashrUploaderPolicy.json` contiene un esempio di policy per il bucket S3 `hashr-bucket`.
`hashr.worker` viene utilizzato sul computer che esegue i comandi HashR. L'account necessita dei permessi EC2 e S3. `scripts/aws/AwsHashrWorkerPolicy.json` contiene un esempio di policy per l'account `hashr.worker`.
`hashr_setup.sh` è uno script che aiuta a creare istanze EC2. Modifica `hashr_setup.sh` e controlla e aggiorna i seguenti campi come richiesto:
- `AWS_PROFILE`
- `AWS_REGION`
- `SECURITY_SOURCE_CIDR`
- `WORKER_AWS_CONFIG_FILE`
**Nota**: Il file specificato da `WORKER_AWS_CONFIG_FILE` deve esistere nella directory contenente `hashr_setup.sh`.
**Nota**: `hashr_setup.sh` deve essere eseguito dalla stessa directory in cui si trova `hashr_setup.sh`.
Esegui i seguenti comandi per creare e configurare le istanze 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'importatore AWS segue i seguenti passaggi di alto livello:
Il comando seguente elabora le immagini debian-12 e le archivia in un database PostgreSQL.```shell
hashr -storage postgres -exporters postgres -importers aws -aws_bucket aws-hashr-bucket -aws_os_filter debian-12
**Nota**: Amazon Linux (al2023-*) è stato utilizzato come worker durante lo sviluppo dell'importer. Pertanto, il valore predefinito per `-aws_ssh_user` è impostato su `ec2-user`. Una distro diversa potrebbe avere un utente SSH predefinito diverso; usa `-aws_ssh_user` per impostare l'utente SSH appropriato.
#### GCR (Google Container Registry)
Questo importer estrae file da immagini container memorizzate nei repository GCR. Per configurarlo, segui questi passaggi:
Passo 1: Crea l'account di servizio HashR, salta al passo 4 se è già stato fatto durante la configurazione di altri componenti dipendenti da GCP.``` shell
gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Passaggio 2: Crea la chiave dell'account di servizio e salvala nella tua home directory. Assicurati di impostare <project_name> con il nome del tuo progetto:``` shell gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Passaggio 3: Imposta la variabile d'ambiente GOOGLE_APPLICATION_CREDENTIALS per puntare alla chiave del tuo account di servizio:``` shell
export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Passaggio 4: Concedi alla chiave dell'account di servizio hashR le autorizzazioni necessarie per accedere al repository GCR indicato.``` 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"
Per utilizzare questo importatore è necessario specificare i seguenti flag:
1. `-gcr_repos` che deve contenere un elenco separato da virgole di repository GCR da cui si desidera importare le immagini dei container.
#### Windows
Questo importatore estrae i file dai supporti di installazione ufficiali di Windows in formato ISO-13346, ad esempio quelli che puoi scaricare dal [sito Web](https://www.microsoft.com/en-gb/software-download/windows10ISO) ufficiale di Microsoft.
Un singolo file ISO può contenere più immagini WIM:
1. Windows10ProEducation
1. Windows10Education
1. Windows10EducationN
1. Windows10ProN
1. ecc.
Questo importatore estrarrà i file da tutte le immagini che riesce a trovare nel file `install.wim`.
#### WSUS
Questo importatore utilizza 7z per estrarre ricorsivamente il contenuto dei pacchetti di Windows Update. Cercherà i file di Windows Update nel bucket GCS fornito; il modo più semplice per aggiornare automaticamente il bucket GCS con i nuovi aggiornamenti è il seguente:
1. Configura una VM GCE che esegue Windows Server nel progetto GCP hashr.
1. Configurala con il ruolo WSUS, seleziona i pacchetti di Windows Update che desideri elaborare
1. Configura WSUS per approvare e scaricare automaticamente gli aggiornamenti nell'archivio locale
1. Imposta un'attività di Windows per sincronizzare automaticamente il contenuto dell'archivio locale con il bucket GCS: `gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/` (ricorda di modificare i percorsi)
1. Se desideri utilizzare il nome file del pacchetto di aggiornamento (che di solito contiene il numero KB) come ID (per impostazione predefinita è sha1, è così che MS memorizza gli aggiornamenti WSUS) e la sua descrizione, queste informazioni possono essere estratte dal database WID interno di WSUS. Puoi utilizzare il seguente script Power Shell ed eseguirlo come attività:```
#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/
This operazione esporterà le informazioni rilevanti dal database WSUS, le salverà nel file export.csv e sincronizzerà il contenuto della cartella WSUS con il bucket GCS. L'importatore WSUS verificherà se il file export.csv è presente nella radice del repository WSUS e, in tal caso, lo utilizzerà.
Questo è un semplice importatore che esamina i repository e cerca file .tar.gz. Una volta trovato, calcolerà l'hash dei primi e degli ultimi 10MB del file per verificare se è già stato elaborato. Questo viene fatto per evitare di dover calcolare l'hash dell'intero file ogni volta che il repository viene scansionato alla ricerca di nuove fonti. Per utilizzare questo importatore è necessario specificare il/i seguente/i flag:
-targz_repo_path che deve puntare al percorso nel file system locale che contiene i file .tar.gzQuesto è molto simile all'importatore TarGz, tranne per il fatto che cerca pacchetti .deb. Una volta trovato, calcolerà l'hash dei primi e degli ultimi 10MB del file per verificare se è già stato elaborato. Questo viene fatto per evitare di dover calcolare l'hash dell'intero file ogni volta che il repository viene scansionato alla ricerca di nuove fonti. Per utilizzare questo importatore è necessario specificare il/i seguente/i flag:
-deb_repo_path che deve puntare al percorso nel file system locale che contiene i file .debQuesto è molto simile all'importatore TarGz, tranne per il fatto che cerca pacchetti .rpm. Una volta trovato, calcolerà l'hash dei primi e degli ultimi 10MB del file per verificare se è già stato elaborato. Questo viene fatto per evitare di dover calcolare l'hash dell'intero file ogni volta che il repository viene scansionato alla ricerca di nuove fonti. Per utilizzare questo importatore è necessario specificare il/i seguente/i flag:
-rpm_repo_path che deve puntare al percorso nel file system locale che contiene i file .rpmQuesto è molto simile all'importatore TarGz, tranne per il fatto che cerca archivi .zip. Una volta trovato, calcolerà l'hash dei primi e degli ultimi 10MB del file per verificare se è già stato elaborato. Questo viene fatto per evitare di dover calcolare l'hash dell'intero file ogni volta che il repository viene scansionato alla ricerca di nuove fonti. Per utilizzare questo importatore è necessario specificare il/i seguente/i flag:
-zip_repo_path che deve puntare al percorso nel file system locale che contiene i file .zipFacoltativamente, puoi anche impostare il/i seguente/i flag:
-zip_file_exts elenco separato da virgole di estensioni di file da trattare come file zip, es. "zip,whl,jar". Predefinito: "zip"Questo è molto simile all'importatore TarGz, tranne per il fatto che cerca file .iso. Una volta trovato, calcolerà l'hash dei primi e degli ultimi 10MB del file per verificare se è già stato elaborato. Questo viene fatto per evitare di dover calcolare l'hash dell'intero file ogni volta che il repository viene scansionato alla ricerca di nuove fonti. Per utilizzare questo importatore è necessario specificare il/i seguente/i flag:
-iso_repo_path che deve puntare al percorso nel file system locale che contiene i file .isoL'exporter Postgres consente l'invio di hash, metadati dei file e il contenuto effettivo del file a un'istanza PostgreSQL. Per ottenere le migliori prestazioni, si consiglia di configurarlo su una macchina separata e dedicata. Se hai configurato PostgreSQL durante la scelta dello storage dei job di elaborazione, sei quasi pronto per partire: esegui semplicemente il seguente comando per creare le tabelle richieste:``` shell cat scripts/CreatePostgresExporterTables.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Se non hai scelto Postgres per l'archiviazione dei job di elaborazione, segui i passaggi 1 e 2 della sezione [Configurazione dell'archiviazione PostgreSQL](####setting-up-postgresql-storage).
Questo è attualmente l'exporter predefinito, non è necessario abilitarlo esplicitamente. Per impostazione predefinita, il contenuto dei file effettivi non verrà caricato nel database PostgreSQL; se desideri modificare questo comportamento, usa il flag `-upload_payloads true`.
Affinché l'exporter Postgres funzioni, è necessario impostare i seguenti flag: `-exporters postgres -postgresHost <host> -postgresPort <port> -postgresUser <user> -postgresPassword <pass> -postgresDBName <db_name>`
#### Configurazione dell'exporter GCP
L'exporter GCP consente l'invio di hash e metadati dei file a un'istanza GCP Spanner. Facoltativamente, puoi caricare i file estratti in un bucket GCS. Se non hai configurato Cloud Spanner per archiviare i job di elaborazione, segui i passaggi in [Configurazione di Cloud Spanner](####setting-up-cloud-spanner) e, invece dell'ultimo passaggio, esegui il comando seguente per creare le tabelle necessarie:``` shell
gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateCloudSpannerExporterTables.ddl
Se hai già configurato Cloud Spanner per archiviare i dati dei job, devi solo eseguire il comando sopra e sei pronto a partire.
Se desideri caricare i file estratti su GCS, devi creare il bucket GCS:
Passo 1: Rendi l'account di servizio amministratore di questo bucket:``` shell gcloud storage buckets create gs://<gcs_bucket_name> --project=project_name>
Passaggio 2: Rendi l'account di servizio amministratore di questo 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"
To use this exporter you need to provide the following flags: -exporters GCP -gcp_exporter_gcs_bucket <gcs_bucket_name>
-processing_worker_count: Questo flag controlla il numero di worker di elaborazione paralleli. L'elaborazione è intensiva per CPU e I/O; durante i miei test ho trovato che avere 2 worker è la soluzione più ottimale.-cache_dir: Posizione della cache locale utilizzata per la deduplicazione; si consiglia di cambiarla da /tmp ad esempio nella home directory dell'utente che eseguirà hashr.-export: Se impostato su false, hashr salverà i risultati su disco bypassando l'exporter.-export_path: Se export è impostato su false, questa è la cartella in cui verranno salvati i campioni.-reprocess: Consente di rielaborare una determinata sorgente (nel caso in cui, ad esempio, abbia generato un errore) in base al valore sha256 memorizzato nella tabella dei job.-upload_payloads: Controlla se il contenuto effettivo del file verrà caricato dagli exporter definiti.-gcp_exporter_worker_count: Numero di worker/goroutine che l'exporter GCP utilizzerà per caricare i dati.This is not an officially supported Google product.