google/hashrGera conjuntos de hashes forenses de arquivos a partir de imagens de disco, pacotes e arquivos em GCP, AWS e fontes locais, com deduplicação e exportação para PostgreSQL/Spanner para fluxos de trabalho de DFIR.
O HashR permite que você crie seus próprios conjuntos de hashes com base nas suas fontes de dados. É uma ferramenta que extrai arquivos e hashes de fontes de entrada (por exemplo, imagem de disco bruta, imagem de disco do GCE, arquivo ISO, pacote de atualização do Windows, arquivo .tar.gz, etc.).
O HashR consiste nos seguintes componentes:
Importadores atualmente implementados:
Depois que os arquivos são extraídos e o hash é calculado, os resultados são passados aos exportadores, atualmente implementados:
Você pode escolher quais importadores deseja executar; cada um tem requisitos diferentes. Mais informações sobre isso podem ser encontradas nas seções abaixo.
O HashR requer Linux para ser executado, podendo ser uma máquina física, virtual ou na nuvem. Abaixo estão os requisitos de hardware ideais:
O HashR provavelmente pode rodar em máquinas com especificações inferiores, porém isso não foi testado de forma completa.
Para compilar um binário hashr, execute o seguinte comando:``` shell env GOOS=linux GOARCH=amd64 go build hashr.go
Para executar testes para o pacote hashR principal, você precisa executar o emulador do Spanner:``` shell
gcloud emulators spanner start
Em seguida, para executar todos os testes, execute o seguinte comando:``` shell go test -timeout 2m ./...
## Configurando o HashR
### HashR na infraestrutura OSDFIR
Você pode implantar o HashR como parte do [projeto OSDFIR Infrastructure](https://github.com/google/osdfir-infrastructure/tree/main/charts/hashr)
Essa implantação executará o HashR como cronjobs do Kubernetes e permite uma fácil
integração com o Timesketch.
### HashR usando docker
Para executar o HashR em um contêiner docker, visite o [guia específico do docker](https://github.com/google/hashr/blob/main/docker/README.md)
### Configuração do SO e ferramentas de terceiros necessárias
O HashR cuida do trabalho pesado (análise de imagens de disco, volumes, sistemas de arquivos) usando o Plaso. Você precisa baixar o contêiner docker do Plaso usando o seguinte comando:``` shell
docker pull log2timeline/plaso
Também precisamos que o 7z, usado pelo importador WSUS para extração recursiva de pacotes do Windows Update, esteja instalado na máquina que executa o HashR:``` shell sudo apt install p7zip-full
Você precisa permitir que o usuário, sob o qual o HashR será executado, execute determinados comandos via sudo. Supondo que seu usuário seja `hashr`, crie um arquivo `/etc/sudoers.d/hashr` e coloque:``` shell
hashr ALL = (root) NOPASSWD: /bin/mount,/bin/umount,/sbin/losetup,/bin/rm
O usuário sob o qual o HashR será executado também precisará conseguir executar o docker. Supondo que seu usuário seja hashr, adicione-o ao grupo docker assim:``` shell
sudo usermod -aG docker hashr
### Configurando armazenamento para tarefas de processamento
O HashR precisa armazenar informações sobre fontes processadas. Ele também armazena telemetria adicional sobre tarefas de processamento: tempos de processamento, número de arquivos extraídos, etc. Você pode escolher entre usar:
1. PostgreSQL
1. Cloud (GCP) Spanner
#### Configurando armazenamento PostgreSQL
Existem muitas maneiras de executar e manter sua instância PostgreSQL; uma das mais simples seria executá-la em um contêiner Docker. Siga as etapas abaixo para configurar um contêiner Docker PostgreSQL.
Etapa 1: Baixe a imagem Docker do PostgreSQL.``` shell
docker pull postgres
Passo 2: Inicialize e execute o contêiner PostgreSQL em segundo plano. Certifique-se de ajustar a senha.``` 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
Passo 3: Crie uma tabela que será usada para armazenar tarefas de processamento.``` shell
cat scripts/CreateJobsTable.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Para usar o PostgreSQL para armazenar informações sobre tarefas de processamento, você precisa especificar as seguintes flags: -storage postgres -postgres_host <host> -postgres_port <port> -postgres_user <user> -postgres_password <pass> -postgres_db <db_name>
Você pode optar por armazenar os dados sobre os trabalhos de processamento no Cloud Spanner. Você precisará de um projeto do Google Cloud para isso. A principal vantagem dessa configuração é que você pode criar facilmente painéis (dashboards) usando o Google Data Studio e conectar-se diretamente à instância do Cloud Spanner, o que permite monitoramento e depuração sem executar consultas na sua instância do PostgreSQL.
Supondo que a ferramenta gcloud esteja configurada com o seu projeto GCP hashr de destino, você precisará seguir as etapas abaixo para habilitar o Cloud Spanner.
Crie a conta de serviço do HashR:``` shell gcloud iam service-accounts create hashr --description="HashR SA key." --display-name="hashr"
Crie uma chave de conta de serviço e armazene-a no seu diretório pessoal. Defina *<project_name>* como o nome do seu projeto.``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Aponte a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para a chave da sua conta de serviço:``` shell export GOOGLE_APPLICATION_CREDENTIALS=/home/hashr/hashr-sa-private-key.json
Crie uma instância do Spanner, ajuste a configuração e o valor de processing-units, se necessário:``` shell
gcloud spanner instances create hashr --config=regional-us-central1 --description="hashr" --processing-units=100
Criar banco de dados Spanner:``` shell gcloud spanner databases create hashr --instance=hashr
Permita que a conta de serviço use o banco de dados Spanner, defina *<project_name>* para o nome do seu projeto:``` shell
gcloud spanner databases add-iam-policy-binding hashr --instance hashr --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/spanner.databaseUser"
Atualize o esquema do banco de dados Spanner:``` shell gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateJobsTable.ddl
Para usar o Cloud Spanner para armazenar informações sobre tarefas de processamento, você precisa especificar as seguintes flags: `-jobStorage cloudspanner -spannerDBPath <spanner_db_path>`
### Configurando importadores
Para especificar qual importador você deseja executar, use a flag `-importers`. Valores possíveis: `GCP,targz,windows,wsus,deb,rpm,zip,gcr,iso9660`
#### GCP (Google Cloud Platform)```shell
-importers GCP
Este importador pode extrair arquivos de imagens de disco do GCP. Isso é feito em poucos passos:
Uma lista de projetos GCP que contêm imagens públicas do GCP pode ser encontrada aqui. Para usar este importador, você precisa ter um projeto GCP e seguir estes passos:
Etapa 1: Crie a conta de serviço do HashR. Se isso foi feito durante a configuração do Cloud Spanner, vá para a etapa 4.``` shell gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Passo 2: Crie a chave da conta de serviço e armazene no seu diretório inicial. Certifique-se de definir *<project_name>* para o nome do seu projeto:``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Passo 3: Aponte a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para a chave da sua conta de serviço:``` shell export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Passo 4: Crie o bucket GCS que será usado para armazenar imagens de disco no formato .tar.gz, defina *<project_name>* para o nome do seu projeto e *<gcs_bucket_name>* para o nome do novo bucket GCS do seu projeto:``` shell
gcloud storage buckets create gs://<gcs_bucket_name> --project=<project_name>
Step 5: Torne a conta de serviço administradora deste 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"
Passo 6: Ative a API Compute:``` shell
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com
Passo 7: Crie a função do IAM e atribua a ela as permissões necessárias:``` 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: Vincular a função IAM à conta de serviço:``` shell
gcloud projects add-iam-policy-binding <project_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="projects/<project_name>/roles/hashr"
Passo 9a: Ative a API cloudbuild``` shell gcloud services enable cloudbuild.googleapis.com --project <project_name>
Passo 9b: Obtenha seu project_number```shell
gcloud projects list --filter="mlegin-testing-things" --format="value(PROJECT_NUMBER)"
Etapa 9c: Conceda às contas de serviço o acesso necessário para executar o Cloud Build e certifique-se de alterar os valores de <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'
Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
1. `-gcp_projects` que é uma lista separada por vírgulas de projetos cloud contendo imagens de disco. Se você quiser importar imagens públicas, dê uma olhada [aqui](https://cloud.google.com/compute/docs/images/os-details#general-info)
1. `-hashr_gcp_project` projeto GCP que será usado para armazenar uma cópia das imagens de disco para processamento e também para executar o Cloud Build
1. `-hashr_gcs_bucket` bucket GCS que será usado para armazenar a saída do Cloud Build (imagens de disco no formato .tar.gz)
#### AWS
Este importador processa AMIs de propriedade da Amazon e gera hashes. O importador requer pelo menos um worker HashR (uma instância EC2).
##### Workers HashR AWS
O worker HashR AWS é uma instância EC2 onde o volume da AMI é anexado, o arquivo de disco é criado e, em seguida, enviado para o bucket S3. Recomenda-se ter pelo menos dois workers HashR AWS. Se a sua configuração usa um único worker AWS, use `-processing_worker_count 1`.
Um worker HashR AWS precisa atender aos seguintes requisitos:
- As instâncias EC2 devem ter a tag `InUse: false`. Se o valor for `true`, o worker não é usado para processamento.```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Tags’
O sistema que executa o hashr deve ser capaz de usar SSH para a instância EC2 usando:
Keyname. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’Para FQDN conforme descrito em PublicDnsName. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].PublicDnsName’
scripts/hashr-archive deve ser copiado para o worker AWS HashR em /usr/local/sbin/hashr-archive
Uma conta AWS com permissão para enviar arquivos para o bucket HashR. A configuração e as credenciais da AWS devem ser armazenadas no diretório $HOME/.aws/.```shell
aws configure
##### Aplicação HashR
No sistema que executa o `hashr`, é necessário o seguinte.
- Uma conta AWS com permissões para chamar as seguintes APIs:
- EC2
- AttachVolume
- CopyImage
- CreateTags
- CreateVolume
- DeleteVolume
- DescribeAvailabilityZones
- DescribeImages
- DescribeInstances
- DescribeSnapshots
- DescribeVolumes
- DetachVolume
- S3
- DeleteObject
- A configuração da conta AWS e o arquivo de credenciais devem estar localizados no diretório `$HOME/.aws/`.
- A chave privada SSH usada para o HashR na AWS deve estar localizada no diretório `$HOME/.ssh/`. Ela deve corresponder ao valor de `Keyname` conforme descrito em `aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’`
##### Configurando a instância EC2 da AWS
Esta seção descreve como criar instâncias EC2 para usar com o HashR. Idealmente, queremos duas contas AWS: `hashr.uploader` e `hashr.worker`.
`hashr.uploader` é usada em instâncias EC2 e precisa de permissões para enviar imagens de disco arquivadas para o bucket S3. `scripts/aws/AwsHashrUploaderPolicy.json` contém uma política de exemplo para o bucket S3 `hashr-bucket`.
`hashr.worker` é usada no computador que executa os comandos do HashR. A conta precisa de permissões para EC2 e S3. `scripts/aws/AwsHashrWorkerPolicy.json` contém uma política de exemplo para a conta `hashr.worker`.
O `hashr_setup.sh` é um script que ajuda a criar instâncias EC2. Edite o `hashr_setup.sh` e revise e atualize os seguintes campos conforme necessário:
- `AWS_PROFILE`
- `AWS_REGION`
- `SECURITY_SOURCE_CIDR`
- `WORKER_AWS_CONFIG_FILE`
**Nota**: O arquivo especificado em `WORKER_AWS_CONFIG_FILE` deve existir no diretório junto com `hashr_setup.sh`.
**Nota**: O `hashr_setup.sh` deve ser executado a partir do mesmo diretório em que o `hashr_setup.sh` está localizado.
Execute os seguintes comandos para criar e configurar as instâncias 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
O importador AWS segue os seguintes passos de alto nível:
O comando abaixo processa imagens debian-12 e as armazena em um banco de dados PostgreSQL.```shell
hashr -storage postgres -exporters postgres -importers aws -aws_bucket aws-hashr-bucket -aws_os_filter debian-12
**Nota**: O Amazon Linux (al2023-*) foi usado como worker durante o desenvolvimento do importador. Assim, o valor padrão para `-aws_ssh_user` está definido como `ec2-user`. Uma distro diferente pode ter um usuário SSH padrão diferente; use `-aws_ssh_user` para definir o usuário SSH apropriado.
#### GCR (Google Container Registry)
Este importador extrai arquivos de imagens de contêiner armazenadas em repositórios GCR. Para configurá-lo, siga estas etapas:
Etapa 1: Crie a conta de serviço HashR. Pule para a etapa 4 se isso foi feito durante a configuração de outros componentes dependentes do GCP.``` shell
gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Passo 2: Crie a chave da conta de serviço e armazene-a no seu diretório inicial. Certifique-se de definir <project_name> para o nome do seu projeto:``` shell gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Passo 3: Aponte a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para a chave da sua conta de serviço:``` shell
export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Passo 4: Conceda à chave da conta de serviço do hashR as permissões necessárias para acessar o repositório GCR fornecido.``` 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"
Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
1. `-gcr_repos`, que deve conter uma lista separada por vírgulas dos repositórios GCR dos quais você deseja importar as imagens de contêiner.
#### Windows
Este importador extrai arquivos de mídias oficiais de instalação do Windows no formato ISO-13346, por exemplo, as que você pode baixar do [site](https://www.microsoft.com/en-gb/software-download/windows10ISO) oficial da Microsoft.
Um arquivo ISO pode conter várias imagens WIM:
1. Windows10ProEducation
1. Windows10Education
1. Windows10EducationN
1. Windows10ProN
1. etc.
Este importador extrairá arquivos de todas as imagens que encontrar no arquivo `install.wim`.
#### WSUS
Este importador utiliza 7z para extrair recursivamente o conteúdo dos pacotes do Windows Update. Ele procurará arquivos do Windows Update no bucket GCS fornecido; a maneira mais fácil de atualizar automaticamente o bucket GCS com novas atualizações seria fazer o seguinte:
1. Configure uma VM GCE executando Windows Server no projeto GCP hashr.
1. Configure-a com a função WSUS, selecione os pacotes do Windows Update que deseja processar
1. Configure o WSUS para aprovar e baixar automaticamente as atualizações para o armazenamento local
1. Configure uma tarefa do Windows para sincronizar automaticamente o conteúdo do armazenamento local com o bucket GCS: `gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/` (lembre-se de ajustar os caminhos)
1. Se você deseja ter o nome do arquivo do pacote de atualização (que geralmente contém o número KB) como o ID (por padrão é sha1, é assim que a MS armazena atualizações do WSUS) e sua descrição, isso é algo que pode ser extraído do banco de dados WID WSUS interno. Você pode usar o seguinte script do Power Shell e executá-lo como uma tarefa:```
#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/
Isso irá despejar as informações relevantes do banco de dados do WSUS, armazená-las no arquivo export.csv e sincronizar o conteúdo da pasta do WSUS com o bucket do GCS. O importador WSUS verificará se o arquivo export.csv está presente na raiz do repositório do WSUS e, se estiver, o utilizará.
Este é um importador simples que percorre repositórios e procura por arquivos .tar.gz. Quando encontrado, ele irá gerar o hash dos primeiros e dos últimos 10MB do arquivo para verificar se já foi processado. Isso é feito para evitar o hash do arquivo inteiro toda vez que o repositório é verificado em busca de novas fontes. Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
-targz_repo_path que deve apontar para o caminho no sistema de arquivos local que contém arquivos .tar.gzEste é muito semelhante ao importador TarGz, exceto que procura por pacotes .deb. Quando encontrado, ele irá gerar o hash dos primeiros e dos últimos 10MB do arquivo para verificar se já foi processado. Isso é feito para evitar o hash do arquivo inteiro toda vez que o repositório é verificado em busca de novas fontes. Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
-deb_repo_path que deve apontar para o caminho no sistema de arquivos local que contém arquivos .debEste é muito semelhante ao importador TarGz, exceto que procura por pacotes .rpm. Quando encontrado, ele irá gerar o hash dos primeiros e dos últimos 10MB do arquivo para verificar se já foi processado. Isso é feito para evitar o hash do arquivo inteiro toda vez que o repositório é verificado em busca de novas fontes. Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
-rpm_repo_path que deve apontar para o caminho no sistema de arquivos local que contém arquivos .rpmEste é muito semelhante ao importador TarGz, exceto que procura por arquivos .zip. Quando encontrado, ele irá gerar o hash dos primeiros e dos últimos 10MB do arquivo para verificar se já foi processado. Isso é feito para evitar o hash do arquivo inteiro toda vez que o repositório é verificado em busca de novas fontes. Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
-zip_repo_path que deve apontar para o caminho no sistema de arquivos local que contém arquivos .zipOpcionalmente, você também pode definir a(s) seguinte(s) flag(s):
-zip_file_exts lista separada por vírgulas de extensões de arquivo a serem tratadas como arquivos zip, ex.: "zip,whl,jar". Padrão: "zip"Este é muito semelhante ao importador TarGz, exceto que procura por arquivos .iso. Quando encontrado, ele irá gerar o hash dos primeiros e dos últimos 10MB do arquivo para verificar se já foi processado. Isso é feito para evitar o hash do arquivo inteiro toda vez que o repositório é verificado em busca de novas fontes. Para usar este importador, você precisa especificar a(s) seguinte(s) flag(s):
-iso_repo_path que deve apontar para o caminho no sistema de arquivos local que contém arquivos .isoO exportador Postgres permite o envio de hashes, metadados de arquivos e o conteúdo real do arquivo para uma instância PostgreSQL. Para obter o melhor desempenho, é recomendado configurá-lo em uma máquina separada e dedicada. Se você configurou o PostgreSQL ao escolher o armazenamento de trabalhos de processamento, você já está quase pronto; basta executar o seguinte comando para criar as tabelas necessárias:``` shell cat scripts/CreatePostgresExporterTables.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Se você não escolheu o Postgres para o armazenamento de trabalhos de processamento, siga os passos 1 e 2 da seção [Configurando o armazenamento PostgreSQL](####setting-up-postgresql-storage).
Este é atualmente o exportador padrão, você não precisa habilitá-lo explicitamente. Por padrão, o conteúdo dos arquivos reais não será enviado para o banco de dados PostgreSQL; se você desejar alterar isso, use a flag `-upload_payloads true`.
Para que o exportador Postgres funcione, você precisa definir as seguintes flags: `-exporters postgres -postgresHost <host> -postgresPort <port> -postgresUser <user> -postgresPassword <pass> -postgresDBName <db_name>`
#### Configurando o exportador GCP
O exportador GCP permite o envio de hashes e metadados de arquivos para a instância GCP Spanner. Opcionalmente, você pode enviar os arquivos extraídos para o bucket GCS. Se você ainda não configurou o Cloud Spanner para armazenar trabalhos de processamento, siga os passos em [Configurando o Cloud Spanner](####setting-up-cloud-spanner) e, em vez da última etapa, execute o seguinte comando para criar as tabelas necessárias:``` shell
gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateCloudSpannerExporterTables.ddl
Se você já configurou o Cloud Spanner para armazenar dados de jobs, basta executar o comando acima e estará pronto para começar.
Se você deseja enviar os arquivos extraídos para o GCS, é necessário criar o bucket do GCS:
Passo 1: Defina a conta de serviço como administradora deste bucket:``` shell gcloud storage buckets create gs://<gcs_bucket_name> --project=project_name>
Passo 2: Torne a conta de serviço administradora deste 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"
Para usar este exportador, você precisa fornecer as seguintes flags: -exporters GCP -gcp_exporter_gcs_bucket <gcs_bucket_name>
-processing_worker_count: Esta flag controla o número de workers de processamento paralelo. O processamento consome muita CPU e I/O; durante meus testes, descobri que ter 2 workers é a solução mais otimizada.-cache_dir: Localização do cache local usado para deduplicação; é recomendado alterá-la de /tmp para, por exemplo, o diretório home do usuário que executará o hashr.-export: Quando definido como false, o hashr salvará os resultados em disco, ignorando o exportador.-export_path: Se export estiver definido como false, esta é a pasta onde as amostras serão salvas.-reprocess: Permite reprocessar uma determinada fonte (caso ela, por exemplo, tenha falhado) com base no valor sha256 armazenado na tabela de jobs.-upload_payloads: Controla se o conteúdo real do arquivo será enviado pelos exportadores definidos.-gcp_exporter_worker_count: Número de workers/goroutines que o exportador GCP usará para enviar os dados.Este não é um produto oficialmente suportado pelo Google.