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

Windows

Registry, Sam, Lsass.exe, Uac, Service, Driver

ה-Registry, קובץ SAM, תהליך lsass.exe, UAC, שירותים ודרייברים ב-Windows.

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

חומר לימוד

Registry, Sam, Lsass.exe, Uac, Service, Driver: שישה רכיבים של Windows מבפנים

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

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

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

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

מושגי יסוד לפני שצוללים פנימה

שתי רמות הרשאה: מצב משתמש ומצב ליבה

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

ברמה הפנימית, מצב ליבה (kernel mode), שוכנים גרעין המערכת (הקובץ ntoskrnl.exe) ורוב מנהלי ההתקנים. מי שרץ שם נוגע בכל כתובת זיכרון ובכל רכיב חומרה, בלי חסם.

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

מכאן נגזר גם מה קורה בתקלה. תוכנה במצב משתמש שנתקלת בשגיאה קטלנית נסגרת לבדה, והסביבה ממשיכה כרגיל. קוד במצב ליבה שטועה טעות חמורה אינו מוקף בשום שכבה מגנה, ולכן המערכת כולה נבלמת ומציגה מסך כחול (BSOD, Blue Screen of Death).

C
#include <stdio.h>

int main(void) {
    int *p = NULL;               /* address 0 is never mapped into a process */
    printf("before the bad write\n");
    fflush(stdout);
    *p = 42;                     /* a user-mode access violation happens here */
    printf("this line is never reached\n");
    return 0;
}
פלט
before the bad write

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

Python
import os, subprocess

child = os.path.join(os.getcwd(), "crash.exe")
result = subprocess.run([child])                 # launch the faulting program
print("child exit status:", hex(result.returncode & 0xFFFFFFFF))
print("parent process still running")
פלט
before the bad write
child exit status: 0xc0000005
parent process still running

קוד היציאה 0xc0000005 הוא הקוד של הפרת גישה (access violation). התקלה ארעה במצב משתמש, ולכן נסגר רק התהליך הזה בעוד האב ממשיך ברוגע. אותה טעות במצב ליבה לא הייתה נעצרת כך, אלא מפילה את המערכת למסך כחול.

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

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

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

מי אתם מבחינת המערכת: SID ואסימון גישה

המערכת אינה נאחזת בשם החשבון כדי לזהות אתכם, פשוט מפני שהשם ניתן לשינוי. במקום זה יש לכל חשבון ולכל קבוצה מזהה פנימי קבוע וחד-ערכי, SID (Security Identifier), שנדבק אליהם לצמיתות.

ל-SID של חשבון מקומי יש חלק שמזהה את המחשב, ובסופו מספר קצר שמזהה את החשבון בתוכו:

Text
S-1-5-21-365931374-3886608294-1942855644-1001
        \________ identifies the machine ________/ \__/
                                                   RID

אותו מספר אחרון, ה-RID, הוא שמבחין בין חשבון לחשבון על אותה מכונה. ל-Administrator המובנה שמור תמיד RID 500, ול-Guest שמור 501, ולא משנה איזה שם קיבלו.

לחשבונות של המערכת עצמה יש SID קצר וזהה בכל מחשב. ביקשנו מ-Windows לתרגם שלושה כאלה חזרה לשם:

Python
import ctypes
from ctypes import wintypes

advapi = ctypes.WinDLL("advapi32", use_last_error=True)

def name_of(sid_text):
    sid = ctypes.c_void_p()
    advapi.ConvertStringSidToSidW(sid_text, ctypes.byref(sid))
    name = ctypes.create_unicode_buffer(256)
    dom  = ctypes.create_unicode_buffer(256)
    n, d, use = wintypes.DWORD(256), wintypes.DWORD(256), wintypes.DWORD()
    advapi.LookupAccountSidW(None, sid, name, ctypes.byref(n),
                             dom, ctypes.byref(d), ctypes.byref(use))
    return dom.value + "\\" + name.value

for s in ["S-1-5-18", "S-1-5-19", "S-1-5-20"]:
    print(s, "->", name_of(s))
פלט
S-1-5-18 -> NT AUTHORITY\SYSTEM
S-1-5-19 -> NT AUTHORITY\LOCAL SERVICE
S-1-5-20 -> NT AUTHORITY\NETWORK SERVICE
חשבוןSIDרמת ההרשאות
SYSTEM, המוכר גם כ-LocalSystemS-1-5-18הגבוהה ביותר במחשב
LocalServiceS-1-5-19מצומצמת
NetworkServiceS-1-5-20מצומצמת, אך פונה לרשת בזהות המחשב

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

חשבו על תעודת עובד שמונפקת בכניסה לבניין: אחרי שהסיסמה התקבלה נוצר אסימון גישה (access token), וכל תוכנה שתפעילו מאותו רגע מחזיקה עותק שלו. על התעודה מודפסים ארבעה פרטים: מי אתם (ה-SID שלכם), לאילו קבוצות אתם שייכים (ה-SID של כל קבוצה), אילו פעולות מיוחדות מותרות לכם (privileges), ובאיזו רמת שלמות (integrity level) אתם פועלים.

בכל ניסיון לפתוח קובץ או מפתח ב-Registry מחליט רכיב בגרעין בשם Security Reference Monitor. הוא מניח זה לצד זה את האסימון של התהליך ואת רשימת ההרשאות של האובייקט, ורק אם הם מתיישבים הגישה מאושרת, ואת האסימון עצמו מנפיק מלכתחילה lsass.exe, ברגע הכניסה.

טעויות נפוצות
  • המערכת מזהה חשבון לפי שם המשתמש שלו. הזיהוי הפנימי נשען תמיד על ה-SID. השם הוא רק תווית נוחה שאפשר להחליף.
  • SYSTEM הוא שם נוסף לחשבון Administrator. Administrator הוא חשבונו של מנהל אנושי, ו-SYSTEM הוא חשבון מערכת ההפעלה, חזק אף ממנו.
בדקו את עצמכם
איזה RID שמור לחשבון Administrator המובנה, ומה אפשר למצוא בתוך אסימון גישה?

RID 500. בתוך האסימון: ה-SID של המשתמש ושל קבוצותיו, ההרשאות המיוחדות שלו ורמת השלמות שלו.

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

Registry: מרכז ההגדרות של Windows

מה ה-Registry מחזיק, ומה הוא בכוונה לא עושה

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

  • מפתח (Key) מתפקד כתיקייה: הוא יכול להכיל מפתחות משנה (Subkeys) וגם ערכים.
  • ערך (Value) הוא כקובץ זעיר שבתוכה, ולו שלושה חלקים: שם, סוג ונתונים.
Text
HKEY_LOCAL_MACHINE                          root key
  SYSTEM                                    key
    CurrentControlSet                       key
      Services                              key
        Dnscache                            key (one service)
          Start        REG_DWORD     0x2    value: name, type, data

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

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

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

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

טעויות נפוצות
  • ה-Registry שולט בהרשאות הקבצים בכונן NTFS. ההרשאות האלה שמורות על הקבצים עצמם במערכת הקבצים, ולא ב-Registry.
  • ה-Registry הוא שמתזמן משימות רקע. התזמון שייך ל-Task Scheduler. ה-Registry רק מחזיק נתונים.
  • ה-Registry שומר רק תמונת רקע וצבעי חלונות. הוא מחזיק גם שירותים, דרייברים וסדר אתחול, לא רק מראה.
  • קוראים אותו פעם אחת, בעת ההתקנה. פונים אליו בכל אתחול ולאורך הריצה, לא רק פעם אחת.
בדקו את עצמכם
אם מדמים את ה-Registry לעץ תיקיות, מי בו ממלא את תפקיד התיקייה ומי את תפקיד הקובץ?

המפתח (Key) הוא התיקייה, והערך (Value) הוא הקובץ הקטן שבתוכה, עם שם, סוג ונתונים.

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

חמשת מפתחות השורש, ומי מהם מחזיק נתונים באמת

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

שם מלאקיצורמה שוכן בו
HKEY_LOCAL_MACHINEHKLMהגדרות של המחשב כולו: חומרה, דרייברים, שירותים, תוכנות מותקנות והגדרות רוחביות
HKEY_CURRENT_USERHKCUההגדרות הפרטיות של מי שמחובר כעת
HKEY_USERSHKUפרופיל לכל משתמש שטעון כרגע, מפתח נפרד לכל אחד
HKEY_CLASSES_ROOTHKCRשיוך סוגי קבצים לתוכנות שפותחות אותם, ורישום רכיבי COM
HKEY_CURRENT_CONFIGHKCCפרופיל החומרה הפעיל כרגע

רק שניים מהחמישה אוגרים נתונים בפועל: HKLM ו-HKU. השאר הם חלון תצוגה או קיצור דרך אל הנתונים שבשניים האלה:

  • HKCU מפנה אל המפתח של המשתמש הנוכחי שבתוך HKU.
  • HKCR הוא מיזוג תצוגה של HKLM\Software\Classes עם HKCU\Software\Classes.
  • HKCC מפנה אל פרופיל החומרה הפעיל שבתוך HKLM.

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

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

תרחיש 1: מה באמת חוזר מ-reg query HKU

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

Bash
reg query HKU
פלט
HKEY_USERS\.DEFAULT
HKEY_USERS\S-1-5-19
HKEY_USERS\S-1-5-20
HKEY_USERS\S-1-5-21-365931374-3886608294-1942855644-1001
HKEY_USERS\S-1-5-21-365931374-3886608294-1942855644-1001_Classes
HKEY_USERS\S-1-5-18

קל לפענח. SYSTEM מופיע כ-S-1-5-18, בעוד S-1-5-19 ו-S-1-5-20 הם LocalService ו-NetworkService. השורה הארוכה שפותחת ב-S-1-5-21 ונחתמת ב-1001 היא פרופיל המשתמש הרגיל שמחובר ברגע זה, ועליו בדיוק מצביע HKCU.

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

טעויות נפוצות
  • הגדרות רוחביות של המחשב יושבות ב-HKCU. HKCU שייך למשתמש יחיד. הגדרות של כל המחשב נמצאות ב-HKLM.
  • HKCU מחזיק את ההגדרות של כל המשתמשים. זה דווקא HKU. HKCU הוא רק המחובר הנוכחי.
  • HKCR מחזיק את ההגדרות של המשתמש הנוכחי. HKCR מחזיק שיוכי קבצים ורכיבי COM, לא הגדרות משתמש.
  • HKU מונה כל חשבון מחשב, לפי שם. הוא מונה רק פרופילים טעונים, ולפי SID ולא לפי שם.
בדקו את עצמכם
באיזה מפתח שורש תחפשו איזו תוכנה אמורה לפתוח קובצי png?

ב-HKCR, שמחזיק את שיוכי סוגי הקבצים.

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

ב-HKCU. מכיוון שהמפתח הזה שלו, הוא רשאי לכתוב בלי הרשאות מנהל.

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

כוורות (Hives): הקבצים שמהם ה-Registry מורכב

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

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

קובץ הכוורת בדיסקנטען בתורמה יש בו
C:\Windows\System32\config\SYSTEMHKLM\SYSTEMהגדרות אתחול, שירותים ודרייברים
C:\Windows\System32\config\SOFTWAREHKLM\SOFTWAREתוכנות מותקנות והגדרות של Windows
C:\Windows\System32\config\SAMHKLM\SAMחשבונות מקומיים וגיבובי סיסמאות
C:\Windows\System32\config\SECURITYHKLM\SECURITYמדיניות אבטחה מקומית
C:\Users\Noa\NTUSER.DATהמפתח של Noa ב-HKU, שהוא ה-HKCU שלהההגדרות הפרטיות של משתמש יחיד

כוורות המחשב כולו מרוכזות אפוא בתיקייה C:\Windows\System32\config ונטענות תחת HKLM. לעומתן, לכל משתמש יש כוורת פרטית, קובץ ה-NTUSER.DAT שיושב בתוך תיקיית הפרופיל שלו. בכניסה, Windows טוענת אותו אל HKU, ו-HKCU מצביע עליו.

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

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

תרחיש 2: לגבות כקובץ אחד את ההגדרות האישיות של Noa

מנהל רוצה לרכז בקובץ כוורת יחיד את כל ההגדרות שנטענות ל-HKCU כש-Noa מתחברת.

את SOFTWARE ו-SYSTEM פוסלים מיד, כי אלה כוורות שכל המשתמשים חולקים. ntuser.ini אינו כוורת אלא טקסט. נותר הקובץ הנכון היחיד, C:\Users\Noa\NTUSER.DAT, הכוורת הפרטית של Noa.

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

טעויות נפוצות
  • כוורת היא מפתח משנה בודד עם ערך יחיד. כוורת היא קובץ שלם עם שפע מפתחות וערכים, לא פריט בודד.
  • כוורת וקובץ ייצוא בסיומת reg הם היינו הך. קובץ reg הוא העתק טקסט, והכוורת היא הקובץ הבינארי שנטען למערכת.
  • כוורת נמחקת בכל אתחול ונבראת מחדש. הכוורות עמידות בדיסק ושורדות בין אתחולים.
  • הגדרות של משתמש יחיד יושבות בקובץ SOFTWARE. SOFTWARE היא כוורת של המחשב כולו. ההגדרות האישיות ב-NTUSER.DAT.
