Mengumpulkan log Digital Guardian EDR

Didukung di:

Google SecOps SIEM

Dokumen ini menjelaskan cara menyerap log Digital Guardian EDR ke Google Security Operations menggunakan Google Cloud Storage V2 melalui fungsi Cloud Run.

Digital Guardian dari Fortra (sebelumnya Digital Guardian) adalah platform pencegahan kehilangan data dan deteksi serta respons endpoint yang komprehensif yang memberikan visibilitas ke dalam peristiwa sistem, pengguna, dan data di seluruh endpoint, jaringan, dan aplikasi cloud. Layanan Analytics & Reporting Cloud (ARC) memberikan kemampuan analisis, alur kerja, dan pelaporan tingkat lanjut untuk perlindungan data yang holistik. Fungsi Cloud Run melakukan autentikasi ke ARC Export API menggunakan OAuth 2.0, mengambil data ekspor, mengonfirmasi penanda untuk melanjutkan ke bagian berikutnya, menulis hasilnya sebagai NDJSON ke bucket GCS, dan Google SecOps menyerapnya melalui feed GCS V2.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

Instance Google SecOps
Project Google Cloud dengan API berikut diaktifkan:
- Cloud Storage
- Cloud Run Functions
- Cloud Scheduler
- Pub/Sub
- Cloud Build
Izin untuk membuat dan mengelola bucket Cloud Storage, fungsi Cloud Run, topik Pub/Sub, dan tugas Cloud Scheduler
Akses istimewa ke Konsol Pengelolaan Digital Guardian (DGMC)
Akses ke Setelan Tenant Digital Guardian Analytics & Reporting Cloud (ARC)
Izin administrator untuk mengonfigurasi Cloud Services di DGMC
Profil Ekspor yang dibuat di DGMC dengan GUID yang valid

Membuat bucket Google Cloud Storage

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

Berikan detail konfigurasi berikut:

Setelan	Nilai
Beri nama bucket Anda	Masukkan nama yang unik secara global (misalnya, `digitalguardian-edr-logs`)
Location type	Pilih berdasarkan kebutuhan Anda (Region, Dual-region, Multi-region)
Location	Pilih lokasi yang paling dekat dengan instance Google SecOps Anda (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

Klik Create.

Catatan: Catat nama bucket. Anda akan menggunakannya saat mengonfigurasi fungsi Cloud Run dan feed Google SecOps.

Mengumpulkan kredensial Digital Guardian API

Untuk mengaktifkan fungsi Cloud Run agar dapat mengambil data ekspor dari Digital Guardian ARC, Anda harus mendapatkan kredensial API dan mengonfigurasi profil ekspor.

Catatan: Digital Guardian ARC menggunakan jenis pemberian kredensial klien OAuth 2.0 dengan cakupan client. ID Akses API dan Secret Akses API memberikan izin yang diperlukan untuk mengakses profil ekspor.

Mendapatkan kredensial API dari DGMC

Login ke Digital Guardian Management Console (DGMC).
Buka System > Configuration > Cloud Services.
Di bagian API Access, temukan dan catat nilai berikut:
- ID Akses API: Ini adalah ID Klien Anda untuk autentikasi OAuth 2.0.
- Rahasia Akses API: Ini adalah Rahasia Klien Anda untuk autentikasi OAuth 2.0.
- URL Dasar Gateway Akses: Endpoint gateway API (misalnya, https://accessgw-usw.msp.digitalguardian.com).
- URL Server Otorisasi: Endpoint token OAuth 2.0 (misalnya, https://authsrv.msp.digitalguardian.com/as/token.oauth2).
Penting: Segera salin dan simpan Secret Akses API. Data mungkin tidak dapat diambil setelah keluar dari halaman ini.

Membuat dan mengonfigurasi profil ekspor

Di Konsol Pengelolaan Digital Guardian (DGMC), buka Admin > Laporan > Ekspor Profil.
Klik Buat Profil Ekspor atau pilih profil ekspor yang sudah ada.
Konfigurasi profil ekspor dengan setelan berikut:
- Nama Profil: Masukkan nama deskriptif (misalnya, Google SecOps SIEM Integration).
- Sumber Data: Pilih Peristiwa atau Pemberitahuan, bergantung pada data yang ingin Anda ekspor.
- Format Ekspor: Pilih JSON Flattened Table (direkomendasikan untuk integrasi SIEM).
- Kolom: Pilih kolom yang ingin Anda sertakan dalam ekspor.
- Filter: Konfigurasi filter apa pun untuk membatasi data yang diekspor (opsional).
Klik Simpan untuk membuat profil ekspor.
Setelah menyimpan, temukan profil ekspor dalam daftar dan salin GUID dari URL profil ekspor atau halaman detail.

Penting: Salin hanya bagian GUID dari ID profil ekspor. GUID adalah ID unik dalam format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

Ringkasan kredensial catatan

Simpan informasi berikut untuk mengonfigurasi variabel lingkungan fungsi Cloud Run:

ID Klien (ID Akses API): Dari DGMC Cloud Services
Rahasia Klien (Rahasia Akses API): Dari DGMC Cloud Services
URL Server Otorisasi: Misalnya, https://authsrv.msp.digitalguardian.com/as/token.oauth2
URL Dasar Access Gateway: Misalnya, https://accessgw-usw.msp.digitalguardian.com
Export Profile GUID: Dari profil ekspor yang dibuat di DGMC

Menguji akses API

Verifikasi bahwa kredensial Anda valid dengan menjalankan perintah berikut:

# Step 1: Obtain OAuth 2.0 access token
curl -s -X POST \
  -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&scope=client" \
  "https://authsrv.msp.digitalguardian.com/as/token.oauth2"

# Step 2: Test export endpoint with the access token
curl -s -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  "https://accessgw-usw.msp.digitalguardian.com/rest/1.0/export/YOUR_EXPORT_PROFILE_GUID"

Respons yang berhasil akan menampilkan dokumen JSON yang berisi data ekspor. Jika Anda menerima error autentikasi, verifikasi ID dan Secret Akses API di DGMC Cloud Services.

Catatan: Ganti YOUR_CLIENT_ID, YOUR_CLIENT_SECRET, YOUR_ACCESS_TOKEN, dan YOUR_EXPORT_PROFILE_GUID dengan nilai sebenarnya. Gunakan URL Server Otorisasi dan URL Dasar Access Gateway dari konfigurasi DGMC Anda.

Buat akun layanan untuk fungsi Cloud Run

Di Konsol Google Cloud, buka IAM & Admin > Service Accounts.
Klik Create Service Account.
Berikan detail konfigurasi berikut:
- Nama akun layanan: Masukkan digitalguardian-ingestion (atau nama deskriptif).
- Deskripsi akun layanan: Masukkan Service account for Digital Guardian EDR Cloud Run function to write logs to GCS.
Klik Create and Continue.
Di bagian Berikan akun layanan ini akses ke project, tambahkan peran berikut:
- Storage Object Admin (untuk membaca/menulis objek di bucket Cloud Storage)
- Cloud Run Invoker (untuk mengizinkan Cloud Scheduler memanggil fungsi)
Klik Lanjutkan.
Klik Done.

Catatan: Catat email akun layanan (misalnya, digitalguardian-ingestion@PROJECT_ID.iam.gserviceaccount.com). Anda akan menggunakannya saat membuat tugas Cloud Scheduler.

Membuat topik Pub/Sub

Cloud Scheduler memicu fungsi Cloud Run melalui topik Pub/Sub.

Di konsol Google Cloud, buka Pub/Sub > Topics.
Klik Create topic.
Di kolom Topic ID, masukkan digitalguardian-edr-trigger.
Biarkan setelan default.
Klik Create.

Catatan: Catat nama topik lengkap (misalnya, projects/PROJECT_ID/topics/digitalguardian-edr-trigger).

Membuat fungsi Cloud Run

Buat fungsi Cloud Run yang melakukan autentikasi ke Digital Guardian ARC menggunakan kredensial klien OAuth 2.0, mengambil data ekspor, mengonfirmasi bookmark untuk melanjutkan ke bagian berikutnya, dan menulis hasil sebagai NDJSON ke GCS.

Menyiapkan file sumber fungsi

Buat dua file berikut untuk deployment fungsi Cloud Run.

requirements.txt

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

main.py

"""Cloud Run function to ingest Digital Guardian EDR logs into GCS."""

import json
import os
import time
import urllib.parse
from datetime import datetime, timezone

import functions_framework
import urllib3
from google.cloud import storage

GCS_BUCKET = os.environ["GCS_BUCKET"]
GCS_PREFIX = os.environ.get("GCS_PREFIX", "digitalguardian_edr")
STATE_KEY = os.environ.get("STATE_KEY", "digitalguardian_edr_state.json")
AUTH_SERVER_URL = os.environ["AUTH_SERVER_URL"]
ARC_SERVER_URL = os.environ["ARC_SERVER_URL"]
CLIENT_ID = os.environ["CLIENT_ID"]
CLIENT_SECRET = os.environ["CLIENT_SECRET"]
EXPORT_PROFILE_GUID = os.environ["EXPORT_PROFILE_GUID"]
MAX_RECORDS = int(os.environ.get("MAX_RECORDS", "10000"))

http = urllib3.PoolManager()
gcs = storage.Client()

def _get_access_token() -> str:
    """Obtain an OAuth 2.0 access token using client credentials grant."""
    body = urllib.parse.urlencode({
        "grant_type": "client_credentials",
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "scope": "client",
    })
    resp = http.request(
        "POST",
        AUTH_SERVER_URL,
        body=body,
        headers={"Content-Type": "application/x-www-form-urlencoded"},
    )
    if resp.status != 200:
        raise RuntimeError(
            f"OAuth token request failed: {resp.status} — "
            f"{resp.data.decode('utf-8')}"
        )
    token_data = json.loads(resp.data.decode("utf-8"))
    return token_data["access_token"]

def _arc_get(token: str, path: str, retries: int = 5) -> dict:
    """Execute a GET request against the ARC API with retry on 429."""
    url = f"{ARC_SERVER_URL}{path}"
    headers = {
        "Authorization": f"Bearer {token}",
        "Accept": "application/json",
    }
    backoff = 2
    for attempt in range(retries):
        resp = http.request("GET", url, headers=headers)
        if resp.status == 200:
            return json.loads(resp.data.decode("utf-8"))
        if resp.status == 429:
            wait = backoff * (2 ** attempt)
            print(
                f"Rate limited (429). Retrying in {wait}s "
                f"(attempt {attempt + 1}/{retries})."
            )
            time.sleep(wait)
            continue
        raise RuntimeError(
            f"ARC API error: {resp.status} — {resp.data.decode('utf-8')}"
        )
    raise RuntimeError(
        "ARC API rate limit exceeded after maximum retries."
    )

def _arc_acknowledge(token: str) -> None:
    """POST to the acknowledge endpoint to advance the export bookmark."""
    url = (
        f"{ARC_SERVER_URL}/rest/1.0/export/"
        f"{EXPORT_PROFILE_GUID}/acknowledge"
    )
    headers = {
        "Authorization": f"Bearer {token}",
        "Accept": "application/json",
    }
    resp = http.request("POST", url, headers=headers)
    if resp.status not in (200, 204):
        raise RuntimeError(
            f"ARC acknowledge failed: {resp.status} — "
            f"{resp.data.decode('utf-8')}"
        )
    print("Export bookmark acknowledged successfully.")

def _load_state() -> dict:
    """Load the last run state from GCS."""
    bucket = gcs.bugcs.bucketUCKET)
    blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
    if blob.exists():
        return json.loads(blob.downlodownload_as_text  return {}

def _save_state(state: dict) -> None:
    """Persist run state to GCS."""
    bucket = gcs.bugcs.bucketUCKET)
    blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
    blob.uploadupload_from_string    json.dumps(state), content_type="application/json"
    )

def _fetch_export(token: str) -> list:
    """Fetch export data from the ARC Export API."""
    path = f"/rest/1.0/export/{EXPORT_PROFILE_GUID}"
    data = _arc_get(token, path)
    records = data if isinstance(data, list) else data.get("data", [])
    return records[:MAX_RECORDS]

def _write_ndjson(records: list, run_ts: str) -> str:
    """Write records as NDJSON to GCS and return the blob path."""
    bucket = gcs.bugcs.bucketUCKET)
    blob_path = (
        f"{GCS_PREFIX}/year={run_ts[:4]}/month={run_ts[5:7]}/"
        f"day={run_ts[8:10]}/{run_ts}_export.ndjson"
    )
    blob = bucket.blob(blob_path)
    ndjson = "\n".join(
        json.dumps(r, separators=(",", ":")) for r in records
    )
    blob.uploadupload_from_stringn, content_type="application/x-ndjson")
    return blob_path

