איסוף יומנים של פלטפורמת ZeroFox

נתמך ב:

במאמר הזה מוסבר איך להטמיע יומנים של פלטפורמת ZeroFox ב-Google Security Operations באמצעות Google Cloud Storage. פלטפורמת ZeroFox מספקת הגנה מפני סיכונים במרחב הדיגיטלי על ידי מעקב אחרי איומים וניתוח שלהם ברשתות החברתיות, באפליקציות לנייד, בענן, באימייל ובערוצים דיגיטליים אחרים.

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

ודאו שאתם עומדים בדרישות המוקדמות הבאות:

  • מכונה של Google SecOps
  • פרויקט ב-GCP שבו מופעל Cloud Storage API
  • הרשאות ליצירה ולניהול של קטגוריות ב-GCS
  • הרשאות לניהול מדיניות IAM בקטגוריות של GCS
  • הרשאות ליצירת שירותי Cloud Run, נושאי Pub/Sub ומשימות ב-Cloud Scheduler
  • גישה מורשית לדייר (tenant) בפלטפורמת ZeroFox

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

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

  5. ממלאים את פרטי ההגדרה הבאים:

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

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

איסוף פרטי הכניסה לפלטפורמת ZeroFox

קבלת טוקן גישה אישי ל-ZeroFox

  1. נכנסים לפלטפורמת ZeroFox בכתובת https://cloud.zerofox.com.
  2. עוברים אל הגדרות > חיבורי נתונים > פידים של נתוני API.
    • כתובת URL ישירה (אחרי ההתחברות): https://cloud.zerofox.com/data_connectors/api
    • הערה: אם האפשרות הזו לא מופיעה בתפריט, צריך לפנות לאדמין ב-ZeroFox כדי לקבל גישה. יכול להיות שהתפריט יופיע גם עם התווית מחברים של מקורות נתונים חיצוניים > פידים של נתוני API, בהתאם לגרסת ממשק המשתמש של הדייר (tenant).
  3. לוחצים על Generate Token (יצירת טוקן) או על Create Personal Access Token (יצירת טוקן גישה אישי).
  4. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים שם תיאורי (לדוגמה, Google SecOps GCS Ingestion).
    • ‫Expiration: בוחרים תקופת רוטציה בהתאם למדיניות האבטחה של הארגון.
    • הרשאות/פידים: בוחרים הרשאות קריאה עבור:
      • התראות
      • פידים של CTI
      • סוגי נתונים אחרים שרוצים לייצא
  5. לוחצים על יצירה.
  6. מעתיקים ושומרים את טוקן הגישה שנוצר במיקום מאובטח (לא תהיה אפשרות לראות אותו שוב).

  7. שומרים את ZEROFOX_BASE_URL: https://api.zerofox.com (ברירת המחדל לרוב הדיירים).

אימות ההרשאות

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

  1. נכנסים לפלטפורמת ZeroFox.
  2. עוברים אל הגדרות (⚙️) > חיבורי נתונים > פידים של נתוני API.
  3. אם אתם רואים את הקטע פידים של נתוני API ויכולים ליצור טוקנים, יש לכם את ההרשאות הנדרשות.
  4. אם האפשרות הזו לא מופיעה, פנו לאדמין כדי לקבל הרשאות גישה ל-API.

בדיקת הגישה ל-API

  • לפני שממשיכים בתהליך השילוב, בודקים את פרטי הכניסה:

    # Replace with your actual credentials
ZEROFOX_API_TOKEN="your-personal-access-token"
ZEROFOX_BASE_URL="https://api.zerofox.com"

# Test API access (example endpoint - adjust based on your data type)
curl -v -H "Authorization: Bearer $ZEROFOX_API_TOKEN" \
  -H "Accept: application/json" \
  "$ZEROFOX_BASE_URL/v1/alerts?limit=1"

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

לפונקציית Cloud Run נדרש חשבון שירות עם הרשאות כתיבה בקטגוריית GCS, וצריך להפעיל אותה באמצעות Pub/Sub.

יצירת חשבון שירות

  1. במסוף GCP, נכנסים לדף IAM & Admin > Service Accounts.
  2. לוחצים על Create Service Account.
  3. מזינים את פרטי ההגדרה הבאים:
    • שם חשבון השירות: מזינים zerofox-logs-collector-sa.
    • Service account description: מזינים Service account for Cloud Run function to collect ZeroFox Platform 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. לוחצים על סיום.

התפקידים האלה נדרשים כדי:

  • אדמין של אובייקט אחסון: כתיבת יומנים לקטגוריית GCS וניהול קובצי תמונת מצב
  • Cloud Run Invoker: מאפשר ל-Pub/Sub להפעיל את הפונקציה
  • מפעיל פונקציות של Cloud Functions: מאפשר להפעיל פונקציות

