‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

איסוף יומני ביקורת של Lucid

נתמך ב:

Google SecOps SIEM

במאמר הזה מוסבר איך להטמיע יומני ביקורת של Lucid ב-Google Security Operations באמצעות Google Cloud Storage V2.

חברת Lucid Software מספקת חבילה של כלים לשיתוף פעולה חזותי, כולל Lucidchart, ‏ Lucidspark ו-Lucidscale. ‫Audit Logs API, שזמין באופן בלעדי ללקוחות Enterprise Shield, מתעד אירועי אבטחה ותאימות בארגון, כולל גישה לחשבון, פעילות במסמכים, ניהול משתמשים, פעולות אדמין ופעולות צוות.

לפני שמתחילים

חשוב לוודא שמתקיימות הדרישות המוקדמות הבאות:

מופע של Google SecOps
פרויקט ב-GCP עם Cloud Storage API מופעל
הרשאות ליצירה ולניהול של מאגרי GCS
הרשאות לניהול מדיניות IAM בקטגוריות GCS
הרשאות ליצירת שירותי Cloud Run, נושאי Pub/Sub ומשימות Cloud Scheduler
חשבון Lucid Enterprise Shield עם הרשאות אדמין או בעלים
גישה לפורטל למפתחים של Lucid עם הפעלת כלים למפתחים

הפעלת הכלים למפתחים ב-Lucid

לפני שיוצרים פרטי כניסה ל-API, צריך לקבל גישה לפורטל המפתחים של Lucid. יש שתי דרכים להפעיל את כלי הפיתוח:

אפשרות 1: הפעלה דרך הגדרות המשתמש

נכנסים אל lucid.app.
לוחצים על סמל הפרופיל בפינה הימנית העליונה.
לוחצים על הגדרות חשבון.
מסמנים את תיבת הסימון הפעלת כלים למפתחים.

הערה: יכול להיות שהאדמין שלכם ב-Lucid השבית את תיבת הסימון הזו. אם היא מושבתת, משתמשים באפשרות 2.

אפשרות 2: הפעלה באמצעות הקצאת תפקיד אדמין

נכנסים אל lucid.app בתור בעלי החשבון או אדמין של הצוות.
עוברים לחלונית הניהול.
עוברים לקטע משתמשים.
בוחרים את משתמש היעד.
עורכים את התפקידים של המשתמש ומקצים לו את התפקיד מפתח.

הערה: הקצאת תפקיד המפתח מאפשרת למשתמש להשתמש בכלים למפתחים, גם אם הוא לא הפעיל את התכונות למפתחים בהגדרות המשתמש שלו.

הגדרת גישה ל-Lucid API

כדי לאפשר ל-Google SecOps לאחזר יומני ביקורת, צריך ליצור לקוח OAuth 2.0 וליצור אסימון גישה ברמת החשבון עם ההיקף account.audit.logs.

יצירה של אפליקציית OAuth 2.0 ולקוח

עוברים אל הפורטל למפתחים של Lucid.
לוחצים על יצירת אפליקציה.
מזינים שם לאפליקציה (לדוגמה, Chronicle SIEM Integration).
לוחצים על האפליקציה החדשה שנוצרה כדי לגשת להגדרות שלה.
עוברים לכרטיסייה OAuth 2.0.
מזינים שם ללקוח OAuth 2.0 (לדוגמה, Chronicle Audit Log Collector).

הערה: השם של לקוח OAuth 2.0 גלוי לכולם כשהמשתמשים מעניקים גישה, ואי אפשר לשנות אותו אחרי שהוא נוצר.
לוחצים על Create OAuth 2.0 client (יצירת לקוח OAuth 2.0).

הקלטת פרטי הכניסה של הלקוח

אחרי שיוצרים את לקוח OAuth 2.0, פרטי הכניסה מוצגים בפורטל:

‫Client ID: מזהה הלקוח הייחודי שלכם.
‫Client Secret: מפתח ה-API Secret.