@functions_framework.cloud_event
def main(cloud_event):
    """Entry point triggered by Pub/Sub via Cloud Scheduler."""
    state = _load_state()
    now = datetime.now(timezone.utc)

    print("Authenticating to Digital Guardian ARC.")
    token = _get_access_token()

    print(
        f"Fetching export data for profile {EXPORT_PROFILE_GUID}."
    )
    records = _fetch_export(token)

    if not records:
        print("No new export data found.")
        return "OK"

    run_ts = now.strftime("%Y-%m-%dT%H%M%SZ")
    blob_path = _write_ndjson(records, run_ts)
    print(
        f"Wrote {len(records)} records to "
        f"gs://{GCS_BUCKET}/{blob_path}."
    )

    _arc_acknowledge(token)

    state["last_run"] = now.isoformat()
    state["records_written"] = len(records)
    _save_state(state)
    print(f"State updated. last_run={now.isoformat()}.")
    return "OK"

Men-deploy fungsi Cloud Run

Simpan kedua file (main.py dan requirements.txt) ke direktori lokal (misalnya, digitalguardian-function/).
Buka Cloud Shell atau terminal dengan CLI gcloud terinstal.

Jalankan perintah berikut untuk men-deploy fungsi:

gcloud functions deploy digitalguardian-edr-to-gcs \
  --gen2 \
  --region=us-central1 \
  --runtime=python312 \
  --trigger-topic=digitalguardian-edr-trigger \
  --entry-point=main \
  --memory=512MB \
  --timeout=540s \
  --service-account=digitalguardian-ingestion@PROJECT_ID.iam.gserviceaccount.com \
  --set-env-vars=\
  "GCS_BUCKET=digitalguardian-edr-logs",\
  "GCS_PREFIX=digitalguardian_edr",\
  "STATE_KEY=digitalguardian_edr_state.json",\
  "AUTH_SERVER_URL=https://authsrv.msp.digitalguardian.com/as/token.oauth2",\
  "ARC_SERVER_URL=https://accessgw-usw.msp.digitalguardian.com",\
  "CLIENT_ID=YOUR_CLIENT_ID",\
  "CLIENT_SECRET=YOUR_CLIENT_SECRET",\
  "EXPORT_PROFILE_GUID=YOUR_EXPORT_PROFILE_GUID",\
  "MAX_RECORDS=10000"

