WEBVTT

00:00:00.000 --> 00:00:04.640
הבעיה בקופילות שלכם היא לא באמת בעיה של תכונות, זוהי בעיית אמון במודל שעומד מאחוריו.

00:00:04.760 --> 00:00:08.920
רוב הצוותים עדיין חושבים שהבטיחות תמונה בהנחיות, בהרשאות ובכמה פילטרים בקצה.

00:00:09.020 --> 00:00:14.380
אבל העניין הוא שתוקפים לא צריכים לנצח את ההנחיה שלכם, הם רק צריכים להראיל את ההקשר סביבה, ושם דברים משתבשים.

00:00:14.500 --> 00:00:15.980
פילטרים בסיסיים יכולים לתפוס.

00:00:16.220 --> 00:00:20.260
ברור, אבל הם מפספסים את המטען החבוי בתוך אימייל, קובץ SharePoint או שדה תופס.

00:00:20.260 --> 00:00:25.120
התוכן שנשלף יושב שם בשקט עד שקופילות מושך אותו ומתייחס אליו כאל הוראה ישירה.

00:00:25.220 --> 00:00:33.640
כבר ראינו את סימני ההזהרה עם דליפת אקו במיקרוסופט 365 קופיילוט ודליפת Share בקופילות סטודיו, והמציאות היא שעדכוני אבטחה לא סיימו את התופעה.

00:00:33.760 --> 00:00:40.960
מכיוון שקופילות יכול לחפש, לסכם ולפעול בכל סביבת המיקרוסופט 365 שלכם, נתיב הוראה אחד רע יכול להתפשט מהר.

00:00:40.960 --> 00:00:48.960
אז זה לא עניין של להוסיף עוד לוח מכוונים למערכת, אלא להציב Azure Logic Apps בנתיב כדי לבדוק, לדרג ולחסום מתענים זדוניים לפני שקופילות בכלל פועל.

00:00:49.080 --> 00:00:51.520
הסכנה האמיתית היא בארכיטקטורה, לא בהנחיה.

00:00:51.640 --> 00:00:55.860
המודל הישן מניח שאפשר לשמור על המערכת בטוחה על ידי כתיבת הנחיות טובות יותר סביב המודל.

00:00:55.980 --> 00:01:00.360
אתם נותנים לו הנחיית מערכת חזקה, מוסיפים מפרידים ואומרים למשתמשים מה לא לעשות.

00:01:00.360 --> 00:01:10.580
זה נשמע הגיוני על הנייר, אבל במציאות, המודל לא אוכף גבולות אמון כפי שמערכת הבטחה הייתה עושה, כי הוא קורא שפה בערוץ משותף אחד שבו הוראות ונתונים מתחרים על תשומת הלב.

00:01:10.700 --> 00:01:12.060
ההנחה הזו היא הפגם.

00:01:12.260 --> 00:01:21.660
אם מודל לא יכול להבחין בצורה אמינה בין משתמש שמבקש עזרה לבין מסמך שאומר לו בשקט להתעלם מהוראות קודמות, אז נקודת הבקרה לא יכולה לשבת רק בשכבת ההנחיה.

00:01:21.660 --> 00:01:27.160
אתם מנסים להבטח התנהגות בקצה בזמן שהסיכון האמיתי יושב בזרימת ההקשר שנכנסת למודל.

00:01:27.300 --> 00:01:31.560
זה נפל להסימון של הרבה צוותים ברגע שהופיעו אומסי עבודה של קופה אילות מבוססי שליפת נתונים.

00:01:31.740 --> 00:01:37.480
ברגע שקופילות מתחיל למשוך אימיילים, קבצים והיסטוריית שט ממיקרוסופט גראפ, שטח התקיפה משתנה לחלוטין.

00:01:37.600 --> 00:01:42.180
אתם כבר לא מאבטחים רק שיחה, אתם מאבטחים זרם חי של קלטים ברמות אמון מעורבות.

00:01:42.180 --> 00:01:45.120
ורמה אחת עמוק יותר, קופה אילות, מגדיל את טווח ההגעה.

00:01:45.220 --> 00:01:48.600
הוא לא רק עונה על שאלות, הוא שולף, מסכם ועוקב אחרי הפניות.

00:01:48.820 --> 00:01:51.900
בהגדרות מסוימות, הוא יכול אפילו להפעיל כלים או תהליכי עבודה.

00:01:52.040 --> 00:01:56.980
אז כשתוכן לא מהימן נכנס לשרשרת הזו, המודל יכול לשאת את ההשפעה הזו הלאה לתוך פעולות רגישות.

00:01:56.980 --> 00:01:59.920
זו הסיבה שהזרקת הנחיות עקיפה כל כך חשובה כרגע.

00:01:59.920 --> 00:02:04.900
במערכות ייצור, ההתקפה הנפוצה היא לא תמיד משתמש שמקליד תתעלם מהחוקים שלך בתיבת הצ'ה.

00:02:05.060 --> 00:02:10.560
הגירסה המסוכנת יותר נמצאת בתוך תוכן שנשלף, לעתים קרובות שבועות לפני שמישהו בכלל מבחין שהיא שם.

00:02:10.560 --> 00:02:17.720
מסמך מורעל, אימייל מתוחכם או הזנת תופס עשויים להיראות תמימים לבני אדם, אך הם מכילים שפת הוראות המופנית ישירות למודל.

00:02:17.720 --> 00:02:24.100
מאוחר יותר, קופא אילוט שולף את התוכן הזה כהקשר רלוונטי, מערבב אותו עם חומר מהימן, והמודל עוקב אחר הדבר הלא נכון.

00:02:24.280 --> 00:02:27.060
שרשרת התקיפה פשוטה, וזה מה שהופך אותה לי מסוכנת.

00:02:27.060 --> 00:02:36.320
ראשית, התוקף שוטל תוכן במקום שקופא אילוט יוכל להגיע אליו מאוחר יותר, לאחר מכן השליפה מביאה את התוכן הזה לסשן, ואז המודל מתייחס למטען כאל הוראה במקום כאל נתונים.

