google/hashrGCP, AWS और स्थानीय स्रोतों से डिस्क इमेज, पैकेज और संग्रह से फोरेंसिक फ़ाइल हैश सेट बनाता है, DFIR वर्कफ़्लो के लिए डीडुप्लीकेशन और PostgreSQL/Spanner निर्यात के साथ।
HashR आपको अपने डेटा स्रोतों के आधार पर अपने स्वयं के हैश सेट बनाने की अनुमति देता है। यह एक उपकरण है जो इनपुट स्रोतों (जैसे रॉ डिस्क इमेज, GCE डिस्क इमेज, ISO फ़ाइल, Windows अपडेट पैकेज, .tar.gz फ़ाइल, आदि) से फ़ाइलें और हैश निकालता है।
HashR निम्नलिखित घटकों से मिलकर बना है:
वर्तमान में कार्यान्वित importers:
फ़ाइलें निकाले जाने और हैश हो जाने के बाद परिणाम exporters को भेज दिए जाएंगे, वर्तमान में कार्यान्वित exporters:
आप चुन सकते हैं कि कौन से importers चलाने हैं, प्रत्येक की अलग-अलग आवश्यकताएँ हैं। इसके बारे में अधिक जानकारी नीचे दिए गए अनुभागों में मिल सकती है।
HashR को चलाने के लिए Linux OS आवश्यक है, यह भौतिक, वर्चुअल या क्लाउड मशीन हो सकती है। नीचे इष्टतम हार्डवेयर आवश्यकताएँ दी गई हैं:
HashR संभवतः कम विशिष्टताओं वाली मशीनों पर चल सकता है, हालांकि इसका पूरी तरह से परीक्षण नहीं किया गया था।
एक hashr बाइनरी बनाने के लिए निम्नलिखित कमांड चलाएँ:``` shell env GOOS=linux GOARCH=amd64 go build hashr.go
कोर hashR पैकेज के लिए परीक्षण चलाने हेतु आपको Spanner एमुलेटर चलाना होगा:``` shell
gcloud emulators spanner start
फिर सभी परीक्षण निष्पादित करने के लिए निम्न कमांड चलाएँ:``` shell go test -timeout 2m ./...
## HashR की स्थापना
### OSDFIR इंफ्रास्ट्रक्चर में HashR
आप HashR को [OSDFIR Infrastructure project](https://github.com/google/osdfir-infrastructure/tree/main/charts/hashr) के हिस्से के रूप में तैनात कर सकते हैं। यह तैनाती HashR को kubernetes cronjobs के रूप में चलाएगी और Timesketch के साथ आसान एकीकरण की अनुमति देती है।
### Docker का उपयोग करके HashR
Docker कंटेनर में HashR चलाने के लिए [डॉकर विशिष्ट मार्गदर्शिका](https://github.com/google/hashr/blob/main/docker/README.md) देखें।
### OS कॉन्फ़िगरेशन और आवश्यक तृतीय-पक्ष टूलिंग
HashR भारी-भरकम काम (डिस्क इमेज, वॉल्यूम, फाइल सिस्टम पार्स करना) Plaso का उपयोग करके करता है। आपको निम्न कमांड का उपयोग करके Plaso docker कंटेनर खींचने की आवश्यकता है:``` shell
docker pull log2timeline/plaso
हमें 7z की भी आवश्यकता है, जिसका उपयोग WSUS importer द्वारा Windows Update पैकेजों के पुनरावर्ती निष्कर्षण के लिए किया जाता है, ताकि इसे HashR चलाने वाली मशीन पर स्थापित किया जा सके:``` shell sudo apt install p7zip-full
आपको उस उपयोगकर्ता को, जिसके अंतर्गत HashR चलेगा, sudo के माध्यम से कुछ कमांड चलाने की अनुमति देनी होगी। यह मानते हुए कि आपका उपयोगकर्ता `hashr` है, एक फ़ाइल `/etc/sudoers.d/hashr` बनाएँ और उसमें डालें:``` shell
hashr ALL = (root) NOPASSWD: /bin/mount,/bin/umount,/sbin/losetup,/bin/rm
जिस उपयोगकर्ता के अंतर्गत HashR चलेगा, उसे भी docker चलाने में सक्षम होना होगा। यह मानते हुए कि आपका उपयोगकर्ता hashr है, उसे docker समूह में इस प्रकार जोड़ें:``` shell
sudo usermod -aG docker hashr
### प्रसंस्करण कार्यों के लिए भंडारण की स्थापना
HashR को संसाधित स्रोतों के बारे में जानकारी संग्रहीत करने की आवश्यकता होती है। यह प्रसंस्करण कार्यों के बारे में अतिरिक्त टेलीमेट्री भी संग्रहीत करता है: प्रसंस्करण समय, निकाले गए फ़ाइलों की संख्या, आदि। आप उपयोग करने के बीच चयन कर सकते हैं:
1. PostgreSQL
1. Cloud (GCP) Spanner
#### PostgreSQL भंडारण की स्थापना
अपने PostgreSQL इंस्टेंस को चलाने और बनाए रखने के कई तरीके हैं, सबसे सरल तरीकों में से एक इसे Docker कंटेनर में चलाना होगा। PostgreSQL Docker कंटेनर सेट करने के लिए नीचे दिए गए चरणों का पालन करें।
चरण 1: PostgreSQL Docker इमेज पुल करें।``` shell
docker pull postgres
चरण 2: PostgreSQL कंटेनर को पृष्ठभूमि में प्रारंभ करें और चलाएँ। पासवर्ड समायोजित करना सुनिश्चित करें।``` 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
चरण 3: एक टेबल बनाएं जिसका उपयोग प्रोसेसिंग जॉब्स को संग्रहीत करने के लिए किया जाएगा।``` shell
cat scripts/CreateJobsTable.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
In order to use PostgreSQL to store information about processing tasks you need to specify the following flags: -storage postgres -postgres_host <host> -postgres_port <port> -postgres_user <user> -postgres_password <pass> -postgres_db <db_name>
आप प्रोसेसिंग जॉब्स के बारे में डेटा Cloud Spanner में संग्रहीत करना चुन सकते हैं। इसके लिए आपको एक Google Cloud प्रोजेक्ट की आवश्यकता होगी। इस सेटअप का मुख्य लाभ यह है कि आप Google Data Studio का उपयोग करके आसानी से डैशबोर्ड बना सकते हैं और सीधे Cloud Spanner इंस्टेंस से कनेक्ट हो सकते हैं, जो आपके PostgreSQL इंस्टेंस के विरुद्ध क्वेरी चलाए बिना मॉनिटरिंग और डीबगिंग की अनुमति देता है।
यह मानते हुए कि आपका gcloud टूल आपके लक्षित hashr GCP प्रोजेक्ट के साथ कॉन्फ़िगर किया गया है, Cloud Spanner को सक्षम करने के लिए आपको नीचे दिए गए चरणों का पालन करना होगा।
HashR सेवा खाता बनाएँ:``` shell gcloud iam service-accounts create hashr --description="HashR SA key." --display-name="hashr"
सेवा खाता कुंजी बनाएँ और इसे अपनी होम डायरेक्टरी में संग्रहीत करें। *<project_name>* को अपने प्रोजेक्ट नाम पर सेट करें।``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
GOOGLE_APPLICATION_CREDENTIALS env वेरिएबल को अपनी service account key पर पॉइंट करें:``` shell export GOOGLE_APPLICATION_CREDENTIALS=/home/hashr/hashr-sa-private-key.json
Spanner इंस्टेंस बनाएँ, यदि आवश्यक हो तो config और processing-units मान समायोजित करें:``` shell
gcloud spanner instances create hashr --config=regional-us-central1 --description="hashr" --processing-units=100
Spanner डेटाबेस बनाएं:``` shell gcloud spanner databases create hashr --instance=hashr
सेवा खाते (service account) को Spanner डेटाबेस का उपयोग करने की अनुमति दें, *<project_name>* को अपने प्रोजेक्ट नाम पर सेट करें:``` 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 डेटाबेस स्कीमा अपडेट करें:``` shell gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateJobsTable.ddl
Cloud Spanner का उपयोग करके प्रोसेसिंग कार्यों के बारे में जानकारी संग्रहीत करने के लिए आपको निम्नलिखित फ़्लैग निर्दिष्ट करने होंगे: `-jobStorage cloudspanner -spannerDBPath <spanner_db_path>`
### इम्पोर्टर सेट अप करना
आप कौन सा इम्पोर्टर चलाना चाहते हैं, यह निर्दिष्ट करने के लिए आपको `-importers` फ़्लैग का उपयोग करना चाहिए। संभावित मान: `GCP,targz,windows,wsus,deb,rpm,zip,gcr,iso9660`
#### GCP (Google Cloud Platform)```shell
-importers GCP
यह इम्पोर्टर GCP डिस्क इमेज से फ़ाइलें निकाल सकता है। यह कुछ चरणों में किया जाता है:
सार्वजनिक GCP इमेज वाले GCP प्रोजेक्ट्स की सूची यहाँ पाई जा सकती है। इस इम्पोर्टर का उपयोग करने के लिए आपके पास एक GCP प्रोजेक्ट होना आवश्यक है और इन चरणों का पालन करें:
Step 1: HashR सेवा खाता बनाएं, यदि यह Cloud Spanner सेट करते समय किया गया था तो कृपया Step 4 पर जाएं।``` shell gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
चरण 2: सेवा खाता कुंजी बनाएँ और इसे अपनी होम निर्देशिका में संग्रहीत करें। सुनिश्चित करें कि *<project_name>* को अपने प्रोजेक्ट नाम पर सेट करें:``` shell
gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
चरण 3: GOOGLE_APPLICATION_CREDENTIALS env वेरिएबल को अपनी सेवा खाता कुंजी पर इंगित करें:``` shell export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
चरण 4: GCS bucket बनाएं जिसका उपयोग डिस्क इमेज को .tar.gz प्रारूप में संग्रहीत करने के लिए किया जाएगा, *<project_name>* को अपने प्रोजेक्ट के नाम पर और *<gcs_bucket_name>* को अपने नए GCS bucket नाम पर सेट करें:``` shell
gcloud storage buckets create gs://<gcs_bucket_name> --project=<project_name>
चरण 5: इस बकेट का सेवा खाता व्यवस्थापक बनाएं:``` 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"
चरण 6: Compute API सक्षम करें:``` shell
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com
चरण 7: IAM रोल बनाएँ और उसे आवश्यक अनुमतियाँ प्रदान करें:``` 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
चरण 8: IAM role को service account से बांधें:``` shell
gcloud projects add-iam-policy-binding <project_name> --member="serviceAccount:hashr-sa@<project_name>.iam.gserviceaccount.com" --role="projects/<project_name>/roles/hashr"
चरण 9a: cloudbuild API सक्षम करें``` shell gcloud services enable cloudbuild.googleapis.com --project <project_name>
चरण 9b: अपना project_number प्राप्त करें```shell
gcloud projects list --filter="mlegin-testing-things" --format="value(PROJECT_NUMBER)"
चरण 9c: Cloud Build चलाने के लिए आवश्यक service accounts एक्सेस प्रदान करें, सुनिश्चित करें कि <project_name> और <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'
इस इम्पोर्टर का उपयोग करने के लिए आपको निम्नलिखित फ़्लैग(s) निर्दिष्ट करने होंगे:
1. `-gcp_projects` जो डिस्क इमेज वाले क्लाउड प्रोजेक्ट्स की अल्पविराम से अलग की गई सूची है। यदि आप सार्वजनिक इमेज आयात करना चाहते हैं तो [यहाँ](https://cloud.google.com/compute/docs/images/os-details#general-info) देखें।
1. `-hashr_gcp_project` वह GCP प्रोजेक्ट जिसका उपयोग प्रोसेसिंग के लिए डिस्क इमेज की प्रतिलिपि संग्रहीत करने और Cloud Build चलाने के लिए किया जाएगा।
1. `-hashr_gcs_bucket` वह GCS बकेट जिसका उपयोग Cloud Build के आउटपुट (.tar.gz प्रारूप में डिस्क इमेज) को संग्रहीत करने के लिए किया जाएगा।
#### AWS
यह इम्पोर्टर Amazon के स्वामित्व वाली AMIs को प्रोसेस करता है और हैश उत्पन्न करता है। इस इम्पोर्टर को कम से कम एक HashR वर्कर (एक EC2 इंस्टेंस) की आवश्यकता होती है।
##### AWS HashR वर्कर्स
AWS HashR वर्कर एक EC2 इंस्टेंस है जहाँ AMI का वॉल्यूम अटैच किया जाता है, डिस्क आर्काइव बनाया जाता है, और फिर S3 बकेट पर अपलोड किया जाता है। कम से कम दो AWS HashR वर्कर रखने की अनुशंसा की जाती है। यदि आपका सेटअप एकल AWS वर्कर का उपयोग करता है तो `-processing_worker_count 1` का उपयोग करें।
AWS HashR वर्कर को निम्नलिखित आवश्यकताओं को पूरा करना होगा:
- EC2 इंस्टेंस में `InUse: false` टैग होना चाहिए। यदि मान `true` है, तो वर्कर का उपयोग प्रोसेसिंग के लिए नहीं किया जाता है।```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Tags’
hashr चलाने वाला सिस्टम निम्नलिखित का उपयोग करके EC2 इंस्टेंस में SSH करने में सक्षम होना चाहिए:
Keyname में वर्णित SSH कुंजी। ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’PublicDnsName में वर्णित FQDN के लिए। ```shell
aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].PublicDnsName’
scripts/hashr-archive को AWS HashR worker के /usr/local/sbin/hashr-archive पर कॉपी किया जाना चाहिए
एक AWS खाता जिसके पास HashR बकेट में फ़ाइलें अपलोड करने की अनुमति हो। AWS कॉन्फ़िगरेशन और क्रेडेंशियल $HOME/.aws/ निर्देशिका में संग्रहीत किए जाने चाहिए।```shell
aws configure
##### HashR अनुप्रयोग
जिस सिस्टम पर `hashr` चलता है, उस पर निम्नलिखित आवश्यक है।
- निम्नलिखित APIs को कॉल करने की अनुमति वाला एक AWS खाता:
- EC2
- AttachVolume
- CopyImage
- CreateTags
- CreateVolume
- DeleteVolume
- DescribeAvailabilityZones
- DescribeImages
- DescribeInstances
- DescribeSnapshots
- DescribeVolumes
- DetachVolume
- S3
- DeleteObject
- AWS खाता कॉन्फ़िगरेशन और क्रेडेंशियल फ़ाइल `$HOME/.aws/` निर्देशिका में स्थित होनी चाहिए।
- AWS HashR के लिए उपयोग की जाने वाली SSH निजी कुंजी `$HOME/.ssh/` निर्देशिका में स्थित होनी चाहिए। इसे `Keyname` के मान से मेल खाना चाहिए जैसा कि `aws ec2 describe-instances --instance-id INSTANCE_ID | jq -r ‘.Reservations[].Instances[0].Keyname’` में वर्णित है।
##### AWS EC2 इंस्टेंस सेट अप करना
यह अनुभाग वर्णन करता है कि HashR के साथ उपयोग के लिए EC2 इंस्टेंस कैसे बनाएँ। आदर्श रूप से हमें दो AWS खाते चाहिए: `hashr.uploader` और `hashr.worker`।
`hashr.uploader` का उपयोग EC2 इंस्टेंस पर किया जाता है और उसे संग्रहीत डिस्क इमेज को S3 बकेट में अपलोड करने की अनुमति चाहिए। `scripts/aws/AwsHashrUploaderPolicy.json` में S3 बकेट `hashr-bucket` के लिए नमूना नीति है।
`hashr.worker` का उपयोग HashR कमांड चलाने वाले कंप्यूटर पर किया जाता है। इस खाते को EC2 और S3 अनुमतियों की आवश्यकता होती है। `scripts/aws/AwsHashrWorkerPolicy.json` में `hashr.worker` खाते के लिए नमूना नीति है।
`hashr_setup.sh` एक स्क्रिप्ट है जो EC2 इंस्टेंस बनाने में सहायता करती है। `hashr_setup.sh` को संपादित करें और आवश्यकतानुसार निम्नलिखित फ़ील्ड की समीक्षा करें और अपडेट करें:
- `AWS_PROFILE`
- `AWS_REGION`
- `SECURITY_SOURCE_CIDR`
- `WORKER_AWS_CONFIG_FILE`
**नोट**: `WORKER_AWS_CONFIG_FILE` में निर्दिष्ट फ़ाइल `hashr_setup.sh` के साथ वाली निर्देशिका में मौजूद होनी चाहिए।
**नोट**: `hashr_setup.sh` को उसी निर्देशिका से निष्पादित किया जाना चाहिए जिसमें `hashr_setup.sh` स्थित है।
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
AWS importer निम्नलिखित उच्च-स्तरीय चरणों का पालन करता है:
नीचे दिया गया कमांड debian-12 इमेज को प्रोसेस करता है और उन्हें PostgreSQL डेटाबेस में संग्रहीत करता है।```shell
hashr -storage postgres -exporters postgres -importers aws -aws_bucket aws-hashr-bucket -aws_os_filter debian-12
**नोट**: इम्पोर्टर को विकसित करते समय एक वर्कर के रूप में Amazon Linux (al2023-*) का उपयोग किया गया था। इसलिए, `-aws_ssh_user` के लिए डिफ़ॉल्ट मान `ec2-user` पर सेट है। एक अलग डिस्ट्रो का डिफ़ॉल्ट SSH उपयोगकर्ता अलग हो सकता है, उपयुक्त SSH उपयोगकर्ता सेट करने के लिए `-aws_ssh_user` का उपयोग करें।
#### GCR (Google Container Registry)
यह इम्पोर्टर GCR रिपॉज़िटरी में संग्रहीत कंटेनर इमेज से फ़ाइलें निकालता है। इसे सेट अप करने के लिए इन चरणों का पालन करें:
चरण 1: HashR सेवा खाता बनाएं, यदि यह अन्य GCP-निर्भर घटकों को सेट अप करते समय किया गया था तो चरण 4 पर जाएँ।``` shell
gcloud iam service-accounts create hashr-sa --description="HashR SA key." --display-name="hashr"
चरण 2: सेवा खाता कुंजी बनाएँ और इसे अपनी होम निर्देशिका में संग्रहीत करें। सुनिश्चित करें कि <project_name> को अपने प्रोजेक्ट नाम पर सेट करें:``` shell gcloud iam service-accounts keys create ~/hashr-sa-private-key.json --iam-account=hashr-sa@<project_name>.iam.gserviceaccount.com
चरण 3: GOOGLE_APPLICATION_CREDENTIALS env वेरिएबल को अपनी सेवा खाता कुंजी की ओर इंगित करें:``` shell
export GOOGLE_APPLICATION_CREDENTIALS=~/hashr-sa-private-key.json
चरण 4: दिए गए GCR रिपॉजिटरी तक पहुँचने के लिए hashR सेवा खाता कुंजी को आवश्यक अनुमतियाँ प्रदान करें।``` 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"
इस importer का उपयोग करने के लिए आपको निम्नलिखित flag(s) निर्दिष्ट करने होंगे:
1. `-gcr_repos` जिसमें GCR रिपॉजिटरी की comma separated सूची होनी चाहिए जिनसे आप कंटेनर इमेज आयात करना चाहते हैं।
#### Windows
यह importer आधिकारिक Windows इंस्टॉलेशन मीडिया से ISO-13346 प्रारूप में फ़ाइलें निकालता है, उदा. वे जिन्हें आप आधिकारिक Microsoft [website](https://www.microsoft.com/en-gb/software-download/windows10ISO) से डाउनलोड कर सकते हैं।
एक ISO फ़ाइल में कई WIM इमेज हो सकती हैं:
1. Windows10ProEducation
1. Windows10Education
1. Windows10EducationN
1. Windows10ProN
1. आदि।
यह importer `install.wim` फ़ाइल में मिलने वाली सभी इमेज से फ़ाइलें निकालेगा।
#### WSUS
यह importer Windows Update पैकेज की सामग्री को पुनरावर्ती रूप से निकालने के लिए 7z का उपयोग करता है। यह दिए गए GCS bucket में Windows Update फ़ाइलों की तलाश करेगा, GCS bucket को नए अपडेट के साथ स्वचालित रूप से अपडेट करने का सबसे आसान तरीका निम्नलिखित होगा:
1. hashr GCP प्रोजेक्ट में Windows Server चलाने वाला GCE VM सेट करें।
1. इसे WSUS भूमिका के साथ कॉन्फ़िगर करें, उन Windows Update पैकेजों का चयन करें जिन्हें आप प्रोसेस करना चाहते हैं
1. WSUS को स्थानीय स्टोरेज पर अपडेट स्वचालित रूप से अनुमोदित और डाउनलोड करने के लिए कॉन्फ़िगर करें
1. स्थानीय स्टोरेज की सामग्री को GCS bucket में स्वचालित रूप से सिंक करने के लिए एक Windows कार्य सेट करें: `gcloud storage rsync --recursive D:/WSUS/WsusContent gs://hashr-wsus/` (पथ समायोजित करना याद रखें)
1. यदि आप अपडेट पैकेज का फ़ाइलनाम (जिसमें आमतौर पर KB नंबर होता है) ID के रूप में रखना चाहते हैं (डिफ़ॉल्ट रूप से यह sha1 है, MS WSUS अपडेट को ऐसे ही संग्रहीत करता है) और इसका विवरण, तो यह आंतरिक WID WSUS डेटाबेस से डंप किया जा सकता है। आप निम्नलिखित Power Shell स्क्रिप्ट का उपयोग कर सकते हैं और इसे एक कार्य के रूप में चला सकते हैं:```
#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 will dump the relevant information from WSUS DB, store it in the export.csv file and sync the contents of the WSUS folder with GCS bucket. WSUS importer will check if export.csv file is present in the root of the WSUS repo, if so it will use it.
This is a simple importer that traverses repositories and looks for .tar.gz files. Once found it will hash the first and the last 10MB of the file to check if it was already processed. This is done to prevent hashing the whole file every time the repository is scanned for new sources. To use this importer you need to specify the following flag(s):
-targz_repo_path which should point to the path on the local file system that contains .tar.gz filesThis is very similar to the TarGz importer except that it looks for .deb packages. Once found it will hash the first and the last 10MB of the file to check if it was already processed. This is done to prevent hashing the whole file every time the repository is scanned for new sources. To use this importer you need to specify the following flag(s):
-deb_repo_path which should point to the path on the local file system that contains .deb filesThis is very similar to the TarGz importer except that it looks for .rpm packages. Once found it will hash the first and the last 10MB of the file to check if it was already processed. This is done to prevent hashing the whole file every time the repository is scanned for new sources. To use this importer you need to specify the following flag(s):
-rpm_repo_path which should point to the path on the local file system that contains .rpm filesThis is very similar to the TarGz importer except that it looks for .zip archives. Once found it will hash the first and the last 10MB of the file to check if it was already processed. This is done to prevent hashing the whole file every time the repository is scanned for new sources. To use this importer you need to specify the following flag(s):
-zip_repo_path which should point to the path on the local file system that contains .zip filesOptionally, you can also set the following flag(s):
-zip_file_exts comma-separated list of file extensions to treat as zip files, eg. "zip,whl,jar". Default: "zip"This is very similar to the TarGz importer except that it looks for .iso file. Once found it will hash the first and the last 10MB of the file to check if it was already processed. This is done to prevent hashing the whole file every time the repository is scanned for new sources. To use this importer you need to specify the following flag(s):
-iso_repo_path which should point to the path on the local file system that contains .iso filesPostgres exporter allows sending of hashes, file metadata and the actual content of the file to a PostgreSQL instance. For best performance it's advised to set it up on a separate and dedicated machine. If you did set up PostgreSQL while choosing the processing jobs storage you're almost good to go, just run the following command to create the required tables:``` shell cat scripts/CreatePostgresExporterTables.sql | docker exec -i hashr_postgresql psql -U hashr -d hashr
यदि आपने प्रोसेसिंग जॉब स्टोरेज के लिए Postgres नहीं चुना है, तो [PostgreSQL स्टोरेज सेट करना](####setting-up-postgresql-storage) अनुभाग के चरण 1 और 2 का पालन करें।
यह वर्तमान में डिफ़ॉल्ट एक्सपोर्टर है, आपको इसे स्पष्ट रूप से सक्षम करने की आवश्यकता नहीं है। डिफ़ॉल्ट रूप से, वास्तविक फ़ाइलों की सामग्री PostgreSQL DB पर अपलोड नहीं की जाएगी, यदि आप इसे बदलना चाहते हैं तो `-upload_payloads true` फ़्लैग का उपयोग करें।
Postgres एक्सपोर्टर को काम करने के लिए आपको निम्नलिखित फ़्लैग्स सेट करने होंगे: `-exporters postgres -postgresHost <host> -postgresPort <port> -postgresUser <user> -postgresPassword <pass> -postgresDBName <db_name>`
#### GCP एक्सपोर्टर सेट करना
GCP एक्सपोर्टर हैश, फ़ाइल मेटाडेटा को GCP Spanner इंस्टेंस में भेजने की अनुमति देता है। वैकल्पिक रूप से आप निकाली गई फ़ाइलों को GCS बकेट में अपलोड कर सकते हैं। यदि आपने प्रोसेसिंग जॉब्स को संग्रहीत करने के लिए Cloud Spanner सेट नहीं किया है, तो [Cloud Spanner सेट करना](####setting-up-cloud-spanner) में दिए गए चरणों का पालन करें और अंतिम चरण के बजाय आवश्यक टेबल बनाने के लिए निम्न कमांड चलाएं:``` shell
gcloud spanner databases ddl update hashr --instance=hashr --ddl-file=scripts/CreateCloudSpannerExporterTables.ddl
यदि आपने पहले से ही जॉब डेटा संग्रहीत करने के लिए Cloud Spanner सेट अप कर लिया है, तो आपको बस उपरोक्त कमांड चलाने की आवश्यकता है और आप शुरू करने के लिए तैयार हैं।
यदि आप निकाले गए फ़ाइलों को GCS पर अपलोड करना चाहते हैं, तो आपको GCS बकेट बनाने की आवश्यकता है:
चरण 1: इस बकेट का सेवा खाता व्यवस्थापक बनाएं:``` shell gcloud storage buckets create gs://<gcs_bucket_name> --project=project_name>
चरण 2: सेवा खाते को इस बकेट का व्यवस्थापक बनाएँ:``` 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"
इस एक्सपोर्टर का उपयोग करने के लिए आपको निम्नलिखित फ्लैग प्रदान करने होंगे: -exporters GCP -gcp_exporter_gcs_bucket <gcs_bucket_name>
-processing_worker_count: यह फ्लैग समानांतर प्रोसेसिंग वर्कर्स की संख्या को नियंत्रित करता है। प्रोसेसिंग CPU और I/O भारी है, अपने परीक्षण के दौरान मैंने पाया कि 2 वर्कर्स होना सबसे अनुकूल समाधान है।-cache_dir: डीडुप्लिकेशन के लिए उपयोग किए जाने वाले स्थानीय कैश का स्थान, इसे /tmp से बदलकर, उदाहरण के लिए, hashr चलाने वाले उपयोगकर्ता की होम निर्देशिका में करने की सलाह दी जाती है।-export: जब इसे false पर सेट किया जाता है, hashr एक्सपोर्टर को बायपास करते हुए परिणामों को डिस्क पर सहेज लेगा।-export_path: यदि export को false पर सेट किया गया है, तो यह वह फ़ोल्डर है जहाँ सैंपल सहेजे जाएँगे।-reprocess: jobs तालिका में संग्रहीत sha256 मान के आधार पर किसी दिए गए स्रोत को फिर से प्रोसेस करने की अनुमति देता है (उदाहरण के लिए यदि उसमें त्रुटि हुई हो)।-upload_payloads: नियंत्रित करता है कि परिभाषित एक्सपोर्टर द्वारा फ़ाइल की वास्तविक सामग्री अपलोड की जाएगी या नहीं।-gcp_exporter_worker_count: GCP एक्सपोर्टर द्वारा डेटा अपलोड करने के लिए उपयोग किए जाने वाले वर्कर्स/गोरूटीन की संख्या।यह आधिकारिक रूप से समर्थित Google उत्पाद नहीं है।