Ganti nilai placeholder berikut:
- PROJECT_ID: ID project Google Cloud Anda.
- digitalguardian-edr-logs: Nama bucket GCS Anda.
- YOUR_CLIENT_ID: ID Akses API Digital Guardian Anda.
- YOUR_CLIENT_SECRET: Rahasia Akses Digital Guardian API Anda.
- YOUR_EXPORT_PROFILE_GUID: GUID Profil Ekspor Anda dari DGMC.
Catatan: Untuk deployment produksi, gunakan Google Cloud Secret Manager untuk menyimpan CLIENT_SECRET, bukan meneruskannya sebagai variabel lingkungan teks biasa. Referensi secret menggunakan --set-secrets="CLIENT_SECRET=dg-client-secret:latest".

Verifikasi deployment dengan memeriksa status fungsi:

gcloud functions describe digitalguardian-edr-to-gcs --region=us-central1 --gen2

Referensi variabel lingkungan

Variabel	Wajib	Default	Deskripsi
`GCS_BUCKET`	Ya		Nama bucket GCS untuk menyimpan output NDJSON
`GCS_PREFIX`	Tidak	`digitalguardian_edr`	Awalan objek (jalur folder) dalam bucket
`STATE_KEY`	Tidak	`digitalguardian_edr_state.json`	Nama blob untuk file status dalam awalan
`AUTH_SERVER_URL`	Ya		URL server otorisasi OAuth 2.0
`ARC_SERVER_URL`	Ya		URL dasar ARC Access Gateway
`CLIENT_ID`	Ya		ID Akses API dari DGMC
`CLIENT_SECRET`	Ya		Rahasia Akses API dari DGMC
`EXPORT_PROFILE_GUID`	Ya		Mengekspor GUID Profil dari DGMC
`MAX_RECORDS`	Tidak	`10000`	Jumlah maksimum data yang akan ditulis per eksekusi

Buat tugas Cloud Scheduler

Cloud Scheduler memicu fungsi Cloud Run secara berkala melalui topik Pub/Sub.

Di konsol Google Cloud, buka Cloud Scheduler.
Klik Create Job.
Berikan detail konfigurasi berikut:
- Nama: Masukkan digitalguardian-edr-ingestion-schedule.
- Region: Pilih region yang sama dengan fungsi Cloud Run Anda (misalnya, us-central1).
- Frekuensi: Masukkan */5 * * * * (setiap 5 menit).
  
  Catatan: Interval 5 menit menyeimbangkan penyerapan log tepat waktu dengan batas kecepatan API. Sesuaikan jadwal berdasarkan volume data ekspor dan persyaratan keaktualan Anda.