00:02:36.320 --> 00:02:43.820
אחרי זה, הוא יכול להתחיל להכין מידע רגיש, לעצב תגובות, או לדחוף נתונים לעבר נתיב זליגה באמצעות קישורים או שימוש בחלים.

00:02:43.820 --> 00:02:49.200
לכן, עבור מנהיגים, זו לא רק היגיינה של AI, אלא בקרת זמן ריצה הקשורה ישירות לממשל גישה.

00:02:49.300 --> 00:02:58.520
אם לקופילות יש טווח הגעה רחב ברחבי הדייר, והמודל צורך הקשר של אמון מעורב ללא הפרדה קשיחה, מודל ההבטחה שלכם חייב לקחת בחשבון מה נכנס לזרימה לפני הביצוע.

00:02:58.520 --> 00:03:05.300
ברגע שמבינים זאת, גם הפתרון משתנה. מפסיקים להיות אובססיביים לגבי פרומפטים מושלמים ומתחילים להציב אכיפה במקום שבו ההקשרנה.

00:03:05.300 --> 00:03:10.320
מדוע הגנות בסיסיות נכשלות בסביבת הייצור? רוב הצוותים עושים טעות בסיסית כבר בהתחלה.

00:03:10.460 --> 00:03:15.480
הם מניחים שביקרות ההבטחה ששימשו אותם במשך שנים בפיתוח אפליקציות יעבדו באותה מידה עבור קופיילוט.

00:03:15.480 --> 00:03:21.820
הם כותבים פרומפט מערכת חזק יותר, עוטפים כלת משתמש בתווים מיוחדים ומפרסמים הנחיות לעובדים, ואז הם מרגישים בטוחים.

00:03:21.820 --> 00:03:26.820
הצעדים האלה אינם רעים, ולא הייתי אומר לכם להפסיק לעשות אותם, אבל הם לא יוצרים גבול הבטחה אמיתי.

00:03:26.980 --> 00:03:31.500
הם רק מנסים לשכנע את המודל להתנהג, ובאבטחה שכנוע אינו זהה לאכיפה.

00:03:31.680 --> 00:03:32.740
שם נמצא הפער.

00:03:32.740 --> 00:03:40.980
פרומפט מערכת אומר למודל מה הייתם מעדיפים שיעשה, אבל הוא לא יכול למנוע מקובץ דוני להתחרות על תשומת הלב של המודל ברגע שהקובץ נמשך לסביבת העבודה.

00:03:40.980 --> 00:03:46.140
שימוש במפרידים עשוי לעזור במבנה הטקסט, אך הוא לא נותן למודל דרך לבדוק סיווגים ביטחוניים.

00:03:46.300 --> 00:03:53.600
הנחיות לעובדים מצוינות להצירת טעויות בתום לב, אך הן לא עושות דבר נגד מסמך מורעל או מטען חבלה חבוי בנתונים שנשלפו.

00:03:53.600 --> 00:03:57.400
הבקרה קיימת כהצעה, לא ככלל נוקשה שרץ בזמן הביצוע.

00:03:57.540 --> 00:04:02.200
ל-regex יש בעיה דומה, הוא מהיר וזול, לכן כדאי להשתמש בו כמעבר ראשוני מהיר.

00:04:02.200 --> 00:04:07.160
אם משתמש מקליד, התעלם מכל ההוראות הקודמות, המערכת שלכם צריכה לתפוס זאת בתוך כמה מילי שניות.

00:04:07.280 --> 00:04:12.680
ניתן גם להשתמש בו כדי לסמן ביטויי עקיפת פרטיות ברורים או תווים בסגנון סיקוואל בארגומנטים של הכלים שלכם.

00:04:12.680 --> 00:04:20.780
החלק הזה עובד בסדר, אבל regex מזהה רק תפוסים שהגדרת מראש, לכן הוא נכשל כשהניסוח משתנה מעט או כשהמתקפה מבוססת על משמעות ולא על מילים ספציפיות.

00:04:20.980 --> 00:04:22.880
זו הסיבה שאתם צריכים שכבות סיווג.

00:04:22.880 --> 00:04:27.880
ל-Azure AI Content Safety יש מגיני הנחיות שיכולים לזהות התקפות הזרקה ישירות והקיפות כאחד.

00:04:28.000 --> 00:04:34.900
בתוך Logic App אפשר לקרוא לה API כדי לבדוק את ההנחיה לפני שהמודל רואה אותה ואז לשנות את נתיב זרימת העבודה אם מזוהה מתקפה.

00:04:34.900 --> 00:04:41.800
זהו מנגנון בקרה חזק הרבה יותר מהתאמת מחרוזות פשוטה כי הוא מחפש את הכוונה שמאחורי המילים בהנחיה ובמסמכים יחד.

00:04:41.980 --> 00:04:46.840
גם אז, זיהוי לבדו אינו מספיק, כי לראות סיכון זה לא משנה אם אין לך דרך לעצור אותו.

00:04:46.840 --> 00:04:51.360
צוותי הבטחה ממיתים לעיתים קרובות בחשיבותו של החלק הספציפי הזה בתהליך.

00:04:51.480 --> 00:04:56.220
הזהרה בקובץ יומן רישום אינה בלימה וגם אריח יפה בלוח הבקרה אינו בלימה.

00:04:56.220 --> 00:05:03.400
אפילו התראה בעדיפות גבוהה ב-CM שלך נכשלת אם המטען כבר עבר דרך קופה אילות והפעיל פעולה במערכת במורד הזרם.

00:05:03.580 --> 00:05:08.640
בדיקת מה שקרה בדיעבד מועילה על החקירה, אבל היא לא מספיק טובה כשמתקפה מתרחשת בשניות.

00:05:08.640 --> 00:05:13.200
אתם מתמודדים עם מודל שיכול לפעול בתוך מערכות שהארגון שלכם כבר סומך עליהן.

00:05:13.320 --> 00:05:17.200
ישנה גם בעיה אם תוצאות שליליות כוזבות שרוב שיווק המוצרים מתעלם ממנה.

