IBM Security Identity Manager-Logs erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie IBM Security Identity Manager-Logs mit Google Cloud Storage V2 in Google Security Operations aufnehmen.

IBM Security Identity Manager (ISIM) ist eine automatisierte und richtlinienbasierte Lösung, mit der der Nutzerzugriff in IT-Umgebungen verwaltet wird. So können Sie ein effektives Identitätsmanagement und eine effektive Governance im gesamten Unternehmen erreichen. Durch die Verwendung von Rollen, Konten und Zugriffsberechtigungen wird die Erstellung, Änderung, Neuzertifizierung und Beendigung von Nutzeridentitäten während des gesamten Nutzerlebenszyklus automatisiert. Das Produkt ist in neueren Versionen auch als IBM Security Verify Governance – Identity Manager bekannt.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Ein GCP-Projekt mit aktivierter Cloud Storage API
  • Berechtigungen zum Erstellen und Verwalten von GCS-Buckets
  • Berechtigungen zum Verwalten von IAM-Richtlinien für GCS-Buckets
  • Berechtigungen zum Erstellen von Cloud Run-Diensten, Pub/Sub-Themen und Cloud Scheduler-Jobs
  • Privilegierter Zugriff auf die IBM Security Identity Manager REST API
  • IBM Security Identity Manager Version 7.0.2 oder höher oder IBM Security Verify Governance 10.0.1 oder höher
  • Ein ISIM-Nutzerkonto mit Administratorberechtigungen für den Zugriff auf die REST API-Endpunkte (/itim/rest/activities und /itim/rest/requests)
  • Netzwerkverbindung zwischen dem GCP-Projekt und der virtuellen ISIM-Appliance (Firewallregeln müssen HTTPS-Traffic über den ISIM-Port zulassen)

IBM Security Identity Manager-API-Zugriff konfigurieren

Damit Google SecOps Aktivitäts- und Anforderungs-Audit-Daten abrufen kann, müssen Sie in ISIM ein dediziertes Dienstkonto mit den erforderlichen Berechtigungen für den REST API-Zugriff konfigurieren.

Dediziertes ISIM-Konto für den API-Zugriff erstellen

  1. Melden Sie sich in der IBM Security Identity Manager-Verwaltungskonsole an.
  2. Klicken Sie auf Nutzer verwalten> Nutzer erstellen.
  3. Erstellen Sie ein neues Nutzerkonto für die Integration (z. B. secops-api-user).
  4. Weisen Sie die Rolle Systemadministrator oder eine benutzerdefinierte Rolle zu, die Berechtigungen zum Aufrufen von Aktivitäten und Anfragen über die REST API enthält.
  5. Speichern Sie die Anmeldedaten für das Konto sicher:
    • Nutzername: Der ISIM-Anmeldenutzername (z. B. secops-api-user)
    • Passwort: Das ISIM-Anmeldepasswort

ISIM API-Basis-URL ermitteln

  • Die Basis-URL der ISIM API hat folgendes Format:

    https://<isim-hostname>:<port>

  • Wenn der Hostname Ihrer ISIM-Appliance beispielsweise isim.example.com lautet und der Standard-HTTPS-Port verwendet wird:

    https://isim.example.com:9082

API-Zugriff testen

  • Testen Sie Ihre Anmeldedaten, bevor Sie mit der Integration fortfahren:

    # Replace with your actual credentials and ISIM URL
ISIM_BASE_URL="https://isim.example.com:9082"
ISIM_USER="chronicle-api-user"
ISIM_PASS="your-password"

# Authenticate and obtain session cookie
curl -v -k -c cookies.txt \
    -d "j_username=${ISIM_USER}&j_password=${ISIM_PASS}" \
    "${ISIM_BASE_URL}/itim/j_security_check"

# Retrieve CSRF token from systemusers/me endpoint
curl -v -k -b cookies.txt \
    -H "Accept: application/json" \
    "${ISIM_BASE_URL}/itim/rest/systemusers/me"