- Zona waktu: Pilih zona waktu pilihan Anda (misalnya, UTC).
Klik Lanjutkan.
Di bagian Konfigurasi eksekusi:
- Jenis target: Pilih Pub/Sub.
- Topik: Pilih digitalguardian-edr-trigger.
- Isi pesan: Masukkan {"run": true}.
Klik Lanjutkan.
Di bagian Konfigurasi setelan opsional:
- Jumlah maksimal upaya mencoba lagi: Masukkan 3.
- Durasi backoff minimum: Masukkan 5s.
- Durasi backoff maksimum: Masukkan 60s.
Klik Create.
Untuk menjalankan pengujian langsung, klik tiga titik (...) di samping nama tugas, lalu pilih Jalankan paksa.

Catatan: Pantau log eksekusi fungsi di Cloud Logging dengan memfilter nama fungsi digitalguardian-edr-to-gcs. Pastikan file NDJSON muncul di bucket GCS Anda dengan awalan yang dikonfigurasi.

Mengambil akun layanan Google SecOps dan mengonfigurasi feed

Google SecOps menggunakan akun layanan unik untuk membaca data dari bucket GCS Anda. Anda harus memberi akun layanan ini akses ke bucket Anda.

Dapatkan email akun layanan

Buka Setelan SIEM > Feed.
Klik Tambahkan Feed Baru.
Klik Konfigurasi satu feed.
Di kolom Nama feed, masukkan nama untuk feed (misalnya, Digital Guardian EDR Logs).
Pilih Google Cloud Storage V2 sebagai Source type.
Pilih Digital Guardian EDR sebagai Jenis log.
Klik Get Service Account. Email akun layanan yang unik akan ditampilkan, misalnya:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
Salin alamat email ini untuk digunakan di langkah berikutnya.

Catatan: Setiap instance Google SecOps memiliki akun layanan yang unik. Jangan gunakan akun layanan dari dokumentasi atau contoh lain.
Klik Berikutnya.
Tentukan nilai untuk parameter input berikut:
- URL bucket penyimpanan: Masukkan URI bucket GCS:
```
gs://digitalguardian-edr-logs/digitalguardian_edr/
```
  - Ganti digitalguardian-edr-logs dengan nama bucket GCS Anda.
  - Ganti digitalguardian_edr dengan nilai GCS_PREFIX yang Anda konfigurasi.
  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 Google SecOps harus memiliki peran Storage Object Admin, bukan Storage Object Viewer. Perbarui izin IAM yang sesuai.
- Usia File Maksimum: Menyertakan 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.
Klik Berikutnya.
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 Cloud Storage Anda.

