Mengumpulkan log BeyondTrust Endpoint Privilege Management (EPM)

Didukung di:

Google SecOps SIEM

Dokumen ini menjelaskan cara menyerap log BeyondTrust Endpoint Privilege Management (EPM) ke Google Security Operations menggunakan Google Cloud Storage. Parser berfokus untuk mengubah data log JSON mentah dari BeyondTrust Endpoint menjadi format terstruktur yang sesuai dengan UDM Chronicle. Pertama-tama, nilai default untuk berbagai kolom diinisialisasi, lalu payload JSON diurai, dan selanjutnya kolom tertentu dari log mentah dipetakan ke kolom UDM yang sesuai dalam objek event.idm.read_only_udm.

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
Akses istimewa ke tenant atau API BeyondTrust Endpoint Privilege Management

Membuat bucket Google Cloud Storage

Buka Google Cloud Console.
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, `beyondtrust-epm-logs`)
Location type	Pilih berdasarkan kebutuhan Anda (Region, Dual-region, Multi-region)
Lokasi	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

Klik Buat.

Mengumpulkan kredensial BeyondTrust EPM API

Login ke konsol web BeyondTrust Privilege Management sebagai administrator.
Buka Konfigurasi > Setelan > Setelan API.
Klik Create an API Account.
Berikan detail konfigurasi berikut:
- Nama: Masukkan Google SecOps Collector.
- Akses API: Aktifkan Audit (Baca) dan cakupan lainnya sesuai kebutuhan.
Salin dan simpan Client ID dan Client Secret.
Salin URL dasar API Anda; biasanya https://<your-tenant>-services.pm.beyondtrustcloud.com (Anda akan menggunakan ini sebagai BPT_API_URL).

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

Di GCP Console, buka IAM & Admin > Service Accounts.
Klik Create Service Account.
Berikan detail konfigurasi berikut:
- Nama akun layanan: Masukkan beyondtrust-epm-collector-sa.
- Deskripsi akun layanan: Masukkan Service account for Cloud Run function to collect BeyondTrust EPM logs.
Klik Create and Continue.
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.
Klik Lanjutkan.
Klik Selesai.

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:

Buka Cloud Storage > Buckets.
Klik nama bucket Anda.
Buka tab Izin.
Klik Grant access.
Berikan detail konfigurasi berikut:
- Tambahkan prinsipal: Masukkan email akun layanan (misalnya, beyondtrust-epm-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- Tetapkan peran: Pilih Storage Object Admin.
Klik Simpan.

Membuat topik Pub/Sub

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

Di GCP Console, buka Pub/Sub > Topics.
Klik Create topic.
Berikan detail konfigurasi berikut:
- ID Topik: Masukkan beyondtrust-epm-trigger.
- Biarkan setelan lainnya tetap default.
Klik Buat.

Membuat fungsi Cloud Run untuk mengumpulkan log

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

Di GCP Console, buka Cloud Run.
Klik Create service.
Pilih Function (gunakan editor inline untuk membuat fungsi).
Di bagian Konfigurasi, berikan detail konfigurasi berikut:

Setelan Nilai

Nama layanan beyondtrust-epm-collector

Wilayah Pilih region yang cocok dengan bucket GCS Anda (misalnya, us-central1)

Runtime Pilih Python 3.12 atau yang lebih baru
Di bagian Pemicu (opsional):
1. Klik + Tambahkan pemicu.
2. Pilih Cloud Pub/Sub.
3. Di Select a Cloud Pub/Sub topic, pilih topik beyondtrust-epm-trigger.
4. Klik Simpan.
Di bagian Authentication:
1. Pilih Wajibkan autentikasi.
2. Periksa Identity and Access Management (IAM).
Catatan: Pub/Sub secara otomatis menangani autentikasi saat memanggil fungsi.
Scroll ke bawah dan luaskan Containers, Networking, Security.
Buka tab Security:
- Akun layanan: Pilih akun layanan beyondtrust-epm-collector-sa.

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

Buka tab Containers:

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

Nama Variabel	Nilai Contoh
`GCS_BUCKET`	`beyondtrust-epm-logs`
`GCS_PREFIX`	`beyondtrust-epm/`
`STATE_KEY`	`beyondtrust-epm/state.json`
`BPT_API_URL`	`https://yourtenant-services.pm.beyondtrustcloud.com`
`CLIENT_ID`	`your-client-id`
`CLIENT_SECRET`	`your-client-secret`
`OAUTH_SCOPE`	`management-api`
`RECORD_SIZE`	`1000`
`MAX_ITERATIONS`	`10`

Scroll ke bawah di tab Variables & Secrets ke Requests:
- Waktu tunggu permintaan: Masukkan 600 detik (10 menit).
Buka tab Setelan di Penampung:
- Di bagian Materi:
  - Memori: Pilih 512 MiB atau yang lebih tinggi.
  - CPU: Pilih 1.
- Klik Selesai.
Scroll ke Lingkungan eksekusi:
- Pilih Default (direkomendasikan).
Di bagian Penskalaan revisi:
- Jumlah minimum instance: Masukkan 0.
- Jumlah maksimum instance: Masukkan 100 (atau sesuaikan berdasarkan perkiraan beban).
Klik Buat.
Tunggu hingga layanan dibuat (1-2 menit).
Setelah layanan dibuat, editor kode inline akan terbuka secara otomatis.

Menambahkan kode fungsi

Masukkan main di Function entry point

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
http = urllib3.PoolManager()

# Initialize Storage client
storage_client = storage.Client()

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch logs from BeyondTrust EPM API and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'beyondtrust-epm/')
    state_key = os.environ.get('STATE_KEY', 'beyondtrust-epm/state.json')

    # BeyondTrust EPM API credentials
    api_url = os.environ.get('BPT_API_URL')
    client_id = os.environ.get('CLIENT_ID')
    client_secret = os.environ.get('CLIENT_SECRET')
    oauth_scope = os.environ.get('OAUTH_SCOPE', 'management-api')
    record_size = int(os.environ.get('RECORD_SIZE', '1000'))
    max_iterations = int(os.environ.get('MAX_ITERATIONS', '10'))

    if not all([bucket_name, api_url, client_id, client_secret]):
        print('Error: Missing required environment variables')
        return

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(bucket_name)

        # Load state (last processed timestamp)
        state = load_state(bucket, state_key)
        last_timestamp = state.get('last_timestamp', (datetime.utcnow() - timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ"))

        print(f'Processing logs since {last_timestamp}')

        # Get OAuth access token
        token = get_oauth_token(api_url, client_id, client_secret, oauth_scope)

        # Fetch audit events
        events = fetch_audit_events(api_url, token, last_timestamp, record_size, max_iterations)

        if events:
            # Store events in GCS
            current_timestamp = datetime.utcnow()
            filename = f"{prefix}beyondtrust-epm-events-{current_timestamp.strftime('%Y%m%d_%H%M%S')}.json"
            store_events_to_gcs(bucket, filename, events)

            # Update state with latest timestamp
            latest_timestamp = get_latest_event_timestamp(events)
            save_state(bucket, state_key, {'last_timestamp': latest_timestamp, 'updated_at': datetime.utcnow().isoformat() + 'Z'})

            print(f'Successfully processed {len(events)} events and stored to {filename}')
        else:
            print('No new events found')

    except Exception as e:
        print(f'Error processing logs: {str(e)}')
        raise

def get_oauth_token(api_url, client_id, client_secret, scope):
    """
    Get OAuth access token using client credentials flow for BeyondTrust EPM.
    Uses the correct endpoint: /oauth/token
    """
    token_url = f"{api_url}/oauth/token"
    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
    body = f"grant_type=client_credentials&client_id={client_id}&client_secret={client_secret}&scope={scope}"

    response = http.request('POST', token_url, headers=headers, body=body, timeout=urllib3.Timeout(60.0))

    if response.status != 200:
        raise RuntimeError(f"Token request failed: {response.status} {response.data[:256]!r}")

    token_data = json.loads(response.data.decode('utf-8'))
    return token_data['access_token']

def fetch_audit_events(api_url, access_token, last_timestamp, record_size, max_iterations):
    """
    Fetch audit events using the BeyondTrust EPM API endpoint: /management-api/v2/AuditEvents
    with query parameters for filtering and pagination
    """
    headers = {
        'Authorization': f'Bearer {access_token}',
        'Content-Type': 'application/json'
    }

    all_events = []
    current_start_date = last_timestamp
    iterations = 0

    # Enforce maximum RecordSize limit of 1000 based on BeyondTrust documentation
    record_size_limited = min(record_size, 1000)

    while iterations < max_iterations:
        iterations += 1

        if len(all_events) >= 10000:
            print(f"Reached maximum events limit (10000)")
            break

        # Use the BeyondTrust EPM API endpoint for audit events
        query_url = f"{api_url}/management-api/v2/AuditEvents"
        params = {
            'StartDate': current_start_date,
            'RecordSize': record_size_limited
        }

        # Construct URL with query parameters
        query_string = '&'.join([f"{k}={v}" for k, v in params.items()])
        full_url = f"{query_url}?{query_string}"

        try:
            response = http.request('GET', full_url, headers=headers, timeout=urllib3.Timeout(300.0))

            # Handle rate limiting with exponential backoff
            if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', '30'))
                print(f"Rate limited (429). Retrying after {retry_after}s...")
                time.sleep(retry_after)
                continue

            if response.status != 200:
                raise RuntimeError(f"API request failed: {response.status} {response.data[:256]!r}")

            response_data = json.loads(response.data.decode('utf-8'))
            events = response_data.get('events', [])

            if not events:
                break

            print(f"Page {iterations}: Retrieved {len(events)} events")
            all_events.extend(events)

            # If we got fewer events than RecordSize, we've reached the end
            if len(events) < record_size_limited:
                break

            # For pagination, update StartDate to the timestamp of the last event
            last_event = events[-1]
            last_timestamp = extract_event_timestamp(last_event)

            if not last_timestamp:
                print("Warning: Could not find timestamp in last event for pagination")
                break

            # Convert to datetime and add 1 second to avoid retrieving the same event again
            try:
                dt = parse_timestamp(last_timestamp)
                dt = dt + timedelta(seconds=1)
                current_start_date = dt.strftime("%Y-%m-%dT%H:%M:%SZ")
            except Exception as e:
                print(f"Error parsing timestamp {last_timestamp}: {e}")
                break

        except Exception as e:
            print(f"Error fetching page {iterations}: {e}")
            break

    return all_events

def extract_event_timestamp(event):
    """Extract timestamp from event, checking multiple possible fields"""
    # Check common timestamp fields
    timestamp_fields = ['event.dateTime', 'event.timestamp', 'timestamp', 'eventTime', 'dateTime', 'whenOccurred', 'date', 'time', 'event.ingested']

    # Try nested event.dateTime first (common in BeyondTrust)
    if isinstance(event, dict) and isinstance(event.get("event"), dict):
        ts = event["event"].get("dateTime")
        if ts:
            return ts
        ts = event["event"].get("timestamp")
        if ts:
            return ts

    # Fallback to other timestamp fields
    for field in timestamp_fields:
        if field in event and event[field]:
            return event[field]

    return None

def parse_timestamp(timestamp_str):
    """Parse timestamp string to datetime object, handling various formats"""
    if isinstance(timestamp_str, (int, float)):
        # Unix timestamp (in milliseconds or seconds)
        if timestamp_str > 1e12:  # Milliseconds
            return datetime.fromtimestamp(timestamp_str / 1000, tz=timezone.utc)
        else:  # Seconds
            return datetime.fromtimestamp(timestamp_str, tz=timezone.utc)

    if isinstance(timestamp_str, str):
        # Try different string formats
        try:
            # ISO format with Z
            if timestamp_str.endswith('Z'):
                return datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
            # ISO format with timezone
            elif '+' in timestamp_str or timestamp_str.endswith('00:00'):
                return datetime.fromisoformat(timestamp_str)
            # ISO format without timezone (assume UTC)
            else:
                dt = datetime.fromisoformat(timestamp_str)
                if dt.tzinfo is None:
                    dt = dt.replace(tzinfo=timezone.utc)
                return dt
        except ValueError:
            pass

    raise ValueError(f"Could not parse timestamp: {timestamp_str}")

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: {str(e)}')
    return {}

def save_state(bucket, key, state):
    """Save state to GCS."""
    try:
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state),
            content_type='application/json'
        )
    except Exception as e:
        print(f'Warning: Could not save state: {str(e)}')

