Mengumpulkan log Intel 471 Watcher Alerts

Didukung di:

Dokumen ini menjelaskan cara menyerap log Intel 471 Watcher Alerts ke Google Security Operations menggunakan Google Cloud Storage V2.

Intel 471 adalah perusahaan cyber threat intelligence yang menyediakan intelijen musuh dan malware yang bersumber dari ekonomi bawah tanah. Pemberitahuan Watcher adalah notifikasi yang dihasilkan oleh platform Titan Intel 471 saat konten baru yang cocok dengan kriteria Watcher yang ditentukan pelanggan terdeteksi, sehingga memungkinkan kesadaran tepat waktu akan ancaman yang relevan seperti aktivitas pelaku, postingan forum, dan informasi malware.

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
  • Langganan Intel 471 Titan yang aktif dengan akses API diaktifkan
  • Akses istimewa ke portal Intel 471 Titan

Buat 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
    Memberi nama bucket Anda Masukkan nama yang unik secara global (misalnya, intel471-watcher-alerts-logs)
    Location type Pilih berdasarkan kebutuhan Anda (Region, Dual-region, Multi-region)
    Location Pilih lokasi (misalnya, us-central1)
    Storage class Standar (direkomendasikan untuk log yang sering diakses)
    Kontrol akses Seragam (direkomendasikan)
    Alat perlindungan Opsional: Mengaktifkan pembuatan versi objek atau kebijakan retensi

  6. Klik Create.

Kumpulkan kredensial Intel 471 Titan API

Mendapatkan kredensial API

  1. Login ke portal Intel 471 Titan.
  2. Klik ikon profil pengguna Anda di sudut kanan atas.
  3. Buka bagian API.
  4. Salin dan simpan kunci API yang ditampilkan di halaman.
  5. Catat alamat email yang terkait dengan akun Intel 471 Anda (email yang Anda gunakan untuk login).

Memverifikasi izin

Untuk memverifikasi bahwa akun memiliki izin yang diperlukan:

  1. Login ke portal Intel 471 Titan.
  2. Buka Pengamat di menu navigasi.
  3. Jika Anda dapat melihat konfigurasi dan pemberitahuan Watcher yang ada, berarti Anda memiliki izin yang diperlukan.
  4. Jika Anda tidak dapat melihat bagian ini, hubungi administrator Intel 471 Anda untuk memberikan akses API dan izin Watcher.

Menguji akses API

  • Uji kredensial Anda sebelum melanjutkan integrasi:

    # Replace with your actual credentials
INTEL471_EMAIL="your-email@example.com"
INTEL471_API_KEY="your-api-key"

# Test API access
curl -v -u "${INTEL471_EMAIL}:${INTEL471_API_KEY}" \
    "https://api.intel471.com/v1/alerts?count=1"

Jika pengujian berhasil, Anda akan menerima respons JSON dengan array alerts. Jika Anda menerima error:

  • HTTP 401: Pastikan email dan kunci API sudah benar
  • HTTP 403: Pastikan akun memiliki izin Pemberitahuan Pengamat
  • HTTP 429: Batas kapasitas terlampaui, tunggu dan coba lagi

Buat akun layanan untuk fungsi Cloud Run

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

