google/hashrErstellt forensische Datei-Hash-Sets aus Datenträger-Images, Paketen und Archiven aus GCP, AWS und lokalen Quellen, mit Deduplizierung und PostgreSQL/Spanner-Export für DFIR-Workflows.
HashR ermöglicht es dir, eigene Hash-Sets basierend auf deinen Datenquellen zu erstellen. Es ist ein Tool, das Dateien und Hashes aus Eingabequellen extrahiert (z. B. rohes Festplatten-Image, GCE-Festplatten-Image, ISO-Datei, Windows-Update-Paket, .tar.gz-Datei usw.).
HashR besteht aus den folgenden Komponenten:
Derzeit implementierte Importeure:
Sobald Dateien extrahiert und gehasht wurden, werden die Ergebnisse an die Exporteure übergeben. Derzeit implementierte Exporteure:
Du kannst auswählen, welche Importeure du ausführen möchtest; jeder hat unterschiedliche Anforderungen. Mehr dazu findest du in den folgenden Abschnitten.
HashR benötigt ein Linux-Betriebssystem, um ausgeführt zu werden. Dies kann eine physische, virtuelle oder Cloud-Maschine sein. Im Folgenden sind die optimalen Hardware-Anforderungen aufgeführt:
HashR läuft wahrscheinlich auch auf Maschinen mit geringeren Spezifikationen, dies wurde jedoch nicht gründlich getestet.
Um eine HashR-Binary zu erstellen, führe den folgenden Befehl aus:``` shell env GOOS=linux GOARCH=amd64 go build hashr.go
Um Tests für das Kernpaket hashR auszuführen, müssen Sie den Spanner-Emulator starten:``` shell
gcloud emulators spanner start
Um dann alle Tests auszuführen, führen Sie den folgenden Befehl aus:``` shell go test -timeout 2m ./...
## HashR einrichten
### HashR in OSDFIR Infrastructure
Sie können HashR als Teil des [OSDFIR-Infrastructure-Projekts](https://github.com/google/osdfir-infrastructure/tree/main/charts/hashr) bereitstellen. Diese Bereitstellung führt HashR als Kubernetes-Cronjobs aus und ermöglicht eine einfache
Integration mit Timesketch.
### HashR mit Docker
Um HashR in einem Docker-Container auszuführen, besuchen Sie den [Docker-spezifischen Leitfaden](https://github.com/google/hashr/blob/main/docker/README.md).
### OS-Konfiguration und erforderliche Drittanbieter-Tools
HashR übernimmt die schwere Arbeit (Parsen von Datenträger-Images, Volumes, Dateisystemen) mithilfe von Plaso. Sie müssen den Plaso-Docker-Container mit dem folgenden Befehl abrufen:``` shell
docker pull log2timeline/plaso
Zudem muss 7z, das vom WSUS importer für die rekursive Extraktion von Windows-Update-Paketen verwendet wird, auf dem Rechner installiert sein, auf dem HashR läuft:``` shell sudo apt install p7zip-full
Sie müssen dem Benutzer, unter dem HashR ausgeführt wird, erlauben, bestimmte Befehle über sudo auszuführen. Angenommen, Ihr Benutzer ist `hashr`, erstellen Sie eine Datei `/etc/sudoers.d/hashr` und fügen Sie Folgendes ein:``` shell
hashr ALL = (root) NOPASSWD: /bin/mount,/bin/umount,/sbin/losetup,/bin/rm
Der Benutzer, unter dem HashR ausgeführt wird, muss auch in der Lage sein, Docker auszuführen. Angenommen, Ihr Benutzer ist hashr, fügen Sie ihn wie folgt zur Docker-Gruppe hinzu:``` shell
sudo usermod -aG docker hashr
### Einrichtung des Speichers für Verarbeitungsaufgaben
HashR muss Informationen über verarbeitete Quellen speichern. Außerdem speichert es zusätzliche Telemetriedaten zu Verarbeitungsaufgaben: Verarbeitungszeiten, Anzahl der extrahierten Dateien usw. Sie können zwischen folgenden Optionen wählen:
1. PostgreSQL
1. Cloud (GCP) Spanner
#### Einrichten des PostgreSQL-Speichers
Es gibt viele Möglichkeiten, Ihre PostgreSQL-Instanz zu betreiben und zu warten. Eine der einfachsten Möglichkeiten ist der Betrieb in einem Docker-Container. Befolgen Sie die folgenden Schritte, um einen PostgreSQL-Docker-Container einzurichten.
Schritt 1: Ziehen Sie das PostgreSQL-Docker-Image.``` shell
docker pull postgres
Schritt 2: Initialisieren und starten Sie den PostgreSQL-Container im Hintergrund. Achten Sie darauf, das Passwort anzupassen.``` 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
Schritt 3: Erstellen Sie eine Tabelle, die zum Speichern von Verarbeitungsaufträgen verwendet wird.``` shell
cat scripts/CreateJobsTable.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Um PostgreSQL zum Speichern von Informationen über Verarbeitungsaufgaben zu verwenden, müssen Sie die folgenden Flags angeben: -storage postgres -postgres_host <host> -postgres_port <port> -postgres_user <user> -postgres_password <pass> -postgres_db <db_name>
Sie können wählen, die Daten über Verarbeitungsaufträge in Cloud Spanner zu speichern. Dazu benötigen Sie ein Google Cloud-Projekt. Der Hauptvorteil dieser Einrichtung ist, dass Sie mithilfe von Google Data Studio problemlos Dashboards erstellen und direkt eine Verbindung zur Cloud-Spanner-Instanz herstellen können, was Überwachung und Debugging ermöglicht, ohne Abfragen gegen Ihre PostgreSQL-Instanz ausführen zu müssen.
Angenommen, Ihr gcloud-Tool ist mit Ihrem Ziel-HashR-GCP-Projekt konfiguriert, müssen Sie die folgenden Schritte ausführen, um Cloud Spanner zu aktivieren.
HashR-Dienstkonto erstellen:``` shell gcloud iam service-accounts create hashr --description="HashR SA key." --display-name="hashr"
Erstellen Sie einen Service-Account-Schlüssel und speichern Sie ihn in Ihrem Home-Verzeichnis. Setzen Sie *<project_name>* auf Ihren Projektnamen.``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Setzen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS auf Ihren Service-Account-Schlüssel:``` shell export GOOGLE_APPLICATION_CREDENTIALS=/home/hashr/hashr-sa-private-key.json
Erstellen Sie eine Spanner-Instanz und passen Sie bei Bedarf den config- und den processing-units-Wert an:``` shell
gcloud spanner instances create hashr --config=regional-us-central1 --description="hashr" --processing-units=100
Spanner-Datenbank erstellen:``` shell gcloud spanner databases create hashr --instance=hashr
Erlauben Sie dem Dienstkonto die Verwendung der Spanner-Datenbank und setzen Sie *<project_name>* auf Ihren Projektnamen:``` shell
gcloud spanner databases add-iam-policy-binding hashr --instance hashr --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="roles/spanner.databaseUser"
Spanner-Datenbankschema aktualisieren:``` shell gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateJobsTable.ddl
Um Cloud Spanner zum Speichern von Informationen über Verarbeitungsaufgaben zu verwenden, müssen Sie die folgenden Flags angeben: `-jobStorage cloudspanner -spannerDBPath <spanner_db_path>`
### Setting up importers
Um anzugeben, welchen Importer Sie ausführen möchten, sollten Sie das Flag `-importers` verwenden. Mögliche Werte: `GCP,targz,windows,wsus,deb,rpm,zip,gcr,iso9660`
#### GCP (Google Cloud Platform)```shell
-importers GCP
Dieser Importer kann Dateien aus GCP-Disk-Images extrahieren. Dies erfolgt in wenigen Schritten:
dd auf dem kopierten Image ausführt und die Ausgabe in einer .tar.gz-Datei speichert.Eine Liste von GCP-Projekten mit öffentlichen GCP-Images finden Sie hier. Um diesen Importer nutzen zu können, benötigen Sie ein GCP-Projekt und müssen die folgenden Schritte ausführen:
Schritt 1: HashR-Dienstkonto erstellen. Falls dies bereits beim Einrichten von Cloud Spanner erfolgt ist, fahren Sie mit Schritt 4 fort.``` shell gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Schritt 2: Erstellen Sie einen Dienstkontoschlüssel und speichern Sie ihn in Ihrem Home-Verzeichnis. Stellen Sie sicher, dass Sie *<project_name>* auf Ihren Projektnamen setzen:``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Schritt 3: Setzen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS auf Ihren Dienstkonto-Schlüssel:``` shell export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Schritt 4: Erstellen Sie einen GCS-Bucket zum Speichern von Disk-Images im .tar.gz-Format, setzen Sie *<project_name>* auf Ihren Projektnamen und *<gcs_bucket_name>* auf den Namen Ihres neuen GCS-Buckets:``` shell
gcloud storage buckets create gs://<gcs_bucket_name> --project=<project_name>
Schritt 5: Machen Sie das Dienstkonto zum Administrator dieses Buckets:``` 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"
Schritt 6: Compute API aktivieren:``` shell
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com
Schritt 7: IAM-Rolle erstellen und ihr die erforderlichen Berechtigungen zuweisen:``` 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
Schritt 8: IAM-Rolle an das Dienstkonto binden:``` shell
gcloud projects add-iam-policy-binding <project_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="projects/<project_name>/roles/hashr"
Schritt 9a: Aktivieren Sie die cloudbuild API``` shell gcloud services enable cloudbuild.googleapis.com --project <project_name>
Schritt 9b: Rufe deine project_number ab```shell
gcloud projects list --filter="mlegin-testing-things" --format="value(PROJECT_NUMBER)"
Schritt 9c: Gewähren Sie den Dienstkonten den Zugriff, der zum Ausführen von Cloud Build erforderlich ist, und stellen Sie sicher, dass Sie die Werte <project_name> und <project_number> ändern:``` 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'
Um diesen Importer zu verwenden, musst du die folgenden Flags angeben:
1. `-gcp_projects` eine durch Kommas getrennte Liste von Cloud-Projekten, die Datenträgerimages enthalten. Wenn du öffentliche Images importieren möchtest, wirf einen Blick [hier](https://cloud.google.com/compute/docs/images/os-details#general-info).
1. `-hashr_gcp_project` GCP-Projekt, das verwendet wird, um eine Kopie der Datenträgerimages für die Verarbeitung zu speichern und auch Cloud Build auszuführen
1. `-hashr_gcs_bucket` GCS-Bucket, der verwendet wird, um die Ausgabe von Cloud Build zu speichern (Datenträgerimages im `.tar.gz`-Format)
#### AWS
Dieser Importer verarbeitet Amazon-eigene AMIs und erzeugt Hashes. Der Importer benötigt mindestens einen HashR-Worker (eine EC2-Instanz).
##### AWS HashR-Worker
Der AWS-HashR-Worker ist eine EC2-Instanz, an die das Volume der AMI angehängt wird, ein Datenträgerarchiv erstellt und anschließend in einen S3-Bucket hochgeladen wird. Es wird empfohlen, mindestens zwei AWS-HashR-Worker zu haben. Wenn dein Setup einen einzelnen AWS-Worker verwendet, verwende `-processing_worker_count 1`.
Ein AWS-HashR-Worker muss die folgenden Anforderungen erfüllen:
- EC2-Instanzen müssen das Tag `InUse: false` haben. Wenn der Wert `true` ist, wird der Worker nicht für die Verarbeitung verwendet.```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Tags’
Das System, auf dem hashr läuft, muss per SSH auf die EC2-Instanz zugreifen können, und zwar mit:
Keyname beschrieben. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’Zu FQDN, wie in PublicDnsName beschrieben. ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].PublicDnsName’
Das Skript scripts/hashr-archive muss auf den AWS-HashR-Worker nach /usr/local/sbin/hashr-archive kopiert werden.
Ein AWS-Konto mit der Berechtigung, Dateien in den HashR-Bucket hochzuladen. Die AWS-Konfiguration und die Anmeldedaten sollten im Verzeichnis $HOME/.aws/ gespeichert werden.```shell
aws configure
##### HashR-Anwendung
Auf dem System, auf dem `hashr` ausgeführt wird, ist Folgendes erforderlich.
- Ein AWS-Konto mit Berechtigungen zum Aufrufen der folgenden APIs:
- EC2
- AttachVolume
- CopyImage
- CreateTags
- CreateVolume
- DeleteVolume
- DescribeAvailabilityZones
- DescribeImages
- DescribeInstances
- DescribeSnapshots
- DescribeVolumes
- DetachVolume
- S3
- DeleteObject
- Die AWS-Kontokonfiguration und die Credential-Datei müssen sich im Verzeichnis `$HOME/.aws/` befinden.
- Der für AWS HashR verwendete SSH-Private-Key muss sich im Verzeichnis `$HOME/.ssh/` befinden. Er muss mit dem Wert von `Keyname` übereinstimmen, wie in `aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’` beschrieben.
##### AWS-EC2-Instanz einrichten
Dieser Abschnitt beschreibt, wie EC2-Instanzen für die Verwendung mit HashR erstellt werden. Idealerweise benötigen wir zwei AWS-Konten: `hashr.uploader` und `hashr.worker`.
`hashr.uploader` wird auf EC2-Instanzen verwendet und benötigt Berechtigungen, um archivierte Datenträger-Images in den S3-Bucket hochzuladen. `scripts/aws/AwsHashrUploaderPolicy.json` enthält eine Beispielrichtlinie für den S3-Bucket `hashr-bucket`.
`hashr.worker` wird auf dem Computer verwendet, auf dem HashR-Befehle ausgeführt werden. Das Konto benötigt EC2- und S3-Berechtigungen. `scripts/aws/AwsHashrWorkerPolicy.json` enthält eine Beispielrichtlinie für das `hashr.worker`-Konto.
`hashr_setup.sh` ist ein Skript, das beim Erstellen von EC2-Instanzen hilft. Bearbeiten Sie `hashr_setup.sh` und überprüfen und aktualisieren Sie die folgenden Felder nach Bedarf:
- `AWS_PROFILE`
- `AWS_REGION`
- `SECURITY_SOURCE_CIDR`
- `WORKER_AWS_CONFIG_FILE`
**Hinweis**: Die unter `WORKER_AWS_CONFIG_FILE` angegebene Datei muss im Verzeichnis mit `hashr_setup.sh` vorhanden sein.
**Hinweis**: `hashr_setup.sh` muss aus demselben Verzeichnis ausgeführt werden, in dem sich `hashr_setup.sh` befindet.
Führen Sie die folgenden Befehle aus, um die EC2-Instanzen zu erstellen und einzurichten.```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
Der AWS-Importer führt die folgenden Schritte auf hoher Ebene aus:
Der folgende Befehl verarbeitet debian-12-Images und speichert sie in einer PostgreSQL-Datenbank.```shell
hashr -storage postgres -exporters postgres -importers aws -aws_bucket aws-hashr-bucket -aws_os_filter debian-12
**Hinweis**: Beim Entwickeln des Importers wurde Amazon Linux (al2023-*) als Worker verwendet. Daher ist der Standardwert für `-aws_ssh_user` auf `ec2-user` gesetzt. Eine andere Distribution kann einen anderen Standard-SSH-Benutzer haben. Verwenden Sie `-aws_ssh_user`, um den entsprechenden SSH-Benutzer festzulegen.
#### GCR (Google Container Registry)
Dieser Importer extrahiert Dateien aus Container-Images, die in GCR-Repositories gespeichert sind. Um ihn einzurichten, gehen Sie folgendermaßen vor:
Schritt 1: Erstellen Sie ein HashR-Dienstkonto. Springen Sie zu Schritt 4, wenn dies bereits beim Einrichten anderer GCP-abhängiger Komponenten erledigt wurde.``` shell
gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
Schritt 2: Erstellen Sie einen Dienstkontoschlüssel und speichern Sie ihn in Ihrem Home-Verzeichnis. Stellen Sie sicher, dass Sie <project_name> auf Ihren Projektnamen setzen:``` shell gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
Schritt 3: Setzen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS auf Ihren Servicekontoschlüssel:``` shell
export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
Schritt 4: Erteilen Sie dem hashR-Dienstkontoschlüssel die erforderlichen Berechtigungen für den Zugriff auf das angegebene GCR-Repository.``` 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"
Um diesen Importer zu verwenden, müssen Sie die folgenden Flags angeben:
1. `-gcr_repos`, das eine durch Kommas getrennte Liste von GCR-Repositories enthalten sollte, aus denen Sie die Container-Images importieren möchten.
#### Windows
Dieser Importer extrahiert Dateien aus offiziellen Windows-Installationsmedien im ISO-13346-Format, z. B. denjenigen, die Sie von der offiziellen Microsoft-[Website](https://www.microsoft.com/en-gb/software-download/windows10ISO) herunterladen können.
Eine ISO-Datei kann mehrere WIM-Images enthalten:
1. Windows10ProEducation
1. Windows10Education
1. Windows10EducationN
1. Windows10ProN
1. usw.
Dieser Importer extrahiert Dateien aus allen Images, die er in der Datei `install.wim` finden kann.
#### WSUS
Dieser Importer verwendet 7z, um den Inhalt von Windows-Update-Paketen rekursiv zu extrahieren. Er sucht nach Windows-Update-Dateien im angegebenen GCS-Bucket. Der einfachste Weg, den GCS-Bucket automatisch mit neuen Updates zu aktualisieren, wäre Folgendes:
1. Richten Sie eine GCE-VM ein, auf der Windows Server im GCP-Projekt hashr läuft.
1. Konfigurieren Sie sie mit der WSUS-Rolle und wählen Sie die Windows-Update-Pakete aus, die Sie verarbeiten möchten.
1. Konfigurieren Sie WSUS so, dass Updates automatisch genehmigt und in den lokalen Speicher heruntergeladen werden.
1. Richten Sie eine Windows-Aufgabe ein, die den Inhalt des lokalen Speichers automatisch mit dem GCS-Bucket synchronisiert: `gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/` (denken Sie daran, die Pfade anzupassen).
1. Wenn Sie den Dateinamen des Update-Pakets (der normalerweise die KB-Nummer enthält) als ID verwenden möchten (standardmäßig ist es sha1, so speichert MS WSUS-Updates) und dessen Beschreibung, kann dies aus der internen WID-WSUS-Datenbank exportiert werden. Sie können das folgende PowerShell-Skript verwenden und es als Aufgabe ausführen:```
#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/
Dadurch werden die relevanten Informationen aus der WSUS-DB exportiert, in der Datei export.csv gespeichert und der Inhalt des WSUS-Ordners mit dem GCS-Bucket synchronisiert. Der WSUS-Importer prüft, ob die Datei export.csv im Stammverzeichnis des WSUS-Repos vorhanden ist; wenn ja, verwendet er sie.
Dies ist ein einfacher Importer, der Repositories durchläuft und nach .tar.gz-Dateien sucht. Sobald eine Datei gefunden wird, werden die ersten und letzten 10 MB der Datei gehasht, um zu prüfen, ob sie bereits verarbeitet wurde. Dies dient dazu, ein Hashing der gesamten Datei bei jedem Scan des Repositories nach neuen Quellen zu vermeiden. Um diesen Importer zu verwenden, musst du die folgenden Flags angeben:
-targz_repo_path, das auf den Pfad im lokalen Dateisystem zeigen sollte, der .tar.gz-Dateien enthältDies ist dem TarGz-Importer sehr ähnlich, mit dem Unterschied, dass nach .deb-Paketen gesucht wird. Sobald eines gefunden wird, werden die ersten und letzten 10 MB der Datei gehasht, um zu prüfen, ob es bereits verarbeitet wurde. Dies dient dazu, ein Hashing der gesamten Datei bei jedem Scan des Repositories nach neuen Quellen zu vermeiden. Um diesen Importer zu verwenden, musst du die folgenden Flags angeben:
-deb_repo_path, das auf den Pfad im lokalen Dateisystem zeigen sollte, der .deb-Dateien enthältDies ist dem TarGz-Importer sehr ähnlich, mit dem Unterschied, dass nach .rpm-Paketen gesucht wird. Sobald eines gefunden wird, werden die ersten und letzten 10 MB der Datei gehasht, um zu prüfen, ob es bereits verarbeitet wurde. Dies dient dazu, ein Hashing der gesamten Datei bei jedem Scan des Repositories nach neuen Quellen zu vermeiden. Um diesen Importer zu verwenden, musst du die folgenden Flags angeben:
-rpm_repo_path, das auf den Pfad im lokalen Dateisystem zeigen sollte, der .rpm-Dateien enthältDies ist dem TarGz-Importer sehr ähnlich, mit dem Unterschied, dass nach .zip-Archiven gesucht wird. Sobald eines gefunden wird, werden die ersten und letzten 10 MB der Datei gehasht, um zu prüfen, ob es bereits verarbeitet wurde. Dies dient dazu, ein Hashing der gesamten Datei bei jedem Scan des Repositories nach neuen Quellen zu vermeiden. Um diesen Importer zu verwenden, musst du die folgenden Flags angeben:
-zip_repo_path, das auf den Pfad im lokalen Dateisystem zeigen sollte, der .zip-Dateien enthältOptional kannst du außerdem die folgenden Flags setzen:
-zip_file_exts – Kommagetrennte Liste von Dateiendungen, die als Zip-Dateien behandelt werden sollen, z. B. „zip,whl,jar“. Standard: „zip“Dies ist dem TarGz-Importer sehr ähnlich, mit dem Unterschied, dass nach .iso-Dateien gesucht wird. Sobald eine gefunden wird, werden die ersten und letzten 10 MB der Datei gehasht, um zu prüfen, ob sie bereits verarbeitet wurde. Dies dient dazu, ein Hashing der gesamten Datei bei jedem Scan des Repositories nach neuen Quellen zu vermeiden. Um diesen Importer zu verwenden, musst du die folgenden Flags angeben:
-iso_repo_path, das auf den Pfad im lokalen Dateisystem zeigen sollte, der .iso-Dateien enthältDer Postgres-Exporter ermöglicht das Senden von Hashes, Dateimetadaten und dem tatsächlichen Inhalt der Datei an eine PostgreSQL-Instanz. Für die beste Leistung wird empfohlen, ihn auf einer separaten und dedizierten Maschine einzurichten. Wenn du PostgreSQL bei der Auswahl des Speichers für die Verarbeitungsaufträge eingerichtet hast, bist du fast startklar. Führe einfach den folgenden Befehl aus, um die erforderlichen Tabellen zu erstellen:``` shell cat scripts/CreatePostgresExporterTables.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
Falls du PostgreSQL nicht für die Speicherung von Verarbeitungsaufträgen gewählt hast, folge den Schritten 1 und 2 aus dem Abschnitt [Einrichtung des PostgreSQL-Speichers](####setting-up-postgresql-storage).
Dies ist derzeit der Standard-Exporter; du musst ihn nicht explizit aktivieren. Standardmäßig werden die Inhalte der eigentlichen Dateien nicht in die PostgreSQL-Datenbank hochgeladen. Wenn du das ändern möchtest, verwende das Flag `-upload_payloads true`.
Damit der Postgres-Exporter funktioniert, musst du die folgenden Flags setzen: `-exporters postgres -postgresHost <host> -postgresPort <port> -postgresUser <user> -postgresPassword <pass> -postgresDBName <db_name>`
#### Einrichten des GCP-Exporters
Der GCP-Exporter ermöglicht das Senden von Hashes und Dateimetadaten an eine GCP-Spanner-Instanz. Optional kannst du die extrahierten Dateien in einen GCS-Bucket hochladen. Wenn du Cloud Spanner noch nicht für die Speicherung von Verarbeitungsaufträgen eingerichtet hast, folge den Schritten unter [Einrichtung von Cloud Spanner](####setting-up-cloud-spanner) und führe anstelle des letzten Schritts den folgenden Befehl aus, um die erforderlichen Tabellen zu erstellen:``` shell
gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateCloudSpannerExporterTables.ddl
Wenn Sie bereits Cloud Spanner für die Speicherung von Auftragsdaten eingerichtet haben, müssen Sie nur den obigen Befehl ausführen und schon kann es losgehen.
Wenn Sie die extrahierten Dateien in GCS hochladen möchten, müssen Sie den GCS-Bucket erstellen:
Schritt 1: Machen Sie das Dienstkonto zum Administrator dieses Buckets:``` shell gcloud storage buckets create gs://<gcs_bucket_name> --project=project_name>
Schritt 2: Machen Sie das Dienstkonto zum Administrator dieses Buckets:``` 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"
Um diesen Exporter zu verwenden, müssen die folgenden Flags angegeben werden: -exporters GCP -gcp_exporter_gcs_bucket <gcs_bucket_name>
-processing_worker_count: Dieses Flag steuert die Anzahl der parallelen Verarbeitungs-Worker. Die Verarbeitung ist CPU- und I/O-intensiv; in meinen Tests habe ich festgestellt, dass 2 Worker die optimale Lösung sind.-cache_dir: Speicherort des lokalen Caches, der für die Deduplizierung verwendet wird. Es wird empfohlen, diesen von /tmp beispielsweise in das Home-Verzeichnis des Benutzers zu ändern, der hashr ausführen wird.-export: Wenn dies auf false gesetzt ist, speichert hashr die Ergebnisse auf der Festplatte und umgeht dabei den Exporter.-export_path: Wenn export auf false gesetzt ist, ist dies der Ordner, in dem die Samples gespeichert werden.-reprocess: Ermöglicht die erneute Verarbeitung einer bestimmten Quelle (falls sie z. B. fehlgeschlagen ist) anhand des in der Jobs-Tabelle gespeicherten sha256-Werts.-upload_payloads: Steuert, ob der tatsächliche Inhalt der Datei von den definierten Exporteuren hochgeladen wird.-gcp_exporter_worker_count: Anzahl der Worker/Goroutinen, die der GCP-Exporter zum Hochladen der Daten verwendet.Dies ist kein offiziell unterstütztes Google-Produkt.