חזרה לפיד
articlesמקור: PortSwigger Research10.12.2025

המנעול השביר: דרכי עקיפה חדשניות לאימות SAML

אמ;לק

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

סיכום בעברית: מערכת VibeSec · מדיניות המקורות

נוסף ל-VibeSec:

כותרת מקורית: The Fragile Lock: Novel Bypasses For SAML Authentication

המנעול השביר: דרכי עקיפה חדשניות לאימות SAML

התוכן המלא בעברית

תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.

⁦Zakhar Fedotkin⁩

• פורסם: יום רביעי, 10 בדצמבר 2025 בשעה 12:32 ⁦UTC⁩

• עודכן: יום רביעי, 21 בינואר 2026 בשעה 10:34 ⁦UTC⁩

⁦TLDR⁩

פוסט זה מציג כיצד להשיג מעקף אימות מלא במערכות SAML המבוססות על Ruby ו-PHP, על ידי ניצול חוסר עקביות ברמת המנתח (Parser): החל מזיהום תכונות (Attribute pollution), דרך בלבול במרחבי שמות, ועד לסוג חדש של התקפות Void Canonicalization. טכניקות אלו מאפשרות לתוקף לעקוף לחלוטין את אימות החתימה של ה-XML, תוך הצגת מסמך SAML שנראה תקין לחלוטין בפני האפליקציה.

ניתן לקבל מאמר זה בפורמט PDF ידידותי להדפסה או להורדה. כמו כן, ניתן לעיין בשקופיות מההרצאה ב-Black Hat.

הנה הדגמה של המתקפה על מופע פגיע של ⁦GitLab⁩ ⁦EE⁩ 17.8.4:

תוכן עניינים

תַקצִיר

התקן Security Assertion Markup Language (SAML 2.0) הוא תקן אימות מורכב הבנוי על טכנולוגיית XML לא מאובטחת ומיושנת. יסודות מורשת אלו הפכו את הפרוטוקול לקשה לתחזוקה, והובילו לזרם בלתי פוסק של פגיעויות קריטיות במהלך שני העשורים האחרונים.

מאמר זה מציג מספר סוגים חדשים של התקפות ⁦Signature Wrapping⁩ (⁦XSW⁩) המסוגלות לעקוף לחלוטין אימות בספריות קוד פתוח ⁦SAML⁩ בשימוש נרחב המשמשות ברחבי האינטרנט.

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

העלייה האחרונה בפגיעויות ⁦SAML⁩ מראה שאימות מאובטח לא יכול לקרות בטעות. שמירה על פרוטוקולים כמו ⁦SAML⁩ בטוחה דורשת מאמץ מתואם ומתמשך מכל קהילת האבטחה, לא רק תיקונים מהירים.

זרימת SAML ביוזמת ספק השירות (Service Provider-initiated)

זרימת ⁦Service Provider-Initiated⁩ (⁦SP-Initiated⁩) ⁦SAML⁩ היא הדרך הנפוצה ביותר של אימות באמצעות ⁦SAML⁩. זה מתחיל כאשר משתמש מנסה לגשת למשאב מוגן באתר האינטרנט של ספק השירות. מכיוון שהמשתמש עדיין לא מאומת, ספק השירות מייצר בקשת אימות ⁦SAML⁩ ומפנה את המשתמש ל-⁦Identity Provider⁩ (⁦IdP⁩) לצורך אימות.

ה-⁦IdP⁩ מקבל את הבקשה הזו, מאמת את תקפותה ולאחר מכן מוציא תגובה ⁦SAML⁩ המכילה ⁦Assertion⁩ חתום דיגיטלי המאשרת את זהות המשתמש. תגובה זו נשלחת חזרה דרך הדפדפן של המשתמש לספק השירות (⁦SP⁩). לאחר מכן, ה-⁦SP⁩ מאמת את החתימה הדיגיטלית ומחלץ מידע משתמש (כגון שם משתמש ואימייל) מה-⁦Assertion⁩. אם החתימה והנתונים חוקיים, ניתנת גישה.