00:05:17.320 --> 00:05:20.980
מתקפות עקיפות גורמות לחלק גדול מהזיהויים המוחמצים בעולם האמיתי,

00:05:20.980 --> 00:05:25.660
כי ההוראה המסוכנת נראית תקינה לחלוטין עד שהמודל משלב אותה עם שאר השיחה.

00:05:25.760 --> 00:05:30.760
עד שאדם סוקר את הפלט ומבין שמשהו לא קשורה, הכלט הרע כבר סיים את עבודתו.

00:05:30.880 --> 00:05:32.720
הטעות המעשית כאן היא פשוטה מאוד.

00:05:32.720 --> 00:05:38.040
צוותים מבלים את כל זמנם בצפייה במה שקופילות אומר, אבל הם לא שולטים במה שנכנס אליו באותה רמת משמעת.

00:05:38.100 --> 00:05:42.900
הם בוחנים את התשובה לאחר שהיא נוצרה, תוך מתן אפשרות לחומר לא מהימן להיכנס לפני שהעבודה מתחילה.

00:05:43.000 --> 00:05:44.520
הסדר הזה הפוך לחלוטין.

00:05:44.520 --> 00:05:48.720
ברגע שמזהים את הפגם הזה, כל המטרה של אסטרטגיית ההבטחה שלכם משתנה.

00:05:48.840 --> 00:05:54.080
אתם מפסיקים לשאול איך לכתוב הנחיה בטוחה יותר ומתחילים לשאול איפה אפשר ליראת את הנתונים לפני שהמודל מבצע.

00:05:54.220 --> 00:05:56.100
מודל חומת האש של לוגיק אפ.

00:05:56.240 --> 00:05:59.840
אם ירות הוא המטרה, עלינו לבחון איך בקרה כזו נראית בפועל.

00:05:59.980 --> 00:06:04.440
עליכם להשתמש ב-Azure Logic Apps כשכבת מדיניות שיושבת לפני שלב הביצוע.

00:06:04.440 --> 00:06:08.060
זה לא אמור להיות קלי פסיבי ששולח דוח אחרי שהנזק כבר נעשה.

00:06:08.060 --> 00:06:14.440
עליכם להציב אותו ישירות בנתיב שבו כלת המשתמש ושליפת הנתונים מתרחשים, כך שניתן יהיה לבדוק אותם לפני שהמודל ניגש לעבודה.

00:06:14.580 --> 00:06:17.920
השינוי הזה עוצמתי כי האפליקציות בנויות עבור תזמור.

00:06:18.060 --> 00:06:23.560
הוא יכול להפעיל אירועים ספציפיים, לקרוא לאפיס אחרים ולקבל החלטות על סמך תנאים מורכבים.

00:06:23.560 --> 00:06:31.440
ניתן לנתב נתונים, לשלוח התראות למיקרוסופט סנטינר ולהעשיר את התהליך במידע חיצוני בלי לבנות שער הבטחה מותאם אישית מאפס.

00:06:31.440 --> 00:06:37.000
אתם לא מנסים להחליף את כל פעילות כאן, אתם רק מוסיפים שכבת בקרה לזרימת העבודה סביבו.

00:06:37.120 --> 00:06:39.380
ההיגיון מאחורי המודל הזה פשוט בכוונה.

00:06:39.560 --> 00:06:46.540
תחילה מפעילים את התהליך ואז מנרמלים את הנתונים, בודקים אותם, מדרגים את הסיכון, מקבלים החלטה ולבסוף מנתבים או מתעדים את התוצאה.

00:06:46.540 --> 00:06:47.500
זה כל הדפוס.

00:06:47.640 --> 00:06:53.100
כאשר בקשה או תוכן נכנסים לזרימת העבודה, הלוג'יק אפ מושך את הפעילות ומבצע לו סטנדרטיזציה.

00:06:53.100 --> 00:06:57.120
כלת גולמי הוא לרוב מבולגן כי מחברים שונים מטפלים בנתונים בדרכים שונות.

00:06:57.340 --> 00:07:03.120
דואר אלקטרוני נראה אחרת מהזנת תופס, ותוכן קובץ או ארגומנטים של כלים מגיעים עם מטה דאטה ושדות שונים.

00:07:03.300 --> 00:07:08.400
אם תנסו להריץ בדיקה לפני שתנרמלו את הנתונים, מערכת הזיהוי שלכם תהיה רועשת מאוד.

00:07:08.400 --> 00:07:12.180
ברגע שהפעילות מיושר לפורמט עקבי, מתחיל סבב הבדיקה הראשון.

00:07:12.280 --> 00:07:14.980
כאן לריג'קס המותאם אישית שלכם עדיין יש תפקיד.

00:07:14.980 --> 00:07:19.620
זה לא השופט הסופי או פתרון קסם, אבל זה עובד כי מסנן מהיר מאוד בקצה המערכת שלכם.

00:07:19.740 --> 00:07:26.920
ניתן לסרוק במהירות אחר שפת עקיפה מוכרת, רמזי כידוד או דפוסים חשודים בפרמטרים של כלים כדי לקבל הערכה מידית של המצב.

00:07:27.060 --> 00:07:30.880
לאחר מכן עוברים לסבב הבדיקה השני שצולל עמוק יותר לתוך התוכן.

00:07:30.880 --> 00:07:34.460
כאן אתם מפעילים את מגיני הפרומפט של Azure Eye Content Safety.

00:07:34.460 --> 00:07:41.120
ה-Logic App שולח את הפרומפט של המשתמש ומסמכים שנשלפו ל-API, ואז מתפצל בהתאם לשאלה אם זוהתה התקפה.

00:07:41.280 --> 00:07:45.140
זה חשוב כי הזרקות פרומפט לא תמיד נראות כמו קוד מחשב ברור.

00:07:45.400 --> 00:07:50.060
לפעמים הסכנה מתבהרת רק כאשר הפרומפט והמסמך מוערכים כיחידה אחת.

