חזרה לפיד
articlesמקור: Wiz Blog24.10.2023

הסבר על רוטקיטים בלינוקס – חלק 2: מודולים הניתנים לטעינה בקרנל

אמ;לק

החלק השני צולל לעולם של LKMs (מודולים הניתנים לטעינה בקרנל) ורוטקיטים הפועלים במרחב הקרנל. הוא מסביר מהם LKMs, כיצד תוקפים מנצלים אותם וכיצד לזהות אותם במערכות לינוקס.

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

נוסף ל-VibeSec:

כותרת מקורית: Linux rootkits explained – Part 2: Loadable kernel modules

הסבר על רוטקיטים בלינוקס – חלק 2: מודולים הניתנים לטעינה בקרנל

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

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

בחלק הקודם של סדרה זו, סקרנו את ה-rootkit למרחב המשתמש מסוג LD_PRELOAD. למדנו כיצד פועלים ה-rootkits הללו וסיפקנו שיטות עבודה מומלצות לזיהויים במערכת ההפעלה שלך.

ב-Linux (ובמערכות הפעלה אחרות דמויות Unix), זיכרון המערכת מחולק לשני תחומים נפרדים: מרחב משתמש (user space) ומרחב ליבה (kernel space). מרחבים אלו מייצגים אזורי זיכרון שונים ומשרתים מטרות שונות, ומספקים הפרדה בסיסית בין יישומים ברמת המשתמש לבין פונקציונליות הליבה של מערכת ההפעלה (ה-kernel). ההפרדה בין שני המרחבים משפרת את יציבות המערכת, את האבטחה ואת הביצועים הכוללים.

בחלק השני של סדרה זו, נחקור את ה-rootkit למרחב הליבה מסוג LKM (Loadable Kernel Modules). טכניקת rootkit זו נוצלה על ידי גורמי איומים שונים בשטח, כולל:

• TeamTNT, שהשתמש ב-rootkit בקוד פתוח מסוג LKM שנקרא Diamorphine כדי להסתיר תהליכי כריית מטבעות דיגיטליים (cryptomining).

• קבוצת Winnti (המכונה גם APT 41), שהשתמשה ב-rootkits מסוג LKM בשם adore-ng ו-suterusu כדי להסתיר פעילות זדונית מגוונת.

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

ה-kernel של Linux הוא הליבה של מערכת ההפעלה המנהלת את משאבי המערכת ומספקת שירותים חיוניים לחלקים אחרים של מערכת ההפעלה וליישומים. מודולי ליבה הניתנים לטעינה הם פיסות קוד שניתן לטעון באופן דינמי לתוך ה-kernel של Linux כדי להרחיב את הפונקציונליות שלו ללא צורך בהידור מחדש (recompile) של ה-kernel או אפילו באתחול המערכת. לדוגמה, כאשר עליך לטפל בסוג חדש של מערכת קבצים שאינה נתמכת על ידי ה-kernel, ייתכן שתצטרך לטעון מודול ליבה ספציפי שנועד לספק תמיכה עבור סוג מערכת קבצים זה.

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

חקירה ואינטראקציה עם מודולי ליבה ממרחב המשתמש

Linux מספקת פקודות שונות לניהול מודולי ליבה, המהוות חלק מתוכנית השירות kmod. פקודות אלו כוללות:

• insmod : משמש להכנסת מודול ליבה באופן ידני לליבה הפועלת.

• rmmod : משמש לפריקת (הסרה) של מודול ליבה.

• modprobe: כלי מתקדם לניהול מודולים שלא רק טוען אותם, אלא גם מטפל בתלויות של מודולים וטוען אוטומטית מודולים קשורים בעת הצורך.

• lsmod: משמש להצגת רשימת כל מודולי הליבה הטעונים. הוא פועל על ידי קריאת מידע מקובץ /proc/modules וביצוע שאילתות בספריית /sys/module/ לקבלת פרטים על כל מודול.

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

שלושה קבצים וספריות רלוונטיים הם:

• /lib/modules/ - מכיל מודולי ליבה וקבצים קשורים הספציפיים לגרסאות ה-kernel השונות המותקנות במערכת. כל ספריית משנה בתוך /lib/modules/ מתאימה לגרסת kernel מסוימת ומכילה את הרכיבים הרלוונטיים. זה מאפשר למערכת ההפעלה לשמור על גרסאות kernel שונות והמודולים המשויכים אליהן בנפרד, מה שמקל על המעבר בין גרסאות בעת הצורך.

• ⁦/proc/modules⁩ - קובץ וירטואלי זה מספק רשימה של מודולי הליבה הטעונים כעת. כל שורה בקובץ זה מייצגת מודול נטען בודד ומכילה מידע על אותו מודול, כולל שמו, גודלו וספירת השימוש שלו.

• /sys/module/ - ספרייה וירטואלית זו מספקת מידע על מודולי הליבה הטעונים כעת. לכל מודול טעון יש ספרייה משלו תחת /sys/modules/, ובתוך כל ספריית מודול קיימים קבצים שונים המכילים מידע עליו. ספרייה זו מאפשרת לתהליכים במרחב המשתמש, לכלים ולאדמיניסטרטורים לגשת למידע על מודולי הליבה הטעונים והמאפיינים שלהם בזמן ריצה. עיין כאן כדי ללמוד עוד על המבנה של ספרייה זו.

לפני שנצלול לאופן שבו תוקפים עושים שימוש לרעה ב-LKMs, חשוב להבין מה הן פונקציות מערכתיות (syscalls) ופונקציות ליבה.

כאשר תוכנית במרחב המשתמש צריכה לבצע משימות הדורשות אינטראקציה עם ה-kernel (למשל, קריאת קובץ, יצירת שקע רשת (socket), ניהול תהליכים), עליה לבקש מה-kernel לבצע את הפעולות הללו. Syscalls פועלים כממשק בין מרחב המשתמש למרחב הליבה, ומאפשרים ל-kernel לבצע את הפעולה המבוקשת בשם תוכנית המשתמש. עיין בדף המדריך של Linux syscalls למידע נוסף.

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

בקטע שלמעלה, אנו יכולים לראות את השימוש ב-syscall מסוג getdents64 (get directory entries). קריאת מערכת זו משמשת לאחזור רשומות מתוך ספרייה. היא משמשת בעיקר תוכניות שצריכות לקרוא את התוכן של ספרייה, כולל ls ו-ps. במקרה זה, הרצנו ls על ספרייה ריקה, וזו הסיבה שה-syscall הזה החזיר 2 ערכים (ברירת המחדל . ו-..).

filldir היא פונקציה ב-kernel שנקראת מ-fs/readdir.c. היא אחראית למילוי רשומות ספרייה (שמות קבצים ומטא-נתונים) במאגר נתונים במהלך רישום ספריות. קריאת המערכת getdents מוגדרת ב-fs/readdir.c ומשתמשת בפונקציית filldir (ראה קוד מקור fs/readdir).

בחלק הקודם של סדרה זו, ציינו ש-rootkits משמשים לעתים קרובות להסתרת פעילות זדונית על ידי hooking לזרימת הביצוע. בעוד שבמרחב המשתמש תוקפים יכולים, למשל, לדרוס פונקציות libc למטרה זו, חטיפת זרימת השליטה במרחב ה-kernel תתבצע בפועל על ידי hooking של פונקציות kernel או syscalls.

מגבלות

השימוש ב-rootkits מסוג LKM מציב אילוצים מסוימים עבור גורמי איומים. ניתן לחלק את האילוצים הללו להרשאות וניידות (הידור):

• קונטיינרים: בניגוד ל-rootkits במצב משתמש, rootkits מסוג מודול ליבה דורשים גישה ל-kernel של המערכת במכונה המארחת. גורמי איומים שפורצים לקונטיינר יוכלו לטעון מודולי ליבה רק אם מתקיים אחד מהתנאים הבאים: הקונטיינר הוא בעל הרשאות (privileged)

• למיכל יש את היכולת ⁦SYS_MODULE⁩

• לשרשור הנשלט של התוקף יש את היכולת ⁦SYS_MODULE⁩

• מכונה וירטואלית/מארחת: על גורם האיום להיות בעל הרשאות root או יכולת להריץ תהליך עם יכולת SYS_MODULE.

בנוסף, ניתן להשתמש במנגנוני אבטחה כגון seccomp ו-AppArmor כדי להגביל את פעולות התהליכים, כולל מניעת אינטראקציות עם מודולי ליבה. יתר על כן, ניתן להדר את ה-kernels של המערכות ללא יכולת טעינת מודולים כלל.

יש להדר מודולי ליבה באמצעות כותרות ה-kernel (kernel headers) הספציפיות התואמות לגרסת ה-kernel של מערכת היעד. בנוסף, פונקציות ואובייקטים של ה-kernel משתנים בין גרסאות kernel וארכיטקטורות שונות. כתוצאה מכך, עבור כל גרסת kernel ייחודית, ייתכן שתידרש הידור נפרד של המודול. מורכבות זו מציבה אתגר בפני תוקפים, מכיוון שהם לא יכולים פשוט להזריק ולטעון קובץ .ko (קובץ אובייקט ליבה) שהוכן מראש. במקום זאת, עליהם להדר את המודול ישירות על מערכת היעד או על מערכת התואמת לכותרות ה-kernel של מערכת היעד.

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

שיטות hooking לפונקציות kernel

ברגע שגורמי איומים מסוגלים להחדיר LKM זדוני, יש להם שליטה מלאה על מרחב הליבה (ובכך על המכונה כולה), והם יכולים לעשות שימוש לרעה בתכונות שונות ב-kernel.

להלן כמה מהשיטות הנפוצות שבהן משתמשים תוקפים לביצוע hooking לפונקציות kernel: שינוי טבלת ה-syscall, Kprobes (בדיקות kernel), Ftrace וביצוע מניפולציות ב-VFS (Virtual File System).

נפרט כל שיטה ברמה גבוהה ונתייחס לפרויקט rootkit בקוד פתוח מסוג LKM שממנף אותה. חקירת פרויקטי ה-rootkit הללו יכולה לעזור להבין כיצד שיטות אלו מיושמות בפועל על ידי גורמי איומים.

שינוי טבלת ה-syscall

טבלת ה-syscall היא מבנה נתונים המשמש את ה-kernel של Linux לניהול קריאות מערכת. היא משמשת כטבלת חיפוש המכילה מצביעים לפונקציות האחראיות לטיפול בקריאות מערכת ספציפיות. כאשר תוכנית במרחב המשתמש מבצעת קריאת מערכת, ה-kernel משתמש בטבלה זו כדי למצוא את פונקציית הטיפול המתאימה ולבצע את הפעולה המבוקשת.

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

פרויקט rootkit בקוד פתוח ⁦LKM⁩ הממנף את השיטה הזו: Diamorphine.

שימוש ב-Kprobes (בדיקות kernel)

Kprobes הן תכונת מכשור (instrumentation) דינמית ב-kernel של Linux המאפשרת למפתחים להכניס קוד מותאם אישית (probes) בנקודות ספציפיות בנתיבי הקוד של ה-kernel. בדיקות אלו נועדו לשמש לאיתור באגים, יצירת פרופילים, מעקב ואיסוף מידע בזמן ריצה על התנהגות ה-kernel ללא צורך בשינוי קוד ה-kernel בפועל.

Kprobes פועלים על ידי צירוף פונקציית מטפל לבדיקה (probe handler) לנקודה נבחרת בקוד ה-kernel. כאשר נתיב הקוד הספציפי מבוצע, פונקציית המטפל מופעלת. על ידי הצבת kprobe על פונקציית kernel רגישה, תוקפים יכולים להריץ את הקוד שלהם בכל פעם שהפונקציה הזו נקראת.

פרויקט rootkit בקוד פתוח מסוג LKM הממנף שיטה זו: Reptile (ממנף את khook).

שימוש ב-Ftrace

Ftrace היא תשתית מעקב (tracing) מובנית בתוך ה-kernel של Linux, המספקת כלים לאיסוף וניתוח סוגים שונים של מידע בזמן ריצה על התנהגות וביצועי ה-kernel. היא נועדה לעזור למפתחים ולאנשי מערכת להבין כיצד ה-kernel פועל, ולזהות צווארי בקבוק בביצועים, בעיות באגים ועוד.

Ftrace מאפשר למשתמשים לעקוב אחר פונקציות kernel ספציפיות. תוקפים יכולים להשתמש בתכונה זו כדי לבצע hooking וליירט את הביצוע של פונקציות ה-kernel.

פרויקט rootkit בקוד פתוח ⁦LKM⁩ הממנף את השיטה הזו: Ftrace-hook .

מניפולציה ב-VFS (Virtual File System)

ה-VFS הוא מרכיב מפתח במערכות הפעלה דמויות Unix; הוא מספק ממשק מערכת קבצים לתוכניות במרחב המשתמש על ידי הפעלת syscalls כגון open(), stat(), read(), write() ו-chmod(). ה-VFS מפשט ומאחד את הגישה למערכות קבצים שונות, ומאפשר למימושים שונים של מערכות קבצים להתקיים במקביל. VFS הוא משפחה של מבני נתונים המייצגים את מודל הקבצים המשותף. ארבעת סוגי האובייקטים העיקריים של ה-VFS הם:

• אובייקט Superblock - מייצג מערכת קבצים מסויימת.

• אובייקט Inode - מייצג קובץ ספציפי (למשל קבצים רגילים, ספריות, FIFOs ושקעים). אובייקט זה מחזיק במבנה שדה פעולות ה-inode (i_op). פעולות Inode הן קבוצה של פונקציות ברמה נמוכה המסופקות על ידי שכבת מערכת הקבצים ב-kernel כדי לבצע מניפולציות ואינטראקציה עם קבצים וספריות. זה כולל – lookup(), rename(), mkdir(), unlink() ועוד (שים לב שהמבנה משתנה בין גרסאות kernel).

• Dentry - מייצג ערך ספרייה, רכיב בודד של נתיב.

• אובייקט קובץ (File object) - מייצג קובץ פתוח המשויך לתהליך. אובייקט זה מחזיק במבנה שדה פעולות הקבצים (f_op). פעולות קבצים הן פונקציות המגדירות כיצד ניתן לתפעל קבצים כשהם פתוחים לקריאה, לכתיבה או לצורות גישה אחרות. זה כולל – read(), write(), mmap(), fsync() ועוד (שים לב שהמבנה משתנה בין גרסאות kernel).

#linux#rootkits#kernel-modules#threat-detection
קרא במקור