לשבור את מחסום הסאונד, חלק ב': ניצול CVE-2024-54529
אמ;לק
חלק זה מתאר את תהליך הניצול המורכב של פגיעות מסוג Type Confusion (CVE-2024-54529) ב-macOS. הפגיעות התגלתה בשרת ה-coreaudiod באמצעות טכניקת 'knowledge-driven fuzzing'. המאמר מתמקד בפרטים הטכניים של היישום ומסביר כיצד להפוך פגיעות זו לכדי ניצול אפקטיבי במערכת ההפעלה.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: Breaking the Sound Barrier, Part II: Exploiting CVE-2024-54529

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
בחלק הראשון של סדרה זו, פירטתי את המסע שלי אל מחקר האבטחה של macOS, אשר הוביל לגילוי פגיעות של בלבול מסוג (CVE-2024-54529) ופגיעות כפולה חופשית (double-free) (CVE-2025-31235) בדמון המערכת coreaudiod, באמצעות תהליך שאני מכנה knowledge-driven fuzzing. בעוד הפוסט הראשון התמקד בתהליך מציאת הפגיעויות, הפוסט הזה צולל לתוך התהליך המורכב של ניצול פגיעות הבלבול מסוג (type confusion).
אסביר את הפרטים הטכניים של הפיכת קריסה (crash) שניתן לנצלה לניצול עובד: מסע מלא במבוי סתום, פתרון בעיות יצירתי ובסופו של דבר, הצלחה.
הפגיעות: סיכום מהיר
אם עדיין לא עשית זאת, אני ממליץ בחום לקרוא את הכתבה המפורטת שלי על הפגיעות הזו לפני שתמשיך.
לרענון, CVE-2024-54529 היא פגיעות של בלבול מסוגים (type confusion) בתוך שירות ה-Mach שנקרא com.apple.audio.audiohald, הממוקם ב-framework שנקרא CoreAudio ומשמש את תהליך coreaudiod. מספר מטפלי הודעות Mach, כגון _XIOContext_Fetch_Workgroup_Port, היו שולפים HALS_Object מתוך ה-Object Map על סמך מזהה (ID) מהודעת ה-Mach, ולאחר מכן מבצעים עליו פעולות בהנחה שהוא מסוג מסוים (ioct) ללא אימות מתאים. הנחה שגויה זו הובילה לקריסה כאשר הקוד ניסה לבצע קריאה וירטואלית על אובייקט שהמצביע שלו מאוחסן בתוך ה-HALS_Object, כפי שמוצג במעקב המחסנית (stack trace) להלן:
Process 82516 stopped * thread # 8, queue = 'com.apple.audio.system-event' , stop reason = EXC_BAD_ACCESS ( code = 1, address = 0xffff805cdc7f7daf ) frame # 0: 0x00007ff81224879a CoreAudio _XIOContext_Fetch_Workgroup_Port + 294 CoreAudio_XIOContext_Fetch_Workgroup_Port: 0x7ff81224879a <+291> : mov rax, qword ptr [ rdi] -> 0x7ff81224879d <+294>: call qword ptr [ rax + 0x168] 0x7ff8122487a3 <+300> : mov dword ptr [ rbx + 0x1c], eax 0x7ff8122487a6 <+303> : mov rdi, r13 (lldb) bt * thread # 8, queue = 'com.apple.audio.system-event' , stop reason = EXC_BAD_ACCESS ( code = 1, address = 0xffff805cdc7f7daf ) * frame # 0: 0x00007ff81224879a CoreAudio _XIOContext_Fetch_Workgroup_Port + 294 frame # 1: 0x00007ff812249c81 CoreAudio[6 [2] מסגרת # 3: 0x00007ff811f202ed CoreAudio invocation function for block in AMCP::Utility::Dispatch_Queue::install_mig_server ( unsigned int, unsigned int, unsigned int ( * )( mach_msg_header_t * , mach_msg_header_t * ) , bool, bool ) + 42 frame # 4: 0x00007ff80f33e7e2 libdispatch.dylib _dispatch_client_callout + 8 frame # 5: 0x00007ff80f34136d libdispatch.dylib _dispatch_continuation_pop + 511 frame # 6: 0x00007ff80f351c83 libdispatch.dylib _dispatch_source_invoke + # 207: 0x00007ff80f3447ba libdispatch.dylib _dispatch_lane_serial_drain + 322 frame # 8: 0x00007ff80f3453e2 libdispatch.dylib _dispatch_lane_invoke + 377 frame # 9: 0x00007ff80f346393 libdispatch.dylib _dispatch_workloop_invoke + 782 frame # 10: 0x00007ff80f34f0db libdispatch.dylib _dispatch_lane_invoke + 377 frame # 9: 0x00007ff80f346393 libdispatch.dylib _dispatch_workloop_invoke + 782 frame # 10: 0x00007ff80f34f0db libdispatch.dylib _dispatch_root_queue_de 1 0x00007ff80f34e9dc libdispatch.dylib _dispatch_workloop_worker_thread + 659 frame # 12: 0x00007ff80f4e2c7f libsystem_pthread.dylib _pthread_wqthread + 326 frame # 13: 0x00007ff80f4e1bdb libsystem_pthread.dylib start_wqthread + 15
הבנת היעד
ניצול פגיעות שכזו נראה פשוט למדי: אם נוכל לשלוט בכתובת שממנה מבוצע ה-dereference בהיסט 0x168 של אוגר ה-rax, נוכל להשתלט על זרימת הבקרה (control flow). אבל זה לא היה כל כך פשוט. ה-HALS_Object שהובא מהערימה (heap) עבר dereference מספר פעמים לפני שהוראת ה-call התרחשה:
לפיכך, הניצול דרש הקמת שרשרת מצביעים. ראשית, היינו צריכים להגדיר ערך בהיסט 0x68 של HALS_Object שיצביע על אזור בזיכרון שאנו שולטים בו. אזור זה, בתורו, היה צריך להכיל מצביע בהיסט 0x0 שלו, שיצביע על vtable מזויף, שגם הוא בשליטתנו. עם השרשרת הזו במקום, נוכל לכתוב את כתובת היעד שלנו בהיסט 0x168 של ה-vtable המזויף כדי לחטוף את זרימת הבקרה. הגישה תיראה כך:
ניסיונות ניצול ראשוניים והמשוכה של CFString
הנתיב הישיר ביותר לניצול נראה כמציאת API לכתיבת נתונים שרירותיים להיסט הפגיע (0x68) של HALS_Object. המחשבה הראשונית שלי הייתה ליצור אובייקט CFString ולמצוא דרך להציב מצביע אליו בהיסט הפגיע של HALS_Object.
מצאתי API שנראה מתאים ב-coreaudiod שאוכל לקרוא לו, אשר יקבע את ההיסט 0x68 ל-CFString הנשלט על ידי התוקף:
עם זאת, גישה זו נתקלה במהירות בקיר. לסוג CFString יש כותרת (header) שלא ניתן לשלוט בה, מה שאומר שלמרות שיכולתי לשלוט בתוכן של ה-CFString, לא יכולתי לשלוט בכותרת של האובייקט. כדי שהניצול הזה יעבוד, הייתי צריך שהנתונים בהיסט 0x0 של ה-CFString יהיו מצביע לנתונים ששלטתי בהם. הכותרת של CFString הפכה את זה לבלתי אפשרי.
זה אומר שהייתי צריך גישה חדשה. הייתי צריך למצוא דרך אחרת לשלוט בזיכרון בהיסט הפגיע.
כלי העבודה
כאשר הניסיונות הראשוניים שלי למצוא פרימיטיב אובייקט מתאים לא הניבו תוצאות, התברר שאני זקוק לדרך טובה יותר לדמיין את ה-heap של coreaudiod ולהבין את האובייקטים החיים בו. לשם כך, בניתי מספר כלים מותאמים אישית.
השימושי ביותר שבהם היה כלי להשלכת אובייקטים (object dumper) מותאם אישית שכתבתי באמצעות TinyInst Hook API של Ivan Fratric. כלי זה התחבר לתהליך ועבר על הרשימה המקושרת של ה-HALS_ObjectMap, כשהוא משליך (dumping) את התוכן הגולמי, הגודל, הסוג ותת-הסוג של כל HALS_Object שנמצא כעת ב-heap. זה נתן לי שיטה רבת עוצמה לבחון את ההרכב של כל אובייקט, לחפש נתונים שניתן לשלוט בהם, ולראות אם כבר קיימים מצביעים מעניינים בהיסט הקריטי 0x68.
לצד כלי הניתוח הדינמי הזה, השתמשתי בסקריפט IDAPython כדי לבצע ניתוח סטטי ממוקד, בחיפוש אחר נתיבי קוד שכותבים להיסטים בעלי עניין לאחר שאובייקט נשלף באמצעות CopyObjectByObjectID. שילוב זה של ניתוח דינמי וסטטי היה חיוני למיפוי שיטתי של משטח הניצול.
כפיית קריאות מחוץ לתחום (Out-of-Bounds) ב-Heap
חמוש בכלי שלי, החלטתי לחקור נתיב ניצול פוטנציאלי נוסף. אם לא הצלחתי למצוא דרך לכתוב מצביע ישירות להיסט 0x68, אולי אוכל להפעיל קריאה מחוץ לתחום (out-of-bounds read) כדי להשיג אפקט דומה.
הרעיון היה למצוא HALS_Object הקטן מ-0x68 בתים, ליצור אותו ב-heap, ולאחר מכן להציב בזהירות אובייקט שני, הנשלט על ידי התוקף, מיד אחריו בזיכרון. אם לאחר מכן אפעיל את הבלבול מסוג (type confusion) על האובייקט הראשון (הקטן יותר), הניסיון של הקוד לקרוא מהיסט 0x68 יקרא מעבר לגבולות האובייקט ואל תוך הנתונים המבוקרים של האובייקט השני.
לרוע המזל, כלי השלכת האובייקטים והניתוח הסטטי שלי הוכיחו במהירות שזהו מבוי סתום. לאחר קטלוג כל סוגי האובייקטים, היה ברור שלא קיים אובייקט קטן מ-0x68 בתים. בגרסה האחרונה של macOS שהייתה זמינה במהלך המחקר שלי (macOS Sequoia 15.0.1), סוג האובייקט הקטן ביותר, stap, היה בגודל 0x70 בתים.
מעניין שגרסאות קודמות של macOS שבדקתי (כולל macOS Ventura 13.1) אכן הכילו HALS_Objects קטנים יותר, מה שמוכיח שהבדלים בגרסאות תוכנה יכולים לעיתים להכניס פרימיטיבים חדשים לניצול.
כאשר אפשרות הקריאה מחוץ לתחום בוטלה, הפוקוס שלי עבר חזרה למניפולציה של ה-heap ולמציאת דרך לשלוט ישירות בתוכן של הקצאת אובייקט.
ניצוץ של תקווה: זיכרון לא מאותחל באובייקט ngne
כדי לחפש פרימיטיבים אחרים לניצול, פניתי לכלי ניפוי באגים רב עוצמה ב-macOS: Guard Malloc עם האפשרות PreScribble מופעלת. תכונה זו מאתחלת בלוקים של זיכרון שהוקצו זה עתה עם תבנית בתים ספציפית (0xAA), מה שמקל על זיהוי כאשר אובייקטים אינם מאופסים כראוי ועלולים להוביל לשימוש בזיכרון לא מאותחל.
בהרצת coreaudiod עם הגדרות אלו, גיליתי סוג אובייקט בשם ngne, שהיה בעל תכונה מוזרה: חלק מהזיכרון של האובייקט לא היה מאותחל. באופן ספציפי, 6 בתים גבוהים של שדה בגודל מצביע בהיסט הנכון לא נוקו בעת ההקצאה, מה שהשאיר אותם עם תבנית ה-0xAA מ-PreScribble.
זה היה שינוי משמעותי. פגיעות של זיכרון לא מאותחל יכולה לספק את הפרימיטיב שהייתי צריך כדי להשיג שליטה על המצביע בהיסט הפגיע.
האילוץ המורכב
אתם שואלים למה רק 6 בתים לא מאותחלים? סביר להניח שהמפתח עשה משהו כזה בהיסט 0x68 בעת הגדרת אובייקט ה-ngne:
class NGNE { ... size_t previous_var ; // offset 0x60 short var = 0 ; // offset 0x68 size_t next_var ; // offset 0x70 ... }
זה קורה בגלל שהמהדר (compiler) מיישר משתנים של 8 בתים, כמו size_t בארכיטקטורת x64, לגבולות של 8 בתים לצורך אופטימיזציה. כתוצאה מכך, המשתנה short גורם ל-next_var להיות ממוקם בהיסט 0x70 במקום מיד אחרי var ב-0x6A, מה שמשאיר פער של 6 בתים לא מאותחלים.
אילוץ זה הופך את הדברים לקצת מסובכים. גם אם נוכל לגרום לזיכרון מבוקר להופיע בתוך האובייקט, 2 הבתים האחרונים יאופסו.
אסטרטגיית ניצול חדשה
חמוש בידע החדש הזה, גיבשתי אסטרטגיית ניצול חדשה ומורכבת יותר:
• Allocate Controlled Data : מצא דרך להקצות כמויות גדולות של נתונים שאני שולט בהם בתהליך coreaudiod.
• Create Indirect Pointers : צור מצביעים עקיפים המצביעים על הנתונים המבוקרים שלי.
• Reuse Pointers : להערים על התוכנית לעשות שימוש חוזר בזיכרון המכיל מצביעים כאשר אובייקט ה-ngne מוקצה.
Heap Feng Shui עם Property Lists
כדי לשלוט בחלקים גדולים של הזיכרון, פניתי למאפיין נפוץ ב-APIs של Apple: Property Lists. ממשקי API רבים מקבלים נתוני משתמש כקבצי plist שעברו סריאליזציה, אשר לאחר מכן עוברים דה-סריאליזציה (deserialized) ומקצים זיכרון עבור אובייקטי CoreFoundation. CoreAudio חשף API, HALS_Object_SetPropertyData_DPList, שעשה בדיוק את זה ואחסן אותו ב-heap:
Plist מאפשר לך לציין ערכים מקוננים ממספר סוגים:
זה אומר שיכולתי ליצור קבצי plist עם מערכים גדולים של אובייקטי CFString או CFData, מה שנתן לי פרימיטיב רב עוצמה להקצאת נתונים המונית ושליטה בפריסת ה-heap. יתרה מכך, יכולתי להוסיף אובייקטי CFArray או CFDictionary כדי להשיג את העקיפה (indirection) הדרושה לניצול, שכן סוגי נתונים אלה מכילים מצביעים לאובייקטים אחרים הנשלטים על ידי המשתמש.
המבנה הכללי ייראה כך:
אבל אולי אתם תוהים: האם זה לא מציג בעיה דומה לזו שנתקלנו בה כשניסינו להקצות מצביע ל-CFString? (שרשרת המצביעים תנסה לבצע dereference לכותרת ה-CFRuntimeBase ותיכשל). כן! אבל באופן אירוני, הניקוי של 2 הבתים האחרונים בהיסט 0x68 פתח אפשרות חדשה: אולי נוכל להקצות אובייקט על גבי מצביע CFString באמצע המערך, שאחרי ניקוי 2 הבתים האחרונים, יצביע על נתונים גולמיים. זה נראה כמו סיכוי קלוש, אבל הייתי מוכן לאתגר!
שחרור הנתונים
לאחר מכן, הייתי צריך לשחרר את מבנה הזיכרון שהוקצה עם הנתונים שלי. זה היה קל למדי - פשוט הייתי צריך לקרוא ל-API שוב עם קובץ plist קטן בהרבה. אז, מבנה ה-plist הגדול והמוקצה שלי שוחרר.
שימוש חוזר בנתונים המשוחררים באובייקט ngne
לאחר הנדסה לאחור כואבת, מצאתי דרך ליצור אובייקטי ngne לפי דרישה על ידי שליחת הודעת Mach מותאמת לשירות audiohald. חשבתי שאני נמצא בישורת האחרונה. התוכנית שלי הייתה לרסס את ה-heap, לשחרר את הזיכרון, ואז מיד להקצות את אובייקט ה-ngne שלי כדי להשתלט עליו מחדש.
אבל מהר מאוד נתקלתי במחסום מהותי ומתסכל: malloc zones.
אובייקטי ה-ngne שיכולתי ליצור היו בגודל של 776 בתים, מה שהציב אותם ישירות באזור הזיכרון malloc_tiny. זו הייתה בעיה קריטית מכיוון שכהפחתת אבטחה, מקצה הזיכרון של macOS מאפס באופן מאובטח כל זיכרון באזור malloc_tiny בעת ההקצאה. ספריי ה-heap המעוצב בקפידה שלי היה נמחק רגעים לפני שהאובייקט ngne היה מונח על גביו.