00:07:50.060 --> 00:07:55.480
יש שכבה נוספת שהופכת את זה ממסנן פשוט לבקרת הבטחה אמיתית, וזו מודיעין איומים.

00:07:55.480 --> 00:08:01.720
אם תוכן מתייחס לדומיין סדוני מוכר או ל-URL חשוד שהצוות שלכם ראה בעבר, זה אמור לשנות את החלטתכם.

00:08:01.880 --> 00:08:08.100
Logic Apps יכולים לבדוק את האירוע מול מודיעין האיומים של Defender או עדכונים מצד שלישי כדי להוסיף ציון מהימנות לסיכון.

00:08:08.100 --> 00:08:15.020
זה אומר שדפוס מוזר ממקור מהימן עשוי לעבור, בעוד שאותו דפוס בדיוק עם ציון מוניטין או יין יחסם מיד.

00:08:15.560 --> 00:08:19.820
זה הופך את עץ ההחלטות שלכם למה שהוא מעבר לבחירה פשוטה של כן או לא.

00:08:19.820 --> 00:08:25.180
ניתן לאשר את הבקשה עם ציון הסיכון נמוך או לחלופין לבצע ניקוי של מקטעים לא בטוחים.

00:08:25.340 --> 00:08:28.840
ייתכן שתבחר להכניס את הנתונים להסגר אם המקור דורש בדיקה ידנית.

00:08:29.000 --> 00:08:33.320
אם הפעולה כוללת נתונים רגישים, ניתן אפילו לדרוש אישור אנושי לפני שהיא ממשיכה.

00:08:33.320 --> 00:08:37.260
כמובן, אם האות חזק מספיק, פשוט חוסמים את הבקשה ומפעילים התראה.

00:08:37.360 --> 00:08:40.740
מגוון האפשרויות הזה הוא מה שגורם למודל הזה לעבוד עבור העסק.

00:08:40.740 --> 00:08:45.260
צוותי הבטחה לעיתים קרובות פוגעים באימוץ כשהם דוחים כל מקרה שנראה מעט לא ודאי.

00:08:45.480 --> 00:08:48.360
וכשהבקרות קשיחות מדי, אנשים מוצאים דרכים לעקוף אותן.

00:08:48.480 --> 00:08:53.040
תהליך עבודה מבוסס ציונים מעניק לך את המרחב להגיב על סמך סיכון אמיתי במקום מתוך פאניקה.

00:08:53.040 --> 00:08:56.760
זו בדיוק הסיבה של לוג'יק אפס מתאים יותר מאשר אוסף של כלים נפרדים.

00:08:56.920 --> 00:09:01.720
הוא כבר מתחבר לשאר המערכת האקולוגית של מייקרוסופט ועובד בצורה מושלמת עם הפלייבוקס של סנטינר.

00:09:01.720 --> 00:09:06.300
ניתן לבצע בדיקת בטיחות תוכן, לחפש נתוני איומים ולדחוף אירועי ביקורת במקום אחד.

00:09:06.460 --> 00:09:11.840
אין צורך במחזור פיתוח ארוך בכל פעם שתוקף משנה את הניסוח שלו או שמופיעה דרך חדשה להיכנס למערכת.

00:09:11.840 --> 00:09:14.400
הכלל שגורם לכל זה לעבוד הוא פשוט מאוד.

00:09:14.520 --> 00:09:18.560
עליך להתייחס לכל פיסת הקשר כאל לא מהימנה עד שהיא מקבלת ציון.

00:09:18.760 --> 00:09:24.100
זה לא אומר רק את הנחיית המשתמש, אלא גם את גוף האימייל, הקובץ שהוא עלה ושדה הטופס בשארפוינט.

00:09:24.100 --> 00:09:28.900
זה כולל את מתען הקונקטר, מקטעי המסמכים שנשלפו ואפילו את ארגומנטי הכלים.

00:09:29.100 --> 00:09:30.100
יש לבדוק את הכל.

00:09:30.280 --> 00:09:35.280
ברגע שאתה מניח שאחד מהמקורות האלה בטוח כברירת מחדל, יצרת פרצה חדשה עבור תוקף.

00:09:35.280 --> 00:09:42.140
ברגע שתהליך העבודה שלך רוכף כלל זה בעקביות, אינך צריך עוד להסתמך על כל פעילות שיפריד לבדו נתונים טובים מנתונים רעים.

00:09:42.280 --> 00:09:44.520
התהליך הופך למערכת כניסה מבוקרת.

00:09:44.720 --> 00:09:46.780
על הנייר, זו נשמעת תיאוריה נהדרת.

00:09:46.780 --> 00:09:52.140
אבל מה שאנשים באמת דואגים לגביו הוא מה קורה כשמטען מסוכן פוגע בתהליך העבודה בעולם האמיתי.

00:09:52.340 --> 00:09:58.060
מה שתהליך העבודה עושה בזמן אמת כשהמערכת פועלת הוא לא רק שריקת טקסט למילים רעות,

00:09:58.060 --> 00:10:01.440
הוא בונה תמונה מלאה של הבקשה לפני קבלת החלטה.

00:10:01.580 --> 00:10:07.980
אירוע פוגע בנקודת הכניסה שלך, אולי הגשת תופס, זרימת אימייל או העלאת מסמך הקשורים לתהליך קופה אילות,

00:10:08.180 --> 00:10:10.640
ולוגיק אפס עוטפת האירוע מיד עם מטה נתונים.

00:10:10.640 --> 00:10:16.420
הוא עוקב אחרי מי שלח את הבקשה, איזו אפליקציה נגעה בה, מהו מקור הקובץ ומה המערכת עומדת לעשות הלאה.

00:10:16.520 --> 00:10:21.840
ההקשר הנוסף הזה חיוני, כיוון שאוטומשפט יכול לקבל משמעות שונה אל החלוטין בהתאם למקור ממנו הוא מגיע.

00:10:21.840 --> 00:10:25.640
ברגע שהנתונים נלכדים, המטען מפוצל לעזורי אמון ספציפיים.