⁦XML⁩ ⁦Signature Wrapping Attack⁩ (⁦XSW⁩)

האבטחה הכוללת של זרימה זו תלויה לחלוטין באופן שבו חתימת התגובה ⁦SAML⁩ מאומתת. ביישומים רבים, אימות חתימות ועיבוד הצהרות מטופלים על ידי מודולים נפרדים או אפילו מנתחים ⁦XML⁩ שונים. התקפת ⁦XML⁩ ⁦Signature Wrapping⁩ (⁦XSW⁩) מנצלת את הפערים בין הרכיבים הללו.

בתרחיש טיפוסי, תוקף מיירט תגובה לגיטימית ⁦SAML⁩ חתומה על ידי ⁦Identity Provider⁩ מהימן ומחדיר ⁦Assertion⁩ זדוני חדש המכיל מידע שרירותי של משתמש לאותו מסמך. כאשר ה-⁦Service Provider⁩ מעבד את התגובה, מודול אימות החתימה מאמת נכון את החלק הלגיטימי של ההודעה, בעוד שהלוגיקת העיבוד ⁦SAML⁩ צורכת בטעות את ⁦Assertion⁩ שהוזרקו מהתוקף. כתוצאה מכך, הנתונים המזויפים של התוקף מטופלים כאותנטיים, מה שמוביל להסלמה של הרשאות.

Juraj Somorovsky, במחקרו "On Breaking SAML: Be Whoever You Want to Be", מציע שניתן לעשות זאת באמצעות רישום דרך ה-IdP, ביצוע התקפת Man-in-the-Middle, או אפילו חיפוש בקבצים חשופים לציבור באמצעות Google Dorking. הבעיה היא שמדובר בדרישה משמעותית. השגת SAML Assertion חתום וחוקי עבור אתר שרירותי היא קשה ביותר; ספקי זהות (Identity Providers) כמעט אף פעם לא חושפים אותם, וגם אם הצלחת ללכוד אחד, רוב ספקי השירות (Service Providers) יקבלו אותו רק פעם אחת – לאחר מכן הוא יישמר במטמון ויידחה.

עקיפת אימות מלאה

לכן, אנו נוקטים בגישה אחרת. במקום לנסות לגנוב או לעשות שימוש חוזר ב-Assertion חתום, אנו פשוט עושים שימוש חוזר בכל מסמך XML אחר שנחתם באמצעות המפתח הפרטי של ה-IdP.

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

אשליית האבטחה

במחקר הקודם שלנו עם ⁦Gareth Heyes⁩ - ⁦SAML⁩ רולטה: ההאקר תמיד מנצח , הדגמנו כיצד ניתן לנצל פגמים בטיפול ב-⁦Document Type Declarations⁩ (⁦DTDs⁩) כדי לבצע מתקפה ⁦XSW⁩ נגד ספריית ⁦Ruby⁩-⁦SAML⁩ בשימוש נרחב. כדי למתן את הבעיות הללו, שוחררו שני תיקוני אבטחה - גרסאות 1.12.4 ו-1.18.0.

במאמר זה, אני משתמש בתיקוני ⁦Ruby⁩-⁦SAML⁩ 1.12.4 כמחקר מקרה כדי להדגים מדוע תיקונים מצטברים אינם מספיקים ולמרות ניסיונות מרובים לטפל בפגיעויות ⁦XML-related⁩, הארכיטקטורה הבסיסית נותרה שברירית.

יישום אבטחת XML פגום

תיקון אבטחה 1.12.4 הציג שתי בדיקות חדשות כדי להבטיח שמסמך ה-SAML אינו מכיל DTDs ושהוא מסמך XML תקין (Well-formed). אמנם זה ביטל את הניצול המקורי שלנו, אך הוא לא טיפל בשורש הבעיה. ספריית אבטחת ה-XML עדיין הסתמכה על שני מנתחי XML נפרדים – REXML ו-Nokogiri – עבור חלקים שונים בתהליך האימות.

