פיצול אטומי של כתובות אימייל: ניצול Pparsers לעקיפת בקרות גישה
אמ;לק
מאמר זה דן בניצול הבדלים באופן שבו מפרסרי כתובות אימייל (email parsers) שונים מנתחים נתונים, במטרה לעקוף בקרות גישה. אתרים מסוימים מנתחים כתובות אימייל כדי להסיק מהן את הדומיין והארגון של המשתמש. פערים אלו עלולים להוביל לפרצות אבטחה משמעותיות, במיוחד בפיתוח מונחה AI.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: Splitting the email atom: exploiting parsers to bypass access controls

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
Gareth Heyes
• פורסם: יום רביעי, 7 באוגוסט 2024 בשעה 21:32 UTC
• עודכן: יום שישי, 27 ביוני 2025 בשעה 13:49 UTC
חלק מהאתרים מנתחים כתובות דוא"ל כדי לחלץ את הדומיין ולהסיק לאיזה ארגון שייך הבעלים. דפוס זה הופך אי-התאמות במנתחי כתובות דוא"ל לנקודות קריטיות. חיזוי לאיזה דומיין ינותב אימייל אמור להיות פשוט, אך למעשה הוא קשה בצורה מגוחכת – אפילו עבור כתובות "תקניות" התואמות את תקן ה-RFC.
במאמר זה אראה לכם כיצד להפוך אי-התאמות בניתוח דוא"ל לעקיפת בקרות גישה ואפילו לביצוע קוד מרחוק (RCE).
מאמר זה מלווה ב-CTF מקוון וחינמי, כך שתוכלו לתרגל את מערך המיומנויות החדש שלכם באופן מיידי.
ניתן גם להוריד מאמר זה בפורמט PDF ידידותי להדפסה. כמו כן, ניתן להוריד את השקופיות מהרצאת ה-Black Hat.
הצגתי את ההרצאה הזו ב-Black Hat ו-DEF CON. אתה יכול לצפות בו כאן:
תמצית
• מתודולוגיה/כלים: יצירת התקפות פיצול אימייל
מָבוֹא
חלק מה-RFCs שמכתיבים את פורמט כתובת הדוא"ל קיימים כבר למעלה מ-50 שנה; הם חוברו יחד כדי ליצור סטנדרט לכתובות דוא"ל שהוא מקל מדי. אימיילים יכולים לכלול ערכים בתוך מירכאות, הערות, תווים בורחים (escapes) וקידודים שונים. אם אתם עומדים בפני המשימה של כתיבת מנתח אימייל (Parser), מבחינה טכנית עליכם לפעול לפי המפרט, אך בגלל המורכבות הזו, מדובר במשימה קשה. יישומי אינטרנט מעבירים את המורכבות הזו לספריות ניתוח דוא"ל, וכתוצאה מכך הם לא באמת יודעים כיצד האימייל מנותח. זה מוביל לבעיות כאשר הם מקבלים החלטות אבטחה על סמך הדומיין של המייל.
אם תסתכלו על סעיפים 3.2.5 ו-3.2.2 של RFC2822, תראו שהם מאפשרים שימוש בערכים בתוך מירכאות ובתווים בורחים (escapes). אלו מאפשרים שימוש בתווים שבדרך כלל אינם מותרים ב-local-part של כתובת הדוא"ל. הנה כמה דוגמאות:
בדוגמה הראשונה, מכיוון שה-local-part מוקף במירכאות, סמל ה-@ ישמש ככתובת יעד לאחר הסרת המירכאות. בדוגמה השנייה ניתן לראות כיצד ניתן להשתמש בתווים בורחים בתוך ה-local-part המצוטט כדי להשתמש במירכאה כפולה כחלק מכתובת היעד. אם נסתכל לעומק על סעיף 3.2.3 באותו RFC, נראה שהוא תומך בהערות. הערות נבנות באמצעות סוגריים ויכולות להכיל רווחים ואפילו קינון. הנה כמה דוגמאות לאימיילים "תקפים" המשתמשים בהערות:
אינכם מוגבלים רק לערכים אלפאנומריים; ניתן להציב מגוון רחב של תווים בתוך הערה. כל זה נראה בשל לניצול לרעה על ידי יצירת בלבול בין המנתח, האפליקציה ושירות המייל. המסע שלי במחקר זה החל בניסיון ליצור את הבלבול הזה על ידי ניצול לרעה של תווים בורחים והערות.
יצירת בלבול בדומיין הדוא"ל
אני לא גאה בסיפור על איך גיליתי את זה, אבל זו האמת. לא ביליתי שעות בבחינת קוד המקור של Postfix ו-Sendmail עם מנפה באגים (Debugger), ובהחלט היה כאן אלמנט של אקראיות ומזל.
זה התחיל כשנכנסתי לשרת שבו השתמשתי לבדיקות; התקנתי אפליקציה ללא שם והתחלתי לבדוק אותה לאיתור אי-התאמות בניתוח אימייל. לא הגעתי לשום מקום. כל מה שניסיתי נכשל, והיו לי מחשבות לנטוש את המחקר לחלוטין. ואז, מתוך ייאוש, לקחתי את התווים המיוחדים שהאפליקציה השתמשה בהם והדבקתי אותם בכתובת המייל שלי. ידעתי שהכתובת תהיה תקפה כי אלו היו התווים שהם אישרו, אבל רק רציתי לראות מה יקרה עם שרת המייל.
בדקתי את ה-syslog של השרת ושמתי לב שאני מקבל הודעת DSN (Delivery Status Notification) עם מארח לא חוקי. מופתע מכך, התחלתי לחפור עמוק יותר. התחלתי להסיר תווים מכתובת האימייל כדי לצמצם מדוע Sendmail חשב שמדובר במארח לא חוקי. בסופו של דבר, צמצמתי את זה לסימן הקריאה ונזכרתי בפרוטוקול UUCP שקראתי עליו במהלך המחקר.
UUCP הוא פרוטוקול עתיק שהיה קיים לפני האינטרנט והאימייל. הוא אפשר שליחת הודעות בין מערכות Unix ופירושו Unix To Unix Copy. הוא פועל באמצעות שימוש בסימן קריאה כמפריד בין הדומיין לחלק המשתמש, אך בסדר הפוך מכתובת אימייל מסורתית.
זה היה מטורף – במזל טהור, התווים שהדבקתי הסתיימו בקו נטוי אחורי (backslash) שביטל את סמל ה-@, ואז סימן הקריאה גרם לכתובת להיתפס ככתובת UUCP! הנה הגילוי שלי במלוא הדרו:
באופן טבעי, הייתי צריך לבדוק עם דומיין Collaborator שונה כדי לוודא שזה באמת מגיע לשרת אחר:
הדוגמה הקודמת מגיעה לדומיין Collaborator בשם "oastify.com" ולא ל-example.com בעת שימוש ב-Sendmail 8.15.2. זה היה ממש מרגש עבורי כי הוכחתי שהמחקר הזה באמת מוביל לאנשהו. השלב הבא היה למצוא תווים אחרים שגרמו להתנהגות הזו, אז כתבתי במהירות SMTP fuzzer. גיליתי של-Postfix לא הייתה התנהגות זו כי היא מאובטחת יותר, נכון? ובכן, זה מה שחשבתי עד שמצאתי וריאציה ב-Postfix 3.6.4 באמצעות ה-fuzzer:
זה למעשה עובר ל-psres.net ולא ל-example.com ומשתמש בפרוטוקול ארכאי נוסף שנקרא נתיבי מקור (source routes). נתיבי מקור מאפשרים להשתמש בשרשרת של שרתים כדי לשלוח דואר. הרעיון היה להפריד כל מארח בפסיק ואז לכלול את היעד הסופי בסוף. יש גם מה שנקרא "percent hack", שבו שרת המייל ממיר את ה-% או תו נבחר אחר לסמל @ ואז מעביר את המייל לשרת. דוגמה זו ממחישה זאת:
בתהליך זה, המייל נשלח תחילה ל-example.com, ולאחר מכן סמל האחוז מומר לסמל @ ואימייל נשלח ל-foo@psres.net. זה בדיוק מה שקורה עם הווקטור: הסוגריים הופכים את חלק הדומיין בכתובת האימייל להערה, ואז Postfix משתמש ב-local-part כמסלול מקור ששולח את האימייל ליעד הבלתי צפוי. Postfix למעשה תומך גם ב-UUCP, דבר שגיליתי מאוחר יותר כשניסיתי את הטריק של הסוגריים הבודדים.
הממצאים האלה נתנו לי ביטחון שיש המון באגים בחוץ ולכן התחלתי לחפש עוד.
אי התאמות מנתח
Unicode עולה על גדותיו
אחת הבעיות העיקריות שהייתי צריך לפתור במחקר זה הייתה יצירת תווים חסומים. מאחר שיישומי אינטרנט רבים חוסמים ריבוי של סמלי @, התחלתי לבחון גלישות Unicode.
בדקתי יעד ללא שם ושמתי לב שכאשר משתמשים בתווי Unicode גבוהים יותר, הם מייצרים תווים אחרים ב-ASCII. הדפוס הזה נראה אקראי בהתחלה, אבל אז הבנתי מה קורה. כנראה הכי קל להמחיש זאת באמצעות תמונה של האופן שבו האלגוריתם chr() עובד ב-PHP. הפונקציה chr() מחזירה תו שצוין על ידי נקודת קוד (code point) כמספר שלם:
בדוגמה, PHP עובר בלולאה על הבתים ובודק אם הערך קטן מאפס; אם כן, הוא מוסיף 256 עד שהוא חיובי. לאחר מכן הוא מבצע פעולת מודולו (modulus) כדי להתאים את הערך לטווח של 0-255. משמעות הדבר היא שאם תעבירו ערך בתים הגדול מ-255, הוא יגלוש וייאלץ להיכנס לטווח 0-255 בגלל פעולת המודולו. כך בדיוק פועלות גלישות Unicode; אנחנו פשוט צריכים לספק תו שנקודת הקוד שלו גדולה מ-255 כדי ליצור תווים אחרים. זה מומחש בצורה הטובה ביותר עם דוגמה פשוטה:
בדוגמה הקודמת השתמשתי בפונקציה fromCodePoint כדי ליצור תו; העברתי ערך hex של 0x100 שמתורגם ל-256 עשרוני, ואז הוספתי 0x40, שהוא הערך ההקסדצימלי של סמל ה-@. לאחר מכן, כאשר המערכת מבצעת פעולה כמו הפונקציה chr() ב-PHP, נקודת הקוד של ה-Unicode תגלוש ותתאים לטווח 0-255, מה שיצור את סמל ה-@.
אחרי שגיליתי את זה, התחלתי לבצע Fuzzing ליעד עם Turbo Intruder ושמתי לב שתווים אחרים מפגינים התנהגות זו. בהתחלה זה נראה אקראי, אבל אז הבנתי מה קורה: 0x100 הוא רק אחד המספרים שניתן להשתמש בהם כדי לבצע גלישה. אם משתמשים בתווים גבוהים יותר, ניתן להשתמש בכל אחד מהתווים שביניהם.
כל אחד מערכי ה-hex שלעיל יוצרים גלישות מכיוון שפעולת המודולו תניב אפס, וזה יכול להמשיך עד לנקודת הקוד המקסימלית הנוכחית של Unicode, שהיא 0x10ffff. יעד זה אפשר לכל מיני תווי Unicode ליצור תווים אחרים:
אם תבצעו פעולת מודולו 256 על כל אחד מהתווים, תתקבל התוצאה של התו שנוצר:
למרות שהצלחתי לזייף מגוון רחב של תווים, לא הצלחתי לפצל דוא"ל ביעד הזה באמצעות טכניקה זו. אבל זו הייתה רק ההתחלה – הוכחתי שאפשר ליצור תווים חסומים. זה נתן לי את הביטחון לחפש עוד.
מילה מקודדת (Encoded-word)
ככל שהתחלתי להעמיק, כך מצאתי יותר מה-RFCs של הדוא"ל. לפני מחקר זה הנחתי שהודעות אימייל הן בדרך כלל אלפאנומריות עם נקודות ב-local-part. מעולם לא דמיינתי שקיימת מערכת קידוד מורכבת שמאפשרת לבצע שכבות של קידוד. ובכל זאת, זה מה שגיליתי. כשסרקתי את ה-RFCs שמתי לב ל-rfc2047 ול-encoded-word; מערכת קידוד זו מאפשרת לייצג תווים באמצעות hex ו-base64.
אם אנו משתמשים באימייל מקודד כהמחשה:
ה-"=?" מציין את ההתחלה של מילה מקודדת (encoded-word), ואז מציינים את ערכת התווים (במקרה זה UTF-8). לאחר מכן סימן השאלה מפריד את הפקודה הבאה, שהיא "q", המציינת "Q-Encoding". אחריה יש עוד סימן שאלה שמציין את סוף פורמט הקידוד ואת תחילת הנתונים המקודדים. Q-Encoding הוא פשוט hex עם קידומת שווה. בדוגמה זו אני משתמש ב-=41=42=43, שהם האותיות "ABC". לבסוף, ?= מציין את סוף הקידוד. כאשר זה מנותח על ידי ספריית דוא"ל, יעד הדוא"ל יהיה ABCUSER@psres.net!
חמוש במידע הזה, התחלתי לחפש מערכות אמיתיות שמנתחות מיילים באמצעות קידוד זה. כדי לעזור בכך, הגיתי שתי בדיקות שעבדו ברוב האתרים שהציגו התנהגות זו:
בתחילה השתמשתי בערכת התווים "x" כדי להקטין את גודל הבדיקה, אולם מערכות מסוימות דוחות ערכות תווים לא מוכרות ונכשלות. עדיף להשתמש בשתי הבדיקות הללו, שכן גיליתי שהן ערכות התווים הנפוצות ביותר שמותרות לאחר בדיקה של אתרים רבים. השתמשו ב-Collaborator כדי ליצור Payload והחליפו את "collab" למעלה בזה שנוצר. אם תראו אינטראקציית SMTP עם האימייל בפקודת ה-RCPT TO של שיחת ה-SMTP:
זה מוכיח שמנתח האימייל מפענח את האימייל עם "מילה מקודדת".
מצאתי חבורה של אתרים עם ההתנהגות הזו ולכולם היה מכנה משותף אחד: Ruby. נראה שכולם השתמשו באותו Ruby Gem בשם "Mail", שיש לו למעלה מ-508 מיליון הורדות. התחלתי להסתכל על קוד המקור וגיליתי שהספרייה מפענחת UTF-7! בסביבת הבדיקות שלי ניסיתי לשחזר את זה:
זה מטורף! לאימיילים יכול להיות עכשיו UTF-7! ואז צץ לי רעיון בראש: אם יש Q-Encoding וערכות תווים, האם אפשר לקבל את שניהם? התשובה המפתיעה לשאלה זו היא "כן" מהדהד. ניתן לשלב UTF-7 עם Q-Encoding!
לאחר מכן התחלתי לשחק בקידוד base64 כי כמובן ש"מקודדת-מילה" תומכת בזה במיילים! אתה פשוט משתמש ב-"b" במקום "q" בסוג הקידוד ואתה יכול להשתמש בו.
הדוגמה הקודמת משתמשת במחרוזת "foobar" מקודדת ב-base64 שמפוענחת על ידי המנתח. אני יודע מה אתם חושבים, או אולי זה רק אני, אבל כן – ניתן להשתמש בנתונים מקודדים ב-UTF-7 וב-base64:
בדוגמה זו יש כתובת מקודדת ב-base64 עם ערכת תווים UTF-7. ראשית, מנתח האימייל יפענח את ה-base64. לאחר מכן, מנתח האימייל יפענח את ערכת התווים UTF-7. בסופו של דבר, המייל יפוענח ל-foobar@psres.net. בשלב זה אולי יהיו לכם ספקות לגבי ציות קפדני ל-RFC, במיוחד כשאני אומר לכם שזה עובד גם בחלק של הדומיין כשבדקתי את ספריית Mail. שימו לב שאני משתמש כאן בערכים אלפאנומריים, אך כמובן שניתן לקודד גם כל תו מיוחד.