00:10:25.760 --> 00:10:27.420
עליכם להקפיד על הפרדה ברורה.

00:10:27.600 --> 00:10:30.980
הנחיית המשתמש נכנסת לקטגוריה אחת, מסמכים שנשלפו לאחרת,

00:10:30.980 --> 00:10:33.960
והיסטוריית שיחה או פרמטרים של כלים מקבלים מרחב משלהם.

00:10:34.100 --> 00:10:36.040
אם מערבבים את כל אלו מוקדם מדי,

00:10:36.320 --> 00:10:39.400
מאבדים את היכולת לזהות היכן התחיל ההנחיה המסוכנת,

00:10:39.600 --> 00:10:41.820
ותהליך הבדיקה הופך לניחוש אחד גדול.

00:10:41.820 --> 00:10:45.200
צוותים רבים מדלגים על השלב הזה כי נראה ששילוב הכל מהיר יותר,

00:10:45.460 --> 00:10:48.400
אך במציאות זה רק מסתיר את הנתיב שצריך לעקוב אחריו.

00:10:48.500 --> 00:10:50.960
בשלב הבא, זרימת העבודה עוברת לנרימול.

00:10:51.160 --> 00:10:55.100
זה החלק המשעמם בעבודה, אבל הוא גם זה שהופך את הזיהוי שלכם ליישים באמת.

00:11:00.980 --> 00:11:03.160
מכוננים כדי שהבדיקה תרוץ מול מבנה יציב.

00:11:03.300 --> 00:11:06.680
אם מחבר אחד שולח טקסט עשיר ואחר שולח מקטעי ג'ייסן,

00:11:06.900 --> 00:11:10.300
תרצו שכולם יצומצמו לשדות שהבדיקות שלכם יכולות לקרוא באופן עקבי.

00:11:10.300 --> 00:11:15.000
ללא זאת, הלוגיקה שלכם מבלה יותר זמן במאבק בסכיפת פורמטים מאשר במציאת התקפות אמיתיות.

00:11:15.160 --> 00:11:18.560
אחרי שהנתונים נקיים, מעבר דפוסי הזיהוי המהיר רץ ראשון.

00:11:18.700 --> 00:11:20.660
זה צריך להיות זול, ישיר ומהיר.

00:11:20.820 --> 00:11:23.800
אתם מחפשים ביטויים שמנסים לעקוף את התנהגות המערכת,

00:11:23.800 --> 00:11:27.820
כמו וריאציות של התעלם מכל ההנחיות הקודמות או עקיפת מערכת.

00:11:27.820 --> 00:11:33.940
אתם מחפשים גם שפת חילוץ שבה מישהו מבקש לחשוף חומר סודי, להוציא סודות או לעקוף הגדרות פרטיות.

00:11:34.160 --> 00:11:39.100
בלוגיק אפס, צוותים בדרך כלל מטפלים בזה באמצעות ביטויים או שלבי הרכבה שמגדירים דגלים,

00:11:39.360 --> 00:11:41.380
במקום לחשום את הבקשה מיד בכל התאמה.

00:11:41.480 --> 00:11:45.760
הסימון הזה חשוב כי ביטוי בודד לא תמיד מעיד על כך שמישהו פועל באופן סדוני.

00:11:45.760 --> 00:11:50.940
אדם שעובד במסגרת תהליך הבטחה תקין עשוי פשוט לשאול על סקירת טיפול בתוכן רגיש.

00:11:51.120 --> 00:11:57.120
כדי לפתור זאת, זרימת העבודה שולחת את המטען העשיר יותר למגן ההנחיות של Azure Eye Content Safety לבדיקה מעמיקה.

00:11:57.240 --> 00:12:00.760
קריאת ה-API כוללת גם את הנחיית המשתמש וגם את המסמכים שנשלפו,

00:12:01.400 --> 00:12:04.280
כי הקשר ביניהם הוא לרוב המקום שבו מסתתרת הבעיה האמיתית.

00:12:04.280 --> 00:12:10.400
השירות מחזיר עוד פשוט, ואם מזוהה התקפה, זרימת העבודה פשוט משנה את הנתיב לפני שקריאת המודל מתרחשת.

00:12:10.580 --> 00:12:12.620
לאחר מכן עליכם להוסיף הקשר חיצוני.

00:12:12.800 --> 00:12:16.260
בדיקות מודיעין איומים נותנות לזרימת העבודה עדשה נוספת להסתכל דרכה.

00:12:16.360 --> 00:12:21.220
ניתן לשאול את Microsoft Defender Threat Intelligence או כל מקור TXII מהימן כדי לבדוק דומיינים,

00:12:21.380 --> 00:12:23.980
כתובות URL או אינדיקטורים למקורות הקשורים לשימוש לרעה.

00:12:23.980 --> 00:12:30.580
כדאי לשלב ציוני ביטחון היכן שהם זמינים, כי המוניטין של מקור אמור להשפיע על הציון הסופי, לא להחליף אותו לחלוטין.

00:12:30.760 --> 00:12:36.460
מטען חלש ממקור מסוכן תמיד צריך להיות מדורג גבוה יותר מאותו מטען שמגיע מתהליך פנימי מוכר.

00:12:36.600 --> 00:12:38.760
לבסוף, המערכת בונה ציון משוקלל.

00:12:38.980 --> 00:12:44.560
היא בוחנת את עוצמת ההתאמה לדפוס, תוצאות הפרומפט שירדס, מוניטין המקור ורמת הרגישות של הפעולה המבוקשת.

00:12:44.560 --> 00:12:50.060
בקשה בסיכון נמוך לסיכום מאמר ציבורי אינה בעלת משקל זהה לבקשה שעלולה לחשוף קבצים מוגנים.

00:12:50.240 --> 00:12:52.660
הציון המשולב הזה הוא מה שמניע את הפיצול.

00:12:52.820 --> 00:12:54.600
אירועים תקינים ממשיכים כמתוכנן.

00:12:54.800 --> 00:12:58.200
מקרים בסיכון בינוני עוברים ניקוי או מנותבים לחלופה בטוחה.

