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

איסוף יומני אימות של Duo

גרסת כלי הניתוח: 7.0

נתמך ב:

Google SecOps SIEM

במאמר הזה מוסבר איך להטמיע יומני אימות של Duo ב-Google Security Operations. הכלי לניתוח מחלץ את היומנים מהודעות בפורמט JSON. הוא הופך את נתוני היומן הגולמיים למודל נתונים מאוחד (UDM), ממפה שדות כמו משתמש, מכשיר, אפליקציה, מיקום ופרטי אימות, וגם מטפל בגורמי אימות ובתוצאות שונות כדי לסווג אירועי אבטחה. הכלי לניתוח תחבירי מבצע גם ניקוי נתונים, המרת סוגים וטיפול בשגיאות כדי להבטיח את איכות הנתונים ועקביותם.

אפשר לבחור בין שתי שיטות איסוף:

אפשרות 1: הטמעה ישירה באמצעות API של צד שלישי
אפשרות 2: איסוף יומנים באמצעות פונקציה של Cloud Run ו-Google Cloud Storage

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

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

מופע של Google SecOps
גישה עם הרשאות מיוחדות ל-Duo Admin Panel (נדרש תפקיד בעלים כדי ליצור אפליקציות Admin API)
גישה עם הרשאות מיוחדות ל-GCP אם משתמשים באפשרות 2

אפשרות 1: הטמעה של יומני אימות של Duo באמצעות API של צד שלישי

איסוף הדרישות המוקדמות ל-Duo (פרטי כניסה ל-API)

נכנסים ל-Duo Admin Panel כאדמינים עם התפקיד בעלים, אדמין או מנהל אפליקציות.
עוברים אל Applications > Application Catalog.
מחפשים בקטלוג את הערך Admin API.
לוחצים על + הוספה כדי ליצור את האפליקציה.
מעתיקים ושומרים במיקום מאובטח את הפרטים הבאים:
- Integration Key
- מפתח סודי
- שם המארח של ה-API (לדוגמה, api-XXXXXXXX.duosecurity.com)
עוברים לקטע הרשאות.
מבטלים את הסימון של כל אפשרויות ההרשאה מלבד Grant read log (הענקת הרשאה לקריאת יומן).
לוחצים על שמירת השינויים.

הגדרת פיד ב-Google SecOps להטמעה של יומני אימות של Duo

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על + הוספת פיד חדש.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Duo Authentication Logs).
בוחרים באפשרות API של צד שלישי בתור סוג המקור.
בוחרים באפשרות Duo Auth בתור סוג היומן.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- שם משתמש: מזינים את מפתח השילוב מ-Duo.
- סוד: מזינים את המפתח הסודי מ-Duo.
- שם המארח של ה-API: מזינים את שם המארח של ה-API (לדוגמה, api-XXXXXXXX.duosecurity.com).
- מרחב שמות של נכס: אופציונלי. מרחב השמות של הנכס.
- תוויות להעברת נתונים: אופציונלי. התווית שתתווסף לאירועים מהפיד הזה.
לוחצים על הבא.
בודקים את ההגדרות של הפיד החדש במסך סיום ולוחצים על שליחה.

אפשרות 2: העברה של יומני אימות של Duo באמצעות Google Cloud Storage

איסוף פרטי הכניסה ל-Duo Admin API

נכנסים לחשבון ב-Duo Admin Panel.
עוברים אל Applications > Application Catalog.
מאתרים את Admin API בקטלוג האפליקציות.
לוחצים על + הוספה כדי להוסיף את אפליקציית Admin API.
מעתיקים ושומרים את הערכים הבאים:
- מפתח שילוב (ikey)
- מפתח סודי (skey)
- שם המארח של ה-API (לדוגמה, api-XXXXXXXX.duosecurity.com)
בהרשאות, מפעילים את ההגדרה מתן הרשאת קריאה של יומן.
לוחצים על שמירת השינויים.

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

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

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

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

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

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

