Mengumpulkan log audit Lucid

Didukung di:

Google SecOps SIEM

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

Lucid Software menyediakan rangkaian kolaborasi visual yang mencakup Lucidchart, Lucidspark, dan Lucidscale. Audit Logs API, yang tersedia secara eksklusif untuk pelanggan Enterprise Shield, mencatat peristiwa keamanan dan kepatuhan di seluruh organisasi, termasuk akses akun, aktivitas dokumen, pengelolaan pengguna, tindakan admin, dan operasi tim.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

• Instance Google SecOps
• Project GCP dengan Cloud Storage API diaktifkan
• Izin untuk membuat dan mengelola bucket GCS
• Izin untuk mengelola kebijakan IAM di bucket GCS
• Izin untuk membuat layanan Cloud Run, topik Pub/Sub, dan tugas Cloud Scheduler
• Akun Lucid Enterprise Shield dengan hak istimewa admin atau pemilik akun
• Akses ke Lucid Developer Portal dengan alat developer yang diaktifkan

Mengaktifkan alat developer di Lucid

Sebelum membuat kredensial API, Anda harus memiliki akses ke Lucid Developer Portal. Ada dua cara untuk mengaktifkan alat developer:

Opsi 1: Aktifkan melalui setelan pengguna

1. Login ke lucid.app.
2. Klik ikon profil Anda di sudut kanan atas.
3. Pilih Setelan Akun.

4. Centang kotak Aktifkan alat developer.

   Catatan: Kotak centang ini mungkin dinonaktifkan oleh admin Lucid Anda. Jika dinonaktifkan, gunakan Opsi 2.

Opsi 2: Aktifkan melalui penetapan peran admin

1. Login ke lucid.app sebagai pemilik akun atau admin tim.
2. Buka panel admin.
3. Buka bagian Pengguna.
4. Pilih pengguna target.

5. Edit peran pengguna dan tetapkan peran Developer.

   Catatan: Pemberian peran developer akan membuka kunci alat developer untuk pengguna tersebut, meskipun mereka belum mengaktifkan fitur developer di setelan pengguna mereka.

Mengonfigurasi akses Lucid API

Untuk mengizinkan Google SecOps mengambil log audit, Anda harus membuat klien OAuth 2.0 dan membuat token akses tingkat akun dengan cakupan account.audit.logs.

Membuat aplikasi dan klien OAuth 2.0

1. Buka Lucid Developer Portal.
2. Klik Create Application.
3. Masukkan nama aplikasi Anda (misalnya, Chronicle SIEM Integration).
4. Klik aplikasi yang baru dibuat untuk mengakses setelannya.
5. Buka tab OAuth 2.0.

6. Masukkan nama untuk klien OAuth 2.0 Anda (misalnya, Chronicle Audit Log Collector).

   Catatan: Nama klien OAuth 2.0 dapat dilihat secara publik saat pengguna memberikan akses dan tidak dapat diubah setelah dibuat.

7. Klik Create OAuth 2.0 client.

Mencatat kredensial klien

Setelah membuat klien OAuth 2.0, portal akan menampilkan kredensial Anda:

• Client ID: ID klien unik Anda.
• Rahasia Klien: Kunci rahasia API Anda.

Penting: Segera salin dan simpan rahasia klien. Jika rahasia klien disusupi, klik tombol Reset Client Secret di halaman setelan OAuth 2.0. Mereset secret akan segera mencabut akses hingga secret baru diperbarui dalam integrasi Anda.

Mendaftarkan URI pengalihan

1. Di halaman setelan OAuth 2.0, klik Tambahkan URI Pengalihan.

2. Masukkan URI pengalihan untuk integrasi Anda. Jika menggunakan pengalihan pengujian yang disediakan Lucid, masukkan:

   https://lucid.app/oauth2/clients/<CLIENT_ID>/redirect
   

   Ganti <CLIENT_ID> dengan ID klien Anda yang sebenarnya.

Mendapatkan token akses tingkat akun

Audit Logs API memerlukan token akun (bukan token pengguna). Admin akun harus mengizinkan klien OAuth 2.0 untuk membuat token atas nama akun.

1. Arahkan admin akun ke URL otorisasi berikut di browser:

   https://lucid.app/oauth2/authorizeAccount?client_id=<CLIENT_ID>&redirect_uri=<REDIRECT_URI>&scope=account.audit.logs
   

   Ganti <CLIENT_ID> dan <REDIRECT_URI> dengan nilai sebenarnya.

2. Admin meninjau izin yang diminta di layar izin dan mengklik Izinkan.

3. Lucid mengalihkan ke URI pengalihan dengan parameter kueri otorisasi code.

4. Tukarkan kode otorisasi dengan token akses dengan membuat permintaan POST ke endpoint token:

   curl --request POST \
     --url https://api.lucid.co/oauth2/token \
     --header 'Content-Type: application/json' \
     --data '{
       "grant_type": "authorization_code",
       "client_id": "<CLIENT_ID>",
       "client_secret": "<CLIENT_SECRET>",
       "code": "<AUTHORIZATION_CODE>",
       "redirect_uri": "<REDIRECT_URI>"
     }'
   

5. Respons mencakup access_token dan refresh_token. Catat kedua nilai dengan aman.

   Catatan: Kode otorisasi berlaku selama dua menit. Segera tukarkan.

Memverifikasi akses API

• Pastikan token akses berfungsi dengan membuat permintaan pengujian:

  curl --request GET \
    --url 'https://api.lucid.co/auditLogs?pageSize=1' \
    --header 'Authorization: Bearer <ACCESS_TOKEN>' \
    --header 'Lucid-Api-Version: 1' \
    --header 'Accept: application/json'
  

Respons yang berhasil akan menampilkan array JSON peristiwa log audit.

Izin API yang diperlukan

• Klien OAuth 2.0 memerlukan cakupan berikut:

  Cakupan	Jenis Token	Tujuan
  account.audit.logs	Akun	Mengambil peristiwa log audit untuk akun

  Catatan: Hanya akses baca yang diperlukan. Cakupan account.audit.logs berlaku untuk Token akun dan Token pengguna, tetapi Token akun direkomendasikan untuk integrasi SIEM karena tidak terikat dengan sesi pengguna tertentu.

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
   Beri nama bucket Anda	Masukkan nama yang unik secara global (misalnya, lucid-audit-logs-gcs)
   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.

Buat akun layanan untuk fungsi Cloud Run

1. Di Konsol GCP, buka IAM & Admin > Service Accounts.
2. Klik Create Service Account.
3. Berikan detail konfigurasi berikut:
   • Nama akun layanan: Masukkan lucid-audit-collector-sa
   • Deskripsi akun layanan: Masukkan Service account for Cloud Run function to collect Lucid 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.

Memberikan izin IAM pada bucket GCS

1. Buka Cloud Storage > Buckets.
2. Klik nama bucket Anda (lucid-audit-logs-gcs).
3. Buka tab Izin.
4. Klik Grant access.
5. Berikan detail konfigurasi berikut:
   • Tambahkan prinsipal: Masukkan email akun layanan (lucid-audit-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
   • Menetapkan peran: Pilih Storage Object Admin
6. Klik Simpan.

Membuat topik Pub/Sub

1. Di Konsol GCP, buka Pub/Sub > Topics.
2. Klik Create topic.
3. Berikan detail konfigurasi berikut:
   • ID Topik: Masukkan lucid-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 Lucid Audit Logs API dan menuliskannya ke GCS.

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

4. Di bagian Konfigurasi, berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama layanan	lucid-audit-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 lucid-audit-trigger.
   4. Klik Simpan.

6. Di bagian Authentication:

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

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

8. Buka tab Security:

   • Akun layanan: Pilih lucid-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	lucid-audit-logs-gcs	Nama bucket GCS
   GCS_PREFIX	lucid-audit	Awalan untuk file log
   STATE_KEY	lucid-audit/state.json	Jalur file status
   LUCID_CLIENT_ID	your-oauth-client-id	ID Klien OAuth 2.0 Lucid
   LUCID_CLIENT_SECRET	your-oauth-client-secret	Rahasia Klien OAuth 2.0 Lucid
   LUCID_REFRESH_TOKEN	your-refresh-token	Token Refresh OAuth 2.0 Lucid
   LOOKBACK_HOURS	24	Periode lihat balik awal
   PAGE_SIZE	200	Jumlah data per halaman API (maks. 200)
   MAX_PAGES	50	Halaman maksimum per proses

10. Di bagian Variables & Secrets, scroll ke bawah ke 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

13. Klik Create.

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

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

Menambahkan kode fungsi

1. Masukkan main di 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 re
  
  http = urllib3.PoolManager(
      timeout=urllib3.Timeout(connect=10.0, read=60.0),
      retries=False,
  )
  
  storage_client = storage.Client()
  
  GCS_BUCKET = os.environ.get('GCS_BUCKET')
  GCS_PREFIX = os.environ.get('GCS_PREFIX', 'lucid-audit')
  STATE_KEY = os.environ.get('STATE_KEY', 'lucid-audit/state.json')
  LUCID_CLIENT_ID = os.environ.get('LUCID_CLIENT_ID')
  LUCID_CLIENT_SECRET = os.environ.get('LUCID_CLIENT_SECRET')
  LUCID_REFRESH_TOKEN = os.environ.get('LUCID_REFRESH_TOKEN')
  LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
  PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '200'))
  MAX_PAGES = int(os.environ.get('MAX_PAGES', '50'))
  
  API_BASE = 'https://api.lucid.co'
  
  @functions_framework.cloud_event
  def main(cloud_event):
      if not all([GCS_BUCKET, LUCID_CLIENT_ID, LUCID_CLIENT_SECRET, LUCID_REFRESH_TOKEN]):
          print('Error: Missing required environment variables')
          return
  
      try:
          bucket = storage_client.bucket(GCS_BUCKET)
          state = load_state(bucket)
          now = datetime.now(timezone.utc)
  
          if isinstance(state, dict) and state.get('last_event_time'):
              try:
                  last_val = state['last_event_time']
                  if last_val.endswith('Z'):
                      last_val = last_val[:-1] + '+00:00'
                  last_time = datetime.fromisoformat(last_val)
                  last_time = last_time - timedelta(minutes=2)
              except Exception as e:
                  print(f"Warning: Could not parse last_event_time: {e}")
                  last_time = now - timedelta(hours=LOOKBACK_HOURS)
          else:
              last_time = now - timedelta(hours=LOOKBACK_HOURS)
  
          print(f"Fetching audit logs from {last_time.isoformat()} to {now.isoformat()}")
  
          access_token, new_refresh_token = refresh_access_token()
  
          if new_refresh_token:
              save_refresh_token(bucket, new_refresh_token)
  
          records, newest_event_time = fetch_audit_logs(access_token, last_time, now)
  
          if not records:
              print("No new audit log records found.")
              save_state(bucket, now.isoformat())
              return
  
          timestamp = now.strftime('%Y%m%d_%H%M%S')
          object_key = f"{GCS_PREFIX}/lucid_audit_{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}")
  
          if newest_event_time:
              save_state(bucket, newest_event_time)
          else:
              save_state(bucket, now.isoformat())
  
          print(f"Successfully processed {len(records)} audit log records")
  
      except Exception as e:
          print(f'Error processing logs: {str(e)}')
          raise
  
  def refresh_access_token():
      url = f"{API_BASE}/oauth2/token"
      body = json.dumps({
          'grant_type': 'refresh_token',
          'refresh_token': LUCID_REFRESH_TOKEN,
          'client_id': LUCID_CLIENT_ID,
          'client_secret': LUCID_CLIENT_SECRET
      }).encode('utf-8')
  
      response = http.request(
          'POST', url,
          body=body,
          headers={'Content-Type': 'application/json'}
      )
  
      if response.status != 200:
          raise Exception(
              f"Token refresh failed: {response.status} - "
              f"{response.data.decode('utf-8')}"
          )
  
      data = json.loads(response.data.decode('utf-8'))
      access_token = data.get('access_token')
      new_refresh_token = data.get('refresh_token')
  
      if not access_token:
          raise Exception("No access_token in token refresh response")
  
      print("Successfully refreshed Lucid API access token")
      return access_token, new_refresh_token
  
  def fetch_audit_logs(access_token, start_time, end_time):
      records = []
      newest_time = None
      page_num = 0
      next_page_url = None
  
      since_str = start_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')
      until_str = end_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')
  
      while page_num < MAX_PAGES:
          page_num += 1
  
          if next_page_url:
              url = next_page_url
          else:
              url = (
                  f"{API_BASE}/auditLogs"
                  f"?pageSize={PAGE_SIZE}"
                  f"&since={since_str}"
                  f"&until={until_str}"
              )
  
          headers = {
              'Authorization': f'Bearer {access_token}',
              'Lucid-Api-Version': '1',
              'Accept': 'application/json'
          }
  
          response = http.request('GET', url, headers=headers)
  
          if response.status == 429:
              print(f"Rate limited on page {page_num}. Stopping pagination.")
              break
  
          if response.status != 200:
              print(
                  f"API error on page {page_num}: {response.status} - "
                  f"{response.data.decode('utf-8')}"
              )
              break
  
          page_results = json.loads(response.data.decode('utf-8'))
  
          if not page_results:
              print(f"No more results at page {page_num}")
              break
  
          records.extend(page_results)
          print(f"Page {page_num}: Retrieved {len(page_results)} events "
                f"(total: {len(records)})")
  
          for event in page_results:
              try:
                  event_time = event.get('eventTimestamp')
                  if event_time:
                      if newest_time is None or event_time > newest_time:
                          newest_time = event_time
              except Exception as e:
                  print(f"Warning: Could not parse event time: {e}")
  
          link_header = response.headers.get('Link', '')
          next_page_url = parse_link_header(link_header)
  
          if not next_page_url:
              print(f"No next page link found. Pagination complete.")
              break
  
          if len(page_results) < PAGE_SIZE:
              break
  
      print(f"Total audit log records fetched: {len(records)} from {page_num} pages")
      return records, newest_time
  
  def parse_link_header(link_header):
      if not link_header:
          return None
  
      match = re.search(r'<([^>]+)>;\s*rel="next"', link_header)
      if match:
          return match.group(1)
      return None
  
  def load_state(bucket):
      try:
          blob = bucket.blob(STATE_KEY)
          if blob.exists():
              return json.loads(blob.download_as_text())
      except Exception as e:
          print(f"Warning: Could not load state: {e}")
      return {}
  
  def save_state(bucket, last_event_time_iso):
      try:
          state = {
              'last_event_time': last_event_time_iso,
              'last_run': datetime.now(timezone.utc).isoformat()
          }
          blob = bucket.blob(STATE_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 save_refresh_token(bucket, new_refresh_token):
      try:
          token_key = f"{GCS_PREFIX}/refresh_token.json"
          blob = bucket.blob(token_key)
          blob.upload_from_string(
              json.dumps({'refresh_token': new_refresh_token}, indent=2),
              content_type='application/json'
          )
          print("Saved new refresh token to GCS")
      except Exception as e:
          print(f"Warning: Could not save refresh token: {e}")
  

• requirements.txt:

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

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

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

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

Buat tugas Cloud Scheduler

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

3. Berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama	lucid-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 lucid-audit-trigger
   Isi pesan	{} (objek JSON kosong)

4. Klik Create.

Menguji integrasi

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

7. Pastikan fungsi berhasil dieksekusi. Cari:

   Fetching audit logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
   Successfully refreshed Lucid API access token
   Page 1: Retrieved X events (total: X)
   Wrote X records to gs://lucid-audit-logs-gcs/lucid-audit/lucid_audit_YYYYMMDD_HHMMSS.ndjson
   Successfully processed X audit log records
   

8. Buka Cloud Storage > Buckets.

9. Klik lucid-audit-logs-gcs.

10. Buka folder lucid-audit/.

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

Jika Anda melihat error dalam log:

• HTTP 401: Pastikan variabel lingkungan LUCID_CLIENT_ID, LUCID_CLIENT_SECRET, dan LUCID_REFRESH_TOKEN sudah benar
• HTTP 403: Verifikasi bahwa klien OAuth 2.0 memiliki cakupan account.audit.logs dan tokennya adalah token akun
• HTTP 429: Pembatasan kecepatan — fungsi akan menghentikan penomoran halaman dan dilanjutkan pada eksekusi terjadwal berikutnya
• Variabel lingkungan tidak ada: Pastikan semua variabel yang diperlukan ditetapkan dalam konfigurasi fungsi Cloud Run

Kategori peristiwa log audit

Log audit Lucid diatur ke dalam kategori peristiwa berikut:

Kategori	Deskripsi
Login	Peristiwa yang terkait dengan login pengguna
Konten	Peristiwa yang terkait dengan akses dan perubahan dokumen serta folder
Administrasi	Peristiwa yang terkait dengan aktivitas admin dan perubahan akun
User	Peristiwa yang terkait dengan tindakan pengguna pada setelan pribadi
Tim	Acara yang terkait dengan operasi tim

Untuk mengetahui daftar lengkap jenis peristiwa dan skemanya, lihat dokumentasi Peristiwa Log Audit Lucid.

Lingkungan FedRAMP

Pengguna di lingkungan Lucid FedRAMP menggunakan endpoint API dan otorisasi yang berbeda. Lihat dokumentasi lingkungan FedRAMP Lucid untuk mengetahui URL endpoint yang benar.

Mengambil akun layanan Google SecOps

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

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

   [e-mail]
   

8. 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.

9. Klik Berikutnya.

10. Tentukan nilai untuk parameter input berikut:

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

      gs://lucid-audit-logs-gcs/lucid-audit/
      

    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 (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 peran Storage Object Viewer di bucket GCS Anda.

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

6. Klik Simpan.

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

Tabel pemetaan UDM

Kolom Log	Pemetaan UDM	Logika
document_opened	additional.fields	Digabungkan dengan label yang dibuat dari setiap kolom sumber jika tidak kosong
share_link_enable	additional.fields
restricted_account_enable	additional.fields
event1.documentIds	additional.fields
team_folder	additional.fields
method_type	additional.fields
extensions.auth.type	extensions.auth.type	Disetel ke "AUTHTYPE_UNSPECIFIED" untuk peristiwa login/logout
eventTimestamp	metadata.event_timestamp	Dikonversi menggunakan kecocokan tanggal ISO8601 atau yyyy-MM-ddTHH:mm:ss.SSSSSSZ
has_user_login	metadata.event_type	Ditetapkan berdasarkan tanda has_*: USER_LOGIN jika has_user_login dan has_target_user, USER_LOGOUT jika has_user_logout dan has_target_user, USER_RESOURCE_UPDATE_CONTENT jika has_user_resource_updated dan has_target_resource dan has_principal_user, USER_CREATION jika has_principal_user dan has_target_application dan has_target_user, USER_RESOURCE_CREATION jika has_target_resource dan has_principal_user, FILE_CREATION jika has_target_file dan has_principal dan has_target, USER_RESOURCE_ACCESS jika has_target_resource, USER_COMMUNICATION jika has_principal_user, STATUS_UPDATE jika has_principal dan has_target salah (false), atau GENERIC_EVENT
has_user_logout	metadata.event_type
has_user_resource_updated	metadata.event_type
has_principal_user	metadata.event_type
has_target_resource	metadata.event_type
has_target_file	metadata.event_type
has_principal	metadata.event_type
has_target_user	metadata.event_type
has_target_application	metadata.event_type
has_target	metadata.event_type
event1.event1Type	metadata.product_event_type	Nilai disalin secara langsung
actor.actorIp	principal.asset.ip	Nilai disalin langsung jika tidak kosong
actor.actorIp	principal.ip	Nilai disalin langsung jika tidak kosong
actor.actorAccountId	principal.resource.id	Nilai disalin langsung jika tidak kosong
actor.actorClient	principal.resource.name	Nilai disalin langsung jika tidak kosong
flowId	principal.resource.product_object_id	Nilai disalin langsung jika tidak kosong
actor.actorType	principal.user.attribute.roles	Digabungkan dari actor_type jika eventType bukan login/logout dan actor_type tidak kosong
actor.actorEmail	principal.user.email_addresses	Digabungkan jika actor_email tidak kosong dan merupakan email yang valid serta eventType bukan login/logout
actor.actorUserId	principal.user.userid	Nilai disalin secara langsung jika tidak kosong dan eventType bukan login/logout
event1.registrationMethod	security_result.description	Nilai disalin langsung jika tidak kosong
event1.source	target.application	Nilai disalin langsung jika tidak kosong
event1.publishedLink.link	target.file.full_path	Nilai disalin langsung jika tidak kosong
event1.filename	target.file.names	Digabungkan jika tidak kosong
targetData._targetType	target.resource.attribute.labels	Digabungkan dengan label yang dibuat dari setiap kolom sumber jika tidak kosong
targetData._targetId	target.resource.attribute.labels
event1.format	target.resource.attribute.labels
event1.method	target.resource.attribute.labels
event1.publishedLink.format	target.resource.attribute.labels
accountId	target.resource.id	Nilai disalin langsung jika tidak kosong
event1.destinationFolderName	target.resource.name	Disetel ke destinationFolderName jika tidak kosong, atau folderName jika tidak kosong, atau publishedLink.name jika tidak kosong
event1.folderName	target.resource.name
event1.publishedLink.name	target.resource.name
event1.documentId	target.resource.product_object_id	Nilai disalin langsung jika tidak kosong
actor.actorType	target.user.attribute.roles	Digabungkan dari actor_type jika eventType adalah login/logout, dan dari event_role jika tidak kosong
event1.role	target.user.attribute.roles
actor.actorEmail	target.user.email_addresses	Digabungkan dari actor_email jika login/logout dan valid, serta dari userEmail di _target
targetData.userEmail	target.user.email_addresses
event1.destinationFolderId	target.user.product_object_id	Ditetapkan ke destinationFolderId jika tidak kosong, atau folderId jika tidak kosong
event1.folderId	target.user.product_object_id
targetData.displayName	target.user.user_display_name	Nilai disalin langsung jika tidak kosong
actor.actorUserId	target.user.userid	Nilai disalin langsung jika tidak kosong dan eventType adalah login/logout
event1.product	metadata.product_name	Nilai dari produk jika tidak kosong, atau "LUCID"
metadata.vendor_name	metadata.vendor_name	Ditetapkan ke "LUCID"

Log Perubahan

Melihat Log Perubahan untuk parser ini

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