Membuat akun layanan

  1. Di Konsol GCP, buka IAM & Admin > Service Accounts.
  2. Klik Create Service Account.
  3. Berikan detail konfigurasi berikut:
    • Nama akun layanan: Masukkan intel471-alerts-collector-sa
    • Service account description: Masukkan Service account for Cloud Run function to collect Intel 471 Watcher Alerts logs
  4. Klik Create and Continue.
  5. Di bagian Grant this service account access to 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 state file
  • 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, intel471-watcher-alerts-logs).
  3. Buka tab Izin.
  4. Klik Grant access.
  5. Berikan detail konfigurasi berikut:
    • Tambahkan entitas: Masukkan email akun layanan (misalnya, intel471-alerts-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
    • Menetapkan 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 intel471-alerts-trigger
    • Biarkan setelan lainnya sesuai 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 Watcher Alerts dari Intel 471 Titan API dan menulisnya ke GCS.

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

  4. Di bagian Konfigurasi, berikan detail konfigurasi berikut:

    Setelan Nilai
    Nama layanan intel471-alerts-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 Pub/Sub (misalnya, intel471-alerts-trigger).
    4. Klik Simpan.

  6. Di bagian Authentication:

    1. Pilih Wajibkan autentikasi.
    2. Periksa Identity and Access Management (IAM).

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

  8. Buka tab Security:

    • Service account: Pilih akun layanan (misalnya, intel471-alerts-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 intel471-watcher-alerts-logs Nama bucket GCS
      GCS_PREFIX intel471-alerts Awalan untuk file log
      STATE_KEY intel471-alerts/state.json Jalur file status
      INTEL471_EMAIL your-email@example.com Email akun Intel 471
      INTEL471_API_KEY your-api-key Kunci API Intel 471
      MAX_RECORDS 1000 Jumlah data maks per proses
      PAGE_SIZE 100 Data per halaman (maks. 100)
      LOOKBACK_HOURS 24 Periode lihat balik awal

  10. Di bagian Variables & Secrets, scroll ke bawah ke Requests:

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

  11. Buka tab Setelan:

    • Di bagian Resources:
      • Memori: Pilih 512 MiB atau lebih tinggi
      • CPU: Pilih 1

  12. Di bagian Revision scaling:

    • Minimum number of instances: Masukkan 0
    • Maximum number of instances: Masukkan 100 (atau sesuaikan berdasarkan perkiraan beban)

  13. Klik Create.

  14. Tunggu hingga layanan dibuat (1-2 menit). Setelah layanan dibuat, editor kode inline akan terbuka secara otomatis.

Menambahkan kode fungsi

  1. Masukkan main di kolom Entry point.

  2. Di editor kode inline, buat dua file:

    • main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time
import base64

# 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', 'intel471-alerts')
STATE_KEY = os.environ.get('STATE_KEY', 'intel471-alerts/state.json')
INTEL471_EMAIL = os.environ.get('INTEL471_EMAIL')
INTEL471_API_KEY = os.environ.get('INTEL471_API_KEY')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '1000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

API_BASE = 'https://api.intel471.com/v1'

def to_unix_millis(dt: datetime) -> int:
    """Convert datetime to Unix epoch milliseconds."""
    if dt.tzinfo is None:
        dt = dt.replace(tzinfo=timezone.utc)
    dt = dt.astimezone(timezone.utc)
    return int(dt.timestamp() * 1000)

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 Intel 471 Watcher Alerts and write to GCS.

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

    if not all([GCS_BUCKET, INTEL471_EMAIL, INTEL471_API_KEY]):
        print('Error: Missing required environment variables')
        return

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

        # Load state
        state = load_state(bucket, STATE_KEY)

        # Determine time window
        now = datetime.now(timezone.utc)
        last_time = None

        if isinstance(state, dict) and state.get("last_event_time"):
            try:
                last_time = parse_datetime(state["last_event_time"])
                # Overlap by 2 minutes to catch any delayed events
                last_time = last_time - timedelta(minutes=2)
            except Exception as e:
                print(f"Warning: Could not parse last_event_time: {e}")

        if last_time is None:
            last_time = now - timedelta(hours=LOOKBACK_HOURS)

        print(f"Fetching alerts from {last_time.isoformat()} to {now.isoformat()}")

        # Convert to Unix milliseconds for Titan API
        start_millis = to_unix_millis(last_time)
        end_millis = to_unix_millis(now)

        # Fetch alerts
        records, newest_event_time = fetch_alerts(
            email=INTEL471_EMAIL,
            api_key=INTEL471_API_KEY,
            start_millis=start_millis,
            end_millis=end_millis,
            page_size=PAGE_SIZE,
            max_records=MAX_RECORDS,
        )

        if not records:
            print("No new alert records found.")
            save_state(bucket, STATE_KEY, now.isoformat())
            return

        # Write to GCS as NDJSON
        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = f"{GCS_PREFIX}/alerts_{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}")

        # Update state with newest event time
        if newest_event_time:
            save_state(bucket, STATE_KEY, newest_event_time)
        else:
            save_state(bucket, STATE_KEY, now.isoformat())

        print(f"Successfully processed {len(records)} records")

    except Exception as e:
        print(f'Error processing alerts: {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_event_time_iso: str):
    """Save the last event timestamp to GCS state file."""
    try:
        state = {'last_event_time': last_event_time_iso}
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
        )
        print(f"Saved state: last_event_time={last_event_time_iso}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

def fetch_alerts(email: str, api_key: str, start_millis: int, end_millis: int, page_size: int, max_records: int):
    """
    Fetch Watcher Alerts from Intel 471 Titan API with pagination and rate limiting.

    Args:
        email: Intel 471 account email
        api_key: Intel 471 API key
        start_millis: Start time in Unix epoch milliseconds
        end_millis: End time in Unix epoch milliseconds
        page_size: Number of records per page (max 100)
        max_records: Maximum total records to fetch

    Returns:
        Tuple of (records list, newest_event_time ISO string)
    """
    endpoint = f"{API_BASE}/alerts"

    # Build Basic Auth header
    auth_string = f"{email}:{api_key}"
    auth_bytes = auth_string.encode('utf-8')
    auth_b64 = base64.b64encode(auth_bytes).decode('utf-8')

    headers = {
        'Authorization': f'Basic {auth_b64}',
        'Accept': 'application/json',
        'User-Agent': 'GoogleSecOps-Intel471Collector/1.0'
    }

    records = []
    newest_time = None
    page_num = 0
    backoff = 1.0
    offset = 0

    while True:
        page_num += 1

        if len(records) >= max_records:
            print(f"Reached max_records limit ({max_records})")
            break

        # Build request URL with pagination and time filtering
        current_page_size = min(page_size, max_records - len(records))
        params = []
        params.append(f"count={current_page_size}")
        params.append(f"offset={offset}")
        params.append(f"from={start_millis}")
        params.append(f"until={end_millis}")
        url = f"{endpoint}?{'&'.join(params)}"

        try:
            response = http.request('GET', url, headers=headers)

            # Handle rate limiting with exponential backoff
            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, 60.0)
                continue

            backoff = 1.0

            if response.status != 200:
                print(f"HTTP Error: {response.status}")
                response_text = response.data.decode('utf-8')
                print(f"Response body: {response_text}")
                return [], None

            data = json.loads(response.data.decode('utf-8'))

            # Extract results from alerts
            page_results = data.get('alerts', [])

            if not page_results:
                print(f"No more results (empty page)")
                break

            print(f"Page {page_num}: Retrieved {len(page_results)} alerts")
            records.extend(page_results)

            # Track newest event time using foundTime (Unix milliseconds)
            for alert in page_results:
                try:
                    found_time_ms = alert.get('foundTime')
                    if found_time_ms:
                        event_dt = datetime.fromtimestamp(found_time_ms / 1000, tz=timezone.utc)
                        event_time = event_dt.isoformat()
                        if newest_time is None or parse_datetime(event_time) > parse_datetime(newest_time):
                            newest_time = event_time
                except Exception as e:
                    print(f"Warning: Could not parse event time: {e}")

            # Check for more results
            alert_total = data.get('alertTotalCount', 0)
            if len(records) >= alert_total:
                print(f"Retrieved all available alerts ({alert_total} total)")
                break

            if len(page_results) < current_page_size:
                print(f"Reached last page (size={len(page_results)} < limit={current_page_size})")
                break

            offset += len(page_results)

        except Exception as e:
            print(f"Error fetching alerts: {e}")
            return [], None

    print(f"Retrieved {len(records)} total records from {page_num} pages")
    return records, newest_time

    • 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).