00:12:58.280 --> 00:13:01.460
ומקרים בסיכון גבוה נחסמים לפני שקופילות בכלל פועל.

00:13:01.600 --> 00:13:04.920
הכל נכתב ליומן ביקורת, תוך שמירה על נתיב קבלת ההחלטות.

00:13:04.920 --> 00:13:09.420
האירועים החסומים הללו הם שמלמדים עוד חייכה נבנה הלחץ ואילו מקורות ממשיכים לעורר בעיות.

00:13:09.600 --> 00:13:12.700
כשאתה רואה אילו דפוסים חודרים לתהליכי העבודה העסקיים שלך,

00:13:12.940 --> 00:13:15.900
יש לך סוף סוף את הנתונים הדרושים לכיוונון המערכת לסבב הבא.

00:13:16.020 --> 00:13:18.740
כיצד לכוונן להפחתת רעשים ולשימוש עסקי אמיתי.

00:13:18.940 --> 00:13:21.380
ברגע שהמערכת פועלת, אופי העבודה משתנה.

00:13:21.540 --> 00:13:23.620
בניית הזרימה היא למעשה החלק הקל.

00:13:23.620 --> 00:13:26.840
כיוונון המערכת כך שאנשים יבטחו בה ולא ינסו לעקוף אותה,

00:13:26.840 --> 00:13:30.260
ומה שיקבע אם היא תהפוך לבקרת הבטחה אמיתית או לעוד ניסוי כושל.

00:13:30.380 --> 00:13:32.080
אם המערכת יוצרת יותר מדי חיכוך,

00:13:32.300 --> 00:13:33.880
משתמשים פשוט ימצאו דרך לעקוף אותה,

00:13:34.040 --> 00:13:35.800
מה שיהפוך את הפרויקט כולו לחסר תועלת.

00:13:35.880 --> 00:13:37.460
עליך להתחיל בהיקף מצומצם.

00:13:37.600 --> 00:13:40.560
אל תנסה לעקוב אחר כל נקודת ממשק של קופ העילות ביום הראשון.

00:13:40.700 --> 00:13:43.980
במקום זאת, בחר את המקומות שבהם הסיכון הוא הגבוה ביותר והנתיב ברור,

00:13:43.980 --> 00:13:46.620
כמו פעולות מבוססות כלים או מקורות מידע בעלי ערך רב.

00:13:46.620 --> 00:13:50.460
אתה יכול להתחיל עם תהליך אחד המגובה בשורפוינט או עם זרימת עבודה ספציפית,

00:13:50.540 --> 00:13:51.940
כדי לקבל אות שניתן באמת לקרוא.

00:13:52.060 --> 00:13:55.120
היקף קטן נותן לך את המרחב ללמוד מבלי לטבוע בנתונים.

00:13:55.320 --> 00:13:57.280
כאשר אתה מגדיר את הבדיקות הראשוניות,

00:13:57.480 --> 00:13:59.980
כוונן את הסינונים לזיהוי רחב ולא לוודאות מוחלטת.

00:14:00.140 --> 00:14:02.920
המעבר הראשון אמור לטפוס שפה חשודה בשלב מוקדם,

00:14:02.920 --> 00:14:05.180
לא להוכיח כוונה הזדונית מעבר לכל ספק סביר.

00:14:05.300 --> 00:14:07.120
אם תיעלץ את הדפוסים שלך להיות מושלמים,

00:14:07.120 --> 00:14:10.040
הם יהפכו לשבירים ויתחילו לפספס את הדברים שבאמת חשובים לך.

00:14:10.160 --> 00:14:12.360
עדיף לתת למערכת לסמן קצת יותר מדי בהתחלה,

00:14:12.560 --> 00:14:15.900
ולאחר מכן לאפשר לבדיקות מאוחרות יותר להוסיף הקשר כדי להפחית את הרעש.

00:14:16.060 --> 00:14:18.780
זו הסיבה שציון משוקלל חשוב יותר מהתאמות בודדות.

00:14:18.960 --> 00:14:21.740
התאמת ביטוי כשלעוצמה לא תמיד צריכה לחסום בקשה,

00:14:21.740 --> 00:14:26.220
אך כשמשלבים אותה עם סימון של פרומפט שירד ומקור מסוכן, התמונה משתנה.

00:14:26.340 --> 00:14:28.700
אותות חלשים צריכים להצטבר זה על גבי זה,

00:14:28.700 --> 00:14:31.020
ואותות חזקים צריכים להעיץ את החסימה.

00:14:31.160 --> 00:14:36.460
זהו ההבדל המהותי בין מסנן קשיח ומעצבן לבין מודל מדיניות שעובד באמת עבור העסק.

00:14:36.580 --> 00:14:38.620
עליך גם להגדיר תקרא לזיהויים שגועיים.

00:14:38.800 --> 00:14:40.500
נסו לשמור על זה מתחת למד מינוס שני אחוזים,

00:14:40.620 --> 00:14:42.860
כי ברגע שאנשים מרגישים שהבקרה חושמת את עבודתם השוטפת,

00:14:42.860 --> 00:14:44.020
הם יפסיקו לתת אמון במערכת.

00:14:44.160 --> 00:14:46.080
זה השלב שבו מתחילים לעקוף את הנהלים.

00:14:46.240 --> 00:14:48.300
משתמשים יעתיקו טקסט לחילים לא מנוהלים,

00:14:48.300 --> 00:14:49.760
צוותים יבנו תהליכי צל,

00:14:49.920 --> 00:14:51.640
ומנהלים יתחילו לבקש פטורים גורפים.

00:14:51.800 --> 00:14:53.000
הבקרה תקרוס מבפנים,

00:14:53.220 --> 00:14:54.420
לא בגלל שהזיהוי נכשל,

00:14:54.600 --> 00:14:56.920
אלא בגלל שהחיכוך הפך להיות גדול מכדי להכילו.

00:14:57.080 --> 00:14:57.840
כדי למנוע זאת,