# Test activities endpoint
curl -v -k -b cookies.txt \
    -H "Accept: application/json" \
    "${ISIM_BASE_URL}/itim/rest/activities"

Eine erfolgreiche Antwort gibt ein JSON-Array mit den letzten ISIM-Aktivitäten zurück.

Google Cloud Storage-Bucket erstellen

  1. Gehen Sie zur Google Cloud Console.
  2. Wählen Sie Ihr Projekt aus oder erstellen Sie ein neues.
  3. Rufen Sie im Navigationsmenü Cloud Storage > Buckets auf.
  4. Klicken Sie auf Bucket erstellen.

  5. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Bucket benennen Geben Sie einen global eindeutigen Namen ein, z. B. ibm-sim-logs-gcs.
    Standorttyp Wählen Sie die Option aus, die am besten zu Ihren Anforderungen passt (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Speicherort aus, z. B. us-central1.
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutztools Optional: Objektversionierung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

Dienstkonto für Cloud Run-Funktion erstellen

Für die Cloud Run-Funktion ist ein Dienstkonto mit Berechtigungen zum Schreiben in den GCS-Bucket und zum Aufrufen durch Pub/Sub erforderlich.

Dienstkonto erstellen

  1. Wechseln Sie in der GCP Console zu IAM und Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie ibm-sim-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect IBM Security Identity Manager logs ein.
  4. Klicken Sie auf Erstellen und fortfahren.
  5. Fügen Sie im Abschnitt Diesem Dienstkonto Zugriff auf das Projekt erteilen die folgenden Rollen hinzu:
    1. Klicken Sie auf Rolle auswählen.
    2. Suchen Sie nach Storage Object Admin und wählen Sie die Rolle aus.
    3. Klicken Sie auf + Weitere Rolle hinzufügen.
    4. Suchen Sie nach Cloud Run Invoker und wählen Sie die Rolle aus.
    5. Klicken Sie auf + Weitere Rolle hinzufügen.
    6. Suchen Sie nach Cloud Functions Invoker und wählen Sie die Rolle aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

Diese Rollen sind für Folgendes erforderlich:

  • Storage-Objekt-Administrator: Protokolle in GCS-Bucket schreiben und Statusdateien verwalten
  • Cloud Run Invoker: Pub/Sub darf die Funktion aufrufen.
  • Cloud Functions-Invoker: Funktionsaufruf zulassen

IAM-Berechtigungen für GCS-Bucket erteilen

Gewähren Sie dem Dienstkonto Schreibberechtigungen für den GCS-Bucket:

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets (ibm-sim-logs-gcs).
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Geben Sie die E‑Mail-Adresse des Dienstkontos (ibm-sim-collector-sa@PROJECT_ID.iam.gserviceaccount.com) ein.
    • Rollen zuweisen: Wählen Sie Storage Object Admin aus.
  6. Klicken Sie auf Speichern.

Pub/Sub-Thema erstellen

Erstellen Sie ein Pub/Sub-Thema, in dem Cloud Scheduler veröffentlicht und das von der Cloud Run-Funktion abonniert wird.

  1. Rufen Sie in der GCP Console Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie ibm-sim-logs-trigger ein.
    • Übernehmen Sie die anderen Einstellungen.
  4. Klicken Sie auf Erstellen.

Cloud Run-Funktion zum Erfassen von Logs erstellen

Die Cloud Run-Funktion wird durch Pub/Sub-Nachrichten von Cloud Scheduler ausgelöst, um Logs von der IBM Security Identity Manager REST API abzurufen und in GCS zu schreiben.

So erstellen Sie eine Cloud Run-Funktion zum Erfassen von Logs:

  1. Rufen Sie in der GCP Console Cloud Run auf.
  2. Klicken Sie auf Dienst erstellen.
  3. Wählen Sie Funktion aus, um eine Funktion mit einem Inline-Editor zu erstellen.

  4. Geben Sie im Abschnitt Konfigurieren die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Dienstname ibm-sim-collector
    Region Wählen Sie die Region aus, die Ihrem GCS-Bucket entspricht (z. B. us-central1).
    Laufzeit Wählen Sie Python 3.12 oder höher aus.

  5. Im Abschnitt Trigger (optional):

    1. Klicken Sie auf + Trigger hinzufügen.
    2. Wählen Sie Cloud Pub/Sub aus.
    3. Wählen Sie unter Cloud Pub/Sub-Thema auswählen die Option ibm-sim-logs-trigger aus.
    4. Klicken Sie auf Speichern.

  6. Im Abschnitt Authentifizierung:

    1. Wählen Sie Authentifizierung erforderlich aus.
    2. Weitere Informationen finden Sie unter Identity and Access Management (IAM).

  7. Scrollen Sie nach unten und maximieren Sie Container, Netzwerk, Sicherheit.

  8. Rufen Sie den Tab Sicherheit auf:

    • Dienstkonto: Wählen Sie ibm-sim-collector-sa aus.

  9. Rufen Sie den Tab Container auf:

    1. Klicken Sie auf Variablen und Secrets.

    2. Klicken Sie für jede Umgebungsvariable auf + Variable hinzufügen:

      Variablenname Beispielwert Beschreibung
      GCS_BUCKET ibm-sim-logs-gcs Name des GCS-Buckets
      GCS_PREFIX ibm-sim Präfix für Logdateien
      STATE_KEY ibm-sim/state.json Pfad der Statusdatei
      ISIM_BASE_URL https://isim.example.com:9082 ISIM-Server-Basis-URL
      ISIM_USERNAME secops-api-user ISIM API-Nutzername
      ISIM_PASSWORD your-password ISIM API-Passwort
      LOOKBACK_HOURS 24 Anfänglicher Rückschauzeitraum
      PAGE_SIZE 100 Einträge pro API-Seite
      MAX_RECORDS 5000 Maximale Anzahl von Datensätzen pro Ausführung

  10. Scrollen Sie im Bereich Variablen und Secrets nach unten zu Anfragen:

    • Zeitlimit für die Anfrage: Geben Sie 600 Sekunden (10 Minuten) ein.

  11. Gehen Sie zum Tab Einstellungen:

    • Im Abschnitt Ressourcen:
      • Arbeitsspeicher: Wählen Sie 512 MiB oder höher aus.
      • CPU: Wählen Sie 1 aus.

  12. Im Abschnitt Versionsskalierung:

    • Mindestanzahl von Instanzen: Geben Sie 0 ein.
    • Maximale Anzahl von Instanzen: Geben Sie 100 ein.

  13. Klicken Sie auf Erstellen.

  14. Warten Sie, bis der Dienst erstellt wurde (1–2 Minuten).

  15. Nachdem der Dienst erstellt wurde, wird automatisch der Inline-Code-Editor geöffnet.

Funktionscode hinzufügen

  1. Geben Sie main in das Feld Einstiegspunkt ein.

  2. Erstellen Sie im Inline-Code-Editor zwei Dateien:

    • main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
import urllib.parse
from datetime import datetime, timezone, timedelta

# Disable SSL warnings for self-signed certificates
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=10.0, read=60.0),
    retries=False,
    cert_reqs='CERT_NONE',
)

