Mengumpulkan log SpyCloud

Didukung di:

Google SecOps SIEM

Dokumen ini menjelaskan cara menyerap log SpyCloud ke Google Security Operations menggunakan Google Cloud Storage V2.

SpyCloud adalah platform pencegahan pengambilalihan akun yang menyediakan intelijen kredensial curian dan pelanggaran. API ini mengirimkan catatan pelanggaran, pemberitahuan daftar pantauan, dan laporan kredensial yang disusupi melalui REST API.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

• Instance Google SecOps
• Project GCP dengan Cloud Storage API diaktifkan
• Izin untuk membuat dan mengelola bucket GCS
• Izin untuk mengelola kebijakan IAM di bucket GCS
• Izin untuk membuat layanan Cloud Run, topik Pub/Sub, dan tugas Cloud Scheduler
• Akun SpyCloud dengan akses API dan kunci API yang valid

Membuat bucket Google Cloud Storage

1. Buka Konsol Google Cloud.
2. Pilih project Anda atau buat project baru.
3. Di menu navigasi, buka Cloud Storage > Buckets.
4. Klik Create bucket.

5. Berikan detail konfigurasi berikut:

   Setelan	Nilai
   Beri nama bucket Anda	Masukkan nama yang unik secara global (misalnya, spycloud-logs)
   Location type	Pilih berdasarkan kebutuhan Anda (Region, Dual-region, Multi-region)
   Location	Pilih lokasi (misalnya, us-central1)
   Kelas penyimpanan	Standar (direkomendasikan untuk log yang sering diakses)
   Access control	Seragam (direkomendasikan)
   Alat perlindungan	Opsional: Aktifkan pembuatan versi objek atau kebijakan retensi

6. Klik Create.

Kumpulkan kredensial SpyCloud API

Mendapatkan kunci API

1. Login ke portal SpyCloud sebagai administrator.
2. Buka Setelan > API.
3. Salin dan simpan kunci API di lokasi yang aman.

Verifikasi izin

Untuk memverifikasi bahwa kunci API Anda memiliki akses yang diperlukan:

1. Login ke portal SpyCloud.
2. Buka Setelan > API.
3. Verifikasi bahwa kunci API aktif dan memiliki akses ke endpoint yang diperlukan (data pelanggaran, daftar pantauan, kompas).
4. Jika akses dibatasi, hubungi administrator SpyCloud Anda.

Menguji akses API

• Uji kredensial Anda sebelum melanjutkan integrasi:

  # Replace with your actual API key
  API_KEY="your-api-key"
  
  # Test API access - fetch watchlist data
  curl -v -H "X-API-Key: ${API_KEY}" \
    "https://api.spycloud.io/enterprise-v2/breach/data/watchlist?since=2024-01-01&until=2024-01-02"
  

Buat akun layanan untuk Cloud Run Function

Fungsi Cloud Run memerlukan akun layanan dengan izin untuk menulis ke bucket GCS dan dipanggil oleh Pub/Sub.

Membuat akun layanan

1. Di GCP Console, buka IAM & Admin > Service Accounts.
2. Klik Create Service Account.
3. Berikan detail konfigurasi berikut:
   • Nama akun layanan: Masukkan spycloud-collector-sa.
   • Deskripsi akun layanan: Masukkan Service account for Cloud Run function to collect SpyCloud logs.
4. Klik Create and Continue.
5. Di bagian Berikan akun layanan ini akses ke project, tambahkan peran berikut:
   1. Klik Pilih peran.
   2. Telusuri dan pilih Storage Object Admin.
   3. Klik + Add another role.
   4. Telusuri dan pilih Cloud Run Invoker.
   5. Klik + Add another role.
   6. Telusuri dan pilih Cloud Functions Invoker.
6. Klik Lanjutkan.
7. Klik Done.

Peran ini diperlukan untuk:

• Storage Object Admin: Menulis log ke bucket GCS dan mengelola file status
• Cloud Run Invoker: Mengizinkan Pub/Sub memanggil fungsi
• Cloud Functions Invoker: Mengizinkan pemanggilan fungsi

Memberikan izin IAM pada bucket GCS

Beri akun layanan izin tulis di bucket GCS:

1. Buka Cloud Storage > Buckets.
2. Klik nama bucket Anda (misalnya, spycloud-logs).
3. Buka tab Izin.
4. Klik Grant access.
5. Berikan detail konfigurasi berikut:
   • Tambahkan prinsipal: Masukkan email akun layanan (misalnya, [e-mail]).
   • Tetapkan peran: Pilih Storage Object Admin.
6. Klik Simpan.

Membuat topik Pub/Sub

Buat topik Pub/Sub yang akan dipublikasikan oleh Cloud Scheduler dan akan dilanggan oleh fungsi Cloud Run.

1. Di Konsol GCP, buka Pub/Sub > Topics.
2. Klik Create topic.
3. Berikan detail konfigurasi berikut:
   • ID Topik: Masukkan spycloud-trigger.
   • Biarkan setelan lainnya tetap default.
4. Klik Create.

Membuat fungsi Cloud Run untuk mengumpulkan log

Fungsi Cloud Run akan dipicu oleh pesan Pub/Sub dari Cloud Scheduler untuk mengambil log dari SpyCloud API dan menuliskannya ke GCS.

1. Di Konsol GCP, buka Cloud Run.
2. Klik Create service.
3. Pilih Function (gunakan editor inline untuk membuat fungsi).

4. Di bagian Konfigurasi, berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama layanan	spycloud-collector
   Region	Pilih region yang cocok dengan bucket GCS Anda (misalnya, us-central1)
   Runtime	Pilih Python 3.12 atau yang lebih baru

5. Di bagian Pemicu (opsional):

   1. Klik + Tambahkan pemicu.
   2. Pilih Cloud Pub/Sub.
   3. Di Select a Cloud Pub/Sub topic, pilih topik spycloud-trigger.
   4. Klik Simpan.

6. Di bagian Authentication:

   1. Pilih Wajibkan autentikasi.
   2. Periksa Identity and Access Management (IAM).
   Catatan: Pub/Sub akan otomatis menangani autentikasi saat memanggil fungsi.

7. Scroll ke bawah dan luaskan Containers, Networking, Security.

8. Buka tab Security:

   • Akun layanan: Pilih akun layanan spycloud-collector-sa.

9. Buka tab Containers:

   1. Klik Variables & Secrets.
   2. Klik + Tambahkan variabel untuk setiap variabel lingkungan:

   Nama Variabel	Nilai Contoh	Deskripsi
   GCS_BUCKET	spycloud-logs	Nama bucket GCS
   GCS_PREFIX	spycloud	Awalan untuk file log
   STATE_KEY	spycloud/state.json	Jalur file status
   API_KEY	your-api-key	Kunci API SpyCloud
   API_BASE	https://api.spycloud.io	URL dasar API
   MAX_RECORDS	10000	Jumlah maksimum data per proses
   LOOKBACK_DAYS	7	Periode lihat balik awal dalam hari
   STREAMS	watchlist,catalog	Aliran data yang dipisahkan koma

10. Scroll ke bawah di tab Variables & Secrets ke Requests:

    • Waktu tunggu permintaan: Masukkan 600 detik (10 menit).

11. Buka tab Setelan di Kontainer:

    • Di bagian Materi:
      • Memori: Pilih 512 MiB atau yang lebih tinggi.
      • CPU: Pilih 1.

12. Di bagian Penskalaan revisi:

    • Minimum number of instances: Masukkan 0.
    • Jumlah maksimum instance: Masukkan 100 (atau sesuaikan berdasarkan perkiraan beban).

13. Klik Create.

14. Tunggu hingga layanan dibuat (1-2 menit).

15. Setelah layanan dibuat, editor kode inline akan terbuka secara otomatis.

Menambahkan kode fungsi

1. Masukkan main di Function entry point.