00:14:57.960 --> 00:14:59.540
עליכם לעקוב אחר המדדים הנכונים.

00:14:59.760 --> 00:15:01.260
שכחו מילוחות מכוונים למראית עין,

00:15:01.260 --> 00:15:02.800
והתמקדו בזמן הממוצע לזיהוי.

00:15:02.880 --> 00:15:05.120
אתם רוצים לשמור עליו מתחת למד מינוס 15 דקות,

00:15:05.200 --> 00:15:06.420
לכל דבר שדורש סקירה ידנית.

00:15:06.420 --> 00:15:08.200
כדאי גם לעקוב אחר זמן ההכלה האוטומטי,

00:15:08.260 --> 00:15:09.620
ולשאוף לפחות ממינוס 5 דקות,

00:15:09.680 --> 00:15:11.500
במקרים שבהם חסימה יכולה להתבצע בביטחה.

00:15:11.600 --> 00:15:13.280
אם תהליך העבודה מופעל ללא הרף,

00:15:13.360 --> 00:15:15.040
אך לעולם לא משפיע בפועל על החלטה,

00:15:15.220 --> 00:15:16.120
הוא סתם רעש רקע.

00:15:16.220 --> 00:15:18.460
עלות היא גורם נוסף שדורש כבנון מתמיד.

00:15:18.620 --> 00:15:21.720
אפליקציות לוגיקה מבוססות צריכה הן מצוינות לאומסים משתנים,

00:15:21.800 --> 00:15:22.760
או לפרויקטי פיילוט,

00:15:22.960 --> 00:15:24.280
כי משלמים רק על מה שמריצים.

00:15:24.280 --> 00:15:27.940
עם זאת, התוכנית הסטנדרטית הגיונית יותר ברגע שנפח האירועים שלכם צפוי,

00:15:28.000 --> 00:15:30.320
וגבוה מספיק כך שעלויות לפי הרצה מתחילות להכאיב.

00:15:30.420 --> 00:15:31.620
אל תנחשו בנושא הזה.

00:15:31.780 --> 00:15:34.040
מידדו את כמויות ההפעלה וגידלי המטען בפועל,

00:15:34.100 --> 00:15:35.620
לפני שאתם מתחייבים למודל תמכור.

00:15:35.780 --> 00:15:37.780
היזהרו באופן שבו אתם מטפלים ביחסון.

00:15:37.940 --> 00:15:40.960
אתם צריכים מספיק היסטוריית הרצות לזכירת אירועים וראיות ממשל,

00:15:41.160 --> 00:15:43.420
אך אין צורך במסד נתונים עצום מלא בתוכן רגיש.

00:15:43.420 --> 00:15:46.000
שימרו את השדות הספציפיים שמסבירים מדוע התקבלה,

00:15:46.120 --> 00:15:48.800
החלטה והסירו את העומס שיוצר סיכון בשמירת נתונים.

00:15:48.980 --> 00:15:53.440
איחסון עודף נתונים עלול להפוך את כלי ההבטחה שלכם למטרד פרטיות אם לא תיזהרו.

00:15:53.540 --> 00:15:56.840
לסיום, חברו את כל הכבנון הזה בחזרה לממשל הרחב שלכם.

00:15:56.960 --> 00:15:59.700
מפו את תהליך העבודה לפונקציות ה-AIRMF של ניסט,

00:15:59.820 --> 00:16:02.700
כמו מדידה וניהול, וקישרו אותו לטביות רגישות המידע בפרוויו.

00:16:02.700 --> 00:16:05.180
לפעמים הפתרון הטוב ביותר אינו גליי חכם יותר,

00:16:05.180 --> 00:16:08.760
אלא פשוט הסרת גישה מיותרת מתהליך העבודה לפני שהיא הופכת לבעיה.

00:16:08.880 --> 00:16:13.460
כשמגיעים לשלב הזה, אתם כבר לא רק מתווכחים על בטיחות בינה מלאכותית באופן תיאורטי.

00:16:13.580 --> 00:16:18.120
אתם מנהלים מודל תפעולי אמיתי עם ספים ופשרות שעשה ככל באמת לנהל.

00:16:18.180 --> 00:16:20.480
מה זה משנה עבור מנהיגים וארכיטקטים?

00:16:20.680 --> 00:16:25.820
ברגע שמיישמים זאת, קופה אילוט מפסיק לפעול כמערכת של אמון עיוור, וזה השינוי האמיתי.

00:16:25.820 --> 00:16:31.940
לפני השינוי הזה, המודל פשוט קיבל בלגן של הקשרים מעורבים בזמן שהצוות שלכם קיבה שההנחיות הנכונות ינצחו.

00:16:32.020 --> 00:16:36.720
כעת, ההקשר הזה עובר סינון, ניקוד וניתוב לפני שהמודל אי פעם מקבל הזדמנות לגעת בו.

00:16:36.820 --> 00:16:41.020
התוצאה הביטחונית היא כבר לא רק מדיניות מופשטת, כי כעת היא מתפקדת כביצוע מבוקר.

00:16:41.140 --> 00:16:45.120
עבור ארכיטקטים, זה מעביר את המיקום שבו האבטחה באמת חיה בתוך התכנון שלכם.

00:16:45.120 --> 00:16:51.640
הוא כבר לא יושב רק בהגדרות הדייר, בהרשאות או בתבניות הנחיה, אלא יושב ישירות בנתיב הטרנזקציה.

00:16:51.800 --> 00:16:57.400
כל בקשה שחשובה מקבלת נקודת ירות, וכל פעולה רגישה עוקבת אחר נתיב החלטה ספציפי.

00:16:57.520 --> 00:17:03.120
משמעות הדבר היא שכל מחבר, סוכן או תוסף חדש הופך למשהו שאתה מעריך כנתיב קלט ולא רק כעוד תכונת פרודוקטיביות.

00:17:03.840 --> 00:17:08.000
זה חיוני מכיוון שסטיית ארכיטקטורה היא בדרך כלל הסיבה לכך שהתוכניות האלה נכשלות.