בדקו את עצמכם
היכן מרוכזים קובצי הכוורת של המחשב כולו, ותחת איזה מפתח שורש הם נטענים?

בתיקייה C:\Windows\System32\config, והם נטענים תחת HKLM.

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

סוגי ערכים: מ-REG_SZ ועד REG_BINARY

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

סוגמה הוא מחזיקדוגמה
REG_SZמחרוזת טקסט בודדת, שנקראת מילה במילה כפי שנכתבהD:\Apps\reader.exe
REG_EXPAND_SZמחרוזת עם משתני סביבה, שמוחלפים בערכם בעת הקריאה%SystemRoot%\System32\svchost.exe
REG_MULTI_SZרשימה של כמה מחרוזותnsi, Afd
REG_DWORDמספר באורך 32 ביט0x2
REG_QWORDמספר באורך 64 ביט0x0000000100000000
REG_BINARYרצף בתים גולמי02 00 ff 7c

הבלבול הגדול ביותר הוא בין REG_SZ ל-REG_EXPAND_SZ, וההבדל נעוץ ביחס למשתני סביבה. ניקח את %SystemRoot%, שמצביע על ספריית Windows (לרוב C:\Windows).

ערך שסומן REG_EXPAND_SZ עובר הרחבה: המערכת מחליפה את %SystemRoot% בנתיב בפועל ברגע הקריאה, ולכן הוא תקף גם במכונה שבה Windows הותקנה בכונן אחר. אותו תוכן בתוך ערך REG_SZ לא יעבור שום החלפה, וסימני האחוז יישארו כפשוטם.

תרחיש 3: הנתיב שבתוך מפתח של שירות אמיתי

בדקנו על מכונה פעילה את הערך ImagePath של שירות ה-DNS, וגם ביקשנו לראות כיצד הוא נראה לאחר ההחלפה:

Python
import winreg

path = r"SYSTEM\CurrentControlSet\Services\Dnscache"
with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) as key:   # read-only
    for name in ("ImagePath", "Start", "DependOnService"):
        data, kind = winreg.QueryValueEx(key, name)
        print(name, kind, repr(data))
    raw, _ = winreg.QueryValueEx(key, "ImagePath")
    print("expanded:", winreg.ExpandEnvironmentStrings(raw))
פלט
ImagePath 2 '%SystemRoot%\\system32\\svchost.exe -k NetworkService -p'
Start 4 2
DependOnService 7 ['nsi', 'Afd']
expanded: C:\Windows\system32\svchost.exe -k NetworkService -p

המספר ליד כל שם הוא קוד הסוג: 2 פירושו REG_EXPAND_SZ, 4 הוא REG_DWORD ו-7 הוא REG_MULTI_SZ. הערך ImagePath הוא מסוג REG_EXPAND_SZ, ולכן בעליית השירות %SystemRoot% הופך ל-C:\Windows, כנראה בשורת ה-expanded.

אילו הסוג היה REG_SZ, המערכת הייתה מנסה להפעיל נתיב שפותח בטקסט %SystemRoot% ממש, ונכשלת. שני הערכים הנוספים ממחישים את שאר הטבלה: Start הוא מספר 32 ביט, ו-DependOnService הוא רשימת מחרוזות.

טעויות נפוצות
  • מחרוזת עם %SystemRoot% נשמרת ב-REG_SZ. REG_SZ אינו מרחיב משתנים. לטקסט עם משתנה סביבה מתאים REG_EXPAND_SZ.
  • REG_MULTI_SZ הוא מחרוזת אחת עם משתנים. REG_MULTI_SZ הוא רשימה של כמה מחרוזות נפרדות.
  • REG_DWORD מחזיק טקסט. REG_DWORD מחזיק מספר באורך 32 ביט.
בדקו את עצמכם
תוכנה צריכה לשמור רשימה של ארבעה שמות תיקיות. איזה סוג מתאים?

REG_MULTI_SZ, שמחזיק רשימת מחרוזות.

ואיזה סוג מתאים לדגל מספרי פשוט כמו 0 או 1?

REG_DWORD, מספר של 32 ביט.

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

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

ל-Windows שני כלים מובנים לעבודה מול ה-Registry. הראשון, regedit, הוא עורך גרפי: בצד אחד עץ המפתחות, ובצד השני הערכים של המפתח שנבחר. שינוי בו תופס מיד, ואין בו כפתור שמירה בכלל.

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

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

פקודת reg add מקבלת קודם נתיב, שיכול לפתוח בכל אחד ממפתחות השורש (למשל HKCU או HKLM), ואחריו ארבעה מתגים. שלושה מהם בונים את הערך: /t בוחר את הסוג (REG_SZ, REG_DWORD וכן הלאה), /v קובע איך הערך ייקרא, ו-/d מספק את התוכן שייכתב בו. הרביעי, /f, נועד לסקריפטים: הוא מבטל את השאלה אם לדרוס ערך קיים.

שימו לב ש-reg add אינה מנקה מפתח קיים לפני הכתיבה, ואף אינה מייבאת קובץ שלם, לזה נועדה reg import. כדי לקרוא ערך בודד משתמשים ב-reg query עם /v, כפי שנראה כאן על משתנה הסביבה TEMP:

Bash
reg query HKCU\Environment /v TEMP
פלט
HKEY_CURRENT_USER\Environment
    TEMP    REG_EXPAND_SZ    %USERPROFILE%\AppData\Local\Temp

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

אל תחליפו בין reg לבין sc config. הפקודה sc config עניינה בשירות: היא מכוונת את הגדרותיו, כמו סוג ההפעלה, ונחזור אליה בחלק על השירותים. regedit, לעומתה, הוא עורך גרפי של ה-Registry כולו.

טעויות נפוצות
  • reg.exe מדלג על ההרשאות שעל המפתחות. הוא כבול לאותן הרשאות כמו regedit, בלי שום קסם שעוקף הגנות.
  • reg.exe יודע רק לקרוא. reg add ו-reg delete משנים את המאגר, אז הוא גם כותב וגם מוחק.
  • regedit דורש הפעלה מחדש כדי לשמור, בשונה מ-reg. שני הכלים מחילים את השינוי לאלתר.
  • regedit פועל משורת הפקודה, ו-sc config הוא כלי גרפי לשירותים. המצב הפוך: regedit גרפי, ו-sc config רץ בשורת הפקודה.
בדקו את עצמכם
איזו תת-פקודה רק מציגה את תוכן המפתח בלי לשנותו?

reg query.

מדוע מי שכותב סקריפט התקנה יעדיף את reg על פני regedit?

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

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

לגבות לפני שמשנים, ומה הסיכון בלי זה

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

ובכל זאת כדאי לדעת עד היכן מגיע הנזק, ועד היכן לא:

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

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

Bash
reg export "HKLM\SOFTWARE\Falcon" D:\Backup\falcon.reg

rem ... now make the change ...

rem if the change broke something, restore the key:
reg import D:\Backup\falcon.reg

ב-regedit עושים זאת דרך תפריט File ואז Export, ומשחזרים בייבוא (reg import, או לחיצה כפולה על הקובץ ואישור).

יש מעשים שמתחזים לגיבוי אבל אינם:

  • להעתיק את קובצי הכוורת מ-System32\config דרך סייר הקבצים ייכשל בזמן ריצה, כי הם נעולים.
  • reg query רק מדפיס ערכים למסך, בלי ליצור קובץ שאפשר לייבא בחזרה.
  • הרצת regedit בהרשאות מנהל אינה מייצרת שום גיבוי אוטומטי.
תרחיש 4: שינוי שהשתבש, ושחזור ממנו

מנהל עומד לשנות כמה ערכים תחת HKLM\SOFTWARE\Falcon, ולכן הוא מריץ קודם reg export ושומר את המפתח לקובץ falcon.reg.

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

אילו הסתפק ב-reg query, היה בידו פלט על המסך בלבד, בלי קובץ שאפשר להחזיר אל ה-Registry.

טעויות נפוצות
  • מחיקת מפתח מוחקת גם את קובצי התוכנה מהדיסק. המאגר מחזיק הגדרות בלבד, והקבצים נשארים בדיסק.
  • טעות ב-Registry עלולה לקלקל את קושחת ה-BIOS שעל לוח האם. ה-BIOS אינו חלק מהמאגר ואינו מושפע מעריכתו.
  • שינוי ב-HKCU חל על כל המשתמשים. הוא חל רק על המחובר הנוכחי.
  • גיבוי טוב הוא להעתיק את הכוורות בזמן שהמערכת פועלת. הן נעולות בריצה, אז ההעתקה נכשלת.
בדקו את עצמכם
מה ההבדל בין reg export לבין reg import?

reg export כותבת מפתח לקובץ reg, ו-reg import מחזירה את תוכן קובץ כזה אל המאגר.

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

הפעלה אוטומטית: מפתחות Run ו-RunOnce

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

מיקוםמתי זה פועל, ולמימי רשאי לכתוב
HKCU\Software\Microsoft\Windows\CurrentVersion\Runבכל כניסה של המחובר הנוכחיהמשתמש עצמו, בלי הרשאות מנהל
HKLM\Software\Microsoft\Windows\CurrentVersion\Runבכל כניסה של כל משתמשמנהל בלבד
...\CurrentVersion\RunOnceפעם אחת, בכניסה הבאה, ואז הערך נמחקב-HKCU המשתמש, ב-HKLM מנהל
תיקיית Startupבכל כניסהלפי התיקייה: של המשתמש או של כולם

מבחינת מבנה, מפתח Run הוא רשימה פשוטה: שם הערך הוא רק תווית, ומה שמכריע הוא הנתונים, כלומר הנתיב של התוכנה שתופעל. תוכנות 32 ביט שרצות על Windows של 64 ביט מקבלות מהמערכת מפתחות Run נפרדים משלהן תחת Wow6432Node, כצד מקביל ל-Run שב-HKLM.

שימו לב ששירותים כלל אינם עולים דרך Run. מקומם הוא תחת HKLM\SYSTEM\CurrentControlSet\Services, שם לכל שירות מפתח משנה משלו, וכמובן נדרשות הרשאות מנהל כדי לכתוב שם.

תרחיש 5: תוכנה שרוצה לעלות עם המשתמש, בלי מנהל

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

Python
import winreg

RUN = r"Software\Microsoft\Windows\CurrentVersion\Run"
for label, hive in (("HKCU", winreg.HKEY_CURRENT_USER),
                    ("HKLM", winreg.HKEY_LOCAL_MACHINE)):
    try:
        winreg.OpenKey(hive, RUN, 0, winreg.KEY_SET_VALUE).Close()
        print(label, "Run: write access granted")
    except PermissionError as e:
        print(label, "Run: refused,", e.strerror)
פלט
HKCU Run: write access granted
HKLM Run: refused, Access is denied

הבקשה ל-HKCU אושרה, כי המפתח שם שייך למשתמש עצמו. הבקשה ל-HKLM נדחתה ב-Access is denied, מפני שכתיבה שם משפיעה על כלל החשבונות ומצריכה הרשאות מנהל. לכן התוכנה תירשם במפתח Run שתחת HKCU.

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

טעויות נפוצות
  • משתמש רגיל יכול לכתוב למפתח Run שתחת HKLM. כתיבה ל-HKLM תובעת הרשאות מנהל, ולכן היא נדחית למשתמש רגיל.
  • RunOnce מעלה את התוכנה בכל כניסה. הוא מעלה אותה פעם אחת ומוחק את הערך.
  • תוכנה שעולה עם המשתמש נרשמת במפתח Services. Services מגדיר שירותים, לא תוכנות שעולות בכניסת משתמש.
בדקו את עצמכם
מנהל רוצה שתוכנה תעלה בכל כניסה של כל משתמש במחשב. היכן ירשום אותה?

ב-HKLM\Software\Microsoft\Windows\CurrentVersion\Run, שחל על כל המשתמשים.

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

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

מה ה-SAM שומר, היכן, ומי מורשה לראות

SAM הוא ראשי התיבות של Security Account Manager. זהו מסד הנתונים של החשבונות המקומיים, כלומר כאלה שהוגדרו על המחשב עצמו ולא על שרת מרוחק.

מה ה-SAM מנהל לכל חשבון מקומי:

  • הגיבוב (hash) של הסיסמה, אף פעם לא הסיסמה כמות שהיא.
  • זהות החשבון: שם המשתמש וה-SID הצמוד אליו.
  • השיוך לקבוצות, למשל חברות ב-Administrators.
  • מצב החשבון ודגליו, למשל אם הוא מושבת.

ה-SAM הוא כוורת של ה-Registry. בדיסק הוא הקובץ C:\Windows\System32\config\SAM, בשכנות לכוורות SYSTEM, SOFTWARE ו-SECURITY, ובמאגר הוא נטען כמפתח HKLM\SAM.