הענקת הרשאות IAM בקטגוריית GCS

נותנים לחשבון השירות (zerofox-logs-collector-sa) הרשאות כתיבה בקטגוריה של GCS:

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

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

יוצרים נושא Pub/Sub ש-Cloud Scheduler יפרסם בו ופונקציית Cloud Run תירשם אליו.

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

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

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

  1. במסוף GCP, נכנסים ל-Cloud Run.
  2. לוחצים על Create service.
  3. בוחרים באפשרות Function (שימוש בעורך ישיר כדי ליצור פונקציה).

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

    הגדרה ערך
    שם השירות zerofox-logs-collector
    אזור בוחרים את האזור שתואם לקטגוריית ה-GCS (לדוגמה, us-central1)
    זמן ריצה בוחרים באפשרות Python 3.12 או גרסה עדכנית יותר.

  5. בקטע טריגר (אופציונלי):

    1. לוחצים על + הוספת טריגר.
    2. בוחרים באפשרות Cloud Pub/Sub.
    3. בקטע Select a Cloud Pub/Sub topic, בוחרים את הנושא ב-Pub/Sub‏ (zerofox-logs-trigger).
    4. לוחצים על Save.

  6. בקטע אימות:

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

  7. גוללים למטה ומרחיבים את הקטע Containers, Networking, Security.

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

    • ‫Service account: בוחרים את חשבון השירות (zerofox-logs-collector-sa).

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

    1. לוחצים על Variables & Secrets.
    2. לוחצים על ‎+ Add variable לכל משתנה סביבה:
    שם משתנה ערך לדוגמה תיאור
    GCS_BUCKET zerofox-platform-logs שם הקטגוריה ב-GCS
    GCS_PREFIX zerofox/platform קידומת לקובצי יומן
    STATE_KEY zerofox/platform/state.json נתיב קובץ תמונת המצב
    ZEROFOX_BASE_URL https://api.zerofox.com כתובת ה-URL הבסיסית של ה-API
    ZEROFOX_API_TOKEN your-zerofox-personal-access-token טוקן גישה אישי
    LOOKBACK_HOURS 24 תקופת המבט לאחור הראשונית
    PAGE_SIZE 200 רשומות בכל דף
    MAX_PAGES 20 מספר הדפים המקסימלי בכל הפעלה
    HTTP_TIMEOUT 60 זמן קצוב לתפוגה של בקשת HTTP בשניות
    HTTP_RETRIES 3 מספר הניסיונות החוזרים של HTTP
    URL_TEMPLATE (אופציונלי) תבנית של כתובת URL מותאמת אישית עם {SINCE}, {PAGE_TOKEN}, {PAGE_SIZE}

  10. בקטע Variables & Secrets, גוללים למטה אל Requests:

    • ‫Request timeout: מזינים 600 שניות (10 דקות).

  11. עוברים לכרטיסייה הגדרות:

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

  12. בקטע Revision scaling:

    • מספר מינימלי של מכונות: מזינים 0.
    • Maximum number of instances: מזינים 100 (או משנים בהתאם לעומס הצפוי).

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

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

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

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

  1. מזינים main בשדה Function entry point.

  2. בעורך הקוד, יוצרים שני קבצים:

    • הקובץ הראשון: main.py:
    import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time
import urllib.parse

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=30.0),
    retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'zerofox/platform')
STATE_KEY = os.environ.get('STATE_KEY', 'zerofox/platform/state.json')
ZEROFOX_BASE_URL = os.environ.get('ZEROFOX_BASE_URL', 'https://api.zerofox.com')
ZEROFOX_API_TOKEN = os.environ.get('ZEROFOX_API_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', '20'))
HTTP_TIMEOUT = int(os.environ.get('HTTP_TIMEOUT', '60'))
HTTP_RETRIES = int(os.environ.get('HTTP_RETRIES', '3'))
URL_TEMPLATE = os.environ.get('URL_TEMPLATE', '')

def parse_datetime(value: str) -> datetime:
    """Parse ISO datetime string to datetime object."""
    if value.endswith("Z"):
        value = value[:-1] + "+00:00"
    return datetime.fromisoformat(value)

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch ZeroFox Platform logs and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    if not all([GCS_BUCKET, ZEROFOX_BASE_URL, ZEROFOX_API_TOKEN]):
        print('Error: Missing required environment variables')
        return

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(GCS_BUCKET)

        # Load state
        state = load_state(bucket, STATE_KEY)

        # Determine time window
        now = datetime.now(timezone.utc)
        last_time = None

        if isinstance(state, dict) and state.get("last_since"):
            try:
                last_time = parse_datetime(state["last_since"])
                # Overlap by 2 minutes to catch any delayed events
                last_time = last_time - timedelta(minutes=2)
            except Exception as e:
                print(f"Warning: Could not parse last_since: {e}")

        if last_time is None:
            last_time = now - timedelta(hours=LOOKBACK_HOURS)

        since_iso = last_time.strftime('%Y-%m-%dT%H:%M:%SZ')
        print(f"Fetching logs since {since_iso}")

        # Fetch logs
        records, newest_since = fetch_logs(
            api_base=ZEROFOX_BASE_URL,
            api_token=ZEROFOX_API_TOKEN,
            since=since_iso,
            page_size=PAGE_SIZE,
            max_pages=MAX_PAGES,
        )

        if not records:
            print("No new log records found.")
            save_state(bucket, STATE_KEY, since_iso)
            return

        # Write to GCS as NDJSON
        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = f"{GCS_PREFIX}/logs_{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}")

        # Update state with newest timestamp
        if newest_since:
            save_state(bucket, STATE_KEY, newest_since)
        else:
            save_state(bucket, STATE_KEY, since_iso)

        print(f"Successfully processed {len(records)} records")

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

def load_state(bucket, key):
    """Load state from GCS."""
    try:
        blob = bucket.blob(key)
        if blob.exists():
            state_data = blob.download_as_text()
            return json.loads(state_data)
    except Exception as e:
        print(f"Warning: Could not load state: {e}")

    return {}

def save_state(bucket, key, last_since: str):
    """Save the last since timestamp to GCS state file."""
    try:
        state = {'last_since': last_since}
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
        )
        print(f"Saved state: last_since={last_since}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

def fetch_logs(api_base: str, api_token: str, since: str, page_size: int, max_pages: int):
    """
    Fetch logs from ZeroFox Platform API with pagination and rate limiting.

    Args:
        api_base: API base URL
        api_token: Personal access token
        since: ISO timestamp for filtering logs
        page_size: Number of records per page
        max_pages: Maximum pages to fetch

    Returns:
        Tuple of (records list, newest_since ISO string)
    """
    # Use URL_TEMPLATE if provided, otherwise construct default alerts endpoint
    if URL_TEMPLATE:
        base_url = URL_TEMPLATE.replace("{SINCE}", urllib.parse.quote(since))
    else:
        base_url = f"{api_base}/v1/alerts?since={urllib.parse.quote(since)}"

    headers = {
        'Authorization': f'Bearer {api_token}',
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'User-Agent': 'GoogleSecOps-ZeroFoxCollector/1.0'
    }

    records = []
    newest_since = since
    page_num = 0
    page_token = ""
    backoff = 1.0

    while page_num < max_pages:
        page_num += 1

        # Construct URL with pagination
        if URL_TEMPLATE:
            url = (base_url
                   .replace("{PAGE_TOKEN}", urllib.parse.quote(page_token))
                   .replace("{PAGE_SIZE}", str(page_size)))
        else:
            url = f"{base_url}&limit={page_size}"
            if page_token:
                url += f"&page_token={urllib.parse.quote(page_token)}"

        attempt = 0
        while attempt <= HTTP_RETRIES:
            try:
                response = http.request('GET', url, headers=headers, timeout=HTTP_TIMEOUT)

                # Handle rate limiting with exponential backoff
                if response.status == 429:
                    retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
                    print(f"Rate limited (429). Retrying after {retry_after}s...")
                    time.sleep(retry_after)
                    backoff = min(backoff * 2, 30.0)
                    attempt += 1
                    continue

                backoff = 1.0

                if response.status != 200:
                    print(f"HTTP Error: {response.status}")
                    response_text = response.data.decode('utf-8')
                    print(f"Response body: {response_text}")
                    return records, newest_since

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

                # Extract results (try multiple possible keys)
                page_results = []
                for key in ('results', 'data', 'alerts', 'items', 'logs', 'events'):
                    if isinstance(data.get(key), list):
                        page_results = data[key]
                        break

                if not page_results:
                    print(f"No more results (empty page)")
                    return records, newest_since

                print(f"Page {page_num}: Retrieved {len(page_results)} events")
                records.extend(page_results)

                # Track newest timestamp
                for event in page_results:
                    try:
                        # Try multiple possible timestamp fields
                        event_time = (event.get('timestamp') or 
                                    event.get('created_at') or 
                                    event.get('last_modified') or 
                                    event.get('event_time') or 
                                    event.get('log_time') or 
                                    event.get('updated_at'))
                        if event_time and isinstance(event_time, str):
                            if event_time > newest_since:
                                newest_since = event_time
                    except Exception as e:
                        print(f"Warning: Could not parse event time: {e}")

                # Check for next page token
                next_token = (data.get('next') or 
                            data.get('next_token') or 
                            data.get('nextPageToken') or 
                            data.get('next_page_token'))

                if isinstance(next_token, dict):
                    next_token = (next_token.get('token') or 
                                next_token.get('cursor') or 
                                next_token.get('value'))

                if not next_token:
                    print("No more pages (no next token)")
                    return records, newest_since

                page_token = str(next_token)
                break

            except urllib3.exceptions.HTTPError as e:
                if attempt < HTTP_RETRIES:
                    print(f"HTTP error (attempt {attempt + 1}/{HTTP_RETRIES}): {e}")
                    time.sleep(1 + attempt)
                    attempt += 1
                    continue
                else:
                    print(f"Error fetching logs after {HTTP_RETRIES} retries: {e}")
                    return records, newest_since
            except Exception as e:
                print(f"Error fetching logs: {e}")
                return records, newest_since

    print(f"Retrieved {len(records)} total records from {page_num} pages")
    return records, newest_since
    • הקובץ השני: requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

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

  4. מחכים שהפריסה תסתיים (2-3 דקות).

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

‫Cloud Scheduler מפרסם הודעות בנושא Pub/Sub‏ (zerofox-logs-trigger) במרווחי זמן קבועים, ומפעיל את פונקציית Cloud Run.

  1. במסוף GCP, נכנסים ל-Cloud Scheduler.
  2. לוחצים על Create Job.

  3. ממלאים את פרטי ההגדרה הבאים:

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

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

אפשרויות לתדירות התזמון

  • בוחרים את התדירות בהתאם לנפח היומן ולדרישות לגבי זמן האחזור:

    תדירות ביטוי Cron תרחיש לדוגמה
    כל 5 דקות */5 * * * * נפח גבוה, זמן אחזור נמוך
    כל 15 דקות */15 * * * * נפח חיפושים בינוני
    כל שעה 0 * * * * רגיל (מומלץ)
    כל 6 שעות 0 */6 * * * נפח נמוך, עיבוד ברצף (batch processing)
    יומי 0 0 * * * איסוף נתונים היסטוריים

בדיקת השילוב

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

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

    Fetching logs since YYYY-MM-DDTHH:MM:SSZ
Page 1: Retrieved X events
Wrote X records to gs://zerofox-platform-logs/zerofox/platform/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. נכנסים לדף Cloud Storage > Buckets.

  9. לוחצים על שם הקטגוריה (zerofox-platform-logs).

  10. עוברים לתיקיית הקידומת (zerofox/platform/).

  11. מוודאים שנוצר קובץ .ndjson חדש עם חותמת הזמן הנוכחית.

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

  • ‫HTTP 401: בודקים את פרטי הכניסה ל-API במשתני הסביבה. צריך לוודא שהערך של ZEROFOX_API_TOKEN נכון ושהתוקף שלו לא פג.
  • ‫HTTP 403: מוודאים שלחשבון ZeroFox יש את ההרשאות הנדרשות להתראות ולפידים של CTI. עוברים אל הגדרות > חיבורי נתונים > פידים של נתוני API ובודקים את הרשאות הטוקן.
  • ‫HTTP 404: יכול להיות שנקודת הקצה (endpoint) שמוגדרת כברירת מחדל ב-/v1/alerts לא מתאימה לדייר (tenant) שלכם. מגדירים את משתנה הסביבה URL_TEMPLATE כך שיתאים למאמרי העזרה של ה-API של ZeroFox, או פונים לתמיכה של ZeroFox.
  • ‫HTTP 429: הגבלת קצב של יצירת בקשות – הפונקציה תנסה שוב באופן אוטומטי עם השהיה מעריכית לפני ניסיון חוזר (exponential backoff).
  • משתני סביבה חסרים: ודאו שכל המשתנים הנדרשים מוגדרים בהגדרות של פונקציית Cloud Run.

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

מערכת Google SecOps משתמשת בחשבון שירות ייחודי כדי לקרוא נתונים מהקטגוריה שלכם ב-GCS. אתם צריכים לתת לחשבון השירות הזה גישה לקטגוריה שלכם.

איך מקבלים את כתובת האימייל של חשבון השירות

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, ZeroFox Platform Logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות ZeroFox Platform בתור Log type.

  7. לוחצים על Get Service Account (קבלת חשבון שירות). מוצגת כתובת אימייל ייחודית של חשבון שירות, לדוגמה:

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

  8. מעתיקים את כתובת האימייל הזו כדי להשתמש בה בשלב הבא.

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

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

  1. נכנסים לדף Cloud Storage > Buckets.
  2. לוחצים על שם הקטגוריה (zerofox-platform-logs).
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מזינים את פרטי ההגדרה הבאים:
    • הוספת חשבונות משתמשים: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
    • הקצאת תפקידים: בוחרים באפשרות צפייה באובייקטים באחסון.

  6. לוחצים על Save.

הגדרת פיד ב-Google SecOps כדי להטמיע יומנים מפלטפורמת ZeroFox

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, ZeroFox Platform Logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות ZeroFox Platform בתור Log type.
  7. לוחצים על הבא.

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

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

      gs://zerofox-platform-logs/zerofox/platform/

      • מחליפים את:

        • ‫zerofox-platform-logs: השם של קטגוריית GCS.
        • ‫zerofox/platform: נתיב הקידומת או התיקייה שבהם נשמרים היומנים.

    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:

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

      • מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת.

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

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

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

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

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

טבלת מיפוי UDM

שדה ביומן מיפוי UDM Logic (פונקציה לוגית)
ai_confidence_display_color_label additional.fields ממוזג
ai_confidence_display_icon_label additional.fields ממוזג
ai_confidence_display_name_label additional.fields ממוזג
arecord_list additional.fields ממוזג
browser_label additional.fields ממוזג
created_at_label additional.fields ממוזג
model_name_label additional.fields ממוזג
mx_record_list additional.fields ממוזג
ns_record_list additional.fields ממוזג
redirect_list additional.fields ממוזג
screenshot_label additional.fields ממוזג
soa_record_list additional.fields ממוזג
tag_list additional.fields ממוזג
tier_1_2_label additional.fields ממוזג
tier_1_label additional.fields ממוזג
tier_2_label additional.fields ממוזג
timestamp_modify_tags_label additional.fields ממוזג
txt_record_list additional.fields ממוזג
whois_label additional.fields ממוזג
metadata1 metadata שינוי שם/מיפוי
created_at metadata.event_timestamp נותח בתור ISO8601
timestamp metadata.event_timestamp נותח בתור ISO8601
event_metadata.navigation_metadata.user_agent network.http.user_agent מיפוי ישיר
event_metadata.unicode_domain_name principal.administrative_domain מיפוי ישיר
asset.id principal.asset.asset_id מיפוי ישיר
device_name_label principal.asset.attribute.labels ממוזג
ip principal.asset.hostname מיפוי ישיר
ip principal.asset.ip ממוזג
asset.entity_group.name principal.group.group_display_name מיפוי ישיר
asset.entity_group.id principal.group.product_object_id שינוי שם/מיפוי
asset.name principal.hostname מיפוי ישיר
host_name principal.hostname מיפוי ישיר
ip principal.hostname מיפוי ישיר
ip principal.ip ממוזג
os principal.platform מופו: (?i)Windows ← WINDOWS, (?i)Linux ← LINUX, (?i)Mac ← MAC
os principal.platform_version מיפוי ישיר
last_modified_label principal.resource.attribute.labels ממוזג
id principal.resource.id מיפוי ישיר
asset.image principal.url מיפוי ישיר
perpetrator.display_name principal.user.user_display_name מיפוי ישיר
perpetrator.id principal.user.userid מיפוי ישיר
log_sec_res security_result ממוזג
alert_type security_result.category_details ממוזג
detect.confidence security_result.confidence_score מיפוי ישיר
index security_result.confidence_score מופה: 0 ← float
alert_reason_label security_result.detection_fields ממוזג
detect_confidence_label security_result.detection_fields ממוזג
detect_label security_result.detection_fields ממוזג
escalated_label security_result.detection_fields ממוזג
network_label security_result.detection_fields ממוזג
perpetrator_timestamp_label security_result.detection_fields ממוזג
reviewed_label security_result.detection_fields ממוזג
rule_group_id_label security_result.detection_fields ממוזג
sec_status_label security_result.detection_fields ממוזג
type_label security_result.detection_fields ממוזג
rule_id security_result.rule_id מיפוי ישיר
rule_name security_result.rule_name מיפוי ישיר
severity security_result.severity_details מיפוי ישיר
content security_result.summary מיפוי ישיר
offending_content_url security_result.url_back_to_product מיפוי ישיר
לא רלוונטי principal.platform קבוע: WINDOWS

יומן שינויים

הצגת יומן השינויים של המנתח הזה

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