פונקציית Cloud Run צריכה חשבון שירות עם הרשאות כתיבה לקטגוריה של GCS.

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

במסוף GCP, עוברים אל IAM & Admin > Service Accounts.
לוחצים על יצירת חשבון שירות.
מספקים את פרטי ההגדרה הבאים:
- שם חשבון השירות: מזינים duo-auth-collector-sa.
- תיאור חשבון השירות: מזינים Service account for Cloud Run function to collect Duo authentication 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.
לוחצים על סיום.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שם המשתנה	ערך לדוגמה
`GCS_BUCKET`	`duo-auth-logs`
`GCS_PREFIX`	`duo/auth/`
`STATE_KEY`	`duo/auth/state.json`
`DUO_IKEY`	`DIXYZ...`
`DUO_SKEY`	`****************`
`DUO_API_HOSTNAME`	`api-XXXXXXXX.duosecurity.com`
`LIMIT`	`500`

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

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

מזינים main בFunction entry point

בעורך הקוד המוטבע, יוצרים שני קבצים:

הקובץ הראשון: main.py:

#!/usr/bin/env python3
# Cloud Run Function: Pull Duo Admin API v2 Authentication Logs to GCS (raw JSON pages)
# Notes:
# - Duo v2 requires mintime/maxtime in *milliseconds* (13-digit epoch).
# - Pagination via metadata.next_offset ("<millis>,<txid>").
# - We save state (mintime_ms) in ms to resume next run without gaps.

import functions_framework
from google.cloud import storage
import os
import json
import time
import hmac
import hashlib
import base64
import email.utils
import urllib.parse
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

DUO_IKEY = os.environ["DUO_IKEY"]
DUO_SKEY = os.environ["DUO_SKEY"]
DUO_API_HOSTNAME = os.environ["DUO_API_HOSTNAME"].strip()
GCS_BUCKET = os.environ["GCS_BUCKET"]
GCS_PREFIX = os.environ.get("GCS_PREFIX", "duo/auth/").strip("/")
STATE_KEY = os.environ.get("STATE_KEY", "duo/auth/state.json")
LIMIT = min(int(os.environ.get("LIMIT", "500")), 1000)  # default 500, max 1000

storage_client = storage.Client()

def _canon_params(params: dict) -> str:
    parts = []
    for k in sorted(params.keys()):
        v = params[k]
        if v is None:
            continue
        parts.append(f"{urllib.parse.quote(str(k), '~')}={urllib.parse.quote(str(v), '~')}")
    return "&".join(parts)

def _sign(method: str, host: str, path: str, params: dict) -> dict:
    now = email.utils.formatdate()
    canon = "\n".join([
        now,
        method.upper(),
        host.lower(),
        path,
        _canon_params(params)
    ])
    sig = hmac.new(
        DUO_SKEY.encode("utf-8"),
        canon.encode("utf-8"),
        hashlib.sha1
    ).hexdigest()
    auth = base64.b64encode(f"{DUO_IKEY}:{sig}".encode()).decode()
    return {
        "Date": now,
        "Authorization": f"Basic {auth}"
    }

def _http(method: str, path: str, params: dict, timeout: int = 60, max_retries: int = 5) -> dict:
    host = DUO_API_HOSTNAME
    assert host.startswith("api-") and host.endswith(".duosecurity.com"), \
        "DUO_API_HOSTNAME must be like api-XXXXXXXX.duosecurity.com"

    qs = _canon_params(params)
    url = f"https://{host}{path}" + (f"?{qs}" if qs else "")

    attempt, backoff = 0, 1.0
    while True:
        req = Request(url, method=method.upper())
        req.add_header("Accept", "application/json")
        for k, v in _sign(method, host, path, params).items():
            req.add_header(k, v)

        try:
            with urlopen(req, timeout=timeout) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            if (e.code == 429 or 500 <= e.code <= 599) and attempt < max_retries:
                time.sleep(backoff)
                attempt += 1
                backoff *= 2
                continue
            raise
        except URLError:
            if attempt < max_retries:
                time.sleep(backoff)
                attempt += 1
                backoff *= 2
                continue
            raise