שתי שכבות שומרות עליו כברירת מחדל. ראשית, בזמן ש-Windows פועלת הקובץ נעול, כך שאי אפשר להעתיקו או לפתוח אותו בתוכנה אחרת. שנית, רק SYSTEM רשאי לקרוא את תוכן HKLM\SAM, ולכן אפילו מנהל שמגיע אליו ב-regedit אינו רואה את נתוני החשבונות.

תחום הכיסוי של ה-SAM הוא חשבונות מקומיים בלבד. את חשבונות הדומיין מחזיק מנגנון אחר, Active Directory, שמאחסן אותם בקובץ NTDS.dit על שרתי הדומיין. גם הגדרות כרטיס רשת, קובצי הרצה של שירותים וסדר האתחול אינם כאן, אלא פזורים במקומות אחרים:

תיקייהמה יש בה
C:\Windows\System32\configכוורות המחשב: SAM, SYSTEM, SOFTWARE, SECURITY
C:\Windows\System32\driversקובצי דרייברים בסיומת sys
C:\Windows\SysWOW64קבצים של 32 ביט במערכת 64 ביט
C:\Windows\System32\winevtקובצי יומני האירועים
טעויות נפוצות
  • ה-SAM יושב בתיקייה System32\drivers. הוא יושב ב-System32\config. תיקיית drivers מיועדת לקובצי דרייברים.
  • ה-SAM מחזיק גם חשבונות דומיין. אלה שמורים ב-Active Directory, בקובץ NTDS.dit.
  • ל-SAM אין קובץ, הוא חי רק בזיכרון של lsass.exe. הוא קובץ של ממש בדיסק, שנטען אל המאגר.
  • ב-SAM שמורות הגדרות כרטיס רשת וסדר אתחול. הוא מחזיק חשבונות מקומיים בלבד.
בדקו את עצמכם
מנהל פותח regedit, מגיע ל-HKLM\SAM, ולא רואה את נתוני החשבונות. מדוע?

מפני שכברירת מחדל רק SYSTEM רשאי לקרוא את תוכן המפתח הזה, ומנהל אינו SYSTEM.

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

גיבובי הסיסמאות: NT hash ותכונותיו

מה בדיוק כתוב ב-SAM במקום הסיסמה? רשומה נפרדת לכל חשבון, ובה ה-NT hash שלו: הסיסמה אחרי שעברה דרך פונקציית MD4. פונקציית גיבוב (hash) כזו פועלת בכיוון אחד בלבד, כלומר המעבר מהסיסמה אל הגיבוב מהיר, ואילו הדרך ההפוכה, מהגיבוב אל הסיסמה, אינה קיימת.

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

שתי תכונות כדאי לזכור. ראשית, אין כאן salt, אין ערך אקראי שמצטרף לסיסמה לפני הגיבוב, ולכן אותה סיסמה מולידה אותו NT hash בכל מכונה. שנית, בתוך הקובץ הגיבובים מוצפנים במפתח האתחול (boot key), השמור בכוורת נפרדת, SYSTEM.

כדי להמחיש מה ה-salt משנה, הרצנו פונקציית גיבוב כללית (לא NT hash) פעם בלי salt ופעם עם salt אקראי לכל חשבון:

Python
import hashlib, os

def unsalted(password):                       # illustrates the no-salt case
    return hashlib.sha256(password.encode("utf-16-le")).hexdigest()[:16]

def salted(password):                         # adds a fresh random value per account
    salt = os.urandom(8)
    return hashlib.sha256(salt + password.encode("utf-16-le")).hexdigest()[:16]

# the same password used on two different machines
print("machine A, no salt:", unsalted("Orchard#77"))
print("machine B, no salt:", unsalted("Orchard#77"))
print("machine A, salted: ", salted("Orchard#77"))
print("machine B, salted: ", salted("Orchard#77"))
פלט
machine A, no salt: dc01fa089c113772
machine B, no salt: dc01fa089c113772
machine A, salted:  4bd9e0178d1548c6
machine B, salted:  ed6b7ce7e0593fdf

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

הגיבוב שבקוד הוא הדגמה בלבד של רעיון ה-salt, עם פונקציה כללית. ה-NT hash האמיתי מחושב ב-MD4 וללא salt, והערך בדוגמה אינו ה-NT hash של הסיסמה.

היה פעם גם גיבוב ותיק וחלש בהרבה, ה-LM hash, אך גרסאות Windows מאז Vista משביתות אותו כברירת מחדל. גם כך, העובדה שהסיסמה אינה נקראת ישירות אינה הופכת את ה-SAM למבצר חסין:

  • פיצוח (cracking): מנחשים סיסמאות רבות, מגבבים כל ניחוש, ומשווים אם הוא שווה לגיבוב שנגנב.
  • שימוש חוזר בגיבוב: מזדהים מול מכונות אחרות בעזרת הגיבוב עצמו, בלי לדעת כלל את הסיסמה (הטכניקה המכונה pass-the-hash).

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

טעויות נפוצות
  • ה-SAM שומר סיסמאות גלויות. הוא שומר NT hash, לא את הסיסמה עצמה.
  • מנהל יכול לחלץ מה-SAM סיסמה שנשכחה. הגיבוב חד-כיווני. אפשר רק לקבוע סיסמה חדשה במקומה.
  • גיבוב גנוב חסר ערך לגורם עוין. אפשר לנסות לפצח אותו, או להשתמש בו בשיטת pass-the-hash.
  • ה-salt של כל גיבוב שמור בכוורת SYSTEM. ל-NT hash אין salt כלל. מה ששמור ב-SYSTEM הוא מפתח האתחול.
  • הגיבוב נועד להאיץ את הטעינה בכניסה. ייעודו להסתיר את הסיסמה, לא לזרז דבר.
בדקו את עצמכם
לשני משתמשים על שתי מכונות נפרדות אותה סיסמה בדיוק. האם ה-NT hash שלהם זהה, ומדוע?

כן. NT hash נטול salt, ולכן אותה סיסמה מולידה תמיד אותו גיבוב, בכל מכונה.

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

כיצד קובץ ה-SAM יוצא החוצה, ומה נדרש לפענח אותו

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

Bash
reg save HKLM\SAM D:\temp\sam.hive
reg save HKLM\SYSTEM D:\temp\system.hive

שתי הפקודות מצריכות שורת פקודה שנפתחה כמנהל. דרכים נוספות אל הקובץ הן עותק צל (shadow copy) של הכונן, או הדיסק של מכונה כבויה.

ולמה בכלל נחוצה SYSTEM? הגיבובים שבתוך ה-SAM אינם חשופים, אלא מוגנים תחת מפתח האתחול, ואותו מפתח יושב דווקא בכוורת SYSTEM.

מי שאין לו את SYSTEM נשאר עם קובץ SAM שאי אפשר לפענח. שאר הנתונים, השמות, ה-SID והשיוך לקבוצות, גלויים בתוך ה-SAM ואינם תלויים ב-SYSTEM.

תרחיש 6: מה בידי מי שהשיג את שתי הכוורות

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

בעזרת מפתח האתחול שבתוך SYSTEM הוא מפענח את ה-SAM, ומקבל רשימת חשבונות מקומיים, ולצד כל אחד את ה-NT hash שלו.

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

טעויות נפוצות
  • כדי לפענח את ה-SAM דרוש NTDS.dit. NTDS.dit הוא מסד חשבונות הדומיין. לפענוח ה-SAM המקומי נחוצה הכוורת SYSTEM.
  • מפתח ההגנה של ה-SAM נמצא ב-HKCU של המשתמש. מפתח האתחול שוכן בכוורת SYSTEM, לא ב-HKCU.
  • הסיסמאות שמורות גלויות בקובץ ההחלפה pagefile.sys. סיסמאות של חשבונות מקומיים נשמרות כגיבוב ב-SAM.
  • עם SAM ו-SYSTEM מקבלים סיסמאות גלויות. מקבלים גיבובים בלבד, לא את הסיסמאות עצמן.
  • את שמות המשתמשים מחזיקה הכוורת SYSTEM, לא ה-SAM. כל נתוני החשבונות, השמות בכללם, יושבים ב-SAM.
בדקו את עצמכם
מישהו הצליח להעתיק רק את קובץ ה-SAM, בלי שום קובץ נוסף. מה חסר לו כדי להגיע לגיבובים?

הכוורת SYSTEM, שבתוכה מפתח האתחול שמצפין את הגיבובים.

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

עריכה לא מקוונת ואיפוס סיסמה מקומית

כש-Windows פועלת אי אפשר לערוך את ה-SAM: הקובץ נעול, והמפתח פתוח לקריאה ל-SYSTEM לבדו. גם אי אפשר לשחרר את הנעילה על ידי עצירת lsass.exe, מפני שעצירתו גוררת הפעלה מחדש של המחשב. הדרך היא לעבוד כשה-Windows שעל הדיסק אינה רצה, מצב שמכונה offline:

  1. מעלים את המחשב ממדיה חיצונית, למשל מדיית WinPE (סביבת Windows זעירה שעולה מדיסק או מכונן USB).
  2. כעת ה-Windows שעל הדיסק אינה פעילה, וקובץ ה-SAM שלה משוחרר מנעילה.
  3. ב-regedit מסמנים את HKEY_LOCAL_MACHINE ובוחרים File ואז Load Hive.
  4. בוחרים את הקובץ \Windows\System32\config\SAM בכונן שעליו מותקנת ה-Windows הכבויה (ב-WinPE אות הכונן עשויה להשתנות, למשל E:), ומעניקים לו שם זמני.
  5. בסיום בוחרים Unload Hive.

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

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

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

תרחיש 7: סיסמה מקומית שנשכחה, עם גישה פיזית

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

הוא מעלה את המחשב מכונן USB עם WinPE, ואז מחבר את כוורת ה-SAM שבתיקיית config אל regedit דרך Load Hive (שרק פותחת אותה לעריכה), או מריץ כלי ייעודי שמאפס את הסיסמה בעצמו.

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

טעויות נפוצות
  • עוצרים את lsass.exe ב-sc stop ואז עורכים את ה-SAM. עצירת lsass.exe כופה הפעלה מחדש של המערכת, כך שהיא אינה משחררת דבר.
  • פותחים regedit כמנהל ועורכים ישירות את HKLM\SAM. בזמן ריצה רק SYSTEM יכול אפילו לקרוא אותו, ובוודאי לא לערוך.
  • דרך Explorer מרפים את ההרשאות של קובץ ה-SAM ועורכים אותו בפנקס רשימות. שינוי הרשאות אינו מסיר את הנעילה, והקובץ בינארי ולא טקסט.
  • פגיעה ב-SAM מעבירה אוטומטית לחשבון Administrator מוסתר. פגיעה בו פוגעת בכל החשבונות המקומיים, Administrator ביניהם.
  • עריכה של ה-SAM נוגעת גם בחשבונות שבמחשבים אחרים בדומיין. ה-SAM מקומי למכונה יחידה בלבד.
בדקו את עצמכם
מדוע איפוס סיסמה לא מקוון מחייב להעלות את המחשב ממדיה חיצונית?

מפני שרק כשה-Windows שעל הדיסק אינה רצה קובץ ה-SAM משוחרר מנעילה, ואפשר לטעון ולערוך אותו.

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

lsass.exe: מי מאמת אתכם, ואיך שומרים עליו

התפקיד של lsass.exe במערכת

השם lsass.exe בא מ-Local Security Authority Subsystem Service. זה התהליך ש-Windows מפקידה בידיו את מדיניות האבטחה המקומית: מי רשאי להיכנס, באילו תנאים, ומה נרשם על כך.

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

משימהמה lsass.exe עושה בה
אימות כניסהבודק שהסיסמה שהוזנה אכן שייכת לחשבון
הנפקת access tokenאחרי אימות מוצלח בונה את אסימון הגישה, שמתאר מי המשתמש ולאילו קבוצות הוא שייך
החלפת סיסמהמטפל בבקשה לשנות סיסמה
ביקורת (audit)רושם אירועי אבטחה, כמו כניסה מוצלחת או כושלת, ביומן Security

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

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

מהקלדת הסיסמה ועד שולחן העבודה

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

  1. winlogon.exe אחראי על הכניסה האינטראקטיבית, ומציג את מסך הכניסה דרך LogonUI.exe. במחשב שמצורף לדומיין המסך נפתח רק אחרי Ctrl+Alt+Del.
  2. השם והסיסמה שהוקלדו עוברים מ-winlogon.exe אל lsass.exe.
  3. בחשבון מקומי, lsass.exe מגבב את הסיסמה שקיבל ומשווה את התוצאה לגיבוב שנשמר ב-SAM עבור אותו חשבון.
  4. גיבובים זהים: lsass.exe בונה access token למשתמש. גיבובים שונים: הכניסה נדחית.
  5. נפתח סשן, ו-explorer.exe, שאחראי על שולחן העבודה ושורת המשימות, מופעל עם האסימון החדש.
  6. מכאן והלאה, בכל ניסיון לגשת לקובץ, הגרעין בודק את האסימון של התהליך שמבקש.
