סקירה כללית של מנתחי נתונים

נתמכים ב:

במאמר הזה מוסבר איך Google Security Operations מנתח יומנים גולמיים בפורמט Unified Data Model‏ (UDM).

מערכת Google SecOps יכולה לקבל נתוני יומנים ממקורות ההטמעה הבאים:

בדרך כלל, הלקוחות שולחים נתונים כיומנים גולמיים מקוריים. מערכת Google SecOps מזהה באופן ייחודי את המכשיר שיצר את היומנים באמצעות LogType. הערך LogType מזהה את:

  • הספק והמכשיר שיצרו את היומן, כמו Cisco Firewall,‏ Linux DHCP Server או Bro DNS.
  • איזה מנתח ממיר את היומן הגולמי ל-UDM מובנה. יש קשר של אחד לאחד בין מנתח לבין LogType. כל מנתח ממיר נתונים שמתקבלים מ-LogType אחד.

ב-Google SecOps יש קבוצה של מנתחי נתונים שמוגדרים כברירת מחדל, שקוראים את היומנים הגולמיים המקוריים ויוצרים רשומות UDM מובְנות באמצעות הנתונים שביומן הגולמי המקורי. ‫Google SecOps מתחזקת את המנתחים האלה. הלקוחות יכולים גם להגדיר הוראות למיפוי נתונים בהתאמה אישית על ידי יצירת מנתח ספציפי ללקוח. אם שולחים מטען ייעודי (payload) עם כמה שורות, המערכת מפרשת כל שורה כרשומה נפרדת ביומן.

תהליך העבודה של הטמעה ונורמליזציה

המנתח מכיל הוראות למיפוי נתונים. הוא מגדיר איך הנתונים ממופים מהיומן הגולמי המקורי לשדה אחד או יותר במבנה הנתונים של ה-UDM.

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

מנתח ברירת מחדל עשוי למפות קבוצת משנה של ערכים עיקריים מהיומן הגולמי. בדרך כלל, שדות הליבה האלה הם החשובים ביותר כדי לספק תובנות אבטחה ב-Google SecOps. ערכים שלא מופו נשארים ביומן הגולמי, אבל לא נשמרים ברשומת ה-UDM.

הלקוח יכול גם להשתמש בשיטות הטמעת הנתונים של Chronicle API כדי לשלוח נתונים בפורמט UDM מובנה. במאמר מעבר מ-SIEM API מדור קודם ל-Chronicle API מוסבר איך עוברים מ-Ingestion API מדור קודם ל-Chronicle API.

התאמה אישית של ניתוח הנתונים שנטמעים

ב-Google SecOps יש את היכולות הבאות שמאפשרות ללקוחות להתאים אישית את ניתוח הנתונים של נתוני היומן המקוריים שנכנסים. למידע נוסף על ניהול המנתחים האלה, ראו ניהול מנתחים מובנים ומותאמים אישית.

  • מנתחים ספציפיים ללקוח: הלקוחות יוצרים הגדרה של מנתח מותאם אישית לסוג ספציפי של יומן שעומד בדרישות הספציפיות שלהם. מנתח ספציפי ללקוח מחליף את מנתח ברירת המחדל של LogType הספציפי. מידע נוסף זמין במאמר ניהול מנתחים מוגדרים מראש ומותאמים אישית.
  • תוספים למנתח: הלקוחות יכולים להוסיף הוראות מיפוי בהתאמה אישית בנוסף להגדרת ברירת המחדל של המנתח. כל לקוח יכול ליצור קבוצה ייחודית משלו של הוראות מיפוי בהתאמה אישית. הוראות המיפוי האלה מגדירות איך לחלץ שדות נוספים מהיומנים הגולמיים המקוריים ולהמיר אותם לשדות UDM. תוסף מנתח לא מחליף את המנתח שמוגדר כברירת מחדל או את המנתח הספציפי ללקוח.

דוגמה לשימוש ביומן של שרת proxy לאינטרנט מסוג Squid

בקטע הזה מופיעה דוגמה ליומן של שרת proxy לאינטרנט מסוג Squid, ומוסבר איך הערכים ממופים לרשומת UDM. לתיאור של כל השדות בסכימת ה-UDM, קראו את המאמר רשימת השדות של Unified Data Model.

