Mengumpulkan log HCL BigFix

Didukung di:

Dokumen ini menjelaskan cara menyerap log HCL BigFix ke Google Security Operations menggunakan Cloud Storage V2 melalui fungsi Cloud Run.

HCL BigFix adalah platform pengelolaan endpoint yang menyediakan kemampuan pengelolaan, keamanan, dan kepatuhan endpoint terpadu. Layanan ini memungkinkan organisasi menemukan, mengelola, dan memulihkan endpoint di seluruh infrastruktur mereka, termasuk pengelolaan patch, distribusi software, manajemen konfigurasi, dan kepatuhan keamanan. Fungsi Cloud Run melakukan polling pada REST API HCL BigFix menggunakan kueri relevansi sesi, menulis hasilnya sebagai NDJSON ke bucket Cloud Storage, dan Google SecOps menyerapnya melalui feed Cloud Storage V2.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

  • Instance Google SecOps
  • Project Google Cloud dengan penagihan diaktifkan
  • Akses ke HCL BigFix Console dengan hak istimewa operator master
  • HCL BigFix Server versi 9.5 atau yang lebih baru
  • Layanan WebReports yang berjalan di BigFix Server
  • Konektivitas jaringan dari fungsi Cloud Run ke BigFix Server di port 52311 (port REST API default)
  • Google Cloud API yang diaktifkan: Cloud Run Functions, Cloud Storage, Cloud Scheduler, Pub/Sub, dan Identity and Access Management (IAM)

Membuat bucket Cloud Storage

  1. Buka konsolGoogle 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, hcl-bigfix-logs)
    Location type Pilih sesuai kebutuhan Anda (Region, Dual-region, Multi-region)
    Location Pilih lokasi yang paling dekat dengan instance Google SecOps Anda (misalnya, us-central1)
    Kelas penyimpanan Standard (direkomendasikan untuk log yang sering diakses)
    Kontrol akses Seragam (direkomendasikan)
    Alat perlindungan Opsional: Mengaktifkan pembuatan versi objek atau kebijakan retensi
  6. Klik Create.

Mengumpulkan kredensial HCL BigFix API

Agar fungsi Cloud Run dapat mengambil data endpoint, Anda perlu membuat operator BigFix Console khusus dengan izin akses REST API.

Membuat operator khusus untuk akses API

  1. Login ke BigFix Console.
  2. Buka Tools > Create Operator.
  3. Dalam dialog Add User, berikan informasi berikut:

    • Username: Masukkan nama pengguna deskriptif (misalnya, chronicle_api).
    • Sandi: Masukkan sandi yang kuat.
    • Confirm Password: Masukkan kembali sandi.
  4. Klik Oke.

Mengonfigurasi izin operator

Setelah membuat operator, jendela Console Operator akan otomatis terbuka.

  1. Klik tab Details.
  2. Di bagian Ringkasan:
    • Pilih Selalu izinkan pengguna ini login.
  3. Di bagian Permissions, tetapkan izin berikut:
    • Dapat Mengirimkan Kueri: Tetapkan ke Ya.
    • Custom Content: Tetapkan ke Yes.
  4. Di bagian Interface Login Privileges:
    • Can use REST API: Tetapkan ke Yes.
  5. Klik tab Administered Computers.
  6. Pilih All computers untuk mengizinkan operator mengkueri semua endpoint, atau pilih grup komputer tertentu berdasarkan kebutuhan Anda.
  7. Klik Simpan Perubahan.

Mencatat kredensial API

Simpan informasi berikut untuk mengonfigurasi variabel lingkungan fungsi Cloud Run:

  • Nama pengguna: Nama pengguna operator yang Anda buat (misalnya, chronicle_api)
  • Password: Sandi operator
  • BigFix Server Hostname: Nama domain yang sepenuhnya memenuhi syarat atau alamat IP BigFix Server Anda (misalnya, bigfix.company.com)
  • API Port: Port REST API (defaultnya adalah 52311)

