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

טכניקות תקיפה חדשות ב-Windows (Dangling COM)

אמ;לק

חוקרי אבטחה גילו שיטה לעקוף הרשאות ב-Windows דרך אובייקטי COM לא מנוהלים. מדובר בשיפור של פרצה קודמת שחייב את תשומת לב מנהלי ה-IT.

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

נוסף ל-VibeSec:

כותרת מקורית: Windows Exploitation Techniques: Dangling COM Object Registrations

טכניקות תקיפה חדשות ב-Windows (Dangling COM)

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

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

פוסט קצר זה בבלוג עוסק בניצול של באג להסלמת הרשאות ש-Microsoft תיקנה לאחרונה ב-Windows, תחת המזהה CVE-2026-66804, עליו דיווחתי יחד עם 14 אחרים. בעיה זו מהווה תיקון חלקי עבור CVE-2026-50343, באג שזכה לכינוי "Dark Elevator" על ידי Calif.

סיבת השורש של הבאג הייתה רישום "תלוי" (dangling) של אובייקט COM מסוג CrossDevice, בעל ה-CLSID {E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}. רישום COM מצריך בדרך כלל שני חלקים: קובץ הרצה של שרת (עבור רכיבי in-process מדובר בקובץ DLL) וערך CLSID תחת מפתח הרישום HKEY_CLASSES_ROOT, המצביע על אותו קובץ DLL.

אובייקט זה נרשם במפתח המחלקות הכלל-מערכתי, כלומר היה נגיש לכל המשתמשים במערכת, כולל שירותי המערכת. עם זאת, קובץ ההרצה של השרת היה חסר. באופן ספציפי, הוא נרשם לשימוש ב-DLL בנתיב %PROGRAMDATA%\CrossDevice\CrossDevice.Streaming.Source.dll. לא רק שהנתיב הזה לא קיים, הוא גם נמצא בתוך הספרייה C:\ProgramData. זהו מיקום משותף לכל המשתמשים במערכת, ולכן הוא מאפשר לכל אחד ליצור ספריות בו. לפיכך, ניתן ליצור קובץ DLL שרירותי במיקום זה, מה שמאפשר ליצור מופע של אובייקט ה-COM ועלול להוביל להסלמת הרשאות.

אבל איך גורמים לאובייקט ה-COM, ובכך ל-DLL, להיטען לתהליך בעל הרשאות גבוהות? הבאג המתוקן ש-Calif כתב עליו בבלוג, CVE-2026-50343, עשה שימוש לרעה בהרשאות חלשות של מפתח רישום כדי להוסיף את המחלקה כפלאגין למתקין (installer plugin), ולאחר מכן לגרום ל-InstallService לטעון אותה לזיכרון. הבעיה ב-InstallService תוקנה, לכן אנו זקוקים לדרך חלופית לנצל את הפניית ה-COM התלויה שנותרה ללא תיקון.

ניצול חוזר של Custom COM Marshaling

טכניקה שהשתמשתי בה מספר פעמים בעבר כדי לטעון DLL שרירותי לתהליך מיוחס היא שימוש לרעה ב-custom COM marshaling. כאשר קוראים לשיטת ממשק שמיושמת מחוץ לתהליך, זמן הריצה (runtime) של COM מבצע marshaling לפרמטרים לתוך קריאת RPC כדי לשלוח אותם לשרת. אם פרמטר הוא אובייקט COM, זמן הריצה מבצע marshaling לאובייקט זה לתוך מבנה OBJREF שמאפשר להשתמש באובייקט בשרת. שני הסוגים העיקריים של OBJREFs מוצגים בתרשים להלן, או שניתן לקרוא עליהם בתיעוד הרשמי של DCOM כאן:

אסטרטגיית ה-marshaling כברירת מחדל ב-COM היא לפי הפניה (by reference), שמייצרת Standard OBJREF המכיל את כל המידע הדרוש כדי להתחבר לאובייקט המקורי. האובייקט עשוי להימצא אפילו במחשב אחר לגמרי. כאשר האובייקט עובר unmarshaling, מידע זה משמש ליצירת ערוץ RPC חזרה אל הקורא, כך שהשרת יוכל להפעיל שיטות על האובייקט.

זמן הריצה תומך גם במנגנון אופציונלי של marshal by value, אם האובייקט מיישם את ממשק IMarshal. זה מאפשר לאובייקט לציין CLSID שרירותי לשימוש כאובייקט ה-unmarshaling, שאינו חייב להיות זהה לאובייקט המועבר. כאשר האובייקט עובר unmarshaling בשרת, ה-CLSID משמש לחיפוש קובץ DLL של שרת in-process לטעינה.

לכן, טכניקה ברורה לניצול רישום אובייקט ה-COM התלוי היא שליחת Custom OBJREF לשירות COM מיוחס המציין את ה-CLSID של האובייקט התלוי. בעת ה-unmarshaling, שמתרחש אוטומטית בזמן הריצה לפני קריאת שיטת היעד, ה-DLL הזדוני ייטען ונקבל הסלמת הרשאות. הקוד הבא מראה כמה פשוט לציין את מחלקת ה-COM התלויה ביישום IMarshal:

⁦class FakeMarshal : public IMarshal { // Inherited via IMarshal HRESULT GetUnmarshalClass ( REFIID riid , void * pv , DWORD dwDestContext , void * pvDestContext , DWORD mshlflags , CLSID * pCid ) override { return CLSIDFromString ( L"{E9F83CF2-E0C0-4CA7-AF01-E90C70BEF496}" , pCid ); } // ... };⁩

אנחנו צריכים למצוא שירות מיוחס כדי לשלוח אליו את אובייקט ה-COM המועבר (marshaled) כדי להפוך למנהל מערכת. למרבה הצער, מציאת שירות כזה אינה כה פשוטה. העובדה שאובייקט marshaling מותאם אישית יגרום לטעינת DLL שרירותי לתהליך וביצוע קוד היא פעולה מסוכנת, במיוחד מעבר לגבולות הרשאות. לכן, Microsoft הטמיעה אמצעי מיתוג שניתן להפעיל כדי להשבית marshaling מותאם אישית בתהליך, אלא אם המחלקה הוגדרה במפורש לכך, או שהיא אחת ממספר קטן של רכיבים מהימנים כגון מחלקות בספריית זמן הריצה.

החל מ-Windows 8, מיתוג זה מיושם באמצעות שני מנגנונים. השיטה הראשונה והמקורית היא הגדרת דגל היכולות EOAC_NO_CUSTOM_MARSHAL בעת קריאה ל-CoInitializeSecurity. השנייה, שנוספה כדי לשפר את האבטחה בארגזי חול מסוג AppContainer, מוגדרת באמצעות המתודה IGlobalOptions::Set וציון סוג המאפיין COMGLB_UNMARSHALING_POLICY. מכיוון שאיננו מנסים לברוח מארגז חול, הערך היחיד בעל חשיבות הוא COMGLB_UNMARSHALING_POLICY_STRONG, אשר משבית marshaling מותאם אישית בדומה לדגל היכולות.

מכיוון שאובייקט ה-COM התלוי אינו רשום כ-marshaler מהימן, עלינו למצוא שרת COM מיוחס שאינו מאפשר את המיתוגים הללו. הגישה הקלה ביותר היא לסרוק את התהליכים בזמן ריצה. דגלי היכולות מאוחסנים בערך combase!gCapabilities, בעוד שמדיניות ה-marshaling מאוחסנת ב-combase!g_GLBOPT_UnmarshalingPolicy.

עם זאת, המשכתי לחשוב שחייב להיות שירות COM שרץ כ-SYSTEM ואינו מפעיל הגבלות על marshaling מותאם אישית. אחרי קצת חיטוט מצאתי אחד, אם כי ללא ספק ישנם נוספים. התברר שזהו שירות COM שחקרתי וניצלתי בעבר, אובייקט ה-Shell Create Object Handler. זהו אובייקט COM מעניין, בכך שבעוד שהוא פועל בשירות SYSTEM, הוא לא ניתן ליצירה ישירה (instantiable):

⁦PS > $cls = Get-ComClass -Clsid 135fd325-45b7-4c30-89f8-4386961669f0 PS > $o = New-ComObject -Class $cls Exception calling "CreateInstanceAsObject" with "3" argument ( s ): "Class not registered" PS > $cls . AppIdEntry | Select Name , RunAs , IsService Name RunAs IsService ---- ----- --------- Shell Create Object Handler nt authority\system False⁩

בדרך כלל, כאשר אובייקט COM מאוחסן על ידי שירות מיוחס, הוא רשום עם שם של שירות מערכת ש-RPCSS יפעיל אוטומטית כאשר תתבקש מחלקת האובייקט. עם זאת, במקרה זה, מכיוון שאין שירות, יצירת האובייקט נכשלת עם שגיאת "Class not registered". כדי ליצור את שרת ה-COM, השירות צריך לרוץ כבר כמשתמש SYSTEM לפני הקריאה ל-CoCreateInstance.

במקום זאת, עליך להפעיל את השרת המיוחס באמצעות המשימה המתוזמנת \Microsoft\Windows\Shell\CreateObjectTask. למרבה המזל, משתמשים רגילים יכולים להפעיל משימה זו, כפי שניתן לוודא באמצעות הפקודה Get-AccessibleScheduledTask שלי:

⁦PS > Get-AccessibleScheduledTask -Executable | ? Name -Match Shell\\CreateObjectTask TokenId Access Name ------- ------ ---- 77 E3156D GenericExecute | GenericRead ... \Shell\CreateObjectTask⁩

כמובן שרק התחלת המשימה הזו אינה מספיקה; עליך גם ליצור אירוע גלובלי בשם ShellCreateObjectTaskReadyEvent, אחרת המשימה תסתיים מיד ולא תייצא את שירות ה-COM. להלן סקריפט פשוט ליצירת מופע:

⁦PS > $ev = New-NtEvent -Win32Path "Global\ShellCreateObjectTaskReadyEvent" -InitialState $false PS > Start-ScheduledTask -TaskPath "\Microsoft\Windows\Shell\" -TaskName "CreateObjectTask" PS > $ev . Wait () PS > $o = New-ComObject -Clsid "135fd325-45b7-4c30-89f8-4386961669f0" PS > $o InterfaceName Iid ------------- --- IUnknown 00000000-0000-0000-c000-000000000046⁩

ניתן לוודא שהאובייקט מאוחסן בתהליך מיוחס באמצעות הפקודה Get-ComProcess ובדיקת המאפיין CustomMarshalAllowed. שימו לב שהפקודה הזו אינה עובדת כרגע ב-Windows 11 25H2 בשל שינויי מבנים שלא הספקתי לעדכן, אך היא עדיין עובדת בגרסאות קודמות.

⁦PS > $objref = Get-ComObjRef -Object $o PS > $p = Get-ComProcess -ProcessId $objref . ProcessId PS > $p | Select Name , User , CustomMarshalAllowed Name User CustomMarshalAllowed ---- ---- -------------------- dllhost NT AUTHORITY\SYSTEM True⁩

בשלב זה יש לנו את כל מה שאנו צריכים כדי לנצל את אובייקט ה-COM התלוי: יש לנו שירות COM הפועל כ-SYSTEM עם הרשאה ל-marshaling מותאם אישית. אנו יכולים להשתמש ב-API שנקרא CoGetInstanceFromIStorage כדי ליצור את האובייקט, ולהעביר את האובייקט ה"מזויף" כפרמטר pstg. אובייקט זה יעבור marshaling לתהליך שרת ה-COM ולאחר מכן unmarshaling ללא תנאי במהלך הפעלת האובייקט. עלינו ליישם ממשק IStorage מזויף כדי לעבור את היישום המקומי של ה-API, דבר שאינו קשה במיוחד, אך תהיתי אם יש דרך קלה יותר. בואו נסתכל על הממשקים הנתמכים:

⁦PS > Get-ComInterface -Object $o Name IID HasProxy HasTypeLib ---- --- -------- ---------- IUnknown 00000000-0000-... False False IMarshal 00000003-0000-... False False IMarshal2 000001cf-0000-... False False ICreateObject 75121952-e0d0-... True False PS > Get-ComInterface -Name ICreateObject | ConvertTo-ComSourceCode -Parse [ object , uuid ( 75121952 -E0D0-43E5-9380-1D80483ACF72 ), ] interface ICreateObject : IUnknown { HRESULT Proc3 ([ in ] GUID * p0 , [ in ] IUnknown * p1 , [ in ] GUID * p2 , [ out , iid_is ( p2 )] IUnknown ** p3 ); }⁩

לאובייקט ה-COM יש רק ממשק ייחודי אחד, ICreateObject. המרת ה-proxy של הממשק ל-IDL מראה שהוא לוקח מצביע IUnknown כפרמטר השני שלו. לכן, כדי לנצל את הרישום ה-COM התלוי, אנו יכולים פשוט להעביר את האובייקט ה"מזויף" לפרמטר זה ולקבל ביצוע קוד מיוחס. צירפתי לבעיה המקורית כאן ניצול מעודכן ופועל במלואו של הבאג.

ראוי לציין שבעוד שטכניקת ניצול זו מקלה על ניצול רישומי COM תלויים, ניתן להשתמש בה גם כדי לנצל מחלקות COM עם באגים ב-custom unmarshalers. לעיתים, עצם הטעינה של DLL לתוך תהליך יכולה לגרום לקריסה.

מציאת רישומי אובייקט COM תלויים

כהערת שוליים, דרך מהירה לנסות למצוא שרתי COM תלויים נוספים היא להשתמש בסקריפט ה-PowerShell הבא, יחד עם המודולים OleViewDotNet ו-NtObjectManager שלי:

⁦function Test-ComServer { param ( $Server ) try { Use-NtObject ( $lib = Import-Win32Module -Path $Server -Flags AsDataFile ) { $true } } catch { $false } } PS > $db = Get-ComDatabase -LoadMode MachineOnly PS > $cs = Get-ComClass -Database $db -ServerType InProcServer32 PS > $cs | ? { -not ( Test-ComServer $_ . DefaultServer ) } | Sort DefaultServer | Select Name , DefaultServer⁩

זה ידפיס כל מחלקת COM מסוג in-process מכוורת המכונה שבה LoadLibrary לא מצליחה למצוא את ה-DLL. חשוב להשתמש ב-LoadLibrary דרך הפקודה Import-Win32Module, מכיוון שחלק מרישומי ה-COM מציינים רק את שם הקובץ ואתה רוצה לוודא שהם נפתרים כראוי בהתאם לנתיב המערכת.

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

#cve#windows#exploit
קרא במקור