Buka Cloud Storage > Buckets.
Klik nama bucket Anda (misalnya, digitalguardian-edr-logs).
Buka tab Izin.
Klik Grant access.
Berikan detail konfigurasi berikut:
- Add principals: Tempelkan email akun layanan Google SecOps (misalnya, chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com).
- Tetapkan peran: Pilih Storage Object Viewer.
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
Aplikasi	target.application	Nilai disalin secara langsung
Aplikasi	target.process.command_line	Disetel ke %{Application} jika Aturan cocok dengan .Printer.
Bytes_Written	network.sent_bytes	Nilai disalin secara langsung dan dikonversi ke uinteger
Category, Computer_Name, Detail	metadata.description	Ditetapkan ke %{Detail} jika Category == "Policies" dan Computer_Name kosong; jika tidak, ditetapkan ke %{message} pada grok_parse_failure
Command_Line, Command_Line1	principal.process.command_line	Nilai dari Command_Line setelah menghapus tanda petik di akhir jika tidak kosong, atau dari Command_Line1 setelah menghapus tanda petik di akhir
Computer_Name, sumber	principal.hostname	Nilai dari computerName jika tidak kosong, jika tidak, setel ke %{source}
Destination_Device_Serial_Number, Destination_Device_Serial_Number1		Diekstrak menggunakan pola grok untuk menangani kutipan
Destination_Directory, Destination_File	target.file.full_path	Digabungkan dari Destination_Directory dan Destination_File jika keduanya tidak kosong
Destination_Drive_Type	security_result.detection_fields	Digabungkan dengan destination_drive_type_label (kunci: Destination_Drive_Type, nilai: %{Destination_Drive_Type})
Destination_File	target.file.names	Digabungkan dari Destination_File
Destination_File_Extension	target.file.mime_type	Nilai disalin secara langsung
Dll_SHA1_Hash	target.process.file.sha1	Nilai disalin langsung setelah dikonversi menjadi huruf kecil
Email_Address	principal.user.email_addresses	Digabungkan dari Email_Address
Email_Sender, Email_Subject	network.email.from	Disetel ke %{Email_Sender} jika tidak kosong
Email_Sender, Email_Subject	network.email.subject	Digabungkan dari subjek (%{Email_Subject}) jika Email_Sender tidak kosong
File_Extension	principal.process.file.mime_type	Nilai disalin secara langsung
IP_Address, source_ip	principal.ip	Digabungkan dari source_ip jika tidak kosong, atau dari IP_Address
Local_Port, source_port	principal.port	Nilai dari source_port jika tidak kosong dan dikonversi menjadi bilangan bulat, atau dari Local_Port dan dikonversi menjadi bilangan bulat
MD5_Checksum	target.process.file.md5	Nilai disalin langsung setelah dikonversi menjadi huruf kecil
Network_Direction	network.direction	Setel ke INBOUND jika Benar, atau OUTBOUND jika Salah
Process_PID	principal.process.pid	Nilai disalin secara langsung
Process_SHA256_Hash	target.process.file.sha256	Nilai disalin langsung setelah dikonversi menjadi huruf kecil
Product_Version	metadata.product_version	Nilai disalin secara langsung
Protokol	network.ip_protocol	Tetapkan ke ICMP jika == "1"
Remote_Port	target.port	Nilai disalin langsung dan dikonversi menjadi bilangan bulat
Aturan	security_result.rule_name	Nilai disalin secara langsung
Aturan	metadata.event_type	Disetel ke PROCESS_UNCATEGORIZED jika cocok dengan .Printer., atau FILE_MOVE jika cocok dengan DLP.*
Keparahan	security_result.severity	Setel ke RENDAH jika <=3, SEDANG jika <=6, TINGGI jika <=8, KRITIS jika <=10 setelah dikonversi menjadi bilangan bulat
Keparahan	security_result.severity_details	Nilai disalin secara langsung
Source_Directory, Source_File	src.file.full_path	Digabungkan dari Source_Directory dan Source_File jika keduanya tidak kosong
Source_Drive_Type	security_result.detection_fields	Digabungkan dengan source_drive_type_label (kunci: Source_Drive_Type, nilai: %{Source_Drive_Type})
Source_File	src.file.names	Digabungkan dari Source_File
Source_File_Extension	src.file.mime_type	Nilai disalin secara langsung
URL_Path, http_url	target.url	Nilai dari http_url jika tidak kosong, atau dari URL_Path
User_Name	principal.user.userid	Nilai dari userName setelah ekstraksi grok
User_Name	principal.administrative_domain	Nilai dari domainName setelah ekstraksi grok
Was_Removable	security_result.detection_fields	Digabungkan dengan was_removable_label (kunci: Was_Removable, nilai: %{Was_Removable})
Was_Source_Removable	security_result.detection_fields	Digabungkan dengan was_source_removable_label (kunci: Was_Source_Removable, nilai: %{Was_Source_Removable})
computerName, destination_ip, protocol, source_ip, IP_Address, destination, userName, Process_PID, Category, Computer_Name	metadata.event_type	Disetel ke GENERIC_EVENT pada awalnya; NETWORK_HTTP jika protocol == HTTPS dan (destination_ip atau computerName); NETWORK_CONNECTION jika (source_ip atau IP_Address) dan destination_ip; USER_UNCATEGORIZED jika userName tidak kosong; SCAN_PROCESS jika Process_PID tidak kosong
destination_ip	target.ip	Digabungkan dari destination_ip
incidents_url, matched_policies_by_severity	security_result	Digabungkan dengan _sr (rule_name: %{matched_policies_by_severity}, url_back_to_product: %{incidents_url})
protokol	network.application_protocol	Setel ke HTTPS jika protokol == HTTP atau HTTPS
security_action	security_result.action	Digabungkan dari security_action
	metadata.product_name	Tetapkan ke "Enterprise DLP Platform"
	metadata.vendor_name	Disetel ke "DigitalGuardian"

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