הדוגמה של יומן שרת ה-proxy לאינטרנט של Squid מכילה ערכים שמופרדים ברווחים. כל רשומה מייצגת אירוע אחד ומאחסנת את הנתונים הבאים: חותמת זמן, משך זמן, לקוח, קוד תוצאה/סטטוס תוצאה, בייטים שהועברו, שיטת בקשה, כתובת URL, משתמש, קוד היררכיה וסוג תוכן. בדוגמה הזו, השדות הבאים נשלפים וממופים לרשומת UDM: זמן, לקוח, סטטוס תוצאה, בייטים, שיטת בקשה וכתובת URL.

1588059648.129 23 192.168.23.4 TCP_HIT/200 904 GET www.google.com/images/sunlogo.png - HIER_DIRECT/203.0.113.52 image/jpeg

שרת proxy לדוגמה לאינטרנט של Squid

כשמשווים בין המבנים האלה, אפשר לראות שרק חלק מנתוני היומן המקוריים נכללים ברשומת ה-UDM. חלק מהשדות הם שדות חובה וחלק הם אופציונליים. בנוסף, רק בחלק מהקטעים ברשומת ה-UDM יש נתונים. אם המנתח לא ממפה נתונים מהיומן המקורי לרשומת ה-UDM, הקטע הזה של רשומת ה-UDM לא יופיע ב-Google SecOps.

ערכי יומן שממופים ל-UDM

הקטע metadata מאחסן את חותמת הזמן של האירוע. שימו לב שהערך הומר מפורמט Epoch לפורמט RFC 3339. ההמרה הזו היא אופציונלית. אפשר לאחסן את חותמת הזמן בפורמט Epoch, עם עיבוד מראש כדי להפריד את החלקים של השניות והאלפיות השנייה לשדות נפרדים.

השדה metadata.event_type מאחסן את הערך NETWORK_HTTP, שהוא ערך מספרי שמזהה את סוג האירוע. הערך של metadata.event_type קובע אילו שדות UDM נוספים נדרשים ואילו אופציונליים. הערכים product_name ו-vendor_name מכילים תיאורים ידידותיים למשתמש של המכשיר שתיעד את היומן המקורי.

השדה metadata.event_type ברשומת אירוע UDM לא זהה לשדה log_type שמוגדר כשמטמיעים נתונים באמצעות Chronicle API. שני המאפיינים האלה מאחסנים מידע שונה.

הקטע network מכיל ערכים מאירוע היומן המקורי. שימו לב שבדוגמה הזו, ערך הסטטוס מהיומן המקורי נותח מהשדה result code/status לפני שנכתב ברשומת ה-UDM. רק result_code נכלל ברשומת ה-UDM.

ערכי יומן שממופים ל-UDM

הקטע principal מאחסן את פרטי הלקוח מהיומן המקורי. בקטע target מאוחסנות גם כתובת ה-URL המוגדרת במלואה וגם כתובת ה-IP.

בקטע security_result מאוחסן אחד מערכי ה-enum שמייצגים את הפעולה שתועדה ביומן המקורי.

זוהי רשומת ה-UDM בפורמט JSON. שימו לב שרק קטעים שמכילים נתונים נכללים בדוח. הקטעים src,‏ observer,‏ intermediary,‏ about ו-extensions לא נכללים.

{
        "metadata": {
            "event_timestamp": "2020-04-28T07:40:48.129Z",
            "event_type": "NETWORK_HTTP",
            "product_name": "Squid Proxy",
            "vendor_name": "Squid"
        },
        "principal": {
            "ip": "192.168.23.4"
        },
        "target": {
            "url": "www.google.com/images/sunlogo.png",
            "ip": "203.0.113.52"
        },
        "network": {
            "http": {
                "method": "GET",
                "response_code": 200,
                "received_bytes": 904
            }
        },
        "security_result": {
            "action": "UNKNOWN_ACTION"
        }
}

שלבים בהוראות לניתוח קובצי XML

ההוראות למיפוי נתונים במנתח פועלות לפי דפוס נפוץ, כמו בדוגמה הבאה:

  1. לנתח ולחלץ נתונים מהיומן המקורי.
  2. לבצע שינויים בנתונים שחולצו. זה כולל שימוש בלוגיקה מותנית כדי לנתח ערכים באופן סלקטיבי, להמיר סוגי נתונים, להחליף מחרוזות משנה בערך, להמיר לאותיות רישיות או קטנות וכו'.
  3. מקצים ערכים לשדות UDM.
  4. מפיקים את רשומת ה-UDM הממופה למפתח @output.