Menguji konektivitas API

  • Pastikan kredensial API berfungsi dengan menjalankan kueri pengujian berikut dari mesin yang memiliki akses jaringan ke BigFix Server:

    curl -k -u "chronicle_api:YOUR_PASSWORD" \
      -X POST \
      -H "Content-Type: application/x-www-form-urlencoded" \
      -d "relevance=(name of it, id of it) of bes computers" \
      "https://bigfix-server:52311/api/query"
    

    Respons yang berhasil akan menampilkan dokumen XML yang berisi nama dan ID komputer. Jika Anda menerima error autentikasi, verifikasi izin operator yang dikonfigurasi pada langkah sebelumnya.

Membuat akun layanan untuk fungsi Cloud Run

  1. Di konsol Google Cloud , buka IAM & Admin > Service Accounts.
  2. Klik Create Service Account.
  3. Berikan detail konfigurasi berikut:

    • Service account name: Masukkan bigfix-cloud-run (atau nama deskriptif).
    • Service account description: Masukkan Service account for HCL BigFix Cloud Run function to write logs to Cloud Storage.
  4. Klik Create and Continue.

  5. Di bagian Grant this service account access to project, tambahkan peran berikut:

    • Storage Object Admin (untuk membaca/menulis objek di bucket Cloud Storage).
    • Cloud Run Invoker (untuk mengizinkan Cloud Scheduler memanggil fungsi).
  6. Klik Lanjutkan.

  7. Klik Done.

Membuat topik Pub/Sub

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

  1. Di konsol Google Cloud , buka Pub/Sub > Topics.
  2. Klik Create topic.
  3. Di kolom Topic ID, masukkan bigfix-ingestion-trigger.
  4. Biarkan setelan default.
  5. Klik Create.

Membuat fungsi Cloud Run

Menyiapkan file sumber fungsi