storage_client = storage.Client()

GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'ibm-sim')
STATE_KEY = os.environ.get('STATE_KEY', 'ibm-sim/state.json')
ISIM_BASE_URL = os.environ.get('ISIM_BASE_URL', '').rstrip('/')
ISIM_USERNAME = os.environ.get('ISIM_USERNAME')
ISIM_PASSWORD = os.environ.get('ISIM_PASSWORD')
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100'))
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))

@functions_framework.cloud_event
def main(cloud_event):
    if not all([GCS_BUCKET, ISIM_BASE_URL, ISIM_USERNAME, ISIM_PASSWORD]):
        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 logs from {last_time.isoformat()} to {now.isoformat()}")

        session_cookies = authenticate()
        csrf_token = get_csrf_token(session_cookies)

        activities = fetch_activities(session_cookies, csrf_token, last_time, now)
        requests_data = fetch_requests(session_cookies, csrf_token, last_time, now)

        all_records = []
        for a in activities:
            a['_isim_record_type'] = 'activity'
            all_records.append(a)
        for r in requests_data:
            r['_isim_record_type'] = 'request'
            all_records.append(r)

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

        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = f"{GCS_PREFIX}/ibm_sim_audit_{timestamp}.ndjson"
        blob = bucket.blob(object_key)

        ndjson = '\n'.join(
            [json.dumps(r, ensure_ascii=False, default=str) for r in all_records]
        ) + '\n'
        blob.upload_from_string(ndjson, content_type='application/x-ndjson')

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

        newest = find_newest_time(all_records)
        save_state(bucket, newest if newest else now.isoformat())

        print(f"Successfully processed {len(all_records)} records "
            f"(activities: {len(activities)}, requests: {len(requests_data)})")

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

