תיקנתם את LiteLLM, אך האם אתם מכירים את 'רדיוס הפיצוץ' של ה-AI שלכם?
אמ;לק
פרצת LiteLLM הדגימה שסיכוני AI חורגים מעבר לתלויות בקוד בלבד. השתמשו ב-Evo AI-SPM כדי למפות את 'רדיוס הפיצוץ' המלא של מערכות ה-AI שלכם, ובכך לאבטח מודלים, כלים ותהליכי עבודה מקושרים. הבנה זו קריטית למפתחים בעידן ה-Vibe Coding.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: You Patched LiteLLM, But Do You Know Your AI Blast Radius?

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
במשך תקופה קצרה, חבילת קוד פתוח בשימוש נרחב במערכת האקולוגית של AI נפגעה מתוכנה זדונית לגניבת אישורים.
LiteLLM, שער מודלים המשמש לניתוב בקשות ליותר מ-100 ספקי LLM, מורד מיליוני פעמים ביום. באותו חלון זמן קצר, הגרסאות הזדוניות הורדו ככל הנראה עשרות אלפי פעמים לפני שזוהו.
בתיאוריה, זה היה צריך להרגיע: הפרויקט נשא אישורי תאימות, כלי אבטחה היו במקום, והבעיה התגלתה ותוקנה במהירות. אבל זו בדיוק הבעיה.
כי האירוע הזה לא היה רק עניין של תלות שנפגעה. הוא היווה תזכורת לאופן שבו מערכות AI מודרניות נכשלות בפועל: לא על פני השטח, אלא בשכבות שאיננו רואים במלואן.
איתות מוקדם אחד להשפעה הזו כבר מופיע. סטארט-אפ הגיוס מבוסס ה-AI, Mercor, אישר כי הוא היה "אחד מאלפי" קורבנות במורד הזרם שהושפעו מהתקפת שרשרת האספקה של LiteLLM. במקרה שלהם, הפרצה לא נעצרה בחבילה פגיעה; על פי הדיווחים, היא הובילה לדליפת נתונים רחבת היקף, כולל קוד מקור, לאחר שנעשה שימוש באישורים גנובים כדי לגשת למערכות פנימיות.
זה החלק שרוב הצוותים מפספסים. הסיכון אינו התלות עצמה, אלא למה לתלות הזו יש גישה בזמן ריצה. ברגע שמשהו כמו LiteLLM יושב בנתיב הביצוע בין האפליקציה לספקי המודלים שלך, הוא הופך לצינור לכל מה שמאחוריו: APIs, כלים, תהליכי עבודה של סוכנים (agent workflows) ונתונים רגישים.
Mercor ואחרים לא נפרצו רק בגלל שהם "השתמשו ב-LiteLLM". הם נפרצו בגלל הקשרים שהיו ל-LiteLLM.
באירוע הפשרה של LiteLLM המקורי, התוכנה הזדונית עצמה הייתה יחסית לא מתוחכמת. היא הייתה רועשת, גרמה לקריסת מכונות ונתפסה. גרסה מתוחכמת יותר, כזו שנועדה לחלץ בשקט אישורים מספקי מודלים, APIs ותהליכי עבודה של סוכנים, הייתה עלולה להישאר ללא גילוי במשך שבועות.
ואילו זה היה קורה, רוב הצוותים לא היו יודעים מה באמת נמצא בסיכון. הם היו יודעים רק שהם משתמשים ב-LiteLLM.
• אילו דגמים נותבו דרכו
• לאילו כלים ומערכות מודלים אלה יכולים לגשת
• איך הסיכון הזה התפשט דרך היישומים שלהם
זה הפער. וזו הסיבה שמקרים כאלה הם כבר לא רק בעיות בשרשרת האספקה; בסופו של דבר, מדובר בנראות של מערכות AI.
כאשר אירוע ה-LiteLLM התרחש, רוב הצוותים עשו בדיוק את מה שהיית מצפה. הם בדקו את התלויות שלהם, זיהו את הגרסאות הפגיעות ופעלו במהירות כדי לבצע תיקון או להצמיד גרסה בטוחה. מנקודת מבט מסורתית של אבטחת יישומים, זו עבודה טובה.
אבל זה מעלה שאלה מעניינת יותר, כזו שרוב הקבוצות לא עוצרות לשאול: מה בעצם תיקנת?
צריך להסתכל מעבר למקום שבו נעשה שימוש ב-LiteLLM ולברר מה הוא עשה בתוך המערכת שלך, למה הוא היה מחובר, ואיזה סיכון הוא הציג מעבר לחבילה עצמה. כי באפליקציות AI, זה המקום שבו הדברים מסתבכים.
איפה הנראות המסורתית מתקלקלת
LiteLLM היא לא סתם עוד ספרייה שיושבת בשקט בבסיס הקוד. היא יושבת ישירות בנתיב הביצוע בין האפליקציה שלך למודלים שעליהם היא מסתמכת. היא מנתבת בקשות, מבצעת אבסטרקטציה של ספקים ובסופו של דבר מעצבת את אופן הפעולה של המערכת שלך בזמן ריצה.
זה אומר שכאשר LiteLLM נפגעת, ההשפעה אינה מוגבלת למאגרים הכוללים את החבילה. היא מתרחבת לאילו מודלים נקראים דרכה, אילו ספקים מעורבים, לאילו כלים מודלים אלו יכולים לגשת, ואילו תהליכי עבודה של סוכנים תלויים בה.
זה המקום שבו רוב הקבוצות מאבדות נראות. שורת קוד אחת שמציינת מודל עשויה להיראות חסרת משמעות, אבל היא מקודדת סדרה של החלטות לגבי ספקים, יכולות וגישה שאינן נתפסות בשום מקום בגרף תלות.
תכפיל את זה על פני מאגרים, צוותים ותהליכי עבודה של סוכנים שמתפתחים ללא הרף, ומה שמתקבל אינו רק בעיית תלות. זו מערכת שקשה לראות או להבין במלואה.
הפער ש-Evo AI-SPM נועד לסגור
במקום להתמקד אך ורק בתלויות הקיימות, Evo מתמקדת באופן שבו נעשה שימוש ב-AI. במקרה של LiteLLM, זה אומר לזהות אותה כשער מודלים, למפות אילו ספקים ומודלים מנותבים דרכה, לגלות את הכלים וה-APIs שאותם מודלים מקיימים איתם אינטראקציה, ולחבר את הכל בחזרה לתהליכי העבודה של הסוכנים שמגדירים את התנהגות המערכת.
התוצאה היא AI-BOM, מפה חיה של מערכת ה-AI עצמה, ולא רק הרכיבים שמהם היא בנויה.
למה ההקשר משנה הכל
ההקשר הנוסף הזה משנה מהותית את האופן שבו צוותים מגיבים לאירועים. אם כל מה שאתה יודע הוא ש-LiteLLM נפגע, השלב הבא הוא פשוט: תקן את זה. אבל ברגע שאתה מבין כיצד נעשה בו שימוש, התגובה הופכת לניואנסית יותר.
אתה יכול להתחיל בשאלת האם התעבורה מנותבת לספקי מודלים לא מאושרים, אילו סוכנים מסתמכים על המסלול הזה, אילו מערכות חיצוניות נחשפות דרכו, והאם מדיניות כלשהי מסדירה את האינטראקציות הללו מלכתחילה. זה ההבדל בין תגובה לפגיעות לבין הבנת החשיפה שלך בפועל.
כך כבר בנויות אפליקציות מבוססות AI
זה משקף את מספר האפליקציות מבוססות ה-AI שכבר נבנות. מפתח עשוי להשתמש ב-framework כדי לתזמר סוכן, להסתמך על LiteLLM כדי לבצע אבסטרקטציה לגישה למודל, ולחבר את הסוכן הזה לכלים חיצוניים או ל-APIs כדי להשלים משימות. מנקודת מבט מסורתית, זה מופיע כחבילה פגיעה. מנקודת מבט מערכתית, זה מייצג שרשרת של החלטות, אינטגרציות והתנהגויות שמשתרעות הרבה מעבר לחבילה עצמה.
ה-AI שאתה לא יודע שיש לך
מה שמפתיע לעתים קרובות צוותים הוא כמות ה-AI שכבר קיימת בסביבות שלהם. רבים מאמינים שהם עדיין בתחילת האימוץ של AI, רק כדי לגלות שימוש מפוזר בשערי מודלים, מסגרות תזמור ודפוסי סוכנים מתעוררים ברחבי בסיסי הקוד שלהם.
שום דבר מזה אינו ריכוזי, חלק ניכר מזה אינו מנוהל, ובכל זאת הוא כבר חלק ממערכות ייצור. תקריות כמו הפגיעה ב-LiteLLM לא יוצרות את המורכבות הזו; הן חושפות אותה.
אתה עדיין צריך SCA (רק לא רק SCA)
זה לא כישלון של Software Composition Analysis (SCA). כלים כמו Snyk Open Source מסמנים גרסאות שנפרצו של LiteLLM, מציגים היכן גרסאות אלו היו קיימות ברחבי המאגרים—כולל תלויות טרנזיטיביות—מתריעים במהירות לצוותים ומספקים הנחיות ברורות לתיקון.
האות הזה הוא בסיסי, ובלעדיו, הצוותים אפילו לא ידעו שיש בעיה. אבל SCA בנוי לענות על שאלה מאוד ספציפית: "האם התלות הזו פגיעה?" האתגר הוא שמערכות מודרניות AI אינן עוצרות בתלות.
תגובה נפוצה לתקריות מסוג זה היא לומר, "SCA כבר תפס את זה". וזה נכון, אבל זה מניח שהתלות היא המערכת. במציאות, היא רק נקודת הכניסה. המערכת היא כל מה שהתלות מאפשרת: גישה למודל, ביצוע כלים, תזמור סוכנים וקבלת החלטות דינמית. אם אתה לא יכול לראות את השכבה הזו, אתה לא מבין באמת איפה הסיכון שלך נמצא.
הפשרה של LiteLLM היא רק דוגמה אחת, אבל היא מבהירה את השינוי: אם אתה מסתכל רק על תלויות, אתה לא רואה את המערכת. SCA אומר לך שמשהו לא בסדר, Evo עוזר לך להבין מה זה אומר בהקשר של מערכת ה-AI שלך, ונותן לך את היכולת לשלוט בה.
כיצד להפעיל Evo AI-SPM
הדרך המהירה ביותר לראות זאת בסביבה שלך היא פשוטה עם Evo AI-SPM, ובתוך דקות, תוכל:
• זהה היכן קיימים LiteLLM (ושערים של מודלים דומים) ברחבי המאגרים שלך
• ראה אילו ספקי דגמים ודגמים מנותבים דרכם
• גלה כלים מחוברים, APIs, סוכנים וזרימות עבודה
• גלה "צל AI" (Shadow AI) שאינו גלוי דרך כלי אבטחה מסורתיים
• החל מדיניות כדי לשלוט במה שמותר להתקדם
רוב הצוותים מופתעים ממה שהם מוצאים בסריקה הראשונה כי המציאות היא: אם אתה בונה עם AI, כבר יש לך שרשרת אספקה של AI. ייתכן שפשוט עדיין לא ראית אותה.
Snyk Open Source עוזר לך למצוא נקודות תורפה .
Evo AI-SPM מראה לך את המערכת ועוזרת לך לאבטח אותה.
התחל עם Discovery. התחל עם Evo AI-SPM.
חשוף כל רכיב AI מוסתר בבסיס הקוד שלך והחל ממשל כלל הארגון.
קרא עוד
PHP2Shell לא יהיה האחרון. הנה איפה שהבא הבא יופיע.
PHP2Shell הראה באיזו מהירות פגם ברמת המנוע יכול לסכן אפליקציות הפונות לאינטרנט. למד מדוע מלאי חיצוני, בדיקות מהירות ובדיקות חוזרות חשובות לפני החשיפה הבאה.
סניק UNFILTERED: Inside Our First-Ever Customer Summit
בפסגת הלקוחות הראשונה של Snyk, מנהיגי אבטחה חלקו נקודות מבט גלויות לגבי סיכוני AI, תיקון פגיעויות וניהול סוכנים אוטונומיים. חמישה נושאים חושפים כיצד צוותים מתאימים את האבטחה למהירות ה-AI.
PHP מתקנת שתי פגיעויות RCE קריטיות ללא אימות (CVE-2026-109618, CVE-2026-109619): [עודכן עבור CVE-2026-115560]
שני פגמים קריטיים במחזור החיים של הבקשות של PHP יכולים לאפשר ביצוע קוד מרחוק לא מאומת. שדרג למהדורה קבועה או התקן פורט אחורי של ספק עבור גרסאות ישנות יותר.