לנתח ולחלץ נתונים מהיומן המקורי

הגדרת הצהרת הסינון

ההצהרה filter היא ההצהרה הראשונה בקבוצת הוראות הניתוח. כל הוראות הניתוח הנוספות כלולות בהצהרה filter.

filter {

}

מאתחלים משתנים שיאחסנו את הערכים שחולצו

בתוך ההצהרה filter, מאתחלים משתני ביניים שבהם המנתח ישתמש כדי לאחסן ערכים שחולצו מהיומן.

המשתנים האלה משמשים בכל פעם שמתבצע ניתוח של יומן בודד. הערך בכל משתנה ביניים יוגדר לשדה UDM אחד או יותר בהמשך הוראות הניתוח.

  mutate {
    replace => {
      "event.idm.read_only_udm.metadata.product_name" => "Webproxy"
      "event.idm.read_only_udm.metadata.vendor_name" => "Squid"
      "not_valid_log" => "false"
      "when" => ""
      "srcip" => ""
      "action" => ""
      "username" => ""
      "url" => ""
      "tgtip" => ""
      "method" => ""
    }
  }

חילוץ ערכים ספציפיים מהיומן

ב-Google SecOps יש קבוצה של מסננים שמבוססים על Logstash, כדי לחלץ שדות מקובצי יומן מקוריים. בהתאם לפורמט של היומן, משתמשים במסנן חילוץ אחד או יותר כדי לחלץ את כל הנתונים מהיומן. אם המחרוזת היא:

  • ‫JSON מקורי, תחביר המנתח דומה למסנן JSON שתומך ביומנים בפורמט JSON. אין תמיכה ב-JSON בתצורה של עץ.
  • פורמט XML, תחביר המנתח דומה למסנן XML שתומך ביומנים בפורמט XML.
  • צמדי מפתח/ערך, תחביר המנתח דומה למסנן Kv שתומך בהודעות בפורמט של מפתח/ערך.
  • פורמט CSV, תחביר המנתח דומה למסנן CSV שתומך בהודעות בפורמט CSV.
  • בכל שאר הפורמטים, תחביר המנתח דומה למסנן GROK עם תבניות מובנות של GROK. השיטה הזו משתמשת בהוראות חילוץ בסגנון ביטוי רגולרי (Regex).

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

נמשיך עם הדוגמה של יומן שרת ה-proxy לאינטרנט Squid. הוראת חילוץ הנתונים הבאה כוללת שילוב של תחביר Logstash Grok וביטויים רגולריים.

הצהרת החילוץ הבאה מאחסנת ערכים במשתני הביניים הבאים:

  • when
  • srcip
  • action
  • returnCode
  • size
  • method
  • username
  • url
  • tgtip

ההצהרה לדוגמה משתמשת גם במילת המפתח overwrite כדי לאחסן את הערכים שחולצו בכל משתנה. אם תהליך החילוץ מחזיר שגיאה, ההצהרה on_error מגדירה את not_valid_log ל-true.

grok {
   match => {
     "message" => [
       "%{NUMBER:when}\\s+\\d+\\s%{SYSLOGHOST:srcip} %{WORD:action}\\/%{NUMBER:returnCode} %{NUMBER:size} %{WORD:method} (?P<url>\\S+) (?P<username>.*?) %{WORD}\\/(?P<tgtip>\\S+).*"
     ]
   }
   overwrite => ["when","srcip","action","returnCode","size","method","url","username","tgtip"]
   on_error => "not_valid_log"
}

שינוי והמרה של הערכים שחולצו

כדי לאפשר שינוי של ערכים שחולצו מהיומן המקורי, Google SecOps משתמש ביכולות של הפלאגין של מסנן המוטציה של Logstash. ‫Google SecOps מספקת קבוצת משנה של היכולות שזמינות בפלאגין. בקטע תחביר של מנתח מתוארות התכונות הנתמכות והפונקציות בהתאמה אישית, כמו:

  • להמיר ערכים לסוג נתונים אחר
  • להחליף ערכים במחרוזת
  • למזג שני מערכים או להוסיף מחרוזת למערך. ערכי מחרוזות מומרים למערך לפני המיזוג.
  • להמיר לאותיות קטנות או לאותיות רישיות