חשוב: צריך להעתיק ולשמור את הסוד של הלקוח באופן מיידי. אם הסוד של הלקוח נחשף, לוחצים על הלחצן Reset Client Secret (איפוס הסוד של הלקוח) בדף ההגדרות של OAuth 2.0. איפוס הסוד מבטל את הגישה באופן מיידי עד שהסוד החדש יעודכן בשילוב.

רישום של URI להפניה אוטומטית

בדף ההגדרות של OAuth 2.0, לוחצים על Add Redirect URI (הוספת URI להפניה אוטומטית).
מזינים את ה-URI של ההפניה האוטומטית לשילוב. אם משתמשים בהפניה אוטומטית לבדיקה שסופקה על ידי Lucid, מזינים:
```
https://lucid.app/oauth2/clients/<CLIENT_ID>/redirect
```
מחליפים את <CLIENT_ID> במזהה הלקוח בפועל.

קבלת טוקן גישה ברמת החשבון

‫Audit Logs API דורש טוקן של חשבון (לא טוקן של משתמש). אדמין בחשבון צריך לאשר ללקוח OAuth 2.0 ליצור אסימון בשם החשבון.

מפנים את האדמין של החשבון לכתובת ה-URL הבאה של ההרשאה בדפדפן:
```
https://lucid.app/oauth2/authorizeAccount?client_id=<CLIENT_ID>&redirect_uri=<REDIRECT_URI>&scope=account.audit.logs
```
מחליפים את <CLIENT_ID> ו-<REDIRECT_URI> בערכים בפועל.
האדמין בודק את ההרשאות הנדרשות במסך ההסכמה ולוחץ על אישור.
מערכת Lucid מפנה אוטומטית לכתובת ה-URI להפניה אוטומטית עם פרמטר שאילתה של הרשאה code.

כדי להחליף את קוד ההרשאה באסימון גישה, שולחים בקשת POST לנקודת הקצה של האסימון:

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

התשובה כוללת את השדות access_token ו-refresh_token. חשוב לתעד את שני הערכים בצורה מאובטחת.

הערה: קוד ההרשאה תקף למשך שתי דקות. צריך להחליף אותה בהקדם.

אימות הגישה ל-API

כדי לוודא שאסימון הגישה פועל, שולחים בקשת בדיקה:

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'

תגובה מוצלחת מחזירה מערך JSON של אירועים ביומן הביקורת.

הרשאות ה-API הנדרשות

לקוח OAuth 2.0 דורש את היקף ההרשאות הבא:

היקף סוג הטוקן מטרה

account.audit.logs חשבון אחזור אירועים ביומן הביקורת של החשבון

הערה: נדרשת רק הרשאת גישה לקריאה. היקף ההרשאות account.audit.logs תקף גם לטוקנים של חשבונות וגם לטוקנים של משתמשים, אבל מומלץ להשתמש בטוקנים של חשבונות לשילובים של SIEM כי הם לא קשורים לסשן של משתמש ספציפי.

היקף	סוג הטוקן	מטרה
account.audit.logs	חשבון	אחזור אירועים ביומן הביקורת של החשבון

יצירת קטגוריה של Google Cloud Storage

נכנסים אל מסוף Google Cloud.
בוחרים פרויקט או יוצרים פרויקט חדש.
בתפריט הניווט, עוברים אל Cloud Storage > Buckets.
לוחצים על Create bucket.

מספקים את פרטי ההגדרה הבאים:

הגדרה	ערך
Name your bucket (שם הקטגוריה)	מזינים שם ייחודי גלובלית (לדוגמה, `lucid-audit-logs-gcs`)
סוג המיקום	בוחרים לפי הצרכים (אזור, שני אזורים, מספר אזורים)
Location	בוחרים את המיקום (לדוגמה, `us-central1`).
סוג אחסון (storage class)	רגיל (מומלץ ליומנים שמתבצעת אליהם גישה לעיתים קרובות)
בקרת גישה	אחיד (מומלץ)
כלים להגנה	אופציונלי: הפעלת ניהול גרסאות של אובייקטים או מדיניות שמירת נתונים

לוחצים על יצירה.

יצירת חשבון שירות לפונקציית Cloud Run

