Off Guard: פריצה ל-LiteLLM - מאימות עוקפת ועד פגיעה בענן
אמ;לק
מאמר זה מתאר פרצת אבטחה קריטית ב-LiteLLM, החושפת תשתית AI בענן לביצוע קוד מרחוק וגניבת זהויות (IAM). הוא מדגים כיצד מפתחות ברירת מחדל, סשנים לא מאומתים וקוד מותאם אישית יצרו וקטור תקיפה. המאמר קריטי למפתחי LLM ואבטחת ענן.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: Off Guard: Breaking LiteLLM from authentication bypass to cloud compromise

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
כמעט 1 מכל 10 מופעי LiteLLM הנגישים לציבור מקבלים מפתח ראשי (master key) המוגדר כברירת מחדל או אינם דורשים אימות כלל. מצאנו זאת במהלך סריקה של כ-3,000 פריסות הפונות לאינטרנט של שער ה-LLM הנפוץ ביותר בקוד פתוח. הדאגה הרגילה עם סוג זה של חשיפה היא LLMjacking – מצב שבו מישהו משתמש באישורים כדי להריץ קריאות API על חשבונך – עם זאת, רצינו לבדוק אם תוקף יכול לעשות נזק חמור יותר: האם הוא יכול להשיג ביצוע קוד על המארח? יתרה מכך, האם הוא יכול לנצל זאת כדי לפגוע בסביבה הרחבה יותר?
החלטנו להשתמש ב-Claude Code כדי לעבור על בסיס הקוד של LiteLLM, בחיפוש אחר תכונות שמקבלות קלט בשליטת המשתמש ומעבירות אותו להקשר ביצוע. מצאנו בעיות מרובות, כמפורט להלן.
• עקיפת אימות MCP דרך נקודת הקצה של MCP (CVE-2026-59822) – אסימון Bearer שרירותי יכול ליצור סשן חוקי; אושר כניתן לניצול במאות מופעים הנגישים לאינטרנט.
• ביצוע קוד מרחוק (RCE) ברמת root לאחר אימות באמצעות מעקות הבטיחות (guardrails) המותאמים אישית של LiteLLM (CVE-2026-59821).
• 9.6% מתוך 3,074 מופעים ציבוריים (בזמן מחקר זה) קיבלו את המפתח הראשי כברירת מחדל (sk-1234) או שלא דרשו אימות כלל. במקרים אלה, ה-RCE הוא למעשה ללא צורך באימות (pre-auth).
• גישה לא מאומתת כמנהל (admin) כברירת מחדל (לא הוקצה CVE; תוקן לצד CVE-2026-59821) – כאשר לא מוגדר אימות, כל המשתמשים מקבלים גישת PROXY_ADMIN.
• וקטור גניבת אישורי ענן לאחר אימות באמצעות תכונת נקודת הקצה של ה-pass-through, מכיוון שחסר בה אימות URL. זה לא נחשב לפגיעות ולכן לא תוקן ולא הוקצה לו CVE, מה שאומר שהטכניקה נותרה ניתנת לניצול בתרחישים שלאחר אימות. עם זאת, בדומה לאמור לעיל, כאשר הוא משורשר עם מפתח ראשי כברירת מחדל או בהיעדר אימות, זהו למעשה וקטור pre-auth.
מאז, כל הפגיעויות נחשפו באחריות ל-LiteLLM וזמינים עבורן תיקונים. CVE-2026-59822 התווסף לקטלוג ה-Known Exploited Vulnerabilities של CISA, וצפינו בו מנוצל בשטח באמצעות תשתית ה-honeypot שלנו. מחקר זה הוצג בעבר ב-DEF CON 34.
LiteLLM הוא שער AI בקוד פתוח המספק API מאוחד ותואם ל-OpenAI עבור למעלה מ-100 ספקי LLM, כולל OpenAI, Anthropic, AWS Bedrock, Azure ו-Google Vertex AI. ארגונים מנתבים את תעבורת ה-LLM שלהם דרכו כדי לנהל באופן מרכזי את מפתחות ה-API שלהם, לאכוף תקציבים, ליישם מעקות בטיחות, לפקח על השימוש וכו'.
LiteLLM הוא אחד משערי ה-AI הפופולריים ביותר בקוד פתוח, הקיים בכשליש מסביבות הענן על פי נתוני Wiz. LiteLLM יכול להחזיק מפתחות API עבור כל ספק LLM מוגדר, לעבד כל הנחיה (prompt) ותגובה שעוברים דרכו, ולהתחבר לכלים חיצוניים באמצעות MCP. מופע LiteLLM שנפגע משמעו תשתית AI שנפרצה, וכפי שנראה, לעתים קרובות גם סביבת הענן שבה הוא פועל.
מודל הסיכון המקובל לכך הוא LLMjacking: תוקף מבצע קריאות API בשם הארגון, צובר עלויות ומחלץ מפתחות ספק מוגדרים. למרות שזה אכן סיכון מוכח בעולם האמיתי, LiteLLM הוא לא רק מאגר אישורים. הוא מריץ קוד Python בצד השרת בכל בקשת הסקה (inference), יכול לשמש כפרוקסי לבקשות ל-URLs פנימיים שרירותיים, ומתחבר לכלים ומערכות פנימיים באמצעות MCP. לכן, רצינו לדעת מה תוקף יכול לעשות בפועל עם מופע שנפגע מעבר לניצול לרעה של ה-API.
באמצעות Claude Code, עברנו על מעקות בטיחות, נקודות קצה של pass-through, תצורת מודלים, מערכות hook ושכבת ה-MCP. לשלוש תכונות היה משטח התקפה ברור:
• מטפל אימות MCP (user_api_key_auth_mcp.py): נתיב אימות נפרד עבור נקודת הקצה של ה-Model Context Protocol.
• מעקות בטיחות של קוד מותאם אישית (guardrail_endpoints.py): מנהלי מערכת מגישים קוד Python שהשרת מעביר לפונקציית exec(compile(...)).
• נקודות קצה של pass-through (pass_through_endpoints.py): נתיבי פרוקסי המעבירים בקשות ל-URLs שרירותיות ללא אימות.
LiteLLM תומך ב-MCP (Model Context Protocol), תקן לחיבור מודלי AI לכלים ומקורות נתונים חיצוניים. לנקודת הקצה של MCP יש מטפל אימות משלה, נפרד מהאימות הראשי של LiteLLM. הוא תוכנן לתמוך במודל אימות כפול: מפתחות API של LiteLLM למשתמשים ישירים, והעברת אסימון (passthrough) של OAuth2 למשתמשים המאמתים באמצעות ספקים חיצוניים כמו GitHub או Atlassian. הרעיון פשוט – אם אסימון Bearer אינו מפתח LiteLLM חוקי, העבר אותו לשרת ה-MCP במעלה הזרם כאסימון OAuth2.
הבעיה נמצאת בלוגיקת ה-fallback. כאשר אסימון נכשל באימות של LiteLLM, המטפל אינו מבחין בין "זהו אסימון OAuth2 לגיטימי המיועד לספק במעלה הזרם" לבין "זהו זבל מוחלט". הוא תופס את שגיאת ה-401 ומחזיר בשקט אובייקט אימות ריק – מה שמעניק גישה כאילו הבקשה מאומתת:
elif oauth2_headers : try : validated_user_api_key_auth = await user_api_key_auth ( api_key = litellm_api_key, request = request ) except HTTPException as e : if e . status_code in ( 401 , 403 ) : validated_user_api_key_auth = UserAPIKeyAuth () # bypass else : raise
ענף זה מופעל עבור כל בקשה הכוללת כותרת Authorization – כלומר, כל בקשת Bearer token רגילה. כל אסימון "זבל" נכשל באימות עם שגיאת 401, והמטפל ממשיך כאילו כלום לא קרה. הניצול מתבצע בבקשה אחת, כפי שמוצג להלן. שימו לב ש-Authorization: Bearer a, המכיל תו בודד, מספיק כדי ליצור סשן MCP מאומת לחלוטין:
POST / mcp / HTTP / 1.1 Host : < target > : 4000 Authorization : Bearer a Content - Type : application / json Accept : application / json , text / event - stream { "jsonrpc" : "2.0" , "method" : "initialize" , "id" : 1 , "params" :{ "protocolVersion" : "2025-03-26" , "capabilities" :{}, "clientInfo" :{ "name" : "attacker" , "version" : "1.0" }}} -> HTTP 200 (valid session created , mcp - session - id header returned)
כיצד תוקף יכול לנצל גישת MCP?
ברגע שהתוקף בפנים, יש לו גישה לפרוטוקול MCP המלא. לא רק פעולות קריאה, אלא היכולת להריץ כלים עם ארגומנטים שרירותיים. אם שרת MCP חושף כלי לשאילתות במסד נתונים, התוקף יכול להריץ שאילתות. באופן דומה, אם הוא מתחבר ל-GitHub, התוקף יכול לקרוא מאגרים וליצור issues. אם יש לו גישה למערכת הקבצים, התוקף יכול לקרוא ולכתוב קבצים.
לאילו שרתי MCP תוקף יכול להגיע תלוי באופן שבו הארגון הגדיר אותם. LiteLLM תומך בדגל allow_all_keys שהופך שרת MCP לזמין לכל משתמש, כולל האישורים הריקים שנוצרו על ידי עקיפת האימות. התיעוד של LiteLLM ממליץ על הגדרה זו עבור "בסיסי ידע פנימיים, שילובי יומן, או כלי עזר אחרים בעלי סיכון נמוך שבהם כל צוות אמור להיות מסוגל להתחבר מבלי לבקש גישה".
יתרה מכך, ארגונים הפורסים את LiteLLM באופן פנימי נוטים יותר לחבר שרתי MCP למערכות רגישות: Jira לניהול פרויקטים, Slack לתקשורת, מסדי נתונים פנימיים לנתונים עסקיים וצינורות CI/CD לאוטומציה של פריסה. סביבות אלו מניחות קיומה של אבטחה ברמת הרשת ולעתים קרובות מגדירות גישה רחבה יותר לכלים. פגיעות עקיפת האימות הזו מעניקה לתוקף גישה ישירה למערכות הרגישות המחוברות הללו.
תכונת מעקות הבטיחות של LiteLLM מאפשרת למנהלי מערכת להגדיר מדיניות הפועלת על כל בקשת LLM, כולל חסימת הנחיות רגישות, סינון פלטים ואכיפת כללי תאימות. תכונת ה-Custom Code Guardrails מרחיבה זאת: מנהלי מערכת כותבים קוד דמוי Python שהשרת מבצע לפני או אחרי כל קריאת הסקה (inference).
התכנון המקורי כולל ארגז חול (sandbox). הלחצן "Run Test" בממשק ה-Web מאמת קוד מול רשימת תבניות אסורות ומסיר את ה-__builtins__ לפני הביצוע, ובכך חוסם פקודות כמו import, os, subprocess וכדומה. אולם נקודת הקצה של הרישום (POST /guardrails) אינה מיישמת אף אחת מההגנות הללו.
כאשר נוצר מעקה בטיחות, השרת קורא ל-_compile_custom_code() בקובץ custom_code_guardrail.py:
exec_globals = get_custom_code_primitives (). copy () exec ( compile (self.custom_code, "<guardrail>" , "exec" ), exec_globals)
שני דברים חסרים בנתיב הזה. ראשית, בדיקת התבניות האסורות – שחוסמת import, exec(), eval(), os, subprocess ותכונות מסוכנות – פועלת רק בנקודת הקצה של הבדיקה. שנית, נקודת הקצה של הבדיקה מגדירה במפורש exec_globals["__builtins__"] = {} לפני הביצוע, בעוד שנקודת הקצה של הרישום לא עושה זאת. Python מאכלס מחדש את __builtins__ באופן אוטומטי כשהם חסרים, כך שהקוד שנשלח מקבל גישה לספרייה הסטנדרטית המלאה.
POST /guardrails HTTP/1.1 Authorization: Bearer < master_ke y > { "guardrail" : { "guardrail_name ":" rce-poc "," litellm_params ":{" guardrail ":" custom_code ", " mode ":" pre_call "," default_on ":true," custom_code ":" import os \n _cmd = os.popen ( 'id' ) .read () .strip ()\n def apply_guardrail (inputs, request_data, input_type ) : \n return { \" action \" : \" block \" , \" reason \" : _cmd} "}}}
הקוד מופעל מיד עם רישום מעקה הבטיחות, מכיוון שה-import os ו-os.popen('id') רצים במהלך האתחול, עוד לפני כל בקשת LLM. התוצאה מאוחסנת ב-_cmd. תוקף יכול לשלוח כל בקשת צ'אט כדי להפעיל את מעקה הבטיחות ולראות את הפלט שהוחזר כסיבה לחסימה:
uid = 0 (root) gid = 0 (root) groups = 0 (root) ,1 (bin) ,2 (daemon) ,3 (sys) ,4 (adm) ...
• נקודות קצה של מעקות בטיחות דורשות כעת PROXY_ADMIN. נקודות הקצה של ה-CRUD בודקות במפורש תפקיד מנהל במקום לקבל כל מפתח חוקי.
• ארגז חול נאכף כראוי בעת הרישום. נתיב ה-exec() מסיר כעת builtins ומריץ את בדיקת התבניות האסורות לפני ההידור (compilation), בהתאם להתנהגות נקודת הקצה של הבדיקה.
במילים אחרות, מעקות בטיחות של קוד מותאם אישית רצים תמיד בתוך ארגז חול, והתכונה עצמה מוגנת כעת באופן מלא ברמת המנהל, ללא קשר אם האימות מוגדר או לא. התיקון חוסם את הנתיב ממפתח API רגיל, או ללא מפתח כלל, לביצוע קוד. משמעות הדבר היא שתוקף המנסה לנצל תכונה זו בגרסאות חדשות יותר יזדקק לגישת מנהל, ויוכל להריץ קוד רק בתוך ארגז החול.
שים לב שפגיעות עקיפת האימות ב-MCP שהוזכרה לעיל מאפשרת רק גישה לשרת ה-MCP, ואינה מאפשרת ניצול של פגיעות ה-RCE הזו שלאחר אימות.
לכן, בהתחשב בכך שפגיעות זו ניתנת לניצול מלכתחילה רק על ידי מנהל מאומת, השאלה החשובה הופכת להיות באילו תנאים תוקף יכול לעקוף את האימות לרמת מנהל כדי לנצל אותה – מה שמוביל אותנו לשני הנושאים הבאים שלנו.
LiteLLM תומך במספר מנגנוני אימות: מפתח ראשי (השיטה העיקרית), JWT/OAuth2 ומפתחות API וירטואליים. המפתח הראשי הוא הנפוץ ביותר: הוא משמש גם כאישור מנהל וגם כבורר לאימות עצמו. כאשר מפתח ראשי מוגדר, כל בקשות ה-API חייבות לכלול מפתח חוקי. כאשר לא מוגדר מפתח ראשי (ולא מוגדר JWT/OAuth2), הפרוקסי רץ ללא אימות כלל וכל בקשה מתקבלת.
לפני התיקון, היו לכך שתי בעיות מצטברות:
ראשית, כאשר לא הוגדר מפתח ראשי, מטפל האימות של LiteLLM הקצה באופן גלובלי את תפקיד ה-PROXY_ADMIN לכל בקשה נכנסת. זו לא הייתה סתם "גישה לא מאומתת", אלא גישת *ניהול* לא מאומתת לכל הפרוקסי.
שנית, גם כאשר האימות היה מופעל, לא נקודות הקצה של ה-CRUD של מעקות הבטיחות ולא נקודת הקצה של עדכון התצורה (המשמשת להגדרת נתיבי pass-through) דרשו את תפקיד ה-PROXY_ADMIN. שניהן השתמשו בתלות אימות גנרית שקיבלה כל מפתח API חוקי, כך שכל משתמש מאומת יכול היה להגיע אליהן.
PR #22095 טיפל בתפקיד ברירת המחדל (שונה מ-PROXY_ADMIN ל-INTERNAL_USER) והוסיף בדיקות PROXY_ADMIN לנקודות הקצה של מעקות הבטיחות. נקודת הקצה של עדכון התצורה תוקנה בנפרד בגרסה v1.83.0 (CVE-2026-35029).