Mengumpulkan log Audit Tenable

Didukung di:

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

Tenable Vulnerability Management (sebelumnya Tenable.io) adalah platform manajemen kerentanan berbasis cloud (cloud.tenable.com) yang log aktivitasnya mencatat autentikasi pengguna, akses API, perubahan konfigurasi, dan tindakan administratif. Tenable Vulnerability Management REST API menyediakan akses terprogram ke peristiwa log aktivitas ini.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

  • Instance Google SecOps
  • Project Google Cloud dengan Cloud Storage API diaktifkan
  • Izin untuk membuat dan mengelola bucket Cloud Storage
  • Izin untuk mengelola kebijakan Identity and Access Management (IAM) pada bucket Cloud Storage
  • Izin untuk membuat layanan Cloud Run, topik Pub/Sub, dan tugas Cloud Scheduler
  • Akses istimewa ke Tenable Vulnerability Management (cloud.tenable.com) dengan peran Administrator
  • Kunci API Tenable Vulnerability Management (kunci akses dan kunci rahasia) yang dibuat di akun pengguna dengan peran Administrator

Membuat bucket 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, tenable-audit-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)
    Kontrol akses Seragam (direkomendasikan)
    Alat perlindungan Opsional: Aktifkan pembuatan versi objek atau kebijakan retensi

  6. Klik Create.

Mengumpulkan kredensial Tenable Vulnerability Management API

Membuat kunci API

  1. Login ke Tenable Vulnerability Management.
  2. Di sudut kanan atas halaman mana pun, klik lingkaran pengguna berwarna biru, lalu klik Profil Saya. Halaman Akun Saya akan muncul.
  3. Buka tab API Keys.

  4. Klik Generate. Jendela Generate API Keys akan muncul dengan peringatan.

    "Perhatian: Membuat kunci akan menggantikan kunci API yang ada di akun pengguna ini, termasuk kunci yang sudah digunakan oleh integrasi lain. Gunakan akun pengguna khusus untuk integrasi ini, atau perbarui setiap aplikasi yang menggunakan kunci sebelumnya."

  5. Tinjau peringatan, lalu klik Buat.

  6. Salin dan simpan detail berikut di lokasi yang aman:

    • Kunci Akses: Kunci akses API
    • Secret Key: Kunci rahasia API

Memverifikasi akses API

  • Uji kredensial Anda sebelum melanjutkan integrasi:

    # Replace with your actual credentials
ACCESS_KEY="your-access-key"
SECRET_KEY="your-secret-key"

curl -s -H "X-ApiKeys: accessKey=${ACCESS_KEY};secretKey=${SECRET_KEY}" \
    "https://cloud.tenable.com/audit-log/v1/events?limit=1" | head -c 500

Memverifikasi izin

Untuk memverifikasi bahwa akun memiliki izin yang diperlukan:

  1. Login ke Tenable Vulnerability Management.
  2. Di navigasi sebelah kiri, klik Setelan.
  3. Klik kartu Access Control.
  4. Klik tab Pengguna, lalu klik akun pengguna yang digunakan untuk integrasi ini.

  5. Pastikan akun memiliki peran Administrator. Endpoint log aktivitas memerlukan peran pengguna Administrator: tidak ada peran kustom yang memberikan akses ke log aktivitas, dan peran lainnya akan menerima respons HTTP 403.

  6. Jika Anda tidak memiliki izin yang diperlukan, hubungi administrator Tenable Vulnerability Management Anda.

Buat akun layanan untuk fungsi Cloud Run

Fungsi Cloud Run memerlukan akun layanan dengan izin untuk menulis ke bucket Cloud Storage 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 tenable-audit-collector-sa
    • Deskripsi akun layanan: Masukkan Service account for Cloud Run function to collect Tenable Audit 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 Cloud Storage dan mengelola file status
  • Cloud Run Invoker: Mengizinkan Pub/Sub memanggil fungsi
  • Cloud Functions Invoker: Mengizinkan pemanggilan fungsi

Memberikan izin IAM pada bucket Cloud Storage