def store_events_to_gcs(bucket, key, events):
    """Store events as JSONL (one JSON object per line) in GCS"""
    # Convert to JSONL format (one JSON object per line)
    jsonl_content = '\n'.join(json.dumps(event, default=str) for event in events)

    blob = bucket.blob(key)
    blob.upload_from_string(jsonl_content, content_type='application/x-ndjson')

def get_latest_event_timestamp(events):
    """Get the latest timestamp from the events for state tracking"""
    if not events:
        return datetime.utcnow().isoformat() + 'Z'

    latest = None
    for event in events:
        timestamp = extract_event_timestamp(event)
        if timestamp:
            try:
                event_dt = parse_timestamp(timestamp)
                event_iso = event_dt.isoformat() + 'Z'
                if latest is None or event_iso > latest:
                    latest = event_iso
            except Exception as e:
                print(f"Error parsing event timestamp {timestamp}: {e}")
                continue

    return latest or datetime.utcnow().isoformat() + 'Z'

File kedua: requirements.txt:

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

Klik Deploy untuk menyimpan dan men-deploy fungsi.
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 memublikasikan pesan ke topik Pub/Sub secara berkala, sehingga memicu fungsi Cloud Run.

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

Berikan detail konfigurasi berikut:

Setelan	Nilai
Nama	`beyondtrust-epm-collector-hourly`
Wilayah	Pilih region yang sama dengan fungsi Cloud Run
Frekuensi	`0 * * * *` (setiap jam, tepat pada waktunya)
Zona waktu	Pilih zona waktu (UTC direkomendasikan)
Jenis target	Pub/Sub
Topik	Pilih topik `beyondtrust-epm-trigger`
Isi pesan	`{}` (objek JSON kosong)

