חזרה לפיד
articlesמקור: Google Project Zero26.2.2026

צלילה עמוקה ל-API בשם GetProcessHandleFromHwnd

אמ;לק

המאמר מנתח את ה-API של Windows בשם GetProcessHandleFromHwnd, שנמצא בשימוש בפרצת UAC bypass. המחבר חוקר את התיעוד הקיים, התנהגותו, ומאפייני האבטחה שלו, ומדגים כיצד ידע מעמיק על APIs פוטנציאליים יכול לחשוף וקטורי תקיפה חדשים במערכות הפעלה.

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

נוסף ל-VibeSec:

כותרת מקורית: A Deep Dive into the GetProcessHandleFromHwnd API

$cat article.txt

>המאמר מנתח את ה-API של Windows בשם GetProcessHandleFromHwnd, שנמצא בשימוש בפרצת UAC bypass. המחבר חוקר את התיעוד הקיים, התנהגותו, ומאפייני…

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

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

בפוסט הקודם שלי בבלוג הזכרתי את ה-API בשם GetProcessHandleFromHwnd. לא ידעתי על קיומו של API זה עד שמצאתי מעקף UAC שנחשף בפומבי באמצעות האפליקציה Quick Assist UI Access. ה-API נראה מעניין, אז החלטתי לבחון אותו מקרוב.

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

עם זאת, אם למתקשר יש הרשאות UIAccess, הוא יכול להשתמש ב-windows hook כדי להזריק קוד לתהליך היעד, ומתוך תהליך היעד לשלוח handle חזרה למתקשר.

GetProcessHandleFromHwnd היא פונקציית עזר המשתמשת בטכניקה זו כדי להשיג handle לתהליך שבבעלותו ה-HWND שצוין.

שימו לב שזה מצליח רק במקרים בהם תהליך המתקשר ותהליך היעד פועלים כאותו משתמש.

הדבר המעניין בהצהרות הללו הוא שאף אחת מהן אינה נכונה במלואה. ראשית, כפי שהוסבר בפוסט הקודם, לא מספיק להפעיל UI Access כדי להשתמש ב-windows hooks; צריך שתהיה לך רמת שלמות (Integrity Level) זהה או גבוהה מזו של תהליך היעד. שנית, אם בוחנים את המימוש של GetProcessHandleFromHwnd ב-Windows 11, מדובר בפונקציית ליבה (kernel) מסוג Win32k שפותחת את התהליך ישירות, ללא שימוש ב-windows hooks. ולבסוף, העובדה שמעקף ה-Quick Assist שמשתמש ב-API הזה עדיין עובד עם Administrator Protection אומרת שהתהליכים יכולים לרוץ כמשתמשים שונים.

כמובן שחלק מאי-הדיוקים העובדתיים עשויים לנבוע משינויים שבוצעו ב-UAC וב-UI Access במהלך השנים שחלפו מאז שוחררה Vista. לכן חשבתי שיהיה מעניין לבצע מעט "ארכיאולוגיית קוד" כדי לראות כיצד ה-API השתנה במהלך השנים, ואולי למצוא התנהגויות מעניינות.

הגרסה הראשונה

הגרסה הראשונה של ה-API קיימת ב-Vista וממומשת בספריית oleacc.dll. התיעוד טוען לתמיכה עוד מ-Windows XP, אך זה לא הגיוני בהתחשב במטרה שלשמה תוכנן ה-API. בדיקה של עותק הספרייה מ-XP SP3 אינה מציגה את ה-API, כך שניתן להניח שהתיעוד שגוי. ה-API מנסה תחילה לפתוח את התהליך ישירות, אך אם זה נכשל, הוא משתמש ב-windows hook בדיוק כפי שתואר בתיעוד.

ספריית oleacc.dll עם ה-hook תיטען לתהליך המשויך לחלון באמצעות ה-API בשם SetWindowsHookEx עם פרמטר ה-thread ID. עם זאת, היא לא תבצע דבר עד שיישלח לחלון הודעה מותאמת אישית בשם WM_OLEACC_HOOK. פונקציית ה-hook נראית בערך כך (הסרתי את בדיקות השגיאות):

⁦void HandleHookMessage ( CWPSTRUCT * cwp ) { UINT msg = RegisterWindowMessage ( L"WM_OLEACC_HOOK" ); if ( cwp -> message != msg ) return ; WCHAR name [ 64 ]; wParam = cwp -> wParam ; StringCchPrintf ( name , _countof ( name ), L"OLEACC_HOOK_SHMEM_%d_%d" , wParam , cwp -> lParam ); HANDLE mapping = OpenFileMapping ( FILE_MAP_READ | FILE_MAP_WRITE , FALSE , name ); DWORD * buffer = ( DWORD * ) MapViewOfFile ( mapping , FILE_MAP_READ | FILE_MAP_WRITE , 0 , 0 , sizeof ( DWORD )); HANDLE caller = OpenProcess ( PROCESS_DUP_HANDLE , FALSE , cwp -> wParam ); HANDLE current = OpenProcess ( PROCESS_DUP_HANDLE | PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE | SYNCHRONIZE , FALSE , GetCurrentProcessId ()); HANDLE dup ; DuplicateHandle ( CurrentProcess , current , caller , & dup , 0 , 0 , DUPLICATE_SAME_ACCESS ); InterlockedExchange ( buffer , ( DWORD ) dup ); // Cleanup handles etc. }⁩

פרמטרי ההודעה הם ה-process ID של המתקשר שרוצה לפתוח את ה-handle של התהליך, ומונה עולה. פרמטרים אלה משמשים לפתיחת מקטע זיכרון (memory section) בעל שם כדי להעביר את ערך ה-handle המשוכפל חזרה למתקשר. לאחר מכן נפתח עותק של ה-handle של התהליך הנוכחי עם סט מוגבל של זכויות גישה, והוא משוכפל למתקשר. לבסוף, ערך ה-handle מועתק לזיכרון המשותף ופונקציית הטיפול בהודעות מסתיימת. כעת המתקשר יכול לקחת את ה-handle המשוכפל ולהשתמש בו כרצונו.

קוד זה עשוי להסביר כמה דברים נוספים על תיעוד ה-API. אם שני התהליכים פועלים כמשתמשים שונים, ייתכן שתהליך היעד לא יוכל לפתוח את תהליך המתקשר עם הרשאת PROCESS_DUP_HANDLE והעברה תיכשל. אף שה-API מגדיר את רמת השלמות של הזיכרון המשותף, הוא לא מגדיר את ה-DACL, כך שזה גם ימנע פתיחה על ידי משתמש אחר. כמובן שאם תהליך היעד פועל כמנהל (Administrator), כמו במקרה של UAC, כמעט בטוח שתהיה לו גישה גם לתהליך המתקשר וגם לזיכרון המשותף, מה שהופך זאת לנקודה חסרת חשיבות.

שינוי קטן אחד בוצע ב-Windows 7: פונקציית ה-hook הועברה מהספרייה הראשית oleacc.dll לקובץ בינארי נפרד בשם oleacchooks.dll. פונקציית ה-hook חשופה כ-ordinal 1 בטבלת הייצוא ללא שם. ה-DLL הזה עדיין קיים בגרסה העדכנית ביותר של Windows 11, למרות שה-API עבר מאז ל-kernel וכבר אין בו שימוש מצד המשתמשים.

הגרסה השנייה

הגרסה השנייה של ה-API הופיעה רק בשלב מאוחר בחייו של Windows 10, בגרסה 1803. בגרסה זו ה-API עבר לפונקציית ליבה מסוג Win32k. ה-API ב-kernel חשוף כ-NtUserGetWindowProcessHandle מתוך win32kfull.sys. הוא ממומש בערך כך:

⁦HANDLE NtUserGetWindowProcessHandle ( HWND hWnd , ACCESS_MASK DesiredAccess ) { WND * wnd = ValidateHwnd ( Wnd ); if ( ! wnd ) { return NULL ; } THREADINFO * curr_thread = W32GetThreadWin32Thread ( KeGetCurrentThread ()); THREADINFO * win_thread = wnd -> Thread ;; if ( curr_thread -> Desktop != win_thread -> Desktop ) { goto access_denied ; } PROCESSINFO * win_process = win_thread -> ppi ; PROCESSINFO * curr_process = curr_thread -> ppi ; if ( gbEnforceUIPI ) { if ( ! CheckAccess ( curr_process -> UIPIInfo , win_process -> UIPIInfo )) { if ( ! curr_process -> HasUiAccessFlag ) { goto access_denied ; } } } else if ( win_thread -> AuthId != curr_thread -> AuthId ) { goto access_denied ; } if ( win_thread -> TIF_flags & ( TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD )) { goto access_denied ; } KPROCESS process = NULL ; DWORD process_id = PsGetThreadProcessId ( win_thread -> KThread ); PsLookupProcessByProcessId ( process_id , & process ); HANDLE handle = NULL ; ObOpenObjectByPointer ( process , 0 , NULL , DesiredAccess , PsProcessType , KernelMode , & handle ); return handle ; access_denied: UserSetLastError ( ERROR_ACCESS_DENIED ); return NULL ; }⁩

דבר אחד שיש לציין לגבי ה-API החדש הוא שהוא מקבל ACCESS_MASK כדי לציין איזו גישה המתקשר רוצה לקבל על ה-handle של התהליך. זה שונה מהמימוש הישן שבו הגישה הרצויה הייתה ערך קבוע. ה-handle של החלון עובר אימות ומשמש לאיתור מבנה ה-THREADINFO של ה-Win32k עבור ה-thread המשויך, ונערכת בדיקה לוודא שגם ה-thread של המתקשר וגם חלון היעד נמצאים על אותו שולחן עבודה (desktop).

לאחר מכן אנו מגיעים לבדיקות האכיפה של UIPI. ראשית, נבדק המשתנה הגלובלי gbEnforceUIPI. אם UIPI מופעל, הפונקציה תקרא לשיטת CheckAccess כדי לראות אם המתקשר מורשה לגשת לתהליך של חלון היעד. אם הבדיקה נכשלת, היא תבדוק אם למתקשר מופעל דגל ה-UI Access; אם לא, הפונקציה תדחה את הגישה, אחרת היא תורשה להמשיך. בדיקת הגישה פשוטה למדי:

⁦BOOLEAN CheckAccess ( UIPI_INFO * Current , UIPI_INFO * Target ) { if ( Current -> IntegrityLevel > Target -> IntegrityLevel ) { return TRUE ; } if ( Current -> IntegrityLevel != Target -> IntegrityLevel ) { return FALSE ; } if ( Current -> AppContainerNo != Target -> AppContainerNo && Current -> AppContainerNo != - 1 && Target -> AppContainerNo != - 1 ) { return FALSE ; } return TRUE : }⁩

אם רמת השלמות של המתקשר גבוהה מזו של היעד, הבדיקה עוברת מיד. אם היא נמוכה מזו של היעד, היא נכשלת מיד. עם זאת, אם רמת השלמות זהה, מתבצעת בדיקה לוודא האם התהליכים נמצאים ב-AppContainer sandbox ושהם נמצאים באותו ארגז חול. אם תהליך אינו נמצא ב-AppContainer, הערך של AppContainerNo מוגדר ל-1-. הבדיקה גם מוודאת שזה לא מאפשר לתהליך ברמת שלמות נמוכה גישה לתהליך AppContainer, שכן כבר קיימת בדיקה שמונעת זאת דרך OpenProcess. אם הכל עובר, הבדיקה מחזירה TRUE.

אם UIPI אינו נאכף, מושווים מזהי האימות (authentication IDs). הפונקציה תאפשר גישה רק אם המתקשר נמצא באותה session של התחברות (logon session), מה שאומר שאם UIPI היה מושבת, זה לא היה מאפשר גישה לתהליכי UAC מורשים. הבדיקה הסופית היא האם ה-thread של היעד נמצא בתהליך מערכת (כלומר, ה-kernel) או בתהליך CSRSS. אם כן, הגישה נדחית.

לבסוף, תהליך היעד נפתח לפי ה-process ID שלו על ידי חיפוש מצביע ה-KPROCESS ואז שימוש ב-ObOpenObjectByPointer כדי לפתוח handle עם הגישה הרצויה. באופן קריטי, מצב הגישה מוגדר ל-KernelMode. המשמעות היא שלא מתבצעות בדיקות גישה על אובייקט התהליך.

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

זו בעיה מיוחדת עבור שני סוגי תהליכים; הראשון הוא תהליכי ארגז חול עם token מוגבל. אף שאולי תניח שזה לא עניין גדול אם שני תהליכים מוגבלים הפועלים באותה רמת שלמות יוכלו לגשת זה לזה, זה לא תמיד המקרה. לדוגמה, Chromium אינו מאפשר ל-renderers לפתוח זה את זה, ולחלק מה-renderers יש הרשאות גבוהות יותר מאחרים, למשל אם הם מרנדרים תוכן WebUI. למרבה המזל, לפחות במקרה זה, ה-renderers רצים תחת נעילת win32k, מה שאומר שהם לא יכולים ליצור חלון גם אם ירצו.

השני הוא תהליכים מוגנים (protected processes). אם תפתח handle לתהליך מוגן עם מצב גישה מוגדר ל-KernelMode, הגישה תאושר תוך עקיפת ההגנה לחלוטין. אולי לא תחשוב שתהליך מוגן ייצור חלון, אך יכול להיות שזהו "חלון להודעות בלבד" (message-only window), למשל לצורך תמיכה ב-COM, שהקוד אולי אפילו לא מודע לכך שיצר.

עם זאת, גם אם למתקשר אין רמת שלמות מתאימה, מספיק שדגל ה-UI Access יהיה מופעל. זה אומר שטריקים כמו התקפת גניבת ה-token שלי יספיקו כדי לפתוח כל תהליך אחר על אותו שולחן עבודה שיצר חלון. בעיה זו דווחה ל-MSRC ותוקנה כ-CVE-2023-41772. המדווח היה אותו חוקר, Sascha Mayer, שמצא את מעקף ה-Quick Assist UI Access שהזכרתי קודם.

הגרסה השלישית

מטרת גרסה זו הייתה לתקן את CVE-2023-41772, ויש בה שני שינויים עיקריים. ראשית והחשוב ביותר: אם בדיקת ה-UIPI נכשלת, הפונקציה עדיין תבדוק אם דגל ה-UI Access מופעל. עם זאת, במקום לאפשר לה להמשיך, היא תאלץ את הקריאה ל-ObOpenObjectByPointer לפתוח handle עם מצב גישה מוגדר ל-UserMode במקום KernelMode.

שימוש ב-UserMode מבטיח שבדיקת הגישה מופעלת. התוצאה הסופית היא שהפעלת דגל ה-UI Access אינה מעניקה הרשאות נוספות מעבר לקריאה ישירה למערכת (system call) מסוג NtOpenProcess. כנראה שזה הושאר כך מטעמי תאימות. עם זאת, זה לא שינה את ההתנהגות כאשר רמת השלמות של המתקשר גבוהה או שווה לזו של היעד; אובייקט התהליך עדיין ייפתח עם מצב גישה מוגדר ל-KernelMode. המשמעות היא שכשמדובר ב-sandboxes עם token מוגבל או בתהליכים מוגנים, שום דבר לא השתנה.

#windows-security#api-analysis#uac-bypass#exploit-research
קרא במקור