בקטע הזה מוצגות דוגמאות לטרנספורמציה של נתונים, שמבוססות על יומן שרת ה-proxy של Squid שהוצג קודם.

שינוי חותמת הזמן של האירוע

לכל האירועים שמאוחסנים כרשומת UDM צריכה להיות חותמת זמן של האירוע. בדוגמה הזו, המערכת בודקת אם ערך הנתונים חולץ מהיומן. לאחר מכן, הוא משתמש בפונקציית התאריך של Grok כדי להתאים את הערך לפורמט הזמן UNIX.

if [when] != "" {
  date {
    match => [
      "when", "UNIX"
    ]
   }
 }

משנים את הערך של username

ההצהרה הבאה ממירה את הערך במשתנה username לאותיות קטנות.

mutate {
   lowercase => [ "username"]
   }

משנים את הערך של action

בדוגמה הבאה, הפונקציה בודקת את הערך במשתנה הביניים action ומשנה אותו ל-ALLOW, ל-BLOCK או ל-UNKNOWN_ACTION, שהם ערכים תקינים בשדה ה-UDM‏ security_result.action. השדה security_result.action ב-UDM הוא סוג ממוספר שמאחסן רק ערכים ספציפיים.

if ([action] == "TCP_DENIED" or [action] == "TCP_MISS" or [action] == "Denied" or [action] == "denied" or [action] == "Dropped") {
      mutate {
        replace => {
          "action" => "BLOCK"
        }
      }
   } else if ([action] == "TCP_TUNNEL" or [action] == "Accessed" or [action] == "Built" or [action] == "Retrieved" or [action] == "Stored") {
     mutate {
        replace => {
          "action" => "ALLOW"
        }
     }
   } else {
      mutate {
        replace => {
          "action" => "UNKNOWN_ACTION" }
      }
   }

שינוי כתובת ה-IP של היעד

בדוגמה הבאה, המערכת בודקת אם יש ערך במשתנה הביניים tgtip. אם הוא נמצא, הערך מותאם לתבנית של כתובת IP באמצעות תבנית Grok מוגדרת מראש. אם יש שגיאה בהתאמת הערך לתבנית של כתובת IP, הפונקציה on_error מגדירה את המאפיין not_valid_tgtip כ-true. אם ההתאמה מצליחה, המאפיין not_valid_tgtip לא מוגדר.

if [tgtip] not in [ "","-" ] {
   grok {
     match => {
       "tgtip" => [ "%{IP:tgtip}" ]
     }
     overwrite => ["tgtip"]
     on_error => "not_valid_tgtip"
   }

שינוי סוג הנתונים של returnCode ו-size

בדוגמה הבאה, הערך במשתנה size מומר ל-uinteger והערך במשתנה returnCode מומר ל-uinteger. הפעולה הזו נדרשת כי המשתנה size יישמר בשדה network.received_bytes ב-UDM, שבו מאוחסן סוג הנתונים int64. המשתנה returnCode יישמר בשדה network.http.response_code ב-UDM, שבו מאוחסן סוג הנתונים int32.

mutate {
  convert => {
    "returnCode" => "integer"
    "size" => "uinteger"
  }
}

הקצאת ערכים לשדות UDM באירוע

אחרי שהערכים חולצו ועברו עיבוד מראש, מקצים אותם לשדות ברשומת אירוע ב-UDM. אפשר להקצות גם ערכים שחולצו וגם ערכים סטטיים לשדה UDM.

אם מאכלסים את event.disambiguation_key, צריך לוודא שהשדה הזה ייחודי לכל אירוע שנוצר ביומן הנתון. אם לשני אירועים שונים יש את אותו disambiguation_key, זה יגרום להתנהגות לא צפויה במערכת.

הדוגמאות לניתוח בקטע הזה מבוססות על הדוגמה הקודמת של יומן שרת ה-proxy לאינטרנט של Squid.

שמירת חותמת הזמן של האירוע

בכל רשומת אירוע ב-UDM צריך להיות ערך בשדה metadata.event_timestamp. בדוגמה הבאה, חותמת הזמן של האירוע שחולצה מהיומן נשמרת במשתנה המובנה @timestamp. כברירת מחדל, מערכת Google Security Operations שומרת את הנתונים האלה בשדה metadata.event_timestamp ב-UDM.

mutate {
  rename => {
    "when" => "timestamp"
  }
}

הגדרת סוג האירוע

בכל רשומת אירוע ב-UDM צריך להיות ערך בשדה metadata.event_type ב-UDM. השדה הזה הוא מסוג ממוספר. הערך של השדה הזה קובע אילו שדות UDM נוספים צריך לאכלס כדי לשמור את רשומת ה-UDM. תהליך הניתוח והנורמליזציה ייכשל אם אחד משדות החובה לא יכיל נתונים תקינים.

replace => {
    "event.idm.read_only_udm.metadata.event_type" => "NETWORK_HTTP"
   }
}