תרחיש 8: יואב נכנס, ומי באמת עבד

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

  • ה-SAM: סיפק את הגיבוב השמור, וזהו. מאגר נתונים לא משווה ולא מחליט.
  • ntoskrnl.exe: הגרעין ייכנס לתמונה רק אחר כך, כשיבדוק את האסימון בכל גישה. הוא לא בדק את הסיסמה ולא בנה את האסימון.
  • services.exe: עסוק בהפעלה ובעצירה של שירותים, ולא נגע בכניסה.
  • explorer.exe: עדיין לא קיים בסשן של יואב. הוא יעלה רק אחרי שהכניסה תצליח.
  • lsass.exe: חישב גיבוב, השווה אותו לגיבוב השמור ובנה את האסימון. זו התשובה.
טעויות נפוצות
  • ה-SAM בודק את הסיסמה, ו-lsass.exe רק מחזיק את הגיבוב. החלוקה הפוכה: ה-SAM שומר את הגיבוב, ו-lsass.exe מבצע את ההשוואה.
  • את אסימון הגישה מנפיק ה-SAM בסוף האימות. ה-SAM לא מנפיק כלום. האסימון נבנה ב-lsass.exe.
  • כרטיסי Kerberos של משתמשי הדומיין נשמרים ב-SAM. Kerberos שייך לאימות בדומיין, והכרטיסים מוחזקים בזיכרון של lsass.exe, לא במאגר החשבונות המקומיים.
  • explorer.exe מאמת את המשתמש, כי הוא מה שרואים מיד אחרי הכניסה. explorer.exe רק מצייר את שולחן העבודה, והוא עולה אחרי שהאימות כבר הסתיים.
בדקו את עצמכם
בכניסה לחשבון מקומי, מה בדיוק lsass.exe משווה, ומול מה?

את הגיבוב שהוא מחשב מהסיסמה שהוקלדה, מול הגיבוב של אותו חשבון שנשמר ב-SAM.

מי בודק את האסימון כשתהליך של המשתמש פותח קובץ?

הגרעין, ברכיב Security Reference Monitor. lsass.exe רק בנה את האסימון בזמן הכניסה.

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

רץ כ-SYSTEM, ומי עוד רץ לידו

הקובץ של התהליך נמצא ב-C:\Windows\System32\lsass.exe, והוא רץ תחת החשבון SYSTEM. מי שקורא את ה-SAM, מטפל בסיסמאות ובונה אסימונים לכל משתמש במחשב צריך את רמת ההרשאות הגבוהה ביותר שקיימת.

למה לא חשבון אחר? Administrator הוא חשבון של משתמש אנושי, לא של רכיב מערכת. LocalService ו-NetworkService נבנו בכוונה עם הרשאות מצומצמות, ולכן אין להם גישה לכל מה ש-lsass.exe צריך.

Text
C:\>tasklist /fi "imagename eq lsass.exe"
פלט
Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
lsass.exe                      844 Services                   0     10,960 K

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

לצד lsass.exe רצים עוד כמה תהליכי מערכת, ושאלות רבות בונות מסיחים מהשמות שלהם:

Processמה הוא עושה
lsass.exeאימות משתמשים, בניית אסימונים ואכיפת מדיניות האבטחה
winlogon.exeהכניסה האינטראקטיבית: מסך הכניסה ו-Ctrl+Alt+Del
services.exeה-Service Control Manager: מפעיל, עוצר ועוקב אחרי שירותים
svchost.exeתהליך מארח, שבתוכו רצים שירותים הבנויים כ-DLL, לפעמים כמה יחד
wininit.exeתהליך אתחול שמפעיל, בין השאר, את services.exe ואת lsass.exe
explorer.exeשולחן העבודה ושורת המשימות של המשתמש
ntoskrnl.exeהגרעין, שבודק כל גישה לפי האסימון

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

טעויות נפוצות
  • lsass.exe רץ בזהות של Administrator, המנהל המובנה של המחשב. הוא רץ תחת SYSTEM, חשבון של המערכת עצמה, עם הרשאות רחבות יותר מכל משתמש.
  • lsass.exe מעלה ומוריד שירותים. זה התפקיד של services.exe.
  • lsass.exe הוא המארח המשותף של שירותי ה-DLL. המארח הוא svchost.exe.
  • lsass.exe מצייר את מסך הכניסה וקולט את ההקלדה. את מסך הכניסה מנהל winlogon.exe, ו-lsass.exe רק מקבל ממנו את הפרטים לבדיקה.
בדקו את עצמכם
מנהל מציע להריץ את lsass.exe תחת NetworkService, כדי לצמצם הרשאות. למה זה לא יעבוד?

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

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

כש-lsass.exe נעצר: אתחול כפוי

בלי lsass.exe אין ב-Windows מי שיבדוק סיסמה, של חשבון מקומי או של משתמש מהרשת, ואין מי שיבנה אסימון גישה חדש. לכן Windows מסווגת אותו כתהליך קריטי, ואינה מוכנה לרוץ בלעדיו.

בפועל, כשהוא מתרסק, או כשמישהו מסיים אותו ב-End task של Task Manager, קופצת הודעה, והמחשב עובר הפעלה מחדש בכפייה, בלי לשאול איש.

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

מה שנשאר שלם הם הנתונים: ה-SAM שוכב בדיסק ולא נמחק, כי רק מי שקרא ממנו הפסיק לפעול. גם מפתחות הדרייברים ב-Registry לא נפגעים, ואף שירות לא נעצר כדי לפנות זיכרון.
טעויות נפוצות
  • אחרי קריסה של lsass.exe המשתמש רק יחזור למסך הכניסה. Windows מאתחלת את המחשב כולו בכפייה, ולא רק את הסשן.
  • כניסות מקומיות ימשיכו לעבוד, ורק האימות מול הרשת ייפסק. כל אימות, גם של חשבון מקומי, עובר דרך lsass.exe, ולכן לא נשארת שום דרך עוקפת.
  • הקריסה מוחקת את הגיבובים שב-SAM. ה-SAM שמור בדיסק ונשאר כפי שהיה.
  • lsass.exe הוא תהליך עזר, ואפשר לסגור אותו בלי השלכות. סגירה שלו מביאה לאתחול כפוי של Windows.
בדקו את עצמכם
טכנאית סוגרת בטעות את lsass.exe ב-Task Manager. מה יקרה מיד, ומה יהיה מצב החשבונות המקומיים אחרי העלייה?

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

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

איך מזהים lsass.exe מתחזה

במחשב תקין יש בדיוק lsass.exe אחד: הוא נטען מ-System32 ורץ תחת SYSTEM. אין עותק לכל משתמש, גם כשחמישה אנשים מחוברים לאותו שרת.

דווקא מפני שהשם מוכר, תוכנות זדוניות קוראות לעצמן lsass.exe כדי להיבלע ברשימת התהליכים. שני דברים צריכים להדליק נורה: עותק שני בשם lsass.exe, או lsass.exe שהקובץ שלו יושב מחוץ ל-System32.

תהליך אחד נראה קרוב ואינו בעיה: LsaIso.exe. הוא מופיע כש-Credential Guard פעיל, וזה תהליך אחר עם שם אחר, לא שכפול של lsass.exe.

Text
C:\>tasklist /fi "imagename eq LsaIso.exe"
פלט
Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
LsaIso.exe                     716 Services                   0      1,140 K

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

תרחיש 9: שתי שורות של lsass.exe

אנליסטית פותחת את לשונית Details ב-Task Manager ומוצאת שתי שורות בשם lsass.exe. היא מוסיפה את העמודה Command line, כדי לראות מאיפה כל אחת נטענה.

  • שורה אחת: C:\Windows\System32\lsass.exe. זה המקום היחיד שממנו רץ התהליך האמיתי.
  • שורה שנייה: C:\ProgramData\Updater\lsass.exe. אין סיבה לגיטימית ש-lsass.exe ירוץ משם, ולכן זה החשוד.

האם לסגור את שתיהן ליתר ביטחון? לא. סגירה של העותק שב-System32 תאתחל את המחשב בכפייה.

וההסבר 'זה בטח Credential Guard' לא מחזיק: Credential Guard מוסיף תהליך בשם LsaIso.exe, לא lsass.exe שני.

טעויות נפוצות
  • לכל משתמש מחובר יש lsass.exe משלו. בכל המחשב רץ lsass.exe אחד, לא משנה כמה משתמשים מחוברים.
  • Credential Guard מסביר lsass.exe כפול. Credential Guard מריץ את LsaIso.exe, תהליך עם שם שונה.
  • LsaIso.exe ברשימת התהליכים מעיד על הדבקה. זה הרכיב המבודד והלגיטימי של Credential Guard.
בדקו את עצמכם
ברשימת התהליכים יש lsass.exe אחד שנטען מ-System32, ו-LsaIso.exe לידו. האם זה מחשיד?

לא. יש עותק אחד ממקום תקין, ו-LsaIso.exe הוא החלק המבודד של Credential Guard.

מהם שני הסימנים ל-lsass.exe מזויף?

עותק נוסף בשם lsass.exe, או קובץ lsass.exe שרץ מתיקייה שאינה System32.

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

שמירה על הזיכרון של lsass.exe

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

גיבוב שנשלף כך שימושי לתוקף גם בלי לפצח אותו: בהתקפת pass-the-hash הוא מציג את הגיבוב עצמו במקום סיסמה. לכן ההגנה צריכה למנוע את קריאת הזיכרון מלכתחילה.

הגנהאיך היא חוסמת
LSA Protection, שנקראת גם RunAsPPLlsass.exe עולה כ-PPL, Protected Process Light. תהליך רגיל, גם כזה שרץ כמנהל, לא מקבל רשות לקרוא את הזיכרון שלו
Credential Guardחלק מהסודות עוברים לתהליך מבודד, LsaIso.exe, שרץ בסביבה מוגנת שגם הגרעין הרגיל לא ניגש אליה

את LSA Protection מפעילים בערך RunAsPPL שבמפתח Control\Lsa של HKLM\SYSTEM\CurrentControlSet. קריאת הערך היא פעולה בטוחה, ובמחשב הזה הוא פשוט לא הוגדר:

Text
C:\>reg query HKLM\SYSTEM\CurrentControlSet\Control\Lsa /v RunAsPPL
פלט
ERROR: The system was unable to find the specified registry key or value.

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

אמצעיעל מה הוא כן מגןלמה הוא לא עוזר כאן
BitLockerעל הנתונים שבכונן, כשהמחשב כבוי או כשהדיסק נלקחהמערכת דולקת, והזיכרון של lsass.exe נגיש לתוכנה שכבר רצה
חסימת פורט בחומת האשעל חיבורים שמגיעים מהרשתהקריאה נעשית מקומית, מתוך המחשב
הרשאות קשוחות על הקובץ lsass.exeעל הקובץ שבדיסקהתוקף קורא את התהליך שבזיכרון, לא את הקובץ
סיסמאות ארוכות, אנטי וירוס נוסף, Guest מושבתעל תרחישים אחריםאף אחד מהם לא מונע מתוכנה עם הרשאות מנהל לקרוא זיכרון
טעויות נפוצות
  • הצפנת הכונן ב-BitLocker תמנע dump של lsass.exe. BitLocker שומר על הדיסק כשהמחשב כבוי, ולא על הזיכרון של מערכת דולקת.
  • אם כל הסיסמאות יהיו באורך 14 תווים לפחות, אי אפשר יהיה לגנוב גיבובים מהזיכרון. הגיבוב יושב בזיכרון בכל מקרה, ואורך הסיסמה לא משנה את זה.
  • מספיק לנעול את ההרשאות על הקובץ lsass.exe ב-System32. ההתקפה פונה לתהליך שרץ, והקובץ בדיסק לא משחק בה תפקיד.
בדקו את עצמכם
במה RunAsPPL ו-Credential Guard שונים זה מזה?

RunAsPPL משאיר את הסודות ב-lsass.exe, אבל מריץ אותו כתהליך מוגן שתהליכים רגילים לא קוראים. Credential Guard מוציא חלק מהסודות החוצה, לתהליך מבודד נפרד בשם LsaIso.exe.

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

UAC: אישור לפני הרשאות מנהל

הבעיה ש-UAC בא לפתור

UAC הוא ראשי תיבות של User Account Control. הוא נולד ממצב מוכר: אנשים רבים עובדים כל היום עם חשבון שחבר בקבוצת המנהלים.

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

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