def authenticate():
    url = f"{ISIM_BASE_URL}/itim/j_security_check"
    encoded_body = urllib.parse.urlencode({
        'j_username': ISIM_USERNAME,
        'j_password': ISIM_PASSWORD
    }).encode('utf-8')

    response = http.request(
        'POST', url,
        body=encoded_body,
        headers={'Content-Type': 'application/x-www-form-urlencoded'},
        redirect=False
    )

    cookies = {}
    set_cookie_headers = response.headers.getlist('Set-Cookie') if hasattr(response.headers, 'getlist') else []
    if not set_cookie_headers:
        raw = response.headers.get('Set-Cookie', '')
        if raw:
            set_cookie_headers = [raw]

    for cookie_header in set_cookie_headers:
        parts = cookie_header.split(';')[0]
        if '=' in parts:
            name, value = parts.split('=', 1)
            cookies[name.strip()] = value.strip()

    if not cookies:
        raise Exception(
            f"Authentication failed: no session cookies returned "
            f"(HTTP {response.status})"
        )

    print("Successfully authenticated to ISIM")
    return cookies

def get_csrf_token(cookies):
    url = f"{ISIM_BASE_URL}/itim/rest/systemusers/me"
    cookie_str = '; '.join([f"{k}={v}" for k, v in cookies.items()])

    response = http.request(
        'GET', url,
        headers={
            'Accept': 'application/json',
            'Cookie': cookie_str
        }
    )

    if response.status != 200:
        raise Exception(
            f"Failed to get CSRF token: {response.status} - "
            f"{response.data.decode('utf-8')}"
        )

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

    if isinstance(data, dict):
        csrf_token = data.get('_csrf', data.get('CSRFToken'))
    if not csrf_token:
        csrf_header = response.headers.get('CSRFToken', '')
        if csrf_header:
            csrf_token = csrf_header

    print("Successfully retrieved CSRF token")
    return csrf_token

def fetch_activities(cookies, csrf_token, start_time, end_time):
    url = f"{ISIM_BASE_URL}/itim/rest/activities"
    cookie_str = '; '.join([f"{k}={v}" for k, v in cookies.items()])

    headers = {
        'Accept': 'application/json',
        'Cookie': cookie_str
    }
    if csrf_token:
        headers['CSRFToken'] = csrf_token

    all_records = []
    start_index = 0

    while len(all_records) < MAX_RECORDS:
        params = {
            '_start': str(start_index),
            '_count': str(min(PAGE_SIZE, MAX_RECORDS - len(all_records)))
        }
        query_string = urllib.parse.urlencode(params)
        request_url = f"{url}?{query_string}"

        response = http.request('GET', request_url, headers=headers)

        if response.status != 200:
            print(f"Activities query failed: {response.status} - "
                f"{response.data.decode('utf-8')}")
            break

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

        if isinstance(page_results, dict):
            page_results = page_results.get('activities', page_results.get('items', []))

        if not page_results:
            break

        all_records.extend(page_results)
        print(f"Activities: Retrieved {len(page_results)} records "
            f"(total: {len(all_records)})")

        if len(page_results) < PAGE_SIZE:
            break

        start_index += len(page_results)

    print(f"Total activities fetched: {len(all_records)}")
    return all_records