Buat dua file berikut untuk deployment fungsi Cloud Run.

  • requirements.txt

    functions-framework==3.*
    google-cloud-storage==2.*
    requests>=2.31.0
    
  • main.py

    import base64
    import json
    import logging
    import os
    import xml.etree.ElementTree as ET
    from datetime import datetime, timezone, timedelta
    
    import requests
    import urllib3
    from google.cloud import storage
    
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger(__name__)
    
    GCS_BUCKET = os.environ["GCS_BUCKET"]
    GCS_PREFIX = os.environ.get("GCS_PREFIX", "bigfix_logs")
    STATE_KEY = os.environ.get("STATE_KEY", "bigfix_state.json")
    BIGFIX_SERVER = os.environ["BIGFIX_SERVER"]
    BIGFIX_PORT = os.environ.get("BIGFIX_PORT", "52311")
    BIGFIX_USERNAME = os.environ["BIGFIX_USERNAME"]
    BIGFIX_PASSWORD = os.environ["BIGFIX_PASSWORD"]
    MAX_RECORDS = int(os.environ.get("MAX_RECORDS", "10000"))
    LOOKBACK_HOURS = int(os.environ.get("LOOKBACK_HOURS", "24"))
    
    BIGFIX_BASE_URL = f"https://{BIGFIX_SERVER}:{BIGFIX_PORT}/api"
    
    RELEVANCE_QUERIES = {
        "computers": (
            '(id of it, name of it, operating system of it, '
            'last report time of it as string, ip address of it as string, '
            'root server of it) of bes computers'
        ),
        "actions": (
            '(id of it, name of it, name of issuer of it, '
            'time issued of it as string, state of it) of bes actions'
        ),
        "fixlets": (
            '(id of it, name of it, source severity of it, '
            'source of it, category of it) of bes fixlets '
            'whose (source severity of it is not "")'
        ),
    }
    
    def _get_auth_header():
        """Build Basic Auth header from credentials."""
        credentials = f"{BIGFIX_USERNAME}:{BIGFIX_PASSWORD}"
        encoded = base64.b64encode(credentials.encode("utf-8")).decode("utf-8")
        return {"Authorization": f"Basic {encoded}"}
    
    def _query_bigfix(relevance, session=None):
        """Execute a session relevance query against the BigFix REST API."""
        url = f"{BIGFIX_BASE_URL}/query"
        headers = _get_auth_header()
        headers["Content-Type"] = "application/x-www-form-urlencoded"
    
        data = {"relevance": relevance}
        http = session or requests
        resp = http.post(url, headers=headers, data=data, verify=False, timeout=120)
        resp.raise_for_status()
        return resp.text
    
    def _parse_query_xml(xml_text, query_name):
        """Parse BigFix XML response into a list of dicts."""
        root = ET.fromstring(xml_text)
        results = []
    
        for result_elem in root.iter("Result"):
            tuples = result_elem.findall("Tuple")
            if tuples:
                for tup in tuples:
                    answers = [a.text or "" for a in tup.findall("Answer")]
                    record = _map_answers(query_name, answers)
                    record["_query"] = query_name
                    record["_collection_time"] = (
                        datetime.now(timezone.utc).isoformat()
                    )
                    results.append(record)
            else:
                answers_elems = result_elem.findall("Answer")
                if answers_elems:
                    answers = [a.text or "" for a in answers_elems]
                    record = _map_answers(query_name, answers)
                    record["_query"] = query_name
                    record["_collection_time"] = (
                        datetime.now(timezone.utc).isoformat()
                    )
                    results.append(record)
    
        logger.info(
            "Query '%s' returned %d results.", query_name, len(results)
        )
        return results
    
    def _map_answers(query_name, answers):
        """Map positional answers to named fields based on query type."""
        field_maps = {
            "computers": [
                "client_id", "client_name", "OS",
                "last_report_time", "ip_address", "root_server",
            ],
            "actions": [
                "action_id", "action_name", "issuer",
                "time_issued", "state",
            ],
            "fixlets": [
                "fixlet_id", "fixlet_name", "source_severity",
                "source", "category",
            ],
        }
        fields = field_maps.get(query_name, [])
        record = {}
        for i, value in enumerate(answers):
            key = fields[i] if i < len(fields) else f"field_{i}"
            record[key] = value
        return record
    
    def _load_state(gcs_client):
        """Load the last run state from GCS."""
        bucket = gcs_client.bucket(GCS_BUCKET)
        blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
        if blob.exists():
            data = blob.download_as_text()
            return json.loads(data)
        return {}
    
    def _save_state(gcs_client, state):
        """Persist run state to GCS."""
        bucket = gcs_client.bucket(GCS_BUCKET)
        blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
        blob.upload_from_string(
            json.dumps(state), content_type="application/json"
        )
        logger.info("State saved to gs://%s/%s/%s", GCS_BUCKET, GCS_PREFIX, STATE_KEY)
    
    def _write_ndjson(gcs_client, records, timestamp_str):
        """Write records as NDJSON to GCS."""
        if not records:
            logger.info("No records to write.")
            return
    
        records = records[:MAX_RECORDS]
        ndjson_lines = "\n".join(json.dumps(r) for r in records)
        blob_name = f"{GCS_PREFIX}/{timestamp_str}/bigfix_events.ndjson"
        bucket = gcs_client.bucket(GCS_BUCKET)
        blob = bucket.blob(blob_name)
        blob.upload_from_string(ndjson_lines, content_type="application/x-ndjson")
        logger.info(
            "Wrote %d records to gs://%s/%s",
            len(records), GCS_BUCKET, blob_name,
        )
    
    def main(event, context):
        """Cloud Run function entry point triggered by Pub/Sub."""
        logger.info("HCL BigFix ingestion function started.")
    
        gcs_client = storage.Client()
        state = _load_state(gcs_client)
    
        last_run = state.get("last_run")
        if last_run:
            logger.info("Last successful run: %s", last_run)
    
        now = datetime.now(timezone.utc)
        timestamp_str = now.strftime("%Y/%m/%d/%H%M%S")
    
        all_records = []
        session = requests.Session()
    
        for query_name, relevance in RELEVANCE_QUERIES.items():
            try:
                xml_text = _query_bigfix(relevance, session=session)
                records = _parse_query_xml(xml_text, query_name)
                all_records.extend(records)
            except requests.exceptions.RequestException as e:
                logger.error(
                    "Failed to execute query '%s': %s", query_name, e
                )
            except ET.ParseError as e:
                logger.error(
                    "Failed to parse XML for query '%s': %s", query_name, e
                )
    
        session.close()
    
        _write_ndjson(gcs_client, all_records, timestamp_str)
    
        state["last_run"] = now.isoformat()
        state["records_written"] = len(all_records)
        _save_state(gcs_client, state)
    
        logger.info(
            "HCL BigFix ingestion complete. %d total records written.",
            len(all_records),
        )
        return "OK"
    