חשוב באותה מידה לדעת מה לא שייך ל-UAC:

  • ארגז חול (Sandbox): UAC לא מבודד את התוכנה משאר המערכת. אחרי אישור היא רצה כרגיל, עם הרשאות מלאות.
  • זיהוי נוזקות: UAC לא סורק ולא מסווג קבצים. הוא שואל, ואת ההחלטה משאיר למשתמש.
  • חתימות: UAC לא אוסר להתקין תוכנה שלא נחתמה.
  • חסימה גורפת: הוא לא חוסם כל תוכנה חדשה בלי דרך לאשר אותה.
  • דחייה שקטה: הוא לא מסרב לבקשה בלי להודיע, אלא מציג חלון.
  • סיסמאות ותיעוד: הוא לא מנהל סיסמאות של משתמשים, ולא כותב כל פעולה ליומן האירועים.
Microsoft עצמה לא רואה ב-UAC גבול אבטחה (security boundary), אלא שכבת הגנה נוספת. יש אפילו קובצי מערכת שמקבלים הרמה אוטומטית (auto-elevate), בלי שום חלון.
בדקו את עצמכם
מה UAC דורש מהמשתמש לפני שתוכנה מקבלת הרשאות מנהל?

אישור מפורש, שניתן ביודעין, בחלון שמוצג לו.

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

שני אסימונים לכל מנהל

כאן נמצא המנגנון עצמו. כשמשתמש שחבר בקבוצת Administrators נכנס, lsass.exe לא בונה לו אסימון אחד אלא זוג, ומצב זה נקרא split token, אסימון מפוצל.

אסימוןמה יש בורמת שלמותמי מקבל אותו
filtered token (מסונן)הרשאות המנהל הוצאו ממנוMediumכל תוכנה, כברירת מחדל
full token (מלא)כל הרשאות המנהלHighרק תוכנה שקיבלה אישור UAC

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

יש שתי דרכים להגיע לאסימון המלא. המשתמש לוחץ קליק ימני ובוחר Run as administrator, או שהתוכנה מצהירה על כך מראש בקובץ ה-manifest שלה, בשדה requestedExecutionLevel:

requestedExecutionLevelהתנהגות
asInvokerיורשת את האסימון של מי שהפעיל אותה, ולא מבקשת דבר
highestAvailableמבקשת את הרמה הגבוהה ביותר שעומדת לרשות המשתמש הנוכחי
requireAdministratorלא תרוץ בלי הרשאות מנהל, ולכן תמיד מעוררת בקשה. הסמל שלה מסומן במגן

צורת החלון תלויה במי שיושב מול המחשב. למנהל מוצג חלון הסכמה (consent) עם Yes ו-No, כי האסימון המלא כבר שלו. למשתמש רגיל אין אסימון מלא, ולכן החלון מבקש ממנו שם וסיסמה של מנהל (credentials).

חריג שכדאי לזכור: המנהל המובנה, Administrator, שה-RID שלו 500, פטור מ-UAC בהגדרות ברירת המחדל ותמיד מקבל את האסימון המלא.

את רמת השלמות של החלון הנוכחי רואים ב-whoami /groups. זה הפלט מחלון cmd שנפתח כרגיל:

Text
C:\>whoami /groups | findstr Label
פלט
Mandatory Label\Medium Mandatory Level                        Label            S-1-16-8192

בחלון שנפתח עם Run as administrator, אותה שורה מראה High Mandatory Level, עם ה-SID ‏S-1-16-12288.

תרחיש 10: מנהלת שנתקלת ב-Access is denied

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

Text
C:\>bcdedit /enum
פלט
The boot configuration data store could not be opened.
Access is denied.

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

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

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

טעויות נפוצות
  • עד שהמשתמש מאשר, UAC מריץ אותו כאורח (Guest). המשתמש נשאר אותו משתמש, רק עם האסימון המסונן.
  • UAC מוציא את המשתמש מ-Administrators עד האתחול הבא. החברות בקבוצה לא זזה. משתנה רק האסימון שהתוכנה מקבלת.
  • lsass.exe מאמת הרשאות מנהל מחדש לפני כל פקודה. ההרשאות נגזרות מהאסימון שהתהליך כבר מחזיק.
  • תוכנה שמבקשת הרמה נחשבת חשודה ומושבתת. מוצג חלון אישור, ואחרי Yes היא רצה עם האסימון המלא.
  • כשאין אישור, Windows דוחה את הבקשה בלי להגיד דבר, או מריצה את התוכנה ברקע. UAC מציג חלון ומחכה להחלטה של המשתמש.
בדקו את עצמכם
משתמש רגיל, שאינו חבר ב-Administrators, מפעיל תוכנה שה-manifest שלה הוא requireAdministrator. מה יופיע לו?

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

מה רמת השלמות של cmd שנפתח בלחיצה רגילה בחשבון מנהל, ומה היא אחרי Run as administrator?

Medium עם האסימון המסונן, ו-High עם האסימון המלא.

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

למה המסך מתעמעם: ה-secure desktop

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

העמעום אומר שהחלון כבר לא נמצא על שולחן העבודה שלכם, אלא על ה-secure desktop, שולחן עבודה מבודד ששייך ל-Winlogon. על אותו שולחן עבודה מוצג גם מסך Ctrl+Alt+Del, ומה שרואים מאחורי החלון הוא רק תמונה כהה של שולחן העבודה הרגיל.

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

בזמן שהחלון פתוח, שאר התהליכים ממשיכים לרוץ כרגיל, והמשתמש לא מוחלף בחשבון Administrator המובנה.

ברמה שבה בוחרים 'בלי עמעום' (הרמות מופיעות בחלק הבא), החלון מוצג על שולחן העבודה הרגיל, ולכן ההגנה הזו לא קיימת.
טעויות נפוצות
  • העמעום נועד רק למשוך את העין לחלון. העמעום הוא תוצאה של המעבר ל-secure desktop.
  • Windows משהה את כל התהליכים עד התשובה, כדי לחסוך במעבד. התהליכים ממשיכים לעבוד ברקע.
  • למשך החלון Windows עוברת לחשבון Administrator המובנה. המשתמש נשאר אותו משתמש.
בדקו את עצמכם
מה משותף לחלון UAC המעומעם ולמסך Ctrl+Alt+Del?

שניהם מוצגים על ה-secure desktop של Winlogon, שתוכנות רגילות לא ניגשות אליו.

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

ארבע העמדות של המחוון

את רמת UAC קובעים ב-Control Panel, תחת User Accounts, בקישור Change User Account Control settings. נפתח מחוון עם ארבע עמדות, מהמחמירה ועד הכבויה:

עמדהמתי מופיע חלוןאיפה הוא מוצג
Always notifyגם כשתוכנה מנסה לשנות משהו, וגם כשהמשתמש עצמו משנה הגדרה של Windowssecure desktop
Notify me only when apps try to make changes (ברירת המחדל)רק כשתוכנה מנסה לבצע שינויsecure desktop, עם עמעום
Notify me only when apps try to make changes (do not dim my desktop)כמו בברירת המחדלשולחן העבודה הרגיל, בלי עמעום
Never notifyאף פעםאין חלון

המחוון כותב ערכים למפתח HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System, ואפשר לשנות אותם גם ישירות. אחד מהם הוא PromptOnSecureDesktop, שקובע אם החלון יוצג על ה-secure desktop. כך נראית קריאה בלבד של שני ערכים במחשב שעליו נכתב החלק:

Text
C:\>reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v PromptOnSecureDesktop
פלט
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System
    PromptOnSecureDesktop    REG_DWORD    0x0
Text
C:\>reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v ConsentPromptBehaviorAdmin
פלט
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System
    ConsentPromptBehaviorAdmin    REG_DWORD    0x5

הערך 5 ב-ConsentPromptBehaviorAdmin הוא ההתנהגות הרגילה למנהלים: לשאול כשתוכנה מבקשת הרמה. יחד עם PromptOnSecureDesktop=0 זו בדיוק העמדה השלישית: יש חלון, אבל בלי עמעום ובלי secure desktop.

כל ירידה במחוון מגדילה את החשיפה, והעמדה Never notify היא המסוכנת מכולן.

שתי דרכים מדומות לכבות את UAC מופיעות כמסיחים. הראשונה היא sc stop, אבל UAC הוא מנגנון ולא שירות, ולכן אין לו שם שאפשר לעצור. מה שכן קיים הוא השירות Application Information, שמטפל בבקשות ההרמה, ועצירה שלו רק משאירה בחוץ תוכנות שזקוקות להרמה, בלי לכבות את UAC.

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

טעויות נפוצות
  • מכבים את UAC בעצירה של שירות בשם UAC. אין שירות כזה. UAC הוא מנגנון של המערכת, לא שירות.
  • עריכה של hosts מבטלת את חלונות UAC. hosts ממפה שמות לכתובות IP, ולא נוגע בהרשאות.
  • Always notify היא העמדה שמגיעה מהמפעל. ברירת המחדל היא Notify me only when apps try to make changes, עם עמעום.
בדקו את עצמכם
באיזו עמדה יש חלון UAC אבל המסך לא מתעמעם, ומה המשמעות מבחינת אבטחה?

העמדה השלישית, do not dim my desktop. החלון מוצג על שולחן העבודה הרגיל ולא על ה-secure desktop, ולכן הוא לא מבודד מתוכנות אחרות.

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

EnableLUA: המתג הראשי

Never notify רק משתיק את החלונות. כדי לכבות את המנגנון עצמו משנים ערך אחר באותו מפתח Policies\System, ששמו EnableLUA. השם שומר על הכינוי הישן של המנגנון, Limited User Account.

  • הסוג: REG_DWORD.
  • 1: UAC פועל, ותוכנה צריכה הרמה כדי לקבל הרשאות מנהל.
  • 0: UAC מנוטרל לגמרי.
Text
C:\>reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v EnableLUA
פלט
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System
    EnableLUA    REG_DWORD    0x1

הפלט מראה 0x1, כלומר UAC פועל במחשב הזה.

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

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

כיבוי של UAC מתאים רק למחשבי מעבדה ובדיקות, לא למחשב שעובדים עליו.
תרחיש 11: הערך שונה, והחלון עדיין קופץ

איתי מכין מכונה וירטואלית לבדיקות אוטומטיות. הוא כותב 0 ל-EnableLUA עם reg add, מפעיל מיד תוכנת התקנה, ו-UAC עדיין שואל.

הוא מנסה Sign out וכניסה מחדש, וגם אז החלון מופיע.

ההסבר: הערך נטען רק בעליית המערכת. Restart של המכונה הוא מה שמכניס את השינוי לתוקף, ואחריו UAC כבוי.

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

טעויות נפוצות
  • EnableLUA קובע אם דרייברים צריכים חתימה. EnableLUA מדליק ומכבה את UAC. לחתימות של דרייברים אין קשר אליו.
  • EnableLUA בוחר אם החלון יוצג על ה-secure desktop. את זה קובע ערך אחר, PromptOnSecureDesktop.
  • EnableLUA מפעיל גיבוי של ה-SAM בכל עלייה. אין לו שום קשר ל-SAM.
  • אחרי שינוי EnableLUA די לצאת מהחשבון ולהיכנס שוב. השינוי נכנס לתוקף רק אחרי הפעלה מחדש של המחשב.
בדקו את עצמכם
מה הסוג של EnableLUA, ואיזה מספר הוא מכיל כש-UAC פעיל?

REG_DWORD, עם הערך 1.

מה ההבדל בין Never notify לבין EnableLUA=0?

Never notify רק מפסיק להציג חלונות. EnableLUA=0 מכבה, אחרי אתחול, את המנגנון כולו.

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

UAC Virtualization: הפניית כתיבה לתוכנות ותיקות

תוכנות רבות נכתבו בימים שבהם כל משתמש היה מנהל, ולכן הן שומרות הגדרות במקומות מוגנים: בתוך C:\Program Files, בתוך C:\Windows או תחת HKLM\Software. עם אסימון מסונן הכתיבה הזו הייתה נכשלת, והתוכנה הייתה נשברת.

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

לאן התוכנה מנסה לכתובלאן הכתיבה מגיעה בפועל
קבצים בתוך Program Files או WindowsC:\Users\<name>\AppData\Local\VirtualStore
מפתחות תחת HKLM\SoftwareVirtualStore שבתוך HKCU\Software\Classes

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

מי זוכה להסטה? רק תוכנה של 32 ביט, ותיקה מספיק כדי שאין לה manifest עם requestedExecutionLevel, וגם זאת רק כשהיא לא מורמת. תהליך של 64 ביט לא מקבל אותה, ואצלו כתיבה כזו פשוט נכשלת, כפי שמראה ניסיון מ-Python של 64 ביט בחלון רגיל:

Python
import struct
print("bits:", struct.calcsize("P") * 8)
try:
    with open(r"C:\Program Files\settings-probe.txt", "w") as f:
        f.write("volume=7")
    print("written")
except PermissionError as e:
    print("PermissionError:", e.strerror)
פלט
bits: 64
PermissionError: Permission denied

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

תרחיש 12: משחק ישן ששומר שיאים

משחק שחמט ישן של 32 ביט, בלי manifest, שומר את טבלת השיאים בקובץ C:\Program Files\ChessClub\scores.dat. עומר מפעיל אותו כרגיל, בלי Run as administrator, ומנצח.