שומרים את הערכים של username ו-method באמצעות ההצהרה replace

הערכים בשדות הביניים username ו-method הם מחרוזות. בדוגמה הבאה, המערכת בודקת אם קיים ערך תקין. אם כן, היא מאחסנת את הערך username בשדה ה-UDM‏ principal.user.userid ואת הערך method בשדה ה-UDM‏ network.http.method.

if [username] not in [ "-" ,"" ] {
  mutate {
    replace => {
      "event.idm.read_only_udm.principal.user.userid" => "%{username}"
    }
  }
}

if [method] != "" {
  mutate {
    replace => {
      "event.idm.read_only_udm.network.http.method" => "%{method}"
    }
  }
}

שמירת ה-action בשדה ה-UDM של security_result.action

בקטע הקודם, הערך במשתנה הביניים action הוערך והומר לאחד מהערכים הסטנדרטיים של השדה security_result.action ב-UDM.

בשדות security_result ו-action ב-UDM מאוחסן מערך של פריטים, ולכן צריך לפעול בגישה קצת שונה כששומרים את הערך הזה.

קודם שומרים את הערך שעבר טרנספורמציה בשדה security_result.action זמני. השדה security_result הוא הורה של השדה action.

mutate {
   merge => {
     "security_result.action" => "action"
   }
}

לאחר מכן, שומרים את השדה הזמני security_result.action בשדה security_result ב-UDM. השדה security_result ב-UDM מכיל מערך של פריטים, ולכן הערך נוסף לשדה הזה.

 # save the security_result field
mutate {
  merge => {
    "event.idm.read_only_udm.security_result" => "security_result"
  }
}

שומרים את כתובת ה-IP של היעד ואת כתובת ה-IP של המקור באמצעות ההצהרה merge

מאחסנים את הערכים הבאים ברשומת האירוע של ה-UDM:

  • הערך במשתנה הביניים srcip לשדה ה-UDM‏ principal.ip.
  • הערך במשתנה הביניים tgtip לשדה ה-UDM‏ target.ip.

בשדות principal.ip ו-target.ip ב-UDM מאוחסן מערך של פריטים, ולכן הערכים מצורפים לכל שדה.

הדוגמאות הבאות ממחישות גישות שונות לשמירת הערכים האלה. בשלב הטרנספורמציה, המשתנה הזמני tgtip הותאם לכתובת IP באמצעות תבנית Grok מוגדרת מראש. ההצהרה לדוגמה הבאה בודקת אם המאפיין not_valid_tgtip הוא true, מה שמציין שלא ניתן להתאים את הערך tgtip לתבנית של כתובת IP. אם הערך הוא false, הוא שומר את הערך של tgtip בשדה target.ip ב-UDM.

if ![not_valid_tgtip] {
  mutate {
    merge => {
      "event.idm.read_only_udm.target.ip" => "tgtip"
    }
  }
 }

המשתנה הזמני srcip לא עבר טרנספורמציה. ההצהרה הבאה בודקת אם חולץ ערך מהיומן המקורי, ואם כן, שומרת את הערך בשדה principal.ip ב-UDM.

if [srcip] != "" {
  mutate {
    merge => {
      "event.idm.read_only_udm.principal.ip" => "srcip"
    }
  }
}

שומרים את url,‏ returnCode ו-size באמצעות ההצהרה rename

ההצהרה לדוגמה הבאה שומרת את הערכים באמצעות ההצהרה rename:

  • המשתנה url נשמר בשדה target.url ב-UDM.
  • המשתנה הזמני returnCode נשמר בשדה ה-UDM‏ network.http.response_code.
  • המשתנה הזמני size נשמר בשדה network.received_bytes ב-UDM.