Beri akun layanan izin tulis di bucket Cloud Storage:

  1. Buka Cloud Storage > Buckets.
  2. Klik nama bucket Anda (misalnya, tenable-audit-logs).
  3. Buka tab Izin.
  4. Klik Grant access.
  5. Berikan detail konfigurasi berikut:
    • Tambahkan prinsipal: Masukkan email akun layanan (misalnya, tenable-audit-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 tenable-audit-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 log dari Tenable Vulnerability Management REST API dan menuliskannya ke Cloud Storage.

  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 tenable-audit-collector
    Region Pilih region yang cocok dengan bucket Cloud Storage 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 tenable-audit-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:

    • Akun layanan: Pilih akun layanan tenable-audit-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 tenable-audit-logs Nama bucket Cloud Storage
    GCS_PREFIX tenable Awalan untuk file log
    STATE_KEY tenable-state.json Jalur status, di luar awalan log
    TENABLE_ACCESS_KEY your-access-key Kunci akses Tenable Vulnerability Management
    TENABLE_SECRET_KEY your-secret-key Kunci rahasia Tenable Vulnerability Management
    MAX_RECORDS 5000 Jumlah data maks per proses
    PAGE_SIZE 1000 Data per halaman
    LOOKBACK_HOURS 24 Periode lihat balik awal
    OVERLAP_MINUTES 2 Menit yang dibaca ulang sebelum tanda air untuk mendapatkan peristiwa yang diindeks terlambat

  10. Di bagian Variables & Secrets, buka Requests:

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

  11. Buka tab Setelan:

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

  12. Di bagian Penskalaan revisi:

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

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

Tambahkan kode fungsi

  1. Masukkan main di kolom Entry point.

  2. Di editor kode inline, buat dua file:

    • File pertama - main.py:
    import functions_framework
from google.cloud import storage
from google.cloud.exceptions import NotFound
import json
import os
import re
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', 'tenable')
# STATE_KEY must stay OUTSIDE GCS_PREFIX. The feed ingests every object under
# its bucket URI and, with a deletion option selected, deletes what it
# transferred. A state file inside the prefix would be ingested as log data and
# then deleted, resetting collection and re-ingesting duplicates.
STATE_KEY = os.environ.get('STATE_KEY', 'tenable-state.json')
TENABLE_ACCESS_KEY = os.environ.get('TENABLE_ACCESS_KEY')
TENABLE_SECRET_KEY = os.environ.get('TENABLE_SECRET_KEY')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))
# The audit-log API accepts a limit up to 10000.
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
# The query re-reads this many minutes before the watermark so that events
# Tenable indexes late are still collected. Re-read events are dropped by id.
OVERLAP_MINUTES = int(os.environ.get('OVERLAP_MINUTES', '2'))

TENABLE_API_BASE = 'https://cloud.tenable.com'

class FetchError(Exception):
  """Raised when the Tenable API call fails.

  The watermark must never advance on a failed fetch, otherwise every event in
  the failed window is skipped permanently.
  """

def parse_datetime(value: str) -> datetime:
  """Parse a Tenable `received` timestamp into an aware datetime.

  Tenable returns ISO 8601 with either whole seconds (2018-12-31T23:09:40Z) or
  fractional seconds (2024-01-16T15:12:47.334Z). Fractional digits are trimmed
  to microseconds because fromisoformat accepts at most six.
  """
  text = str(value).strip()
  if text.endswith('Z'):
    text = text[:-1] + '+00:00'
  text = re.sub(r'\.(\d{6})\d+', r'.\1', text)
  dt = datetime.fromisoformat(text)
  if dt.tzinfo is None:
    dt = dt.replace(tzinfo=timezone.utc)
  return dt.astimezone(timezone.utc)