Buat tugas Cloud Scheduler

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

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

  3. Berikan detail konfigurasi berikut:

    Setelan Nilai
    Nama intel471-alerts-collector-hourly
    Region 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 Pub/Sub (misalnya, intel471-alerts-trigger)
    Isi pesan {} (objek JSON kosong)

  4. Klik Create.

Opsi frekuensi jadwal

Pilih frekuensi berdasarkan volume pemberitahuan 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 integrasi

  1. Di konsol Cloud Scheduler, temukan tugas Anda (misalnya, intel471-alerts-collector-hourly).
  2. Klik Force run untuk memicu tugas secara manual.
  3. Tunggu beberapa detik.
  4. Buka Cloud Run > Services.
  5. Klik nama fungsi Anda (misalnya, intel471-alerts-collector).
  6. Klik tab Logs.

  7. Pastikan fungsi berhasil dieksekusi. Cari:

    Fetching alerts from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X alerts
Wrote X records to gs://bucket-name/intel471-alerts/alerts_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Buka Cloud Storage > Buckets.

  9. Klik nama bucket Anda (misalnya, intel471-watcher-alerts-logs).

  10. Buka folder awalan (misalnya, intel471-alerts/).

  11. Pastikan file .ndjson baru telah dibuat dengan stempel waktu saat ini.

