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

נתמכים ב:

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

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

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

חשוב לוודא שיש לכם את הדברים הבאים:

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

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

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

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

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

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

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

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

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

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

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

  7. לוחצים על Create OAuth 2.0 client.

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

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

  • מזהה לקוח: מזהה הלקוח הייחודי שלכם.
  • סוד לקוח: מפתח ה-API הסודי שלכם.

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

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

  1. בדף ההגדרות של OAuth 2.0, לוחצים על Add Redirect URI.
  2. מזינים את ה-URI להפניה אוטומטית של השילוב. אם משתמשים בהפניה לכתובת URL לבדיקה שסופקה על ידי Lucid, מזינים:

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

    מחליפים את <CLIENT_ID> במזהה הלקוח בפועל.

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

כדי להשתמש ב-API של יומני ביקורת, צריך טוקן של חשבון (ולא טוקן של משתמש). אדמין בחשבון צריך לאשר ללקוח OAuth 2.0 ליצור אסימון בשם החשבון.

  1. מפנים אדמין בחשבון לכתובת ה-URL הבאה להרשאה בדפדפן:

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

    מחליפים את <CLIENT_ID> ו-<REDIRECT_URI> בערכים בפועל.

  2. האדמין בודק את ההרשאות המבוקשות במסך ההסכמה ולוחץ על אישור.

  3. ‫Lucid מפנה לכתובת ה-URI להפניה אוטומטית עם פרמטר שאילתה של הרשאת code.

  4. כדי להחליף את קוד ההרשאה בטוקן גישה, שולחים בקשת 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>"
      }'
    
  5. התשובה כוללת 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 חשבון אחזור אירועים ביומן הביקורת של החשבון

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

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

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

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

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

הענקת הרשאות IAM בקטגוריה של Cloud Storage

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

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

  1. במסוף Google Cloud , נכנסים לדף Pub/Sub > Topics.
  2. לוחצים על Create topic.
  3. מזינים את פרטי ההגדרה הבאים:
    • מזהה הנושא: מזינים lucid-audit-trigger
    • משאירים את שאר ההגדרות כברירת מחדל.
  4. לוחצים על יצירה.

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

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

  1. נכנסים לדף Cloud Run במסוף Google Cloud .
  2. לוחצים על Create service.
  3. בוחרים באפשרות Function (שימוש בעורך ישיר כדי ליצור פונקציה).
  4. בקטע Configure, מזינים את פרטי ההגדרה הבאים:

    הגדרה ערך
    שם השירות lucid-audit-collector
    אזור בוחרים את האזור שתואם לקטגוריה של Cloud Storage (לדוגמה, us-central1)
    זמן ריצה בוחרים באפשרות Python 3.12 ואילך.
  5. בקטע טריגר (אופציונלי):

    1. לוחצים על + הוספת טריגר.
    2. בוחרים באפשרות Cloud Pub/Sub.
    3. בקטע Select a Cloud Pub/Sub topic, בוחרים את lucid-audit-trigger.
    4. לוחצים על Save.
  6. בקטע Authentication:

    1. לוחצים על דרישת אימות.
    2. בודקים את ניהול הזהויות והרשאות הגישה (IAM).
  7. גוללים למטה ומרחיבים את Containers, Networking, Security.

  8. עוברים לכרטיסייה אבטחה:

    • חשבון שירות: בוחרים באפשרות lucid-audit-collector-sa
  9. עוברים לכרטיסייה Containers:

    1. לוחצים על Variables & Secrets.
    2. לוחצים על ‎+ Add variable לכל משתנה סביבה:
    שם משתנה ערך לדוגמה תיאור
    GCS_BUCKET lucid-audit-logs-gcs שם הקטגוריה של Cloud Storage
    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 מספר הדפים המקסימלי בכל הפעלה
  10. בקטע Variables & Secrets, גוללים למטה אל Requests:

    • ‫Request timeout (זמן קצוב לתפוגה של בקשה): מזינים 600 שניות (10 דקות)
  11. עוברים לכרטיסייה הגדרות:

    • בקטע Resources:
      • זיכרון: בוחרים באפשרות ‎512 MiB או יותר
      • מעבד (CPU): בוחרים באפשרות 1.
  12. בקטע Revision scaling:

    • Minimum number of instances: מזינים 0
    • Maximum number of instances: מזינים 100
  13. לוחצים על יצירה.

  14. ממתינים ליצירת השירות (דקה או שתיים).

  15. אחרי שיוצרים את השירות, עורך הקוד המוטבע נפתח באופן אוטומטי.

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

  1. בשדה Entry point, מזינים main.
  2. בכלי לעריכת קוד, יוצרים שני קבצים:
  • 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. לוחצים על Deploy כדי לשמור ולפרוס את הפונקציה.
  2. מחכים שהפריסה תסתיים (2-3 דקות).

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

  1. במסוף Google Cloud , נכנסים לדף Cloud Scheduler.
  2. לוחצים על Create Job.
  3. ממלאים את פרטי ההגדרה הבאים:

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