def _read_state_ms() -> int | None:
    try:
        bucket = storage_client.bucket(GCS_BUCKET)
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            state_data = blob.download_as_text()
            val = json.loads(state_data).get("mintime")
            if val is None:
                return None
            # Backward safety: if seconds were stored, convert to ms
            return int(val) * 1000 if len(str(int(val))) <= 10 else int(val)
    except Exception:
        return None

def _write_state_ms(mintime_ms: int):
    bucket = storage_client.bucket(GCS_BUCKET)
    blob = bucket.blob(STATE_KEY)
    body = json.dumps({"mintime": int(mintime_ms)}).encode("utf-8")
    blob.upload_from_string(body, content_type="application/json")

def _write_page(payload: dict, when_epoch_s: int, page: int) -> str:
    bucket = storage_client.bucket(GCS_BUCKET)
    key = f"{GCS_PREFIX}/{time.strftime('%Y/%m/%d', time.gmtime(when_epoch_s))}/duo-auth-{page:05d}.json"
    blob = bucket.blob(key)
    blob.upload_from_string(
        json.dumps(payload, separators=(",", ":")).encode("utf-8"),
        content_type="application/json"
    )
    return key

def fetch_and_store():
    now_s = int(time.time())
    # Duo recommends a ~2-minute delay buffer; use maxtime = now - 120 seconds (in ms)
    maxtime_ms = (now_s - 120) * 1000
    mintime_ms = _read_state_ms() or (maxtime_ms - 3600 * 1000)  # 1 hour on first run

    page = 0
    total = 0
    next_offset = None

    while True:
        params = {
            "mintime": mintime_ms,
            "maxtime": maxtime_ms,
            "limit": LIMIT
        }
        if next_offset:
            params["next_offset"] = next_offset

        data = _http("GET", "/admin/v2/logs/authentication", params)
        _write_page(data, maxtime_ms // 1000, page)
        page += 1

        resp = data.get("response")
        items = resp if isinstance(resp, list) else []
        total += len(items)

        meta = data.get("metadata") or {}
        next_offset = meta.get("next_offset")
        if not next_offset:
            break

    # Advance window to maxtime_ms for next run
    _write_state_ms(maxtime_ms)

    return {
        "ok": True,
        "pages": page,
        "events": total,
        "next_mintime_ms": maxtime_ms
    }

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

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """
    try:
        result = fetch_and_store()
        print(f"Successfully processed {result['events']} events in {result['pages']} pages")
        print(f"Next mintime_ms: {result['next_mintime_ms']}")
    except Exception as e:
        print(f"Error processing logs: {str(e)}")
        raise

הקובץ השני: requirements.txt:

functions-framework==3.*
google-cloud-storage==2.*

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

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

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

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

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

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

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

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

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

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

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

בדיקת משימת המתזמן

במסוף Cloud Scheduler, מוצאים את העבודה.
כדי להפעיל את הטריגר באופן ידני, לוחצים על הפעלה מאולצת.
מחכים כמה שניות ועוברים אל Cloud Run > Services > duo-auth-collector > Logs.
מוודאים שהפונקציה בוצעה בהצלחה.
בודקים את דלי ה-GCS כדי לוודא שהיומנים נכתבו.

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

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

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

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

הערה: לכל מופע של Google SecOps יש חשבון שירות ייחודי. אל תשתמשו בחשבונות שירות ממסמכים או מדוגמאות אחרים.

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

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

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

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

הגדרת פיד ב-Google SecOps להטמעה של יומני אימות של Duo

עוברים אל SIEM Settings > Feeds (הגדרות SIEM > פידים).
לוחצים על הוספת פיד חדש.
לוחצים על Configure a single feed (הגדרת פיד יחיד).
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Duo Authentication Logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Duo Auth בתור סוג היומן.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית GCS עם נתיב הקידומת:
```
gs://duo-auth-logs/duo/auth/
```
  - מחליפים את:
    - ‫duo-auth-logs: השם של קטגוריית GCS.
    - ‫duo/auth/: קידומת אופציונלית או נתיב לתיקייה שבה מאוחסנים היומנים (אם לא מציינים כלום, היומנים מאוחסנים בתיקיית הבסיס).
  - לדוגמה:
    - קטגוריית הבסיס: gs://company-logs/
    - עם קידומת: gs://company-logs/duo-logs/
    - עם תיקיית משנה: gs://company-logs/duo/auth/
  הערה: תמיד צריך לכלול את התו '/' בסוף ה-URI.
- אפשרות למחיקת המקור: בוחרים את אפשרות המחיקה לפי ההעדפה שלכם:
  - אף פעם: לא נמחקים קבצים אחרי ההעברה (מומלץ לבדיקות).
  - מחיקת קבצים שהועברו: הקבצים נמחקים אחרי שההעברה מסתיימת.
  - מחיקת קבצים שהועברו וספריות ריקות: מחיקת קבצים וספריות ריקות אחרי שההעברה מסתיימת בהצלחה.
    
    הערה: אם בוחרים באפשרות מחיקה, לחשבון השירות צריך להיות התפקיד Storage Object Admin ולא Storage Object Viewer. מעדכנים את ההרשאות ב-IAM בהתאם.
- הגיל המקסימלי של הקובץ: כולל קבצים שעברו שינוי במספר הימים האחרון. ברירת המחדל היא 180 ימים.
- מרחב השמות של הנכס: מרחב השמות של הנכס.
- תוויות להוספה: התווית שתתווסף לאירועים מהפיד הזה.
לוחצים על הבא.
בודקים את ההגדרות של הפיד החדש במסך סיום ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	היגיון
access_device.browser	target.resource.attribute.labels.value	אם קיים access_device.browser, הערך שלו ממופה ל-UDM.
access_device.hostname	principal.hostname	אם access_device.hostname קיים ולא ריק, הערך שלו ממופה ל-UDM. אם השדה ריק וסוג האירוע הוא USER_CREATION, סוג האירוע משתנה ל-USER_UNCATEGORIZED. אם הערך של access_device.hostname ריק והשדה hostname קיים, המערכת משתמשת בערך של hostname.
access_device.ip	principal.ip	אם המשתנה access_device.ip קיים והוא כתובת IPv4 תקינה, הערך שלו ממופה ל-UDM. אם זו לא כתובת IPv4 תקינה, היא מתווספת כערך מחרוזת ל-additional.fields עם מפתח access_device.ip.
access_device.location.city	principal.location.city	אם יש ערך, הוא ממופה ל-UDM.
access_device.location.country	principal.location.country_or_region	אם יש ערך, הוא ממופה ל-UDM.
access_device.location.state	principal.location.state	אם יש ערך, הוא ממופה ל-UDM.
access_device.os	principal.platform	אם הפרמטר קיים, הערך שלו מתורגם לערך התואם ב-UDM (MAC, ‏ WINDOWS, ‏ LINUX).
access_device.os_version	principal.platform_version	אם יש ערך, הוא ממופה ל-UDM.
application.key	target.resource.id	אם יש ערך, הוא ממופה ל-UDM.
application.name	target.application	אם יש ערך, הוא ממופה ל-UDM.
auth_device.ip	target.ip	אם יש ערך בשדה הזה והוא לא None, הערך ממופה ל-UDM.
auth_device.location.city	target.location.city	אם יש ערך, הוא ממופה ל-UDM.
auth_device.location.country	target.location.country_or_region	אם יש ערך, הוא ממופה ל-UDM.
auth_device.location.state	target.location.state	אם יש ערך, הוא ממופה ל-UDM.
auth_device.name	target.hostname OR target.user.phone_numbers	אם auth_device.name קיים והוא מספר טלפון (אחרי נרמול), הוא מתווסף אל target.user.phone_numbers. אחרת, היא ממופה ל-target.hostname.
client_ip	target.ip	אם יש ערך בשדה הזה והוא לא None, הערך ממופה ל-UDM.
client_section	target.resource.attribute.labels.value	אם יש פרמטר client_section, הערך שלו ממופה ל-UDM עם המפתח client_section.
dn	target.user.userid	אם dn קיים ו-user.name ו-username לא קיימים, מזהה המשתמש מחולץ משדה ה-dn באמצעות grok וממופה ל-UDM. הערך של event_type הוא USER_LOGIN.
event_type	metadata.product_event_type AND metadata.event_type	הערך ממופה אל metadata.product_event_type. הוא משמש גם לקביעת המטא-נתונים.event_type: ‏'authentication' הופך ל-USER_LOGIN,‏ 'enrollment' הופך ל-USER_CREATION, ואם הוא ריק או לא אחד מהם, הוא הופך ל-GENERIC_EVENT.
שלב	extensions.auth.mechanism AND extensions.auth.auth_details	הערך מתורגם לערך המתאים של auth.mechanism ב-UDM (HARDWARE_KEY, ‏ REMOTE_INTERACTIVE, ‏ LOCAL, ‏ OTP). הערך המקורי ממופה גם אל extensions.auth.auth_details.
שם המארח	principal.hostname	אם הוא קיים והשדה access_device.hostname ריק, הערך ממופה ל-UDM.
log_format	target.resource.attribute.labels.value	אם הפרמטר log_format קיים, הערך שלו ממופה ל-UDM עם המפתח log_format.
loglevel._classuuid_	target.resource.attribute.labels.value	אם קיים loglevel._classuuid_, הערך שלו ממופה ל-UDM עם המפתח class_uuid.
log_level.name	target.resource.attribute.labels.value AND security_result.severity	אם log_level.name קיים, הערך שלו ממופה ל-UDM עם שם המפתח. אם הערך הוא info,‏ security_result.severity מוגדר כ-INFORMATIONAL.
log_logger.unpersistable	target.resource.attribute.labels.value	אם המשתנה log_logger.unpersistable קיים, הערך שלו ממופה ל-UDM עם המפתח unpersistable.
log_namespace	target.resource.attribute.labels.value	אם log_namespace קיים, הערך שלו ממופה ל-UDM עם המפתח log_namespace.
log_source	target.resource.attribute.labels.value	אם הפרמטר log_source קיים, הערך שלו ממופה ל-UDM עם המפתח log_source.
msg	security_result.summary	אם השדה הזה קיים והסיבה ריקה, הערך ממופה ל-UDM.
reason	security_result.summary	אם יש ערך, הוא ממופה ל-UDM.
result	security_result.action_details AND security_result.action	אם יש ערך, הוא ממופה אל security_result.action_details. הערך 'success' או 'SUCCESS' מתורגם לפעולה ALLOW של security_result, אחרת BLOCK.
server_section	target.resource.attribute.labels.value	אם יש server_section, הערך שלו ממופה ל-UDM עם המפתח server_section.
server_section_ikey	target.resource.attribute.labels.value	אם קיים server_section_ikey, הערך שלו ממופה ל-UDM עם המפתח server_section_ikey.
סטטוס	security_result.action_details AND security_result.action	אם יש ערך, הוא ממופה אל security_result.action_details. האפשרות Allow (אישור) מתורגמת ל-security_result.action ALLOW, והאפשרות Reject (דחייה) מתורגמת ל-BLOCK.
חותמת זמן	metadata.event_timestamp AND event.timestamp	הערך מומר לחותמת זמן וממופה גם ל-metadata.event_timestamp וגם ל-event.timestamp.
txid	metadata.product_log_id AND network.session_id	הערך ממופה גם למטא-נתונים metadata.product_log_id ולמטא-נתונים network.session_id.
user.groups	target.user.group_identifiers	כל הערכים במערך מתווספים אל target.user.group_identifiers.
user.key	target.user.product_object_id	אם יש ערך, הוא ממופה ל-UDM.
user.name	target.user.userid	אם יש ערך, הוא ממופה ל-UDM.
שם משתמש	target.user.userid	אם הוא קיים והמאפיין user.name לא קיים, הערך ממופה ל-UDM. הערך של event_type הוא USER_LOGIN.
(Parser Logic)	metadata.vendor_name	ההגדרה הזו תמיד תהיה DUO_SECURITY.
(Parser Logic)	metadata.product_name	ההגדרה תמיד תהיה MULTI-FACTOR_AUTHENTICATION.
(Parser Logic)	metadata.log_type	נלקח משדה log_type ברמה העליונה של היומן הגולמי.
(Parser Logic)	extensions.auth.type	תמיד צריך להגדיר את האפשרות 'כניסה יחידה (SSO)'.
`access_device.key`	`event.idm.read_only_udm.target.resource.product_object_id`	מופה מיומן השינויים
`access_device.browser_version`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`access_device.device_info_source`	`event.idm.read_only_udm.principal.asset.attribute.labels`	מופה מיומן השינויים
`access_device.epkey`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`access_device.flash_version`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`access_device.is_encryption_enabled`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`access_device.is_firewall_enabled`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`trusted_endpoint_status`	`event.idm.read_only_udm.principal.asset.attribute.labels`	מופה מיומן השינויים
`access_device.is_password_set`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`access_device.java_version`	`event.idm.read_only_udm.principal.resource.attribute.labels`	מופה מיומן השינויים
`host`	`event.idm.read_only_udm.target.hostname`	מופה מיומן השינויים
`host`	`event.idm.read_only_udm.target.asset.hostname`	מופה מיומן השינויים
`application.name`	`event.idm.read_only_udm.target.application`	מופה מיומן השינויים
`is_supported`	`event.idm.read_only_udm.security_result.detection_fields`	מופה מיומן השינויים
`trusted_session_uuid`	`event.idm.read_only_udm.security_result.detection_fields`	מופה מיומן השינויים
`passport_assessment_reason`	`event.idm.read_only_udm.security_result.detection_fields`	מופה מיומן השינויים
`remembered_factor`	`event.idm.read_only_udm.security_result.detection_fields`	מופה מיומן השינויים
`passport_assessment.is_potential`	`event.idm.read_only_udm.security_result.detection_fields`	מופה מיומן השינויים
`access_device.os`	`event.idm.read_only_udm.principal.platform`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.detected_attack_detectors`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.features_version`	`security_result.detection_fields`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.model_version`	`security_result.detection_fields`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.policy_enabled`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.preview_mode_enabled`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.reason`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.more_secure_auth.trust_level`	`security_result.detection_fields`	מופה מיומן השינויים
`adaptive_trust_assessments.remember_me.features_version`	`security_result.detection_fields`	מופה מיומן השינויים
`adaptive_trust_assessments.remember_me.model_version`	`security_result.detection_fields`	מופה מיומן השינויים
`adaptive_trust_assessments.remember_me.policy_enabled`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.remember_me.preview_mode_enabled`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.remember_me.reason`	`additional.fields`	מופה מיומן השינויים
`adaptive_trust_assessments.remember_me.trust_level`	`security_result.detection_fields`	מופה מיומן השינויים
`application.destination_name`	`target.application`	מופה מיומן השינויים
`auth_stage`	`metadata.product_event_type`	מופה מיומן השינויים

יומן שינויים

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

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