def fetch_requests(cookies, csrf_token, start_time, end_time):
    url = f"{ISIM_BASE_URL}/itim/rest/requests"
    cookie_str = '; '.join([f"{k}={v}" for k, v in cookies.items()])

    headers = {
        'Accept': 'application/json',
        'Cookie': cookie_str
    }
    if csrf_token:
        headers['CSRFToken'] = csrf_token

    all_records = []
    start_index = 0

    while len(all_records) < MAX_RECORDS:
        params = {
            '_start': str(start_index),
            '_count': str(min(PAGE_SIZE, MAX_RECORDS - len(all_records)))
        }
        query_string = urllib.parse.urlencode(params)
        request_url = f"{url}?{query_string}"

        response = http.request('GET', request_url, headers=headers)

        if response.status != 200:
            print(f"Requests query failed: {response.status} - "
                f"{response.data.decode('utf-8')}")
            break

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

        if isinstance(page_results, dict):
            page_results = page_results.get('requests', page_results.get('items', []))

        if not page_results:
            break

        all_records.extend(page_results)
        print(f"Requests: Retrieved {len(page_results)} records "
            f"(total: {len(all_records)})")

        if len(page_results) < PAGE_SIZE:
            break

        start_index += len(page_results)

    print(f"Total requests fetched: {len(all_records)}")
    return all_records

def find_newest_time(records):
    newest = None
    for r in records:
        for field in ['completedTime', 'scheduledTime', 'startedTime',
                    'lastModified', 'requestDate', 'timestamp']:
            t = r.get(field)
            if t:
                try:
                    if isinstance(t, (int, float)):
                        dt = datetime.fromtimestamp(t / 1000, tz=timezone.utc)
                        t_iso = dt.isoformat()
                    else:
                        t_iso = str(t)
                    if newest is None or t_iso > newest:
                        newest = t_iso
                except Exception:
                    continue
    return newest

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}")

    • requirements.txt:

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

  3. Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.

  4. Warten Sie, bis die Bereitstellung abgeschlossen ist (2–3 Minuten).

Cloud Scheduler-Job erstellen