בדיקת השילוב

  1. במסוף Cloud Scheduler, מאתרים את המשימה (lucid-audit-collector-hourly).
  2. לוחצים על Force run כדי להפעיל את המשימה באופן ידני.
  3. מחכים כמה שניות.
  4. עוברים אל Cloud Run > Services.
  5. לוחצים על lucid-audit-collector.
  6. לוחצים על הכרטיסייה Logs.
  7. מוודאים שהפונקציה בוצעה בהצלחה. חפשו את:

    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. נכנסים לדף Cloud Storage > Buckets.

  9. לוחצים על lucid-audit-logs-gcs.

  10. עוברים לתיקייה lucid-audit/.

  11. מוודאים שנוצר קובץ .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

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמת SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Lucid Audit Logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Lucid בתור סוג היומן.
  7. לוחצים על Get Service Account (קבלת חשבון שירות). תוצג כתובת אימייל ייחודית של חשבון שירות, לדוגמה:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  8. מעתיקים את כתובת האימייל הזו כדי להשתמש בה בשלב הבא.

  9. לוחצים על הבא.

  10. מציינים ערכים לפרמטרים הבאים של הקלט:

    • כתובת ה-URL של קטגוריה של Cloud Storage: מזינים את ה-URI של קטגוריה של Cloud Storage עם נתיב הקידומת:

      gs://lucid-audit-logs-gcs/lucid-audit/
      
    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:

      • אף פעם: לא מוחק קבצים אחרי העברות (מומלץ לבדיקה).
      • מחיקת קבצים שהועברו: מחיקת קבצים אחרי שהועברו בהצלחה.
      • מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי העברה מוצלחת.

    • גיל הקובץ המקסימלי: הכללת קבצים ששונו במספר הימים האחרונים (ברירת המחדל היא 180 ימים)

    • מרחב השמות של הנכס: מרחב השמות של הנכס

    • תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה

  11. לוחצים על הבא.

  12. בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

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

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

  1. נכנסים לדף Cloud Storage > Buckets.
  2. לוחצים על lucid-audit-logs-gcs.
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מזינים את פרטי ההגדרה הבאים:
    • Add principals: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
    • הקצאת תפקידים: בוחרים באפשרות צפייה באובייקטים של אחסון.
  6. לוחצים על Save.

טבלת מיפוי 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 הוא לא התחברות/התנתקות ו-actor_type לא ריק
actor.actorEmail principal.user.email_addresses מיזוג אם actor_email לא ריק, כתובת האימייל תקינה ו-eventType הוא לא התחברות/התנתקות
actor.actorUserId principal.user.userid הערך מועתק ישירות אם הוא לא ריק וסוג האירוע הוא לא התחברות או התנתקות
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 הוא התחברות/התנתקות, ומ-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.