השמירה לא נכשלת. Windows מסיטה אותה ל-C:\Users\Omer\AppData\Local\VirtualStore\Program Files\ChessClub\scores.dat, והקובץ שב-Program Files נשאר כמו שהיה.

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

טעויות נפוצות
  • Virtualization מעניק לתוכנה הרשאות מנהל בלי לשאול. ההרשאות נשארות של אסימון מסונן. רק יעד הכתיבה מוסט לעותק פרטי.
  • בפעם הראשונה מופיע חלון, והאישור נשמר לפעמים הבאות. אין חלון בכלל, לא בפעם הראשונה ולא אחריה.
  • זה מצב תאימות של 32 ביט, שבו לא צריך הרשאות כדי לכתוב לאזור מוגן. ההרשאות לא משתנות, והאזור המוגן לא נכתב. רק הנתיב משתנה.
בדקו את עצמכם
אחרי ש-Virtualization הסיט כתיבה, האם הקובץ שב-Program Files השתנה?

לא. השינוי נשמר בעותק שב-VirtualStore, בפרופיל של המשתמש שהפעיל את התוכנה.

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

Service: תוכניות הרקע של Windows

מהו שירות, ובמה הוא שונה מדברים דומים

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

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

מהההבדל משירות
Scheduled Task (משימה מתוזמנת)מופעלת לפי שעה או אירוע, מסיימת ויוצאת. מנוהלת ב-Task Scheduler
תוכנה שהמשתמש פותחחיה בסשן של המשתמש, עם חלונות, ונגמרת כשסוגרים אותה
Driver (דרייבר)קוד שמגשר בין Windows לחומרה, ורובו רץ במצב ליבה

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

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

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

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

מי מנהל את השירותים: SCM, svchost.exe וחשבונות

מאחורי כל שירות במחשב עומד מנהל אחד: Service Control Manager, או SCM. הוא חי בתהליך services.exe, ותפקידו להעלות שירותים, להוריד אותם ולדעת בכל רגע מה מצבו של כל אחד.

ה-SCM לא מחכה למשתמש: הוא מעלה שירותים עוד לפני שמישהו נכנס, ולכן explorer.exe אינו ההורה שלהם. את ההגדרות הוא קורא מה-Registry, ממפתח נפרד לכל שירות תחת HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services.

כל שירות רץ בזהות מסוימת:

חשבוןהרשאות
LocalSystemהחשבון SYSTEM, הרשאות מקסימליות
LocalServiceהרשאות מצומצמות
NetworkServiceהרשאות מצומצמות, וכשהוא פונה לרשת הוא מזדהה בשם המחשב
חשבון משתמש מסויםמה שהוקצה לאותו חשבון

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

כך נראית התצורה של שירות השעון, שבנוי כ-DLL:

Text
C:\>sc qc W32Time
פלט
[SC] QueryServiceConfig SUCCESS

SERVICE_NAME: W32Time
        TYPE               : 20  WIN32_SHARE_PROCESS
        START_TYPE         : 3   DEMAND_START
        ERROR_CONTROL      : 1   NORMAL
        BINARY_PATH_NAME   : C:\Windows\system32\svchost.exe -k LocalService
        LOAD_ORDER_GROUP   :
        TAG                : 0
        DISPLAY_NAME       : Windows Time
        DEPENDENCIES       :
        SERVICE_START_NAME : NT AUTHORITY\LocalService

BINARY_PATH_NAME מצביע על svchost.exe עם שם של קבוצת אירוח, ו-SERVICE_START_NAME מראה שהשירות רץ כ-LocalService.

עובדה נוספת לשאלות: PID (Process ID) מזהה תהליך אחד. שני תהליכים שחיים באותו רגע לא יקבלו אותו מספר.

תרחיש 13: שני שירותים, PID אחד

בלשונית Services של Task Manager, השירותים RpcSs ו-RpcEptMapper מופיעים עם אותו PID. בודקים מה עומד מאחוריו:

Text
C:\>sc queryex RpcEptMapper | findstr "SERVICE_NAME STATE PID"
פלט
SERVICE_NAME: RpcEptMapper
        STATE              : 4  RUNNING
        PID                : 1312
Text
C:\>tasklist /svc /fi "pid eq 1312"
פלט
Image Name                     PID Services
========================= ======== ============================================
svchost.exe                   1312 RpcEptMapper, RpcSs

ה-PID 1312 שייך לתהליך svchost.exe אחד, ושני השירותים יושבים בתוכו.

אילו היו אלה שני עותקים נפרדים של svchost.exe, כל אחד היה מקבל PID משלו. אין כאן גם קשר ל-explorer.exe, וסוג ההפעלה של שירות לא קובע את ה-PID שלו.

טעויות נפוצות
  • Windows מצמידה PID זהה לכל העותקים של אותו קובץ הפעלה. לכל תהליך PID ייחודי, גם כשכמה תהליכים נוצרו מאותו קובץ.
  • השירותים נולדים כתהליכי בן של explorer.exe. ה-SCM, ב-services.exe, מפעיל אותם, גם לפני שמישהו נכנס.
  • שירותים שמוגדרים Automatic חולקים PID. ה-PID לא תלוי בסוג ההפעלה. PID משותף פירושו מארח משותף.
בדקו את עצמכם
באיזה תהליך רץ ה-SCM, ואיפה הוא שומר את ההגדרות של השירותים?

ב-services.exe. ההגדרות שמורות במפתח Services שתחת CurrentControlSet, בענף HKEY_LOCAL_MACHINE\SYSTEM.

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

סוגי ההפעלה וערך Start

ה-Startup type קובע מתי שירות עולה. כל סוג נשמר כמספר בערך Start שבמפתח של השירות, ול-sc יש מילה משלו לכל סוג:

Startup typeמתי השירות עולהStartב-sc
Automaticכש-Windows עולה, עוד לפני כניסה של משתמש2start= auto
Automatic (Delayed Start)כש-Windows עולה, קצת אחרי שאר השירותים האוטומטיים2, ובנוסף DelayedAutostart=1start= delayed-auto
Manualלא עם Windows, אלא רק כשמשתמש, תוכנה או שירות אחר מבקשים3start= demand
Manual (Trigger Start)ידני, ובנוסף עולה מעצמו כשאירוע מוגדר קורה3start= demand
Disabledלא עולה באתחול, וגם ניסיון להפעיל אותו ידנית נכשל4start= disabled

שני ערכים נוספים של Start מופיעים כמעט רק אצל דרייברים: 0 הוא Boot, טעינה בידי מנהל האתחול עוד לפני הגרעין, ו-1 הוא System, טעינה בזמן שהגרעין מאתחל.

פרט שנבחן: ב-sc הסוג Manual נכתב demand. המילה manual לא קיימת שם.

השירות BITS מוגדר במחשב הזה Delayed. כך זה נראה ב-sc וב-Registry:

Text
C:\>sc qc BITS | findstr START_TYPE
פלט
        START_TYPE         : 2   AUTO_START  (DELAYED)
Text
C:\>reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\BITS /v DelayedAutostart
פלט
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\BITS
    DelayedAutostart    REG_DWORD    0x1

כמה כללים שנובעים מהטבלה:

  • Disabled לא נעלם מעצמו. הוא נשאר בתוקף אחרי אתחול, וגם ב-Safe Mode, עד שמישהו משנה אותו.
  • Delayed Start הוא סוג אוטומטי, לא ידני.
  • Manual לא אומר כבוי: שירות כזה רץ כשמבקשים אותו. Application Information, למשל, מוגדר Manual ורץ ברגע זה במחשב הזה.
  • שירות Automatic לא מחכה לכניסה של משתמש, כי השירותים עולים לפני מסך הכניסה.

בנוסף לסוג ההפעלה, לכל שירות יש הגדרות Recovery: מה ה-SCM יעשה כשהשירות נופל, למשל להפעיל אותו שוב.

תרחיש 14: שירות Disabled שמנסים להעלות

השירות PayrollSync מוגדר Disabled. מנהלת מריצה sc start PayrollSync בלי לגעת בהגדרה, ו-sc מחזיר שגיאה 1058. זה הטקסט ש-Windows מצמידה לקוד הזה:

Text
C:\>net helpmsg 1058
פלט
The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.

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

הדרך הנכונה היא לשנות קודם את סוג ההפעלה, ורק אחר כך להפעיל:

Text
C:\>sc config PayrollSync start= demand
C:\>sc start PayrollSync
טעויות נפוצות
  • Manual הוא שם אחר ל-Disabled. Disabled חוסם כל הפעלה. Manual רק לא עולה מעצמו.
  • Manual עולה באתחול, בתנאי שמישהו כבר מחובר. Manual לא עולה עם Windows בכלל, מחובר או לא.
  • Manual פירושו עלייה מעט אחרי שאר השירותים. זה Automatic (Delayed Start).
  • שירות Manual לא יכול לרוץ. הוא רץ ברגע שמבקשים אותו.
  • שירות Disabled ישתחרר מעצמו באתחול הבא. ההגדרה נשמרת עד שמשנים אותה.
בדקו את עצמכם
איזה מספר יש בערך Start של שירות Manual, ואיזו מילה כותבים עבורו ב-sc config?

3, והמילה היא demand.

מה מבדיל ב-Registry בין Delayed Start לבין Automatic רגיל?

בשניהם Start=2, וב-Delayed נוסף הערך DelayedAutostart=1.

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

services.msc: קונסולת השירותים

כדי לנהל שירותים עם העכבר, פותחים את חלון Run בצירוף Win+R, או את תיבת החיפוש, ומקלידים services.msc. מה שנפתח הוא קונסולת MMC שמוקדשת לשירותים.

הקונסולה היא כלי, לא שירות. היא מציגה טבלה של כל השירותים: Status (Running, או תא ריק לשירות עצור), Startup Type, והחשבון שתחתיו כל שירות רץ.

ממנה מבצעים Start, Stop, Pause ו-Restart. לחיצה כפולה על שירות פותחת חלון Properties, ובו:

  • סוג ההפעלה, בלשונית General.
  • החשבון שהשירות רץ תחתיו, בלשונית Log On.
  • מה לעשות כשהשירות נכשל, בלשונית Recovery.
  • באילו שירותים הוא תלוי ומי תלוי בו, בלשונית Dependencies.

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

פקודהמה נפתח
services.mscניהול שירותים
devmgmt.mscDevice Manager: התקנים והדרייברים שלהם
eventvwr.mscEvent Viewer: יומני אירועים
taskschd.mscTask Scheduler: משימות מתוזמנות
lusrmgr.mscLocal Users and Groups: משתמשים וקבוצות מקומיים
gpedit.mscLocal Group Policy Editor: מדיניות מקומית
diskmgmt.mscDisk Management: דיסקים ומחיצות

net start ו-taskkill אינם קונסולות בכלל, אלא פקודות טקסט. net start בלי פרמטרים מדפיס את רשימת השירותים שרצים, וכאן היא מסוננת לשתי שורות:

Text
C:\>net start | findstr /i "Print Workstation"
פלט
   Print Spooler
   Workstation
טעויות נפוצות
  • devmgmt.msc היא קונסולת השירותים. היא פותחת את Device Manager.
  • net start בלי שם פותח חלון ניהול. הוא מדפיס בשורת הפקודה, כטקסט, את השירותים שרצים.
  • בשירותים מטפלים ב-gpedit.msc. gpedit.msc עורך מדיניות מקומית, לא שירותים.
בדקו את עצמכם
באיזו לשונית של Properties מחליפים את החשבון שהשירות רץ תחתיו?

בלשונית Log On.

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

sc ו-net: שירותים משורת הפקודה

sc (Service Control) עושה משורת הפקודה את מה ש-services.msc עושה בעכבר. בגלל שאין לו ממשק גרפי, אפשר לשלב אותו בסקריפטים.

פקודהמה היא עושה
sc query <name>המצב כרגע: רץ או עצור
sc queryex <name>המצב, ובנוסף ה-PID של התהליך
sc qc <name>Query Config: התצורה הקבועה, כלומר סוג הפעלה, נתיב, תלויות וחשבון
sc start <name>מפעילה את השירות כעת
sc stop <name>מבקשת מהשירות לעצור
sc pause <name>משהה שירות שתומך בכך, בלי לעצור אותו
sc config <name> ...משנה תצורה של שירות קיים
sc create <name> ...רושמת שירות חדש
sc delete <name>מוחקת את הרישום של השירות
כלל תחביר ש-sc מקפיד עליו: אחרי = חייב לבוא רווח. start= auto עובד, ו-start=auto לא.

גם net יודע לטפל בשירותים: net start <name> מעלה שירות, net stop <name> מוריד אותו, ו-net start לבדה מציגה את מה שרץ, כפי שראינו. כל פעולה שמשנה שירות מערכת מחייבת חלון שנפתח עם Run as administrator.

ההבחנה המרכזית: start ו-stop משפיעים על הרגע הזה בלבד, ו-config משנה הגדרה שנשמרת ונשארת.