mutate {
  rename => {
     "url" => "event.idm.read_only_udm.target.url"
     "returnCode" => "event.idm.read_only_udm.network.http.response_code"
     "size" => "event.idm.read_only_udm.network.received_bytes"
  }
}

קישור רשומת ה-UDM לפלט

ההצהרה הסופית בהוראה למיפוי הנתונים מוציאה את הנתונים המעובדים לרשומת אירוע ב-UDM.

mutate {
    merge => {
      "@output" => "event"
    }
  }

קוד המנתח המלא

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

filter {

# initialize variables
  mutate {
    replace => {
      "event.idm.read_only_udm.metadata.product_name" => "Webproxy"
      "event.idm.read_only_udm.metadata.vendor_name" => "Squid"
      "not_valid_log" => "false"
      "when" => ""
      "srcip" => ""
      "action" => ""
      "username" => ""
      "url" => ""
      "tgtip" => ""
      "method" => ""
    }
  }

  # Extract fields from the raw log.
    grok {
      match => {
        "message" => [
          "%{NUMBER:when}\\s+\\d+\\s%{SYSLOGHOST:srcip} %{WORD:action}\\/%{NUMBER:returnCode} %{NUMBER:size} %{WORD:method} (?P<url>\\S+) (?P<username>.*?) %{WORD}\\/(?P<tgtip>\\S+).*"
        ]
      }
      overwrite => ["when","srcip","action","returnCode","size","method","url","username","tgtip"]
      on_error => "not_valid_log"
    }

  # Parse event timestamp
  if [when] != "" {
    date {
      match => [
        "when", "UNIX"
      ]
     }
   }

   # Save the value in "when" to the event timestamp
   mutate {
     rename => {
       "when" => "timestamp"
     }
   }

   # Transform and save username
   if [username] not in [ "-" ,"" ] {
     mutate {
       lowercase => [ "username"]
        }
      }
     mutate {
       replace => {
         "event.idm.read_only_udm.principal.user.userid" => "%{username}"
       }
     }


if ([action] == "TCP_DENIED" or [action] == "TCP_MISS" or [action] == "Denied" or [action] == "denied" or [action] == "Dropped") {
      mutate {
        replace => {
          "action" => "BLOCK"
        }
      }
   } else if ([action] == "TCP_TUNNEL" or [action] == "Accessed" or [action] == "Built" or [action] == "Retrieved" or [action] == "Stored") {
     mutate {
        replace => {
          "action" => "ALLOW"
        }
     }
   } else {
      mutate {
        replace => {
          "action" => "UNKNOWN_ACTION" }
      }
   }

  # save transformed value to an intermediary field
   mutate {
      merge => {
        "security_result.action" => "action"
      }
   }

    # save the security_result field
    mutate {
      merge => {
        "event.idm.read_only_udm.security_result" => "security_result"
      }
    }

   # check for presence of target ip. Extract and store target IP address.
   if [tgtip] not in [ "","-" ] {
     grok {
       match => {
         "tgtip" => [ "%{IP:tgtip}" ]
       }
       overwrite => ["tgtip"]
       on_error => "not_valid_tgtip"
     }

     # store  target IP address
     if ![not_valid_tgtip] {
       mutate {
         merge => {
           "event.idm.read_only_udm.target.ip" => "tgtip"
         }
       }
     }
   }

   # convert  the returnCode and size  to integer data type
   mutate {
     convert => {
       "returnCode" => "integer"
       "size" => "uinteger"
     }
   }

   # save  url, returnCode, and size
   mutate {
     rename => {
        "url" => "event.idm.read_only_udm.target.url"
        "returnCode" => "event.idm.read_only_udm.network.http.response_code"
        "size" => "event.idm.read_only_udm.network.received_bytes"
     }

     # set the event type to NETWORK_HTTP
     replace => {
        "event.idm.read_only_udm.metadata.event_type" => "NETWORK_HTTP"
     }
   }

   # validate and set source IP address
   if [srcip] != "" {
     mutate {
       merge => {
         "event.idm.read_only_udm.principal.ip" => "srcip"
       }
     }
   }

  # save  event to @output
   mutate {
     merge => {
       "@output" => "event"
     }
   }

} #end of filter

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