Jika Anda melihat error dalam log:

  • HTTP 401: Periksa email dan kunci API Intel 471 di variabel lingkungan
  • HTTP 403: Memverifikasi bahwa akun memiliki izin Watcher Alerts
  • HTTP 429: Pembatasan kecepatan - fungsi akan otomatis mencoba lagi dengan penundaan
  • Variabel lingkungan tidak ada: Pastikan semua variabel yang diperlukan telah ditetapkan

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

  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, Intel 471 Watcher Alerts).
  5. Pilih Google Cloud Storage V2 sebagai Source type.
  6. Pilih Intel 471 Watcher Alerts sebagai Log type.

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

    secops-12345678@secops-gcp-prod.iam.gserviceaccount.com

  8. Salin alamat email ini untuk digunakan di langkah berikutnya.

  9. Klik Berikutnya.

  10. Tentukan nilai untuk parameter input berikut:

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

      gs://intel471-watcher-alerts-logs/intel471-alerts/

      Ganti:

      • intel471-watcher-alerts-logs: Nama bucket GCS Anda.
      • intel471-alerts: Jalur folder/awalan tempat log pemberitahuan disimpan.

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

      • Never: Tidak pernah menghapus file apa pun setelah transfer (direkomendasikan untuk pengujian).
      • Delete transferred files: Menghapus file setelah transfer berhasil.
      • Hapus file yang ditransfer dan direktori kosong: Menghapus file dan direktori kosong setelah transfer berhasil.

    • Maximum File Age: Sertakan file yang diubah dalam jumlah 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 berita baru Anda di layar Finalize, lalu klik Submit.

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 (misalnya, intel471-watcher-alerts-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.

Tabel pemetaan UDM

Kolom log Pemetaan UDM Logika
post.links.forum.uid additional.fields Kolom metadata tambahan yang tidak tercakup dalam kolom UDM standar
post.links.forum.name additional.fields
post.links.thread.uid additional.fields
post.links.thread.topic additional.fields
post.links.thread.count additional.fields
post.uid additional.fields
post.message additional.fields
highlight.field additional.fields
chunk.text additional.fields
chunk.hl additional.fields
actor.links.forumTotalCount additional.fields
actor.links.forumPrivateMessageTotalCount additional.fields
actor.links.instantMessageChannelTotalCount additional.fields
actor.links.reportTotalCount additional.fields
actor.links.instantMessageTotalCount additional.fields
actor.links.instantMessageServerTotalCount additional.fields
actor.links.forumPostTotalCount additional.fields
actor.lastUpdated additional.fields
actor.activeFrom additional.fields
actor.activeUntil additional.fields
data_leak_post.chunk_number additional.fields
data_leak_post.links.blog.uid additional.fields
data_leak_post.links.blog.name additional.fields
data_leak_post.links.thread.uid additional.fields
data_leak_post.links.thread.topic additional.fields
data_leak_post.links.thread.count additional.fields
data_leak_post.message additional.fields
actor.links.reports[].uid additional.fields
actor.links.reports[].admiraltyCode additional.fields
actor.links.reports[].dateOfInformation additional.fields
status additional.fields
watcherUid additional.fields
watcherGroupUid additional.fields
report.uid additional.fields
report.admiraltyCode additional.fields
foundTime additional.fields
instantMessage.data.message.text additional.fields
instantMessage.data.message.uid additional.fields
instantMessage.data.channel.name additional.fields
instantMessage.data.channel.uid additional.fields
instantMessage.data.channel.url additional.fields
instantMessage.data.channel.registration_date additional.fields
instantMessage.data.channel.topic additional.fields
instantMessage.data.server.uid additional.fields
instantMessage.data.server.service_type additional.fields
post.links.forum.description metadata.description Deskripsi acara atau entitas
actor.links.reports[].subject metadata.description
report.subject metadata.description
report.released metadata.event_timestamp Stempel waktu peristiwa
metadata.event_type metadata.event_type Jenis peristiwa (misalnya, USER_LOGIN, NETWORK_CONNECTION)
uid metadata.product_log_id ID log dari produk
data_leak_post.file_listing.download_url principal.url URL yang terkait dengan prinsipal
actor.links.reports[].portalReportUrl principal.url
report.portalReportUrl principal.url
post.links.authorActor.handle principal.user.attribute.labels Atribut pengguna
actor.links.reports[].actorHandle principal.user.attribute.labels
instantMessage.data.actor.handle principal.user.attribute.labels
post.links.authorActor.uid principal.user.userid ID Pengguna
actor.uid principal.user.userid
data_leak_post.uid principal.user.userid
instantMessage.data.actor.uid principal.user.userid
report.uid event.idm.read_only_udm.metadata.additional.fields Dipetakan dari log perubahan
report.admiraltyCode event.idm.read_only_udm.metadata.additional.fields Dipetakan dari log perubahan
report.subject event.idm.read_only_udm.metadata.description Dipetakan dari log perubahan
report.portalReportUrl event.idm.read_only_udm.principal.url Dipetakan dari log perubahan
report.released event.idm.read_only_udm.metadata.event_timestamp Dipetakan dari log perubahan
post.links.forum.description" and "actor.links.reports.subject metadata.description Dipetakan dari log perubahan
post.links.authorActor.uid", "data_leak_post.uid" and "actor.uid principal.user.userid Dipetakan dari log perubahan
post.links.authorActor.handle" and "actor.links.reports.actorHandle principal.user.attribute.labels Dipetakan dari log perubahan
data_leak_post.file_listing.download_url" and "actor.links.reports.portalReportUrl principal.url Dipetakan dari log perubahan
post.links.forum.uid", "post.links.forum.name", "post.links.thread.uid", "post.links.thread.topic", "post.links.thread.count", "post.uid", "post.message", "highlights.field", "highlights.chunks.text", "highlights.chunks.hl", "actor.links.forumTotalCount", "actor.links.forumPrivateMessageTotalCount", "actor.links.instantMessageChannelTotalCount", "actor.links.reportTotalCount", "actor.links.instantMessageTotalCount", "actor.links.instantMessageServerTotalCount", "actor.links.forumPostTotalCount", "actor.lastUpdated", "actor.activeFrom", "actor.activeUntil", "data_leak_post.chunk_number", "data_leak_post.links.blog.uid", "data_leak_post.links.blog.name", "data_leak_post.links.thread.uid", "data_leak_post.links.thread.topic", "data_leak_post.links.thread.count", "data_leak_post.message", "actor.links.reports.uid", "actor.links.reports.admiraltyCode", "actor.links.reports.dateOfInformation additional.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.