Men-deploy fungsi Cloud Run

  1. Simpan kedua file (main.py dan requirements.txt) ke dalam direktori lokal (misalnya, bigfix-function/).
  2. Buka Cloud Shell atau terminal dengan gcloud CLI yang telah diinstal.
  3. Jalankan perintah berikut untuk men-deploy fungsi:

    gcloud functions deploy bigfix-to-gcs \
      --gen2 \
      --region=us-central1 \
      --runtime=python312 \
      --trigger-topic=bigfix-ingestion-trigger \
      --entry-point=main \
      --memory=512MB \
      --timeout=540s \
      --service-account=bigfix-cloud-run@PROJECT_ID.iam.gserviceaccount.com \
      --set-env-vars="GCS_BUCKET=hcl-bigfix-logs,GCS_PREFIX=bigfix_logs,STATE_KEY=bigfix_state.json,BIGFIX_SERVER=bigfix.company.com,BIGFIX_PORT=52311,BIGFIX_USERNAME=chronicle_api,BIGFIX_PASSWORD=YOUR_PASSWORD,MAX_RECORDS=10000,LOOKBACK_HOURS=24"
    
  4. Ganti nilai placeholder berikut:

    • PROJECT_ID: Project ID Google Cloud Anda.
    • hcl-bigfix-logs: Nama bucket Cloud Storage Anda.
    • bigfix.company.com: Nama host atau alamat IP BigFix Server Anda.
    • chronicle_api: Nama pengguna operator BigFix Anda.
    • YOUR_PASSWORD: Sandi operator BigFix Anda.
  5. Verifikasi deployment dengan memeriksa status fungsi:

    gcloud functions describe bigfix-to-gcs --region=us-central1 --gen2
    

Referensi variabel lingkungan

Variabel Wajib Default Deskripsi
GCS_BUCKET Ya Nama bucket Cloud Storage untuk menyimpan output NDJSON
GCS_PREFIX Tidak bigfix_logs Awalan objek (jalur folder) dalam bucket
STATE_KEY Tidak bigfix_state.json Nama blob untuk state file dalam awalan
BIGFIX_SERVER Ya Nama host atau alamat IP BigFix Server
BIGFIX_PORT Tidak 52311 Port REST API BigFix
BIGFIX_USERNAME Ya Nama pengguna operator BigFix
BIGFIX_PASSWORD Ya Sandi operator BigFix
MAX_RECORDS Tidak 10000 Jumlah maksimum data yang akan ditulis per eksekusi
LOOKBACK_HOURS Tidak 24 Jumlah jam untuk melihat kembali pengumpulan awal

Buat tugas Cloud Scheduler

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

  1. Di konsol Google Cloud , buka Cloud Scheduler.
  2. Klik Create Job.
  3. Berikan detail konfigurasi berikut:
    • Nama: Masukkan bigfix-ingestion-schedule.
    • Region: Pilih region yang sama dengan fungsi Cloud Run Anda (misalnya, us-central1).
    • Frequency: Masukkan 0 */4 * * * (berjalan setiap 4 jam). Sesuaikan jadwal berdasarkan volume data dan persyaratan keaktualan Anda.
    • Zona waktu: Pilih zona waktu yang Anda inginkan.
  4. Klik Lanjutkan.
  5. Di bagian Configure the execution:
    • Target type: Pilih Pub/Sub.
    • Topic: Pilih bigfix-ingestion-trigger.
    • Isi pesan: Masukkan {"run": true}.
  6. Klik Lanjutkan.
  7. Di bagian Configure optional settings:
    • Max retry attempts: Masukkan 3.
    • Durasi backoff minimum: Masukkan 5s.
    • Durasi backoff maksimum: Masukkan 60s.
  8. Klik Create.
  9. Untuk menjalankan pengujian langsung, klik tiga titik (...) di samping nama tugas, lalu pilih Force run.

