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

גרסת המנתח: 7.0

נתמך ב:

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

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

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

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

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

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

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

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

  1. נכנסים לחלונית הניהול של Duo כאדמינים עם התפקיד בעלים, אדמין או מנהל אפליקציות.
  2. עוברים אל Applications > Application Catalog.
  3. מאתרים את הרשומה של Admin API בקטלוג.
  4. לוחצים על + הוספה כדי ליצור את האפליקציה.
  5. מעתיקים ושומרים במיקום מאובטח את הפרטים הבאים:
    • מפתח שילוב
    • מפתח סודי
    • שם המארח של ה-API (לדוגמה, api-XXXXXXXX.duosecurity.com)
  6. עוברים לקטע הרשאות.
  7. מבטלים את הבחירה בכל אפשרויות ההרשאות, חוץ מ-Grant read log.
  8. לוחצים על שמירת השינויים.

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

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על + הוספת פיד חדש.
  3. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Duo Authentication Logs).
  4. בוחרים באפשרות API של צד שלישי בתור סוג המקור.
  5. בוחרים באפשרות Duo Auth בתור Log type.
  6. לוחצים על הבא.
  7. מציינים ערכים לפרמטרים הבאים של הקלט:
    • שם משתמש: מזינים את מפתח השילוב מ-Duo.
    • סוד: מזינים את המפתח הסודי מ-Duo.
    • שם המארח של ה-API: מזינים את שם המארח של ה-API (לדוגמה, api-XXXXXXXX.duosecurity.com).
    • מרחב השמות של הנכס: אופציונלי. מרחב השמות של הנכס.
    • תוויות הטמעה: אופציונלי. התווית שתתווסף לאירועים מהפיד הזה.
  8. לוחצים על הבא.
  9. בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

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

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

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

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

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

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

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

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

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

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

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

  1. נכנסים לדף Cloud Storage > Buckets.
  2. לוחצים על שם הקטגוריה.
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מזינים את פרטי ההגדרה הבאים:
    • הוספת חשבונות משתמשים: מזינים את כתובת האימייל של חשבון השירות (לדוגמה, duo-auth-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. מזינים את פרטי ההגדרה הבאים:
    • מזהה הנושא: מזינים את הערך duo-auth-trigger.
    • משאירים את ההגדרות האחרות כברירת מחדל.
  4. לוחצים על יצירה.

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

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

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

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

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

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

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

    • חשבון שירות: בוחרים את חשבון השירות duo-auth-collector-sa.
  9. עוברים לכרטיסייה מאגרי תגים:

    1. לוחצים על Variables & Secrets.
    2. לוחצים על ‎+ Add variable לכל משתנה סביבה:
    שם משתנה ערך לדוגמה
    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
  10. גוללים למטה בכרטיסייה Variables & Secrets (משתנים וסודות) עד שמגיעים לקטע Requests (בקשות):

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

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

    • בוחרים באפשרות ברירת מחדל (מומלץ).
  13. בקטע Revision scaling:

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

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

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

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

  1. מזינים main בשדה Function entry point.
  2. בעורך הקוד, יוצרים שני קבצים:

    • הקובץ הראשון: 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.*
    
  3. לוחצים על Deploy כדי לשמור ולפרוס את הפונקציה.

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

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

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

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

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

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

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

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

בדיקת המשימה המתוזמנת

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

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

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

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

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Duo Authentication Logs).
  5. בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
  6. בוחרים באפשרות Duo Auth בתור 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. לוחצים על שם הקטגוריה.
  3. עוברים לכרטיסייה Permissions.
  4. לוחצים על הענקת גישה.
  5. מזינים את פרטי ההגדרה הבאים:
    • הוספת חשבונות משתמשים: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
    • הקצאת תפקידים: בוחרים באפשרות צפייה באובייקטים באחסון.
  6. לוחצים על Save.

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

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

    • כתובת ה-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/
    • אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:

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

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

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

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

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

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

טבלת מיפוי UDM

שדה ביומן מיפוי UDM Logic (פונקציה לוגית)
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 ו-שם משתמש לא קיימים, מזהה המשתמש נשלף מהשדה dn באמצעות grok וממופה ל-UDM. הערך של event_type מוגדר כ-USER_LOGIN.
event_type metadata.product_event_type AND metadata.event_type הערך ממופה ל-metadata.product_event_type. הוא משמש גם לקביעת metadata.event_type: הערך "authentication" הופך ל-USER_LOGIN, הערך "enrollment" הופך ל-USER_CREATION, ואם הוא ריק או לא אחד מהם, הוא הופך ל-GENERIC_EVENT.
גורם extensions.auth.mechanism וגם 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.
תוצאה security_result.action_details AND security_result.action אם הוא קיים, הערך ממופה ל-security_result.action_details. הערך success או SUCCESS מתורגם ל-security_result.action ALLOW, אחרת הוא מתורגם ל-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. האפשרות "אישור" מתורגמת ל-security_result.action ALLOW, והאפשרות "דחייה" מתורגמת ל-BLOCK.
חותמת זמן metadata.event_timestamp ו-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.