@functions_framework.cloud_event
def main(cloud_event):
  """Fetch Tenable Vulnerability Management activity log events and write them to Cloud Storage.

  Args:
    cloud_event: CloudEvent object containing the Pub/Sub message.
  """
  if not all([GCS_BUCKET, TENABLE_ACCESS_KEY, TENABLE_SECRET_KEY]):
    # Raise rather than return: a bare return acks the Pub/Sub message and
    # reports the run as successful, silently discarding the schedule tick.
    raise RuntimeError('Missing required environment variables')

  bucket = storage_client.bucket(GCS_BUCKET)
  state = load_state(bucket, STATE_KEY)

  now = datetime.now(timezone.utc)
  watermark = None
  if state.get('last_event_time'):
    watermark = parse_datetime(state['last_event_time'])
  seen_ids = set(state.get('seen_ids', []))

  if watermark is None:
    start_time = now - timedelta(hours=LOOKBACK_HOURS)
  else:
    start_time = watermark - timedelta(minutes=OVERLAP_MINUTES)

  print(f"Fetching logs from {start_time.isoformat()} to {now.isoformat()}")

  # A FetchError propagates: the run fails, the watermark is untouched, and the
  # next invocation retries the same window.
  records, newest_event_time = fetch_logs(
    start_time=start_time,
    page_size=PAGE_SIZE,
    max_records=MAX_RECORDS,
  )

  # Drop events already written by an earlier run. Without this the overlap
  # window re-emits its events on every invocation, and an idle tenant has its
  # newest events rewritten to a new object every hour.
  fresh = [r for r in records if str(r.get('id', '')) not in seen_ids]
  print(f"Fetched {len(records)} records, {len(fresh)} new after deduplication")

  if not fresh:
    print("No new log records found. Watermark left unchanged.")
    return

  if not newest_event_time:
    raise FetchError('Records were returned but no `received` timestamp could be parsed')

  timestamp = now.strftime('%Y%m%dT%H%M%SZ')
  object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
  blob = bucket.blob(object_key)

  ndjson = '\n'.join(json.dumps(record, ensure_ascii=False) for record in fresh) + '\n'
  blob.upload_from_string(ndjson, content_type='application/x-ndjson')

  print(f"Wrote {len(fresh)} records to gs://{GCS_BUCKET}/{object_key}")

  # Advance the watermark only after the data is durably written.
  new_watermark = parse_datetime(newest_event_time)
  if watermark and new_watermark < watermark:
    new_watermark = watermark

  # Retain only the ids still inside the overlap window, so the state file
  # stays small while covering every event the next query can re-read.
  cutoff = new_watermark - timedelta(minutes=OVERLAP_MINUTES)
  retained = []
  for record in records:
    received = record.get('received')
    if not received:
      continue
    try:
      if parse_datetime(received) >= cutoff:
        retained.append(str(record.get('id', '')))
    except ValueError:
      continue

  save_state(bucket, STATE_KEY, {
    'last_event_time': new_watermark.isoformat(),
    'seen_ids': sorted(i for i in set(retained) if i),
  })

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

def load_state(bucket, key):
  """Read the collector state from Cloud Storage.

  Only a missing object is treated as a cold start. Any other error is raised:
  swallowing it would silently reset collection to the full lookback window and
  re-ingest that entire period.
  """
  blob = bucket.blob(key)
  try:
    return json.loads(blob.download_as_text())
  except NotFound:
    print('No state file found. Starting from the lookback window.')
    return {}

def save_state(bucket, key, state: dict):
  """Write the collector state to Cloud Storage.

  Failures are raised, not logged. If the state write fails after the data was
  uploaded, the next run repeats the same window and duplicates it.
  """
  blob = bucket.blob(key)
  blob.upload_from_string(
    json.dumps(state, indent=2),
    content_type='application/json',
  )
  print(f"Saved state: last_event_time={state.get('last_event_time')}")