00:17:08.000 --> 00:17:15.120
צוות אחד משיק את קופ העילות למקרה שימוש בודד, צוות אחר מחבר תופס, ובסוף מישהו מוסיף זרימת עבודה או נותן לסוכן גישה לכלי.

00:17:15.260 --> 00:17:21.200
כל אחד מהשינויים האלה נראה קטן בפני עצמו, אבל יחד הם יוצרים נתיב תקיפה גדול בהרבה ממה שמישהו תכנן אי פעם.

00:17:21.360 --> 00:17:27.040
אם לא תבנה ירות לתוך המודל התפעולי שלך, הסביבה תתרחב הרבה יותר מהר מכפי שהבקרות שלך יוכלו לעמוד בקצב.

00:17:27.040 --> 00:17:32.000
עבור מובילי הבטחה, הגישה הזו סוף סוף פותרת בעיית בעלות מבולגנת שמטרידה את רוב הארגונים.

00:17:32.180 --> 00:17:35.940
כרגע, סיכוני קופ העילות נופלים בדרך כלל בין הכיסאות שבין הצוותים השונים.

00:17:36.160 --> 00:17:42.900
מרכז בקרת ההבטחה, SOC, רואה את ההתראות, מנהלי מייקרוסופט 365 רואים את הקונפיגורציה ובעל ה-AI דואג רק לאימוץ.

00:17:43.040 --> 00:17:48.260
כשאתה משתמש בנתיב בקרה של Logic Apps, כל הקבוצות האלה יכולות סוף סוף לעבוד לפי מודל תגובה מאוחד.

00:17:48.260 --> 00:17:56.620
הן משתמשות באותו תיעוד אירועים, באותה לוגיקת ניקוד ובאותה היסטוריית ענפים, מה שמפחית את הבלבול כשמופיעה הנחיה מסוכנת או מסמך רעיל בזרימת עבודה חיה.

00:17:56.780 --> 00:17:59.880
ההיבט העסקי של זה ישיר הרבה יותר ממה שאנשים מצפים.

00:18:00.020 --> 00:18:03.540
חסימת איום בשלב מוקדם תמיד זולה יותר מניסיון לנקות אותו מאוחר יותר.

00:18:03.540 --> 00:18:11.720
ניקוי כולל חקירות, סקירות משפטיות והפרעות למשתמשים, ובדרך כלל מסתיים בסבב לא נעים של ביקורות גישה שהיו אמורות לקרות לפני הפריסה.

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

00:18:21.960 --> 00:18:25.600
עבור מנהלים, זה מעלה נקודה לא נוחה לגבי המקום שבו נמצא הסיכון.

00:18:25.600 --> 00:18:31.780
סיכון AI כבר לא יושב בארגז חול או בפיילות מעבדה, אלא יושב כעת ב-Word, Outlook, SharePoint ו-Teams.

00:18:31.920 --> 00:18:38.460
אנשים כבר מניחים שהמקומות האלה בטוחים מספיק כדי להתקדם מהר, והאמון המושאל הזה הוא בדיוק מה שמעלה את הסיכונים עבור החברה.

00:18:38.580 --> 00:18:46.140
זרימת עבודה גרועה באפליקציה הניסיונית היא בעיה מוגבלת, אבל זרימת עבודה גרועה בתוך חבילת הפרודוקטיביות היומית שלך היא סיפור שונה לחלוטין.

00:18:46.280 --> 00:18:49.120
נתיב הפריסה שלך צריך להישאר קטן ומחושב מאוד.

00:18:49.120 --> 00:18:52.240
התחל עם מקרי שימוש אחד, טריגר אחד ומודל ניקוד אחד.

00:18:52.360 --> 00:18:56.180
בחר נתיב שבו הנתונים באמת חשובים וההתנהגות קלה עבורך לצפייה.

00:18:56.340 --> 00:19:02.840
עליך להוכיח שזרימת העבודה מזהה קלטים מסוכנים ומנתבת את התקינים תוך מתן מידע שימושי לבני אדם כשנדרשת בדיקה.

00:19:02.960 --> 00:19:05.560
ברגע שתוכיח שזה עובד, תוכל להתחיל להתרחב.

00:19:05.720 --> 00:19:09.280
בהמשך, תוכל להוסיף זיהוי חריגות או בקרות פלט היכן שהם מתאימים.

00:19:09.280 --> 00:19:15.580
אתה יכול אפילו להוסיף ניטור מעמיק לשימוש לרעה בכלים, אך עליך להשאיר את השער הראשון בדיוק איפה שהקשר לא מהימן נכנס למערכת.

00:19:15.720 --> 00:19:20.800
אם השער הראשון נשאר חלש, כל בקרה שתוסיף לאחר מכן רק תנסה לפצות על נקודת פתיחה גרועה.

00:19:20.920 --> 00:19:22.720
השינוי כאן הוא למעשה פשוט מאוד.

00:19:22.920 --> 00:19:25.760
תפסיק להתייחס להזרקת הנחיות כאל בעיית ניסוח בלבד,

00:19:25.960 --> 00:19:30.180
והתחיל להתייחס אליה כאל בקרת זמן ריצה על הקשר לא מהימן שעובר דרך קופאילוט.

00:19:30.180 --> 00:19:33.980
פנה זמן כדי למפות זרימת עבודה אחת של קופאילוט מקצה לקצה השבוע.

00:19:34.140 --> 00:19:40.520
מצא את נקודת הירות הבטוחה האחרונה לפני הביצוע ובני אפליקציית לוגיקה אחת שמדרגת, חוסמת ומתעדת את הנתיב הספציפי הזה.

00:19:40.680 --> 00:19:44.780
אם אתה רוצה עוד על הבטחת קופאילוט ללא תוספות מיותרות, הרשם והשאר ביקורת.

00:19:44.780 --> 00:19:51.000
אתה יכול גם להתחבר אליי מרקו פיטרס בלנקדין כדי לספר לי על תרחיש הטננט הספציפי שאתה מנסה להבטח.