2. Di editor kode inline, buat dua file:

   • File pertama: main.py:

     import functions_framework
     from google.cloud import storage
     import json
     import os
     import urllib3
     from datetime import datetime, timezone, timedelta
     import time
     
     # Initialize HTTP client with timeouts
     http = urllib3.PoolManager(
       timeout=urllib3.Timeout(connect=5.0, read=30.0),
       retries=False,
     )
     
     # Initialize Storage client
     storage_client = storage.Client()
     
     # Environment variables
     GCS_BUCKET = os.environ.get('GCS_BUCKET')
     GCS_PREFIX = os.environ.get('GCS_PREFIX', 'spycloud')
     STATE_KEY = os.environ.get('STATE_KEY', 'spycloud/state.json')
     API_KEY = os.environ.get('API_KEY', '')
     API_BASE = os.environ.get('API_BASE', 'https://api.spycloud.io').rstrip('/')
     MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
     LOOKBACK_DAYS = int(os.environ.get('LOOKBACK_DAYS', '7'))
     STREAMS = [s.strip() for s in os.environ.get('STREAMS', 'watchlist').split(',') if s.strip()]
     
     def parse_datetime(value: str) -> datetime:
       """Parse ISO datetime string to datetime object."""
       if value.endswith("Z"):
         value = value[:-1] + "+00:00"
       return datetime.fromisoformat(value)
     
     @functions_framework.cloud_event
     def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch SpyCloud logs and write to GCS.
     
       Args:
         cloud_event: CloudEvent object containing Pub/Sub message
       """
     
       if not all([GCS_BUCKET, API_KEY]):
         print('Error: Missing required environment variables')
         return
     
       try:
         bucket = storage_client.bucket(GCS_BUCKET)
     
         # Load state
         state = load_state(bucket, STATE_KEY)
     
         now = datetime.now(timezone.utc)
     
         # Determine date range
         if isinstance(state, dict) and state.get("last_date"):
           since_date = state["last_date"]
         else:
           since_date = (now - timedelta(days=LOOKBACK_DAYS)).strftime('%Y-%m-%d')
     
         until_date = now.strftime('%Y-%m-%d')
     
         print(f"Fetching data from {since_date} to {until_date}")
     
         report = {}
     
         if 'watchlist' in STREAMS:
           print("Fetching watchlist breach data...")
           count = pull_watchlist(bucket, since_date, until_date)
           report['watchlist_records'] = count
     
         if 'catalog' in STREAMS:
           print("Fetching breach catalog...")
           count = pull_catalog(bucket, since_date, until_date)
           report['catalog_records'] = count
     
         if 'compass' in STREAMS:
           print("Fetching compass data...")
           count = pull_compass(bucket, since_date, until_date)
           report['compass_records'] = count
     
         # Update state
         save_state(bucket, STATE_KEY, until_date)
         print(f"Successfully processed: {json.dumps(report)}")
     
       except Exception as e:
         print(f'Error processing logs: {str(e)}')
         raise
     
     def load_state(bucket, key):
       """Load state from GCS."""
       try:
         blob = bucket.blob(key)
         if blob.exists():
           state_data = blob.download_as_text()
           return json.loads(state_data)
       except Exception as e:
         print(f"Warning: Could not load state: {e}")
     
       return {}
     
     def save_state(bucket, key, last_date: str):
       """Save the last query date to GCS state file."""
       try:
         state = {'last_date': last_date, 'last_event_time': datetime.now(timezone.utc).isoformat()}
         blob = bucket.blob(key)
         blob.upload_from_string(
           json.dumps(state, indent=2),
           content_type='application/json'
         )
         print(f"Saved state: last_date={last_date}")
       except Exception as e:
         print(f"Warning: Could not save state: {e}")
     
     def api_get(endpoint: str, params: dict = None):
       """Make authenticated GET request to SpyCloud API with rate limiting."""
       url = f"{API_BASE}{endpoint}"
       if params:
         query = '&'.join([f"{k}={v}" for k, v in params.items()])
         url = f"{url}?{query}"
     
       headers = {
         'X-API-Key': API_KEY,
         'Accept': 'application/json',
         'User-Agent': 'GoogleSecOps-SpyCloudCollector/1.0'
       }
     
       backoff = 1.0
       max_retries = 3
     
       for attempt in range(max_retries):
         response = http.request('GET', url, headers=headers)
     
         if response.status == 429:
           retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
           print(f"Rate limited (429). Retrying after {retry_after}s...")
           time.sleep(retry_after)
           backoff = min(backoff * 2, 30.0)
           continue
     
         if response.status != 200:
           print(f"HTTP Error: {response.status} - {response.data.decode('utf-8')}")
           return None
     
         return json.loads(response.data.decode('utf-8'))
     
       print(f"Failed after {max_retries} retries due to rate limiting")
       return None
     
     def write_ndjson(bucket, prefix: str, stream_name: str, records: list):
       """Write records to GCS as NDJSON."""
       if not records:
         return 0
     
       now = datetime.now(timezone.utc)
       timestamp = now.strftime('%Y%m%d_%H%M%S')
       object_key = f"{GCS_PREFIX}/{stream_name}/logs_{timestamp}.ndjson"
       blob = bucket.blob(object_key)
     
       ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in records]) + '\n'
       blob.upload_from_string(ndjson, content_type='application/x-ndjson')
     
       print(f"Wrote {len(records)} records to gs://{GCS_BUCKET}/{object_key}")
       return len(records)
     
     def pull_watchlist(bucket, since_date: str, until_date: str):
       """Fetch watchlist breach data."""
       cursor = None
       all_records = []
     
       while True:
         params = {'since': since_date, 'until': until_date}
         if cursor:
           params['cursor'] = cursor
     
         data = api_get('/enterprise-v2/breach/data/watchlist', params)
         if not data:
           break
     
         results = data.get('results', [])
         if not results:
           break
     
         all_records.extend(results)
     
         if len(all_records) >= MAX_RECORDS:
           print(f"Reached max_records limit ({MAX_RECORDS})")
           break
     
         cursor = data.get('cursor')
         if not cursor:
           break
     
       return write_ndjson(bucket, GCS_PREFIX, 'watchlist', all_records)
     
     def pull_catalog(bucket, since_date: str, until_date: str):
       """Fetch breach catalog."""
       params = {'since': since_date, 'until': until_date}
       data = api_get('/enterprise-v2/breach/catalog', params)
       if not data:
         return 0
     
       results = data.get('results', [])
       return write_ndjson(bucket, GCS_PREFIX, 'catalog', results)
     
     def pull_compass(bucket, since_date: str, until_date: str):
       """Fetch compass findings."""
       cursor = None
       all_records = []
     
       while True:
         params = {'since': since_date, 'until': until_date}
         if cursor:
           params['cursor'] = cursor
     
         data = api_get('/enterprise-v2/compass/data', params)
         if not data:
           break
     
         results = data.get('results', [])
         if not results:
           break
     
         all_records.extend(results)
     
         if len(all_records) >= MAX_RECORDS:
           print(f"Reached max_records limit ({MAX_RECORDS})")
           break
     
         cursor = data.get('cursor')
         if not cursor:
           break
     
       return write_ndjson(bucket, GCS_PREFIX, 'compass', all_records)
     

   • File kedua: requirements.txt:

     functions-framework==3.*
     google-cloud-storage==2.*
     urllib3>=2.0.0
     

3. Klik Deploy untuk menyimpan dan men-deploy fungsi.

4. Tunggu hingga deployment selesai (2-3 menit).

   Catatan: Konfigurasi pemicu Pub/Sub akan otomatis membuat langganan dan izin yang diperlukan.

Buat tugas Cloud Scheduler

Cloud Scheduler akan memublikasikan pesan ke topik Pub/Sub secara berkala, sehingga memicu fungsi Cloud Run.

1. Di GCP Console, buka Cloud Scheduler.
2. Klik Create Job.

3. Berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama	spycloud-collector-daily
   Region	Pilih region yang sama dengan fungsi Cloud Run
   Frekuensi	0 0 * * * (harian pada tengah malam)
   Zona Waktu	Pilih zona waktu (UTC direkomendasikan)
   Jenis target	Pub/Sub
   Topik	Pilih topik spycloud-trigger
   Isi pesan	{} (objek JSON kosong)

4. Klik Create.

Opsi frekuensi jadwal

Pilih frekuensi berdasarkan volume log dan persyaratan latensi:

Frekuensi	Ekspresi Cron	Kasus Penggunaan
Setiap 5 menit	*/5 * * * *	Volume tinggi, latensi rendah
Setiap 15 menit	*/15 * * * *	Volume sedang
Setiap jam	0 * * * *	Standar
Setiap 6 jam	0 */6 * * *	Volume rendah, pemrosesan batch
Harian	0 0 * * *	Pengumpulan data historis (direkomendasikan untuk data pelanggaran)

Menguji integrasi

1. Di konsol Cloud Scheduler, temukan tugas Anda (spycloud-collector-daily).
2. Klik Jalankan paksa untuk memicu secara manual.
3. Tunggu beberapa detik, lalu buka Cloud Run > Services > spycloud-collector > Logs.

4. Pastikan fungsi berhasil dieksekusi. Cari:

   Fetching data from YYYY-MM-DD to YYYY-MM-DD
   Fetching watchlist breach data...
   Wrote X records to gs://spycloud-logs/spycloud/watchlist/logs_YYYYMMDD_HHMMSS.ndjson
   Successfully processed: {"watchlist_records": X, "catalog_records": Y}
   

5. Periksa bucket GCS (spycloud-logs) untuk mengonfirmasi bahwa log telah ditulis.

Jika Anda melihat error dalam log:

• HTTP 401: Periksa kunci API di variabel lingkungan
• HTTP 403: Pastikan kunci API memiliki akses ke endpoint yang diperlukan
• HTTP 429: Pembatasan kecepatan - fungsi akan otomatis mencoba lagi dengan penundaan
• Variabel lingkungan tidak ada: Pastikan semua variabel yang diperlukan telah ditetapkan

Mengonfigurasi feed di Google SecOps untuk menyerap log SpyCloud

1. Buka Setelan SIEM > Feed.
2. Klik Tambahkan Feed Baru.
3. Klik Konfigurasi satu feed.
4. Di kolom Nama feed, masukkan nama untuk feed (misalnya, SpyCloud Logs).
5. Pilih Google Cloud Storage V2 sebagai Source type.
6. Pilih SpyCloud sebagai Jenis log.

7. Klik Get Service Account. Email akun layanan yang unik akan ditampilkan, misalnya:

   [e-mail]
   

8. Salin alamat email ini. Anda akan menggunakannya pada langkah berikutnya.

   Catatan: Setiap instance Google SecOps memiliki akun layanan yang unik. Jangan gunakan akun layanan dari dokumentasi atau contoh lain.

9. Klik Berikutnya.

10. Tentukan nilai untuk parameter input berikut:

    • URL bucket penyimpanan: Masukkan URI bucket GCS dengan jalur awalan:

      gs://spycloud-logs/spycloud/
      

      • Ganti:
        • spycloud-logs: Nama bucket GCS Anda.
        • spycloud: Awalan/jalur folder opsional tempat log disimpan (biarkan kosong untuk root).
    Catatan: Selalu sertakan garis miring (/) di akhir URI.

    • Opsi penghapusan sumber: Pilih opsi penghapusan sesuai preferensi Anda:

      • Jangan pernah: Tidak pernah menghapus file apa pun setelah transfer (direkomendasikan untuk pengujian).
      • Hapus file yang ditransfer: Menghapus file setelah transfer berhasil.

      • Hapus file yang ditransfer dan direktori kosong: Menghapus file dan direktori kosong setelah transfer berhasil.

        Catatan: Jika Anda memilih opsi penghapusan, akun layanan harus memiliki peran Storage Object Admin, bukan Storage Object Viewer. Perbarui izin IAM yang sesuai.

    • Usia File Maksimum: Sertakan file yang dimodifikasi dalam beberapa hari terakhir (defaultnya adalah 180 hari).

    • Namespace aset: Namespace aset.

    • Label penyerapan: Label yang akan diterapkan ke peristiwa dari feed ini.

11. Klik Berikutnya.

12. Tinjau konfigurasi feed baru Anda di layar Selesaikan, lalu klik Kirim.

Memberikan izin IAM ke akun layanan Google SecOps

Akun layanan Google SecOps memerlukan peran Storage Object Viewer di bucket GCS Anda.

1. Buka Cloud Storage > Buckets.
2. Klik nama bucket Anda (spycloud-logs).
3. Buka tab Izin.
4. Klik Grant access.
5. Berikan detail konfigurasi berikut:
   • Add principals: Tempel email akun layanan Google SecOps.
   • Tetapkan peran: Pilih Storage Object Viewer.

6. Klik Simpan.

   Catatan: Jika Anda berencana menggunakan opsi penghapusan "Hapus file yang ditransfer" atau "Hapus file yang ditransfer dan direktori kosong", berikan peran Storage Object Admin, bukan Storage Object Viewer.

Tabel pemetaan UDM

Kolom Log	Pemetaan UDM	Logika
av_softwares, assets.av_softwares, assets.country, assets.country_code, assets.display_resolution, assets.email, assets.full_name, assets.infected_machine_id, assets.infected_path, assets.infected_time, assets.ip_addresses, assets.keyboard_languages, assets.password, assets.target_url, assets.username, assets.user_browser, assets.user_hostname, assets.user_os, assets.user_sys_registered_owner	additional.fields	Digabungkan dari label yang dibuat dari kolom ini dan av_software_list
sandi	extensions.auth.auth_details	Nilai disalin secara langsung
kapan	metadata.event_timestamp	Diuraikan sebagai stempel waktu ISO8601
	metadata.event_type	Ditetapkan berdasarkan kondisi: NETWORK_CONNECTION jika has_principal, has_target, has_network; USER_UNCATEGORIZED jika has_principal dan has_principal_userid; STATUS_UPDATE jika has_principal dan bukan has_principal_ip; atau GENERIC_EVENT; atau USER_UNCATEGORIZED jika user_hostname, ip, atau infected_machine_id ada
infected_time	metadata.ingested_timestamp	Diuraikan sebagai stempel waktu dengan format yyyy-MM-ddTHH:mm:ssZ, RFC 3339, ISO8601
log_id, assets.log_id, uuid	metadata.product_log_id	Nilai dari log_id jika tidak kosong, jika tidak, assets.log_id, jika tidak, uuid
user_os	network.http.parsed_user_agent	Dikonversi menjadi agen pengguna yang diuraikan
user_os	network.http.user_agent	Nilai disalin secara langsung
cookie_domain	principal.administrative_domain	Nilai disalin secara langsung
country	principal.asset.location.country_or_region	Nilai disalin secara langsung
infected_machine_id	principal.asset_id	Digabungkan sebagai "id: " + infected_machine_id
infected_path	principal.file.full_path	Nilai disalin secara langsung
user_hostname, domain	principal.hostname	Disetel ke user_hostname jika tidak kosong, lalu ke domain jika tidak kosong
ip, ip_addresses	principal.ip	Digabungkan dari array ip dan ip_addresses
country_code	principal.resource.attribute.labels	Digabungkan dari country_code_label yang dibuat dari country_code
id	principal.resource.id	Nilai disalin secara langsung (dikonversi menjadi string)
beranda	principal.url	Nilai disalin secara langsung
email	principal.user.email_addresses	Nilai disalin secara langsung
full_name	principal.user.user_display_name	Nilai disalin secara langsung
user_sys_registered_owner, email_username	principal.user.userid	Disetel ke user_sys_registered_owner, lalu ke email_username jika tidak kosong
keyakinan	security_result.confidence_details	Dikonversi ke string
deskripsi	security_result.description	Nilai disalin secara langsung
cookie_expiration, cookie_name, cookie_subdomain, cookie_value, day, document_id, locality_zone, source_id, spycloud_publishdate, spycloud_publish_date, user_browser, infected_time, timezone, password_type, password_plaintext, email_domain, api_token, account_status, breach_category, breach_main_category, consumer_category, malware_family, num_records, premium_flag, sensitive_source, short_title, site_description, title, tlp, type, display_resolution, keyboard_languages	security_result.detection_fields	Digabungkan dari label yang dibuat dari kolom ini
tingkat keseriusan,	security_result.severity	Disetel ke RENDAH jika "2", INFORMASI jika "5", TINGGI jika "20", KRITIS jika "25" atau "26"
tingkat keseriusan,	security_result.severity_details	Nilai disalin secara langsung
target_subdomain	target.administrative_domain	Nilai disalin secara langsung
target_domain	target.asset.hostname	Nilai disalin secara langsung
target_domain	target.hostname	Nilai disalin secara langsung
target_url	target.url	Nilai disalin secara langsung
nama pengguna	target.user.userid	Nilai disalin secara langsung
	metadata.product_name	Ditetapkan ke "SPYCLOUD"
	metadata.vendor_name	Ditetapkan ke "SpyCloud"
spycloud_publish_date", "infected_time", and "timezone	security_result.detection_fields	Dipetakan dari log perubahan

Log Perubahan

Melihat Log Perubahan untuk parser ini

Perlu bantuan lain? Dapatkan jawaban dari anggota Komunitas dan profesional Google SecOps.