במסוף GCP, עוברים אל IAM & Admin > Service Accounts.
לוחצים על יצירת חשבון שירות.
מספקים את פרטי ההגדרה הבאים:
- שם חשבון השירות: מזינים lucid-audit-collector-sa
- תיאור חשבון השירות: מזינים Service account for Cloud Run function to collect Lucid audit logs
לוחצים על יצירה והמשך.
בקטע Grant this service account access to project (מתן גישה של חשבון השירות הזה לפרויקט), מוסיפים את התפקידים הבאים:
1. לוחצים על בחירת תפקיד.
2. מחפשים את Storage Object Admin ולוחצים עליו.
3. לוחצים על + הוספת תפקיד נוסף.
4. מחפשים את האפשרות Cloud Run Invoker (הפעלת שירותים ב-Cloud Run) ולוחצים עליה.
5. לוחצים על + הוספת תפקיד נוסף.
6. מחפשים את האפשרות Cloud Functions Invoker (הפעלת פונקציות של Cloud Functions) ולוחצים עליה.
לוחצים על Continue.
לוחצים על סיום.

מתן הרשאות IAM בקטגוריית GCS

עוברים אל Cloud Storage > Buckets (קטגוריות).
לוחצים על שם הקטגוריה (lucid-audit-logs-gcs).
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מספקים את פרטי ההגדרה הבאים:
- הוספת ישויות מורשות: מזינים את כתובת האימייל בחשבון של חשבון השירות (lucid-audit-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
- הקצאת תפקידים: בוחרים באפשרות אדמין של אובייקטים באחסון.
לוחצים על Save.

יצירת נושא Pub/Sub

במסוף GCP, עוברים אל Pub/Sub > Topics.
לוחצים על יצירת נושא.
מספקים את פרטי ההגדרה הבאים:
- מזהה הנושא: מזינים lucid-audit-trigger
- השארת ההגדרות האחרות כברירת מחדל
לוחצים על יצירה.

יצירת פונקציית Cloud Run לאיסוף יומנים

הפונקציה של Cloud Run תופעל על ידי הודעות Pub/Sub מ-Cloud Scheduler כדי לאחזר יומנים מ-Lucid Audit Logs API ולכתוב אותם ב-GCS.

במסוף GCP, עוברים אל Cloud Run.
לוחצים על יצירת שירות.
בוחרים באפשרות Function (שימוש בעורך ישיר ליצירת פונקציה).

בקטע Configure (הגדרה), מזינים את פרטי ההגדרה הבאים:

הגדרה	ערך
שם השירות	`lucid-audit-collector`
אזור	בוחרים אזור שתואם ל-GCS Bucket (לדוגמה, `us-central1`)
זמן ריצה	בוחרים באפשרות Python 3.12 ואילך.

בקטע טריגר (אופציונלי):
1. לוחצים על + הוספת טריגר.
2. בוחרים באפשרות Cloud Pub/Sub.
3. בקטע Select a Cloud Pub/Sub topic, בוחרים באפשרות lucid-audit-trigger.
4. לוחצים על Save.
בקטע Authentication:
1. בוחרים באפשרות דרישת אימות.
2. בודקים את ניהול זהויות והרשאות גישה (IAM).
הערה: מערכת Pub/Sub תטפל באימות באופן אוטומטי כשתפעיל את הפונקציה.
גוללים למטה ומרחיבים את Containers, Networking, Security (מאגרי תגים, רשתות, אבטחה).
עוברים לכרטיסייה אבטחה:
- חשבון שירות: בוחרים באפשרות lucid-audit-collector-sa

עוברים לכרטיסייה מאגרי תגים:

לוחצים על Variables & Secrets (משתנים וסודות).
לוחצים על + הוספת משתנה לכל משתנה סביבתי:

שם המשתנה	ערך לדוגמה	תיאור
`GCS_BUCKET`	`lucid-audit-logs-gcs`	שם קטגוריית GCS
`GCS_PREFIX`	`lucid-audit`	קידומת לקובצי יומן
`STATE_KEY`	`lucid-audit/state.json`	נתיב קובץ תמונת מצב
`LUCID_CLIENT_ID`	`your-oauth-client-id`	מזהה לקוח Lucid ב-OAuth 2.0
`LUCID_CLIENT_SECRET`	`your-oauth-client-secret`	סוד לקוח Lucid OAuth 2.0
`LUCID_REFRESH_TOKEN`	`your-refresh-token`	טוקן רענון של Lucid OAuth 2.0
`LOOKBACK_HOURS`	`24`	תקופת המבט לאחור הראשונית
`PAGE_SIZE`	`200`	רשומות בכל דף API (עד 200)
`MAX_PAGES`	`50`	מספר הדפים המקסימלי בכל הפעלה

בקטע Variables & Secrets, גוללים למטה אל Requests:
- זמן קצוב לתפוגת בקשה: מזינים 600 שניות (10 דקות)
עוברים לכרטיסייה הגדרות:
- בקטע Resources (מקורות מידע):
  - זיכרון: בוחרים באפשרות 512MiB או יותר
  - ‫CPU: בוחרים באפשרות 1
בקטע שינוי קנה מידה של העריכה:
- מספר מינימלי של מופעים: מזינים 0
- מספר מקרים מקסימלי: מזינים 100
לוחצים על יצירה.
ממתינים ליצירת השירות (1-2 דקות).
אחרי שיוצרים את השירות, עורך הקוד המוטבע נפתח באופן אוטומטי.

הוספת קוד פונקציה

מזינים main בשדה Entry point.
בעורך הקוד המוטבע, יוצרים שני קבצים:

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
  ```

לוחצים על Deploy כדי לשמור ולפרוס את הפונקציה.
ממתינים לסיום הפריסה (2-3 דקות).

הערה: הגדרת הטריגר Pub/Sub יוצרת באופן אוטומטי את המינויים וההרשאות הנדרשים.

יצירת משימה ב-Cloud Scheduler

במסוף GCP, עוברים אל Cloud Scheduler.
לוחצים על Create Job (יצירת משימה).

מספקים את פרטי ההגדרה הבאים:

הגדרה	ערך
שם	`lucid-audit-collector-hourly`
אזור	בחירה באותו אזור כמו פונקציית Cloud Run
תדירות	‫`0 * * * *` (כל שעה, בדיוק בשעה)
אזור זמן	בחירת אזור זמן (מומלץ לבחור UTC)
סוג הטירגוט	Pub/Sub
נושא	בחירת `lucid-audit-trigger`
גוף ההודעה	‫`{}` (אובייקט JSON ריק)

לוחצים על יצירה.

בדיקת השילוב

במסוף Cloud Scheduler, מאתרים את המשימה (lucid-audit-collector-hourly).
לוחצים על הפעלת המשימה בכוח כדי להפעיל את המשימה באופן ידני.
מחכים כמה שניות.
עוברים אל Cloud Run > Services.
לוחצים על lucid-audit-collector.
לוחצים על הכרטיסייה Logs (יומנים).

מוודאים שהפונקציה בוצעה בהצלחה. מחפשים:

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

עוברים אל Cloud Storage > Buckets (קטגוריות).
לוחצים על lucid-audit-logs-gcs.
עוברים לתיקייה lucid-audit/.
מוודאים שנוצר קובץ .ndjson חדש עם חותמת הזמן הנוכחית.

אם מופיעות שגיאות ביומנים:

HTTP 401: מוודאים שמשתני הסביבה LUCID_CLIENT_ID,‏ LUCID_CLIENT_SECRET ו-LUCID_REFRESH_TOKEN נכונים
‫HTTP 403: מוודאים שללקוח OAuth 2.0 יש היקף הרשאות account.audit.logs והאסימון הוא אסימון חשבון
‫HTTP 429: הגבלת קצב – הפונקציה תפסיק את המספור העמודים ותמשיך בהפעלה המתוזמנת הבאה
משתני סביבה חסרים: מוודאים שכל המשתנים הנדרשים מוגדרים בהגדרות של פונקציית Cloud Run

קטגוריות של אירועים ביומן הביקורת

יומני הביקורת של Lucid מאורגנים לפי קטגוריות האירועים הבאות:

קטגוריה	תיאור
התחברויות	אירועים שמשויכים להתחברויות של משתמשים
תוכן	אירועים שקשורים לגישה למסמכים ולתיקיות ולשינוי שלהם
ניהול	אירועים שקשורים לפעילות של אדמינים ולשינויים בחשבון
משתמש	אירועים שמשויכים לפעולות של משתמשים בהגדרות אישיות
צוות	אירועים שקשורים לפעולות של צוותים

רשימה מלאה של סוגי האירועים והסכימות שלהם זמינה במסמכי התיעוד בנושא אירועים ביומן הביקורת של Lucid.

סביבת FedRAMP

משתמשים בסביבת Lucid FedRAMP משתמשים בנקודות קצה שונות של API ובהרשאות שונות. כתובות ה-URL הנכונות של נקודות הקצה מפורטות במסמכי התיעוד של סביבת Lucid FedRAMP.

אחזור חשבון השירות של Google SecOps

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על Configure a single feed (הגדרת פיד יחיד).
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Lucid Audit Logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Lucid בתור סוג היומן.
לוחצים על קבלת חשבון שירות. תוצג כתובת האימייל בחשבון שירות ייחודי, לדוגמה:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
מעתיקים את כתובת האימייל הזו לשימוש בשלב הבא.

הערה: לכל מופע של Google SecOps יש חשבון שירות ייחודי. אל תשתמשו בחשבונות שירות ממסמכים או מדוגמאות אחרים.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:
```
gs://lucid-audit-logs-gcs/lucid-audit/
```
הערה: תמיד צריך לכלול את התו '/' בסוף ה-URI.
- אפשרות למחיקת המקור: בוחרים את אפשרות המחיקה לפי ההעדפה שלכם:
  - אף פעם: לא נמחקים קבצים אחרי ההעברה (מומלץ לבדיקות).
  - מחיקת קבצים שהועברו: הקבצים נמחקים אחרי שההעברה מסתיימת.
  - מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת בהצלחה.
    
    הערה: אם בוחרים באפשרות מחיקה, לחשבון השירות צריך להיות התפקיד Storage Object Admin ולא Storage Object Viewer. מעדכנים את ההרשאות ב-IAM בהתאם.
- הגיל המקסימלי של הקובץ: כולל קבצים ששונו במספר הימים האחרון (ברירת המחדל היא 180 ימים)
- מרחב השמות של הנכס: מרחב השמות של הנכס
- תוויות להוספה: התווית שתתווסף לאירועים מהפיד הזה
לוחצים על הבא.
בודקים את ההגדרות של הפיד החדש במסך סיום ולוחצים על שליחה.

הענקת הרשאות IAM לחשבון השירות של Google SecOps

לחשבון השירות של Google SecOps צריך להיות התפקיד צפייה באובייקט אחסון בקטגוריה של GCS.

עוברים אל Cloud Storage > Buckets (קטגוריות).
לוחצים על lucid-audit-logs-gcs.
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מספקים את פרטי ההגדרה הבאים:
- Add principals (הוספת ישויות מורשות): מדביקים את כתובת האימייל בחשבון של חשבון השירות של Google SecOps
- הקצאת תפקידים: בוחרים באפשרות צפייה באובייקטים באחסון.
לוחצים על Save.

הערה: אם אתם מתכננים להשתמש באפשרות המחיקה 'מחיקת קבצים שהועברו' או 'מחיקת קבצים שהועברו וספריות ריקות', צריך להעניק את התפקיד Storage Object Admin במקום Storage Object Viewer.

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	היגיון
document_opened	additional.fields	אם השדה לא ריק, הוא ימוזג עם תוויות שנוצרו מכל שדה מקור
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	הערך שמוגדר לאירועי התחברות/התנתקות הוא AUTHTYPE_UNSPECIFIED
eventTimestamp	metadata.event_timestamp	ההמרה מתבצעת באמצעות התאמת תאריך לפורמט ISO8601 או לפורמט yyyy-MM-ddTHH:mm:ss.SSSSSSZ
has_user_login	metadata.event_type	הערך מוגדר על סמך הדגלים has_*:‏ USER_LOGIN אם הדגלים has_user_login ו-has_target_user מוגדרים, USER_LOGOUT אם הדגלים has_user_logout ו-has_target_user מוגדרים, USER_RESOURCE_UPDATE_CONTENT אם הדגלים has_user_resource_updated,‏ has_target_resource ו-has_principal_user מוגדרים, USER_CREATION אם הדגלים has_principal_user,‏ has_target_application ו-has_target_user מוגדרים, USER_RESOURCE_CREATION אם הדגלים has_target_resource ו-has_principal_user מוגדרים, FILE_CREATION אם הדגלים has_target_file,‏ has_principal ו-has_target מוגדרים, USER_RESOURCE_ACCESS אם הדגל has_target_resource מוגדר, USER_COMMUNICATION אם הדגל has_principal_user מוגדר, STATUS_UPDATE אם הדגלים has_principal ו-has_target מוגדרים כ-false, אחרת 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	הערך הועתק ישירות
actor.actorIp	principal.asset.ip	הערך מועתק ישירות אם הוא לא ריק
actor.actorIp	principal.ip	הערך מועתק ישירות אם הוא לא ריק
actor.actorAccountId	principal.resource.id	הערך מועתק ישירות אם הוא לא ריק
actor.actorClient	principal.resource.name	הערך מועתק ישירות אם הוא לא ריק
flowId	principal.resource.product_object_id	הערך מועתק ישירות אם הוא לא ריק
actor.actorType	principal.user.attribute.roles	המיזוג מתבצע מ-actor_type אם eventType הוא לא login/logout ו-actor_type לא ריק
actor.actorEmail	principal.user.email_addresses	האירועים ימוזגו אם actor_email לא ריק והוא כתובת אימייל תקינה, וגם אם eventType הוא לא login או logout
actor.actorUserId	principal.user.userid	הערך מועתק ישירות אם הוא לא ריק ו-eventType הוא לא login/logout
event1.registrationMethod	security_result.description	הערך מועתק ישירות אם הוא לא ריק
event1.source	target.application	הערך מועתק ישירות אם הוא לא ריק
event1.publishedLink.link	target.file.full_path	הערך מועתק ישירות אם הוא לא ריק
event1.filename	target.file.names	אם הוא לא ריק, הוא ימוזג
targetData._targetType	target.resource.attribute.labels	אם השדה לא ריק, הוא ימוזג עם תוויות שנוצרו מכל שדה מקור
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	הערך מועתק ישירות אם הוא לא ריק
event1.destinationFolderName	target.resource.name	הערך מוגדר ל-destinationFolderName אם הוא לא ריק, אחרת ל-folderName אם הוא לא ריק, אחרת ל-publishedLink.name אם הוא לא ריק
event1.folderName	target.resource.name
event1.publishedLink.name	target.resource.name
event1.documentId	target.resource.product_object_id	הערך מועתק ישירות אם הוא לא ריק
actor.actorType	target.user.attribute.roles	המיזוג מתבצע מ-actor_type אם eventType הוא login/logout, ומ-event_role אם הוא לא ריק
event1.role	target.user.attribute.roles
actor.actorEmail	target.user.email_addresses	המידע ממוזג מ-actor_email אם מדובר בכניסה או ביציאה מהחשבון והוא תקף, ומ-userEmail ב-‎_target
targetData.userEmail	target.user.email_addresses
event1.destinationFolderId	target.user.product_object_id	הערך מוגדר ל-destinationFolderId אם הוא לא ריק, אחרת ל-folderId אם הוא לא ריק
event1.folderId	target.user.product_object_id
targetData.displayName	target.user.user_display_name	הערך מועתק ישירות אם הוא לא ריק
actor.actorUserId	target.user.userid	הערך מועתק ישירות אם הוא לא ריק וסוג האירוע הוא התחברות או התנתקות
event1.product	metadata.product_name	הערך מהמוצר אם הוא לא ריק, אחרת הערך הוא LUCID
metadata.vendor_name	metadata.vendor_name	הגדרה כ-LUCID

יומן שינויים

צפייה ביומן השינויים של מנתח התוכן הזה

הבעיה עדיין לא נפתרה? קבלת תשובות מחברי הקהילה וממומחי Google SecOps.