Mengambil akun layanan Google SecOps dan mengonfigurasi feed

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

Mendapatkan email akun layanan

  1. Buka Setelan > Pengelolaan Data > Feed. Jika Anda menggunakan platform khusus SIEM, buka Settings > Feeds.
  2. Klik Tambahkan Feed Berita Baru.
  3. Klik Konfigurasi satu feed.
  4. Di kolom Nama feed, masukkan nama untuk feed (misalnya, HCL BigFix Logs).
  5. Pilih Google Cloud Storage V2 sebagai Source type.
  6. Pilih HCL BigFix 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 untuk digunakan di langkah berikutnya.

  9. Klik Berikutnya.

  10. Tentukan nilai untuk parameter input berikut:

    • Storage bucket URL: Masukkan URI bucket Cloud Storage:

      gs://hcl-bigfix-logs/bigfix_logs/
      
      • Ganti hcl-bigfix-logs dengan nama bucket Cloud Storage Anda.
      • Ganti bigfix_logs dengan nilai GCS_PREFIX yang Anda konfigurasi.
    • 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.
      • Delete transferred files and empty directories: Menghapus file dan direktori kosong setelah transfer berhasil.

    • Usia File Maksimum: 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 Cloud Storage Anda.

  1. Buka Cloud Storage > Buckets.
  2. Klik nama bucket Anda (misalnya, hcl-bigfix-logs).
  3. Buka tab Izin.
  4. Klik Grant access.
  5. Berikan detail konfigurasi berikut:
    • Add principals: Tempel email akun layanan Google SecOps (misalnya, chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com).
    • Assign roles: Pilih Storage Object Viewer.
  6. Klik Simpan.

Tabel pemetaan UDM

Kolom Log Pemetaan UDM Logika
WMI_Asset_ID entity.asset.asset_id Setel ke "ID aset:" + nilai jika tidak kosong dan bukan "N/A"
Computer_Serial_Number, Computer_Manufacturer, Computer_Model entity.asset.hardware Objek dengan serial_number, manufacturer, model
client_name entity.asset.hostname Nilai disalin langsung
MAC_Addresses entity.asset.mac Digabungkan dari array setelah pemformatan
OperatingSystemType entity.asset.platform_software.platform Nilai dalam huruf besar jika tidak kosong dan bukan "Unix"
OS entity.asset.platform_software.platform_version Nilai disalin langsung
SerialNumber entity.asset.product_object_id Nilai jika tidak kosong
WindowsOperatingSystem entity.asset.software Objek dengan nama yang ditetapkan ke nilai jika tidak kosong
OperatingSystemRole entity.asset.type Nilai huruf besar jika tidak kosong
DNS_Name entity.domain.name Nilai jika tidak kosong
CloudInfo entity.labels Objek label dengan kunci "CloudInfo" dan nilai (tanda kutip dihapus) jika tidak kosong
Peran Domain entity.user.attribute.roles Objek dengan nama yang ditetapkan ke nilai jika tidak kosong
Active_Directory_Path entity.user.group_identifiers Nilai gabungan jika tidak kosong dan bukan ""
WMI_Service_Tag entity.user.product_object_id Nilai jika tidak kosong
User_Name entity.user.user_display_name Nilai jika tidak kosong dan bukan ""
client_id entity.user.userid Nilai disalin langsung
metadata.entity_type Setel ke "ASSET" jika SerialNumber tidak kosong, jika tidak, setel ke "USER"
metadata.product_name Tetapkan ke "HCL Big Fix"
metadata.vendor_name Setel ke "HCL Software"
CloudInfo event.idm.entity.entity.labels Dipetakan dari log perubahan

Log Perubahan

Melihat Log Perubahan untuk parser ini

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