על פי המפרט ⁦SAML⁩, יש להתייחס לאלמנט ⁦Assertion⁩ - או לאחד ממרכיבי האב הקדמוניים שלו - על ידי האלמנט ⁦Signature⁩ באמצעות חתימה עטופה ⁦XML⁩.

ביישום ⁦Ruby⁩-⁦SAML⁩, הן ⁦REXML⁩ והן ⁦Nokogiri⁩ מאתרים את האלמנט ⁦Signature⁩ באמצעות השאילתה ⁦XPath⁩ "//ds:Signature" , אשר מאחזרת את המופע הראשון של חתימה בכל מקום במסמך. לאחר מכן, לוגיקה נוספת, המיושמת ב-⁦REXML⁩, מאמתת שרכיב האב של החתימה הוא ⁦Assertion⁩. השאילתה המתירנית מדי ⁦XPath⁩ זו הפכה למרכיב מרכזי של הניצול.

חתימת XML היא מנגנון חתימה דו-שלבי: ערך ה-hash של המשאב החתום (DigestValue) והפניה ב-URI לאלמנט החתום מאוחסנים בתוך אלמנט Reference. הבלוק SignedInfo, המכיל הפניות אלו, נחתם בעצמו, והחתימה המקודדת ב-Base64 ממוקמת באלמנט SignatureValue. ביישום Ruby-SAML, נעשה שימוש ב-REXML כדי לחלץ את ה-DigestValue, שמושווה לאחר מכן מול האלמנט שעבר גיבוב (Hashing) וטרנספורמציה באמצעות Nokogiri. ה-SignatureValue, שחולץ אף הוא על ידי REXML, אמור להתאים ל-SignedInfo כפי שעובד על ידי Nokogiri, מה שיוצר תלות שברירית בין שני מנתחים שונים עם טיפול לא עקבי ב-XML.

זיהום תכונות (Attribute pollution)

כדי ליצור ניצול אמין, חשוב להבין תחילה תכונה בסיסית של ⁦XML⁩ - מרחבי שמות. ⁦XML⁩ מרחבי שמות מספקים מנגנון להסמכת שמות אלמנטים ומאפיינים על ידי שיוך שלהם עם ⁦Uniform Resource Identifiers⁩ (⁦URIs⁩).

הצהרות ⁦Namespace⁩ מוגדרות באמצעות משפחה מיוחדת של תכונות שמורות. שם של תכונה כזו חייב להיות בדיוק xmlns (כדי להכריז על מרחב שמות ברירת מחדל) או להתחיל בקידומת xmlns: (כדי להגדיר מרחב שמות עם קידומת ספציפית). לְדוּגמָה:

שתי הצורות תקפות ומשייכות אלמנטים לאותו מרחב שמות של SAML 2.0 Protocol.

מרחבי שמות הם אידיאליים עבור ⁦Signature Wrapping⁩ התקפות, מכיוון שהם משפיעים ישירות על האופן שבו ⁦XML⁩ אלמנטים מזוהים על ידי שאילתות ⁦XPath⁩. רוב הספריות ⁦SAML⁩ מסתמכות על ⁦libxml2⁩ לניתוח ⁦XML⁩. ספרייה זו יורשת מוזרויות מורשת רבות.

הדגמה מצוינת לשבריריות של libxml2 נמצאת במאמר "Abusing libxml2 quirks to bypass SAML authentication on GitHub Enterprise (CVE-2025-23369)" מאת Hakim, שמציג כיצד ניתן לנצל לרעה התנהגות מטמון פנימית כדי להשיג תוצאות עיבוד XML בלתי צפויות. למרבה הצער, מכיוון שגם Entities וגם Doctypes מוגבלים כעת על ידי תיקון 1.12.4, וקטור התקפה זה אינו ישים עוד – מה שמאלץ אותנו לחקור דרכים חלופיות לניצול חוסר העקביות בניתוח.

תובנה מועילה אחת מגיעה ישירות מהתיעוד של ⁦libxml2⁩ של ⁦xmlGetProp⁩:

פונקציה זו מחפשת בהצהרות תכונה ⁦DTD⁩ עבור #⁦FIXED⁩ או ערכי הצהרת ברירת מחדל. ⁦NOTE⁩: פונקציה זו מתעלמת ממרחבי שמות. השתמש ב-⁦xmlGetNsProp⁩ או ⁦xmlGetNoNsProp⁩ לעיבוד מודע למרחב שמות.

גם Ruby (Nokogiri) וגם PHP חושפים התנהגויות של libxml2 שעלולות לבטל את הסנכרון בין אימות החתימה לבין ניתוח ה-Assertion. ב-Nokogiri, חיפושי תכונות כמו node.attribute('ID') (ולא get_attribute) או צורת הקיצור node['ID'], מתעלמים ממרחבי שמות של תכונות ומשתמשים רק בשם הפשוט. כאשר קיימות מספר תכונות עם שם פשוט זהה (למשל ID ו-samlp:ID), רק אחת מוחזרת, והתיעוד אינו מבטיח איזו מהן.

ב-⁦DOM⁩ של ⁦PHP⁩: ⁦DOMNamedNodeMap⁩::⁦getNamedItem⁩ מאחזרת גם תכונה בשם פשוט בלבד.

ניתן להיווכח באי-בהירות הזו ישירות באופן שבו מנתחים פותרים תכונות. שקלו את שני קטעי ה-XML הבאים שנראים שקולים:

במקרה הראשון, הקריאה ⁦xmlGetProp⁩ מחזירה 1, בעוד שבמקרה השני היא מחזירה 2.

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

REXML, המיישמת לוגיקת ניתוח XML משלה ללא תלות ב-libxml2, חשופה לאותה בעיית זיהום תכונות. גם attributes['ID'] וגם get_attribute("ID").value מציגים התנהגות לא עקבית בהתאם לטיפול במרחבי שמות.

במקרה הראשון, הגישה לתכונה באמצעות attributes['ID'] מחזירה 1, בעוד שבמקרה השני היא מחזירה 2. כאשר קיימת קידומת של מרחב שמות, החיפוש הפנימי של REXML מתייחס לשמות התכונות בצורה שונה, מה שמוביל לסדר בחירה הפוך בהשוואה ל-libxml2. חוסר עקביות זה אומר שאותו מסמך XML יכול לייצר ערכי תכונות שונים במנתחים שונים, מה שמאפשר לתוקף לתפעל איזה אלמנט נחתם בפועל לעומת איזה מהם מעובד:

• מודול אימות חתימה מאתר את היעד של החתימה ⁦XML⁩ באמצעות השאילתה ⁦XPath⁩ "//*[@⁦ID⁩='id']", שמתעלמת ממרחבי שמות

• ההיגיון העסקי מוודא שהמזהה של אלמנט השורש תואם לזה שהחתימה מתייחסת אליו - אחזור ה-⁦ID⁩ באמצעות משבר מאפיינים אגנוסטיים של מרחב שמות (למשל, אלמנט['⁦ID⁩'] , ⁦getNamedItem⁩('⁦ID⁩') , או מאפיינים['⁦ID⁩'])).

בלבול במרחבי שמות ב-REXML ללא DTDs

כפי שאתה כבר יודע, xmlns היא תכונה שמורה, ו-xml היא עוד קידומת שמורה. שניהם מוגדרים על ידי המפרט ⁦XML⁩ ולא ניתן להצהיר מחדש או לכבול אותם לערכים שונים.

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

טכניקה זו פועלת גם בכיוון ההפוך, ומאפשרת לתוקף להסתיר את האלמנט הלגיטימי ⁦Signature⁩ מהשאילתה ⁦REXML⁩ ⁦XPath⁩ "//ds:Signature" תוך שמירה על תוקף המסמך. על ידי קינון קפדני של אלמנטים והגדרה מחדש של מרחבי שמות, ניתן להפוך את הצומת ⁦Signature⁩ לגלוי ל-⁦Nokogiri⁩ אך בלתי נראה ל-⁦REXML⁩:

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

ה-XML Schema

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

#saml-authentication#bypass-techniques#web-security#parser-vulnerabilities
קרא במקור