שרשרת ניצול 0-קליקים עבור Pixel 9 חלק 2: פריצת SandBox עם Big Wave
אמ;לק
המאמר ממשיך את סדרת הבלוגים על ניצולPixel 9 ומתמקד בפריצת ה-sandbox של אנדרואיד. הוא מתאר כיצד ניתן לנצל דרייבר התקן נגיש, /dev/bigwave, מתוך הקשר ה-mediacodec ה'מבודד'. הניתוח חושף דרכים לעקוף מגבלות אבטחה ולגשת למשאבי מערכת נוספים, פריצת דרך משמעותית בשרשרת הניצול.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: A 0-click exploit chain for the Pixel 9 Part 2: Cracking the Sandbox with a Big Wave
>המאמר ממשיך את סדרת הבלוגים על ניצולPixel 9 ומתמקד בפריצת ה-sandbox של אנדרואיד. הוא מתאר כיצד ניתן לנצל דרייבר התקן נגיש, /dev/bigwave…
התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
עם הופעתו של ניצול RCE פוטנציאלי ב-Dolby Unified Decoder, נראה היה נבון לבדוק אילו מנהלי התקנים (drivers) של ליבת Linux עשויים להיות נגישים מהקשר ה-userland שנוצר, כלומר ההקשר של mediacodec. בהתאם לתיעוד AOSP, הקשר ה-SELinux של mediacodec נועד להיות הקשר מוגבל (המכונה ארגז חול) שבו נעשה שימוש במפענחי תוכנה לא מאובטחים. עם זאת, באמצעות הכלי DriverCartographer שלי, גיליתי מנהל התקן מעניין, /dev/bigwave, שהיה נגיש מהקשר ה-SELinux של mediacodec. BigWave הוא חומרה הקיימת ב-Pixel SOC שמאיצה משימות פענוח AV1, מה שמסביר מדוע היא נגישה מהקשר ה-mediacodec. כפי שמחקרים קודמים אישרו שוב ושוב, מנהלי התקנים של Android עבור רכיבי חומרה הם מקור מצוין למציאת באגים עוצמתיים של הסלמת הרשאות מקומיות (LPE). הדרייבר BigWave לא היה יוצא מן הכלל - לאחר כמה שעות של ביקורת קוד, גיליתי שלושה באגים נפרדים, כולל אחד שהיה חזק מספיק כדי לברוח מארגז החול של mediacodec ולהשיג יכולת קריאה/כתיבה שרירותית בקרנל ב-Pixel 9.
ציד הבאגים (הקצר מאוד)
הבאג הראשון שמצאתי היה כפילות שדווחה במקור בפברואר 2024 אך נותרה ללא תיקון בזמן הגילוי מחדש ביוני 2025, יותר משנה לאחר מכן, למרות שהתיקון דרש בסך הכל היפוך של שתי שורות קוד. הבאג השני הציג מחלקת באגים מרתקת באמת, המקבילה לפרימיטיב הניצול של double-free ב-kmalloc - אך עם רשימה מקושרת שונה לחלוטין. עם זאת, הבאג השלישי שגיליתי הוא זה שיצר את פרימיטיב הניצול הטוב ביותר. תיקונים עבור כל שלושת הבאגים פורסמו ב-5 בינואר 2026.
הבאג הטוב ביותר
בכל פעם שהמכשיר /dev/bigwave נפתח, הדרייבר מקצה מבנה ליבה (kernel struct) חדש בשם inst המאוחסן בשדה private_data של ה-fd. בתוך ה-inst קיים מבנה משנה בשם job, העוקב אחר ערכי הרגיסטרים והסטטוס המשויכים להפעלה בודדת של חומרת BigWave לצורך ביצוע משימה. כדי להגיש עבודה לחומרת ה-bigo, תהליך משתמש ב-ioctl מסוג BIGO_IOCX_PROCESS, אשר שואב את ערכי הרגיסטרים של Bigwave מה-caller של ה-ioctl ב-AP userland, ומציב את ה-job בתור שנקלט ומעובד על ידי שרשור נפרד, ה-bigo_worker_thread. המשמעות היא שאובייקט שאורך חייו קשור מטבעו ל-file descriptor נגיש באופן חולף בשרשור ליבה נפרד שאינו מסונכרן באופן מפורש לקיומו של אותו file descriptor. במהלך הטיפול ב-ioctl מסוג BIGO_IOCX_PROCESS, לאחר הגשת עבודה לביצוע ב-bigo_worker_thread, קריאת ה-ioctl נכנסת ל-wait_for_completion_timeout עם פסק זמן של 16 שניות בהמתנה לכך ש-bigo_worker_thread ישלים את העבודה. לאחר 16 שניות אלו, אם bigo_worker_thread לא סימן שהעבודה הושלמה, תקופת ההמתנה מסתיימת וה-ioctl מוציא את ה-job מתור העדיפויות. עם זאת, אם מספר רב מספיק של עבודות קודמות נערמו ב-bigo_worker_thread, ייתכן ש-bigo_worker_thread התעכב עד כדי כך שהוא רק עתה הוציא מהתור ובמקביל מעבד את בדיוק את אותה עבודה שה-ioctl החשיב ככזו שפג זמנה וכעת מנסה להוציא מהתור. במקרה זה, הקשר ה-syscall פשוט חוזר ל-userland, ואם בשלב זה ה-userland סוגר את ה-fd המשויך למופע ה-BigWave, ה-inst (ובכך גם ה-job) מושמד בזמן ש-bigo_worker_thread ממשיך להתייחס ל-job.
ההדגשות מציינות כל גישה לאובייקט ה-UAF:
static int bigo_worker_thread ( void * data ) { ... while ( 1 ) { rc = wait_event_timeout ( core -> worker , dequeue_prioq ( core , & job , & should_stop ), msecs_to_jiffies ( BIGO_IDLE_TIMEOUT_MS )); //The job is fetched from the queue ... inst = container_of ( job , struct bigo_inst , job ); //The job is an inline struct inside of the inst which gets UAF'd ... rc = bigo_run_job ( core , job ); ... job -> status = rc ; complete ( & inst -> job_comp ); } return 0 ; } ... static int bigo_run_job ( struct bigo_core * core , struct bigo_job * job ) { ... inst = container_of ( job , struct bigo_inst , job ); bigo_bypass_ssmt_pid ( core , inst -> is_decoder_usage ); bigo_push_regs ( core , job -> regs ); //The register values of the bigwave processor are set (defined by userland) bigo_core_enable ( core ); ret = wait_for_completion_timeout ( & core -> frame_done , msecs_to_jiffies ( core -> debugfs . timeout )); //pause for 1 second ... //At this point inst/job have been freed bigo_pull_regs ( core , job -> regs ); //A pointer is taken directly from the freed object * ( u32 * )( job -> regs + BIGO_REG_STAT ) = status ; if ( rc || ret ) rc = - ETIMEDOUT ; return rc ; }
void bigo_pull_regs ( struct bigo_core * core , void * regs ) { memcpy_fromio ( regs , core -> base , core -> regs_size ); //And the current register values of the bigwave processor are written to that location }
על ידי ריסוס הקצאות kmalloc הנשלטות על ידי התוקף (לדוגמה באמצעות הודעות Unix Domain Socket), אנו יכולים לשלוט במצביע ה-UAF הבסיסי job->regs, כך שנוכל לשלוט ביעד הכתיבה שלנו. בנוסף, מכיוון שאנו מגדירים את הרגיסטרים בתחילת הביצוע, על ידי הגדרת הרגיסטרים בצורה כזו שהמעבד BigWave לא יבצע פעולה כלל, אנו יכולים להבטיח שמצב הרגיסטרים הסופי יהיה כמעט זהה למצבם המקורי - ומכאן שנוכל לשלוט גם על מה שנכתב. וכך בדיוק, יש לנו יכולת כתיבה שרירותית של 2144 בתים! והכל בלי להדליף את ה-KASLR slide!
הבסת KASLR (בלי לעשות כלום)
ניצול בעיה זו כאשר KASLR מופעלת היה דורש בדרך כלל הקצאה מחדש של אובייקט אחר על גבי ה-bigo inst עם מצביע במיקום של inst->job.regs, מה שמוביל להשחתת זיכרון של האובייקט שאליו מצביע אותו מצביע חופף. זה היה דורש מציאת אובייקט שניתן להקצאה עם מצביע במיקום זה, וגם מציאת דרך לנצל את היכולת לדרוס את אובייקט המשנה. מציאת אובייקט כזה היא קשה אך לא בלתי אפשרית, במיוחד אם לוקחים בחשבון התקפות cross-cache. עם זאת, זה תהליך די מייגע ולא באמת הרעיון שלי לזמן מהנה. למרבה המזל, מצאתי אסטרטגיה פשוטה הרבה יותר המאפשרת למעשה עקיפה גנרית של KASLR ב-Pixel בשלמותה, על פרטיה תוכלו לקרוא בפוסט הקודם שלי בבלוג. התוצאה הסופית של ה-sidequest הזה היא הגילוי שבמקום להזדקק להדלפת ה-KASLR base, אפשר פשוט להשתמש ב-0xffffff8000010000, במיוחד כשמדובר בדריסת .data בקרנל. זה מפשט באופן דרמטי את הניצול ומשפר משמעותית את האמינות הפוטנציאלית שלו.
יצירת קריאה/כתיבה שרירותית
בשלב זה, יש לי פרימיטיב כתיבה שרירותי ברובו בכל מקום ב-.data של הקרנל - יש לי מיקום כינוי (aliased) עבור, ואני יכול לשנות, כל משתנה גלובלי של הליבה שאני רוצה. עם זאת, הקריאה ל-complete בסוף לולאת ביצוע העבודה ב-bigo_worker_thread מסבכת מעט את הניצול. הקריאה ל-complete מפעילה את swake_up_locked שמבצע סדרה של פעולות רשימה על צומת list_head בתוך ה-bigo inst:
static inline int list_empty ( const struct list_head * head ) { return READ_ONCE ( head -> next ) == head ; } void swake_up_locked ( struct swait_queue_head * q ) //The q is located at &inst->job_comp.wait (so attacker controlled) { struct swait_queue * curr ; if ( list_empty ( & q -> task_list )) return ; curr = list_first_entry ( & q -> task_list , typeof ( * curr ), task_list ); wake_up_process ( curr -> task ); list_del_init ( & curr -> task_list ); }
בעוד שהקריאה הראשונה ל-list_empty תהיה הפשוטה ביותר לזיוף, היא גם תדרוש לדעת את המיקום של ה-inst בזיכרון הליבה, שכן q הוא מבנה מוטבע בתוך ה-inst. למרבה הצער, עקיפת ה-KASLR שלנו לא נותנת לנו זאת, וזה גם לא קל במיוחד להשגה, מכיוון שה-inst נמצא ב-kernel heap, לא ב-.data של הקרנל. זה אומר שאנחנו צריכים במקום זאת לזייף ערך רשימה חוקי שה-q יצביע עליו, וכן לדעת את המיקום של משימה להעביר ל-wake_up_process(). לבסוף, עלינו לזייף מספיק רשימה כדי לשרוד את list_del_init על ערך ב-q->task_list, מה שכולל צמתי רשימה ראשונים, וצמתי רשימה שניים שמצביעים על צומת הרשימה הראשון. זה אולי נשמע קשה מאוד לזיוף בהתחשב במגבלה שציינו קודם לגבי עקיפת ה-KASLR שלנו, אך למעשה, זה לא כל כך נורא, מכיוון שהכתיבה השרירותית שלנו כבר התרחשה בשלב זה - אז אנחנו יודעים את המיקום של הזיכרון שאנו שולטים בו איפשהו ב-.data של הקרנל. המשמעות היא שאנחנו יכולים לזייף צמתי רשימה שרירותיים בתוך המרחב הזה ב-.data, ואנחנו יכולים להציב מצביעים לאותם צמתי רשימה מזויפים עתידיים בתוך ה-heap spray המקורי שבו אנו משתמשים כדי להחליף את ה-inst. אנחנו גם יודעים את המיקום של מבנה משימה בודד במרחב הכתובות הווירטואלי של הקרנל - משימת ה-init! מבנה המשימה של init נמצא ב-.data של הקרנל, כך שנוכל להפנות אליו דרך ה-linear map. קריאת wake_up_process מזויפת על ה-init_task תהיה חסרת משמעות לחלוטין ותמנע התרסקות. תוכלו לראות את הקוד להגדרת צמתי רשימה מקושרת אלו ב-setup_linked_list ב-exploit.
לאחר שהמחסום הזה נפתר, הגיע הזמן להבין למה ב-.data למקד עם הכתיבה השרירותית שלנו. המטרה שלנו היא לשנות את הכתיבה השרירותית הלא מהימנה שלנו של 2144 בתים ל-read/write שרירותי ואמין שגורם לנזק נלווה פחות משמעותי לזיכרון שמסביבו. החלטתי לנסות ליישם מחדש את האסטרטגיה שהנדסתי לאחור מניצול ITW לפני כמה שנים. טכניקה זו כוללת יצירת בלבול סוגים (type-confusion) על ידי החלפת חלק ממטפלי ה-VFS/fops במבנה הנתונים ashmem_misc במטפלי VFS אחרים עבור סוגי קבצים אחרים. למעשה, בגלל CFI אינך יכול להחליף את מצביעי פונקציות המטפל במצביעים לכל מיקום ב-.text של הקרנל. עליך להחליף את מטפלי ה-VFS במטפלי VFS אחרים. עם זאת, בצורה נוחה למדי, אני יכול להשתמש במטפלי VFS של configfs עבור הניצול שלי, בדיוק כמו בניצול ה-ITW. הפריסה הסופית של טבלת ה-fops וה-private_data של ה-struct file נראים כך:
המטפלים של fops בצבע ירוק יגשו למבנה private_data כמבנה ashmem_area (או asma), בעוד שמטפלי ה-fops בצבע צהוב ניגשים לאותו מבנה private_data כמאגר (buffer) של configfs. עבור מטפלי ה-configfs fops, תתבצע גישה לזיכרון שאליו מצביע ה-page - שם נרצה שהקריאה/כתיבה השרירותית שלנו תפעל. נגדיר את היעד שלנו באמצעות ה-ioctl מסוג ASHMEM_SET_NAME.
סיבוך נוסף אחד, לעומת זאת, הוא שהמיפוי הליניארי של ה-.text של הקרנל אינו בר-הרצה (executable), לכן איני יכול להשתמש בכתובות מה-linear map של אזור ה-.text עבור מטפלי ה-VFS בעת זיוף מבנה הנתונים ashmem_misc שלי. בפועל, לא קשה במיוחד להדליף את ה-KASLR slide בפועל. לפני המיקוד ב-ashmem_misc, אני משתמש תחילה בכתיבה השרירותית שלי כדי למקד את האובייקט sel_fs_type ב-.data של הקרנל. למבנה זה יש מחרוזת, name, שמודפסת בעת קריאת /proc/self/mounts. על ידי החלפת מצביע המחרוזת הזה באמצעות הכתיבה השרירותית שלי, ולאחר מכן קריאת /proc/self/mounts, אני יכול להפוך את הכתיבה השרירותית הלא אמינה שלי לקריאה שרירותית! באמצעות קריאה שרירותית זו, אני יכול לקרוא את מבנה ה-ashmem_fops (גם דרך ה-linear map), מה שנותן לי מצביעים בהיסט (offset) מבסיס הקרנל, ומאפשר לי לחשב את ה-KASLR slide.
לאחר מכן אני מבצע את הכתיבה השרירותית שלי שוב כדי לדרוס את מבנה ה-ashmem_misc עם מצביע לטבלת ashmem_fops מזויפת חדשה שאני בונה בו-זמנית - זה היתרון בדריסת נתונים בהיקף גדול בהרבה ממה שאני באמת צריך.