def fetch_logs(start_time: datetime, page_size: int, max_records: int):
  """Fetch audit events from the Tenable Vulnerability Management API.

  Uses offset pagination, which is what the endpoint documents: the request
  accepts `limit` (maximum 10000) and `offset`, and the response `pagination`
  object returns `offset`, `limit`, `count` and `total`.

  Args:
    start_time: Exclusive lower bound for the `received` timestamp
    page_size: Records per page (the API accepts up to 10000)
    max_records: Maximum total records to fetch in one run

  Returns:
    Tuple of (records list, newest `received` value as an ISO 8601 string).

  Raises:
    FetchError: on any API or transport failure, so the caller cannot mistake
      a failed fetch for an empty result and advance the watermark.
  """
  endpoint = f"{TENABLE_API_BASE}/audit-log/v1/events"

  headers = {
    'X-ApiKeys': f'accessKey={TENABLE_ACCESS_KEY};secretKey={TENABLE_SECRET_KEY}',
    'Accept': 'application/json',
    'User-Agent': 'GoogleSecOps-TenableAuditCollector/1.0'
  }

  records = []
  newest_time = None
  page_num = 0
  backoff = 1.0
  rate_limit_retries = 0
  MAX_RATE_LIMIT_RETRIES = 5
  offset = 0

  while True:
    page_num += 1

    if len(records) >= max_records:
      # Stop cleanly. The remaining events stay ahead of the watermark and
      # are collected by the next run.
      print(f"Reached max_records limit ({max_records})")
      break

    # Every parameter is rebuilt per page. `sort=received:asc` is required:
    # a time watermark is only correct over an ascending scan, otherwise a
    # truncated run advances the watermark past events it never read.
    params = {
      'f': f'date.gt:{start_time.strftime("%Y-%m-%dT%H:%M:%SZ")}',
      'sort': 'received:asc',
      'limit': min(page_size, max_records - len(records)),
      'offset': offset,
    }
    url = f"{endpoint}?" + '&'.join(f"{k}={v}" for k, v in params.items())

    try:
      response = http.request('GET', url, headers=headers)
    except Exception as e:
      raise FetchError(f'Request to {endpoint} failed: {e}') from e

    if response.status == 429:
      rate_limit_retries += 1
      if rate_limit_retries > MAX_RATE_LIMIT_RETRIES:
        raise FetchError('Rate limited repeatedly; giving up without advancing the watermark')
      raw_retry_after = response.headers.get('Retry-After')
      try:
        # Retry-After may also be an HTTP date, which int() cannot parse.
        retry_after = int(raw_retry_after) if raw_retry_after else int(backoff)
      except (TypeError, ValueError):
        retry_after = int(backoff)
      print(f"Rate limited (429). Retrying after {retry_after}s...")
      time.sleep(retry_after)
      backoff = min(backoff * 2, 30.0)
      continue

    backoff = 1.0
    rate_limit_retries = 0

    if response.status != 200:
      body = response.data.decode('utf-8')
      raise FetchError(f'HTTP {response.status} from the Tenable audit log API: {body}')

    try:
      data = json.loads(response.data.decode('utf-8'))
    except json.JSONDecodeError as e:
      raise FetchError(f'Malformed JSON response from the Tenable audit log API: {e}') from e

    page_results = data.get('events', [])

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

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

    for event in page_results:
      received = event.get('received')
      if not received:
        continue
      try:
        if newest_time is None or parse_datetime(received) > parse_datetime(newest_time):
          newest_time = received
      except ValueError as e:
        print(f"Warning: Could not parse event time {received!r}: {e}")

    offset += len(page_results)
    total = data.get('pagination', {}).get('total')
    if total is not None and offset >= total:
      print("No more pages (all matching events retrieved)")
      break

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

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

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 tenable-audit-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 tenable-audit-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 (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.
  2. Klik Force run untuk memicu tugas secara manual.
  3. Tunggu beberapa detik.
  4. Buka Cloud Run > Services.
  5. Klik tenable-audit-collector.
  6. Klik tab Logs.

  7. Pastikan fungsi berhasil dieksekusi. Cari:

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X events
Fetched X records, Y new after deduplication
Wrote Y records to gs://tenable-audit-logs/tenable/logs_YYYYMMDDTHHMMSSZ.ndjson
Saved state: last_event_time=YYYY-MM-DDTHH:MM:SS+00:00
Successfully processed Y records

  8. Buka Cloud Storage > Buckets.

  9. Klik nama bucket Anda (tenable-audit-logs).

  10. Buka folder tenable/.

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

Saat tidak ada yang baru, fungsi mencatat No new log records found. Watermark left unchanged. dan tidak menulis objek. Hal ini sudah diperkirakan: menulis ulang peristiwa yang sama akan menduplikasi peristiwa tersebut di Google SecOps.

Jika Anda melihat error dalam log:

  • HTTP 401: Periksa kunci API dalam variabel lingkungan
  • HTTP 403: Akun bukan Administrator. Endpoint log aktivitas memerlukan peran pengguna Administrator [64].
  • HTTP 429: Pembatasan kecepatan. Fungsi mencoba ulang dengan backoff, lalu gagal menjalankan tanpa memajukan tanda airnya, sehingga tidak ada peristiwa yang dilewati.
  • Variabel lingkungan tidak ada: Pastikan semua variabel yang diperlukan telah ditetapkan

Mengonfigurasi feed di Google SecOps untuk menyerap log Tenable Audit

  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, Tenable Audit Logs).
  5. Pilih Google Cloud Storage V2 sebagai Source type.
  6. Pilih Tenable Audit sebagai Log type.

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

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

  8. Salin alamat email ini.

  9. Klik Berikutnya.

  10. Tentukan nilai untuk parameter input berikut:

    • URL bucket penyimpanan: Masukkan URI bucket Cloud Storage dengan jalur awalan:

      gs://tenable-audit-logs/tenable/
      • Ganti:
        • tenable-audit-logs: Nama bucket Cloud Storage Anda.
        • tenable: Awalan/jalur folder opsional tempat log disimpan (biarkan kosong untuk root).

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

      • Jangan pernah menghapus file: Jangan pernah menghapus file dari sumber (direkomendasikan untuk pengujian).

      • Hapus file yang ditransfer dan direktori kosong: Menghapus file dan direktori kosong dari sumber setelah pengambilan yang berhasil selesai.

    • Usia File Maksimum: Menyertakan file yang diubah dalam beberapa hari terakhir (default 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 dua peran di bucket Cloud Storage Anda: Storage Object Viewer untuk membaca objek log, dan peran tingkat bucket untuk membaca metadata bucket.

  1. Buka Cloud Storage > Buckets.
  2. Klik nama bucket Anda.
  3. Buka tab Izin.
  4. Klik Grant access.
  5. Berikan detail konfigurasi berikut:
    • Add principals: Tempel email akun layanan Google SecOps
    • Tetapkan peran: Pilih kedua opsi berikut:
      • Storage Object Viewer: membaca objek log.
      • Storage Legacy Bucket Reader: membaca metadata bucket. Jika Anda memilih opsi penghapusan Hapus file yang ditransfer dan direktori kosong, pilih Storage Legacy Bucket Writer, yang juga memberikan izin penghapusan.
  6. Klik Simpan.

Tabel pemetaan UDM

Kolom Log Pemetaan UDM Logika
crud_label additional.fields Digabung
fields_label additional.fields Digabung
field_name extensions.auth.mechanism Dipetakan: X-Access-Type → mech_label
mech_label extensions.auth.mechanism Digabung
extension_value extensions.auth.type Dipetakan secara langsung
description metadata.description Dipetakan secara langsung
received metadata.event_timestamp Diuraikan sebagai ISO8601
has_principal metadata.event_type Nilai yang dipetakan (total 5, misalnya true → USER_LOGIN, true → USER_CREATION, true → `USER...
has_user metadata.event_type Dipetakan: true → USER_UNCATEGORIZED
action metadata.product_event_type Dipetakan secara langsung
id metadata.product_log_id Dipetakan secara langsung
field_name principal.asset.ip Dipetakan: X-Forwarded-For → ip
ip principal.asset.ip Digabung
field_name principal.ip Dipetakan: X-Forwarded-For → ip
ip principal.ip Digabung
actor.name principal.user.email_addresses Digabung
actor.id principal.user.userid Dipetakan secara langsung
AUTH_VIOLOATION security_result.category Digabung
is_failure security_result.category Dipetakan: true → AUTH_VIOLOATION
is_anonymous_label security_result.detection_fields Digabung
is_failure_label security_result.detection_fields Digabung
target1.name target.user.email_addresses Digabung
target1.type target.user.role_name Dipetakan secara langsung
target1.id target.user.userid Dipetakan secara langsung
T/A extensions.auth.type Konstanta: AUTHTYPE_UNSPECIFIED
T/A metadata.event_type Konstanta: USER_LOGIN
T/A metadata.product_name Konstanta: TENABLE AUDIT
T/A metadata.vendor_name Konstanta: TENABLE

Log Perubahan

Melihat Log Perubahan untuk parser ini

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