Klik Buat.

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 (direkomendasikan)
Setiap 6 jam	`0 /6 * *`	Volume rendah, pemrosesan batch
Harian	`0 0 * * *`	Pengumpulan data historis

Menguji tugas penjadwal

Di konsol Cloud Scheduler, temukan tugas Anda.
Klik Jalankan paksa untuk memicu secara manual.
Tunggu beberapa detik, lalu buka Cloud Run > Services > beyondtrust-epm-collector > Logs.
Pastikan fungsi berhasil dieksekusi.
Periksa bucket GCS untuk mengonfirmasi bahwa log telah ditulis.

Mengambil akun layanan Google SecOps

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, BeyondTrust EPM logs).
Pilih Google Cloud Storage V2 sebagai Source type.
Pilih BeyondTrust Endpoint Privilege Management sebagai Log type.
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.

Memberikan izin IAM ke akun layanan Google SecOps

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

Buka Cloud Storage > Buckets.
Klik nama bucket Anda.
Buka tab Izin.
Klik Grant access.
Berikan detail konfigurasi berikut:
- Add principals: Tempel email akun layanan Google SecOps.
- 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.

Mengonfigurasi feed di Google SecOps untuk memproses log BeyondTrust EPM

Buka Setelan SIEM > Feed.
Klik Tambahkan Feed Baru.
Klik Konfigurasi satu feed.
Di kolom Nama feed, masukkan nama untuk feed (misalnya, BeyondTrust EPM logs).
Pilih Google Cloud Storage V2 sebagai Source type.
Pilih BeyondTrust Endpoint Privilege Management sebagai Log type.
Klik Berikutnya.
Tentukan nilai untuk parameter input berikut:
- URL bucket penyimpanan: Masukkan URI bucket GCS dengan jalur awalan:
```
gs://beyondtrust-epm-logs/beyondtrust-epm/
```
  - Ganti:
    - beyondtrust-epm-logs: Nama bucket GCS Anda.
    - beyondtrust-epm/: Awalan/jalur folder opsional tempat log disimpan (biarkan kosong untuk root).
  - Contoh:
    - Bucket root: gs://beyondtrust-epm-logs/
    - Dengan awalan: gs://beyondtrust-epm-logs/beyondtrust-epm/
  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: Menyertakan file yang diubah 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.

Tabel pemetaan UDM

Kolom Log	Pemetaan UDM	Logika
agent.id	principal.asset.attribute.labels.value	Dipetakan ke label dengan kunci agent_id
agent.version	principal.asset.attribute.labels.value	Dipetakan ke label dengan agen kunci agent_version
ecs.version	principal.asset.attribute.labels.value	Dipetakan ke label dengan kunci ecs_version
event_data.reason	metadata.description	Deskripsi peristiwa dari log mentah
event_datas.ActionId	metadata.product_log_id	ID log khusus produk
file.path	principal.file.full_path	Jalur file lengkap dari acara
headers.content_length	additional.fields.value.string_value	Dipetakan ke label dengan key content_length
headers.content_type	additional.fields.value.string_value	Dipetakan ke label dengan kunci content_type
headers.http_host	additional.fields.value.string_value	Dipetakan ke label dengan kunci http_host
headers.http_version	network.application_protocol_version	Versi protokol HTTP
headers.request_method	network.http.method	Metode permintaan HTTP
host.hostname	principal.hostname	Nama host utama
host.hostname	principal.asset.hostname	Nama host aset utama
host.ip	principal.asset.ip	Alamat IP aset utama
host.ip	principal.ip	Alamat IP utama
host.mac	principal.mac	Alamat MAC utama
host.os.platform	principal.platform	Setel ke MAC jika sama dengan macOS
host.os.version	principal.platform_version	Versi sistem operasi
labels.related_item_id	metadata.product_log_id	ID item terkait
process.command_line	principal.process.command_line	Command line proses
process.name	additional.fields.value.string_value	Dipetakan ke label dengan kunci process_name
process.parent.name	additional.fields.value.string_value	Dipetakan ke label dengan kunci process_parent_name
process.parent.pid	principal.process.parent_process.pid	PID proses induk dikonversi menjadi string
process.pid	principal.process.pid	PID proses dikonversi menjadi string
user.id	principal.user.userid	ID pengguna
user.name	principal.user.user_display_name	Nama tampilan pengguna
T/A	metadata.event_timestamp	Stempel waktu peristiwa ditetapkan ke stempel waktu entri log
T/A	metadata.event_type	GENERIC_EVENT jika tidak ada prinsipal, atau STATUS_UPDATE
T/A	network.application_protocol	Ditetapkan ke HTTP jika kolom http_version berisi HTTP

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