שתי השאילתות מחזירות מידע שונה. sc query מציגה מצב:

Text
C:\>sc query LanmanWorkstation
פלט
SERVICE_NAME: LanmanWorkstation
        TYPE               : 30  WIN32
        STATE              : 4  RUNNING
                                (STOPPABLE, PAUSABLE, IGNORES_SHUTDOWN)
        WIN32_EXIT_CODE    : 0  (0x0)
        SERVICE_EXIT_CODE  : 0  (0x0)
        CHECKPOINT         : 0x0
        WAIT_HINT          : 0x0

השורה בסוגריים מראה גם אילו בקשות השירות מקבל: את Workstation מותר להשהות, כלומר sc pause יעבוד עליו. ו-sc qc, לעומת זאת, מציגה תצורה:

Text
C:\>sc qc Spooler
פלט
[SC] QueryServiceConfig SUCCESS

SERVICE_NAME: Spooler
        TYPE               : 110  WIN32_OWN_PROCESS (interactive)
        START_TYPE         : 2   AUTO_START
        ERROR_CONTROL      : 1   NORMAL
        BINARY_PATH_NAME   : C:\Windows\System32\spoolsv.exe
        LOAD_ORDER_GROUP   : SpoolerGroup
        TAG                : 0
        DISPLAY_NAME       : Print Spooler
        DEPENDENCIES       : RPCSS
                           : http
        SERVICE_START_NAME : LocalSystem

בפלט של qc, START_TYPE הוא סוג ההפעלה (כאן 2, AUTO_START), BINARY_PATH_NAME הוא הקובץ שרץ, DEPENDENCIES מפרט תלויות ו-SERVICE_START_NAME הוא החשבון. אף אחד מאלה לא מופיע בפלט של sc query.

תרחיש 15: שעון שיעלה בכל אתחול

השירות Windows Time ‏(W32Time) מוגדר אצלנו Manual, כפי שראינו ב-sc qc. מנהל רוצה שיעלה לבד בכל הפעלה של המחשב, ובחלון מנהל הוא כותב:

Text
C:\>sc config W32Time start= auto

config משנה שירות שכבר קיים, ו-start= auto הופך אותו ל-Automatic. בדיקה אחר כך ב-sc qc W32Time אמורה להראות START_TYPE 2 AUTO_START.

מה לא היה עובד: sc start W32Time או net start W32Time היו מעלים את השירות עכשיו, אבל באתחול הבא הוא שוב לא היה עולה. sc create היה מנסה לרשום שירות חדש בשם שכבר תפוס, במקום לשנות את הקיים.

טעויות נפוצות
  • sc start עם start= auto הופך שירות לאוטומטי. start רק מפעיל כעת. הגדרה קבועה משנים ב-config.
  • net start עם המתג /auto קובע הפעלה אוטומטית. net start יודע רק להפעיל עכשיו.
  • sc query תראה לכם סוג הפעלה ונתיב. sc query מראה מצב. את התצורה רואים ב-sc qc.
  • sc config היא הדרך לצפות בתצורה. config כותבת תצורה. הצפייה היא qc.
  • sc pause עוצרת את השירות. pause משהה. העצירה היא sc stop.
  • sc delete היא עצירה מהירה. delete מוחקת את רישום השירות מהמערכת.
  • אפשר לנהל שירותים גם עם at, eventvwr או netstat. at הוא כלי תזמון ישן, eventvwr הוא מציג היומנים, ו-netstat מדפיס את חיבורי הרשת הפתוחים.
בדקו את עצמכם
איזו פקודת sc מוסיפה למצב של שירות גם את ה-PID שלו?

sc queryex.

איך מוודאים ששירות לא יעלה, גם אם מישהו ינסה להפעיל אותו ידנית?

משנים את סוג ההפעלה ל-Disabled: sc config <name> start= disabled.

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

תלויות: מי עולה ראשון

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

Text
C:\>sc config ReportHub depend= QueueBroker

התלות נשמרת בערך DependOnService, מסוג REG_MULTI_SZ, בתוך המפתח של השירות. כך נראה הערך של Print Spooler, שתלוי בשני רכיבים:

Text
C:\>reg query HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Spooler /v DependOnService
פלט
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Spooler
    DependOnService    REG_MULTI_SZ    RPCSS\0http

בערך מסוג REG_MULTI_SZ יכולות לשבת כמה מחרוזות, ו-reg מסמן את הגבול ביניהן ב-\0. אותן שתי תלויות מופיעות בשורות DEPENDENCIES של sc qc Spooler שראינו קודם.

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

שלוש הגדרות נראות כאילו הן קובעות סדר, ואינן:

הגדרהמה היא עושה באמת
start= delayed-autoדוחה את העלייה לזמן קצר אחרי האתחול, בלי לדעת על אף שירות אחר
משימה מתוזמנת (schtasks)מופעלת לפי זמן או אירוע, ולא בודקת אם שירות מסוים כבר רץ
שינוי ערך Startקובע באיזה שלב השירות נטען. 0 הוא Boot, שמיועד לדרייברים, ולא המתנה לשירות
תרחיש 16: דוח שנכשל בכל בוקר

השירות ReportHub מייצר דוחות ושולח אותם לתור הודעות שמנהל השירות QueueBroker. אחרי כל אתחול ReportHub נופל, כי QueueBroker עוד לא היה מוכן.

מישהו מציע Delayed Start. אולי זה יעבוד לפעמים, במזל, אבל שום דבר לא מבטיח ש-QueueBroker יהיה מוכן בזמן.

הפתרון היציב הוא התלות שבפקודה למעלה. מעכשיו ה-SCM תמיד מעלה את QueueBroker ראשון, ורק אחריו את ReportHub.

טעויות נפוצות
  • delayed-auto גורם לשירות להמתין לשירות אחר. הוא רק דוחה את העלייה בזמן, בלי לבדוק דבר.
  • משימת schtasks עם onstart מבטיחה סדר עלייה. משימה מתוזמנת לא יודעת מה המצב של שירות אחר.
  • Start=0 גורם לשירות לחכות לאחרים. 0 הוא Boot, טעינה מוקדמת במיוחד של דרייבר.
בדקו את עצמכם
באיזה ערך, ומאיזה סוג, נשמרת תלות שהוגדרה ב-sc config depend=?

בערך DependOnService, מסוג REG_MULTI_SZ, במפתח של השירות.

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

Session 0: השירותים מאחורי הקיר

כל תהליך ב-Windows שייך לסשן (Session). החל מ-Windows Vista, Session 0 שמור לשירותים, והמשתמשים מקבלים מספרים לפי סדר הכניסה: הראשון Session 1, השני Session 2 וכן הלאה.

רואים את זה בעמודה Session# של tasklist:

Text
C:\>tasklist /fi "imagename eq explorer.exe"
פלט
Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
explorer.exe                  1320 Console                    1     49,204 K

explorer.exe של המשתמש רץ בסשן 1, בעוד lsass.exe, כפי שראינו קודם, רץ בסשן 0.

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

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

תרחיש 17: התראה שאף אחד לא ראה

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

החלון נוצר ב-Session 0, בסשן של השירות, ולא ב-Session 1 שבו היא עובדת. ומה שאינו ההסבר:

  • החשבון LocalSystem לא חוסם את MessageBox.
  • ה-SCM לא מעביר הודעות של שירותים ללשונית Services ב-Task Manager.
  • UAC לא קשור לחלונות של שירותים.
  • ה-secure desktop של Ctrl+Alt+Del שייך ל-Winlogon, והחלון לא מחכה שם.
טעויות נפוצות
  • שירות שרץ כ-LocalSystem לא מורשה לקרוא ל-MessageBox. הקריאה מותרת ומצליחה. החלון פשוט נוצר ב-Session 0.
  • UAC עוצר את החלון עד שמשתמש מאשר. UAC לא מעורב בהצגת חלונות של שירותים.
  • את החלון רואים אחרי Ctrl+Alt+Del. ה-secure desktop הוא של Winlogon, לא של השירותים.
בדקו את עצמכם
באיזה Session רצים השירותים, ובאיזה Session יעבוד המשתמש הראשון שייכנס?

השירותים ב-Session 0, והמשתמש הראשון ב-Session 1.

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

לצמצם את מה שעולה אוטומטית

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

לכן כדאי לעבור על רשימת השירותים האוטומטיים. שירות שלא צריך עובר ל-Manual, או ל-Disabled אם אין לו שום שימוש.

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

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

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

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

Driver: התוכנה שמדברת עם החומרה

מהו דרייבר

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

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

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

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

בדיסק, דרייברים הם בדרך כלל קובצי sys בתיקייה C:\Windows\System32\drivers, וההגדרות שלהם נמצאות באותו מפתח Services שבו יושבים השירותים. לכן sc qc יודע להציג גם דרייבר:

Text
C:\>sc qc disk
פלט
[SC] QueryServiceConfig SUCCESS

SERVICE_NAME: disk
        TYPE               : 1  KERNEL_DRIVER
        START_TYPE         : 0   BOOT_START
        ERROR_CONTROL      : 1   NORMAL
        BINARY_PATH_NAME   : \SystemRoot\System32\drivers\disk.sys
        LOAD_ORDER_GROUP   :
        TAG                : 0
        DISPLAY_NAME       : Disk Driver
        DEPENDENCIES       :
        SERVICE_START_NAME :

TYPE 1 KERNEL_DRIVER מסמן דרייבר של הגרעין, ו-START_TYPE 0 BOOT_START הוא הערך Start=0 שהוזכר בחלק על השירותים: טעינה מוקדמת במיוחד, כי בלי דרייבר הדיסק אין מאיפה לקרוא את שאר המערכת.

ומה דרייבר אינו:

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

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

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

דרייבר בליבה, ולמה הוא מסוגל להפיל הכול

רוב הדרייברים רצים במצב ליבה (kernel mode): באותו מרחב זיכרון של הגרעין, עם כל ההרשאות, ובלי שום מחיצה בינם לבין הגרעין.

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

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

לא כל דרייבר חייב לשבת בליבה. המסגרת UMDF (User-Mode Driver Framework) מאפשרת לכתוב דרייבר שרץ במצב משתמש, וכשהוא נכשל, הנזק נשאר מבודד ולכן קטן יותר.

ושלושה מקומות שבהם דרייבר ליבה לא נמצא: בתוך explorer.exe, בתוך התהליכים שמשתמשים בהתקן, וב-Session 0. Session 0 הוא סשן של שירותים, ושירותים הם תהליכים במצב משתמש.

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

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

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

חתימה דיגיטלית על דרייברים

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

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

  • זהות המפרסם: מי יצר את הדרייבר.
  • שלמות (Integrity): הקוד זהה למה שנחתם.

כך מופיע החותם ברשומה אחת מתוך הפלט של pnputil במחשב הזה:

Text
C:\>pnputil /enum-drivers
פלט
Published Name:     oem84.inf
Original Name:      keyboardnotification.inf
Provider Name:      Microsoft
Class Name:         Human Interface Devices
Class GUID:         {745a17a0-74d3-11d0-b6fe-00a0c90f57da}
Driver Version:     05/14/2018 3.3.207.0
Signer Name:        Microsoft Windows Hardware Compatibility Publisher

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

שאלה שחוזרת במבחנים: מה Windows עושה עם דרייבר ליבה שאין עליו חתימה? בגרסאות של 64 ביט התשובה חד משמעית, היא מסרבת לטעון אותו, והמנגנון שאוכף זאת נקרא Driver Signature Enforcement.

ב-Windows 10 הדרישה הוחמרה, החל מגרסה 1607: דרייבר ליבה חדש צריך לעבור דרך Microsoft ולשאת את החתימה שלה.

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

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

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

טעויות נפוצות
  • דרייבר לא חתום רץ בהרשאות מוגבלות, מבודד מהגרעין. החתימה לא קובעת הרשאות. דרייבר ליבה רץ בגרעין בכל מקרה, ובדיוק לכן חוסר חתימה מסוכן.
  • הסכנה בדרייבר לא חתום היא שהוא ממלא את ה-Page file. הסכנה היא קוד שאיש לא אימת, שרץ בליבה.
  • Windows משווה את תאריך הקובץ למאגר מקומי. היא מאמתת חתימה דיגיטלית.
  • החתימה הופכת את קובץ הדרייבר למוצפן. החתימה מזהה את המפרסם ומאמתת שלמות, ותו לא.
בדקו את עצמכם
דרייבר עם חתימה תקינה גרם למסך כחול. איך זה ייתכן?

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

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

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

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

דרךאיך מפעיליםכמה זמן זה נמשך
Disable driver signature enforcementבוחרים באפשרות בתפריט האתחול: Advanced Boot Options (מקש F8 בגרסאות ישנות), או Startup Settings בגרסאות חדשותאתחול אחד. באתחול הבא האכיפה חוזרת
Test Mode ‏(testsigning)bcdedit /set {current} testsigning on ואז הפעלה מחדש. נטענים גם דרייברים בחתימת בדיקה עצמיתעד שמכבים, עם bcdedit /set {current} testsigning off

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

