google/hashrGenera conjuntos de hashes forenses de archivos a partir de imágenes de disco, paquetes y archivos comprimidos en GCP, AWS y fuentes locales, con deduplicación y exportación a PostgreSQL/Spanner para flujos de trabajo DFIR.
HashR te permite construir tus propios conjuntos de hashes basados en tus fuentes de datos. Es una herramienta que extrae archivos y hashes de fuentes de entrada (por ejemplo, imágenes de disco crudas, imágenes de disco GCE, archivos ISO, paquetes de actualización de Windows, archivos .tar.gz, etc.).
HashR consta de los siguientes componentes:
Importadores implementados actualmente:
Una vez que los archivos se extraen y se generan los hashes, los resultados se pasan a los exportadores. Exportadores implementados actualmente:
Puedes elegir qué importadores quieres ejecutar; cada uno tiene requisitos diferentes. Puedes encontrar más información sobre esto en las secciones siguientes.
HashR requiere un sistema operativo Linux para ejecutarse; puede ser una máquina física, virtual o en la nube. A continuación se indican los requisitos óptimos de hardware:
HashR probablemente puede ejecutarse en máquinas con especificaciones menores, sin embargo, esto no fue probado a fondo.
Para compilar un binario de hashr, ejecuta el siguiente comando:``` shell env GOOS=linux GOARCH=amd64 go build hashr.go
Para ejecutar las pruebas del paquete principal hashR, necesitas ejecutar el emulador de Spanner:``` shell
gcloud emulators spanner start
A continuación, para ejecutar todas las pruebas, ejecuta el siguiente comando:``` shell go test -timeout 2m ./...
## Configurando HashR
### HashR en OSDFIR Infrastructure
Puede implementar HashR como parte del [proyecto OSDFIR Infrastructure](https://github.com/google/osdfir-infrastructure/tree/main/charts/hashr)
Esta implementación ejecutará HashR como cronjobs de kubernetes y permite una fácil
integración con Timesketch.
### HashR usando docker
Para ejecutar HashR en un contenedor docker, visite la [guía específica de docker](https://github.com/google/hashr/blob/main/docker/README.md)
### Configuración del SO y herramientas de terceros requeridas
HashR se encarga del trabajo pesado (análisis de imágenes de disco, volúmenes y sistemas de archivos) usando Plaso. Debe extraer el contenedor docker de Plaso usando el siguiente comando:``` shell
docker pull log2timeline/plaso
También necesitamos que 7z, que es utilizado por el importador de WSUS para la extracción recursiva de paquetes de Windows Update, esté instalado en la máquina que ejecuta HashR:``` shell sudo apt install p7zip-full
Debes permitir que el usuario bajo el cual se ejecutará HashR pueda ejecutar ciertos comandos mediante sudo. Suponiendo que tu usuario es `hashr`, crea un archivo `/etc/sudoers.d/hashr` y añade:``` shell
hashr ALL = (root) NOPASSWD: /bin/mount,/bin/umount,/sbin/losetup,/bin/rm
El usuario bajo el cual se ejecutará HashR también necesitará poder ejecutar docker. Suponiendo que tu usuario es hashr, agrégalo al grupo docker de esta manera:``` shell
sudo usermod -aG docker hashr
### Configuración del almacenamiento para tareas de procesamiento
HashR necesita almacenar información sobre las fuentes procesadas. También almacena telemetría adicional sobre las tareas de procesamiento: tiempos de procesamiento, número de archivos extraídos, etc. Puedes elegir entre usar:
1. PostgreSQL
1. Cloud (GCP) Spanner
#### Configuración del almacenamiento PostgreSQL
Hay muchas formas de ejecutar y mantener tu instancia de PostgreSQL; una de las más sencillas sería ejecutarla en un contenedor Docker. Sigue los pasos a continuación para configurar un contenedor Docker de PostgreSQL.
Paso 1: Descarga la imagen de Docker de PostgreSQL.``` shell
docker pull postgres
Paso 2: Inicialice y ejecute el contenedor PostgreSQL en segundo plano. Asegúrese de ajustar la contraseña.``` 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
Paso 3: Crea una tabla que se utilizará para almacenar trabajos de procesamiento.``` shell
cat scripts/CreateJobsTable.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Para usar PostgreSQL con el fin de almacenar información sobre tareas de procesamiento, debes especificar las siguientes opciones: -storage postgres -postgres_host <host> -postgres_port <port> -postgres_user <user> -postgres_password <pass> -postgres_db <db_name>
Puedes elegir almacenar los datos sobre los trabajos de procesamiento en Cloud Spanner. Para ello necesitarás un proyecto de Google Cloud. La principal ventaja de esta configuración es que puedes crear fácilmente paneles (dashboards) usando Google Data Studio y conectarte directamente a la instancia de Cloud Spanner, lo que permite la supervisión y la depuración sin ejecutar consultas contra tu instancia de PostgreSQL.
Suponiendo que tu herramienta gcloud esté configurada con tu proyecto GCP de destino hashr, deberás seguir los pasos que se indican a continuación para habilitar Cloud Spanner.
Crea la cuenta de servicio de HashR:``` shell gcloud iam service-accounts create hashr --description="HashR SA key." --display-name="hashr"
Crea la clave de la cuenta de servicio y guárdala en tu directorio personal. Establece *<project_name>* con el nombre de tu proyecto.``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Apunta la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a tu clave de cuenta de servicio:``` shell export GOOGLE_APPLICATION_CREDENTIALS=/home/hashr/hashr-sa-private-key.json
Crea la instancia de Spanner, ajusta la configuración y el valor de processing-units si es necesario:``` shell
gcloud spanner instances create hashr --config=regional-us-central1 --description="hashr" --processing-units=100
Crear base de datos Spanner:``` shell gcloud spanner databases create hashr --instance=hashr
Permita que la cuenta de servicio use la base de datos de Spanner, establezca *<project_name>* como el nombre de su proyecto:``` shell
gcloud spanner databases add-iam-policy-binding hashr --instance hashr --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/spanner.databaseUser"
Actualizar el esquema de la base de datos Spanner:``` shell gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateJobsTable.ddl
Para usar Cloud Spanner para almacenar información sobre tareas de procesamiento, debes especificar los siguientes flags: `-jobStorage cloudspanner -spannerDBPath <spanner_db_path>`
### Configuración de importadores
Para especificar qué importador deseas ejecutar, debes usar el flag `-importers`. Valores posibles: `GCP,targz,windows,wsus,deb,rpm,zip,gcr,iso9660`
#### GCP (Google Cloud Platform)```shell
-importers GCP
Este importador puede extraer archivos de las imágenes de discos de GCP. Esto se hace en pocos pasos:
La lista de proyectos de GCP que contienen imágenes públicas de GCP se puede encontrar aquí. Para usar este importador necesitas tener un proyecto de GCP y seguir estos pasos:
Paso 1: Crear la cuenta de servicio de HashR; si esto ya se hizo durante la configuración de Cloud Spanner, por favor ve al paso 4.``` shell gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Paso 2: Crea una clave de cuenta de servicio y guárdala en tu directorio personal. Asegúrate de establecer *<project_name>* con el nombre de tu proyecto:``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Paso 3: Apunta la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la clave de tu cuenta de servicio:``` shell export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Paso 4: Crea un bucket de GCS que se utilizará para almacenar imágenes de disco en formato .tar.gz, establece *<project_name>* con el nombre de tu proyecto y *<gcs_bucket_name>* con el nombre del nuevo bucket de GCS de tu proyecto:``` shell
gcloud storage buckets create gs://<gcs_bucket_name> --project=<project_name>
Paso 5: Haz que la cuenta de servicio sea administradora de este 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"
Paso 6: Habilita la API de Compute:``` shell
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com
Paso 7: Crear un rol de IAM y asignarle los permisos requeridos:``` 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
Paso 8: Vincular el rol de IAM a la cuenta de servicio:``` shell
gcloud projects add-iam-policy-binding <project_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="projects/<project_name>/roles/hashr"
Paso 9a: Habilitar la API de cloudbuild``` shell gcloud services enable cloudbuild.googleapis.com --project <project_name>
Paso 9b: Obtén tu project_number```shell
gcloud projects list --filter="mlegin-testing-things" --format="value(PROJECT_NUMBER)"
Paso 9c: Otorgue a las cuentas de servicio el acceso necesario para ejecutar Cloud Build, asegúrese de cambiar los valores de <project_name> y <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 necesitas especificar la(s) siguiente(s) bandera(s):
1. `-gcp_projects` que es una lista separada por comas de proyectos de cloud que contienen imágenes de disco. Si deseas importar imágenes públicas, echa un vistazo [aquí](https://cloud.google.com/compute/docs/images/os-details#general-info)
1. `-hashr_gcp_project` proyecto de GCP que se utilizará para almacenar una copia de las imágenes de disco para su procesamiento y también para ejecutar Cloud Build
1. `-hashr_gcs_bucket` bucket de GCS que se utilizará para almacenar la salida de Cloud Build (imágenes de disco en formato .tar.gz)
#### AWS
Este importador procesa AMIs propiedad de Amazon y genera hashes. El importador requiere al menos un trabajador HashR (una instancia EC2).
##### Trabajadores HashR de AWS
Un trabajador HashR de AWS es una instancia EC2 donde se adjunta el volumen de la AMI, se crea el archivo de disco y luego se sube al bucket de S3. Se recomienda tener al menos dos trabajadores HashR de AWS. Si tu configuración usa un solo trabajador de AWS, usa `-processing_worker_count 1`.
Un trabajador HashR de AWS debe cumplir los siguientes requisitos:
- Las instancias EC2 deben tener la etiqueta `InUse: false`. Si el valor es `true`, el trabajador no se utiliza para el procesamiento.```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Tags’
El sistema que ejecuta hashr debe poder conectarse por SSH a la instancia EC2 usando:
Keyname. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’Al FQDN como se describe en PublicDnsName. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].PublicDnsName’
scripts/hashr-archive debe copiarse al worker de AWS HashR en /usr/local/sbin/hashr-archive
Una cuenta de AWS con permiso para subir archivos al bucket de HashR. La configuración y las credenciales de AWS deben almacenarse en el directorio $HOME/.aws/.```shell
aws configure
##### Aplicación HashR
En el sistema que ejecuta `hashr` se requiere lo siguiente.
- Una cuenta de AWS con permisos para llamar a las siguientes APIs:
- EC2
- AttachVolume
- CopyImage
- CreateTags
- CreateVolume
- DeleteVolume
- DescribeAvailabilityZones
- DescribeImages
- DescribeInstances
- DescribeSnapshots
- DescribeVolumes
- DetachVolume
- S3
- DeleteObject
- La configuración de la cuenta de AWS y el archivo de credenciales deben ubicarse en el directorio `$HOME/.aws/`.
- La clave privada SSH utilizada para AWS HashR debe ubicarse en el directorio `$HOME/.ssh/`. Debe coincidir con el valor de `Keyname` tal como se describe en `aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’`
##### Configuración de la instancia EC2 de AWS
Esta sección describe cómo crear instancias EC2 para usar con HashR. Idealmente queremos dos cuentas de AWS: `hashr.uploader` y `hashr.worker`.
`hashr.uploader` se usa en las instancias EC2 y necesita permisos para subir imágenes de disco archivadas al bucket de S3. `scripts/aws/AwsHashrUploaderPolicy.json` contiene una política de ejemplo para el bucket de S3 `hashr-bucket`.
`hashr.worker` se usa en el equipo que ejecuta los comandos de HashR. La cuenta necesita permisos de EC2 y S3. `scripts/aws/AwsHashrWorkerPolicy.json` contiene una política de ejemplo para la cuenta `hashr.worker`.
El script `hashr_setup.sh` ayuda a crear instancias EC2. Edite `hashr_setup.sh` y revise y actualice los siguientes campos según sea necesario:
- `AWS_PROFILE`
- `AWS_REGION`
- `SECURITY_SOURCE_CIDR`
- `WORKER_AWS_CONFIG_FILE`
**Nota**: El archivo especificado `WORKER_AWS_CONFIG_FILE` debe existir en el directorio junto con `hashr_setup.sh`.
**Nota**: `hashr_setup.sh` debe ejecutarse desde el mismo directorio donde se encuentra `hashr_setup.sh`.
Ejecute los siguientes comandos para crear y configurar las instancias 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
El importador de AWS realiza los siguientes pasos de alto nivel:
El comando siguiente procesa imágenes debian-12 y las almacena en una base de datos PostgreSQL.```shell
hashr -storage postgres -exporters postgres -importers aws -aws_bucket aws-hashr-bucket -aws_os_filter debian-12
**Nota**: Se usó Amazon Linux (al2023-*) como worker durante el desarrollo del importador. Por lo tanto, el valor predeterminado de `-aws_ssh_user` se establece en `ec2-user`. Una distro diferente puede tener un usuario SSH predeterminado diferente; use `-aws_ssh_user` para establecer el usuario SSH adecuado.
#### GCR (Google Container Registry)
Este importador extrae archivos de imágenes de contenedores almacenadas en repositorios de GCR. Para configurarlo, siga estos pasos:
Paso 1: Cree la cuenta de servicio de HashR, omita al paso 4 si esto ya se hizo durante la configuración de otros componentes dependientes de GCP.``` shell
gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Paso 2: Cree una clave de cuenta de servicio y guárdela en su directorio de inicio. Asegúrese de establecer <project_name> con el nombre de su proyecto:``` shell gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Paso 3: Apunta la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a tu clave de cuenta de servicio:``` shell
export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Paso 4: Otorgue a la clave de cuenta de servicio de hashR los permisos necesarios para acceder al repositorio de GCR indicado.``` 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 necesitas especificar la(s) siguiente(s) bandera(s):
1. `-gcr_repos` que debe contener una lista separada por comas de los repositorios de GCR desde los que quieres importar las imágenes de contenedor.
#### Windows
Este importador extrae archivos de medios de instalación oficiales de Windows en formato ISO-13346, por ejemplo, los que puedes descargar del [sitio web](https://www.microsoft.com/en-gb/software-download/windows10ISO) oficial de Microsoft.
Un archivo ISO puede contener varias imágenes WIM:
1. Windows10ProEducation
1. Windows10Education
1. Windows10EducationN
1. Windows10ProN
1. etc.
Este importador extraerá archivos de todas las imágenes que pueda encontrar en el archivo `install.wim`.
#### WSUS
Este importador utiliza 7z para extraer recursivamente el contenido de los paquetes de Windows Update. Buscará archivos de Windows Update en el bucket de GCS proporcionado; la forma más sencilla de actualizar automáticamente el bucket de GCS con nuevas actualizaciones sería hacer lo siguiente:
1. Configurar una VM de GCE que ejecute Windows Server en el proyecto hashr de GCP.
1. Configurarla con el rol de WSUS, seleccionar los paquetes de Windows Update que quieras procesar
1. Configurar WSUS para que apruebe y descargue automáticamente las actualizaciones al almacenamiento local
1. Programar una tarea de Windows para sincronizar automáticamente el contenido del almacenamiento local con el bucket de GCS: `gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/` (recuerda ajustar las rutas)
1. Si deseas usar el nombre de archivo del paquete de actualización (que normalmente contiene el número de KB) como ID (por defecto es sha1, así es como MS almacena las actualizaciones de WSUS) y su descripción, esto es algo que se puede extraer de la base de datos WID interna de WSUS. Puedes usar el siguiente script de Power Shell y ejecutarlo como tarea:```
#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/
Esto volcará la información relevante de la base de datos de WSUS, la almacenará en el archivo export.csv y sincronizará el contenido de la carpeta de WSUS con el bucket de GCS. El importador de WSUS comprobará si el archivo export.csv está presente en la raíz del repositorio de WSUS y, si es así, lo utilizará.
Este es un importador sencillo que recorre los repositorios y busca archivos .tar.gz. Una vez encontrado, calculará el hash de los primeros y los últimos 10 MB del archivo para comprobar si ya fue procesado. Esto se hace para evitar tener que calcular el hash de todo el archivo cada vez que se escanea el repositorio en busca de nuevas fuentes. Para usar este importador, debes especificar la(s) siguiente(s) bandera(s):
-targz_repo_path, que debe apuntar a la ruta en el sistema de archivos local que contiene archivos .tar.gzEste es muy similar al importador TarGz, excepto que busca paquetes .deb. Una vez encontrado, calculará el hash de los primeros y los últimos 10 MB del archivo para comprobar si ya fue procesado. Esto se hace para evitar tener que calcular el hash de todo el archivo cada vez que se escanea el repositorio en busca de nuevas fuentes. Para usar este importador, debes especificar la(s) siguiente(s) bandera(s):
-deb_repo_path, que debe apuntar a la ruta en el sistema de archivos local que contiene archivos .debEste es muy similar al importador TarGz, excepto que busca paquetes .rpm. Una vez encontrado, calculará el hash de los primeros y los últimos 10 MB del archivo para comprobar si ya fue procesado. Esto se hace para evitar tener que calcular el hash de todo el archivo cada vez que se escanea el repositorio en busca de nuevas fuentes. Para usar este importador, debes especificar la(s) siguiente(s) bandera(s):
-rpm_repo_path, que debe apuntar a la ruta en el sistema de archivos local que contiene archivos .rpmEste es muy similar al importador TarGz, excepto que busca archivos .zip. Una vez encontrado, calculará el hash de los primeros y los últimos 10 MB del archivo para comprobar si ya fue procesado. Esto se hace para evitar tener que calcular el hash de todo el archivo cada vez que se escanea el repositorio en busca de nuevas fuentes. Para usar este importador, debes especificar la(s) siguiente(s) bandera(s):
-zip_repo_path, que debe apuntar a la ruta en el sistema de archivos local que contiene archivos .zipOpcionalmente, también puedes configurar la(s) siguiente(s) bandera(s):
-zip_file_exts lista de extensiones de archivo separadas por comas para tratar como archivos zip, p. ej. "zip,whl,jar". Valor predeterminado: "zip"Este es muy similar al importador TarGz, excepto que busca archivos .iso. Una vez encontrado, calculará el hash de los primeros y los últimos 10 MB del archivo para comprobar si ya fue procesado. Esto se hace para evitar tener que calcular el hash de todo el archivo cada vez que se escanea el repositorio en busca de nuevas fuentes. Para usar este importador, debes especificar la(s) siguiente(s) bandera(s):
-iso_repo_path, que debe apuntar a la ruta en el sistema de archivos local que contiene archivos .isoEl exportador de Postgres permite enviar hashes, metadatos de archivos y el contenido real del archivo a una instancia de PostgreSQL. Para un mejor rendimiento, se recomienda configurarlo en una máquina separada y dedicada. Si configuraste PostgreSQL al elegir el almacenamiento de trabajos de procesamiento, ya casi estás listo; solo ejecuta el siguiente comando para crear las tablas necesarias:``` shell cat scripts/CreatePostgresExporterTables.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Si no elegiste Postgres para el almacenamiento de trabajos de procesamiento, sigue los pasos 1 y 2 de la sección [Configuración del almacenamiento PostgreSQL](####setting-up-postgresql-storage).
Actualmente este es el exportador predeterminado, no necesitas habilitarlo explícitamente. Por defecto, el contenido de los archivos reales no se subirá a la base de datos PostgreSQL; si deseas cambiar eso, usa la bandera `-upload_payloads true`.
Para que el exportador de Postgres funcione, necesitas establecer las siguientes banderas: `-exporters postgres -postgresHost <host> -postgresPort <port> -postgresUser <user> -postgresPassword <pass> -postgresDBName <db_name>`
#### Configuración del exportador GCP
El exportador GCP permite enviar hashes y metadatos de archivos a una instancia de GCP Spanner. Opcionalmente, puedes subir los archivos extraídos a un bucket de GCS. Si no has configurado Cloud Spanner para almacenar trabajos de procesamiento, sigue los pasos de [Configuración de Cloud Spanner](####setting-up-cloud-spanner) y, en lugar del último paso, ejecuta el siguiente comando para crear las tablas necesarias:``` shell
gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateCloudSpannerExporterTables.ddl
Si ya has configurado Cloud Spanner para almacenar los datos de los trabajos, solo necesitas ejecutar el comando anterior y estarás listo.
Si deseas subir los archivos extraídos a GCS, necesitas crear el bucket de GCS:
Paso 1: Haz que la cuenta de servicio sea administradora de este bucket:``` shell gcloud storage buckets create gs://<gcs_bucket_name> --project=project_name>
Paso 2: Haz que la cuenta de servicio sea administradora de este 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 necesitas proporcionar los siguientes flags: -exporters GCP -gcp_exporter_gcs_bucket <gcs_bucket_name>
-processing_worker_count: Este flag controla el número de trabajadores de procesamiento en paralelo. El procesamiento consume mucha CPU y E/S; durante mis pruebas encontré que tener 2 trabajadores es la solución más óptima.-cache_dir: Ubicación de la caché local utilizada para la deduplicación; se recomienda cambiarla de /tmp a, por ejemplo, el directorio de inicio del usuario que ejecutará hashr.-export: Cuando se establece en false, hashr guardará los resultados en el disco sin pasar por el exportador.-export_path: Si export está establecido en false, esta es la carpeta donde se guardarán las muestras.-reprocess: Permite reprocesar una fuente determinada (en caso de que, p. ej., haya fallado) basándose en el valor sha256 almacenado en la tabla de trabajos.-upload_payloads: Controla si el contenido real del archivo será subido por los exportadores definidos.-gcp_exporter_worker_count: Número de trabajadores/goroutines que el exportador de GCP utilizará para subir los datos.Este no es un producto oficialmente respaldado por Google.