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

נדריך אתכם דרך קליטת יומנים, זיהוי אנומליות באמצעות מודל למידת מכונה קליל, ואפילו ניגע כיצד המערכת יכולה להגיב באופן אוטומטי.

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

תוכן עניינים

מהם מערכות SIEM?

מערכות ניהול מידע ואירועים בתחום האבטחה (SIEM) הן המערכת העצבית המרכזית של פעולות האבטחה המודרניות. מערכת SIEM מאגדת ומקשרת בין יומני אבטחה ואירועים מכלל הסביבה הטכנולוגית כדי לספק תובנות בזמן אמת לגבי תקריות פוטנציאליות. זה מסייע לארגונים לזהות איומים מהר יותר ולהגיב מוקדם יותר.

מערכות אלה אוספות כמויות עצומות של נתוני יומן — ממודעות של חומת אש ועד יומני אפליקציות — ומנתחות אותן לחיפוש סימני בעיות. זיהוי אנומליות בהקשר זה הוא קריטי, ודפוסים לא רגילים ביומנים יכולים לחשוף תקריות שעשויות להחמיץ כללים סטטיים. לדוגמה, עלייה פתאומית בבקשות רשת עשויה להעיד על התקפת DDoS, בעוד שניסיונות כניסה לא מצליחים רבים עשויים להעיד על ניסי גישה לא מורשים.

ה-AI מבצע צעד נוסף ביכולות ה-SIEM. באמצעות ניצול מודלים מתקדמים של AI (כמו מודלים גדולים של שפה), SIEM המופעל על ידי AI יכול לפרש ולהבין לוגים בצורה חכמה, ללמוד איך נראית התנהגות "נורמלית", ולסמן את הדברים ה"חשודים" שדורשים תשומת לב.

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

דרישות מוקדמות