איך מגיעים לתפריט הזה ב-Windows 10? פותחים את Settings ועוברים דרך Recovery אל Advanced startup. אחרי שהמחשב עולה למסך השחזור בוחרים Troubleshoot, אחר כך Advanced options ו-Startup Settings, ובסוף, אחרי עוד הפעלה מחדש, לוחצים 7 או F7.

שני פרטים על Test Mode: הוא דורש ש-Secure Boot יהיה כבוי, ומי שמפעיל אותו מקבל סימן מים עם המילים Test Mode בפינת המסך.

את testsigning מפעילים ב-bcdedit, הכלי שכותב ל-BCD, מאגר הגדרות האתחול. לאותו כלי יש עוד מתגים, ובשאלות מופיעים לצד testsigning שלושה שאין להם שום קשר לחתימות:

Text
bcdedit /set {current} testsigning on        test-signed drivers may load, Test Mode
bcdedit /set {current} safeboot minimal      the next boot goes to Safe Mode
bcdedit /set {current} nx alwaysoff          DEP is switched off
bcdedit /set {current} recoveryenabled no    no automatic recovery environment

אף אחת מהשורות האלה לא הורצה במחשב הזה: bcdedit דורש חלון מנהל, ובלעדיו הוא מחזיר Access is denied, כפי שראינו בחלק על UAC.

ומה לא עוקף את האכיפה:

  • sigverif: רק סורק ומדווח על חתימות, ולא מכבה דבר.
  • רמת UAC, כולל Never notify: אין לה קשר לחתימות של דרייברים.
  • Update Driver ב-Device Manager, עם בחירה ידנית של הקובץ: הבדיקה רצה בכל זאת.
  • sc start על הדרייבר: לא מדלג על בדיקת החתימה.
  • העתקה של קובץ ה-sys לתיקייה drivers: מיקום לא מחליף חתימה.
תרחיש 18: דרייבר חדש על מכונת בדיקות

מפתחת כתבה דרייבר לחיישן טמפרטורה, והיא רוצה לנסות אותו פעם אחת על מחשב Windows 10 של 64 ביט, לפני שהוא נחתם.

היא נכנסת ל-Startup Settings, בוחרת 7, והמחשב עולה כשהאכיפה כבויה. היא מתקינה את הדרייבר ומריצה את הבדיקות.

אחרי האתחול הבא האכיפה חוזרת לבד, והדרייבר הלא חתום כבר לא נטען.

כשהבדיקות הופכות ליומיומיות, היא עוברת לשיטה הקבועה: חותמת את הדרייבר בתעודת בדיקה, מכבה את Secure Boot ומפעילה testsigning ב-bcdedit.

טעויות נפוצות
  • sigverif משבית את בדיקת החתימות עד האתחול הבא. sigverif רק בודק ומציג.
  • safeboot minimal ב-bcdedit מתיר דרייברים לא חתומים. הוא רק מאתחל ל-Safe Mode.
  • nx alwaysoff מכבה את אכיפת החתימות. הוא מכבה את DEP.
  • Never notify ב-UAC מבטל גם את בדיקת החתימות. אלה שני מנגנונים נפרדים לגמרי.
  • קובץ sys שהועתק לתיקייה drivers נחשב מהימן. Windows בודקת חתימה, לא מיקום.
בדקו את עצמכם
כמה זמן נשארת בתוקף כל אחת מהשתיים: Disable driver signature enforcement, ו-testsigning?

הראשון חל על אתחול אחד בלבד. testsigning נשאר פעיל בכל האתחולים, עד שמכבים אותו ב-bcdedit.

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

Device Manager ו-Roll Back Driver

Device Manager הוא הכלי הגרפי לניהול התקנים והדרייברים שלהם, ונפתח בפקודה devmgmt.msc. בחלון Properties של כל התקן יש לשונית Driver, ובה חמישה לחצנים:

Buttonמה קורה כשלוחצים
Driver Detailsרשימת הקבצים של הדרייבר, לצפייה בלבד
Update Driverחיפוש או התקנה של גרסה אחרת
Roll Back Driverחזרה לגרסה שהייתה מותקנת לפני האחרונה
Disable Deviceכיבוי ההתקן, בלי להחליף או להסיר את הדרייבר
Uninstall Deviceהסרת ההתקן יחד עם הדרייבר שלו

Roll Back Driver זמין רק כשיש לאן לחזור, כלומר כשגרסה קודמת הוחלפה.

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

שלושה כלים נשמעים קרובים ואינם מנהלים דרייברים: Disk Management ‏(diskmgmt.msc) לדיסקים ולמחיצות, Event Viewer ‏(eventvwr.msc) ליומני האירועים, ו-Resource Monitor ‏(resmon.exe) לצריכת מעבד, זיכרון, דיסק ורשת בזמן אמת.

תרחיש 19: כרטיס רשת אחרי עדכון

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

המשתמש עולה ב-Safe Mode, שבו הדרייבר החדש לא נטען, ופותח את devmgmt.msc. הוא נכנס ל-Properties של כרטיס הרשת, ללשונית Driver, ולוחץ Roll Back Driver. הגרסה הקודמת חוזרת, והמחשב עולה כרגיל.

ולמה לא לחצן אחר? Update Driver מחפש גרסה כלשהי, לא דווקא את הקודמת. Disable Device היה משאיר את המחשב בלי רשת, ו-Driver Details רק מציג קבצים.

טעויות נפוצות
  • Update Driver הוא הלחצן שמחזיר לגרסה הקודמת. החזרה היא Roll Back Driver. Update Driver מחפש גרסה אחרת.
  • דרייברים מנהלים ב-Disk Management. Disk Management עוסק בדיסקים ובמחיצות.
  • Resource Monitor הוא המקום לעדכן או להסיר דרייבר. Resource Monitor רק מראה צריכת משאבים.
בדקו את עצמכם
רוצים לכבות זמנית מצלמה מובנית, בלי להסיר את הדרייבר שלה. באיזה לחצן תשתמשו?

Disable Device.

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

driverquery, pnputil ו-sigverif

שלושה כלים נוספים עוסקים בדרייברים, וקל לבלבל ביניהם:

Toolמה הוא עושה
driverqueryמדפיס בשורת הפקודה את הדרייברים שבמערכת, עם הסוג שלהם ותאריך הבנייה (Link Date)
pnputilמנהל משורת הפקודה את חבילות הדרייברים ב-Driver Store: הוספה, מחיקה והצגה
sigverifFile Signature Verification: סורק קובצי מערכת ודרייברים ומסמן אילו חתומים ואילו לא

Driver Store הוא המחסן של חבילות הדרייברים: מכל חבילה שקיבלה אישור התקנה, Windows שומרת שם עותק. המחסן יושב ב-C:\Windows\System32\DriverStore.

Text
pnputil /enum-drivers                        show the packages in the Driver Store
pnputil /add-driver tempsensor.inf /install  stage a package and install it
pnputil /delete-driver oem31.inf             remove a package from the store
sigverif                                     open File Signature Verification

וקטע מהפלט של driverquery במחשב הזה:

Text
C:\>driverquery | findstr /i "Module ==== 3ware Ntfs"
פלט
Module Name  Display Name           Driver Type   Link Date
============ ====================== ============= ======================
3ware        3ware                  Kernel        5/18/2015 5:28:03 PM
Ntfs         Ntfs                   File System

העמודה Driver Type מבחינה בין Kernel ל-File System, ו-Link Date מראה מתי הקובץ נבנה, כשהמידע קיים.

ומה הכלים האלה לא עושים:

  • pnputil לא מושך עדכונים מ-Windows Update בעצמו, ולא מחזיר את המערכת לנקודת שחזור. לשחזור מערכת יש כלי נפרד.
  • sigverif לא עוצר ולא מפעיל דרייברים, לא משווה גרסאות מול אתר היצרן ולא מגבה דרייברים.
  • sigverif גם לא מכבה את Driver Signature Enforcement.
טעויות נפוצות
  • pnputil מציג את הדרייברים הטעונים עם תאריך הבנייה שלהם. זו העבודה של driverquery.
  • pnputil משמש לשחזור המערכת לנקודה קודמת. שחזור מערכת הוא כלי אחר. pnputil מנהל חבילות ב-Driver Store.
  • sigverif שומר גיבוי של הדרייברים בתיקייה חיצונית. sigverif רק בודק חתימות.
בדקו את עצמכם
מנהל רוצה להסיר מה-Driver Store חבילה ישנה של דרייבר מדפסת. באיזה כלי ובאיזה מתג?

pnputil, עם /delete-driver ושם החבילה.

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

סיכום

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

משימהכלי או מיקום
לערוך את ה-Registry בחלון גרפיregedit
לקרוא, להוסיף ולמחוק ערכים מסקריפטreg query, reg add, reg delete
לגבות מפתח לקובץ טקסט ולהחזיר אותוreg export ו-reg import
לשמור כוורת שלמה כקובץ בינאריreg save
קובצי הכוורות של המחשבהתיקייה config שתחת System32
הכוורת האישית של משתמשNTUSER.DAT בתיקיית הפרופיל שלו
תוכנה שתעלה בכל כניסה של המשתמש הנוכחיהמפתח Run שתחת HKCU, בנתיב CurrentVersion
הגדרות של שירותים ושל דרייבריםהמפתח Services שתחת CurrentControlSet, בענף HKEY_LOCAL_MACHINE\SYSTEM
לנטרל את UAC לגמריEnableLUA=0, ואחריו הפעלה מחדש
לנהל שירותים בעכברservices.msc
לראות סוג הפעלה, נתיב, תלויות וחשבון של שירותsc qc
לקבוע ששירות יעלה בכל אתחולsc config עם start= auto
לקבוע ששירות יעלה רק אחרי שירות אחרsc config עם depend=
לנהל התקנים ולהחזיר דרייבר לגרסה קודמתdevmgmt.msc
לבדוק אילו קבצים ודרייברים חתומיםsigverif
להוסיף או למחוק חבילות ב-Driver Storepnputil
להציג את רשימת הדרייבריםdriverquery
לאפשר דרייברים בחתימת בדיקהtestsigning ב-bcdedit, כש-Secure Boot כבוי
  • ה-Registry הוא מסד הגדרות היררכי של מפתחות וערכים, שנטען מכוורות שנשמרות בדיסק.
  • מפתחות השורש: HKLM להגדרות של המחשב כולו (כתיבה אליו דורשת מנהל), HKCU למשתמש המחובר, HKU לכל הפרופילים הטעונים לפי SID, HKCR לשיוכי קבצים ו-HKCC לפרופיל החומרה הנוכחי.
  • סוגי ערכים: REG_SZ למחרוזת, REG_EXPAND_SZ למחרוזת עם משתני סביבה, REG_MULTI_SZ לרשימת מחרוזות, REG_DWORD למספר של 32 ביט ו-REG_BINARY לבתים.
  • ה-SAM שומר את החשבונות המקומיים ואת ה-NT hash שלהם, בלי salt. הקובץ נמצא בתיקייה config, נעול בזמן ש-Windows רצה, ורק SYSTEM קורא אותו.
  • כדי לפענח את הגיבובים שב-SAM צריך גם את הכוורת SYSTEM, שבה נמצא מפתח האתחול. חשבונות של דומיין נשמרים ב-NTDS.dit, לא ב-SAM.
  • lsass.exe מאמת כניסות ובונה אסימוני גישה, מול הגיבובים שה-SAM רק מחזיק. יש ממנו עותק אחד, מ-System32, תחת SYSTEM, וסגירה שלו מאתחלת את המחשב בכפייה.
  • את הזיכרון של lsass.exe מגינים בעזרת RunAsPPL, שהופך אותו לתהליך מוגן, ובעזרת Credential Guard, שמעביר סודות ל-LsaIso.exe.
  • UAC נותן למנהל אסימון מסונן ואסימון מלא, ושואל לפני שהמלא נמסר לתוכנה. ברירת המחדל מציגה את החלון על ה-secure desktop, למחוון יש ארבע עמדות, וכיבוי מלא הוא EnableLUA=0 ואתחול.
  • תוכנות ותיקות של 32 ביט שכותבות לאזורים מוגנים מופנות בשקט ל-VirtualStore שבפרופיל המשתמש.
  • שירות הוא תוכנית רקע שמנוהלת בידי ה-SCM ב-services.exe, רצה ב-Session 0, ומזדהה כ-LocalSystem, כ-LocalService, כ-NetworkService או כמשתמש מסוים.
  • סוגי ההפעלה הם Automatic, Automatic (Delayed Start), Manual ו-Disabled, ונשמרים בערך Start.
  • דרייבר הוא קובץ sys שמתווך בין Windows לחומרה. דרייבר ליבה עם באג מביא למסך כחול, ב-64 ביט הוא חייב חתימה דיגיטלית, ו-Roll Back Driver מחזיר את הגרסה הקודמת שלו.