דלגו לתוכן הראשי
גאמא קוד

Windows

מבחנים מסכמים

שאלות מכל נושאי Windows, מעורבבות במבחנים מסכמים.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

מבחנים מסכמים: עשרים מושגי Windows מהאתחול ועד הזיכרון והתכנות

שאלות סיכום על Windows חוזרות שוב ושוב לאותה קבוצה של עשרים מושגים: Bootloader, boot.ini, Registry, %SystemRoot%, SAM, lsass.exe, UAC, Service, Driver, Task Manager, Thread, Handle, Desktop, Page file, WinAPI, DLL, ntdll.dll, cmd, .NET Framework ו-CLR. מי ששולט בהם עונה על רוב השאלות בנושא.

כדי שיהיה קל לזכור, המושגים מסודרים לפי חייו של מחשב אחד: הוא נדלק ונטען, קורא את הגדרותיו ומאמת את מי שנכנס, מרים שירותים ודרייברים, מריץ תהליכים ומנהל זיכרון, ובסוף מגיעים לכלים שמתכנתים פוגשים. בחלק הזה נעסוק בארבע התחנות הראשונות: האתחול, משתני הסביבה, ה-Registry, והשלישייה SAM, lsass.exe ו-UAC.

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

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

רקע שכדאי להביא איתכם: ההבדל בין קובץ תוכנית בדיסק לבין תהליך (Process) שרץ ומחזיק זיכרון ומשאבים; ההפרדה בין מצב ליבה (Kernel mode), שבו הקוד ניגש לחומרה ישירות, לבין מצב משתמש (User mode) המוגבל; זיכרון פיזי (RAM) לעומת זיכרון וירטואלי שנותן לכל תהליך מרחב כתובות משלו; וחשבון מנהל לעומת חשבון רגיל. Windows מותקנת לרוב תחת C:\Windows. ההסברים כאן תמציתיים יותר מהפרקים המלאים שמוקדשים לכל מושג.

האתחול: Bootloader, BCD ו-boot.ini

מי טוען את מערכת ההפעלה ובאיזה סדר

דמיינו מרוץ שליחים. כשהמחשב נדלק, Windows עדיין שוכבת בדיסק, וה-RAM ריק ממנה, ומישהו צריך לאתר את קובצי הטעינה שלה, להעתיק את המערכת לזיכרון ולהעביר את המקל לליבה. את הקטע הזה של המרוץ רץ ה-Bootloader (טוען אתחול).

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

שלבמחשב BIOS עם דיסק MBRמחשב UEFI
מה הקושחה מריצהאת קוד האתחול שב-MBR, שטוען את מקטע האתחול של המחיצהישירות את bootmgfw.efi ממחיצת ה-EFI System
מנהל האתחולbootmgr (מ-Vista ואילך) או NTLDR (במערכות NT ישנות עד XP ו-Server 2003)bootmgfw.efi, הגרסה של bootmgr לסביבת UEFI
טוען הליבהwinload.exewinload.efi
היכן יושבים מנהל האתחול וה-BCDלרוב במחיצה המוסתרת System Reservedבמחיצת ה-EFI
Text
Firmware (BIOS/MBR or UEFI)
  -> bootmgr          (on UEFI: bootmgfw.efi)   reads the BCD store, draws the boot menu
  -> winload.exe      (on UEFI: winload.efi)    pulls the boot drivers + ntoskrnl.exe into RAM
  -> ntoskrnl.exe     the kernel takes over: smss.exe, services, the sign-in screen
רכיבהשאלה שהוא עונה עליה
bootmgr (Windows Boot Manager)איזו מערכת להעלות? הוא קורא את ה-BCD, מציג תפריט כשיש יותר ממערכת אחת, ומפעיל את winload
winload.exeאיך הליבה מגיעה לזיכרון? הוא מעלה את ntoskrnl.exe יחד עם דרייברי האתחול ומוסר לה את השליטה
winresumeמה קורה ביציאה מ-Hibernate? במקרה הזה bootmgr מפעיל אותו במקום את winload
ntoskrnl.exeמי ממשיך מכאן? הליבה, שמפעילה את smss.exe ליצירת ה-Session הראשון, ואחריו עולים השירותים ומסך הכניסה

ובצד UEFI יש עוד תוספת: Secure Boot, יכולת של הקושחה שמתירה להריץ רק קוד אתחול חתום.

תרחיש 1: איתור התחנה שבה נתקע האתחול

שלושה מחשבים עם Windows 11 נתקעים בשלושה מקומות שונים. בכל מקרה נזהה איזה רכיב כבר סיים את עבודתו ואיזה לא.

  • מחשב א' משמיע צפצופי שגיאה ולא מציג דבר: הבעיה עוד בבדיקת ה-POST של הקושחה, ושום Bootloader לא רץ עדיין.
  • מחשב ב' (BIOS עם MBR) מציג את תפריט הבחירה בין שתי מערכות, אבל אחרי הבחירה נעצר בשגיאה על ntoskrnl.exe: bootmgr הספיק לקרוא את ה-BCD ולצייר את התפריט, והתקלה בשלב של winload.exe, שאמור להעלות את הליבה. NTLDR אינו קשור, כי זו לא מערכת NT ישנה.
  • מחשב ג' מגיע עד הלוגו ואז נופל לפני מסך הכניסה: winload כבר מסר את השליטה לליבה, ואת smss.exe, השירותים ומסך הכניסה מפעילה הליבה, לא ה-Bootloader.

אם מחשב ב' היה מחשב UEFI, התחנה הראשונה הייתה bootmgfw.efi שהקושחה מריצה ישירות ממחיצת ה-EFI, והשגיאה הייתה מגיעה מ-winload.efi.

טעויות נפוצות
  • ב-Windows 11 על מחשב BIOS טוען האתחול הוא NTLDR שקורא את boot.ini. NTLDR ו-boot.ini שייכים ל-XP ולמערכות שלפניה. מ-Vista והלאה טוען האתחול הוא bootmgr והוא קורא את ה-BCD.
  • במחשב UEFI הקושחה מריצה ישר את winload.efi. הקושחה מריצה קודם את bootmgfw.efi, והוא זה שמפעיל אחר כך את winload.efi.
  • winload הוא שמציג את תפריט בחירת המערכת. את התפריט מצייר bootmgr לפי ה-BCD. התפקיד של winload הוא לטעון את הליבה.
  • winload מעלה את explorer.exe ואת מסך הכניסה. את אלה מעלים הליבה והתהליכים שהיא יוצרת, הרבה אחרי ש-winload סיים.
  • ה-Bootloader מוודא שהחומרה תקינה לפני שהמעבד רץ. בדיקת החומרה היא ה-POST של הקושחה, שקודמת לכל טוען אתחול.
  • ntoskrnl.exe או smss.exe הם ה-Bootloader. ntoskrnl.exe היא הליבה עצמה, ו-smss.exe הוא מנהל ה-Sessions שהליבה מפעילה. שניהם באים אחרי שהטעינה הסתיימה.
בדקו את עצמכם
מחשב שחזר ממצב Hibernate: איזה רכיב מופעל במקום winload, ומי מפעיל אותו?

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

במחשב UEFI, מה הקובץ הראשון של Windows שהקושחה מריצה, ומאיזו מחיצה?

bootmgfw.efi, ממחיצת ה-EFI System. רק הוא מפעיל אחר כך את winload.efi.

חזרה לתוכן העניינים

BCD ו-bcdedit: מאגר הגדרות האתחול המודרני

כל מה ש-bootmgr צריך כדי להחליט מה להעלות רשום ב-BCD, ראשי תיבות של Boot Configuration Data. זהו מאגר הגדרות האתחול של כל גרסה מ-Vista והלאה.

רשום ב-BCDלא רשום ב-BCD
רשימת מערכות ההפעלה שאפשר להעלותתוכנות שעולות עם כניסת המשתמש (Startup)
אפשרויות הטעינה של כל מערכתנקודות שחזור
איזו מערכת עולה כברירת מחדל, וכמה זמן התפריט ממתיןרשימה של דרייברים חסומים

אל תחפשו אותו כקובץ טקסט. ה-BCD הוא מאגר בינארי, בנוי בדומה ל-Registry, ומה ששומר עליו הן הרשאות גישה, לא הצפנה. לכן Notepad אינו כלי לעבודה איתו.

טעות נפוצה היא לקשור אותו לסוג הקושחה. מחשב BIOS עם Windows 10 משתמש ב-BCD בדיוק כמו מחשב UEFI. מה שקובע אם יש BCD או boot.ini הוא גרסת Windows.

הכלי לעריכה הוא bcdedit, כלי שורת פקודה ללא ממשק גרפי, שרץ רק בחלון cmd שנפתח עם Run as administrator. כל הפעלה שלו משנה ערך אחד במאגר:

Text
bcdedit /enum                                   dump the entries that exist
bcdedit /copy {current} /d "Diagnostics mode"   duplicate an entry; a brand new {GUID} comes back
bcdedit /set {GUID} safeboot minimal            make the duplicate come up in Safe Mode
bcdedit /default {id}                           pick the entry chosen when nobody touches the menu
bcdedit /displayorder {id1} {id2}               rearrange how the entries are listed
bcdedit /bootsequence {id}                       a one-shot choice, honoured on the very next boot
bcdedit /timeout 10                             how many seconds the menu lingers
bcdedit /set {current} bootlog yes              turn on the Ntbtlog.txt record for next boot
נסו להריץ bcdedit /enum בחלון רגיל, שלא נפתח כמנהל, ותקבלו את ההודעה 'The boot configuration data store could not be opened. Access is denied', כלומר הכלי דורש הרשאות מנהל. בחלון מוגבה אותה פקודה מדפיסה את רשומות האתחול ואת המזהים שלהן.

רוצים Windows 10 ו-Windows 11 על אותו דיסק (Dual-Boot)? כל מערכת מותקנת במחיצה משלה ומקבלת רשומה משלה ב-BCD, ו-bootmgr כבר יודע להציג ביניהן תפריט בלי כלי נוסף. boot.ini לא משחק כאן תפקיד, כי שתי המערכות חדשות, וגם diskpart אינו הכלי: הוא יוצר ומנהל דיסקים ומחיצות, אבל אינו נוגע בתפריט האתחול.

תרחיש 2: שני טכנאים, אותה משימה, תוצאה הפוכה

שני טכנאים התבקשו להוסיף לתפריט האתחול אפשרות של Safe Mode, בלי לפגוע באתחול הרגיל, ולקצר את זמן ההמתנה בתפריט.

רון פתח cmd כמנהל והריץ ישר bcdedit /set {current} safeboot minimal. מאותו רגע כל הפעלה של המחשב עולה ב-Safe Mode, כי הוא שינה את הרשומה היחידה שהייתה, ולא נוספה שום אפשרות חדשה.

שירה התחילה בשכפול: bcdedit /copy {current} /d "Windows Safe Mode". הפקודה החזירה GUID חדש, ועל המזהה הזה בלבד היא הריצה bcdedit /set {GUID} safeboot minimal. הרשומה הרגילה נשארה כמו שהייתה, ובתפריט הופיעה אפשרות שנייה.

את זמן ההמתנה שניהם קבעו עם bcdedit /timeout 10. מי שהיה מנסה לתת מספר שניות ל-/default, ל-/displayorder או ל-/bootsequence היה נכשל, כי שלושתם מצפים למזהה של רשומה.

טעויות נפוצות
  • את ה-BCD פותחים כקובץ BCD.ini בעורך טקסט ומתקנים שורות. המאגר בינארי, והשינויים נעשים רק דרך bcdedit.
  • bcdedit הוא חלון הגדרות עם תיבות סימון. אין לו ממשק גרפי. הוא כלי שורת פקודה שמחייב חלון cmd מוגבה.
  • בלשונית Startup של Task Manager עורכים את רשומות האתחול. הלשונית הזו מטפלת בתוכנות שעולות כשהמשתמש נכנס, ולא ב-BCD.
  • על מחשב BIOS אין BCD, ולכן אין שם צורך ב-bcdedit. כל Windows מ-Vista ואילך משתמשת ב-BCD, בלי קשר לסוג הקושחה.
  • אבטחתו הגבוהה של ה-BCD נובעת מהצפנה שמופעלת עליו מראש. ההגנה עליו היא דרך הרשאות גישה, ולא באמצעות הצפנה.
  • כדי לבנות Dual-Boot של Windows 10 ו-11 מגדירים את התפריט עם diskpart. diskpart מטפל רק בדיסקים ובמחיצות. את רשומות התפריט מחזיק ה-BCD.
  • המתג /safeboot:minimal נכתב בפקודת bcdedit. זה הכתיב של boot.ini הישן. ב-BCD מציבים את הערך safeboot minimal בעזרת /set.
בדקו את עצמכם
מנהל רוצה שבאתחול הבא בלבד המחשב יעלה מרשומה אחרת, ואחר כך יחזור לברירת המחדל. באיזה מתג של bcdedit ישתמש, ומה יעביר לו?

ב-/bootsequence, ויעביר לו את המזהה של הרשומה, לא מספר.

על מחשב BIOS ישן הותקנה Windows 7. איפה יישמרו הגדרות האתחול שלה, ובאיזה כלי עורכים אותן?

ב-BCD, ועורכים אותן ב-bcdedit. סוג הקושחה אינו משנה; גרסת Windows היא שקובעת.

חזרה לתוכן העניינים

boot.ini ו-NTLDR במערכות הישנות

לפני עידן ה-BCD, במערכות XP, 2000, Server 2003 ו-NT, את האתחול ניהל NTLDR. כדי לדעת מה להציג בתפריט והיכן ההתקנה, הוא קרא קובץ טקסט פשוט בשם boot.ini.

שאלהתשובה לגבי boot.ini
איפה הוא יושב?בשורש מחיצת המערכת הפעילה, בדרך כלל C:\boot.ini
אילו תכונות יש לו?מוסתר, קובץ מערכת, קריאה בלבד
מה כתוב בו?תפריט האתחול והנתיבים אל ההתקנות
מה לא כתוב בו?חשבונות משתמשים, סדר טעינת דרייברים, וקוד בינארי כלשהו
Text
[boot loader]
timeout=15
default=multi(0)disk(0)rdisk(1)partition(2)\WINNT

[operating systems]
multi(0)disk(0)rdisk(1)partition(2)\WINNT="Windows 2000 Server" /fastdetect
  • תחת [boot loader] מופיעים שני ערכים: timeout= שקובע כמה שניות ימתין התפריט, ו-default= שמצביע על ההתקנה שתיבחר אם המשתמש שותק.
  • תחת [operating systems] יש שורה אחת לכל מערכת מותקנת, ובה נתיב ARC ואחריו מתגים כמו /fastdetect או /safeboot.
  • בתוך נתיב ה-ARC שווה לזכור את אי-הסימטריה בספירה: את הדיסקים (rdisk) סופרים החל מאפס, ואת המחיצות (partition) החל מאחת.

לעריכה משורת הפקודה היה ב-XP וב-Server 2003 הכלי bootcfg. בעזרתו מוסיפים רשומת אתחול, מוחקים אחת או משנים קיימת, תמיד בתוך boot.ini. מה שאינו בתחומו: ה-BCD, וקוד האתחול שב-MBR.

מ-Vista והלאה החליפו את הצמד NTLDR ו-boot.ini הצמד bootmgr ו-BCD, ובמקום bootcfg בא bcdedit. במחשב מודרני boot.ini חוזר לחיים רק כשלצד המערכת החדשה מותקנת גם מערכת NT ישנה: bootmgr מעביר אליה את השליטה דרך NTLDR, וזה קורא את boot.ini.

תרחיש 3: פענוח קובץ boot.ini של מחשב ישן

ניקח את הקובץ שהוצג זה עתה ונפרש אותו שורה-שורה.

  • הערך timeout=15 פירושו שהתפריט ישהה חמש-עשרה שניות ואז יבחר בעצמו.
  • הרכיב rdisk(1) מצביע על הדיסק השני, שכן ספירת הדיסקים פותחת באפס, ואילו partition(2) מצביע על המחיצה השנייה, שכן מחיצות נספרות החל מאחת.
  • ההתקנה יושבת בתיקייה \WINNT על אותה מחיצה.
  • מי שקורא את הקובץ ומעלה את התפריט הוא NTLDR, ולא bootmgr או winload.

אם היו רוצים להוסיף לשורה אפשרות של Safe Mode, היו משרשרים אליה את המתג /safeboot:minimal, או נעזרים בכלי bootcfg לשם כך.

טעויות נפוצות
  • NTLDR קורא את ה-BCD ו-bootmgr קורא את boot.ini. זה בדיוק הפוך. NTLDR הולך עם boot.ini, ו-bootmgr הולך עם ה-BCD.
  • שני מנהלי האתחול, הישן והחדש, ניזונים מאותו boot.ini. מקור ההגדרות שלהם נפרד לחלוטין: האחד קורא טקסט, והשני מאגר בינארי.
  • גיבובי הסיסמאות של המחשב שמורים ב-boot.ini. את הגיבובים מחזיק SAM. ב-boot.ini יש רק תפריט ונתיבי התקנה.
  • boot.ini קובע אילו קבצי Registry ייטענו ובאיזה סדר יעלו הדרייברים. שום רשימה כזו אינה בקובץ. התוכן שלו מוגבל לתפריט ולמיקומי ההתקנות.
  • bootcfg הוא הכלי לעריכת ה-BCD. bootcfg שייך ל-boot.ini. את ה-BCD עורכים ב-bcdedit.
בדקו את עצמכם
בשורה של boot.ini מופיע rdisk(0)partition(3). איזה דיסק ואיזו מחיצה?

הדיסק הראשון (הספירה של rdisk מתחילה באפס) והמחיצה השלישית (הספירה של partition מתחילה באחת).

על מחשב עם Windows 10 בלבד מישהו מחפש את boot.ini כדי לשנות את זמן ההמתנה בתפריט. מה תגידו לו?

במערכת כזו אין לקובץ תפקיד. ההגדרה נמצאת ב-BCD ומשנים אותה ב-bcdedit. boot.ini נקרא רק כשמותקנת לצד המערכת גם מערכת NT ישנה.

חזרה לתוכן העניינים

msconfig ו-Boot Logging: אבחון עליית המערכת

הכלי msconfig משמש לאבחון בעיות עלייה. דרך הלשונית Services שבו אפשר לסמן אילו שירותים יורשו לעלות בהפעלה, וכך לאתר באמצעות ניסוי וטעייה שירות אחד שגורם לתקיעה או להאטה. בלשונית Boot מסתתרת אפשרות ששמה Number of processors, והיא מגדירה למערכת כולה כמה מעבדים ינוצלו בעת האתחול, אך בשום אופן אינה מקצה ליבות לתהליך בודד.

עד Windows 7 ניהלו ב-msconfig גם את תוכנות ה-Startup, ומ-Windows 8 הן עברו ללשונית Startup של Task Manager. מה ש-msconfig אינו עושה: הוא לא קובע את גודל ה-Page File, לא מתקין דרייברים ולא מסנכרן Registry בין מחשבים.

המנגנון Boot Logging מתעד את תהליך טעינת הדרייברים ברגעי העלייה. מדליקים אותו מתפריט האתחול המתקדם, או בפקודה bcdedit /set {current} bootlog yes בחלון מוגבה. בהפעלה שאחרי כן נכתב לתיקיית Windows הקובץ Ntbtlog.txt, ובו רשומה לכל דרייבר: Loaded driver למי שנטען, ו-Did not load driver למי שלא.

אם המנגנון כבוי, הקובץ פשוט אינו קיים. במחשב שבו לא הפעילו Boot Logging, חיפוש של Ntbtlog.txt בתיקיית Windows יסתיים ב-File Not Found.

טעויות נפוצות
  • driverquery /v מראה אילו דרייברים נכשלו בטעינה. הוא מציג דרייברים מותקנים ומצב Running או Stopped. Stopped אינו בהכרח כישלון, אלא יכול להיות דרייבר שפשוט לא פעיל כרגע.
  • לשונית Services של Task Manager מראה דרייברים שנכשלו. הלשונית הזו מראה שירותים, לא דרייברים.
  • msconfig קובע את גודל ה-Page File. את גודל ה-Page File משנים ב-System Properties תחת Virtual memory.
בדקו את עצמכם
אחרי עדכון, מחשב עולה לאט ויש חשד שדרייבר מסוים לא נטען. מה מפעילים, ואיפה קוראים את התוצאה?

מפעילים Boot Logging, מתפריט האתחול המתקדם או ב-bcdedit, ובעלייה הבאה קוראים את Ntbtlog.txt בתיקיית Windows ומחפשים שורות Did not load driver.

חזרה לתוכן העניינים

%SystemRoot% ומשתני סביבה

מה המשתנה מחזיק ולמה הוא קיים

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

אחד השימושיים שבהם הוא %SystemRoot%, שערכו הוא הנתיב אל התיקייה שבה Windows הותקנה. כשההתקנה יושבת בכונן C תקבלו ממנו C:\Windows, ובמערכות העתיקות NT ו-2000 ישב שם דווקא C:\WINNT.

לצד %SystemRoot% קיימים עוד שני שמות קרובים. %windir% הוא תאום שלו, עם אותו ערך בדיוק. %SystemDrive% שונה: הוא מצומצם לאות הכונן לבדה, לרוב C:. נסכם את ההבחנה בטבלה:

נתיבמה יש שם
%SystemRoot%ספריית הבית שבה יושבת Windows, על פי רוב C:\Windows
%SystemRoot%\System32קבצי המערכת. במערכת 64 ביט אלה קבצי ה-64 ביט
%SystemRoot%\SysWOW64במערכת 64 ביט: קבצי ה-32 ביט
%SystemDrive%אות הכונן בלבד, בדרך כלל C:

מדוע בכלל להסתמך על משתנה ולא לכתוב נתיב מפורש? מפני שלא כל מחשב מתקין את המערכת באותו מקום, והיא עשויה לשבת בכונן או בתיקייה שונים. כתיבה נוקשה בנוסח C:\Windows\System32 תתפרק על מכונה כזאת, ואילו %SystemRoot%\System32 יתרגם את עצמו תמיד ליעד הנכון.

תמצאו את המשתנה בשלושה מקומות עיקריים: בתוך סקריפטים, בנתיבים של קיצורי דרך ותוכניות, ובערכי Registry מהסוג REG_EXPAND_SZ. למשל, נתיב התוכנית של שירות ה-Dhcp שמור בצורה הזו:

Text
reg query HKLM\SYSTEM\CurrentControlSet\Services\Dhcp /v ImagePath
פלט
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Dhcp
    ImagePath    REG_EXPAND_SZ    %SystemRoot%\system32\svchost.exe -k LocalServiceNetworkRestricted -p

המסיחים בשאלות מנסים לבלבל את המשתנה עם שכניו. הטבלה מסדרת אותם:

הדבר שמתבלבלים איתומה הוא באמתלמה זה לא %SystemRoot%
C:\Usersהמקום שבו לכל חשבון יש תיקייה אישית עם המסמכים וההגדרות שלו%SystemRoot% מצביע על תיקיית Windows, לא על הפרופילים
C:\Program Filesהמקום שבו מותקנות תוכנותהתוכנות אינן תיקיית ההתקנה של המערכת
AppDataהגדרות אישיות של תוכנות לכל משתמשהערך של %SystemRoot% זהה לכל המשתמשים במחשב
הגבלת הרשאותנקבעת בהרשאות של קבצים ותיקיותמשתנה סביבה רק מחזיק טקסט; הוא אינו מגביל דבר
כתובת בזיכרוןמיקום של נתונים ב-RAMהערך הוא נתיב בדיסק, לא כתובת
טעויות נפוצות
  • הערך של %SystemRoot% הוא התיקייה System32. System32 יושבת בתוכו. הערך עצמו הוא C:\Windows.
  • גם כשההתקנה נמצאת בכונן D, המשתנה ימשיך להחזיר C:\Windows. הערך משקף את ההתקנה בפועל, ובמקרה כזה יהיה D:\Windows.
  • %SystemRoot% מחזיר את האות של הכונן ותו לא. את האות לבדה מחזיר %SystemDrive%. ב-%SystemRoot% יש נתיב מלא לתיקייה.
  • בהתקנה שאינה על כונן C המשתנה נשאר ריק. המשתנה קיים בכל התקנה ותמיד מצביע על התיקייה האמיתית.
חזרה לתוכן העניינים

קריאה ושינוי ב-cmd וב-PowerShell

אותו משתנה, שתי מעטפות, שני כתיבים. ב-cmd עוטפים את השם בסימני אחוז, וב-PowerShell פונים אליו דרך הקידומת $env:

Text
cmd:         echo %SystemRoot%
PowerShell:  $env:SystemRoot

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

Text
PS> $env:SystemRoot
PS> echo %SystemRoot%
פלט
C:\Windows
%SystemRoot%

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

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

תרחיש 4: פקודת set בחלון אחד, וחלון חדש שלא מכיר אותה

קובץ Batch קצר מדגים את הכלל. הוא מדפיס את %SystemRoot%, משנה אותו ב-set, מדפיס שוב, ואז מפעיל תהליך בן שמדפיס את הערך שקיבל בירושה:

Text
@echo off
echo [1] this window:            %SystemRoot%
set SystemRoot=Q:\Elsewhere
echo [2] this window after set: %SystemRoot%
cmd /c echo [3] child process:        %%SystemRoot%%
פלט
[1] this window:            C:\Windows
[2] this window after set: Q:\Elsewhere
[3] child process:        Q:\Elsewhere

עכשיו פותחים חלון שאינו צאצא של הראשון ומריצים בו קובץ Batch נוסף. החלון הזה קיבל את הצילום שלו מהתהליך שפתח אותו, שלא ראה את ה-set:

Text
@echo off
echo [4] fresh window from Start: %SystemRoot%
פלט
[4] fresh window from Start: C:\Windows

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

טעויות נפוצות
  • הצורה $env:SystemRoot היא הדרך לקרוא את המשתנה בחלון cmd. זו צורת ה-PowerShell. בתוך cmd משתמשים ב-%SystemRoot%.
  • אחרי set על SystemRoot כל המערכת מתחילה לטעון קבצים מהנתיב החדש. רק החלון וילדיו רואים את הערך החדש, ותיקיית Windows נשארת היכן שהייתה.
  • ערך שנקבע ב-set נשמר, ולכן גם חלון שייפתח מחר יראה אותו. השינוי קיים רק בזיכרון של אותו חלון ונמחק כשהוא נסגר.
בדקו את עצמכם
במחשב שבו Windows מותקנת ב-F:\Windows, מה יחזיר %SystemDrive% ומה יחזיר %windir%?

%SystemDrive% יחזיר F: בלבד, ו-%windir% יחזיר F:\Windows, אותו ערך כמו %SystemRoot%.

בחלון cmd הריצו set SystemRoot=Z:\Test ומיד אחר כך notepad מאותו חלון. איזה ערך יראה Notepad אם יבדוק את המשתנה, ומה יראה חלון cmd שנפתח אחר כך מתפריט התחלה?

Notepad נולד מהחלון ששונה, ולכן יראה Z:\Test. החלון החדש מתפריט התחלה לא ירש מהחלון ההוא, ולכן יראה את הנתיב המקורי.

חזרה לתוכן העניינים

Registry

מהו ה-Registry ולמה הוא קריטי

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

הארגון שלו מזכיר עץ של תיקיות: בתוך מפתחות (Keys) יושבים תתי-מפתחות וגם ערכים (Values), כשלכל ערך שלושה חלקים, שם, סוג ותוכן. הסיבה שהוא כה חיוני היא שבכל הפעלה מחדש Windows נשענת עליו כדי לדעת כיצד להרים את השירותים, הדרייברים, רכיבי החומרה והגדרות המשתמשים.

טענה שמופיעה כמסיחמה נכון
הוא יושב רק ב-RAM ונמחק בכיבויהוא שמור בקבצים בדיסק ושורד כיבוי
כל התקנת תוכנה בונה אותו מחדשהתקנה מוסיפה או משנה ערכים, ולא בונה מאגר חדש
הוא מסתנכרן משרתי היצרן בכל הפעלההוא מקומי למחשב
הוא רץ כבר בשלב ה-POSTהקושחה אינה מכירה אותו; Windows קוראת אותו רק אחרי שהיא נטענת
חזרה לתוכן העניינים

חמשת מפתחות השורש וה-Hives

קיצורשם מלאשל מי ההגדרות ועל מה
HKLMHKEY_LOCAL_MACHINEשל המחשב כולו: חומרה, ענף SYSTEM עם השירותים והדרייברים, ותוכנות מותקנות
HKCUHKEY_CURRENT_USERשל מי שמחובר עכשיו: תמונת רקע, קיצורי דרך, העדפות בתוכנות
HKCRHKEY_CLASSES_ROOTאיזו תוכנה פותחת כל סוג קובץ, ורישום של רכיבי COM
HKUHKEY_USERSכל פרופילי המשתמשים שטעונים כרגע
HKCCHKEY_CURRENT_CONFIGפרופיל החומרה שפעיל ברגע זה

שאלה על חומרה, שירותים או דרייברים מובילה כמעט תמיד ל-HKLM, ובתוכו לענף HKLM\SYSTEM. לכל שירות יש שם מפתח, ובו למשל הערך Start שקובע איך הוא עולה:

Text
reg query HKLM\SYSTEM\CurrentControlSet\Services\Dhcp /v Start
פלט
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Dhcp
    Start    REG_DWORD    0x2

מהי בכלל כוורת (Hive)? זהו קובץ Registry שהמערכת טוענת אל מתחת ל-HKLM או ל-HKU. ארבע כוורות מרכזיות של המערכת, בשמות SYSTEM, SOFTWARE, SAM ו-SECURITY, יושבות יחד בתיקייה C:\Windows\System32\config.

בנפרד מהן, לכל חשבון יש הכוורת הפרטית שלו, קובץ NTUSER.DAT שמונח בתיקיית הפרופיל ומכיל אך ורק את ההגדרות של אותו משתמש. שלושת השורשים HKCU, HKCR ו-HKCC אינם נשמרים כקבצים עצמאיים כלל, אלא מורכבים כקיצור או כתצוגה מאוחדת של חלקים מתוך HKLM ו-HKU.

טעויות נפוצות
  • את פרטי החומרה תמצאו ב-HKCU או ב-HKCR. HKCU שייך למשתמש המחובר ו-HKCR לשיוכי קבצים ול-COM. החומרה רשומה ב-HKLM.
  • HKLM הוא שמרכז את ההגדרות הפרטיות של המשתמש המחובר. אותן הגדרות פרטיות שמורות דווקא ב-HKCU, ואילו HKLM משרת את כל המחשב.
  • גיבוי של NTUSER.DAT שומר את כל כוורות המחשב. הקובץ הזה הוא כוורת של חשבון אחד. כוורות המערכת הן קבצים אחרים ב-System32\config.
חזרה לתוכן העניינים

סוגי ערכים ומיקומים ששווה להכיר

סוגמה הוא מחזיק
REG_SZמחרוזת
REG_EXPAND_SZמחרוזת עם משתנים כמו %SystemRoot% שמורחבים בעת הקריאה
REG_MULTI_SZרשימה של כמה מחרוזות
REG_DWORDמספר של 32 ביט
REG_QWORDמספר של 64 ביט
REG_BINARYנתונים בינאריים
אם השאלה עוסקת ב...חפשו ב...
סוג ההפעלה (Start) או התלויות של שירות או של דרייברHKLM\SYSTEM\CurrentControlSet\Services, מפתח נפרד לכל אחד
תוכנות שעולות לבדהמפתחות Run ו-RunOnce תחת HKLM\Software\Microsoft\Windows\CurrentVersion, המקבילים שלהם ב-HKCU, ועותק נוסף תחת Wow6432Node
החשבונות המקומייםHKLM\SAM
המפתחות Run ו-RunOnce הם מנגנון רגיל ומותר, אבל בדיוק בגלל זה גם תוכנות זדוניות נרשמות בהם כדי לחזור אחרי כל אתחול (Persistence). לכן הם מהמקומות הראשונים שבודקים בחקירה.
חזרה לתוכן העניינים

regedit ו-reg: שני כלים לאותו מאגר

regeditreg
סוג הכליחלון גרפי עם עץ של מפתחותפקודה בשורת הפקודה
למה הוא מתאיםעבודה ידנית: לראות, ליצור, לשנות, למחוק, לייצא ולייבאסקריפטים ואוטומציה
פעולותדרך התפריטים, כולל File > Exportreg add, reg query, reg delete, reg save, reg load, reg export ו-reg import
אילו ענפיםכולם, לפי ההרשאות של המשתמשכולם, לפי ההרשאות של המשתמש, לקריאה ולכתיבה

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

שאילתה רק קוראת ומדפיסה:

Text
reg query "HKCU\Control Panel\Mouse" /v DoubleClickSpeed
פלט
HKEY_CURRENT_USER\Control Panel\Mouse
    DoubleClickSpeed    REG_SZ    500

שתי הפקודות הבאות משנות את המאגר, ולכן מוצגות בלי פלט:

Text
reg add    HKCU\Software\Playground /v Threshold /t REG_DWORD /d 7
reg delete HKCU\Software\Playground /v Threshold

reg add יוצרת את הערך (ואת המפתח אם הוא חסר) ומדפיסה הודעת הצלחה. reg delete בלי המתג /f עוצרת ושואלת Yes/No לפני המחיקה, ועם /f היא מוחקת בלי לשאול.

טעויות נפוצות
  • regedit מופעל מהטרמינל בעזרת פקודות כגון הוספה ושאילתה של ערכים. regedit הוא דווקא הכלי הגרפי. זה של שורת הפקודה הוא reg.
  • אי אפשר לשמור מפתח לקובץ מתוך regedit. התפריט File > Export עושה בדיוק את זה.
  • regedit מנקה מעצמו ערכים שאף תוכנה כבר לא משתמשת בהם. הוא לא פועל מיוזמתו. כל שינוי בו נעשה ביד המשתמש.
חזרה לתוכן העניינים

גיבוי, עריכה Offline, מחשב מרוחק וניטור

מה שומריםבאיזה פורמטפקודת שמירהפקודת החזרה
מפתח בודד, למשל של תוכנה אחתטקסט קריא בסיומת .reg, נוח להשוואה ולסקריפטיםreg exportreg import
כוורת שלמה, למשל SYSTEMקובץ בינאריreg savereg restore; ו-reg load כשרוצים רק לפתוח אותה זמנית לעיון או לעריכה

ייצוא מפתח מסתיים בהודעת הצלחה, והקובץ שנוצר הוא טקסט שהשורה הראשונה בו היא 'Windows Registry Editor Version 5.00'. לעומת זאת, reg query אינה יוצרת שום קובץ; היא רק מדפיסה.

Text
reg export "HKCU\Control Panel\Mouse" mouse-backup.reg
פלט
The operation completed successfully.

כל עוד Windows פועלת, קובצי הכוורות שתחת System32\config נעולים, ולכן העתקה פשוטה שלהם מתוך סייר הקבצים לא תעבוד. כאן נכנסת לתמונה העריכה במצב Offline, שמיועדת למצב שבו המערכת כלל אינה עולה.

  1. מחברים את הדיסק של המחשב התקוע למחשב תקין.
  2. ב-regedit של המחשב התקין מסמנים את HKLM ובוחרים File > Load Hive.
  3. בוחרים את קובץ הכוורת מהדיסק המחובר ונותנים לו שם זמני.
  4. מתקנים, ובסוף בוחרים File > Unload Hive, שכותב את השינוי ומשחרר את הקובץ.

אל תבלבלו בין זה לבין פעולות דומות: System Restore מגלגל את כל המצב אחורה ולא עורך ערך בודד, sfc /scannow מתעסק בקובצי מערכת ולא בערכי Registry, ו-bcdedit כאמור שייך ל-BCD בלבד.

לעבודה מול מחשב אחר ברשת, שם המחשב נכתב בראש הנתיב אחרי שני לוכסנים הפוכים:

Text
reg add \\PC-LAB07\HKLM\Software\Demo /v Name /d Value
כדי שזה יעבודומה לא קיים
השירות Remote Registry פועל במחשב היעדאין לפקודה reg מתג /remote
יש לכם הרשאות מנהל במחשב היעדreg import לא מקבלת קובץ שיושב על מחשב אחר, רק קובץ מקומי
ניגשים ל-HKLM או ל-HKU, השורשים היחידים שזמינים מרחוקבממשק הגרפי זה File > Connect Network Registry ב-regedit

כדי לראות מה קורה ב-Registry ברגע זה משתמשים ב-Process Monitor מחבילת Sysinternals. כל פעולה מופיעה בו עם התהליך שביצע אותה, הנתיב והתוצאה.

שלושה כלים אחרים אינם עושים זאת: reg query מצלמת את המצב פעם אחת, Resource Monitor מציג פעילות דיסק כללית, ויומן Security ב-Event Viewer אינו רושם שינויי Registry כברירת מחדל.

תרחיש 5: עדכון שבר את האתחול: תיקון מבחוץ

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

הטכנאי מחבר את הדיסק של LAB-12 לתחנה תקינה, ב-regedit מסמן את HKLM, בוחר Load Hive ופותח את Windows\System32\config\SYSTEM מהדיסק המחובר תחת השם הזמני Rescue.

הוא מחפש את מפתח הדרייבר ולא מוצא CurrentControlSet. זה צפוי: CurrentControlSet הוא קישור שנוצר רק כשהמערכת רצה, ובכוורת שנטענה מבחוץ עובדים ישירות ב-ControlSet001\Services. אחרי שהערך מתוקן, Unload Hive, והדיסק חוזר ל-LAB-12.

הלקח לפעם הבאה: reg save HKLM\SYSTEM system.hiv לפני כל סקריפט שנוגע בכוורת הזו.

תרחיש 6: העברת הגדרות של תוכנה בין שני חשבונות

דנה רוצה שחשבון הבדיקות שלה במחשב יקבל את אותן הגדרות של תוכנת ציור כמו החשבון הראשי.

בחשבון הראשי היא מריצה reg export HKCU\Software\SketchPad sketch.reg. היא פותחת את הקובץ ב-Notepad ורואה שזה טקסט רגיל, ומוחקת ממנו שורה שאינה רלוונטית.

בחשבון הבדיקות היא מריצה reg import sketch.reg מהעותק המקומי, והערכים נכתבים ל-HKCU של החשבון הזה. reg load לא הייתה עוזרת כאן: היא מיועדת לכוורת בינארית, וקובץ .reg אינו כוורת.

טעויות נפוצות
  • אפשר לשמור מפתח לקובץ באמצעות שאילתת reg. שאילתה כזו רק מדפיסה ערכים למסך. השמירה לקובץ נעשית דרך reg export או reg save.
  • קובץ שנוצר ב-reg export מחזירים למערכת עם reg load. את קובץ ה-.reg מחזירים עם reg import. reg load שייכת לכוורות בינאריות.
  • reg copy שומרת גיבוי ו-reg compare משחזרת אותו. אחת מעתיקה מפתחות והשנייה משווה ביניהם. אף אחת מהן אינה כלי גיבוי.
  • כדי להגיע למחשב מרוחק מוסיפים ל-reg את המתג /remote ואת שם המחשב. אין מתג כזה. שם המחשב נכתב בראש הנתיב: \\PC-LAB07\HKLM\...
  • כדי לשנות הגדרה במחשב מרוחק מעתיקים אליו קובץ SAM מעודכן. SAM מחזיק חשבונות, לא הגדרות, והוא נעול כל עוד המערכת רצה.
  • Resource Monitor מראה כל גישה ל-Registry. הוא מציג פעילות דיסק כללית. למעקב אחר ה-Registry צריך Process Monitor.
בדקו את עצמכם
פקודת reg add מול \\SRV-3\HKCU\... נכשלת, אף ש-Remote Registry פועל שם ויש לכם הרשאות מנהל. מה הבעיה?

HKCU אינו זמין מרחוק. מרחוק אפשר לגשת רק ל-HKLM ול-HKU.

תוכנה מסוימת מאבדת את ההגדרות שלה בכל כמה דקות, ואתם רוצים לדעת איזה תהליך מוחק אותן. במה תשתמשו ולמה לא ב-reg query?

ב-Process Monitor, שמראה כל פעולה ואת התהליך שביצע אותה. reg query נותנת רק תמונה אחת של המצב ולא את מי ששינה אותו.

חזרה לתוכן העניינים

SAM, lsass.exe ו-UAC

SAM: מאגר החשבונות המקומיים

השם SAM נפרש כ-Security Account Manager, וזהו המקום שבו Windows מחזיקה את רשימת חשבונות המשתמשים המקומיים של אותה תחנה. פיזית מדובר בקובץ שיושב תחת C:\Windows\System32\config בשם SAM, ובזמן ריצה הוא עולה ככוורת של ה-Registry תחת הענף HKLM\SAM.

לכל חשבון מקומי SAM מחזיקדוגמה
מזהה אבטחה ייחודי (SID)המזהה שלפיו המערכת מכירה את החשבון, גם אם שמו משתנה
גיבוב (Hash) של הסיסמה, ולעולם לא את הסיסמה כטקסטמחרוזת שמחושבת מהסיסמה ואינה ניתנת להפיכה ישירה
חברות בקבוצות ודגלים של החשבוןשייכות ל-Administrators, או סימון שהחשבון מושבת

סוג הגיבוב הוא NT hash, תוצר של אלגוריתם MD4 שמופעל בלי Salt, והוא עצמו שמור מאחורי מפתח אתחול (boot key) שיושב בכוורת SYSTEM. הגיבובים הישנים מסוג LM מושבתים אוטומטית החל מ-Windows Vista. בכל פעם שמשתמש מקומי מחליף את סיסמתו, נרשם הגיבוב המעודכן אל תוך קובץ ה-SAM.

רמת ההגנה עליו גבוהה: בזמן שהמערכת פועלת הוא נעול, וברירת המחדל מתירה את קריאת המפתח שלו אך ורק לחשבון SYSTEM. מי שינסה reg query על HKLM\SAM\SAM מחשבון רגיל, ואפילו מחלון מנהל שאינו SYSTEM, יקבל 'ERROR: Access is denied'.

מאחורי ההקפדה הזו עומד חשש ברור: גיבוב שנחשף פותח לתוקף שתי אפשרויות, ניסיון פיצוח של הסיסמה, או שימוש בגיבוב עצמו כדי להתחזות באימות (Pass-the-Hash) אפילו מבלי להכיר את הסיסמה המקורית.

תחום האחריות של SAM צר: הוא אינו מחליט מי רשאי להתקין תוכנה, ואין בו רשימת DLL, מידע על חומרה או תיעוד של התקני USB שחוברו.

היבטSAM המקומיActive Directory
למי מתאיםמחשב עצמאי וחשבונות מקומייםרשת ארגונית עם דומיין
היכן יושבקובץ SAM בכל מחשבקובץ NTDS.dit בבקרי הדומיין
תלות ברשתאין, גם בלי אינטרנטחשבונות מרוכזים ומנוהלים דרך הדומיין
טעויות נפוצות
  • מי שמשיג את קובץ ה-SAM קורא בו את הסיסמאות כמו שהן. בקובץ יש גיבובים בלבד, לא סיסמאות קריאות.
  • קובץ ה-SAM נמצא תחת System32\drivers או SysWOW64. מקומו ב-C:\Windows\System32\config, ליד שאר כוורות המערכת.
  • כשמשתמש מקומי מחליף סיסמה, הגיבוב נכתב ל-NTDS.dit או ל-NTUSER.DAT שלו. NTDS.dit הוא מאגר של בקר דומיין, ו-NTUSER.DAT מחזיק העדפות. החשבון המקומי מתעדכן ב-SAM.
  • SAM מתפזר בין התחנות כמו Active Directory, או זקוק לאינטרנט כדי לאמת. כל מחשב מחזיק SAM משלו ומשתמש בו גם בלי שום רשת.
  • כללי הסיסמאות של הדומיין נקבעים בתוך SAM. את מדיניות הדומיין מכתיב Active Directory, ולא מאגר ה-SAM המקומי.
בדקו את עצמכם
בחברה עם דומיין, עובד מתחבר עם חשבון ארגוני למחשב נייד. האם הגיבוב של הסיסמה הארגונית שלו מגיע מ-SAM של הנייד?

לא. חשבונות הדומיין מנוהלים ב-Active Directory, בקובץ NTDS.dit שבבקרי הדומיין. SAM של הנייד מחזיק רק את החשבונות המקומיים של אותו מחשב.

חזרה לתוכן העניינים

lsass.exe: אימות ומדיניות אבטחה

המערכת מריצה רכיב בשם lsass.exe, ששמו המלא Local Security Authority Subsystem Service, וזה הגורם שאוכף בפועל את כללי האבטחה. הוא נטען מ-C:\Windows\System32\lsass.exe ורץ בחשבון SYSTEM; ב-tasklist תראו אותו ב-Session 0, ה-Session של השירותים.

מתימה lsass.exe עושה
משתמש מקליד שם וסיסמהבודק אם הפרטים נכונים
הבדיקה הצליחהבונה אסימון גישה (Access Token), שקובע מה מותר למשתמש מכאן והלאה
משתמש מחליף סיסמהמטפל בשינוי
אירוע שמדיניות הביקורת דורשת לתעדכותב אותו כאירוע Audit ליומן האבטחה

את ההחלטה אם גישה מסוימת לאובייקט מותרת מקבל רכיב אחר, ה-Security Reference Monitor שבליבה, והוא מסתמך על האסימון ש-lsass הכין.

אל תייחסו לו תפקידים של שכניו: את מסך הכניסה ואת התגובה ל-Ctrl+Alt+Del מנהל winlogon, את הפעלת השירותים מבצע services.exe, ואת יצירת ה-Sessions עושה smss.exe.

כשהאימות מקומי, lsass.exe לוקח את הסיסמה שהוקלדה, מחשב ממנה גיבוב, ומעמיד אותו מול הגיבוב ששמור בתוך SAM. כשהמחשב משויך לדומיין המהלך שונה: הוא מפנה את הפרטים לבקר הדומיין לצורך בדיקה, ורק משחוזר אישור הוא טורח לבנות אסימון גישה. תפקידו של שרת DNS כאן מוגבל לאיתור בקר הדומיין, והוא כשלעצמו אינו מאמת שום סיסמה.

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

הגנהאיך היא עובדתמה היא חוסמת
LSA Protection (ההגדרה RunAsPPL)lsass.exe רץ כ-Protected Process Light (PPL). זכות הגישה לתהליך כזה תלויה ברמת החתימה של התוכנה שפונה אליו, לא בכך שהיא רצה כ-Administratorקריאה של הזיכרון שלו וחיבור דיבאגר, גם מצד תוכנה שרצה כמנהל
Credential Guardהסודות עוברים לסביבה מבודדת שנשענת על וירטואליזציה (VBS). באותה סביבה רץ התהליך LsaIso.exe, רכיב לגיטימי של המערכתגישה לסודות עצמם, גם אם הזיכרון של lsass נחשף
ניטרול WDigestהקשחה נפרדת מ-PPLשמירה של סיסמאות כטקסט גלוי בזיכרון

עצירה של lsass.exe גוררת תוצאה קשה: בלעדיו המערכת כבר אינה מסוגלת לאמת כניסות, ולכן היא כופה על עצמה אתחול מלא. עוד סימן ראוי לחשד הוא מופע שני של התהליך, או מופע שהופעל מתיקייה שאינה System32.

תרחיש 7: שני חשבונות על אותו מחשב ביתי

במחשב משפחתי שאינו בדומיין יש שני חשבונות מקומיים: עומר, שחבר ב-Administrators, ומאיה, משתמשת רגילה. שניהם מתחברים באותו יום ומנסים להתקין אותו משחק.

  • בשני המקרים winlogon מקבל את מה שהוקלד ומוסר ל-lsass.exe, שמחשב גיבוב ומשווה לגיבוב של אותו חשבון ב-SAM.
  • עבור מאיה נבנה אסימון רגיל אחד. עבור עומר נבנים שניים: אסימון מלא, ולצדו אסימון מסונן ברמת משתמש רגיל, ו-explorer.exe של עומר רץ דווקא עם המסונן.
  • עומר מפעיל את המתקין, שדורש הרשאות מנהל: המסך מתעמעם וחלון UAC שואל רק אם לאשר. הוא מאשר, ורק המתקין מקבל את האסימון המלא.
  • מאיה מפעילה את אותו מתקין: החלון שלה מבקש שם וסיסמה של מנהל. בלעדיהם ההתקנה לא תתבצע.

אילו המחשב היה בדומיין, את בדיקת הסיסמאות היה lsass.exe מבצע מול בקר הדומיין, לא מול SAM המקומי.

טעויות נפוצות
  • הסיסמאות כתובות בתוך הקובץ lsass.exe שבדיסק. lsass.exe הוא קובץ תוכנית. הסודות נמצאים בזיכרון של התהליך בזמן שהוא רץ.
  • lsass.exe רץ תחת המשתמש המחובר. הוא רץ בחשבון SYSTEM. ומה שמגן עליו בפועל הן LSA Protection ו-Credential Guard, לא חשבון ההרצה.
  • כדי להגן על lsass.exe מסתירים אותו מ-tasklist. הוא גלוי ברשימת התהליכים. ההגנות הן LSA Protection ו-Credential Guard.
  • PPL מעביר את פרטי ההתחברות למכונה וירטואלית מבודדת. זה Credential Guard. PPL מסמן את lsass כתהליך מוגן מפני קריאה.
  • כל תהליך שרץ כמנהל מקבל אוטומטית אותה רמת PPL כמו lsass.exe. רמת ההגנה נגזרת מהחתימה של התוכנה, ולא מההרשאות שלה.
  • explorer.exe או services.exe משווים את הסיסמה ל-SAM. ההשוואה היא תפקיד lsass.exe.
  • בדומיין, lsass.exe נותן אסימון מיד ומדווח לבקר הדומיין אחר כך. קודם מגיע אישור מבקר הדומיין, ורק אחריו נבנה האסימון.
  • המטרה בקריאת הזיכרון של lsass.exe היא שליפת היסטוריית גלישה או טבלת קריאות המערכת. מה שמחפשים שם הוא אישורים ופרטי התחברות, לא נתוני גלישה.
  • אם lsass.exe נופל, Windows ממשיכה כרגיל. נטילת האימות מהמערכת מכריחה אותה לעבור אתחול מלא.
בדקו את עצמכם
בבדיקת מחשב מוצאים בניהול המשימות שני תהליכים בשם lsass.exe, ואחד מהם נטען מתוך תיקייה זמנית של המשתמש. איך תפרשו את זה?

כסימן חשוד: lsass.exe אמיתי יש אחד, והוא נטען מ-C:\Windows\System32. המופע הנוסף מתיקייה אחרת ראוי לחקירה.

תוכנת ניטור שרצה כמנהל מנסה לפתוח את הזיכרון של lsass.exe ונכשלת. איזו הגנה מסבירה את זה, ולמה הרשאות המנהל לא עזרו?

LSA Protection, שבזכותה lsass.exe רץ כ-PPL. הגישה לתהליך מוגן נקבעת לפי רמת החתימה של התוכנה הפונה, ותוכנה רגילה לא עומדת בה גם כשהיא רצה כמנהל.

חזרה לתוכן העניינים

UAC: הרשאות מנהל רק כשצריך

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

האסימון המפוצל עומד בלב העניין. כשחבר בקבוצת Administrators נכנס, Windows מנפיקה לו שני אסימונים במקביל: אחד מלא, ואחד מסונן לרמה של משתמש רגיל (Medium integrity), והמסונן הוא שמשמש כברירת מחדל. הריצו whoami /groups בחלון רגיל של מנהל, ותמצאו ברשימה את Mandatory Label\Medium Mandatory Level, כלומר האסימון הפעיל הוא המצומצם.

ברגע שמתבצעת פעולה שתובעת הרשאות מנהל, קופץ חלון UAC, ורק לאחר האישור עוברת אותה פעולה לפעול עם האסימון המלא. בכך מתמצה המשמעות של Run as administrator.

אופי החלון משתנה לפי המשתמש: מנהל רואה חלון של אישור בלבד (Consent), ואילו משתמש רגיל נדרש להקליד שם וסיסמה של מנהל (Credentials). תוכנה שמסתפקת בהרשאות רגילות עולה חלק, בלי שום חלון כזה. יוצא דופן הוא חשבון ה-Administrator המובנה, שכברירת מחדל אינו כפוף ל-UAC.

ערך requestedExecutionLevel ב-Manifestבאיזה אסימון התוכנה תרוץ
asInvokerבאסימון שכבר מחזיק התהליך שהפעיל אותה, בלי לבקש יותר
highestAvailableבגבוה ביותר שהמשתמש הנוכחי יכול לקבל
requireAdministratorרק במלא של מנהל. על הסמל של קובץ כזה Windows מוסיפה מגן קטן

לפני רמות ההתראה, מושג אחד: Secure Desktop הוא שולחן עבודה נפרד ומבודד ש-Windows מציגה רק לחלון האישור. בזמן שהוא מוצג, הרקע מעומעם ושאר החלונות אינם מקבלים לחיצות, וכך תוכנה שרצה ברמת משתמש לא יכולה ללחוץ בעצמה על כפתור האישור.

רמה במחווןמה קורה
Always notifyהתראה על כל שינוי
Notify me only when apps try to make changes to my computerברירת המחדל: התראה כשאפליקציה מבקשת שינוי, על Secure Desktop
אותה רמה, בלי עמעוםהתראה באותם מקרים, אבל החלון לא מוצג על Secure Desktop
Never notifyבלי התראות. בקשות להרשאות מנהל מאושרות לבד, אבל תוכנה שהופעלה כרגיל עדיין מקבלת את האסימון המסונן

המחוון נמצא בלוח הבקרה, תחת User Accounts, בהגדרה Change User Account Control settings.

ההגדרות של המנגנון שמורות תחת HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System. במחשב שבו UAC פעיל, שאילתה על EnableLUA תחזיר 0x1. כיבוי מלא הוא EnableLUA=0 ומחייב אתחול, ואחריו כל תוכנה שמנהל מפעיל רצה בהרשאות מלאות בלי לשאול. גם אז משתמש רגיל לא הופך למנהל, ומנהל לא מאבד הרשאות. וחשוב לזכור: היצרן אינו מגדיר את UAC כגבול אבטחה, וחלק מרכיבי המערכת מקבלים הרשאות מלאות בלי חלון.

UAC Virtualization הוא נדבך תאימות נפרד. תוכנות ותיקות, שנכתבו עוד לפני ש-UAC היה קיים, נוטות לנסות ולכתוב ישירות אל Program Files או אל מפתחות חסומים בתוך HKLM. במקום להחזיר להן כישלון, Windows מנתבת בשקט את הכתיבה אל מחסן פרטי בתוך הפרופיל של המשתמש, וכך היישום הישן ממשיך לתפקד בלי שיזדקק להרשאות מוגברות.

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

טעויות נפוצות
  • את רמת UAC משנים בקובץ system.ini, ב-Device Manager או ב-sc config. היא נקבעת במחוון שבלוח הבקרה, תחת User Accounts.
  • חלון האישור מופיע כי UAC סורק את התוכנה ומחכה לתוצאה. אין שם סריקה. החלון מופיע כי התוכנה ביקשה לרוץ עם הרשאות מנהל.
  • כל הרצה של תוכנה, יהיה אשר יהיה אופייה, מחייבת הקלדת סיסמת מנהל. הדרישה עולה רק כשמבקשים הרשאות מנהל, ולא בהרצה שגרתית.
  • מגן קטן על הסמל של קובץ פירושו שהקובץ חתום, נקי או מוגן ממחיקה. הוא מסמן רק שהקובץ יבקש אישור UAC וירוץ כמנהל.
  • העמעום נועד לחסוך משאבים, או שהמערכת מקפיאה בו-זמנית את כלל התהליכים. ההסבר פשוט יותר: החלון עולה על שולחן עבודה מבודד ומאובטח, וזה מה שמכהה את הרקע.
  • UAC Virtualization נותן לתוכנה ישנה הרשאות מנהל לזמן קצר. שום הרשאה לא ניתנת. הכתיבה פשוט מופנית לעותק בפרופיל המשתמש.
בדקו את עצמכם
יישום ותיק, שרץ ללא הרשאות מנהל, שומר בהצלחה קובץ תחת תיקיית התוכנות המוגנת ולא זוכה לשום הודעת שגיאה. כיצד ייתכן?

פעל כאן UAC Virtualization, שהסיט את הכתיבה אל עותק בתוך הפרופיל של המשתמש.

מנהל העביר את המחוון לרמה השלישית, בלי עמעום. איזו הגנה הוא איבד, אף שחלונות האישור עדיין מופיעים?

את ה-Secure Desktop. החלון מוצג עכשיו על שולחן העבודה הרגיל, ולכן תוכנה שרצה ברמת משתמש יכולה בעיקרון לשלוח אליו לחיצות.

חזרה לתוכן העניינים

Services ו-Drivers: קוד שרץ ברקע וקוד שרץ בליבה

שירות: תוכנית שעובדת גם כשאיש לא מול המסך

חשבו על שומר הלילה של בניין משרדים: הוא מגיע לפני העובדים, נשאר אחרי שכולם הלכו, ואף אחד לא צריך לראות אותו כדי שיעשה את העבודה. כך פועל שירות (Service) ב-Windows: תוכנית רקע, לרוב בלי חלון ובלי ממשק, שנותנת יכולת למערכת עצמה או לתוכנות אחרות.

שירות יכול להתחיל לעבוד כבר בזמן עליית המחשב, לפני שמסך הכניסה הופיע, והוא ממשיך לרוץ כשאף משתמש לא מחובר. גם התנתקות של משתמש לא מכבה אותו.

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

מי מנהל את כל השומרים האלה, ואיפה הם עובדים? הפלט הבא עונה על שתי השאלות:

Text
tasklist /fi "imagename eq services.exe"
tasklist /fi "imagename eq explorer.exe"
פלט
Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
services.exe                  1000 Services                   0      8,012 K

Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
explorer.exe                  1320 Console                    1     77,668 K

services.exe הוא ה-Service Control Manager (SCM): התהליך שמרים, עוצר ומשגיח על כל שירות במחשב. בעמודה Session# הוא מסומן 0, ואילו explorer.exe של המשתמש המחובר מסומן 1.

ההפרדה הזו קיימת מאז Windows Vista: כל השירותים חיים ב-Session 0, ולא חולקים את שולחן העבודה של מי שיושב מול המחשב.

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

חזרה לתוכן העניינים

סוגי ההפעלה: מתי השירות עולה, אם בכלל

לכל שירות יש סוג הפעלה (Startup type). ב-services.msc תמצאו חמש אפשרויות:

סוג הפעלהמתי השירות עולה
Automaticכבר בזמן עליית Windows, עוד לפני כניסה של משתמש כלשהו
Automatic (Delayed Start)קצת אחרי שהעלייה הסתיימה, בנפרד מהשירותים האוטומטיים שעולים מיד, כדי לא להעמיס על האתחול
Manualרק כשמישהו מבקש: משתמש, תוכנה, או שירות אחר שזקוק לו
Manual (Trigger Start)כשמתרחש אירוע (טריגר) שהוגדר לשירות מראש
Disabledאף פעם: לא באתחול, לא בהפעלה ידנית ולא כשירות אחר תלוי בו, כל עוד ההגדרה לא שונתה

ב-Registry סוג ההפעלה נשמר בערך Start שבמפתח של השירות: 2 הוא Automatic, 3 הוא Manual ו-4 הוא Disabled. יש שם עוד שני ערכים, Boot (0) ו-System (1), והם שמורים לדרייברים שצריכים לעלות בשלב מוקדם מאוד של האתחול.

הפקודה sc qc מציגה את הערך הזה. כאן שבעה רכיבים שונים, משני דרייברים ועד שירות מושבת:

Text
sc qc disk | find "START_TYPE"
sc qc Afd | find "START_TYPE"
sc qc Dnscache | find "START_TYPE"
sc qc BITS | find "START_TYPE"
sc qc Spooler | find "START_TYPE"
sc qc TapiSrv | find "START_TYPE"
sc qc RemoteRegistry | find "START_TYPE"
פלט
        START_TYPE         : 0   BOOT_START
        START_TYPE         : 1   SYSTEM_START
        START_TYPE         : 2   AUTO_START
        START_TYPE         : 2   AUTO_START  (DELAYED)
        START_TYPE         : 2   AUTO_START
        START_TYPE         : 3   DEMAND_START
        START_TYPE         : 4   DISABLED

disk הוא דרייבר הדיסק, ולכן הוא עולה ב-Boot. ל-BITS יש סימון (DELAYED): זה Automatic (Delayed Start). DEMAND_START הוא השם הפנימי של Manual.

נניח שמנהל מעביר את Spooler ל-Disabled בשעה 10:00. ב-10:01 ההדפסה עדיין עובדת, השירות מופיע ברשימה וכל הקבצים שלו במקומם. רק באתחול הבא הוא יישאר כבוי, ולא יעלה עד שמישהו ישנה את ההגדרה.

ואילו היה בוחר Delayed Start? השירות היה עולה אחרי כל אתחול כרגיל, רק באיחור קטן, בלי לחכות לאף משתמש. ואם השירות נופל באמצע היום, Delayed Start לא מרים אותו; לזה יש Recovery, בחלק הבא.

חזרה לתוכן העניינים

הכלים, Recovery ותלויות בין שירותים

יש ארבע דרכים עיקריות לטפל בשירות, וכל אחת מתאימה למצב אחר:

כלימה עושים בו
services.mscהממשק הגרפי המלא. בלשונית General קובעים סוג הפעלה, ב-Log On את החשבון, ב-Recovery את התגובה לכישלון, וב-Dependencies רואים במה השירות תלוי
scשורת פקודה: שאילתה, עצירה, הפעלה ושינוי הגדרות. נוח לסקריפטים
net start, net stopהפעלה ועצירה בלבד, בלי שום הגדרה
Task Manager, הלשונית Servicesרשימה עם Start, Stop ו-Restart, בלי הגדרות מתקדמות

כך נראית שאילתה על שירות לקוח ה-DNS:

Text
sc qc Dnscache
פלט
[SC] QueryServiceConfig SUCCESS

SERVICE_NAME: Dnscache
        TYPE               : 20  WIN32_SHARE_PROCESS
        START_TYPE         : 2   AUTO_START
        ERROR_CONTROL      : 1   NORMAL
        BINARY_PATH_NAME   : C:\Windows\system32\svchost.exe -k NetworkService -p
        LOAD_ORDER_GROUP   : TDI
        TAG                : 0
        DISPLAY_NAME       : DNS Client
        DEPENDENCIES       : nsi
                           : Afd
        SERVICE_START_NAME : NT AUTHORITY\NetworkService

שלוש שורות בפלט שוות קריאה. BINARY_PATH_NAME מראה ש-Dnscache לא רץ מקובץ משלו אלא בתוך svchost.exe, מארח שכמה שירותים יכולים לחלוק; בגרסאות חדשות, כשיש די RAM, רבים מהם מקבלים svchost נפרד. SERVICE_START_NAME מראה את החשבון, כאן NetworkService, ושאר האפשרויות הן LocalSystem, LocalService או משתמש מסוים.

השורה השלישית, DEPENDENCIES, נשמרת ב-Registry בערך בשם DependOnService. הוא יושב במפתח של Dnscache עצמו, כלומר במפתח של מי שזקוק לאחרים, תחת HKLM\SYSTEM\CurrentControlSet\Services:

Text
reg query HKLM\SYSTEM\CurrentControlSet\Services\Dnscache /v DependOnService
פלט
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Dnscache
    DependOnService    REG_MULTI_SZ    nsi\0Afd

הסוג REG_MULTI_SZ מחזיק רשימה, והרצף \0 מפריד בין השמות. כשה-SCM צריך להרים את Dnscache, הוא מרים קודם את nsi ואת Afd; ואם אחד מהם לא מסוגל לעלות, נגיד כי הוא Disabled, גם Dnscache נשאר למטה. Afd, אגב, הוא דרייבר ליבה, כך ששירות יכול להיות תלוי גם בדרייבר.

פקודות השליטה עצמן קצרות. ב-sc config חייב לבוא רווח אחרי סימן השוויון, אחרת הפקודה נכשלת:

Text
sc query wuauserv
sc stop wuauserv
sc start wuauserv
sc config wuauserv start= demand
net stop wuauserv
net start wuauserv

ומה קורה כשהשירות נופל? במאפייני השירות ב-services.msc יש לשונית Recovery עם שלוש שורות: First failure, Second failure ו-Subsequent failures. לכל שורה בוחרים תגובה משלה: Take No Action, Restart the Service, Run a Program או Restart the Computer.

תרחיש 8: שירות חשבוניות שתלוי במסד נתונים

חברה מתקינה שני שירותים משלה: LedgerDb, שמחזיק מסד נתונים, ו-InvoiceSync, שקורא ממנו ונופל מדי פעם. הדרישות: InvoiceSync יעלה רק אחרי ש-LedgerDb כבר פועל, ויחזור לבד אחרי נפילה.

  1. הסדר: מוסיפים ב-HKLM\SYSTEM\CurrentControlSet\Services\InvoiceSync ערך DependOnService עם LedgerDb. מעכשיו ה-SCM מעלה קודם את LedgerDb.
  2. מה לא יוצר סדר: Delayed Start לשניהם רק מאחר את שניהם, בלי שום קדימות של אחד על השני. גם הרצה של שניהם תחת אותו חשבון לא יוצרת קשר ביניהם.
  3. הנפילות: ב-Recovery של InvoiceSync בוחרים Restart the Service לנפילה הראשונה ולשנייה. sc config עם start= auto לא עוזר כאן, כי הוא קובע רק מתי השירות עולה ולא מה עושים כשהוא נופל.
  4. מקרה קצה: אם מישהו יעביר את LedgerDb ל-Disabled, גם InvoiceSync לא יעלה באתחול הבא, כי מה שהוא תלוי בו לא מורשה לרוץ.
טעויות נפוצות
  • את Spooler עוצרים ב-taskkill ומפעילים שוב ב-tasklist. שתי הפקודות עובדות על תהליכים: tasklist רק מציגה אותם, ו-taskkill מסיימת תהליך. לשירות משתמשים ב-sc או ב-net start ו-net stop.
  • regedit start עם שם השירות מרים אותו. אין פקודה כזו. regedit הוא עורך ה-Registry ולא מנהל שירותים.
  • Disabled הוא בעצם Manual שננעל מאחורי הרשאת מנהל. Manual עולה כשמבקשים אותו. Disabled לא עולה בשום צורה, גם לא בידי מנהל, עד שמשנים את ההגדרה.
  • שירות Automatic ממתין עד שהמשתמש הראשון נכנס. הוא עולה יחד עם המערכת, לפני כל כניסה.
  • שירות הוא קוד ליבה ששולט ישירות בכרטיס הרשת. זה התיאור של דרייבר. שירות רגיל רץ במצב משתמש.
בדקו את עצמכם
LedgerDb הוגדר Disabled, ו-InvoiceSync, שתלוי בו, מוגדר Automatic. מה תראו אחרי אתחול?

LedgerDb לא יעלה, ולכן גם InvoiceSync ייכשל בעלייה. רק החזרה של LedgerDb ל-Manual או ל-Automatic תפתור את זה.

שירות רץ עכשיו, ומישהו מעביר אותו ל-Disabled. האם הוא נעצר?

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

חזרה לתוכן העניינים

דרייבר: המתורגמן שבין Windows להתקן

אם שירות הוא שומר הלילה, דרייבר (Driver, מנהל התקן) הוא המתורגמן. Windows מבקשת בשפה כללית, למשל לקרוא בלוק מהדיסק, והדרייבר הופך את הבקשה לפקודות שהבקר הספציפי מבין. יש גם דרייברים שאין מאחוריהם חומרה בכלל, ותפקידם להרחיב את הליבה.

שלושה דברים שדרייבר אינו: הוא לא הקושחה (Firmware) שצרובה בתוך ההתקן, הוא לא תוכנה רגילה של משתמש, וכמובן לא הכבל שמחבר את ההתקן למחשב.

  • הקובץ: דרייבר ליבה שמור לרוב כקובץ עם הסיומת .sys, ומקומו בתיקייהC:\Windows\System32\drivers.
  • ההגדרות: בדיוק כמו לשירות, יש לו מפתח תחת HKLM\SYSTEM\CurrentControlSet\Services, ושם נשמר גם ערך ה-Start שלו.
  • ההרשאות: דרייבר ליבה רץ בהרשאות מלאות, ולכן באג בו לא נשאר מקומי. הוא יכול להפיל את המערכת כולה למסך כחול (BSOD).
  • החריג: יש דרייברים שרצים במצב משתמש (UMDF). כשאחד כזה נופל, שאר המערכת ממשיכה לעבוד.
Text
sc qc Afd
פלט
[SC] QueryServiceConfig SUCCESS

SERVICE_NAME: Afd
        TYPE               : 1  KERNEL_DRIVER
        START_TYPE         : 1   SYSTEM_START
        ERROR_CONTROL      : 1   NORMAL
        BINARY_PATH_NAME   : \SystemRoot\system32\drivers\afd.sys
        LOAD_ORDER_GROUP   : PNP_TDI
        TAG                : 0
        DISPLAY_NAME       : Ancillary Function Driver for Winsock
        DEPENDENCIES       :
        SERVICE_START_NAME :

אותה פקודה שהציגה שירות מציגה גם דרייבר, כי שניהם רשומים באותו ענף. השורה TYPE מגלה KERNEL_DRIVER, הנתיב מוביל לקובץ afd.sys בתיקיית drivers, וסוג ההפעלה הוא SYSTEM_START, הערך 1.

חזרה לתוכן העניינים

חתימה דיגיטלית: כרטיס הכניסה לליבה

מפתחת בונה דרייבר לחיישן טמפרטורה, חותמת עליו בתעודה שהפיקה לעצמה (self-signed), ומנסה לטעון אותו ב-Windows 10 של 64 ביט. Windows מסרבת. למה?

כי לדרייבר ליבה אין גבולות: הוא יכול לקרוא כל זיכרון ולשנות כל דבר. לכן Windows של 64 ביט מפעילה Driver Signature Enforcement, ומכניסה לליבה רק דרייבר שחתום בחתימה שהיא סומכת עליה. מ-Windows 10 גרסה 1607 הרף עלה: דרייבר ליבה חדש צריך חתימה של Microsoft.

מה החתימה בודקת? זהות ושלמות: מי עומד מאחורי הקובץ, והאם הוא זהה בדיוק למה שנחתם. כך Windows יודעת ש-Microsoft או יצרן שהיא מכירה ערבו לדרייבר, ודרייבר שהושתל או שובש בדרך לא מגיע לליבה.

הדרייברמה קורה כשמנסים לטעון אותו
חתום בחתימה מהימנהנטען כרגיל
חתום בחתימה עצמית (self-signed)בדרך כלל נחסם
נחתם כראוי, ואחר כך שונה בו בייט אחדנחסם, כי החתימה כבר לא תואמת לתוכן

החתימה היא שער ולא דרגה: דרייבר שעבר אותה רץ באותן הרשאות מלאות כמו כל דרייבר ליבה. ואין לה תפקיד נוסף מעבר לשער: היא לא מצפינה את הקובץ, לא מזהה חומרה ולא מביאה עדכונים.

ומה עושה המפתחת? לבדיקות בלבד היא יכולה לכבות את האכיפה לאתחול אחד: Advanced Startup, אחר כך Startup Settings, ובתפריט שמופיע Disable driver signature enforcement. באתחול הבא האכיפה חוזרת, ובמחשב של עבודה אמיתית לא עושים את זה.

טעויות נפוצות
  • דרייבר חתום מקבל בליבה יותר כוח מדרייבר אחר. כל דרייבר ליבה רץ באותן הרשאות מלאות. החתימה רק מכריעה אם הוא ייטען.
  • ההבדל בין self-signed לחתום הוא במהירות הטעינה, או בכך שהראשון נטען רק אחרי כניסה. ההבדל הוא כן או לא: נחסם מול נטען.
  • אם מעלים את UAC ל-Always notify, Windows תשאל אם לאשר דרייבר לא חתום. UAC עוסק בהגבהת הרשאות של תוכנות, ואין לו חלק בבדיקת החתימות של דרייברים.
  • driverquery שמורצת כמנהל מכבה את בדיקת החתימות, וקובץ שהועתק ל-drivers פטור ממנה. driverquery רק מציגה רשימה, והתיקייה לא נותנת פטור לאף קובץ.
חזרה לתוכן העניינים

Device Manager, Driver Store ו-Driver Verifier

כלי או מקוםתפקיד
Device Manager (devmgmt.msc)הדרך הידנית הרגילה לטפל בדרייבר של התקן: עדכון, התקנה, חזרה לגרסה הקודמת (Roll Back Driver), השבתה והסרה
driverqueryפקודה שמציגה את הדרייברים המותקנים. העמודות State ו-Status, שמראות אם דרייבר רץ, מופיעות רק עם המתג /v
Driver Storeמאגר מקומי של חבילות דרייברים, ב-C:\Windows\System32\DriverStore (בתת-התיקייה FileRepository). כשמחברים התקן, Windows מחפשת כאן חבילה מתאימה ומתקינה ממנה
Driver Verifier (verifier.exe)מפעיל בדיקות קפדניות על דרייברים שבחרתם, למשל על הדרך שבה הם מקצים זיכרון
Text
driverquery | findstr /i /c:"Module Name" /c:"afd " /c:"disk "
פלט
Module Name  Display Name           Driver Type   Link Date
AFD          Ancillary Function Dri Kernel
disk         Disk Driver            Kernel
fdc          Floppy Disk Controller Kernel
flpydisk     Floppy Disk Driver     Kernel
iorate       Disk I/O Rate Filter D Kernel
Ramdisk      Windows RAM Disk Drive Kernel

בלי /v הטבלה מקוצרת, כמו כאן: שם, תיאור, סוג ותאריך. כדי לראות אם כל דרייבר פועל או עצור מריצים driverquery /v.

Driver Verifier עובד בשיטה שנשמעת הפוכה: כשדרייבר שנמצא תחת מעקב מפר כלל, Windows מפילה את המחשב למסך כחול בכוונה ושומרת קובץ Dump. העצירה ברגע ההפרה עצמה היא מה שמאפשר לזהות בקובץ את הדרייבר האשם, במקום לנחש אחרי קריסה אקראית.

שתי תיקיות שקל לבלבל: System32\drivers מחזיקה את קבצי ה-.sys שהמערכת משתמשת בהם, ו-System32\DriverStore מחזיקה את החבילות שמהן מתקינים.
תרחיש 9: מסכים כחולים אחרי כרטיס רשת חדש

אחרי שהוסיפו למחשב כרטיס רשת נוסף, הוא נופל למסך כחול פעם או פעמיים ביום.

  1. החשד: רק קוד שרץ בליבה מפיל את כל המערכת, ולכן הדרייבר החדש עומד ראשון בתור.
  2. האבחון: מפעילים Driver Verifier על הדרייבר של הכרטיס בלבד. הנפילה הבאה מגיעה עם קובץ Dump, והניתוח שלו מצביע על הדרייבר שהפר כלל.
  3. התיקון: ב-Device Manager פותחים את ההתקן ומבצעים Roll Back Driver לגרסה הקודמת.
  4. האימות: כדי לדעת מה נטען בפועל באתחול, מפעילים Boot Logging וקוראים את הקובץ Ntbtlog.txt שבתיקיית Windows.
טעויות נפוצות
  • דרייבר מעדכנים ב-Event Viewer, ב-Task Manager (לשונית Details) או ב-Programs and Features. אלה כלים ליומנים, לתהליכים ולתוכנות מותקנות. התקנים ודרייברים מנהלים ב-Device Manager.
  • Driver Store הוא ענף ב-Registry, או כינוי לאתר ההורדות של היצרן. זו תיקייה מקומית בדיסק, תחת System32.
  • Driver Verifier מחליף בעצמו דרייבר תקוע, מעביר דרייברים למצב משתמש, או מצייר גרף צריכה. הוא רק מחמיר את הבדיקות ומפיל בכוונה, כדי שהאשם יתגלה ב-Dump.
בדקו את עצמכם
חיברתם עכבר שכבר היה מחובר למחשב לפני חודש. מאיפה Windows לוקחת את הדרייבר שלו?

מה-Driver Store: החבילה כבר שמורה שם, ב-System32\DriverStore.

למה כלי אבחון שמפיל את המחשב בכוונה הוא בעצם דבר טוב?

כי הנפילה קורית בדיוק ברגע ההפרה, וה-Dump שנשמר אז מצביע על הדרייבר שגרם לה.

חזרה לתוכן העניינים

Task Manager, Thread, Handle ו-Desktop

Task Manager והלשוניות שלו

Task Manager (taskmgr.exe) נפתח הכי מהר בצירוף Ctrl+Shift+Esc. הוא לוח המחוונים של המחשב: מה רץ, כמה משאבים כל דבר צורך, ואיפה אפשר לסיים תהליך או למנוע מתוכנה לעלות עם הכניסה.

לשוניתמה תמצאו בה
Processesהתהליכים בקבוצות, אפליקציות ותהליכי רקע, ולכל אחד צריכת CPU, זיכרון, דיסק ורשת שמתעדכנת כל הזמן
Performanceגרפים למעבד, לזיכרון, לדיסק ולרשת. בעמוד הזיכרון מופיעים In use, Committed, Cached, Paged pool ו-Non-paged pool
Startupהתוכנות שעולות כשמשתמש נכנס, עם כפתור Disable ועמודת Startup impact
Usersמי מחובר, ואילו תהליכים שייכים לכל משתמש
Detailsשורה לכל תהליך: PID, משתמש, מצב וזיכרון. דרך Select columns מוסיפים עמודות, למשל Handles
Servicesהשירותים, עם Start, Stop ו-Restart

רוב הלשוניות ותיקות, אבל Startup ו-Details הגיעו רק עם Windows 8. מי שעבד על Windows 7 ניהל את תוכנות ההפעלה דרך msconfig.

העמודה Startup impact עונה על שאלה אחת: כמה כל תוכנה מאטה את העלייה? Windows מודדת בפועל את זמן ה-CPU והדיסק שהתוכנה צרכה בעליות קודמות, ומתרגמת אותו ל-Low, Medium או High.

אם תוכנת סנכרון מקבלת High ואתם לא צריכים אותה בדקה הראשונה, Disable יקצר את העלייה. היא נשארת מותקנת, ואפשר להפעיל אותה ידנית מתי שרוצים.

Startup איננה מרכז שליטה כללי לאתחול. שירותים, תפריט האתחול ודרייברים מנוהלים בכלים אחרים: services.msc, bcdedit ו-Device Manager.
חזרה לתוכן העניינים

מה עושים עם תהליך, ואילו כלים משלימים

בלשונית Details, לחיצה ימנית על תהליך פותחת תפריט של פעולות:

פעולהמה היא עושה
End taskבלשונית Processes היא קודם מבקשת מהאפליקציה להיסגר, ורק אחר כך מכריחה. בלשונית Details היא מסיימת את התהליך מיד
End process treeמסיימת את התהליך יחד עם כל תהליכי הילד שלו
Set priorityקובעת את מחלקת העדיפות (Priority class) של התהליך
Set affinityבוחרים באילו ליבות התהליך רשאי לרוץ
Analyze wait chainמגלה על מה תהליך תקוע מחכה
Create dump fileצילום של זיכרון התהליך לקובץ, בזמן שהתהליך ממשיך לחיות. את הקובץ פותחים אחר כך בכלי דיבוג

מהתפריט File > Run new task מריצים תוכנית חדשה לפי שמה, למשל explorer.

ומה אם תבחרו End task על תהליך של המערכת עצמה? התשובה תלויה בתהליך:

אם מסיימים את...מה קורה
csrss.exe, wininit.exe או smss.exeWindows לא יכולה להמשיך בלעדיהם, והמחשב נופל למסך כחול עם הקוד CRITICAL_PROCESS_DIED
lsass.exeהמערכת מודיעה שהיא תאתחל, ומאתחלת בעצמה
explorer.exeשולחן העבודה ושורת המשימות נעלמים, ומחזירים אותם ב-Run new task (בתרחיש למטה)

בשתי השורות הראשונות Task Manager עשוי להציג אזהרה לפני הביצוע, ולפעמים הוא לא מאפשר את הסיום בכלל.

Task Manager נותן סכומים. כשצריך לרדת לפרטים, יש שלושה כלים:

  • Resource Monitor (resmon.exe): בלשונית Disk מופיעה לכל תהליך רשימת הקבצים שהוא פותח לקריאה ולכתיבה, ובלשונית Network החיבורים שלו ב-TCP והפורטים. הוא מציג את מה שקורה עכשיו ולא שומר היסטוריה ארוכה.
  • Process Explorer של Sysinternals: חיפוש לפי שם קובץ (Find Handle or DLL) מגלה איזה תהליך מחזיק אותו פתוח.
  • Process Monitor של Sysinternals: רישום חי של כל פעולה על קבצים ועל ה-Registry.
תרחיש 10: תוכנת הנהלת חשבונות שנתקעה, ושולחן עבודה שנעלם

תוכנת הנהלת חשבונות מפסיקה להגיב באמצע הפקת דוח, והמפתחים רוצים לדעת מה קרה בתוכה.

  1. לפני שסוגרים: ב-Details, לחיצה ימנית על התהליך ו-Create dump file. הקובץ נשמר בלי לסגור את התוכנה, והמפתחים ינתחו אותו בכלי דיבוג.
  2. רק עכשיו End task. מ-Details התהליך מסתיים מיד.
  3. למחרת נעלמים שולחן העבודה ושורת המשימות, ובלשונית Details אין שורה של explorer.exe. פותחים Task Manager ב-Ctrl+Shift+Esc, בוחרים File > Run new task, כותבים explorer ומאשרים. המעטפת עולה ומציירת הכול מחדש.
  4. איפה לא לחפש: explorer אינו שירות, ולכן אין לו שורה ב-Services. גם sfc /scannow לא מפעיל אותו.
  5. דרישה אחרונה: תוכנת עיבוד וידאו צריכה לרוץ רק על ליבות 0 ו-1. ב-Details לוחצים עליה לחיצה ימנית, בוחרים Set affinity ומשאירים מסומנות רק את שתיהן.
טעויות נפוצות
  • Set affinity מסתתר בלשונית Performance, ב-Startup, או בתוך Set priority. הוא פריט נפרד בתפריט הלחיצה הימנית על תהליך, בלשונית Details.
  • את הליבות של תהליך אחד קובעים ב-msconfig (Number of processors) או ב-Power Options. אלה הגדרות שחלות על המערכת כולה, לא על תהליך בודד.
  • כדי לראות כמה CPU וזיכרון צורכת כל אפליקציה, בקבוצות, פותחים Performance או Startup. זו הלשונית Processes. Performance מציגה גרפים כלליים, ו-Startup עוסקת בעלייה.
  • Create dump file סוגרת את התהליך, או מעלה את העדיפות שלו, או מעבירה אותו לליבה אחרת. היא רק שומרת צילום של הזיכרון. התהליך ממשיך בדיוק כמו קודם.
  • Details מציגה שירותים, היסטוריה של השבוע האחרון או הרשאות NTFS. Details מציגה תהליכים: PID, משתמש, מצב, ועמודות שבוחרים להוסיף.
  • Resource Monitor שומר חודש של היסטוריה לפי ימים. הוא מפרט את הפעילות הנוכחית ואינו ארכיון.
חזרה לתוכן העניינים

Thread ואיך Windows מתזמנת אותו

תהליך דומה למטבח של מסעדה: יש בו ציוד, מזווה ומפתחות, כלומר מרחב כתובות, Handles ואסימון אבטחה. Thread הוא הטבח, מי שעושה את העבודה בפועל. מטבח בלי טבח לא מבשל, ולכן בכל תהליך יש לפחות Thread אחד.

המתזמן של Windows מחלק זמן מעבד ל-Threads, לא לתהליכים: Thread הוא יחידת הביצוע, ותהליך הוא המיכל של המשאבים. בחלק מהטקסטים בעברית Thread נקרא שרשור, ושני השמות מתארים את אותו דבר.

משותף לכל ה-Threads של תהליךפרטי לכל Thread
מרחב הכתובות: אותם משתנים גלובליים ואותו Heapמחסנית (Stack)
טבלת ה-Handlesערכי האוגרים
הקוד שנטען לתהליך: ה-EXE וה-DLLsמזהה Thread (Thread ID)

המתזמן (Scheduler) בוחר לפי עדיפות, והוא מקדים (Preemptive): הוא לא מחכה ש-Thread יסיים כדי להחליף אותו. הכי קל לראות את זה בציר זמן של ליבה אחת (הזמנים להמחשה בלבד):

Text
t=0 ms   A (priority 8) and B (priority 8) are ready    -> A runs, B waits
t=15 ms  A's quantum is used up                         -> B runs, A waits
t=20 ms  C (priority 13) becomes ready                  -> C takes the core at once, B stops mid-work
t=22 ms  C waits for a disk read                        -> B goes on

שתי השורות הראשונות: A ו-B באותה עדיפות, ולכן הם מתחלפים על הליבה בתורות, כל אחד לפרוסת זמן (Quantum). השורה השלישית: C גבוה מהם, וברגע שהוא מוכן הליבה עוברת אליו, גם אם B באמצע.

ומאיפה המספר 13? העדיפות של Thread נגזרת ממחלקת העדיפות (Priority class) של התהליך שלו, ונעה סביבה. ושתי ציפיות שהציר מפריך: עדיפות גבוהה לא נותנת ל-C ליבה משלו, היא רק מקדימה אותו בתור; ו-Threads אחרים בתהליך של C לא מקבלים את העדיפות שלו מעצמם.

מאיפה Threads באים ולאן הם הולכים? מוסיפים אחד לתהליך קיים ב-CreateThread; תהליך שלם, עם מרחב כתובות נפרד, נוצר ב-CreateProcess. Thread גומר כשהפונקציה שלו מחזירה ערך (כמו sell בתוכנית שבהמשך), כשהוא קורא ל-ExitThread, כשהתהליך שלו נגמר, או כשמישהו עוצר אותו ב-TerminateThread, הדרך המסוכנת, כי שום ניקוי לא מתבצע.

המחיר של הרבה Threads: כל מעבר של ליבה מ-Thread אחד לאחר הוא החלפת הקשר (Context switch), והיא עולה זמן. ונתונים שכמה Threads נוגעים בהם צריכים סנכרון. בתוכנית הבאה שני Threads מוכרים כרטיסים מאותו מונה גלובלי, פעם בלי נעילה ופעם עם Critical section:

C
#include <windows.h>
#include <stdio.h>

static long tickets = 0;                  /* one global: both threads see the same variable */
static CRITICAL_SECTION guard;
static int use_lock = 0;

static DWORD WINAPI sell(LPVOID arg) {
    for (int i = 0; i < 1000000; i++) {
        if (use_lock) EnterCriticalSection(&guard);
        tickets++;                        /* read, add, write back: not atomic */
        if (use_lock) LeaveCriticalSection(&guard);
    }
    return 0;
}

static void run(int lock) {
    HANDLE t[2];
    tickets = 0;
    use_lock = lock;
    t[0] = CreateThread(NULL, 0, sell, NULL, 0, NULL);
    t[1] = CreateThread(NULL, 0, sell, NULL, 0, NULL);
    WaitForMultipleObjects(2, t, TRUE, INFINITE);
    CloseHandle(t[0]);
    CloseHandle(t[1]);
    printf("%-18s tickets = %ld (expected 2000000)\n", lock ? "with lock:" : "without lock:", tickets);
}

int main(void) {
    InitializeCriticalSection(&guard);
    run(0);
    run(1);
    DeleteCriticalSection(&guard);
    return 0;
}
פלט
without lock:      tickets = 1125804 (expected 2000000)
with lock:         tickets = 2000000 (expected 2000000)

בלי נעילה, שני ה-Threads קוראים לפעמים את אותו ערך, מוסיפים אחד וכותבים, ועדכונים הולכים לאיבוד. המספר משתנה מהרצה להרצה; בהרצה נוספת יצא 1068845. עם Critical section רק Thread אחד נמצא בכל רגע בקטע המוגן, והתוצאה מדויקת.

תרחיש 11: שירות התראות שפותח Thread לכל הודעה

שירות התראות פותח Thread חדש לכל הודעה שנכנסת. בשעת עומס חיים בו אלפי Threads בבת אחת, והמעבד עמוס בלי שההודעות זזות.

  1. האבחנה: רוב זמן המעבד הולך על מעברים בין Threads ולא על שליחת הודעות.
  2. התיקון: מגבילים את מספר ה-Threads שעובדים יחד, למשל קבוצה קבועה של עשרה Threads (Thread pool) שמושכים הודעות מתור משותף.
  3. מה יחמיר: להעביר את כולם לעדיפות Realtime. אלפי Threads כאלה ידחקו החוצה את שאר המערכת.
  4. מה לא ישנה דבר: Page File גדול יותר או סגירה של Handles לא מורידים אף החלפת הקשר.
טעויות נפוצות
  • כל Thread מקבל מרחב כתובות משלו, ולכן אין להם זיכרון משותף. ה-Threads של תהליך יושבים באותו מרחב כתובות, ובגלל זה צריך סנכרון.
  • Thread הוא תהליך קטן בתוך תהליך, או DLL שנטען, או סוג של הרשאה. Thread הוא יחידת ביצוע: מחסנית, אוגרים, ומקום בתור של המתזמן.
  • Threads מנוהלים במצב משתמש בלבד, והליבה לא יודעת עליהם. ב-Windows הליבה עצמה מתזמנת את ה-Threads.
  • המתזמן מסדר Threads לפי סדר היצירה, לפי הזיכרון שהם תופסים או לפי המשתמש שהריץ אותם. הקריטריון הוא עדיפות.
  • Thread בעדיפות נמוכה שכבר התחיל ימשיך עד הסוף, גם אם הגיע Thread חשוב ממנו. התזמון מקדים: הגבוה לוקח את הליבה מיד.
בדקו את עצמכם
שני Threads של אותו תהליך כותבים לאותו מונה גלובלי. למה זה בכלל אפשרי, ומה חסר?

זה אפשרי כי יש להם מרחב כתובות אחד. חסר סנכרון: Critical section או Mutex סביב העדכון.

תוכנית צריכה להריץ פונקציה ברקע, בלי מרחב כתובות חדש. CreateProcess או CreateThread?

CreateThread, שמוסיפה Thread לאותו תהליך. CreateProcess יוצרת תהליך נפרד.

חזרה לתוכן העניינים

Handle: מספר שיש לו משמעות רק בתהליך שלו

תוכנית לא נוגעת ישירות באובייקטים של הליבה: Mutex, Event, קובץ פתוח, Thread, תהליך או מפתח Registry. הליבה שומרת אותם אצלה ומוסרת לתוכנית Handle, ערך אטום (Opaque) שמייצג את האובייקט.

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

בפועל, כל Handle הוא רשומה בטבלה של התהליך שקיבל אותו, ואת הערך הזה התוכנית מגישה בכל קריאת API על האובייקט. לכן ארבעה ניחושים נפוצים פסולים: זה לא שם או נתיב של קובץ, לא PID, לא שכפול של האובייקט, ולא מיקום בזיכרון הפיזי.

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

איך משתפים אובייקט עם תהליך אחראיך זה עובד
ירושה (Handle Inheritance)תהליך ילד מקבל מהאב רק את ה-Handles שסומנו מראש כניתנים לירושה, ומשתמש בהם
שכפול (DuplicateHandle)תהליך יוצר רשומה חדשה בטבלה של תהליך אחר (או בטבלה שלו), ויכול לקבוע לה הרשאות גישה

בשתי הדרכים נוצר Handle נוסף, אבל האובייקט נשאר אחד. התוכנית הבאה משכפלת Handle בתוך אותו תהליך, סוגרת את המקורי וממשיכה לקרוא דרך העותק, ובסוף פותחת קובץ 500 פעמים בלי לסגור:

C
#include <windows.h>
#include <stdio.h>

int main(void) {
    DWORD before, after;
    GetProcessHandleCount(GetCurrentProcess(), &before);

    HANDLE a = CreateFileW(L"C:\\Windows\\win.ini", GENERIC_READ, FILE_SHARE_READ,
                           NULL, OPEN_EXISTING, 0, NULL);
    HANDLE b;
    DuplicateHandle(GetCurrentProcess(), a, GetCurrentProcess(), &b,
                    0, FALSE, DUPLICATE_SAME_ACCESS);   /* a second entry, same file object */
    printf("a and b are different values: %s\n", a != b ? "yes" : "no");

    CloseHandle(a);                                     /* the object lives on through b */
    char buf[16] = {0};
    DWORD got = 0;
    BOOL ok = ReadFile(b, buf, 10, &got, NULL);
    printf("read through b after closing a: %s, %lu bytes\n", ok ? "ok" : "failed", got);
    CloseHandle(b);

    for (int i = 0; i < 500; i++)                       /* a leak: opened, never closed */
        CreateFileW(L"C:\\Windows\\win.ini", GENERIC_READ, FILE_SHARE_READ,
                    NULL, OPEN_EXISTING, 0, NULL);
    GetProcessHandleCount(GetCurrentProcess(), &after);
    printf("handle count grew by %lu\n", after - before);
    return 0;
}
פלט
a and b are different values: yes
read through b after closing a: ok, 10 bytes
handle count grew by 500

אחרי DuplicateHandle יש שני ערכים שונים, ושניהם מובילים לאותו קובץ פתוח. סגירת a לא סגרה את הקובץ, כי b עדיין מחזיק בו. והלולאה בסוף היא דליפה קלאסית: 500 פתיחות בלי סגירה, ו-500 רשומות שנשארו בטבלה.

בתוכנית יש שתי קריאות ל-CloseHandle, אחת לכל רשומה, וזו הפונקציה שסוגרת Handle של כל אובייקט ליבה. רק ממשקים מעטים מביאים פונקציית סגירה משלהם: מה שנפתח ב-RegOpenKeyEx נסגר ב-RegCloseKey, וחיפוש שהתחיל ב-FindFirstFile נסגר ב-FindClose.

ולמה לא בודקים את התוצאה של CreateFile מול NULL? כי היא מסמנת כישלון ב-INVALID_HANDLE_VALUE, כלומר -1, בשונה מרוב פונקציות ה-Create* שמחזירות NULL. בדיקה מול NULL הייתה מפספסת קובץ שלא נפתח.

הלולאה האחרונה הוסיפה 500 רשומות שאיש לא ינקה. בתוכנית שרצה ימים דליפה כזו גדלה עד שהמשאבים אוזלים. כדי לעקוב אחריה ב-Task Manager בוחרים Select columns ומסמנים Handles, ומקבלים מספר שמטפס, בלי שמות של קבצים.

לא כל מה שנקרא Handle יושב בטבלה הזו. HWND של חלון, וה-Handles של GDI ושל תפריטים, מנוהלים בידי מערכת החלונות: חלון נעלם ב-DestroyWindow, ו-CloseHandle לא רלוונטית לו.
תרחיש 12: גיליון תקציב שמסרב להימחק

מנהלת מנסה למחוק את budget2025.xlsx ומקבלת הודעה שהקובץ פתוח בתוכנה אחרת. המשמעות: לתהליך כלשהו יש Handle פתוח אליו.

  1. ב-Process Explorer היא בוחרת Find Handle or DLL ומקלידה budget2025.xlsx. בתוצאה מופיעים שם התהליך וה-PID שלו.
  2. היא סוגרת את התוכנה הזו. ה-Handle משתחרר יחד איתה, והמחיקה עוברת.
  3. למה לא כלים אחרים: העמודה Handles ב-Task Manager נותנת מספר בלבד, ו-tasklist ו-Event Viewer לא מראים קבצים פתוחים בכלל.
טעויות נפוצות
  • Handle של קובץ סוגרים ב-DestroyWindow, ב-FreeLibrary, ב-TerminateThread, ב-DeleteFile או ב-ExitThread. DestroyWindow לחלון, FreeLibrary ל-DLL, TerminateThread ו-ExitThread מסיימות Thread, ו-DeleteFile מוחקת קובץ. את ה-Handle סוגרת CloseHandle.
  • מספר של Handle ייחודי בכל המחשב. הוא נכון רק בטבלה של התהליך שקיבל אותו.
  • Mutex ו-Thread לא צריכים Handle, ניגשים אליהם בכתובת. הם אובייקטי ליבה כמו קובץ, וניגשים אליהם דרך Handle.
  • Handle הוא בעצם מצביע ל-EPROCESS, ותהליך משתמש יכול לערוך דרכו את האובייקט. הערך אטום. האובייקט נשאר בזיכרון הליבה, ותוכנית משתמש לא נוגעת בו.
  • תהליך ילד מקבל את כל ה-Handles של האב, מסומנים או לא. רק מה שסומן כניתן לירושה עובר.
  • DuplicateHandle מעתיקה את הקובץ עצמו, או את הטבלה כולה. היא יוצרת רשומה אחת נוספת שמצביעה על אותו אובייקט.
בדקו את עצמכם
תהליך P1 שולח לתהליך P2 את הערך 0x2C8, שהוא Handle ל-Mutex אצל P1. מה יקרה כש-P2 ינסה להשתמש בו?

זה לא יעבוד, כי 0x2C8 רשום בטבלה של P1. P1 צריך לשכפל את ה-Handle אל P2 ב-DuplicateHandle, או ליצור את P2 כילד שיורש Handle שסומן כניתן לירושה.

איזה ערך תבדקו כדי לגלות ש-CreateFile נכשלה?

INVALID_HANDLE_VALUE (-1). NULL הוא ערך הכישלון של רוב פונקציות ה-Create* האחרות, לא של CreateFile.

חזרה לתוכן העניינים

Desktop: גם משטח על המסך וגם אובייקט במערכת

למילה Desktop יש שני מובנים. ביום-יום זה המשטח שעליו רואים חלונות וסמלים. מאחורי הקלעים זה אובייקט של המערכת, ולכל מובן כללים משלו.

במובן היומיומי שני דברים קשורים אליו. explorer.exe הוא שאחראי על הציור של שורת המשימות ושל המעטפת הגרפית, ואם מפעילים אותו מחדש הוא מצייר את שתיהן מההתחלה. והתיקייה Desktop שבכל פרופיל, C:\Users\<name>\Desktop, מחזיקה את הקבצים שמופיעים על המשטח.

במובן הטכני Desktop הוא אובייקט שמכיל חלונות. הוא שייך ל-Window Station, וה-Window Station שייכת ל-Session. כך זה נראה אצל משתמש שמחובר ליד המחשב:

Text
Session 1
  Window Station WinSta0
    Desktop "Default"    the user's application windows
    Desktop "Winlogon"   the secure desktop: Ctrl+Alt+Del screen, UAC prompt
  • ה-Desktop הרגיל (Default): כאן מופיעים החלונות של התוכנות שאתם מריצים.
  • ה-Secure Desktop, ה-Desktop של Winlogon: כאן מוצגים מסך Ctrl+Alt+Del וחלון האישור של UAC ברמות ברירת המחדל. תוכנות שרצות אצל המשתמש לא יכולות לגעת בו.

חיבור Remote Desktop (RDP) לשרת יוצר Session חדש, ובו Window Station נפרדת ו-Desktop נפרד. המשתמש שיושב ליד השרת לא מאבד את ה-Desktop שלו, ושני המשתמשים גם לא חולקים אחד.

Desktops וירטואליים (Win+Tab) הם דבר אחר לגמרי: דרך לסדר בקבוצות את החלונות של אותו משתמש. התהליכים לא עוברים ל-Session אחר או לחשבון אחר, ממשיכים לרוץ גם כשהקבוצה שלהם מוסתרת, ואין שום כניסה מחדש במעבר.

טעויות נפוצות
  • Desktop הוא קובץ תמונת הרקע, או תיקייה שאוספת כל מסמך שפתחתם. הוא המשטח הגרפי, ובמובן הטכני אובייקט שמכיל חלונות. התיקייה Desktop מכילה רק את מה ששמרתם בה.
  • Desktop הוא התהליך שמצייר את שורת המשימות. את זה עושה explorer.exe.
  • Desktop ו-Session הם אותו דבר. Session מכיל Window Station, וה-Window Station מכילה Desktops.
  • תוכנה שנמצאת ב-Desktop וירטואלי מוסתר מושהית עד שחוזרים אליו. היא ממשיכה לרוץ כרגיל. רק התצוגה השתנתה.
  • כל Desktop וירטואלי רץ בחשבון אחר, או שכל תהליך מקבל Desktop משלו. שתי הטענות שגויות: משתמש אחד, Session אחד, וה-Desktops הווירטואליים רק מקבצים חלונות.
  • מעבר ל-Desktop וירטואלי אחר סוגר את החלונות של הקודם. שום דבר לא נסגר. משתנה רק מה מוצג.
בדקו את עצמכם
חלון UAC מופיע, המסך מאחוריו מתעמעם ותוכנות אחרות לא מגיבות. על איזה Desktop הוא מוצג, ולמה זה חשוב?

על ה-Secure Desktop, אובייקט Desktop נפרד. תוכנה שרצה אצל המשתמש לא יכולה ללחוץ שם על אישור במקומכם.

במה Desktop וירטואלי (Win+Tab) שונה מה-Secure Desktop?

Desktop וירטואלי הוא רק קבוצת חלונות של אותו משתמש, בלי בידוד. ה-Secure Desktop הוא אובייקט נפרד של המערכת שתוכנות המשתמש לא יכולות לגעת בו.

חזרה לתוכן העניינים

Page File: זיכרון וירטואלי על הדיסק

מה נכנס ל-Page File ומה לא

ה-RAM הוא שולחן עבודה מוגבל, והתהליכים ביחד מבקשים יותר זיכרון ממה שיש עליו. ה-Page File הוא ארון בצד: קובץ מוסתר בדיסק, בברירת מחדל C:\pagefile.sys, שמשמש זיכרון וירטואלי כשה-RAM מתמלא.

לא כל דף שיושב ב-RAM יכול לעבור לארון. נחלק את מה שתהליך מחזיק לשני סוגים:

סוג הדףדוגמאותמה קורה לו כש-RAM חסר
זיכרון פרטי שהוקצה (Committed)Heap, מחסניות, נתונים שהתוכנית שינתהאם לא נגעו בו לאחרונה, Windows כותבת אותו ל-Page File ומשחררת את מקומו
דף שיש לו עותק בדיסקקוד מקבצי .exe ו-.dll, קבצים ממופיםלא נכתב לשום מקום: הוא פשוט נזרק מה-RAM, וכשצריך Windows קוראת אותו שוב מהקובץ המקורי

ומה קורה כשהתהליך פונה שוב לדף שיצא? המעבד לא עובד מול הדיסק, ולכן נוצר Page fault: Windows עוצרת את התהליך לרגע, מחזירה את הדף ל-RAM, והוא ממשיך. ה-Page File אינו RAM נוסף ואף תהליך לא רץ מתוכו; הוא מחסן, וכל דף ממנו חוזר ל-RAM לפני שמשתמשים בו.

אז מה הוא כן מוסיף? מקום להבטחות. Windows מוכנה להתחייב לתהליכים על זיכרון פרטי עד תקרה שנקראת Commit limit (גבול ההתחייבות, ובחלק מהטקסטים גבול ההקצאה), והתקרה היא בערך ה-RAM ועוד ה-Page File. נמדוד אותה:

Text
$pf    = Get-CimInstance Win32_PageFileUsage
$ramMB = [math]::Round((Get-CimInstance Win32_OperatingSystem).TotalVisibleMemorySize / 1KB)
$limit = [math]::Round((Get-Counter '\Memory\Commit Limit').CounterSamples[0].CookedValue / 1MB)
"page file    : $($pf.Name), $($pf.AllocatedBaseSize) MB"
"RAM          : $ramMB MB"
"RAM + file   : $($ramMB + $pf.AllocatedBaseSize) MB"
"commit limit : $limit MB"
פלט
page file    : C:\pagefile.sys, 24878 MB
RAM          : 16023 MB
RAM + file   : 40901 MB
commit limit : 40902 MB

16,023 ועוד 24,878 נותנים 40,901 MB, והמונה של Windows מראה 40,902 MB. הגבול הוא בדיוק הסכום, פחות או יותר מגה-בייט.

חזרה לתוכן העניינים

גודל, מחסור, ביטול ומיקום

הגודל מוגדר במסך Virtual memory, שמגיעים אליו דרך System Properties > Advanced > Performance. יש שתי גישות: לתת ל-Windows לנהל (Automatically manage paging file size), או לקבוע גודל ידני.

מה רואים או מגדיריםמה עומד מאחורי זה
המחשב כמעט נעצר, והדיסק עובד בלי הפסקהThrashing: התהליכים צריכים כל הזמן יותר דפים ממה שנכנס ב-RAM, ולכן דפים יוצאים וחוזרים שוב ושוב, והדיסק איטי בהרבה מה-RAM
ה-Page File בשימוש כבדכמעט תמיד חסר RAM, ו-Windows משלימה את החסר בדיסק
Page File בגודל ידני מגיע לקצההתקרה שמדדנו נעשית קשיחה, כי Windows מגדילה בעצמה רק קובץ בגודל מנוהל. בקשות חדשות לזיכרון נדחות, מופיעה התראה שהזיכרון הווירטואלי אוזל, וזה נמשך עד שמגדילים את הקובץ ביד או משחררים זיכרון
ה-Page File כובה לגמריWindows עולה בלי בעיה, אבל כשה-RAM מתמלא אין לאן להוציא דפים פרטיים, ולכן בקשות זיכרון עלולות להיכשל ותוכנות ליפול
ה-Page File הועבר לכונן אחרהדפדוף עובר לדיסק אחר ומפריע פחות לקריאות ולכתיבות של מערכת ההפעלה בכונן שלה
מדיניות אבטחה מנקה אותו בכיבוינתונים רגישים שהגיעו מהזיכרון לא נשארים בדיסק אחרי שהמחשב כבה
תרחיש 13: תחנת עריכה עם Page File קבוע של 4 GB

בתחנת עבודה יש 16 GB RAM, והמנהל קבע Page File ידני וקבוע של 4 GB. גבול ההתחייבות הוא אם כן בערך 20 GB.

  1. עורכת וידאו פותחת פרויקט כבד, דפדפן ותוכנת תלת-ממד, וסך ההקצאות מגיע ל-20 GB ומבקש עוד.
  2. Windows מציגה אזהרה על מחסור בזיכרון וירטואלי. כל בקשה נוספת לזיכרון נכשלת, ותוכנות מציגות שגיאה או נסגרות.
  3. מה שלא יקרה: Windows לא תוסיף Page File שני בכונן אחר, לא תסגור מעצמה את התוכנה הגדולה, ודחיסת זיכרון לא תזיז את הגבול.
  4. הפתרונות: להגדיל את הקובץ, לעבור לגודל מנוהל, או להוסיף RAM.
טעויות נפוצות
  • Windows טוענת את הקוד של EXE ו-DLL דרך ה-Page File. קוד נקרא מהקבצים שלו. ה-Page File מחזיק רק זיכרון פרטי.
  • גודל קבוע גורם ל-Windows לדפדף גם כש-RAM רב עומד פנוי. שימוש כבד בקובץ נובע ממחסור ב-RAM, לא מכך שהגודל קבוע.
  • העברת ה-Page File לכונן אחר מוסיפה RAM, או דואגת לגבות את תוכנו. הרווח היחיד הוא פחות תחרות על דיסק המערכת.
  • מחשב בלי Page File לא יעלה. הוא עולה. הבעיה מגיעה אחר כך, כשהזיכרון נגמר.
  • ה-Page File שומר גיבוי של ה-Registry, או קבצים שפתחתם לאחרונה. הוא מחזיק דפי זיכרון פרטי שהוצאו מה-RAM, לא קבצים ולא הגדרות.
חזרה לתוכן העניינים

pagefile.sys, hiberfil.sys ו-MEMORY.DMP

קובץמתי הוא בשימושמה נשמר בו
pagefile.sysכל זמן שהמחשב עובדדפי זיכרון פרטי ש-Windows הוציאה מה-RAM
hiberfil.sysבמעבר ל-Hibernate, שינה עמוקה שבה המחשב כבויתמונה של ה-RAM, כדי שבהדלקה הבאה הכול יחזור בדיוק למקומו
MEMORY.DMPאחרי מסך כחולתמונת זיכרון לניתוח הקריסה

שני מצבי שינה, שתי תשובות שונות. ב-Sleep הרגיל המחשב נשאר מוזן והמצב חי ב-RAM, ולכן שום קובץ מהטבלה לא נכתב. ב-Hybrid Sleep, ברירת המחדל במחשב שולחני, Windows כותבת בנוסף את hiberfil.sys, ליתר ביטחון: אם החשמל נקטע, ההדלקה הבאה ממשיכה מהקובץ.

השורה של MEMORY.DMP מסתירה קשר ל-pagefile.sys. ברגע של מסך כחול לא יוצרים קבצים חדשים, ולכן הליבה כותבת את תמונת הזיכרון לתוך ה-Page File שבכונן של Windows; באתחול שאחרי, התמונה מועתקת ל-%SystemRoot%\MEMORY.DMP.

התוצאה: מי שרוצה Complete memory dump צריך Page File בגודל ה-RAM בערך, או קובץ Dump ייעודי (Dedicated dump file) במקומו. ל-Dump קטן מספיק Page File צנוע בהרבה.

טעויות נפוצות
  • hiberfil.sys מרחיב את הזיכרון בזמן עומס, ו-pagefile.sys שומר את מצב השינה. התפקידים הפוכים: pagefile.sys בזמן ריצה, hiberfil.sys לשינה עמוקה.
  • אחרי מסך כחול פותחים את pagefile.sys כדי לנתח את הקריסה. ה-Page File הוא רק תחנת ביניים. קובץ הניתוח הוא MEMORY.DMP.
בדקו את עצמכם
במחשב 32 GB RAM ו-Page File של 16 GB. מה גבול ההתחייבות בערך?

בערך 48 GB, כי הגבול הוא RAM ועוד Page File.

Windows צריכה לפנות מה-RAM דף של קוד מתוך DLL. למה הוא לא יגיע ל-Page File?

כי הוא כבר שמור בקובץ ה-DLL בדיסק, ו-Windows תקרא אותו משם שוב כשיידרש.

המחשב נכנס ל-Sleep רגיל, לא Hybrid. איזה מהקבצים נכתב?

אף אחד. המצב נשמר ב-RAM, שנשאר מוזן בחשמל.

חזרה לתוכן העניינים

WinAPI, DLL ו-ntdll.dll

WinAPI: הפונקציות ש-Windows מציעה לתוכניות

WinAPI (Windows API, או Win32 API) הוא אוסף הפונקציות ש-Windows פותחת לתוכניות. כל פעולה של תוכנה מול המערכת, מפתיחת קובץ ועד הצגת חלון או הרצה של תוכנית אחרת, עוברת דרך פונקציה מהאוסף הזה.

הפונקציות מחולקות בין כמה DLLs של המערכת, לפי תחום:

DLLאחראית עללדוגמה
kernel32.dllתהליכים, Threads, זיכרון וקבציםCreateProcess, CreateThread, CreateFile, ReadFile, CloseHandle
user32.dllחלונות והודעותMessageBox, CreateWindowEx, GetMessage, DestroyWindow
gdi32.dllגרפיקה וציורBitBlt, TextOut
advapi32.dllRegistry, אבטחה ושירותיםRegOpenKeyEx, RegCloseKey

שלוש פונקציות מהטבלה נשמעות דומות, אבל כל אחת פועלת על משהו אחר:

פונקציהמה נוצר או מסתיים
CreateProcessתהליך נפרד, ובו התוכנית שביקשתם ומרחב כתובות שלו
CreateThreadThread נוסף, באותו תהליך ובאותו מרחב כתובות
ExitProcessהתהליך שקרא לה, כולו

בתוכנית שלמטה כתוב CreateFileW ולא CreateFile. ה-W (wide) אומר שהפונקציה מקבלת מחרוזות Unicode, ולכן הנתיבים כתובים עם L לפניהם; לצידה קיימת CreateFileA, שמקבלת מחרוזות ANSI. כך גם MessageBoxA ו-MessageBoxW, ועוד פונקציות רבות שמקבלות טקסט.

ההבדל בין A ל-W הוא רק סוג המחרוזת: שתיהן פועלות במצב משתמש, ושתיהן קיימות בתוכניות של 32 ושל 64 ביט.

C
#include <windows.h>
#include <stdio.h>

static void try_open(const wchar_t *path) {
    HANDLE h = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL,
                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (h == INVALID_HANDLE_VALUE) {
        DWORD code = GetLastError();      /* read it at once, before any other call */
        printf("open failed, GetLastError = %lu\n", code);
        return;
    }
    printf("opened, handle is valid\n");
    CloseHandle(h);                       /* give the kernel object back */
}

int main(void) {
    try_open(L"C:\\Windows\\win.ini");
    try_open(L"C:\\Windows\\no_such_inventory.csv");
    try_open(L"C:\\no_such_dir\\inventory.csv");
    return 0;
}
פלט
opened, handle is valid
open failed, GetLastError = 2
open failed, GetLastError = 3

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

קוד 2 הוא ERROR_FILE_NOT_FOUND: התיקייה קיימת והקובץ לא. קוד 3 הוא ERROR_PATH_NOT_FOUND: כבר התיקייה חסרה. ובפתיחה שהצליחה, ה-Handle חוזר לליבה ב-CloseHandle.

לא להתבלבל עם שמות קרובים: SetLastError היא זו שכותבת את הקוד, GetExitCodeProcess שואלת באיזה קוד תהליך הסתיים, ו-GetMessage מושכת הודעות של חלון.

ומה קרה בתוך CreateFileW? היא לא פותחת קבצים בעצמה, אלא מעבירה את הבקשה ל-ntdll.dll, ושם מתבצעת קריאת המערכת לליבה (בחלק הבא). פונקציות של חלונות וגרפיקה עוברות בדרך אחרת, דרך win32u.dll אל win32k, ויש פונקציות שמסתיימות כולן במצב משתמש.

גם קוד C# יכול לקרוא לכל אלה, בעזרת P/Invoke.

ומה אם תוכנית מעבירה ל-ReadFile חוצץ של 16 בייטים ומצהירה שגודלו 4096? הפונקציה רצה בתוך התהליך ומאמינה למספר, ולכן היא עלולה לכתוב מעבר לחוצץ. במקרה הטוב התהליך נופל, ובמקרה הרע נפתחה גלישת חוצץ שתוקף יכול לנצל כדי להריץ קוד.

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

טעויות נפוצות
  • kernel32.dll מציגה חלונות, ו-user32.dll מנהלת תהליכים וזיכרון. הפוך: kernel32 לתהליכים, לזיכרון ולקבצים, user32 לחלונות ולהודעות.
  • user32.dll מבצעת את קריאות המערכת, ו-kernel32.dll נועדה לכתיבת דרייברים. את המעבר לליבה מבצעת ntdll.dll. kernel32 היא ספריית מצב משתמש לתוכניות רגילות.
  • W היא גרסת הליבה ו-A גרסת מצב משתמש, או ש-A ל-32 ביט ו-W ל-64 ביט. ההבדל הוא סוג המחרוזות: ANSI מול Unicode.
  • GetLastError מביאה את השגיאה האחרונה מ-Event Viewer, או את השגיאות של כל התהליכים. היא מחזירה קוד אחד: האחרון של ה-Thread שקורא לה.
  • CreateThread היא הדרך להריץ תוכנית נוספת. תוכנית נוספת בתהליך משלה מריצים ב-CreateProcess.
חזרה לתוכן העניינים

DLL: קוד משותף שנטען בזמן ריצה

DLL (Dynamic-Link Library) הוא קובץ של פונקציות וקוד שתוכניות טוענות בזמן שהן רצות. הוא לא רץ לבד ואין לו תהליך משלו. הוא גם לא נצרב לתוך ה-EXE בבנייה; את זה עושה קישור סטטי (Static linking).

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

לשיתוף יש גם צד שני: DLL מרכזי משרת תוכנות ורכיבי מערכת רבים, ולכן מי שמוחק או משנה אותו ביד גורם לתקלות ולקריסות במקומות שלא חשב עליהם.

דרך טעינהמתי ה-DLL נטעןאיך
Implicit (מרומזת)עם תחילת התהליךה-DLL רשום בטבלת הייבוא (Import table) של התוכנית
Explicit (מפורשת)כשהקוד מחליטLoadLibrary, אחריה GetProcAddress לכתובת הפונקציה, ובסוף FreeLibrary
Delay-loadingבקריאה הראשונה לפונקציה ממנוהקישור מוגדר בבנייה, והטעינה נדחית עד שצריך

נבנה DLL קטן עם פונקציה אחת ועם DllMain שמודיעה מתי היא נקראת:

C
#include <windows.h>
#include <stdio.h>

BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved) {
    if (reason == DLL_PROCESS_ATTACH) printf("[greeter.dll] attached\n");
    if (reason == DLL_PROCESS_DETACH) printf("[greeter.dll] detached\n");
    return TRUE;                          /* keep DllMain tiny: it runs under the loader lock */
}

__declspec(dllexport) int Greet(const char *who) {
    printf("hello, %s\n", who);
    return 42;
}

ותוכנית שטוענת אותו פעמיים, מבקשת שתי פונקציות ומשחררת אותו בשני שלבים. שני הקבצים נבנו ב-gcc: gcc -shared greeter.c -o greeter.dll ו-gcc host.c -o host.exe.

C
#include <windows.h>
#include <stdio.h>

typedef int (*GreetFn)(const char *);

int main(void) {
    HMODULE first  = LoadLibraryW(L"greeter.dll");   /* count 1: DllMain runs */
    HMODULE second = LoadLibraryW(L"greeter.dll");   /* count 2: same module, no new attach */
    printf("same module: %s\n", first == second ? "yes" : "no");

    GreetFn greet = (GreetFn)GetProcAddress(first, "Greet");
    printf("Greet returned %d\n", greet("Noa"));

    FARPROC missing = GetProcAddress(first, "Farewell");
    printf("Farewell found: %s, GetLastError = %lu\n", missing ? "yes" : "no", GetLastError());

    FreeLibrary(first);                               /* count 1: still loaded */
    printf("after one FreeLibrary, loaded: %s\n", GetModuleHandleW(L"greeter.dll") ? "yes" : "no");
    FreeLibrary(second);                              /* count 0: unloaded, DllMain runs */
    printf("after two FreeLibrary, loaded: %s\n", GetModuleHandleW(L"greeter.dll") ? "yes" : "no");
    return 0;
}
פלט
[greeter.dll] attached
same module: yes
hello, Noa
Greet returned 42
Farewell found: no, GetLastError = 127
after one FreeLibrary, loaded: yes
[greeter.dll] detached
after two FreeLibrary, loaded: no

שלושה דברים עולים מהפלט. DllMain רצה פעם אחת בטעינה, למרות שתי קריאות ל-LoadLibrary. GetProcAddress על שם שלא קיים מחזירה NULL, וקוד 127 הוא ERROR_PROC_NOT_FOUND.

הסיבה שהשורה detached הופיעה רק אחרי ה-FreeLibrary השנייה: לכל DLL טעון יש מונה הפניות (Reference count). שתי הטעינות הביאו אותו ל-2, השחרור הראשון הוריד ל-1, וה-DLL עזב את זיכרון התהליך רק באפס.

נניח שיצאה גרסה 2 של greeter.dll ואתם רוצים אותה בתהליך שכבר רץ. קודם מורידים את המונה לאפס ב-FreeLibrary, ואז LoadLibrary עם הנתיב של הקובץ החדש. אם מודול אחר בתהליך מחזיק הפניה משלו, המונה לא יתאפס והגרסה הישנה תישאר.

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

ומה עם DllMain שב-greeter.c? זו נקודת כניסה רשות: Windows קוראת לה כשתהליך או Thread נקשרים ל-DLL או מתנתקים ממנו, ובגלל זה ראינו attached ו-detached. היא רצה כשנעילת ה-Loader תפוסה, ולכן הגוף שלה קצר; ואל Greet הגענו דרך GetProcAddress, לא דרך DllMain.

השיתוף שחוסך זיכרון יוצר גם שתי בעיות מוכרות:

תופעהמה קורהמה עוזר
DLL hellתוכנה מתקינה גרסה של DLL משותף מעל גרסה קיימת, ותוכנה אחרת, שצריכה את הגרסה הקודמת, מפסיקה לעבודSide-by-side assemblies: כל גרסה נשמרת בנפרד בתיקייה WinSxS, וה-Manifest של כל אפליקציה קובע איזו גרסה תיטען לה
DLL search order hijackingDLL זדוני בשם שהתוכנה מחפשת מונח בתיקייה שנבדקת לפני התיקייה הנכונה, ונטען במקום המקוריKnownDLLs ו-Safe DLL search mode מצמצמים את הסיכון

ושני פרטים לסיום: גם Assembly של .NET נשמרת לפעמים כקובץ .dll, ו-regsvr32 משמש לרישום DLL שמממש רכיב COM.

תרחיש 14: תוכנת גרפיקה שלא עולה בגלל DLL חסר

תוכנת גרפיקה לא נפתחת, ובמקום החלון מופיעה הודעה בנוסח The program can't start because imgcodec.dll is missing.

  1. מאתרים: Dependency Walker, או Process Monitor, מציג את כל ה-DLLs שהתוכנה צריכה ומראה איזה מהם חסר או בגרסה הלא נכונה. לפעמים גם Event Viewer מזכיר את המודול שנכשל.
  2. מתקנים: מתקינים מחדש את התוכנה, או את הרכיב שאמור לספק את ה-DLL.
  3. לא יעזור: sfc /scannow מתקן רק קבצי מערכת מוגנים של Windows. הוא לא בודק תלויות של תוכנות אחרות ולא מוריד דבר מהאינטרנט.
  4. יזיק: להעתיק DLL באותו שם מגרסת Windows אחרת. זה ניחוש שעלול להביא גרסה לא תואמת, לא אבחון.
  5. והסיבה הרגילה: קובץ שנמחק או שלא הותקן, לא וירוס.
טעויות נפוצות
  • אחרי LoadLibrary קוראים ל-FreeLibrary, ל-DllMain או ל-CreateFile כדי להגיע לפונקציה. הצעד שמחזיר את הכתובת הוא GetProcAddress.
  • כל תהליך מקבל עותק פרטי של קוד ה-DLL, או שרק תהליך אחד יכול להחזיק אותו בכל רגע. הקוד משותף בין כל התהליכים שטוענים אותו.
  • DLL שייך לתוכנה אחת, מחזיק את המסמכים שלכם, או נטען בידי ה-Bootloader. DLL הוא קוד משותף שתהליכים טוענים בזמן ריצה.
  • DLL hell הוא מצב שבו יותר מדי DLLs מאטים את העלייה, או שגרסה זדונית החליפה גרסה תקינה. DLL hell הוא התנגשות גרסאות. החלפה זדונית נקראת Hijacking.
  • כמה גרסאות של DLL מחזיקים יחד בעזרת החלפה ב-System32, PATH או regsvr32. גרסאות במקביל הן העבודה של WinSxS יחד עם ה-Manifest.
בדקו את עצמכם
עורך תמונות צריך את ExportPdf מתוך pdfkit.dll, אבל רק אם המשתמש בחר בייצוא. אילו קריאות יבצע הקוד?

LoadLibrary כדי לטעון את pdfkit.dll בזמן ריצה, ואחריה GetProcAddress כדי לקבל את הכתובת של ExportPdf. בסיום FreeLibrary.

תהליך קרא ל-LoadLibrary פעמיים על אותו DLL ול-FreeLibrary פעם אחת. האם ה-DLL עדיין טעון?

כן. המונה ירד מ-2 ל-1, וה-DLL יוצא רק כשהוא מגיע לאפס.

חזרה לתוכן העניינים

ntdll.dll: התחנה האחרונה לפני הליבה

ntdll.dll יושבת בתחתית שכבות מצב המשתמש, ומתחתיה כבר נמצאת הליבה. כל תהליך משתמש רגיל טוען אותה. תהליך של 32 ביט שרץ ב-Windows של 64 ביט טוען אפילו שתיים: גרסה של 32 ביט וגרסה של 64 ביט.

  • ה-Native API: פונקציות שמתחילות ב-Nt וב-Zw, למשל NtCreateFile.
  • System call stubs: קטעי קוד קצרים שמבצעים את המעבר לליבה.
  • הקוד של ה-Loader ושל ה-Heap: פונקציות Ldr* ו-Rtl*.

כך עוברת בקשה לפתוח קובץ, מהקוד שלכם ועד הליבה:

Text
your program    -> CreateFileW    kernel32.dll / kernelbase.dll   (WinAPI layer, user mode)
kernelbase.dll  -> NtCreateFile   ntdll.dll                       (Native API, user mode)
ntdll.dll       -> syscall        x64 instruction (x86: sysenter)  CPU switches to kernel mode
ntoskrnl.exe    opens the file                                    (kernel mode)

אפשר לבדוק בעצמכם איזו פונקציה נמצאת באיזו ספרייה, בעזרת GetProcAddress:

C
#include <windows.h>
#include <stdio.h>

static void look(const wchar_t *dll, const char *name) {
    HMODULE m = LoadLibraryW(dll);
    printf("%-14ls %-16s %s\n", dll, name, GetProcAddress(m, name) ? "exported" : "-");
}

int main(void) {
    look(L"ntdll.dll",    "NtCreateFile");
    look(L"ntdll.dll",    "CreateFileW");
    look(L"ntdll.dll",    "MessageBoxW");
    look(L"kernel32.dll", "CreateFileW");
    look(L"user32.dll",   "MessageBoxW");
    look(L"user32.dll",   "CreateProcessW");
    look(L"advapi32.dll", "RegOpenKeyExW");
    return 0;
}
פלט
ntdll.dll      NtCreateFile     exported
ntdll.dll      CreateFileW      -
ntdll.dll      MessageBoxW      -
kernel32.dll   CreateFileW      exported
user32.dll     MessageBoxW      exported
user32.dll     CreateProcessW   -
advapi32.dll   RegOpenKeyExW    exported

ntdll.dll מייצאת את NtCreateFile, אבל לא את CreateFileW ולא את MessageBoxW. MessageBoxW ו-CreateWindowEx נמצאות ב-user32.dll, ו-RegOpenKeyEx ב-advapi32.dll; אף אחת מהן לא שייכת ל-Native API.

שאלה על ntdll.dllתשובה
באיזה מצב היא רצה?מצב משתמש (Ring 3), לא Ring 0. היא לא הליבה, ואין בה דרייברים
יש בה משהו גרפי?לא. אין בה פונקציות GUI, ואין לה קשר לתפריט ההתחלה או לשורת המשימות
למה תוכנות רגילות לא קוראות לה ישירות?רוב ה-Native API אינו מתועד, ומספרי קריאות המערכת מתחלפים בין גרסאות Windows. לכן קוראים ל-WinAPI
מה אם היא נפגמה, או הוחלפה בגרסה לא תואמת?כמעט כל תהליך טוען אותה, ולכן תוכנות והמערכת עצמה עלולות ליפול
איך רואים שמות של פונקציות בתוכה בזמן ניתוח?WinDbg מושך קובצי PDB משרת הסמלים של Microsoft ומצמיד שמות לכתובות שבה, כך שב-Dump מופיעים שמות במקום מספרים
טעויות נפוצות
  • ntdll.dll רצה בליבה ונותנת לתוכנות גישה ישירה לחומרה. היא במצב משתמש. תפקידה להעביר את הבקשה לליבה, לא לעקוף אותה.
  • תהליכי המערכת שרצים ברקע לא טוענים את ntdll.dll. כל תהליך משתמש רגיל טוען אותה.
  • ntdll.dll אחראית על Hibernate, ואם היא נפגמה מורידים עותק מאתר Microsoft. Hibernate נשען על hiberfil.sys. ntdll.dll היא שכבת המעבר לליבה.
  • WinDbg בונה סמלים מקוד המקור, או קורא את קוד המקור מתוך הליבה. הוא מוריד PDB מוכנים משרתי הסמלים של Microsoft.
חזרה לתוכן העניינים

Hooking והזרקה: להבין ולזהות

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

API HookingDLL InjectionProcess Hollowing
מה זהקריאה לפונקציית מערכת מיורטת ומופנית לקוד אחר, שיכול לקרוא או לשנות את הפרמטרים ואת התוצאהתהליך אחד גורם לכך ש-DLL לבחירתו ייטען בתוך תהליך אחר, והקוד של ה-DLL רץ שםתהליך לגיטימי נוצר, התוכן שלו בזיכרון מרוקן, ובמקומו מוכנס קוד זר
איך, במיליםשכתוב ההוראות הראשונות של הפונקציה בזיכרון (כך עובדת הספרייה Microsoft Detours), או החלפת הכתובת שלה בטבלת הייבוא (IAT)הדפוס הקלאסי: CreateRemoteThread פותח Thread בתהליך היעד, וה-Thread קורא ל-LoadLibraryפונקציות Native API מתוך ntdll.dll, ורק עם הרשאות מתאימות על תהליך היעד
מי משתמשכלי דיבוג, ניטור ואבטחה; וגם תוכנות זדוניות, כדי לרשום הקשות, להסתיר תהליכים ולעקוף בקרותכלי דיבוג וניטור, וגם תוכנות זדוניותתוקפים
איך זה נראה מבחוץהתהליך נראה רגיל, וההבדל קיים רק בזיכרון שלומודול זר בתוך התהליך, והצירוף CreateRemoteThread עם LoadLibrary שתוכנות אבטחה מנטרותשם תקין ברשימת התהליכים, וקוד זר בפנים
כמה רחוק מגיע Hook? נניח שכלי ניטור שינה את תחילת NtReadFile בתוך תהליך של דפדפן. הדף ששונה הוא עותק פרטי של הדפדפן (Copy-on-write), ולכן ntdll.dll שבדיסק ושאר התהליכים שטענו אותה לא רואים דבר. אם ה-Hook שגוי, רק בדפדפן קריאות מערכת ייכשלו או יחזירו תוצאות לא נכונות, ושום רכיב בליבה לא ישחזר את הקוד המקורי.

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

כמה דברים נשמעים כמו הזרקה ואינם: החלפה של קובץ DLL על הדיסק, רישום DLL ב-regsvr32, או קריאה ישירה ל-NtCreateFile. ו-SetWindowsHookEx נשמע כמו Hooking של פונקציות, אבל הוא מיירט הודעות, כמו מקלדת ועכבר, ולא קריאות לפונקציות.

ntdll.dll עצמה לא פותחת לאף תהליך דלת לזיכרון של תהליך אחר. הזרקה ו-Hollowing דורשות הרשאות מתאימות על תהליך היעד.

טעויות נפוצות
  • API Hooking הוא הוספת ערך למפתח Run, הצפנת קבצים לכופר, או כתיבה מעבר לסוף חוצץ. אלה התמדה, כופרה וניצול גלישת חוצץ. Hooking הוא יירוט של קריאות לפונקציות.
  • Hook ב-ntdll.dll של תהליך אחד פוגע בכל המערכת, ושורד אתחול. הוא חי רק בזיכרון של התהליך שבו הותקן ונעלם יחד איתו.
  • כדי ליירט קריאה לפונקציה משתמשים ב-SetWindowsHookEx, או מריצים Thread בעדיפות גבוהה. SetWindowsHookEx מיירט הודעות, ועדיפות לא קשורה ליירוט. יירוט פונקציה נעשה בשכתוב תחילתה או בהחלפת כתובת ב-IAT.
  • ntdll.dll היא ספרייה של ממשק גרפי. היא שכבת המעבר לליבה.
בדקו את עצמכם
תוכנת ניטור התקינה Hook פגום על NtWriteFile בתוך תהליך אחד. מי ירגיש בזה?

רק התהליך הזה, כי השינוי נעשה בעותק הפרטי שלו בזיכרון. שאר התהליכים והקובץ בדיסק לא השתנו.

תהליך יוצר Thread בתהליך אחר, וה-Thread הזה קורא ל-LoadLibrary. איך נקרא הדפוס?

DLL Injection בשיטה הקלאסית, דרך CreateRemoteThread. זה בדיוק הצירוף שתוכנות אבטחה מחפשות.

חזרה לתוכן העניינים

cmd: מפרש הפקודות של Windows

פקודות פנימיות, תוכניות חיצוניות ועזרה

cmd.exe, ה-Command Prompt, הוא מפרש הפקודות הוותיק של Windows: מקלידים שורת טקסט והוא מריץ אותה, ואותו מנוע מריץ גם קבצי Batch. הדרך הכי טובה להכיר אותו היא לשאול אותו. אלה השורות הראשונות של התשובה:

Text
dir /?
פלט
Displays a list of files and subdirectories in a directory.

DIR [drive:][path][filename] [/A[[:]attributes]] [/B] [/C] [/D] [/L] [/N]
  [/O[[:]sortorder]] [/P] [/Q] [/R] [/S] [/T[[:]timefield]] [/W] [/X] [/4]

/? אחרי שם של פקודה הוא שאלת העזרה של cmd, ו-help לבדה מדפיסה רשימה של פקודות. מי שמגיע מ-Linux ינסה man, --help או -h, ו-cmd פשוט לא יבין.

dir עצמה היא פקודה פנימית: היא חלק מ-cmd.exe ואין לה קובץ משלה, וכך גם cd, copy, move, del, mkdir, type, cls, echo ו-set. לעומתן tasklist, taskkill, sc, reg, whoami, systeminfo ו-attrib הן תוכניות חיצוניות, קובצי exe ב-System32 ש-cmd מפעיל.

כדי לעבור לתיקייה כותבים cd ואחריו הנתיב, למשל cd C:\Projects\reports. שאר המועמדים לתפקיד עושים משהו אחר: dir מציגה תוכן, move מזיזה קבצים, ו-goto עובדת רק בתוך קובץ Batch, שם היא קופצת לתווית.

ואיך יודעים שחלון מוגבה? אם פתחתם אותו ב-Run as administrator, הכותרת שלו נפתחת במילה Administrator:.

חזרה לתוכן העניינים

Pipe, משתנים וקבצי Batch

Pipe (התו |) מחבר שתי פקודות: מה שהראשונה מדפיסה לפלט הרגיל (stdout) נכנס כקלט לשנייה, והשנייה עובדת עליו. זה לא קובץ ולא סתם המתנה, הנתונים עצמם עוברים.

Text
tasklist | find /i "explorer"
פלט
explorer.exe                  1320 Console                    1     71,416 K

> עושה משהו אחר: הוא כותב את הפלט לקובץ, למשל dir C:\Windows > winlist.txt, ולא לפקודה נוספת.

פלט השגיאות (stderr) לא נכנס ל-Pipe, אלא אם מוסיפים 2>&1. בקובץ הבא dir מחפשת תיקייה שלא קיימת, ו-find סופרת את השורות שהגיעו אליה:

Text
@echo off
echo --- 1
dir C:\no_such_folder_77 | find /c /v ""
echo --- 2
dir C:\no_such_folder_77 2>&1 | find /c /v ""
פלט
--- 1
File Not Found
5
--- 2
6

בהרצה הראשונה ההודעה File Not Found יוצאת ישר למסך, כי היא ב-stderr, ו-find סופרת רק חמש שורות. עם 2>&1 ההודעה נכנסת גם היא ל-Pipe, והספירה עולה לשש.

משתנים: %NAME% מוחלף בערך שלו כש-cmd קורא את השורה. הרחבה מאוחרת (Delayed expansion) נכתבת !NAME!, דורשת setlocal EnableDelayedExpansion, ונועדה למשתנים רגילים שהערך שלהם משתנה בתוך בלוק; היא לא קשורה למשתנה של לולאת FOR.

קובץ Batch, עם סיומת .bat או .cmd, הוא רשימה של פקודות cmd שרצות אחת אחרי השנייה. בתוכו הארגומנטים נקראים %1, %2 וכן הלאה. את הקובץ הבא הרצנו בפקודה args.bat north south:

Text
@echo off
echo first=%1 second=%2
set CITY=Haifa
echo city=%CITY%
פלט
first=north second=south
city=Haifa
תרחיש 15: לולאה שעובדת בחלון ונופלת בקובץ

בחלון cmd פתוח השורה הבאה מדפיסה שלושה צבעים:

Text
for %c in (red green blue) do @echo color: %c
פלט
color: red
color: green
color: blue

מעתיקים את אותה לולאה לקובץ colors.bat ומריצים אותו:

Text
@echo off
for %c in (red green blue) do echo color: %c
פלט
c was unexpected at this time.

בתוך קובץ Batch, cmd קורא את %c כמשתנה רגיל ולא כמשתנה הלולאה, והפקודה נשברת. התיקון: להכפיל את סימן האחוז בכל מקום שבו מופיע משתנה הלולאה.

Text
@echo off
for %%c in (red green blue) do echo color: %%c
פלט
color: red
color: green
color: blue

CALL לפני ה-for, סוגריים מסולסלים או !c! לא פותרים את זה. מה שחסר הוא רק האחוז הכפול.

טעויות נפוצות
  • Pipe שומר את הפלט בקובץ, בדיוק כמו >. > כותב לקובץ. Pipe מעביר את הפלט לפקודה הבאה.
  • בצינור הפקודות רק רצות אחת אחרי השנייה, בלי לחלוק נתונים. הפלט של הראשונה הוא הקלט של השנייה, וזה כל הרעיון.
  • גם stdout וגם stderr נכנסים ל-Pipe מעצמם. רק stdout. stderr מצטרף רק עם 2>&1, כמו בדוגמה.
  • cmd משמש לגרירת קבצים, לקומפילציה של C#, או כאשף התקנה. cmd מריץ פקודות טקסט וקבצי Batch.
חזרה לתוכן העניינים

cmd לעומת PowerShell

PowerShell היא מעטפת חדשה יותר, וכאן היא מעניינת אותנו רק כנקודת השוואה ל-cmd.

ההבדל המרכזי הוא מה זורם ב-Pipe. ב-cmd עובר טקסט גולמי, ואם צריך שדה אחד מתוכו מפרקים את הטקסט בעצמכם (Parsing). ב-PowerShell עוברים אובייקטים של .NET עם מאפיינים, וניגשים לשדה לפי שמו.

כך מוציאים את ה-PID של explorer.exe ב-cmd. צריך לדעת שהוא המילה השנייה בשורה, ולבקש אותה ב-tokens=2:

Text
@echo off
for /f "tokens=2" %%p in ('tasklist /fi "imagename eq explorer.exe" /nh') do echo explorer PID: %%p
פלט
explorer PID: 1320

וב-PowerShell אותו מספר הוא פשוט המאפיין Id של אובייקט התהליך, ואפשר לבחור עמודות לפי שם:

Text
(Get-Process explorer).Id
Get-Service Dnscache, Spooler | Select-Object Name, Status, StartType
פלט
1320

Name      Status StartType
----      ------ ---------
Dnscache Running Automatic
Spooler  Running Automatic

גם משתני סביבה מראים את ההבדל בתחביר: הנתיב של Windows נכתב %SystemRoot% ב-cmd ו-$env:SystemRoot ב-PowerShell.

אם PowerShell חזקה יותר, למה cmd לא נעלם? בגלל ההיסטוריה: ארגונים מחזיקים הרבה קבצי Batch ישנים שנכתבו בשבילו, והם עדיין רצים בו כמו שהם.

טעויות נפוצות
  • PowerShell קיימת רק ב-Windows Server, ולכן במחשבים רגילים נשארים עם cmd. PowerShell מותקנת גם בגרסאות הדסקטופ של Windows.
  • כדי להשתמש ב-PowerShell בסקריפטים של ארגון צריך רישיון נפרד. אין רישיון כזה; PowerShell היא חלק מ-Windows.
  • cmd מריץ פקודות במקביל, ו-PowerShell רק אחת אחרי השנייה. ל-PowerShell יש הרצה מקבילית, למשל Jobs, וזו גם לא הסיבה שמשתמשים ב-cmd.
בדקו את עצמכם
למה סקריפט cmd שמשרשר tasklist ו-find צריך לחתוך מחרוזות כדי להגיע ל-PID?

כי ה-Pipe של cmd מעביר רק טקסט. ב-PowerShell עובר אובייקט, וה-PID הוא מאפיין שלו.

בקובץ cleanup.bat כתוב for %f in (*.log) do type %f, והוא נכשל. מה לשנות?

להחליף את %f ב-%%f בשני המקומות, כי בקובץ Batch משתנה לולאה נכתב עם שני סימני אחוז.

חזרה לתוכן העניינים

.NET Framework ו-CLR

מה זה .NET Framework

כדי להבין את .NET Framework, כדאי להתחיל ממה שקורה לקוד C# אחרי Build. התוצאה איננה קוד מכונה, אלא שפת ביניים בשם IL (או CIL). רק כשהתוכנית רצה, ה-CLR מתרגם את ה-IL לפקודות של המעבד שעליו היא רצה.

בזכות ה-IL השפה המקורית לא משנה: C#, VB.NET, F# ושפות נוספות מגיעות לאותה נקודה ורצות על אותו CLR. שפות שלא עוברות בדרך הזו לא שייכות לכאן: Java ו-Kotlin מכוונות ל-JVM, ו-Delphi 7 ו-Visual Basic 6 מפיקות בדרך כלל קוד מכונה ישר.

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

השם .NET Framework שייך לגרסה המקורית, שנבנתה ל-Windows. הטבלה מעמידה אותה מול מי שבאה אחריה:

.NET Framework.NET Core ו-.NET 5 ומעלה
מערכות הפעלהWindows בלבדWindows, Linux ו-macOS
גרסה אחרונה4.8.x, ואין אחריה גרסה חדשהממשיכה להתפתח
הקשר ביניהןהפלטפורמה המקוריתהממשיכה חוצת-הפלטפורמות
גרסאות זמן ריצהCLR 2.0 (מריץ את 2.0 עד 3.5) ו-CLR 4 (מריץ את 4.0 עד 4.8.1) יכולים לחיות זה לצד זה. 4.5 ומעלה מחליפה את 4.0 באותו מקום ולא מותקנת לצידהכמה גרסאות מותקנות יחד
טעויות נפוצות
  • .NET Framework מריצה אפליקציות גם על Linux ועל macOS. זו היכולת של .NET Core ושל .NET 5 ומעלה. Framework היא Windows בלבד.
  • ב-.NET Framework הקוד הופך לקוד מכונה כבר בבנייה, בלי שלב ביניים. הבנייה מפיקה IL, וה-JIT מתרגם אותו בזמן ריצה.
  • ל-.NET Framework אפשר לכתוב רק ב-C#. גם ב-VB.NET, ב-F# ובשפות נוספות.
  • .NET Framework היא DLL אחד ב-System32, מהדר C++, או אוסף הפונקציות הנטיביות של Windows. היא סביבת פיתוח והרצה: CLR וספריית מחלקות. הפונקציות הנטיביות הן WinAPI.
  • .NET Core הוא סתם שם חדש ל-.NET Framework. אלה שתי פלטפורמות שונות, ו-Core והגרסאות שאחריה חוצות פלטפורמות.
חזרה לתוכן העניינים

ה-CLR: JIT ו-Garbage Collector

CLR (Common Language Runtime) הוא המנוע שמריץ קוד .NET, ולקוד שהוא מריץ קוראים קוד מנוהל (Managed code).

תפקידמה ה-CLR עושה
טעינת Assembliesמאתר וטוען את הקבצים המקומפלים שהתוכנית צריכה
JIT (Just-In-Time Compilation)מתרגם IL לקוד מכונה בזמן הריצה, בהתאמה למעבד שעליו התוכנית רצה בפועל
ניהול זיכרוןמקצה אובייקטים, ו-Garbage Collector (GC) משחרר את אלה שכבר אין אליהם הפניה
בטיחותאוכף בטיחות טיפוסים ובודק גבולות של מערכים
חריגותמנהל את מנגנון ה-Exceptions

ה-GC לא עובד כמו מונה ההפניות של COM, שמשחרר אובייקט באותו רגע שבו אחרון המחזיקים עוזב. הוא רץ מפעם לפעם, בודק מה עדיין נגיש, ומשחרר בבת אחת את כל השאר.

C#
using System;
using System.Runtime.CompilerServices;

WeakReference probe = MakeOrphan();             // the only strong reference is already gone
Console.WriteLine("right after the last reference: alive = " + probe.IsAlive);
GC.Collect();                                   // forced here only to show the timing
Console.WriteLine("after a collection:            alive = " + probe.IsAlive);

int before = GC.CollectionCount(0);
byte[] last = Array.Empty<byte>();
for (int i = 0; i < 2_000_000; i++)
    last = new byte[100];                       // each array is garbage one step later
GC.KeepAlive(last);
Console.WriteLine("gen 0 collections during the loop: " + (GC.CollectionCount(0) - before));

[MethodImpl(MethodImplOptions.NoInlining)]
static WeakReference MakeOrphan()
{
    var order = new byte[1024];
    return new WeakReference(order);
}
פלט
right after the last reference: alive = True
after a collection:            alive = False
gen 0 collections during the loop: 40

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

הדוגמה הורצה על .NET מודרני, והעיקרון זהה ב-.NET Framework.

ה-GC מטפל רק בזיכרון מנוהל. משאב נטיבי, כמו Handle לקובץ שאובייקט מחזיק, משחררים ב-Dispose או ב-Close (ב-C# נוח לעשות זאת עם using).

כדי לראות את ה-GC בזמן אמת פותחים את Performance Monitor (perfmon) ומוסיפים את מוני ה-CLR של התהליך: כמה איסופים קרו בכל דור, ואיזה אחוז מהזמן הלך על GC.

תרחיש 16: שירות .NET שמגמגם כל כמה שניות

שירות .NET שעונה לבקשות נעצר לחלקיק שנייה כל כמה שניות, והחשד נופל על ה-GC.

  1. Task Manager ו-tasklist מראים כמה זיכרון התהליך תופס, אבל לא מתי ה-GC רץ.
  2. ildasm מפרק את ה-IL של Assembly, והוא לא מנטר תהליך חי.
  3. ב-Performance Monitor מוסיפים את מוני ה-CLR של התהליך, ורואים שגלי איסוף מתרחשים בדיוק בזמן העצירות.
  4. התיקון: לצמצם יצירה של אובייקטים זמניים בקוד שרץ הכי הרבה. אין טעם לחפש שחרור ידני, כי ל-CLR אין פונקציה כזו לזיכרון מנוהל.
טעויות נפוצות
  • ב-CLR המתכנת אחראי לשחרר כל אובייקט, כמו free ב-C. ה-GC עושה את זה בשבילו.
  • מערכת ההפעלה מנקה את הזיכרון של .NET בסוף כל פונקציה. ה-GC של ה-CLR מנהל אותו, ורץ כשהוא מחליט.
  • ה-CLR מתרגם לקוד מכונה כבר בזמן הבנייה. הבנייה מפיקה IL, וה-JIT מתרגם בזמן ריצה.
  • JIT הוא המנגנון שמשחרר אובייקטים, שמצפין Assemblies או שחוסם ספריות Native. JIT הוא תרגום של IL לקוד מכונה.
  • ה-CLR מריץ קוד C++ נטיבי בתוך הסביבה המנוהלת. קוד נטיבי נשאר מחוץ לה, וקוראים לו דרך Interop (P/Invoke).
חזרה לתוכן העניינים

Assembly, Strong Name, GAC, Reflection ו-CAS

התחילו מבעיה: בשרת רצים חמישה יישומים, וכולם צריכים את אותה ספריית לוגים, Logging.dll. אפשר להעתיק אותה לתיקיית bin של כל יישום, ואפשר להחזיק עותק אחד במקום מרכזי. המקום המרכזי של .NET Framework הוא ה-GAC (Global Assembly Cache), והוא יודע להחזיק גם כמה גרסאות של אותה ספרייה במקביל.

Logging.dll היא Assembly: יחידה מקומפלת של .NET, בקובץ .dll או .exe, עם IL ומטא-נתונים. כדי שה-GAC יקבל אותה, היא צריכה זהות שאין לה כפילויות: Strong Name, שמורכבת משם, גרסה, Culture ומפתח ציבורי, ומגובה בחתימה דיגיטלית.

את הזהות הזו בונים בעזרת sn.exe, שמפיק את שני המפתחות, והקומפילציה חותמת בהם. הסדר לא הפיך: בלי Strong Name אין כניסה ל-GAC, וההעתקה לשם לא מעניקה אותה.

שני דברים נראים קשורים אבל לא יוצרים Strong Name: מספר שנכתב ב-AssemblyVersion, ותעודת Authenticode, שתפקידה לומר מי פרסם את הקובץ.

וה-GAC גם איננו אחד משלושה מקומות אחרים שמחזיקים ספריות: System32 (ספריות נטיביות של Windows), תיקיית bin של יישום (ספריות שלו בלבד), והמטמון של NuGet (חבילות שהורדו לבנייה).

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

C#
using System;
using System.Reflection;

var box = new Locker();
Type t = box.GetType();

foreach (FieldInfo f in t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic))
    Console.WriteLine("private field found: " + f.Name);

FieldInfo code = t.GetField("code", BindingFlags.Instance | BindingFlags.NonPublic)!;
Console.WriteLine("code read from outside: " + code.GetValue(box));
code.SetValue(box, 1111);                       // private, and still changed from outside
box.Report();

object made = Activator.CreateInstance(t)!;     // build an object knowing only its Type
t.GetMethod("Report")!.Invoke(made, null);      // call a method chosen at run time

class Locker {
    private int code = 4826;                    // no public way to read or set it
    public void Report() => Console.WriteLine("locker code is now " + code);
}
פלט
private field found: code
code read from outside: 4826
locker code is now 1111
locker code is now 4826

הפלט מראה את הסיכון: השדה code הוא private, ובכל זאת קוד מבחוץ קרא אותו ושינה אותו. בהרצה רגילה (Full Trust) Reflection עוקפת את מגבלות הגישה של המחלקות, ולכן קוד זדוני שרץ בתוך האפליקציה יכול לגעת במה שהמחלקה התכוונה להסתיר.

שלוש הבהרות על הדוגמה: היא רצה בלי הרשאות מנהל; הנזק האפשרי הוא חשיפה ושינוי של מצב פרטי, לא רק האטה; ומה שקרה בה איננו Serialization (הפיכת אובייקט לבייטים) ואיננו JIT (תרגום IL לקוד מכונה).

לפני שנים .NET Framework ניסתה לרסן קוד בדרך אחרת: CAS (Code Access Security). במקום לשאול מי המשתמש, CAS שאל מאיפה הגיעה ה-Assembly ומה הראיות (Evidence) עליה, למשל חתימה, ולפי זה קבע אם מותר לה לגשת לקבצים, לרשת או למשאבים אחרים. היום כמעט לא משתמשים בו.

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

טעויות נפוצות
  • Reflection רואה רק חברים public. ב-Full Trust היא קוראת ומשנה גם private, כמו בדוגמה.
  • Reflection היא הצפנת קוד, או שם אחר ל-Serialization או ל-JIT. היא בחינה והפעלה דינמית של טיפוסים בזמן ריצה.
  • מספיק להעתיק DLL ל-GAC כדי שיקבל Strong Name. הפוך: בלי Strong Name הוא לא נכנס ל-GAC.
בדקו את עצמכם
ספריית הצפנה משמשת שבעה יישומים באותו שרת. איפה כדאי למקם אותה ב-.NET Framework, ומה צריך לקרות קודם?

ב-GAC. לפני כן היא צריכה Strong Name: sn.exe מפיק זוג מפתחות, והבנייה חותמת בו את הספרייה.

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

Reflection: בחינת המטא-נתונים של ה-Assembly ויצירת האובייקט באופן דינמי, למשל ב-Activator.CreateInstance.

חזרה לתוכן העניינים

סיכום

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

מושגבמשפט אחדמה לזכור למבחן
Bootloaderמעלה את Windows מהדיסק לזיכרוןהקושחה, bootmgr (ב-UEFI: bootmgfw.efi) שקורא את BCD, ואז winload שטוען את ntoskrnl.exe. ב-XP: NTLDR
boot.iniקובץ הטקסט של תפריט האתחול הישןנקרא בידי NTLDR, במערכות NT עד XP. timeout, default ונתיבי ARC. נערך ב-bootcfg
%SystemRoot%הנתיב לתיקיית Windowsבדרך כלל C:\Windows. ב-PowerShell: $env:SystemRoot. set משנה אותו רק בחלון הנוכחי
Registryמסד ההגדרות ההיררכיHKLM, HKCU, HKCR, HKU, HKCC. regedit גרפי ו-reg לסקריפטים. export/import לקובץ .reg, save/load לכוורת
SAMמאגר החשבונות המקומייםSystem32\config\SAM, גיבובים ולא טקסט גלוי. בדומיין: Active Directory
lsass.exeמאמת משתמשים ואוכף מדיניות אבטחהבודק מול SAM או מול בקר הדומיין ומנפיק אסימון. LSA Protection. אם הוא נופל, המחשב מאתחל
UACהרשאות מנהל רק אחרי אישוראסימון מפוצל, ארבע רמות, Secure Desktop, סמל מגן, Virtualization לתוכנות ישנות
Serviceתוכנית רקע במצב משתמשservices.exe, Session 0. Automatic, Delayed, Manual, Disabled. sc, Recovery, DependOnService
Driverהקוד שמתווך בין Windows להתקן.sys ב-System32\drivers. באג בליבה: BSOD. חתימה חובה ב-64 ביט. Device Manager, Driver Store, Driver Verifier
Task Managerתהליכים ומשאבים במבט אחדCtrl+Shift+Esc. Processes, Performance, Startup, Details (PID, Affinity, Dump), Services
Threadיחידת הביצוע בתוך תהליךמרחב כתובות משותף, מחסנית פרטית. מתוזמן לפי עדיפות, באופן מקדים
Handleערך אטום שמייצג אובייקט ליבהטבלה נפרדת לכל תהליך. CloseHandle. ירושה רק למסומנים, DuplicateHandle
Desktopהמשטח הגרפי, ואובייקט שמחזיק חלונותSession, ובו Window Station, ובה Desktops. Secure Desktop מבודד, Win+Tab רק מקבץ
Page fileזיכרון וירטואלי על הדיסקpagefile.sys, רק זיכרון פרטי. Commit limit הוא בערך RAM ועוד הקובץ. לא hiberfil.sys
WinAPIהפונקציות ש-Windows חושפת לתוכניותkernel32, user32, gdi32, advapi32. A מול W. GetLastError מיד אחרי כישלון
DLLספרייה משותפת שנטענת בזמן ריצהLoadLibrary, GetProcAddress, FreeLibrary ומונה הפניות. DLL hell נפתר ב-WinSxS
ntdll.dllהשכבה שמעבירה קריאות לליבהNative API (Nt*), syscall. במצב משתמש, בכל תהליך
cmdמפרש הפקודות הקלאסי/? לעזרה, cd לניווט, Pipe של טקסט, %%i בקובץ Batch
.NET Frameworkהפלטפורמה של Microsoft לפיתוח ב-WindowsCLR וספריית מחלקות. C#, VB.NET, F#. Windows בלבד, אחרונה 4.8.x
CLRמנוע הריצה של .NETJIT מ-IL, GC אוטומטי, Assemblies, GAC ו-Strong Name, Reflection

ואלה הזוגות שהכי קל להחליף ביניהם. לכל זוג, השאלה שמכריעה:

כשמתלבטים ביןהשאלה שמכריעה
Process או Threadמי מחזיק את המשאבים (תהליך), ומי מריץ את הפקודות (Thread)?
CreateProcess או CreateThreadצריך מרחב כתובות נפרד? CreateProcess. מספיק עוד מבצע באותו מרחב? CreateThread
Service או Driverהקוד רץ במצב משתמש בלי חלון? שירות. הוא בליבה ומטפל בהתקן? דרייבר
Delayed Start, Manual או Disabledמתי השירות עולה: קצת אחרי האתחול, רק כשמבקשים, או אף פעם עד שמשנים?
Handle Inheritance או DuplicateHandleתהליך ילד שיורש מה שסומן מראש, או תהליך קיים שמקבל עותק יזום?
CloseHandle, DestroyWindow או FreeLibraryמה משחררים: אובייקט ליבה, חלון, או DLL טעון?
Secure Desktop או Desktop וירטואליצריך בידוד מתוכנות המשתמש? רק ב-Secure Desktop; הווירטואלי רק ממיין חלונות
Task Manager, Resource Monitor, Process Explorer, Process Monitorצריך סכום? Task Manager. קבצים וחיבורים לכל תהליך? Resource Monitor. מי נועל קובץ? Process Explorer. רישום חי של קבצים ו-Registry? Process Monitor
pagefile.sys, hiberfil.sys או MEMORY.DMPמתי הקובץ נכתב: תוך כדי עבודה, בכניסה לשינה עמוקה, או אחרי מסך כחול?
kernel32.dll, user32.dll או ntdll.dllהפונקציה עוסקת בתהליכים, זיכרון וקבצים (kernel32), בחלונות והודעות (user32), או במעבר עצמו לליבה (ntdll)?
JIT או GCמתרגמים קוד, או מפנים זיכרון?
.NET Framework או .NET 5 ומעלהצריך לרוץ גם על Linux או macOS? רק הגרסאות החדשות יודעות
NTLDR או bootmgrיש boot.ini (XP ומטה)? NTLDR. יש BCD (Vista ואילך)? bootmgr
bootmgr או winloadעוד בוחרים מה לטעון (bootmgr), או כבר טוענים ליבה ודרייברי אתחול (winload)?
bcdedit או bootcfgאיזה קובץ עורכים: BCD או boot.ini?
%SystemRoot% או %SystemDrive%רוצים את התיקייה C:\Windows, או רק את האות C:?
reg export/import או reg save/loadקובץ .reg קריא של מפתח, או כוורת בינארית שלמה?
SAM או Active Directoryחשבון של מחשב אחד, או חשבון דומיין שנשמר ב-NTDS.dit?
SAM או lsass.exeשואלים איפה הגיבובים שמורים (SAM), או מי בודק סיסמה ומנפיק אסימון (lsass.exe)?
LSA Protection (PPL) או Credential Guardמגינים על lsass.exe כתהליך מוגן, או מעבירים את הסודות לסביבה וירטואלית מבודדת?
בדקו את עצמכם
במחשב BIOS עם Windows 10, סדרו לפי הזמן: ntoskrnl.exe, הקושחה, winload.exe, bootmgr.

הקושחה, bootmgr, winload.exe, ntoskrnl.exe.

תוכנה מנסה לפתוח קובץ הגדרות, נכשלת, ורוצה לרשום ביומן את הסיבה. אילו שני מושגים מהפרק משתתפים, ובאילו פונקציות?

Handle ו-WinAPI. CreateFile מחזירה INVALID_HANDLE_VALUE, ומיד אחריה GetLastError מחזירה את הקוד של ה-Thread, למשל 2 כשהקובץ לא קיים.

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

בכניסה lsass.exe מאמת אותו מול הגיבובים שב-SAM ומנפיק אסימון מפוצל. כשהמתקין מבקש הרשאות מנהל, UAC מציג אישור על ה-Secure Desktop. לפני הטעינה Windows בודקת את החתימה הדיגיטלית של הדרייבר.

שירות שתלוי בשירות אחר נופל מדי פעם, ולפעמים מחזיק קובץ נעול. אילו שלושה מקומות יעזרו לכם?

DependOnService ב-Registry לתלות, הלשונית Recovery להפעלה מחדש אוטומטית, ו-Process Explorer (Find Handle or DLL) כדי לגלות מי מחזיק את הקובץ.