Cloud Scheduler veröffentlicht in regelmäßigen Abständen Nachrichten im Pub/Sub-Thema und löst so die Cloud Run-Funktion aus.

  1. Rufen Sie in der GCP Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name ibm-sim-collector-hourly
    Region Dieselbe Region wie die Cloud Run-Funktion auswählen
    Frequenz 0 * * * * (stündlich zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema ibm-sim-logs-trigger auswählen
    Inhalt der Nachricht {} (leeres JSON-Objekt)

  4. Klicken Sie auf Erstellen.

Optionen für die Häufigkeit des Zeitplans

Wählen Sie die Häufigkeit basierend auf dem Logvolumen und den Latenzanforderungen aus:

Häufigkeit Cron-Ausdruck Anwendungsfall
Alle 5 Minuten */5 * * * * Hohes Volumen, niedrige Latenz
Alle 15 Minuten */15 * * * * Mittleres Suchvolumen
Stündlich 0 * * * * Standard (empfohlen)
Alle 6 Stunden 0 */6 * * * Geringes Volumen, Batchverarbeitung
Täglich 0 0 * * * Erhebung von Verlaufsdaten

Integration testen

  1. Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job (ibm-sim-collector-hourly).
  2. Klicken Sie auf Ausführung erzwingen, um den Job manuell auszulösen.
  3. Warten Sie einige Sekunden.
  4. Rufen Sie Cloud Run > Dienste auf.
  5. Klicken Sie auf ibm-sim-collector.
  6. Klicken Sie auf den Tab Logs.

  7. Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde. Darauf sollten Sie achten:

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Successfully authenticated to ISIM
Successfully retrieved CSRF token
Activities: Retrieved X records (total: X)
Requests: Retrieved X records (total: X)
Wrote X records to gs://ibm-sim-logs-gcs/ibm-sim/ibm_sim_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records (activities: X, requests: X)

  8. Rufen Sie Cloud Storage > Buckets auf.

  9. Klicken Sie auf ibm-sim-logs-gcs.

  10. Rufen Sie den Ordner ibm-sim/ auf.

  11. Prüfen Sie, ob eine neue .ndjson-Datei mit dem aktuellen Zeitstempel erstellt wurde.

Wenn in den Logs Fehler angezeigt werden:

  • HTTP 401/302: Prüfen Sie, ob die Umgebungsvariablen ISIM_USERNAME und ISIM_PASSWORD korrekt sind und das Nutzerkonto nicht gesperrt ist.
  • HTTP 403: Prüfen Sie, ob das ISIM-Nutzerkonto Administratorberechtigungen für den REST API-Zugriff hat.
  • HTTP 404: Prüfen Sie, ob ISIM_BASE_URL korrekt ist und die richtige Portnummer enthält.
  • Verbindungsfehler: Prüfen Sie die Netzwerkverbindung zwischen der Cloud Run-Funktion und der virtuellen ISIM-Appliance.
  • Fehlende Umgebungsvariablen: Prüfen Sie, ob alle erforderlichen Variablen in der Konfiguration der Cloud Run-Funktion festgelegt sind.

Google SecOps-Dienstkonto abrufen

Google SecOps verwendet ein eindeutiges Dienstkonto, um Daten aus Ihrem GCS-Bucket zu lesen. Sie müssen diesem Dienstkonto Zugriff auf Ihren Bucket gewähren.

E‑Mail-Adresse des Dienstkontos abrufen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf Einzelnen Feed konfigurieren.
  4. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. IBM SIM Logs GCS.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie IBM Security Identity Manager als Log type (Protokolltyp) aus.

  7. Klicken Sie auf Dienstkonto abrufen. Es wird eine eindeutige E-Mail-Adresse für das Dienstkonto angezeigt, z. B.:

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

  8. Kopieren Sie diese E‑Mail-Adresse für den nächsten Schritt.

  9. Klicken Sie auf Weiter.

  10. Geben Sie Werte für die folgenden Eingabeparameter an:

    • Storage-Bucket-URL: Geben Sie den GCS-Bucket-URI mit dem Präfixpfad ein:

      gs://ibm-sim-logs-gcs/ibm-sim/

    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus:

      • Nie: Löscht nach Übertragungen nie Dateien (empfohlen für Tests).
      • Übertragene Dateien löschen: Dateien werden nach der erfolgreichen Übertragung gelöscht.

      • Übertragene Dateien und leere Verzeichnisse löschen: Löscht Dateien und leere Verzeichnisse nach der erfolgreichen Übertragung.

    • Höchstalter der Datei: Dateien einbeziehen, die in den letzten Tagen geändert wurden (Standardwert: 180 Tage)

    • Asset-Namespace: Der Asset-Namespace

    • Labels für Datenaufnahme: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll

  11. Klicken Sie auf Weiter.

  12. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

Das Google SecOps-Dienstkonto benötigt die Rolle Storage Object Viewer für Ihren GCS-Bucket.

So gewähren Sie dem Google SecOps-Dienstkonto IAM-Berechtigungen:

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf ibm-sim-logs-gcs.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Fügen Sie die E‑Mail-Adresse des Google SecOps-Dienstkontos ein.
    • Rollen zuweisen: Wählen Sie Storage Object Viewer aus.
  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
Beschreibung metadata.description Eine Beschreibung des Ereignisses
receivedTime metadata.event_timestamp Zeitstempel des Ereignisses
metadata.event_type metadata.event_type Ereignistyp
Version metadata.product_version Produktversion
connectionId network.session_id Sitzungs-ID
tls network.tls.version TLS-Version
ip principal.asset.ip IP-Adresse des Assets
Hostname principal.hostname Hostname
ip principal.ip IP-Adresse
Port principal.port Portnummer
kv_data principal.user.attribute.labels Labels für Nutzerattribute
Aktion security_result.action_details Details zur ergriffenen Maßnahme
metadata.product_name metadata.product_name Produktname
metadata.vendor_name metadata.vendor_name Anbietername

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten