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

איסוף יומנים של כניסה יחידה (SSO) ב-Delinea (לשעבר Centrify)

גרסת המנתח: 2.0

נתמך ב:

Google SecOps SIEM

במסמך הזה מוסבר איך להטמיע יומני כניסה יחידה (SSO) של Delinea (לשעבר Centrify) ב-Google Security Operations באמצעות Google Cloud Storage. המנתח מחלץ את היומנים ומטפל בפורמטים של JSON ושל syslog. הוא מנתח צמדים של מפתח/ערך, חותמות זמן ושדות רלוונטיים אחרים, וממפה אותם למודל ה-UDM, עם לוגיקה ספציפית לטיפול בכשלים בהתחברות, סוכני משתמשים, רמות חומרה, מנגנוני אימות וסוגי אירועים שונים. הוא נותן עדיפות ל-FailUserName על פני NormalizedUser בכתובות אימייל של יעדים באירועי כשל.

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

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

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

איסוף פרטי הכניסה ל-SSO של Delinea (Centrify)‎

יצירת אפליקציית לקוח ב-OAuth2

נכנסים לפורטל הניהול של Delinea.
עוברים אל Apps > Add Web Apps.
לוחצים על הכרטיסייה בהתאמה אישית.
מחפשים את OAuth2 Client ולוחצים על Add.
לוחצים על Yes (כן) בתיבת הדו-שיח Add Web App (הוספת אפליקציית אינטרנט).
בתיבת הדו-שיח הוספת אפליקציות אינטרנט, לוחצים על סגירה.
בדף Application Configuration (הגדרות האפליקציה), קובעים את ההגדרות הבאות:
- הכרטיסייה הגדרות:
  - מזהה האפליקציה: מזינים מזהה ייחודי (לדוגמה, secops-oauth-client).
  - שם האפליקציה: מזינים שם תיאורי (לדוגמה, SecOps Data Export).
  - Application Description: מזינים תיאור (לדוגמה, OAuth client for exporting audit events to SecOps).
- בקטע שימוש כללי:
  - Client ID Type: בוחרים באפשרות Confidential.
  - מזהה הלקוח שהונפק: מעתיקים את הערך הזה ושומרים אותו.
  - Issued Client Secret: מעתיקים ושומרים את הערך הזה.
- הכרטיסייה "טוקנים":
  - Auth Methods: בוחרים באפשרות Client Creds.
  - סוג אסימון: בוחרים באפשרות JwtRS256.
- הכרטיסייה "היקף":
  - מוסיפים את היקף ההרשאות redrock/query עם התיאור Query API Access.
לוחצים על Save כדי ליצור את לקוח ה-OAuth.
מעתיקים ושומרים במיקום מאובטח את הפרטים הבאים:
- כתובת ה-URL של הדייר: כתובת ה-URL של הדייר ב-Centrify (לדוגמה, https://yourtenant.my.centrify.com).
- מזהה לקוח: משלב 7.
- סוד לקוח: משלב 7.
- מזהה אפליקציית OAuth: מהגדרות האפליקציה.

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

כדי לוודא שללקוח OAuth יש את ההרשאות הנדרשות:

נכנסים לפורטל הניהול של Delinea.
עוברים אל הגדרות > משאבים > תפקידים.
מוודאים שהתפקיד שהוקצה ללקוח OAuth כולל את ההרשאה דוח: אירועי ביקורת: צפייה.
אם ההרשאה חסרה, פנו לאדמין שלכם ב-Delinea כדי לקבל את ההרשאה הנדרשת.

הערה: ללקוח OAuth צריכה להיות ההרשאה דוח: אירועי ביקורת: צפייה כדי לגשת לאירועי ביקורת דרך Redrock Query API.

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

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

# Replace with your actual credentials
TENANT_URL="https://yourtenant.my.centrify.com"
CLIENT_ID="your-client-id"
CLIENT_SECRET="your-client-secret"
OAUTH_APP_ID="your-oauth-application-id"

# Get OAuth token
TOKEN=$(curl -s -X POST "${TENANT_URL}/oauth2/token/${OAUTH_APP_ID}" \
  -H "Authorization: Basic $(echo -n "${CLIENT_ID}:${CLIENT_SECRET}" | base64)" \
  -H "X-CENTRIFY-NATIVE-CLIENT: True" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&scope=redrock/query" | jq -r '.access_token')

# Test query API access
curl -v -X POST "${TENANT_URL}/Redrock/query" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "X-CENTRIFY-NATIVE-CLIENT: True" \
  -H "Content-Type: application/json" \
  -d '{"Script":"Select * from Event where WhenOccurred > datefunc('"'"'now'"'"', '"'"'-1'"'"') ORDER BY WhenOccurred ASC","args":{"PageNumber":1,"PageSize":10,"Limit":10,"Caching":-1}}'

אם הפעולה בוצעה ללא שגיאות, אמורה להופיע תגובת JSON עם אירועי ביקורת. אם מופיעה שגיאה 401 או 403, צריך לבדוק את פרטי הכניסה וההרשאות.

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

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

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

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

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

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

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

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

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

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

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

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

נותנים לחשבון השירות הרשאות כתיבה בקטגוריה של GCS:

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

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

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

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

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

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

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

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

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

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

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

לוחצים על Variables & Secrets.
לוחצים על ‎+ Add variable לכל משתנה סביבה:

שם משתנה	ערך לדוגמה	תיאור
`GCS_BUCKET`	`delinea-centrify-logs-bucket`	שם הקטגוריה ב-GCS
`GCS_PREFIX`	`centrify-sso-logs`	קידומת לקובצי יומן
`STATE_KEY`	`centrify-sso-logs/state.json`	נתיב קובץ תמונת המצב
`TENANT_URL`	`https://yourtenant.my.centrify.com`	כתובת ה-URL של הדייר ב-Delinea
`CLIENT_ID`	`your-client-id`	מזהה לקוח ב-OAuth
`CLIENT_SECRET`	`your-client-secret`	סוד לקוח OAuth
`OAUTH_APP_ID`	`your-oauth-application-id`	מזהה האפליקציה ב-OAuth
`PAGE_SIZE`	`1000`	רשומות בכל דף
`MAX_PAGES`	`10`	מספר הדפים המקסימלי לאחזור

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

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

מזינים main בשדה Function 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 time
import base64

# 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()

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch Delinea Centrify SSO audit events and write to GCS.

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

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'centrify-sso-logs')
    state_key = os.environ.get('STATE_KEY', 'centrify-sso-logs/state.json')

    # Centrify API credentials
    tenant_url = os.environ.get('TENANT_URL')
    client_id = os.environ.get('CLIENT_ID')
    client_secret = os.environ.get('CLIENT_SECRET')
    oauth_app_id = os.environ.get('OAUTH_APP_ID')

    # Optional parameters
    page_size = int(os.environ.get('PAGE_SIZE', '1000'))
    max_pages = int(os.environ.get('MAX_PAGES', '10'))

    if not all([bucket_name, tenant_url, client_id, client_secret, oauth_app_id]):
        print('Error: Missing required environment variables')
        return

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

        # Load state (last processed timestamp)
        state = load_state(bucket, state_key)
        last_timestamp = state.get('last_timestamp')

        print(f'Processing logs since {last_timestamp if last_timestamp else "24 hours ago"}')

        # Get OAuth access token
        access_token = get_oauth_token(tenant_url, client_id, client_secret, oauth_app_id)

        # Fetch audit events
        events = fetch_audit_events(tenant_url, access_token, last_timestamp, page_size, max_pages)

        if events:
            # Write events to GCS
            current_timestamp = datetime.now(timezone.utc)
            blob_name = f"{prefix}/centrify-sso-events-{current_timestamp.strftime('%Y%m%d_%H%M%S')}.json"
            blob = bucket.blob(blob_name)

            # Convert to JSONL format (one JSON object per line)
            jsonl_content = '\n'.join([json.dumps(event, default=str) for event in events])
            blob.upload_from_string(jsonl_content, content_type='application/x-ndjson')

            print(f'Wrote {len(events)} events to {blob_name}')

            # Update state with latest timestamp
            latest_timestamp = get_latest_event_timestamp(events)
            save_state(bucket, state_key, {'last_timestamp': latest_timestamp, 'updated_at': current_timestamp.isoformat() + 'Z'})

            print(f'Successfully processed {len(events)} events')
        else:
            print('No new events found')

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

def get_oauth_token(tenant_url, client_id, client_secret, oauth_app_id):
    """Get OAuth access token using client credentials flow."""
    credentials = f"{client_id}:{client_secret}"
    basic_auth = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')

    token_url = f"{tenant_url}/oauth2/token/{oauth_app_id}"
    headers = {
        'Authorization': f'Basic {basic_auth}',
        'X-CENTRIFY-NATIVE-CLIENT': 'True',
        'Content-Type': 'application/x-www-form-urlencoded'
    }

    data = {
        'grant_type': 'client_credentials',
        'scope': 'redrock/query'
    }

    response = http.request('POST', token_url, headers=headers, fields=data)

    if response.status != 200:
        raise Exception(f"OAuth token request failed: {response.status} {response.data.decode('utf-8')}")

    token_data = json.loads(response.data.decode('utf-8'))
    return token_data['access_token']

def fetch_audit_events(tenant_url, access_token, last_timestamp, page_size, max_pages):
    """Fetch audit events from Centrify using the Redrock/query API with proper pagination."""
    query_url = f"{tenant_url}/Redrock/query"
    headers = {
        'Authorization': f'Bearer {access_token}',
        'X-CENTRIFY-NATIVE-CLIENT': 'True',
        'Content-Type': 'application/json'
    }

    # Build SQL query with timestamp filter
    if last_timestamp:
        sql_query = f"Select * from Event where WhenOccurred > '{last_timestamp}' ORDER BY WhenOccurred ASC"
    else:
        # First run - get events from last 24 hours
        sql_query = "Select * from Event where WhenOccurred > datefunc('now', '-1') ORDER BY WhenOccurred ASC"

    all_events = []
    page_num = 1
    backoff = 1.0

    while page_num <= max_pages:
        payload = {
            "Script": sql_query,
            "args": {
                "PageNumber": page_num,
                "PageSize": page_size,
                "Limit": page_size * max_pages,
                "Caching": -1
            }
        }

        try:
            response = http.request('POST', query_url, headers=headers, body=json.dumps(payload))

            # 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)
                continue

            backoff = 1.0

            if response.status != 200:
                raise Exception(f"API query failed: {response.status} {response.data.decode('utf-8')}")

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

            if not response_data.get('success', False):
                raise Exception(f"API query failed: {response_data.get('Message', 'Unknown error')}")

            # Parse the response
            result = response_data.get('Result', {})
            columns = {col['Name']: i for i, col in enumerate(result.get('Columns', []))}
            raw_results = result.get('Results', [])

            if not raw_results:
                print(f"No more results on page {page_num}")
                break

            print(f"Page {page_num}: Retrieved {len(raw_results)} events")

            for raw_event in raw_results:
                event = {}
                row_data = raw_event.get('Row', {})

                # Map column names to values
                for col_name, col_index in columns.items():
                    if col_name in row_data and row_data[col_name] is not None:
                        event[col_name] = row_data[col_name]

                # Add metadata
                event['_source'] = 'centrify_sso'
                event['_collected_at'] = datetime.now(timezone.utc).isoformat() + 'Z'

                all_events.append(event)

            # Check if we've reached the end
            if len(raw_results) < page_size:
                print(f"Reached last page (page {page_num} returned {len(raw_results)} < {page_size})")
                break

            page_num += 1

        except Exception as e:
            print(f"Error fetching page {page_num}: {e}")
            raise

    print(f"Retrieved {len(all_events)} total events from {page_num} pages")
    return all_events

def get_latest_event_timestamp(events):
    """Get the latest timestamp from the events for state tracking."""
    if not events:
        return datetime.now(timezone.utc).isoformat() + 'Z'

    latest = None
    for event in events:
        when_occurred = event.get('WhenOccurred')
        if when_occurred:
            if latest is None or when_occurred > latest:
                latest = when_occurred

    return latest or datetime.now(timezone.utc).isoformat() + 'Z'

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: {str(e)}')
    return {}

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

requirements.txt:

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת השילוב

במסוף Cloud Scheduler, מחפשים את המשימה (לדוגמה, delinea-sso-log-export-hourly).
לוחצים על Force run כדי להפעיל את המשימה באופן ידני.
מחכים כמה שניות.
נכנסים לדף Cloud Run > Services.
לוחצים על שם הפונקציה delinea-sso-log-export.
לוחצים על הכרטיסייה Logs.

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

Processing logs since YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X events
Wrote X events to centrify-sso-logs/centrify-sso-events_YYYYMMDD_HHMMSS.json
Successfully processed X events

נכנסים לדף Cloud Storage > Buckets.
לוחצים על שם הקטגוריה (לדוגמה, delinea-centrify-logs-bucket).
עוברים לתיקיית הקידומת centrify-sso-logs/.
מוודאים שנוצר קובץ .json חדש עם חותמת הזמן הנוכחית.

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

‫HTTP 401: בודקים את פרטי הכניסה ל-API במשתני הסביבה (CLIENT_ID, ‏ CLIENT_SECRET, ‏ OAUTH_APP_ID)
HTTP 403: מוודאים שללקוח OAuth יש את ההרשאה דוח: אירועי ביקורת: צפייה
‫HTTP 429: הגבלת קצב של יצירת בקשות – הפונקציה תנסה שוב באופן אוטומטי עם השהיה (backoff)
משתני סביבה חסרים: צריך לוודא שכל המשתנים הנדרשים מוגדרים בהגדרות של פונקציית Cloud Run.

הגדרת פיד ב-Google SecOps כדי להטמיע יומני SSO של Delinea (Centrify)‎

עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
לוחצים על הוספת פיד חדש.
לוחצים על הגדרת פיד יחיד.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Delinea Centrify SSO logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Centrify בתור Log type.
לוחצים על Get Service Account (קבלת חשבון שירות). תוצג כתובת אימייל ייחודית של חשבון שירות, לדוגמה:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
מעתיקים את כתובת האימייל הזו. תצטרכו אותו בשלב הבא.

הערה: לכל מכונה של Google SecOps יש חשבון שירות ייחודי. אל תשתמשו בחשבונות שירות ממסמכים או מדוגמאות אחרים.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:
```
gs://delinea-centrify-logs-bucket/centrify-sso-logs/
```
- מחליפים את:
  - ‫delinea-centrify-logs-bucket: השם של קטגוריית GCS.
  - ‫centrify-sso-logs: נתיב אופציונלי לתיקייה או לתחילית שבהם נשמרים היומנים (משאירים ריק בשביל תיקיית הבסיס).
לדוגמה:
- קטגוריית הבסיס: gs://company-logs/
- עם הקידומת: gs://company-logs/centrify-sso-logs/
- עם תיקיית משנה: gs://company-logs/delinea/sso/
הערה: תמיד צריך לכלול את הלוכסן (/) בסוף ה-URI.
- אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה הרצויה:
  - Never: אף פעם לא למחוק קבצים אחרי העברות (מומלץ לבדיקה).
  - מחיקת קבצים שהועברו: מחיקת קבצים אחרי שהם הועברו בהצלחה.
  - מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת.
הערה: אם בוחרים באפשרות מחיקה, לחשבון השירות צריך להיות התפקיד אדמין של אובייקטים ב-Storage במקום התפקיד 'צפייה באובייקטים ב-Storage'. מעדכנים את הרשאות ה-IAM בהתאם.
- גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים. ברירת המחדל היא 180 ימים.
- מרחב השמות של הנכס: מרחב השמות של הנכס.
- תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה.
לוחצים על הבא.
בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

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

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

נכנסים לדף Cloud Storage > Buckets.
לוחצים על שם הקטגוריה (לדוגמה, delinea-centrify-logs-bucket).
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מזינים את פרטי ההגדרה הבאים:
- הוספת חשבונות משתמשים: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
- הקצאת תפקידים: בוחרים באפשרות צפייה באובייקטים באחסון.
לוחצים על Save.

הערה: אם אתם מתכננים להשתמש באפשרות המחיקה "מחיקת קבצים שהועברו" או "מחיקת קבצים שהועברו וספריות ריקות", הקצו את התפקיד אדמין של אובייקטים ב-Cloud Storage במקום "צפייה באובייקטים ב-Cloud Storage".

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	Logic (פונקציה לוגית)
AccountID	security_result.detection_fields.value	הערך של AccountID מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: Account ID.
ApplicationName	target.application	הערך של ApplicationName מהיומן הגולמי מוקצה לשדה target.application.
AuthorityFQDN	target.asset.network_domain	הערך של AuthorityFQDN מהיומן הגולמי מוקצה לשדה target.asset.network_domain.
AuthorityID	target.asset.asset_id	הערך של AuthorityID מהיומן הגולמי מוקצה לשדה target.asset.asset_id, עם הקידומת "AuthorityID:".
AzDeploymentId	security_result.detection_fields.value	הערך של AzDeploymentId מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: AzDeploymentId.
AzRoleId	additional.fields.value.string_value	הערך של AzRoleId מהיומן הגולמי מוקצה לאובייקט additional.fields עם המפתח: AzRoleId.
AzRoleName	target.user.attribute.roles.name	הערך של AzRoleName מהיומן הגולמי מוקצה לשדה target.user.attribute.roles.name.
ComputerFQDN	principal.asset.network_domain	הערך של ComputerFQDN מהיומן הגולמי מוקצה לשדה principal.asset.network_domain.
ComputerID	principal.asset.asset_id	הערך של ComputerID מהיומן הגולמי מוקצה לשדה principal.asset.asset_id, עם הקידומת "ComputerId:".
ComputerName	about.hostname	הערך של ComputerName מהיומן הגולמי מוקצה לשדה about.hostname.
CredentialId	security_result.detection_fields.value	הערך של CredentialId מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: Credential Id.
DirectoryServiceName	security_result.detection_fields.value	הערך של DirectoryServiceName מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: Directory Service Name.
DirectoryServiceNameLocalized	security_result.detection_fields.value	הערך של DirectoryServiceNameLocalized מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: Directory Service Name Localized.
DirectoryServiceUuid	security_result.detection_fields.value	הערך של DirectoryServiceUuid מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: Directory Service Uuid.
EventMessage	security_result.summary	הערך של EventMessage מהיומן הגולמי מוקצה לשדה security_result.summary.
EventType	metadata.product_event_type	הערך של EventType מהיומן הגולמי מוקצה לשדה metadata.product_event_type. הוא משמש גם לקביעת metadata.event_type.
FailReason	security_result.summary	הערך של FailReason מהיומן הגולמי מוקצה לשדה security_result.summary כשהוא קיים.
FailUserName	target.user.email_addresses	הערך של FailUserName מהיומן הגולמי מוקצה לשדה target.user.email_addresses כשהוא קיים.
FromIPAddress	principal.ip	הערך של FromIPAddress מהיומן הגולמי מוקצה לשדה principal.ip.
מזהה	security_result.detection_fields.value	הערך של המזהה מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: ID.
InternalTrackingID	metadata.product_log_id	הערך של InternalTrackingID מהיומן הגולמי מוקצה לשדה metadata.product_log_id.
JumpType	additional.fields.value.string_value	הערך של JumpType מהיומן הגולמי מוקצה לאובייקט additional.fields עם המפתח: Jump Type.
NormalizedUser	target.user.email_addresses	הערך של NormalizedUser מהיומן הגולמי מוקצה לשדה target.user.email_addresses.
OperationMode	additional.fields.value.string_value	הערך של OperationMode מהיומן הגולמי מוקצה לאובייקט additional.fields עם המפתח: Operation Mode.
ProxyId	security_result.detection_fields.value	הערך של ProxyId מהיומן הגולמי מוקצה לאובייקט security_result.detection_fields עם המפתח: Proxy Id.
RequestUserAgent	network.http.user_agent	הערך של RequestUserAgent מהיומן הגולמי מוקצה לשדה network.http.user_agent.
SessionGuid	network.session_id	הערך של SessionGuid מהיומן הגולמי מוקצה לשדה network.session_id.
דייר (tenant)	additional.fields.value.string_value	הערך של Tenant מהיומן הגולמי מוקצה לאובייקט additional.fields עם המפתח: Tenant.
ThreadType	additional.fields.value.string_value	הערך של ThreadType מהיומן הגולמי מוקצה לאובייקט additional.fields עם המפתח: Thread Type.
UserType	principal.user.attribute.roles.name	הערך של UserType מהיומן הגולמי מוקצה לשדה principal.user.attribute.roles.name.
WhenOccurred	metadata.event_timestamp	המערכת מנתחת את הערך של WhenOccurred מהיומן הגולמי ומקצה אותו לשדה metadata.event_timestamp. השדה הזה מאכלס גם את שדה חותמת הזמן ברמה העליונה.
ערך בקידוד קשיח	metadata.product_name	"SSO".
ערך בקידוד קשיח	metadata.event_type	נקבע לפי השדה EventType. אם EventType לא קיים או לא תואם לקריטריונים ספציפיים, ברירת המחדל היא STATUS_UPDATE. הערכים האפשריים הם USER_LOGIN,‏ USER_CREATION,‏ USER_RESOURCE_ACCESS,‏ USER_LOGOUT או USER_CHANGE_PASSWORD.
ערך בקידוד קשיח	metadata.vendor_name	"CENTRIFY_SSO".
ערך בקידוד קשיח	metadata.product_version	"SSO".
ערך בקידוד קשיח	metadata.log_type	"Centrify".
חולץ משדה ההודעה	network.session_id	אם שדה ההודעה מכיל מזהה סשן, המערכת מחלצת אותו ומשתמשת בו. אחרת, ברירת המחדל היא "1".
חולץ משדה המארח	principal.hostname	השדה הזה נשלף משדה המארח, אם הוא זמין, שמגיע מהכותרת של syslog.
חולץ מהשדה pid	principal.process.pid	השדה הזה נשלף מהשדה pid אם הוא זמין, שמגיע מהכותרת של syslog.
UserGuid או חולץ מההודעה	target.user.userid	אם UserGuid קיים, המערכת משתמשת בערך שלו. אחרת, אם שדה ההודעה מכיל מזהה משתמש, הוא מחולץ ונעשה בו שימוש.
נקבע לפי Level ו-FailReason	security_result.action	צריך להגדיר את הערך "ALLOW" אם Level הוא "Info", ואת הערך "BLOCK" אם FailReason קיים.
נקבע לפי FailReason	security_result.category	אם FailReason קיים, צריך להגדיר את הערך AUTH_VIOLATION.
נקבע לפי השדה "רמה"	security_result.severity	נקבע לפי השדה "רמה". אם הרמה היא "מידע", מגדירים את הערך "INFORMATIONAL". אם הרמה היא "אזהרה", מגדירים את הערך "MEDIUM". אם הרמה היא "שגיאה", מגדירים את הערך "ERROR".
`msg`	`metadata.description`	מופה מיומן השינויים
`UserGuid`	`principal.user.userid`	מופה מיומן השינויים
`ComputerName`	`principal.asset.hostname`	מופה מיומן השינויים
`TokenType`	`additional.fields`	מופה מיומן השינויים

יומן שינויים

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

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