לפני שנצלול פנימה, ודא שיש לך את הדברים הבאים:

  • פייתון 3.x מותקן במערכת שלך. דוגמאות הקוד צריכות לעבוד בכל גרסה עדכנית של פייתון.

  • היכרות בסיסית עם תכנות פייתון (לולאות, פונקציות, שימוש בספריות) והבנה של לוגים (למשל, איך נכנס רשומה בלוג) תהיה מועילה.

  • ספריות פייתון: נשתמש בכמה ספריות נפוצות שהן קלות משקל ואינן דורשות חומרה מיוחדת:

    • pandas לניהול נתונים בסיסי (אם היומנים שלך בפורמט CSV או פורמט דומה).

    • numpy עבור פעולות מספריות.

    • scikit-learn עבור מודל זיהוי אנומליות (באופן ספציפי, נשתמש באלגוריתם IsolationForest).

  • סט של נתוני יומן לניתוח. ניתן להשתמש בכל קובץ יומן (יומני מערכת, יומני אפליקציות וכו') בפורמט טקסט פשוט או פורמט CSV. לצורך הדגמה, נדמה מערך נתוני יומן קטן כדי שתוכל לעקוב גם בלעדי קובץ יומן מוכן.

הערה: אם אין לך את הספריות לעיל, התקן אותן באמצעות pip:

pip install pandas numpy scikit-learn

הגדרת הפרויקט

יצירת מבנה פשוט לפרויקט זה של זיהוי חריגות SIEM. צור תיקייה חדשה עבור הפרויקט ונווט אליה. בתוך התיקייה, תוכל ליצור סקריפט פייתון (לדוגמה, siem_anomaly_demo.py) או דף סיכום של Jupyter כדי להריץ את הקוד שלב אחרי שלב.

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

שלבי הגדרת הפרויקט:

  1. אתחול הסביבה – אם אתה מעדיף, צור סביבה וירטואלית עבור פרויקט זה (אופציונלי אך שימוש טוב):

    python -m venv venv
source venv/bin/activate  # במערכת הפעלה Windows השתמש ב-"venv\Scripts\activate"

    לאחר מכן התקן את החבילות הנדרשות בסביבה הווירטואלית הזו.

  2. הכן מקור נתונים – זהה את מקור הלוג שברצונך לנתח. זה יכול להיות נתיב לקובץ לוגים או למסד נתונים. וודא שאתה מכיר בפורמט הלוגים (לדוגמה, האם הם מופרדים בפסיקים, שורות JSON או טקסט פשוט?). לצורך הדגמה, נצטן כמה רשומות לוג.

  3. הגדר את הסקריפט או המחברת שלך – פתח את קובץ הפייתון שלך או המחברת. נתחיל על ידי יבוא הספריות הנדרשות והגדרת כל תצורות נדרשות (כמו זרעים אקראיים לשקיפות).

בסוף שלב ההגדרה הזה, אתה אמור להיות בסביבת Python מוכנה להריץ את קוד ניתוח היומנים שלנו, ויש לך או מערכת נתונים אמיתית של יומנים או הכוונה לדמות נתונים יחד איתי.

יישום ניתוח יומנים

במערכת SIEM מלאה, ניתוח יומנים כולל איסוף יומנים ממקורות שונים ופרסונם לפורמט אחיד לעיבוד נוסף. יומנים מכילים לעיתים קרובות שדות כמו חותמת זמן, רמת חמורה, מקור, הודעת אירוע, מזהה משתמש, כתובת IP, ועוד. המשימה הראשונה היא לקלוט ולעבד מראש את היומנים הללו.

1. קליטת יומנים

אם היומנים שלך נמצאים בקובץ טקסט, תוכל לקרוא אותם ב-Python. לדוגמה, אם כל רשומת יומן היא שורה בקובץ, תוכל לעשות:

with open("my_logs.txt") as f:
    raw_logs = f.readlines()

אם היומנים מסודרים (נגיד, בפורמט CSV עם עמודות), Pandas יכול מאוד לפשט את הקריאה:

import pandas as pd
df = pd.read_csv("my_logs.csv")
print(df.head())

זה ייתן לך DataFrame df עם רשומות היומנים שלך מאורגנות בעמודות. אך רבים מהיומנים הם חצי-מובנים (למשל, רכיבים מופרדים על ידי רווחים או תווים מיוחדים). במקרים כאלה, ייתכן שתצטרך לחלק כל שורה לפי מפריד או להשתמש ב-regex כדי לחלץ שדות. לדוגמה, דמיין שורת יומן:

2025-03-06 08:00:00, INFO, User login success, user: admin

זה מכיל חותמת זמן, רמת יומן, הודעה, ומשתמש. נוכל לפרסם שורות כאלה עם שיטות המחרוזות של Python:

logs = [
    "2025-03-06 08:00:00, INFO, User login success, user: admin",
    "2025-03-06 08:01:23, INFO, User login success, user: alice",
    "2025-03-06 08:02:45, ERROR, Failed login attempt, user: alice",
    # ... (עוד שורות יומן)
]
parsed_logs = []
for line in logs:
    parts = [p.strip() for p in line.split(",")]
    timestamp = parts[0]
    level = parts[1]
    message = parts[2]
    user = parts[3].split(":")[1].strip() if "user:" in parts[3] else None
    parsed_logs.append({"timestamp": timestamp, "level": level, "message": message, "user": user})

# המרת ל-DataFrame לניתוח קל יותר
df_logs = pd.DataFrame(parsed_logs)
print(df_logs.head())

הרצת הקוד הנ"ל על רשימת הדוגמאות שלנו תפיק משהו כמו:

            timestamp  level                 message   user
0  2025-03-06 08:00:00   INFO    User login success   admin
1  2025-03-06 08:01:23   INFO    User login success   alice
2  2025-03-06 08:02:45  ERROR  Failed login attempt   alice
...

כעת סידרנו את היומנים בטבלה. בתרחיש אמיתי, תמשיכו לנתח את כל השדות הרלוונטיים ביומנים שלכם (למשל, כתובות IP, קודי שגיאה, וכו') בהתאם למה שאתם רוצים לנתח.

2. עיבוד מקדים והפקת תכונות

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

  • כמות אירועים: מספר האירועים לדקה/שעה, מספר כישלונות התחברות לכל משתמש, וכו'.

  • משך או גודל: אם היומנים כוללים משכים או גדלי נתונים (למשל, גודל העברת קובץ, זמן ביצוע שאילתה), ניתן להשתמש בערכים המספריים הללו ישירות.

  • קידוד קטגוריאלי: רמות יומן (INFO, ERROR, DEBUG) יכולות להיות ממופות למספרים, או סוגי אירועים ספציפיים יכולים להיות מקודדים באחת החמות.

עבור הוכחת הקונספט הזו, נתרכז בתכונה מספרית פשוטה: מספר ניסיונות ההתחברות לדקה עבור משתמש נתון. נחקור זאת כנתוני התכונה שלנו.

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

כדי לדמות, ניצור רשימה של 50 ערכים המייצגים התנהגות נורמלית, ולאחר מכן נוסיף כמה ערכים גבוהים באופן חריג:

import numpy as np

# דמיין 50 דקות של מספר ניסיונות התחברות נורמליים (סביב 5 לדקה בממוצע)
np.random.seed(42)  # לדוגמה שניתן לשחזר
normal_counts = np.random.poisson(lam=5, size=50)

# דמיין אנומליה: עלייה בניסיונות התחברות (למשל, תוקף מנסה 30+ פעמים בדקה)
anomalous_counts = np.array([30, 40, 50])

# שלב את הנתונים
login_attempts = np.concatenate([normal_counts, anomalous_counts])
print("Login attempts per minute:", login_attempts)

כאשר תריץ את מה שכתוב למעלה, login_attempts עשוי להיראות כך:

Login attempts per minute: [ 5  4  4  5  5  3  5  ...  4 30 40 50]

רוב הערכים הם בעשרות בודדות, אך בסוף יש לנו שלוש דקות עם 30, 40 ו-50 ניסיונות – חריגות ברורות. אלו הם הנתונים המוכנים שלנו לזיהוי אנומליות. בניתוח לוגים אמיתי, סוג כזה של נתונים עשוי להגיע ממניית אירועים בלוגים שלך לאורך זמן או מחילוץ מדד כלשהו מתוכן הלוג.

עכשיו שנתונינו מוכנים, אנו יכולים לעבור לבניית מודל זיהוי האנומליות.

איך לבנות את המודל לזיהוי חריגות

כדי לזהות חריגות בנתוני היומן שלנו, נשתמש בגישת למידת מכונה. במפורש, נשתמש ביער הבידוד – אלגוריתם פופולרי לזיהוי חריגות לא מובחנות

. יער הבידוד פועל על ידי חלוקה אקראית של הנתונים ובידוד נקודות. חריגות הן הנקודות שמתבדרות (מופרדות מאחרות) במהירות, כלומר, בפחות חלוקות אקראיות. זה מקל על זיהוי חריגות במערך נתונים ללא צורך בתוויות (אין צורך לדעת מראש מי מרשומות היומן הן "רעות").

למה יער הבידוד?

  • זה יעיל ועובד היטב גם אם יש לנו הרבה נתונים.

  • הוא אינו מניח כל הפצת נתונים ספציפית (להבדיל מכמה שיטות סטטיסטיות).

  • הוא נותן לנו אופן ישיר לציון חריגות.

בואו נכשיר יער בידוד על הנתונים שלנו של נסיונות_כניסה:

from sklearn.ensemble import IsolationForest

# הכנה של הנתונים בצורה שהמודל מצפה (דוגמאות, תכונות)
X = login_attempts.reshape(-1, 1)  # כל דוגמה היא מערך 1-ממדי [ספירה]

# אתחול המודל של Isolation Forest
model = IsolationForest(contamination=0.05, random_state=42)
# contamination=0.05 אומר שאנחנו מצפים כ-5% מהנתונים להיות חריגים

# אימון המודל על הנתונים
model.fit(X)

כמה הערות על הקוד:

  • שינינו את צורת המערך של ניסיונות_התחברות למערך 2-ממדי X עם עמודת תכונה אחת מכיוון ש-Scikit-learn דורש מערך 2-ממדי לאימון (fit).

  • שמנו ערך של contamination=0.05 כדי לתת למודל רמז שכ-5% מהנתונים עשויים להיות חריגים. בנתונים הסינתטיים שלנו הוספנו 3 חריגים מתוך 53 נקודות, שהם כ-5.7%, לכן 5% הוא תחזית סבירה. (אם לא תציין contamination, האלגוריתם יבחר בברירת מחדל בהנחה או ישתמש בברירת מחדל 0.1 בגרסאות מסוימות.)

  • random_state=42 פשוט מבטיח שניתן לשחזור.

בנקודה זו, דגם ה-Isolation Forest כבר הוכשר על הנתונים שלנו. פנימית, נבנה אנסמבל של עצים אקראיים שמחלקים את הנתונים. נקודות שקשה לבדוד (כלומר, באשף הצפצוף של הנקודות הרגילות) נכנסות עמוק בעצים אלו, בעוד שנקודות שקל לבדוד (החריגים) נכנסות עם מסלולים קצרים.

הבאנו, נשתמש בדגם זה כדי לזהות אילו נקודות נתונים נחשבות כחריגות.

בדיקה ותצוגה חזותית של התוצאות

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

# השתמש בדגם כדי לחזות חריגויות
labels = model.predict(X)
# הדגם מחזיר +1 עבור נקודות רגילות ו-1 עבור חריגות

# חלץ את אינדקסי החריגות והערכים
anomaly_indices = np.where(labels == -1)[0]
anomaly_values = login_attempts[anomaly_indices]

print("Anomaly indices:", anomaly_indices)
print("Anomaly values (login attempts):", anomaly_values)

במקרה שלנו, אנו מצפים שהחריגויות יהיו המספרים הגדולים שהוספנו (30, 40, 50). הפלט עשוי להיראות כמו:

Anomaly indices: [50 51 52]
Anomaly values (login attempts): [30 40 50]

אפילו בלעדי ידע על "ניסיונות כניסה" בפרט, ה-Isolation Forest זיהה את הערכים האלה כמחוץ לקו הנתונים השארי.

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

הצגת התוצאות

בניתוח אמיתי, תמיד שימושי להציג את הנתונים ואת החריגות. לדוגמה, נוכל לצייר את ערכי ניסיונות_התחברות לאורך זמן (לדקה לדקה) ולהדגיש את החריגות בצבע שונה.

במקרה הפשוט הזה, גרף קו יראה קו ממוצע כמעט אופקי סביב 3-8 התחברויות/דקה עם שלושה זנבות ענקיים בסופו. הזנבות הללו הם החריגויות שלנו. ניתן להשיג זאת באמצעות Matplotlib אם אתה מריץ זאת במחברת:

import matplotlib.pyplot as plt

plt.plot(login_attempts, label="Login attempts per minute")
plt.scatter(anomaly_indices, anomaly_values, color='red', label="Anomalies")
plt.xlabel("Time (minute index)")
plt.ylabel("Login attempts")
plt.legend()
plt.show()

עבור פלט מבוסס טקסט כמו שיש לנו כאן, התוצאות המודפסות כבר מאשרות שהערכים הגבוהים תפסו. במקרים מורכבים יותר, דגמי זיהוי חריגות מספקים גם ציון חריגות עבור כל נקודה (לדוגמה, כמה רחוקה היא מהטווח הרגיל). "IsolationForest" של Scikit-learn, למשל, יש לו שיטת "decision_function" שמחזירה ציון (כאשר ציונים נמוכים משמעם חריגות יותר).

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

עם זיהוי החריגויות פועל, מה ניתן לעשות כאשר מוצאים חריגות? זה מוביל אותנו לחשוב על תגובות אוטומטיות.

אפשרויות תגובה אוטומטית

גילוי של אנומליה הוא רק חצי מהקרב – הצעד הבא הוא להגיב לה. במערכות SIEM של ארגונים, תגובה אוטומטית (שלעיתים קרובות מקושרת ל-SOAR – תיאום אבטחה, אוטומציה ותגובה) יכולה להפחית באופן דרמטי את זמן התגובה לאירועים.

מה יכול SIEM מונחה בינה מלאכותית לעשות כאשר הוא מסמן משהו בלתי רגיל? הנה כמה אפשרויות:

  • התראה: הפעולה הפשוטה ביותר היא לשלוח התראה לאנשי אבטחה. זה יכול להיות דוא"ל, הודעת Slack, או יצירת כרטיס במערכת ניהול אירועים. ההתראה תכיל פרטים על האנומליה (למשל, "המשתמש אליס היה לו 50 ניסי כניסה לא מוצלחים בתוך דקה, מה שלא נורמלי"). GenAI יכול לעזור כאן על ידי יצירת סיכום ברור בשפה טבעית של האירוע עבור האנליסט.

  • הפחתה אוטומטית: מערכות מתקדמות יותר עשויות לנקוט בפעולה ישירה. לדוגמה, אם כתובת IP מציגה התנהגות מזיקה ביומנים, המערכת יכולה לחסום אוטומטית את ה-IP הזה בחומת האש. בדוגמה שלנו על עליית הכניסות, המערכת עשויה לנעול זמנית את חשבון המשתמש או לבקש אימות נוסף, בהנחה שמדובר בהתקפת בוטים. מערכות SIEM מבוססות AI כיום יכולות אכן להפעיל פעולות תגובה מוגדרות מראש או אפילו לארגן זרימות עבודה מורכבות כאשר מזוהים איומים מסוימים (ראו AI SIEM: איך SIEM עם AI/ML משנה את ה-SOC | Exabeam למידע נוסף).

  • תמיכה בחקירה: AI יצירתית יכולה גם לשמש לאיסוף קשר באופן אוטומטי. לדוגמה, לאחר זיהוי האנומליה, המערכת עשויה לאסוף יומני רישום קשורים (אירועים סמוכים, פעולות נוספות של אותו משתמש או מאותה כתובת IP) ולספק דוח מצטבר. זה חוסך מהניתוח משא ומתן בשאילתת מקורות נתונים מרובים.

חשוב ליישם תגובות אוטומטיות בזהירות — אתה לא רוצה שהמערכת תגיב באופן יתר לחיובים שקריים. אסטרטגיה נפוצה היא תגובה בשכבות: אנומליות ברמת נאמנות נמוכה עשויות רק לרשום אזהרה או לשלוח התראת עדיפות נמוכה, בעוד שאנומליות ברמת נאמנות גבוהה (או קומבינציות של אנומליות) יכולות להפעיל צעדי הגנה פעילים.

בפועל, SIEM המופעל על ידי AI ישתלב בתשתיות שלך (באמצעות APIs, סקריפטים וכו') כדי לבצע פעולות אלה. לדוגמה, עבור ה- PoC שלנו ב-Python, תוכל לחקות תגובה אוטומטית על ידי הדפסת הודעה או קריאה לפונקציה בדמה כאשר אנומליה מזוהה. לדוגמה:

if len(anomaly_indices) > 0:
    print(f"Alert! Detected {len(anomaly_indices)} anomalous events. Initiating response procedures...")
    # כאן, תוכל להוסיף קוד כדי להשבית משתמש או להודיע למנהל, וכו'.

במהלך ההדגמה שלנו פשוטה, קל לדמיין איך להרחיב את זה. SIEM עשוי, לדוגמה, להעביר אנומליות למודל גנרטיבי גדול יותר שמעריך את המצב ומחליט על הפעולה הטובה ביותר (כמו עזר Ops צ'אטבוט שיודע את ההנחיות שלך). האפשרויות לאוטומציה מתרחבות ככל שה AI מתקדם.

מסקנה

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

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

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

מערכות SIEM מודרניות המוגברות עם AI/ML מתקדמות בכיוון זה: הן לא רק מזהות בעיות, אלא גם מסייעות בתהליך המיון והתגובה להן. AI גנרטיבי משפר זאת עוד יותר על ידי למידה מניתוחי נתונים וסיפוק סיכומים והמלצות חכמים, ובכך הוא הופך לעוזר חסר לאות במרכז מבצעי האבטחה.

לשלבים הבאים ושיפורים:

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

  • ניסוי עם אלגוריתמים אחרים כמו One-Class SVM או Local Outlier Factor לזיהוי אנומליות כדי לראות איך הם משווים.

  • שלב מודל שפה פשוט כדי לנתח שורות יומן או להסביר אנומליות. לדוגמה, LLM יכול לקרוא רשומת יומן אנומלית ולהציע מה עשוי להיות לא בסדר ("שגיאה זו בדרך כלל משמעותה שהמסד נתונים אינו נגיש").

  • הרחיב את התכונות: במערכת SIEM אמיתית, ניתן להשתמש במספר אותות בו זמנית (מניות התחברות כושלות, גיאוקלוקציה לא סטנדרטית של כתובת IP, שמות תהליכים נדידים ביומנים ועוד). יותר תכונות ונתונים יכולים לשפר את ההקשר לזיהוי.