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

Windows

Win api, Cmd, .net framework, Clr, Dll, Ntdll.dll

שורת הפקודה Cmd, Win API, קבצי DLL, ntdll.dll וסביבת .NET עם ה-CLR.

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

חומר לימוד

Win api, Cmd, .net framework, Clr, Dll, Ntdll.dll: איך תוכנית מדברת עם Windows

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

  • מצב משתמש ומצב ליבה: שתי רמות ההרשאה של המעבד. כל שאר הפרק נבנה עליהן, ולכן מתחילים בהן.
  • WinAPI: הפונקציות ש-Windows מציעה לתוכניות, הספריות שמחזיקות אותן, הסיומות A ו-W, HANDLE, טיפול בכישלון עם GetLastError, יצירת תהליך, סנכרון וקלט ופלט אסינכרוני.
  • ntdll.dll: השכבה התחתונה במצב משתמש, זו שמבצעת בפועל את המעבר לליבה.
  • DLL: ספריות שנטענות בזמן ריצה, טעינה מרומזת וטעינה מפורשת, מה קורה כשספרייה חסרה, בעיות גרסאות ובעיית האבטחה של סדר החיפוש.
  • .NET Framework ו-CLR: העולם המנוהל, IL ו-JIT, Garbage Collector, בדיקות בטיחות וחריגות.
  • P/Invoke: הגשר שדרכו קוד C# קורא לפונקציות WinAPI, והסיכונים שבו.
  • cmd: שורת הפקודה של Windows, פקודות פנימיות וחיצוניות, משתנים וקובצי batch.

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

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

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

שתי רמות ההרשאה של המעבד

נפתח בניסוי. התוכנית הבאה היא תהליך (Process) רגיל, כמו כל תוכנית שנמצאת בריצה, והיא מבקשת מהמעבד לבצע את cli, הוראה שמכבה פסיקות:

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

static LONG WINAPI report(EXCEPTION_POINTERS *e) {
    printf("CPU refused: exception 0x%08lX\n", e->ExceptionRecord->ExceptionCode);
    ExitProcess(1);
    return EXCEPTION_CONTINUE_SEARCH;
}

int main(void) {
    AddVectoredExceptionHandler(1, report);
    printf("user mode code asks the CPU to disable interrupts...\n");
    fflush(stdout);
    __asm__ volatile ("cli");      // a kernel-only instruction
    printf("never printed\n");
    return 0;
}
פלט
user mode code asks the CPU to disable interrupts...
CPU refused: exception 0xC0000096

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

רמהמי רץ בהמה מותר בה
מצב משתמש (User Mode)כל התוכניות הרגילות: עורך טקסט, משחק, דפדפן, שירות רקע או תוכנית C# שכתבתםרק הזיכרון של התהליך עצמו. אין גישה ישירה לחומרה, לדיסק או לזיכרון של תהליך אחר
מצב ליבה (Kernel Mode)הגרעין של Windows, הקובץ ntoskrnl.exe, וגם מנהלי ההתקן (Drivers)גישה מלאה לחומרה, לכל הזיכרון ולכל המשאבים

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

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

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

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

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

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

מפת השכבות: מהקוד שלכם ועד הליבה

את רוב הפרק אפשר לתלות על תרשים אחד. כל חץ בו פירושו 'קורא ל'.

Text
  managed code (C#)                      native code (C / C++)
  +----------------------------+         |
  | your C# code               |         |
  | .NET class library + CLR   |         |
  +-------------+--------------+         |
                | P/Invoke               |
                v                        v
  +----------------------------------------------------------------+
  | WinAPI DLLs:  kernel32 -> kernelbase | user32 | gdi32 | advapi32 |
  +----------------------------------------------------------------+
                |   (window and drawing requests leave through win32u.dll)
                v
  +----------------------------------------------------------------+
  | ntdll.dll:  Nt* / Zw* functions + system call stubs            |
  +----------------------------------------------------------------+
  ~~~~~~~~~~~~~~~~ syscall: the CPU changes privilege level ~~~~~~~~~~~~~~~~
  +----------------------------------------------------------------+
  | ntoskrnl.exe (the kernel) + drivers             kernel mode    |
  +----------------------------------------------------------------+

  everything above the ~~~ line is loaded into your process and runs in user mode

נעקוב אחרי שתי בקשות. משמאל, תוכנית C# שומרת קובץ. הקוד שלה רץ בפיקוח ה-CLR, סביבת הריצה של .NET, ולכן הוא נקרא קוד מנוהל (Managed Code); ספריית המחלקות מקבלת את הבקשה ומעבירה אותה דרך P/Invoke לפונקציה ב-kernel32.dll.

מימין, כלי שכתוב ב-C פותח קובץ. אין לו סביבת ריצה באמצע: הקומפיילר כבר הפך אותו לקוד מכונה של המעבד, ולכן קוראים לו קוד native (מקורי), והוא פונה ל-kernel32.dll ישירות.

מכאן שתי הבקשות זהות: יורדות ל-ntdll.dll, ומשם, בהוראת syscall, לליבה. רק בקשה של חלון או ציור הייתה יוצאת דרך win32u.dll.

שימו לב היכן עובר הקו. עד ntdll.dll כולל, הכול נטען לתוך התהליך של התוכנית ורץ במצב משתמש, גם ה-CLR וגם ספריות WinAPI. הליבה ומנהלי ההתקן הם היחידים מתחתיו.
בדקו את עצמכם
באיזו רמת הרשאה רץ הקוד של kernel32.dll כשתוכנית C# קוראת לו דרך P/Invoke?

במצב משתמש, בתוך התהליך של התוכנית. השם kernel32 מטעה: זו ספרייה רגילה שנטענת לתהליך, והליבה עצמה היא ntoskrnl.exe.

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

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

WinAPI: מה הוא ולשם מה הוא קיים

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

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

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

אם האפליקציה כתובה ב-C או ב-C++, היא קוראת לפונקציות האלה כמו לכל פונקציה אחרת, כי WinAPI מוגדר בחתימות של C. גרסת C# שלה הייתה מגיעה לאותן פונקציות דרך P/Invoke, וסקריפט Python דרך המודול ctypes.

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

.NET לא באה במקום WinAPI אלא מעליו: הספריות שלה פונות אליו בעצמן. כל גרסאות Windows הנוכחיות תומכות בו.

פונקציות שכדאי להכיר בשם:

פונקציהתפקיד
CreateFileפותחת קובץ קיים או יוצרת חדש (וגם התקנים), ומחזירה HANDLE
ReadFile / WriteFileקריאה וכתיבה דרך HANDLE שכבר פתוח
CreateProcessמפעילה תוכנית בתהליך חדש
CreateThreadמוסיפה thread לתהליך הנוכחי
MessageBoxמקפיצה חלון הודעה
RegOpenKeyEx / RegSetValueExפתיחת מפתח ב-Registry וכתיבת ערך בתוכו
VirtualAllocהקצאת זיכרון במרחב הכתובות של התהליך
LoadLibrary / GetProcAddressטעינת DLL ואיתור פונקציה בתוכה
CloseHandleשחרור HANDLE
GetLastErrorקוד השגיאה האחרון שנרשם ל-thread הנוכחי

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

טעויות נפוצות
  • WinAPI הוא שכבה שמתרגמת את מה שה-CLR מבקש לפקודות חומרה. WinAPI קיים ועובד גם בלי .NET בכלל, ותוכנית C קוראת לו בלי שום CLR. וגם הוא, כמו כל שכבה במצב משתמש, אינו נוגע בחומרה: את זה עושה הליבה.
  • WinAPI הוא בעצם ממשק ל-Registry. ה-Registry הוא תחום אחד מתוך רבים. באותו ממשק יש קבצים, תהליכים, threads, חלונות, זיכרון ורשת.
  • פונקציות WinAPI נכנסות לליבה בעצמן, ו-ntdll.dll אינה מעורבת. פונקציה שזקוקה לליבה, למשל לפתיחת קובץ או להקצאת זיכרון, מוסרת את הבקשה דרך ntdll.dll. פונקציות של חלונות וציור עוברות דרך win32u.dll.
  • WinAPI נועד לתוכניות עם ממשק גרפי בלבד. כלי קונסול שמעתיק קבצים קורא ל-CreateFile ול-WriteFile בדיוק כמו תוכנית עם חלונות.
  • WinAPI ממיר פקודות PowerShell לפעולות, או עוטף קוד Java. הוא אוסף של פונקציות C ש-Windows חושפת. PowerShell ו-Java הם צרכנים שלו, לא חלק ממנו.
חזרה לתוכן העניינים

איזו DLL מחזיקה איזו פונקציה

אין קובץ אחד שמכיל את כל WinAPI. הממשק מחולק לפי נושאים, וכל נושא גר ב-DLL משלו בתיקייה C:\Windows\System32.

DLLהתחום שלהדוגמאות
kernel32.dll (והמימוש ב-kernelbase.dll)משאבי הבסיס של המערכת: קבצים, זיכרון, תהליכים, threads וטעינת DLLCreateFile, ReadFile, CreateProcess, CreateThread, VirtualAlloc, LoadLibrary
user32.dllממשק המשתמש: חלונות, תיבות דו-שיח, הודעות, קלט ממקלדת ומעכברMessageBox, CreateWindowEx, DestroyWindow
gdi32.dllציור: קווים, צורות, טקסט וגופניםLineTo, TextOut
advapi32.dllRegistry, אבטחה ושירותיםRegOpenKeyEx, RegSetValueEx, OpenProcessToken

kernel32.dll היא כיום בעיקר שער: ברוב הפונקציות שלה הקוד עצמו נמצא ב-kernelbase.dll, ש-Windows פיצלה ממנה בגרסאות החדשות. השם הישן נשמר כדי שתוכניות ותיקות ימצאו את מה שהן מחפשות.

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

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

/* For each function name, list the system DLLs that export it. */
int main(void) {
    const char *dlls[] = { "kernel32.dll", "user32.dll", "gdi32.dll", "advapi32.dll" };
    const char *fns[]  = { "CreateThread", "VirtualAlloc", "MessageBoxA", "MessageBoxW",
                           "DestroyWindow", "LineTo", "CreateServiceW" };
    for (int f = 0; f < 7; f++) {
        printf("%-17s", fns[f]);
        for (int d = 0; d < 4; d++) {
            HMODULE lib = LoadLibraryA(dlls[d]);
            if (lib && GetProcAddress(lib, fns[f]))
                printf(" %s", dlls[d]);
        }
        printf("\n");
    }
    return 0;
}
פלט
CreateThread      kernel32.dll
VirtualAlloc      kernel32.dll
MessageBoxA       user32.dll
MessageBoxW       user32.dll
DestroyWindow     user32.dll
LineTo            gdi32.dll
CreateServiceW    advapi32.dll

שתי הגרסאות של חלון ההודעה, MessageBoxA ו-MessageBoxW, נמצאות שתיהן ב-user32.dll ובשום ספרייה אחרת מהארבע. LineTo נמצאת רק ב-gdi32.dll, ופונקציות ה-threads והזיכרון רק ב-kernel32.dll.

כדי לזכור: מה שהמשתמש רואה ולוחץ עליו ב-user32, ציור ב-gdi32, Registry והרשאות ב-advapi32, וכל הבסיס (קבצים, זיכרון, תהליכים) ב-kernel32.
תרחיש 1: כלי גיבוי קטן ושלוש ספריות

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

  • הרישום ב-Registry נעשה עם RegSetValueEx, ולכן הכלי זקוק ל-advapi32.dll.
  • קובץ הדוח נפתח עם CreateFile ונכתב עם WriteFile, שתיהן של kernel32.dll.
  • החלון הוא MessageBox, חלק מממשק המשתמש, ולכן הוא מגיע מ-user32.dll.

שלוש פעולות, שלוש ספריות: הכלי טוען את שלושתן לתהליך שלו.

טעויות נפוצות
  • MessageBox שייכת ל-kernel32.dll, כי זו הספרייה המרכזית. kernel32.dll מטפלת במשאבי מערכת כמו קבצים וזיכרון. חלונות ותיבות דו-שיח הם התחום של user32.dll.
  • MessageBox שייכת ל-gdi32.dll, כי בסוף משהו מצויר על המסך. gdi32.dll מספקת פעולות ציור כמו קו או טקסט. החלון כרכיב של ממשק המשתמש, עם הכפתורים וההודעות שלו, מנוהל ב-user32.dll.
  • את CreateFile מחפשים ב-user32.dll, או אולי ב-advapi32.dll. פתיחת קובץ היא שירות בסיסי של המערכת, ולכן מקומה ב-kernel32.dll.
בדקו את עצמכם
באילו ספריות תמצאו את VirtualAlloc, את CreateWindowEx ואת TextOut?

VirtualAlloc ב-kernel32.dll (זיכרון), CreateWindowEx ב-user32.dll (חלונות), TextOut ב-gdi32.dll (ציור טקסט).

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

ב-advapi32.dll, הספרייה של האבטחה וה-Registry. הפונקציה היא OpenProcessToken.

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

הסיומות A ו-W

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

סיומתמשמעותסוג המחרוזתדוגמאות
AANSIchar, בקידוד שנקבע לפי דף הקוד (Code Page) הפעיל: תו בבית אחד ברוב השפות, ועד שני בתים לתו בדפי הקוד של סינית, יפנית וקוריאניתMessageBoxA, CreateFileA
WWide, כלומר Unicodewchar_t, תווים 'רחבים' (שני בתים ב-Windows)MessageBoxW, CreateFileW

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

בקוד C ו-C++ כותבים לרוב את השם בלי סיומת. MessageBox ו-CreateFile הם מאקרו בקובצי הכותרת, והקומפיילר מחליף אותם בגרסת A או W לפי השאלה אם הוגדר הסמל UNICODE. המאקרו TEXT והטיפוס TCHAR עובדים באותו עיקרון.

התוכנית הבאה הודרה פעמיים, פעם בלי הגדרה ופעם עם -DUNICODE:

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

int main(void) {
#ifdef UNICODE
    printf("UNICODE defined: CreateFile -> CreateFileW\n");
#else
    printf("UNICODE not defined: CreateFile -> CreateFileA\n");
#endif
    printf("sizeof(TCHAR) = %u\n", (unsigned)sizeof(TCHAR));
    printf("bytes in \"Kiosk\" as char:    %u\n", (unsigned)sizeof("Kiosk"));
    printf("bytes in L\"Kiosk\" as wchar_t: %u\n", (unsigned)sizeof(L"Kiosk"));
    return 0;
}
Bash
gcc aw.c -o aw_ansi.exe && ./aw_ansi.exe
gcc -DUNICODE aw.c -o aw_wide.exe && ./aw_wide.exe
פלט
UNICODE not defined: CreateFile -> CreateFileA
sizeof(TCHAR) = 1
bytes in "Kiosk" as char:    6
bytes in L"Kiosk" as wchar_t: 12
UNICODE defined: CreateFile -> CreateFileW
sizeof(TCHAR) = 2
bytes in "Kiosk" as char:    6
bytes in L"Kiosk" as wchar_t: 12

הקידומת L לפני מחרוזת אומרת לקומפיילר לבנות מחרוזת רחבה. לכן אותה מילה בת חמש אותיות תופסת 6 בתים כמחרוזת רגילה (כולל תו הסיום) ו-12 בתים כמחרוזת רחבה.

C
MessageBoxA(NULL, "Backup finished", "Nightly", MB_OK);            // char strings
MessageBoxW(NULL, L"Backup finished", L"Nightly", MB_OK);          // wide strings
MessageBox(NULL, TEXT("Backup finished"), TEXT("Nightly"), MB_OK); // A or W, picked at compile time

שלוש השורות מציגות אותו חלון, וכל אחת מהן חוזרת רק אחרי שהמשתמש לחץ OK, כי הפונקציה מחזירה את הכפתור שנלחץ.

טעויות נפוצות
  • W מסמנת את הגרסה של Windows ל-64 סיביות. W היא קיצור של Wide. בכל ארכיטקטורה יש את שתי הגרסאות, וההבדל ביניהן הוא רק בקידוד הטקסט.
  • W היא Wait: MessageBoxW מחכה שהמשתמש יסגור את החלון, ו-MessageBoxA חוזרת מיד. שתיהן חוזרות רק אחרי שהחלון נסגר, כי שתיהן מחזירות את הכפתור שהמשתמש בחר.
  • גרסת W חדשה יותר, ובמערכות ישנות יש רק A. שתי הגרסאות קיימות זו לצד זו. מה שמבדיל ביניהן אינו גיל אלא סוג המחרוזת שהן מקבלות.
  • MessageBoxA יושבת ב-user32.dll, ואילו MessageBoxW נמצאת ב-kernel32.dll. התוכנית שבדקה את הייצוא הראתה ששתיהן נמצאות ב-user32.dll בלבד.
  • אחת משתי הגרסאות פותחת חלון עם שדה להקלדה. החלון זהה בשתיהן: טקסט, כותרת וכפתורים. רק אופן הייצוג של המחרוזות שונה.
בדקו את עצמכם
תוכנית שנבנתה בלי UNICODE קוראת ל-CreateFile. לאיזו פונקציה היא קוראת בפועל, ומה עלול לקרות עם שם קובץ שמשלב יפנית ועברית?

המאקרו נפתח ל-CreateFileA, שמקבלת את השם לפי דף הקוד של המערכת. דף קוד אחד אינו מכסה תווים מכל השפות, ולכן לשם כזה מתאימה CreateFileW, שמקבלת Unicode.

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

HANDLE: הכרטיס שמייצג אובייקט

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

התוכנית הבאה פותחת קובץ, כותבת אליו שורה, וסופרת לאורך הדרך כמה 'כרטיסים' כאלה התהליך מחזיק:

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

static DWORD count(void) {
    DWORD n = 0;
    GetProcessHandleCount(GetCurrentProcess(), &n);
    return n;
}

int main(void) {
    DWORD before = count();
    DWORD written = 0;

    HANDLE f = CreateFileW(L"shift_notes.txt", GENERIC_WRITE, 0, NULL,
                           CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    WriteFile(f, "door B closed\r\n", 15, &written, NULL);   // the handle names the file
    printf("wrote %lu bytes, open handles: %lu -> %lu\n", written, before, count());
    CloseHandle(f);
    printf("after CloseHandle:          %lu\n", count());

    for (int i = 0; i < 500; i++)           // a leak: opened, never closed
        CreateFileW(L"shift_notes.txt", GENERIC_READ, FILE_SHARE_READ, NULL,
                    OPEN_EXISTING, 0, NULL);
    printf("after 500 opens, no close:  %lu\n", count());
    printf("my PID: %lu (a system-wide number, not a handle)\n", GetCurrentProcessId());
    DeleteFileW(L"shift_notes.txt");
    return 0;
}
פלט
wrote 15 bytes, open handles: 67 -> 68
after CloseHandle:          67
after 500 opens, no close:  567
my PID: 27804 (a system-wide number, not a handle)

המונה עלה באחד ברגע שהקובץ נפתח. הליבה רשמה שורה חדשה בטבלה שהיא מנהלת עבור התהליך, טבלת ה-Handles (Handle Table), ומסרה לתוכנית את מספר השורה בתור HANDLE: ערך אטום (Opaque), שאינו הקובץ ואינו מוביל למבנה שבליבה.

WriteFile קיבלה את ה-HANDLE ולא את השם shift_notes.txt, וכך הליבה ידעה לאיזה אובייקט לכתוב. אחרי CloseHandle המונה חזר למקומו.

באותה שיטה מקבלים כרטיס לכל אובייקט ליבה (Kernel Object): thread או תהליך, Event או Mutex, מפתח Registry, התקן, ולא רק קובץ.

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

השורה האחרונה מראה מספר מסוג אחר לגמרי, ה-PID. הוא מזהה את התהליך בכל המערכת, ואילו HANDLE שייך לטבלה של תהליך אחד.

הכללים שכדאי לדעת בעל פה:

  • HANDLE תקף רק בתוך התהליך שקיבל אותו, כי הוא מספר שורה בטבלה של אותו תהליך. אותו מספר בתהליך אחר מצביע על משהו אחר, או על כלום.
  • כדי שתהליך נוסף יגיע לאותו אובייקט יש שלוש דרכים: תהליך בן יורש את ה-Handle מהאב, משכפלים אותו לתהליך היעד עם DuplicateHandle, או שהתהליך השני פותח בעצמו אובייקט בעל שם (למשל Mutex בשם קבוע) ומקבל HANDLE משלו.
  • משחררים עם CloseHandle. לכמה סוגים יש פונקציה ייעודית, למשל RegCloseKey למפתח Registry.
  • חלון מזוהה ב-HWND. גם זה Handle, אבל הוא שייך למערכת החלונות ולא לטבלת ה-Handles של התהליך.
  • HANDLE אינו GUID. מזהים גלובליים קבועים, כמו CLSID, מזהים רכיבי COM ונרשמים ב-Registry, ואילו HANDLE נוצר בזמן ריצה ונעלם עם התהליך.
טעויות נפוצות
  • HANDLE הוא הכתובת בזיכרון של המבנה שמתאר את הקובץ. המבנה נמצא בזיכרון של הליבה, והתוכנית אינה רואה אותו. היא מחזיקה רק מספר אטום שהליבה יודעת לתרגם.
  • HANDLE הוא מזהה COM גלובלי, כמו GUID. GUID קבוע לאורך זמן וזהה בכל מחשב. HANDLE נוצר כשפותחים אובייקט, ומשמעותו מוגבלת לתהליך אחד.
  • HANDLE הוא המספר שהמתזמן נותן לתהליך או ל-thread כשהם נוצרים. אלה ה-PID וה-Thread ID, מזהים ברמת המערכת. HANDLE לתהליך הוא שורה בטבלה של מי שפתח אותו, ונוסף על ה-PID.
  • ntdll.dll בונה במצב משתמש את טבלת ה-Handles של התהליך. הטבלה נמצאת בליבה ומנוהלת שם. ntdll.dll רק מעבירה את הבקשה, וה-HANDLE הוא הערך שהליבה החזירה.
בדקו את עצמכם
תהליך A פתח קובץ וקיבל HANDLE שערכו 0x1A4. הוא כותב את המספר לקובץ טקסט, ותהליך B קורא אותו ומעביר אותו ל-ReadFile. מה צפוי?

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

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

כשפונקציה נכשלת: ערך ההחזרה ו-GetLastError

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

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

static DWORD WINAPI worker(LPVOID arg) {
    (void)arg;
    GetFileAttributesW(L"C:\\no_such_folder\\a.txt");      // fails in the worker
    DWORD mine = GetLastError();                           // the worker's own slot
    printf("worker, its own failure:        %lu\n", mine);
    return 0;
}

int main(void) {
    HANDLE h = CreateFileW(L"no_such_invoice.csv", GENERIC_READ, FILE_SHARE_READ, NULL,
                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD saved = GetLastError();                          // read at once, kept in a variable
    printf("h as a number: %lld, saved code: %lu\n", (long long)(INT_PTR)h, saved);

    HANDLE t = CreateThread(NULL, 0, worker, NULL, 0, NULL);
    WaitForSingleObject(t, INFINITE);
    CloseHandle(t);
    printf("main, saved value is still:     %lu\n", saved);

    GetFileAttributesW(L"C:\\no_such_folder\\b.txt");      // a second failure in main
    printf("main, slot after a new failure: %lu\n", GetLastError());

    HMODULE m = LoadLibraryW(L"plugin_v9.dll");
    DWORD why = GetLastError();
    printf("LoadLibrary returned %s, code %lu\n", m ? "a module" : "NULL", why);
    return 0;
}
פלט
h as a number: -1, saved code: 2
worker, its own failure:        3
main, saved value is still:     2
main, slot after a new failure: 3
LoadLibrary returned NULL, code 126

הערך -1 הזה הוא INVALID_HANDLE_VALUE. ב-WinAPI אין חריגות כמו ב-C#: ערך ההחזרה רק מסמן שמשהו השתבש, ואת הסיבה (כאן 2, קובץ לא נמצא) מוסרת GetLastError.

סוג הפונקציהמה היא מחזירה כשהיא נכשלת
CreateFileINVALID_HANDLE_VALUE, שערכו המספרי הוא -1
רוב שאר פונקציות ה-Create, כמו CreateThread ו-CreateEvent, וגם LoadLibraryNULL
פונקציות שמחזירות BOOL, כמו ReadFileFALSE
פונקציות ה-Registry, כמו RegOpenKeyExאת קוד השגיאה עצמו, ישירות בערך ההחזרה

GetLastError קוראת תא ששמור ל-thread שקרא לה, ולכן ה-thread הנוסף, שנכשל בעצמו, קיבל 3 מהתא שלו ולא את ה-2 של ה-thread הראשי. thread אחר לעולם אינו רואה את הקוד שלכם.

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

זה התפקיד של saved בדוגמה. השורה שאחרי הכישלון השני מראה מה קורה לתא עצמו: 3 החליף את 2.

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

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

int main(void) {
    HKEY key;
    LSTATUS rc = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\NoSuchVendor\\Weather",
                               0, KEY_READ, &key);
    printf("RegOpenKeyExW returned %ld\n", rc);    // the reason itself, not TRUE/FALSE
    if (rc == ERROR_SUCCESS)
        RegCloseKey(key);                          // registry keys have their own close
    return 0;
}
פלט
RegOpenKeyExW returned 2
קודקבועמשמעות
2ERROR_FILE_NOT_FOUNDהקובץ (או מפתח ה-Registry) לא נמצא
3ERROR_PATH_NOT_FOUNDתיקייה בנתיב אינה קיימת
5ERROR_ACCESS_DENIEDאין הרשאת גישה
126ERROR_MOD_NOT_FOUNDהמודול (DLL) שביקשו לטעון לא נמצא
תרחיש 2: הודעת יומן שבלעה את הסיבה

בשירות שמעבד הזמנות, CreateFile נכשלת בפתיחת קובץ הזמנה. המפתח כתב קודם log("open failed"), ורק בשורה שאחריה GetLastError().

  • הפונקציה log פותחת בעצמה את קובץ היומן וכותבת אליו, כלומר מריצה עוד קריאות WinAPI.
  • כל אחת מהן רשאית לכתוב לתא של ה-thread, וכאן אחת מהן נכשלה כי היומן היה נעול לרגע.
  • היומן מדווח על 'גישה נדחתה' (5), בזמן שהבעיה האמיתית הייתה קובץ חסר (2).

התיקון: DWORD err = GetLastError(); כשורה הראשונה אחרי הכישלון, ורק אחר כך כתיבה ליומן, כולל הערך של err.

תרחיש 3: thread אחד בודק שגיאה של thread אחר

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

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

טעויות נפוצות
  • את הסיבה אפשר לחלץ מתוך INVALID_HANDLE_VALUE. הערך הזה זהה בכל כישלון, -1, כפי שהודפס בדוגמה. הוא רק אומר שהייתה בעיה.
  • מספיק לבדוק את GetLastError פעם אחת, לקראת סוף התוכנית. עד אז עברו בתא קריאות רבות אחרות, מוצלחות וכושלות, וכל אחת מהן יכלה להחליף את הקוד, כמו ה-2 שהפך ל-3 בדוגמה.
  • CloseHandle על הערך שהתקבל תחזיר את קוד השגיאה. אין שם HANDLE לסגור, ו-CloseHandle מדווחת רק אם היא עצמה הצליחה.
  • את קוד השגיאה של CreateFile רואים ב-%ERRORLEVEL% אחרי שהתוכנית מסתיימת. %ERRORLEVEL% הוא קוד היציאה שהתוכנית כולה החזירה. אם התוכנית לא העבירה את הקוד בעצמה, הוא לא יופיע שם.
בדקו את עצמכם
CreateThread החזירה NULL. מיד אחר כך המתכנת הדפיס הודעה לקונסול, ורק אז קרא ל-GetLastError. מה הבעיה ומה התיקון?

ההדפסה מריצה בעצמה קריאות WinAPI שעלולות לשנות את הקוד. צריך לשמור את GetLastError() במשתנה מיד כשמתגלה ה-NULL, באותו thread, ורק אחר כך להדפיס.

RegOpenKeyEx נכשלה. צריך לקרוא ל-GetLastError?

לא. פונקציות ה-Registry מחזירות את קוד השגיאה ישירות, למשל 2 כשהמפתח אינו קיים.

LoadLibrary מחזירה NULL, והקוד שנשלף הוא 126. מה קרה?

ERROR_MOD_NOT_FOUND: ה-DLL שביקשו לטעון לא נמצא, בדיוק כמו plugin_v9.dll בדוגמה.

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

CreateProcess: להריץ תוכנית חדשה

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

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

int main(void) {
    setvbuf(stdout, NULL, _IONBF, 0);                    // print at once, no buffering
    STARTUPINFOW start = { sizeof(start) };
    PROCESS_INFORMATION info;
    wchar_t line[] = L"cmd.exe /c echo child says hi& exit /b 7";  // writable buffer

    if (!CreateProcessW(NULL, line, NULL, NULL, FALSE, 0, NULL, NULL, &start, &info)) {
        printf("CreateProcess failed, code %lu\n", GetLastError());
        return 1;
    }
    printf("child started, parent waits...\n");
    WaitForSingleObject(info.hProcess, INFINITE);          // block until the child ends

    DWORD code = 0;
    GetExitCodeProcess(info.hProcess, &code);
    printf("child exit code: %lu\n", code);
    CloseHandle(info.hThread);                             // both handles must be closed
    CloseHandle(info.hProcess);

    wchar_t bad[] = L"no_such_tool.exe";
    if (!CreateProcessW(NULL, bad, NULL, NULL, FALSE, 0, NULL, NULL, &start, &info))
        printf("second CreateProcess failed, code %lu\n", GetLastError());
    return 0;
}
פלט
child started, parent waits...
child says hi
child exit code: 7
second CreateProcess failed, code 2

CreateProcessW הקימה תהליך חדש, טענה לתוכו את cmd.exe והפעילה בו thread ראשון. האב חיכה ב-WaitForSingleObject וקרא את קוד היציאה 7; בניסיון השני, עם קובץ שאינו קיים, הוא קיבל FALSE וקוד 2.

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

  • NULL, line: מה להריץ ועם אילו פרמטרים. כאן שם התוכנית פותח את שורת הפקודה. המערך line ניתן לכתיבה, כי CreateProcessW רשאית לשנות את תוכנו זמנית.
  • NULL, NULL: מאפייני האבטחה של התהליך החדש ושל ה-thread הראשון שלו.
  • FALSE: האם הבן יורש מהאב Handles שסומנו כניתנים להורשה.
  • 0: דגלי יצירה, למשל CREATE_SUSPENDED כדי שהתהליך יתחיל מושהה.
  • NULL, NULL: משתני הסביבה ותיקיית העבודה של הבן (NULL פירושו לרשת מהאב).
  • &start: מבנה STARTUPINFO, עם מאפייני החלון ושמות ה-Desktop וה-Window Station שבהם התהליך יופיע.
  • &info: מבנה PROCESS_INFORMATION שהפונקציה ממלאת: HANDLE לתהליך ו-HANDLE ל-thread הראשון, ואיתם ה-PID וה-Thread ID. את שני ה-Handles הדוגמה סוגרת בסוף.
פונקציהמה נוצרזיכרון
CreateProcessתהליך חדש עם thread ראשוןמרחב כתובות חדש ונפרד
CreateThreadthread נוסף בתהליך הקייםאותו מרחב כתובות, משותף לכל ה-threads

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

ומי שמציע את Start-Process של PowerShell כדרך שאינה תלויה ב-.NET טועה, כי PowerShell כולה רצה על .NET.

טעויות נפוצות
  • ב-Windows יוצרים תהליך בן עם fork. fork שייכת ל-POSIX. WinAPI אינה מכירה אותה, והדרך שלה היא CreateProcess.
  • CreateThread היא דרך קלה יותר ליצור תהליך. CreateThread אינה יוצרת תהליך בכלל. היא מוסיפה עוד רצף ביצוע שחולק את הזיכרון של התהליך הקיים.
  • ה-Handles שב-PROCESS_INFORMATION נסגרים מעצמם כשהבן מסתיים. הם נשארים פתוחים בטבלה של האב עד CloseHandle. אב שמפעיל הרבה בנים ואינו סוגר אותם דולף Handles.
חזרה לתוכן העניינים

סנכרון: Mutex, Event, Semaphore ו-Critical Section

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

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

static volatile long tickets = 0;

static DWORD WINAPI sell(LPVOID arg) {
    (void)arg;
    for (int i = 0; i < 1000000; i++)
        tickets = tickets + 1;     // no lock: two threads can interleave the steps
    return 0;
}

int main(void) {
    HANDLE clerks[2];
    clerks[0] = CreateThread(NULL, 0, sell, NULL, 0, NULL);   // two sellers
    clerks[1] = CreateThread(NULL, 0, sell, NULL, 0, NULL);
    WaitForMultipleObjects(2, clerks, TRUE, INFINITE);
    printf("tickets sold: %ld (expected 2000000)\n", tickets);
    CloseHandle(clerks[0]);
    CloseHandle(clerks[1]);
    return 0;
}
פלט
tickets sold: 1387438 (expected 2000000)

כל אחד מהם מכר מיליון, והמונה מראה פחות בהרבה. למעבד, tickets = tickets + 1 הוא שלושה צעדים (לקרוא, להוסיף, לכתוב), והמתזמן רשאי להחליף thread באמצע: שניהם קוראים אותו ערך ישן, ושניהם כותבים אותו ועוד אחד.

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

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

WinAPI פותרת זאת באובייקטי סנכרון:

אובייקטפונקציותמה הוא נותן
MutexCreateMutex, WaitForSingleObject, ReleaseMutexמנעול בלעדי: בכל רגע רק thread אחד מחזיק בו, ומי שמבקש אחריו ממתין
EventCreateEvent, SetEvent, WaitForSingleObjectאות: thread אחד מודיע שמשהו קרה, וה-threads שחיכו לאות ממשיכים
SemaphoreCreateSemaphore, ReleaseSemaphoreמונה: עד N threads מחזיקים בו במקביל, והבא בתור ממתין
Critical SectionEnterCriticalSection, LeaveCriticalSectionמנעול מהיר שפועל רק בין threads של אותו תהליך

שלושת הראשונים הם אובייקטי ליבה, ולכן מקבלים עליהם HANDLE. Critical Section הוא מבנה רגיל בזיכרון של התהליך, בלי HANDLE, ולכן אינו משמש בין תהליכים.

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

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

static HANDLE lock;
static long tickets = 0;

static DWORD WINAPI sell(LPVOID arg) {
    (void)arg;
    for (int i = 0; i < 1000000; i++) {
        WaitForSingleObject(lock, INFINITE);   // only one thread past this line
        tickets = tickets + 1;                 // read, add, write: three steps
        ReleaseMutex(lock);
    }
    return 0;
}

int main(void) {
    lock = CreateMutexW(NULL, FALSE, L"Local\\BoxOfficeLock");
    HANDLE again = CreateMutexW(NULL, FALSE, L"Local\\BoxOfficeLock");  // same name
    printf("second open by name: GetLastError = %lu (ERROR_ALREADY_EXISTS)\n", GetLastError());

    HANDLE clerks[2];
    clerks[0] = CreateThread(NULL, 0, sell, NULL, 0, NULL);   // two sellers
    clerks[1] = CreateThread(NULL, 0, sell, NULL, 0, NULL);
    WaitForMultipleObjects(2, clerks, TRUE, INFINITE);
    printf("tickets sold: %ld\n", tickets);

    CloseHandle(clerks[0]);
    CloseHandle(clerks[1]);
    CloseHandle(again);
    CloseHandle(lock);
    return 0;
}
פלט
second open by name: GetLastError = 183 (ERROR_ALREADY_EXISTS)
tickets sold: 2000000

הפתיחה השנייה באותו שם לא יצרה Mutex חדש. הקריאה הצליחה, ובכל זאת השאירה ב-GetLastError את 183 (ERROR_ALREADY_EXISTS) כדי לדווח על כך. והפעם הספירה מדויקת: שני מיליון.

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

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

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

  1. כל מופע קורא ל-CreateMutexW עם השם הזה ומקבל HANDLE לאותו אובייקט.
  2. לפני כתיבת קבלה הוא ממתין ב-WaitForSingleObject עד שה-Mutex עובר לחזקתו.
  3. אחרי הכתיבה הוא קורא ל-ReleaseMutex, והמופע השני, אם חיכה, נכנס.

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

טעויות נפוצות
  • משתנה bool busy משותף עושה את העבודה של Mutex. קריאת הדגל וכתיבתו הן צעדים נפרדים, ושני threads יכולים לעבור את הבדיקה יחד. Mutex מבטיח שהתפיסה היא פעולה אחת, ומספק גם המתנה.
  • Event ו-Mutex משמשים להעברת נתונים בין תהליכים. הם רק מתאמים את התזמון של הגישה. את הנתונים עצמם מעבירים בזיכרון משותף או ב-Pipe.
  • אובייקט סנכרון קובע באיזה סדר המעבד יריץ את ה-threads. המתזמן ממשיך להחליט מי רץ. האובייקט רק גורם ל-thread שאינו יכול להמשיך לחכות.
חזרה לתוכן העניינים

קריאה חוסמת וקריאה לא חוסמת

התוכנית הבאה מקימה צינור בעל שם (Named Pipe), מתחברת אליו כלקוח, ומבקשת לקרוא ממנו לפני שמישהו כתב בו משהו:

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

int main(void) {
    const wchar_t *name = L"\\\\.\\pipe\\sensor_feed";
    HANDLE server = CreateNamedPipeW(name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
                                     PIPE_TYPE_BYTE, 1, 0, 64, 0, NULL);
    HANDLE client = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

    char buf[64] = {0};
    DWORD got = 0, sent = 0;
    OVERLAPPED op = {0};
    op.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);

    BOOL ok = ReadFile(server, buf, sizeof(buf) - 1, NULL, &op);   // nothing written yet
    DWORD err = GetLastError();
    printf("ReadFile returned %d, GetLastError = %lu\n", ok, err);

    if (!ok && err == ERROR_IO_PENDING) {
        printf("read still in progress, the thread keeps working\n");
        WriteFile(client, "temp=21.5", 9, &sent, NULL);          // data arrives later
        GetOverlappedResult(server, &op, &got, TRUE);             // now wait for it
        printf("finished: %lu bytes: %s\n", got, buf);
    }
    CloseHandle(op.hEvent);
    CloseHandle(client);
    CloseHandle(server);
    return 0;
}
פלט
ReadFile returned 0, GetLastError = 997
read still in progress, the thread keeps working
finished: 9 bytes: temp=21.5

בקריאה רגילה, חוסמת (Blocking), ה-thread היה נתקע בשורה של ReadFile עד שיגיעו נתונים, ובתוכנית הזו לנצח, כי הכתיבה באה רק אחר כך. כאן ה-Handle נפתח עם FILE_FLAG_OVERLAPPED ו-ReadFile קיבלה מבנה OVERLAPPED, ולכן זו קריאה לא חוסמת (Non-Blocking), שבקבצים ובצינורות נקראת Overlapped I/O, קלט ופלט אסינכרוני.

בשורה הראשונה של הפלט ערך ההחזרה הוא 0 (FALSE) והקוד הוא 997, ERROR_IO_PENDING. אין כאן כישלון: זו הודעה שהבקשה נקלטה ועדיין בעבודה, וה-thread חופשי להמשיך, כמו שהשורה השנייה מראה.

אחרי שהלקוח כתב, GetOverlappedResult עם TRUE בפרמטר האחרון חיכתה להשלמה ומסרה את תשעת הבתים. בדרך לא נוצר אף thread נוסף: Windows ביצעה את הקריאה בעצמה, וכשסיימה סימנה את ה-Event שבמבנה OVERLAPPED.

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

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

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

למה בכל זאת לכתוב ב-C או C++ מול WinAPI

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

הצוות הראשון יבחר כנראה C או C++ מול WinAPI, אוסף הפונקציות ברמה נמוכה שמערכת ההפעלה חושפת, בלי שכבת ריצה באמצע. השני יבחר C# על .NET, מסגרת עבודה ברמה גבוהה שרצה על ה-CLR.

היבטC או C++ מול WinAPI (native)C# על .NET (מנוהל)
שליטהכל דגל וכל פרמטר של הפניות לשירותי המערכת בידיים שלכם, עד פרטים נמוכים של Windowsספריית המחלקות מחליטה על רוב הפרטים ומסתירה אותם
זיכרון ומשאביםהמפתח משחרר בעצמו: free, delete, CloseHandleה-Garbage Collector מפנה זיכרון מנוהל
ביצועיםאין שכבת ריצה באמצע, ולכן זו הבחירה לכלי מערכת ולקוד שכל אחוז בו חשובJIT ו-GC מוסיפים עבודה, וברוב היישומים זה זניח
קצב פיתוחיותר קוד ידני ויותר הזדמנויות לטעותספריית מחלקות עשירה חוסכת הרבה קוד
הגעה ל-WinAPIישירהדרך P/Invoke, בתוך אותו תהליך

שני דברים זהים אצל שני הצוותים. ראשית, שניהם רצים במצב משתמש: הסוכן שכתוב ב-C אינו 'קרוב יותר לליבה', ושניהם עוברים לליבה רק כשהם מבצעים קריאת מערכת. שנית, גם הצוות השני יכול להגיע לכל פונקציית WinAPI, דרך P/Invoke.

P/Invoke, שכבת ה-Interop של .NET, אינו מפעיל תהליך עזר. הוא מתרגם את הפרמטרים לצורה ש-C מצפה לה וקורא לפונקציה ב-DLL, באותו תהליך, ולכן מה שמכריע אצל הצוות הראשון הוא שליטה וביצועים ולא 'גישה'.

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

טעויות נפוצות
  • native עדיף, כי ספריית המחלקות הגדולה שלו מקצרת את הפיתוח. ספריית מחלקות עשירה היא דווקא היתרון של .NET. ב-native כותבים יותר בעצמכם.
  • חייבים native, כי מ-.NET אי אפשר לקרוא ל-WinAPI. P/Invoke מאפשר לקוד C# לקרוא לפונקציות WinAPI, ו-.NET עצמה עושה זאת כל הזמן.
  • קריאה ישירה ל-WinAPI חוסכת את המעבר בין מצב ליבה למצב משתמש. שתי הגישות רצות במצב משתמש, ושתיהן משלמות על המעבר רק כשהן מבצעות קריאת מערכת.
  • ב-WinAPI אפשר להעביר לפונקציה כל טיפוס שרוצים. כל פונקציה מוגדרת בחתימת C קבועה. טיפוס שגוי הוא באג, לא גמישות.
  • את WinAPI מתכנתים בדרך כלל באסמבלי של 16 סיביות. השפות המקובלות הן C ו-C++, שבהן כתובים קובצי הכותרת של הממשק.
בדקו את עצמכם
מפתח טוען שהכלי שלו מהיר יותר כי הוא קורא ל-WinAPI ישירות, ולכן רץ במצב ליבה. מה נכון בטענה ומה לא?

ייתכן שהכלי באמת מהיר יותר, כי אין באמצע JIT ו-GC. אבל הוא רץ במצב משתמש בדיוק כמו תוכנית .NET, ועובר לליבה רק בקריאות מערכת.

בכלי של הצוות השני צריך פונקציה של Windows שאין לה מחלקה ב-.NET. האם צריך לכתוב אותו מחדש ב-C?

לא. מצהירים על הפונקציה דרך P/Invoke וקוראים לה מ-C#, באותו תהליך. המחיר הוא שהפרמטרים צריכים להתאים בדיוק לחתימת ה-C שלה.

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

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

מה יש ב-ntdll.dll ובאיזה מצב היא רצה

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

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

int main(void) {
    HMODULE mods[256];
    DWORD bytes = 0;
    wchar_t path[MAX_PATH];

    // every module already mapped into this process, before we load anything
    K32EnumProcessModules(GetCurrentProcess(), mods, sizeof(mods), &bytes);
    for (DWORD i = 0; i < bytes / sizeof(HMODULE); i++) {
        GetModuleFileNameW(mods[i], path, MAX_PATH);
        if (i == 0) wcscpy(path, L"mods.exe");           // the program itself
        wprintf(L"%ls\n", path);
    }

    HMODULE nt = GetModuleHandleW(L"ntdll.dll");
    printf("\nntdll exports NtCreateFile: %s\n", GetProcAddress(nt, "NtCreateFile") ? "yes" : "no");
    printf("ntdll exports ZwCreateFile: %s\n", GetProcAddress(nt, "ZwCreateFile") ? "yes" : "no");
    printf("ntdll exports CreateFileW:  %s\n", GetProcAddress(nt, "CreateFileW") ? "yes" : "no");
    return 0;
}
פלט
mods.exe
C:\Windows\SYSTEM32\ntdll.dll
C:\Windows\System32\KERNEL32.DLL
C:\Windows\System32\KERNELBASE.dll
C:\Windows\System32\ucrtbase.dll

ntdll exports NtCreateFile: yes
ntdll exports ZwCreateFile: yes
ntdll exports CreateFileW:  no

ntdll.dll היא השורה הראשונה אחרי התוכנית עצמה, עוד לפני kernel32.dll: היא ממופה לתהליך לפני כל ספרייה אחרת, והיא ה-DLL הנמוכה ביותר במצב משתמש. במחשב אחר, או עם ספריית זמן ריצה אחרת של C, ייתכן שיופיעו מודולים נוספים (למשל apphelp.dll) או msvcrt.dll במקום ucrtbase.dll, אבל ntdll.dll תמיד ראשונה.

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

ומה עם תוכנית מנוהלת? הנה תוכנית C# שעושה את אותה בדיקה:

C#
using System;
using System.Diagnostics;
using System.IO;

// Which native Windows DLLs does a managed process carry?
string[] wanted = { "ntdll.dll", "kernel32.dll", "kernelbase.dll" };
foreach (string name in wanted)
{
    bool loaded = false;
    foreach (ProcessModule m in Process.GetCurrentProcess().Modules)
        if (string.Equals(m.ModuleName, name, StringComparison.OrdinalIgnoreCase))
            loaded = true;
    Console.WriteLine($"{name,-15} {(loaded ? "loaded" : "not loaded")}");
}
File.WriteAllText("route.txt", "managed write");   // ends in NtCreateFile / NtWriteFile
Console.WriteLine(File.ReadAllText("route.txt"));
פלט
ntdll.dll       loaded
kernel32.dll    loaded
kernelbase.dll  loaded
managed write

גם היא מוצאת את ntdll.dll, את kernel32.dll ואת kernelbase.dll. תהליך .NET הוא תהליך Windows לכל דבר, וה-CLR שבתוכו נשען על אותן ספריות; הכתיבה והקריאה של הקובץ בשורות האחרונות עוברות בשכבות שבחלק הבא.

מה שנובע מהפלט: ntdll.dll מופיעה ברשימת המודולים של התהליך, ולכן היא ממופה לתוך מרחב הכתובות שלו והקוד שלה רץ על ה-threads של התוכנית, במצב משתמש. היא אינה חלק מקובץ הליבה ntoskrnl.exe, אינה מנהל התקן, ואינה תהליך שירות שאליו שולחים בקשות.

במערכת של 64 סיביות, תוכנית שהודרה ל-32 סיביות מקבלת אותה פעמיים: גרסת 64 הסיביות מ-System32, וגרסת 32 הסיביות מ-SysWOW64.

ושלושת השמות: NtCreateFile ו-ZwCreateFile נמצאים, CreateFileW לא. הם מייצגים את מה שיש בפנים:

  • ה-Native API: פונקציות ששמן מתחיל ב-Nt או ב-Zw, כמו NtCreateFile, NtReadFile ו-NtAllocateVirtualMemory.
  • קטעי מעבר (System Call Stubs): כמה הוראות שמכינות את מספר קריאת המערכת ומבצעות את הוראת המעבר, syscall במעבדי x64 ו-sysenter ב-x86.
  • קוד שכל תהליך צריך: טוען התהליכים וה-DLL (פונקציות Ldr), ניהול הערימה (Heap) ופונקציות עזר (Rtl).

למה אף תוכנית רגילה אינה קוראת ל-NtCreateFile בעצמה? כי Microsoft כמעט אינה מתעדת את ה-Native API, ומספרי קריאות המערכת שבקטעי המעבר משתנים מגרסה לגרסה של Windows. WinAPI הוא החוזה היציב, והוא שפונה ל-ntdll.dll בשם התוכנית.

שתי השכבות עובדות יחד: WinAPI למעלה, כממשק שהקוד שלכם רואה, ו-ntdll.dll מתחתיו. אחת אינה מייתרת את השנייה.
טעויות נפוצות
  • ntdll.dll קיימת רק בתהליכי מערכת ובשירותים. כל תהליך במצב משתמש טוען אותה, כולל התוכנית הקטנה שבדוגמה.
  • בתהליך .NET אין ntdll.dll, כי ה-CLR מטפל בהכול. תהליך .NET הוא תהליך Windows רגיל. תוכנית ה-C# בדוגמה מצאה את ntdll.dll בין המודולים שלה.
  • רק תהליך שהורץ כמנהל מקבל את ntdll.dll. ההרשאות אינן משנות כאן דבר: גם תהליך של משתמש רגיל טוען אותה.
  • ntdll.dll רצה בליבה, כחלק מ-ntoskrnl.exe או כמנהל התקן. זו DLL של מצב משתמש שממופה לכל תהליך. הליבה נמצאת מעבר לקריאת המערכת שהיא מבצעת.
  • ntdll.dll אחראית לטעון מנהלי התקן בזמן האתחול, או לנהל את תעבורת הרשת. היא מעבירה בקשות לליבה ומספקת לתהליך קוד טעינה, ערימה ופונקציות עזר. מנהלי התקן ורשת הם עניין של הליבה.
חזרה לתוכן העניינים

הדרך של CreateFile עד הליבה וחזרה

נלווה תוכנית C שפותחת קובץ בשם invoices.db, ונראה מי מטפל בבקשה בכל שלב.

Text
step 1  app.exe          calls CreateFileW(L"invoices.db", ...)
step 2  kernel32.dll     CreateFileW is a thin entry point; the real code lives in kernelbase.dll
step 3  kernelbase.dll   validates and converts the arguments, then calls NtCreateFile
step 4  ntdll.dll        NtCreateFile: loads the service number into a register, executes syscall
        ================ the CPU enters kernel mode ================
step 5  ntoskrnl.exe     checks the caller's access rights, opens the file,
                         writes a new row into the handle table of app.exe
        ================ the CPU returns to user mode ================
step 6  app.exe          receives the HANDLE, or INVALID_HANDLE_VALUE if step 5 refused

שלבים 2 ו-3 הם עבודת הכנה: kernel32.dll מעבירה הלאה, ו-kernelbase.dll בודקת את הארגומנטים וממירה אותם. אף אחת מהן לא נכנסת לליבה; הן מוסרות את הבקשה ל-NtCreateFile, פונקציית ה-Native API שבשלב 4.

בשלב 4 ntdll.dll שמה מספר שירות באוגר ומבצעת syscall, וזה כל תפקידה. אין בשלב הזה בדיקת הרשאות ואין טבלה, ולכן התשובה לשאלות 'מי החליט שמותר' ו'מי רשם את ה-Handle' היא תמיד שלב 5, הליבה.

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

בקשות של חלונות וציור יורדות בערוץ אחר: user32.dll ו-gdi32.dll מעבירות אותן ל-win32u.dll, ומשם קריאת המערכת מגיעה ל-win32k, החלק הגרפי של הליבה. ויש פונקציות WinAPI, כמו טיפול במחרוזות, שלא מגיעות לשלב 4 בכלל, כי אין להן מה לבקש מהליבה.

קוד .NET עובר באותה דרך, כי ספריית המחלקות קוראת בעצמה ל-WinAPI:

Text
C# code          File.AppendAllText("audit.log", line)
.NET library     P/Invoke into CreateFileW, then WriteFile
kernelbase.dll   NtCreateFile, then NtWriteFile (both exported by ntdll.dll)
ntdll.dll        syscall
ntoskrnl.exe     carries out the request in kernel mode

בתרשים הזה ה-CLR מופיע רק בשורה העליונה, כצרכן. אין לו דרך עוקפת משלו: הוא אינו מבצע syscall בעצמו, אינו פונה ל-ntoskrnl.exe ישירות ואינו מדלג על ntdll.dll.

תרחיש 5: ה-JIT מבקש זיכרון לקוד חדש

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

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

  1. שלב 1: ה-CLR, כמו כל תוכנית, קורא לפונקציית WinAPI, כאן VirtualAlloc.
  2. שלבים 2 ו-3: VirtualAlloc מכינה את הבקשה ומעבירה אותה ל-NtAllocateVirtualMemory.
  3. שלב 4: ntdll.dll מבצעת syscall.
  4. שלב 5: הליבה מקצה דפים במרחב הכתובות של התהליך ומחזירה את הכתובת שלהם.

כל השאר אינו של ntdll.dll: את התרגום מ-IL עשה ה-JIT, את קוד המכונה יריץ המעבד ישירות, וה-Garbage Collector הוא חלק מה-CLR.

תרחיש 6: חלון הודעה עוקף את ntdll.dll

נחליף את CreateFileW ב-MessageBoxW ונעבור שוב על התרשים. כבר בשלב 2 הכתובת שונה: user32.dll במקום kernel32.dll.

כשצריך את הליבה, למשל כדי ליצור את החלון, הבקשה יורדת דרך win32u.dll אל win32k, ולא דרך NtCreateFile ודומותיה. את החלון מציירים user32.dll, gdi32.dll ו-win32k, ו-ntdll.dll אינה מציירת אפילו פיקסל.

טעויות נפוצות
  • kernel32.dll היא שמבצעת את הוראת המעבר לליבה. kernel32.dll, דרך kernelbase.dll, מעבירה את הבקשה ל-ntdll.dll, ושם נמצאת ההוראה syscall.
  • בפתיחת קובץ kernel32.dll פונה ל-user32.dll, והיא שנכנסת לליבה. user32.dll שייכת לעולם החלונות, והיא אינה חלק מהדרך של קבצים.
  • lsass.exe פותח את הקובץ ומחזיר לתוכנית Handle. את הקובץ פותחת הליבה. lsass.exe הוא תהליך שמאמת כניסות ואוכף מדיניות, ואינו מתערב בכל פתיחת קובץ.
  • ntdll.dll בודקת אם למשתמש מותר לגשת, ומחליטה. ntdll.dll רצה במצב משתמש, בתוך התהליך שמבקש, ולכן אינה יכולה לשמש שומר. בדיקת הגישה נעשית בליבה, אחרי המעבר.
  • ה-CLR מתרגם את הפעולה ל-IL ואז נכנס לליבה בכוחות עצמו. IL נוצר כבר בבניית התוכנית, לא בזמן הקריאה. וכשהקוד צריך את הליבה, הבקשה עוברת דרך WinAPI ו-ntdll.dll.
בדקו את עצמכם
תוכנית C# כותבת לקובץ יומן. סדרו מלמעלה למטה: ntdll.dll, ntoskrnl.exe, ספריית המחלקות של .NET, kernelbase.dll. איפה עובר הגבול בין מצב משתמש למצב ליבה?

ספריית .NET, kernelbase.dll, ntdll.dll, ובסוף ntoskrnl.exe. הגבול עובר בין ntdll.dll ל-ntoskrnl.exe, ברגע ההוראה syscall.

בפתיחת קובץ, מי מחליט אם הגישה מותרת, ומי מוסיף שורה לטבלת ה-Handles?

שני הדברים נעשים בליבה, ב-ntoskrnl.exe. ntdll.dll רק מוסרת את הבקשה.

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

למה כולם תלויים בה: hooks וקריאות מערכת ישירות

חזרו לרשימת המודולים מתחילת החלק: הנתיב של ntdll.dll היה C:\Windows\SYSTEM32\ntdll.dll. זה אותו קובץ שכל תהליך אחר במחשב ממפה, ולא עותק פרטי של התוכנית (תהליכי 32 סיביות על מערכת של 64 סיביות ממפים בנוסף את העותק שב-SysWOW64).

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

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

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

מימה הוא עושהלמה זה עובד
תוכנות אבטחהמתקינות hooks במצב משתמש בתוך ntdll.dll: משנות את תחילת הפונקציות כך שכל קריאה תעבור קודם דרכן, לפני שהיא מגיעה לליבהכמעט כל בקשה לליבה עוברת שם, ולכן משם רואים כמעט הכול
תוכנות זדוניותמנסות לפעמים לבצע את הוראת syscall בקוד משלהן, בלי לעבור בפונקציות של ntdll.dllה-hook יושב בקוד של ntdll.dll, ומי שלא עובר בקוד הזה אינו נתקל בו
ההבדל בין WinAPI ל-ntdll.dll הוא הגובה בשכבות, לא שפת התכנות ולא סוג התוכנית. WinAPI הוא הממשק המתועד שהקוד שלכם פונה אליו, ומתחתיו יושבת ntdll.dll, שמבצעת את קריאת המערכת.
טעויות נפוצות
  • אם תוכנית אחת מחליפה את ntdll.dll, רק היא תיפגע. הקובץ משותף לכל התהליכים. כל תהליך שייטען אחרי ההחלפה יקבל את הגרסה הפגומה.
  • ntdll.dll משמשת מעט תהליכים, ולכן תקלה בה מוגבלת. היא ממופה כמעט לכל תהליך. בדוגמאות ראיתם אותה גם בתוכנית C קטנה וגם בתוכנית C#.
  • WinAPI ו-ntdll.dll נבדלים בשפה שבה נכתבו, או בכך שאחד לתוכניות גרפיות והשני לקונסול. שניהם משרתים כל סוג של תוכנית. ההבדל הוא המיקום בערימת השכבות: הממשק שמפתחים רואים, מול השכבה שנכנסת לליבה.
  • קריאת מערכת מאפשרת לתהליך לגעת בחומרה בעצמו. קריאת מערכת היא בקשה. הליבה מבצעת את הפעולה בשם התהליך, אחרי שבדקה אותה.
  • קריאות מערכת נועדו בעיקר לגרפיקה, כמו GDI ו-DirectX. קבצים, זיכרון, תהליכים, threads ורשת: כל שירות של הליבה מתבקש בקריאת מערכת, והגרפיקה היא רק חלק קטן מהם.
  • Windows Defender חוסם כברירת מחדל קריאות ל-ntdll.dll, כי הן חשודות. כל תוכנית לגיטימית משתמשת בה כל הזמן, כפי שראיתם ברשימת המודולים. חסימה כזו הייתה משביתה את המערכת, ולכן אין כזו בהגדרות ברירת המחדל.
  • כל קריאת מערכת נרשמת ביומן האירועים לצורכי ביקורת. קריאות מערכת הן ערוץ העבודה הרגיל בין התהליכים לליבה, והדרך שבה הליבה שומרת על המשאבים. הן אינן נרשמות אחת אחת ביומן.
בדקו את עצמכם
כלי אבטחה מזהה פעילות חשודה לפי hooks שהתקין בתחילת הפונקציות של ntdll.dll. תוכנה מסוימת מבצעת את קריאות המערכת שלה בלי לקרוא לפונקציות האלה. מה הכלי יראה בשכבה הזו?

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

למה החלפת ntdll.dll בגרסה פגומה אינה נחשבת DLL Hell?

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

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

DLL: ספרייה שנטענת בזמן ריצה

מה היא DLL ולמה המערכת בנויה מאלפי קבצים כאלה

קובץ DLL (Dynamic-Link Library) הוא קובץ ספרייה בסיומת .dll. בתוכו יושבים קוד ופונקציות, ולעתים גם משאבים כמו אייקונים, מחרוזות או תמונות. ההבדל המרכזי מספרייה סטטית הוא עיתוי החיבור: הקוד של DLL מתחבר לתוכנית בזמן ריצה, ולא מועתק לתוך קובץ ה-exe בזמן ההידור.

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

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

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

למה Windows מפרקת את עצמה לאלפי קבצי DLL, במקום קובץ ענק אחד:

יתרוןמה הוא נותן
שיתוף בזיכרוןכמה תהליכים שטוענים את אותה DLL חולקים עותק אחד של הקוד בזיכרון הפיזי, ולכן אין שכפול.
חיסכון במקוםאין צורך לשכתב את אותו קוד לתוך כל תוכנה; הוא נשמר פעם אחת בדיסק.
מודולריותכל תחום פונקציונלי יושב בקובץ נפרד לפי נושא, במקום להתאחד לגוש אחד.
עדכון נקודתיאפשר להחליף DLL אחת, למשל בתיקון אבטחה, בלי לבנות מחדש את כל התוכנות שנשענות עליה, כל עוד הממשק שלה לא השתנה.
שיתוף הקוד בזיכרון הוא בדיוק מה שמונע כפילויות. לכן הטענה ש-DLL 'מכפילה' זיכרון הפוכה מהמציאות: כמה תהליכים שמשתמשים בה חולקים את אותו עותק מקוד שנטען פעם אחת.
טעויות נפוצות
  • כל DLL רצה כתהליך נפרד ומדברת עם התוכנה דרך צינורות (Pipes). היא נטענת לתוך התהליך הקורא ורצה בתוכו, בלי תהליך משלה ובלי ערוץ תקשורת בין תהליכים.
  • DLL נטענת לזיכרון בזמן ההתקנה ונשארת שם עד שמסירים את התוכנה. היא נטענת כשתהליך זקוק לה, ומשתחררת כשאין בה עוד צורך; היא אינה תושבת קבע בזיכרון.
  • קוד ה-DLL מוטמע בכל exe כבר בזמן ההידור. זו ההגדרה של ספרייה סטטית. ב-DLL החיבור קורה בזמן ריצה, והקוד נשאר בקובץ חיצוני.
  • רק תוכנה אחת יכולה להחזיק DLL בכל רגע, והשאר ממתינות בתור. השיתוף בו-זמני בין תהליכים הוא היתרון המרכזי של המנגנון, לא מגבלה.
  • DLL היא קובץ הגדרות של קבוצת משתמשים, או יישום גרפי שרץ לבד. היא ספריית קוד שנטענת לתוך תהליך אחר; היא אינה קובץ קונפיגורציה ואינה אפליקציה עצמאית.
חזרה לתוכן העניינים

שתי דרכים לטעון: מרומזת ומפורשת

יש שתי דרכים עיקריות לחבר DLL לתוכנית, והן נבדלות ברגע שבו הקובץ נטען.

טעינה מרומזת (Implicit Linking) מתחילה כבר בבנייה. המקשר (Linker) משאיר בקובץ ה-exe טבלת ייבוא (Import Table), שמפרטת לכל DLL אילו פונקציות נדרשות ממנה. כשמפעילים את התוכנית, הטוען עובר על הטבלה, ממפה כל DLL שמופיעה בה ומציב את כתובות הפונקציות, וכל זה מסתיים לפני ש-main מתחיל; את הפונקציות הוא מזהה לפי שם או מספר סידורי (Ordinal), ואין לו מושג אילו סוגי פרמטרים הן מצפות לקבל.

C
#include <stdio.h>

__declspec(dllimport) int vat_cents(int net_cents);   // resolved through the import table

int main(void)
{
    printf("VAT on 9900 cents: %d\n", vat_cents(9900));
    return 0;
}
פלט
VAT on 9900 cents: 1683

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

Text
	DLL Name: KERNEL32.dll
	DLL Name: api-ms-win-crt-environment-l1-1-0.dll
	DLL Name: api-ms-win-crt-heap-l1-1-0.dll
	DLL Name: api-ms-win-crt-locale-l1-1-0.dll
	DLL Name: api-ms-win-crt-math-l1-1-0.dll
	DLL Name: api-ms-win-crt-private-l1-1-0.dll
	DLL Name: api-ms-win-crt-runtime-l1-1-0.dll
	DLL Name: api-ms-win-crt-stdio-l1-1-0.dll
	DLL Name: api-ms-win-crt-string-l1-1-0.dll
	DLL Name: tariff.dll
	0000a450  <none>  0000  vat_cents

טעינה מפורשת (Explicit Linking). כאן התוכנית מחליטה בעצמה, בזמן ריצה, מתי להביא DLL, בעזרת שלוש קריאות WinAPI:

קריאההתפקיד שלה בדוגמה שלהלןכשהיא נכשלת
LoadLibraryW(L"tariff.dll")ממפה את tariff.dll לתוך התהליך ומחזירה את ה-HMODULE שלהמחזירה NULL, ו-GetLastError נותן 126
GetProcAddress(mod, "vat_cents")מאתרת פונקציה בספרייה שכבר ממופה ומחזירה את כתובתה; היא עצמה לא טוענת שום קובץמחזירה NULL, ו-GetLastError נותן 127
FreeLibrary(mod)מודיעה שהתוכנית סיימה עם הספרייה, כדי שאפשר יהיה לשחרר אותהמחזירה FALSE

שימו לב לשורה האחרונה: את mod משחררים ב-FreeLibrary ולא ב-CloseHandle. הסיבה היא ש-HMODULE אינו אינדקס בטבלת ה-Handles של התהליך, אלא פשוט הכתובת שבה הספרייה מתחילה בזיכרון.

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

typedef int (*VAT_FN)(int);
typedef int (*FLAG_FN)(void);

int main(void)
{
    HMODULE mod = LoadLibraryW(L"tariff.dll");     // explicit: decided at run time
    if (mod == NULL) {
        printf("LoadLibrary failed, error %lu\n", GetLastError());
        return 1;
    }
    FLAG_FN flag = (FLAG_FN)GetProcAddress(mod, "was_attached");
    VAT_FN vat = (VAT_FN)GetProcAddress(mod, "vat_cents");
    printf("DllMain ran before LoadLibrary returned: %d\n", flag());
    printf("VAT on 25000 cents: %d\n", vat(25000));

    FARPROC none = GetProcAddress(mod, "vat_euros");  // no such export
    printf("missing export -> %s, error %lu\n", none ? "found" : "NULL", GetLastError());

    FreeLibrary(mod);                               // not CloseHandle
    HMODULE gone = LoadLibraryW(L"no_such_plugin.dll");
    printf("missing file -> %s, error %lu\n", gone ? "loaded" : "NULL", GetLastError());
    return 0;
}
פלט
DllMain ran before LoadLibrary returned: 1
VAT on 25000 cents: 4250
missing export -> NULL, error 127
missing file -> NULL, error 126

מהפלט אפשר לקרוא כמה כללים בבת אחת. DllMain של ה-DLL כבר רצה בתוך LoadLibrary, לכן הדגל חזר 1. פונקציה שאינה קיימת מחזירה NULL מ-GetProcAddress עם קוד שגיאה 127 (ERROR_PROC_NOT_FOUND), וקובץ שלא נמצא מחזיר NULL מ-LoadLibrary עם קוד 126 (ERROR_MOD_NOT_FOUND).

הדגל was_attached חושף מנגנון שקט: ל-DLL מותר להגדיר פונקציית כניסה, DllMain, והטוען מפעיל אותה מעצמו בכל פעם שתהליך או thread מצטרפים לספרייה או עוזבים אותה. בדוגמה היא רצה בתוך LoadLibrary, עוד לפני שהקריאה חזרה. כל זה קורה כשהטוען מחזיק את ה-Loader Lock, ולכן בתוך DllMain עושים רק פעולה זעירה כמו הצבת הדגל; עבודה כבדה שם עלולה להקפיא את התהליך.

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

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

טעויות נפוצות
  • GetProcAddress היא זו שמביאה את הספרייה לזיכרון. היא פועלת על ספרייה שכבר נטענה ורק מחזירה כתובת של פונקציה בתוכה; את הטעינה עושה LoadLibrary.
  • CreateFile טוענת DLL ומריצה את הקוד שלה. CreateFile פותחת קובץ כנתונים בלבד ואינה מריצה את תוכנו.
  • RegOpenKeyEx מביאה DLL מתוך ה-Registry. היא רק פותחת מפתח ב-Registry; היא אינה טוענת קוד.
  • מחשבים ידנית את כתובת הפונקציה בזיכרון וקופצים אליה. הכתובת אינה קבועה ועשויה להשתנות בין הרצות ובין מחשבים, ולכן מקבלים אותה בזמן ריצה.
  • regsvr32 הוא הדרך לטעון DLL לתוך תוכנית. regsvr32 רק רושם DLL של COM ב-Registry; הוא אינו מנגנון טעינה לתהליך.
חזרה לתוכן העניינים

כש-DLL חסרה: מתי התקלה מתגלה

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

דרך הטעינהמתי מתגלה החוסרהתוצאה
מרומזת (טבלת ייבוא)בהפעלת התוכנית, עוד לפני שהקוד שלה רץהתהליך לא עולה בכלל, ו-Windows מציגה הודעה על קובץ DLL שלא נמצא
מפורשת (LoadLibrary)רק כשהקוד מגיע לקריאת LoadLibraryLoadLibrary מחזירה NULL, והתוכנית יכולה לבדוק זאת ולהמשיך בלי אותו רכיב

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

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

תרחיש 7: תוסף ייצוא שחסר במחשב אחד

אפליקציית עריכת וידאו מקושרת מרומזות ל-engine.dll, וטוענת מפורשות h265enc.dll רק כשהמשתמש לוחץ על 'ייצא ב-H.265'.

במחשב של דנה חסר h265enc.dll. העורך עולה כרגיל, כי הקובץ הזה אינו בטבלת הייבוא. כשהיא לוחצת 'ייצא', LoadLibrary מחזירה NULL, הקוד מציג 'מקודד H.265 אינו מותקן' וממשיך לעבוד.

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

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

גרסאות: DLL Hell, WinSxS ושינוי חתימה שקט

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

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

מה שכן עובד הוא Side-by-Side (SxS), והרעיון שלו הפוך: במקום עותק משותף אחד שכולם נאבקים עליו, כל גרסה מקבלת מקום משלה תחת C:\Windows\WinSxS.

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

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

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

תרחיש 8: ספריית הצפנה שקיבלה פרמטר נוסף

בגרסה 1 של seal.dll הפונקציה Encrypt קיבלה שני פרמטרים: חוצץ ואורך. בגרסה 2 נוסף לה פרמטר שלישי, מזהה אלגוריתם, והשם נשאר Encrypt.

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

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

טעויות נפוצות
  • הטוען יבחין שהחתימה השתנתה ויסרב לטעון את ה-DLL. הוא מתאים לפי שם או מספר סידורי בלבד ואינו משווה חתימות.
  • הקריאה לפונקציה עם חתימה שהשתנתה תחזיר קוד שגיאה מסודר. אין בדיקה בזמן הקריאה; הפונקציה פשוט רצה עם פרמטרים לא נכונים.
  • שימוש שגוי ב-DLL גורם ל-Windows לשחזר אותה ברקע. שחזור אוטומטי של DLL פגומה אינו קיים; קובץ מערכת שנפגם מתקנים ביוזמה, למשל בהרצת sfc /scannow.
  • DLL פגומה פוגעת רק בקבצים שבתיקיית Documents. היא פוגעת בכל תהליך שטוען אותה, כולל תוכנות מערכת.
חזרה לתוכן העניינים

.NET Framework

מה היא .NET Framework ולמה בוחרים בה

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

על גבה אפשר לכתוב בכמה שפות, בהן C#, VB.NET ו-F#, וכל קוד שמופעל תחת ה-CLR נושא את הכינוי קוד מנוהל (Managed Code).

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

את הגבולות של ה-Framework קל לזכור בארבע קבוצות:

קבוצהמה ה-Framework אינוהסיבה
איפה הקוד רץאינו רץ בליבה, אינו נוגע בחומרה ישירות ואינו מתזמן תהליכים במקום Windowsקוד מנוהל מתבצע במצב משתמש, בתהליכים רגילים, מעל מערכת ההפעלה
למה הוא לא מתאיםדרייברים, קושחה (Firmware) וסקריפטים של Windows Script Hostדרייבר הוא קוד native בליבה שמנוהל דרך Device Manager; קושחה רצה על לוח האם לפני שיש מערכת הפעלה ו-CLR; ל-WSH יש מנוע משלו
מה הוא לא מספקניהול חשבונות וסיסמאות, מסד נתונים, חומת אש או הצפנה של הקודחשבונות הם תחום ה-SAM, וה-IL שבקובץ ניתן לפענוח חזרה בכלי דקומפילציה
באיזו שפה כותביםאינו שמור ל-C# בלבדVB.NET ו-F# רצות עליו באותה מידה
טעויות נפוצות
  • יישומי .NET Framework מהירים יותר כי הם רצים בתוך הגרעין. קוד מנוהל רץ במצב משתמש, לא בליבה.
  • על ה-Framework אפשר לפתח רק ב-C#. גם VB.NET ו-F# רצות עליה.
  • קובץ שנבנה ב-.NET מוצפן, ולכן אי אפשר לשחזר ממנו קוד. ה-IL ניתן לדקומפילציה חזרה לקוד קריא.
  • ה-Framework תופס את מקום מנהלי ההתקן ומפעיל דרייברים. דרייברים הם קוד native שרץ בליבה, מחוץ לעולם המנוהל.
חזרה לתוכן העניינים

מקוד מקור ל-IL

כשמהדרים שפת .NET, למשל C#, הפלט אינו קוד מכונה אלא שפת ביניים ששמה IL (Intermediate Language, המכונה גם CIL). ה-IL הוא שפת מעבד וירטואלי, שאינה כבולה למשפחת מעבדים כמו x86, x64 או ARM.

התוצר הזה נשמר בתוך קובץ Assembly, בסיומת .exe או .dll. ההמרה האמיתית, אל קוד המכונה שמתאים למעבד המקומי, נדחית להרצה ומבוצעת שם בידי ה-JIT.

Text
Report.cs  --(C# compiler, build time)--> Report.exe (IL + metadata)
Report.exe --(CLR JIT, run time)---------> machine code for this CPU

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

C#
using System;
using System.Reflection;

class Inspect
{
    static void Main()
    {
        Assembly me = Assembly.GetExecutingAssembly();
        PortableExecutableKinds kind;
        ImageFileMachine machine;
        me.ManifestModule.GetPEKind(out kind, out machine);

        Console.WriteLine("CLR version:    " + Environment.Version);
        Console.WriteLine("file contents:  " + kind);
        Console.WriteLine("built for:      " + me.GetName().ProcessorArchitecture);
        Console.WriteLine("running 64-bit: " + Environment.Is64BitProcess);
    }
}
פלט
CLR version:    4.0.30319.42000
file contents:  ILOnly
built for:      MSIL
running 64-bit: True

השורה file contents: ILOnly מוכיחה שבקובץ יש IL בלבד, בלי קוד מכונה. הסימון MSIL (כלומר AnyCPU) אומר שההחלטה אם לרוץ כתהליך של 32 או 64 סיביות נדחית לרגע הטעינה, וכאן התקבל תהליך של 64 סיביות. מה קורה כשבונים את אותו קוד עם הדגל -platform:x86?

Text
csc -nologo -platform:x86 -out:Inspect32.exe Inspect.cs
Inspect32.exe
פלט
CLR version:    4.0.30319.42000
file contents:  ILOnly, Required32Bit
built for:      X86
running 64-bit: False

גם הקובץ הזה הוא IL, ועדיין עובר JIT בזמן ריצה. אבל הוא מסומן Required32Bit, ולכן תמיד ירוץ כתהליך x86 של 32 סיביות, גם על מחשב של 64 סיביות: הדגל קבע את הארכיטקטורה כבר בבנייה, ורק קובץ AnyCPU משאיר את ההחלטה לזמן הטעינה.

שלושה תסריטים שלא מתרחשים כאן: אין הפקה של קוד מכונה מוגמר כבר בבנייה (ה-Assembly נושא IL ותלוי ב-CLR להרצה); אין מעבר דרך שלב של C++ ביניים; ואין המרה לסקריפט ש-cmd.exe יריץ, שכן הוא כלל אינו משתתף בתהליך.

טעויות נפוצות
  • מהדר C# מייצר קוד מכונה סופי כבר בזמן הבנייה. הוא מייצר IL; תרגום לקוד מכונה קורה בזמן ריצה דרך ה-JIT.
  • ה-IL הוא קוד מכונה של מעבד מסוים. ה-IL אינו תלוי ארכיטקטורה; המעבד הקונקרטי נבחר רק ב-JIT.
בדקו את עצמכם
פרויקט VB.NET נבנה לקובץ .dll. האם יש בו קוד מכונה מוכן להרצה?

לא. VB.NET מהודרת ל-IL כמו כל שפת .NET, וקוד המכונה נוצר רק כשה-JIT פוגש את הקוד בזמן ריצה.

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

גרסאות, Windows בלבד, ונעילת גרסה

הדרך הנוחה לזכור את הגרסאות היא כציר זמן:

שלבמה הואמה זה אומר במחשב
CLR 2.0מנוע הריצה של גרסאות 2.0, 3.0 ו-3.5יכול להיות מותקן לצד CLR 4, ושניהם פועלים במקביל
CLR 4מנוע הריצה של 4.0 עד 4.8.1מ-4.5 ואילך כל גרסה מתקינה את עצמה במקום הקודמת (In-place): יש רק 4.x אחת, והתקנה חדשה מעדכנת את ה-CLR ואת ספריות הבסיס של כל יישומי 4.x
4.8.xהגרסה האחרונה של ה-Frameworkרצה על Windows בלבד, לא על Linux ולא על macOS
.NET 5 ואילךהיורשת, .NET (Core)חוצת פלטפורמות: רצה גם על Linux וגם על macOS

במחשב Windows 10 רגיל אפשר לראות את שתי המשפחות זו לצד זו, כתיקיות נפרדות:

Text
dir /b /ad C:\Windows\Microsoft.NET\Framework64\v*
פלט
v2.0.50727
v3.0
v3.5
v4.0.30319

רק שתיים מהתיקיות הן מנועי ריצה: v2.0.50727 היא CLR 2.0, ו-v4.0.30319 היא CLR 4. התיקיות של 3.0 ו-3.5 מוסיפות ספריות מעל CLR 2.0, ואין להן CLR משלהן.

ולמה ה-Framework נשאר ב-Windows למרות ה-IL? כי IL נייד רק כשיש מנוע ריצה שיריץ אותו, וה-CLR של ה-Framework נבנה ל-Windows בלבד.

קיבוע גרסה, דוגמה. מערכת הזמנות של חברת תעופה בנויה מעשרות פרויקטים, וכולם מצהירים על Target Framework 4.7.2. מפתח אחד מעביר את הפרויקט שלו ל-4.8.1, ופתאום ספריית בסיס מתנהגת אצלו אחרת מאשר בשרת הבנייה ובייצור.

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

טעויות נפוצות
  • אפשר להריץ אפליקציית .NET Framework 4.8 על שרת Linux. ה-Framework הוא Windows בלבד; היורשת .NET 5 ואילך היא חוצת הפלטפורמות.
  • המטרה של קיבוע גרסה היא לקבל האצה אוטומטית. הקיבוע דווקא עוצר עדכונים, ולכן אינו מביא שיפור אוטומטי.
  • לקבע את גרסת ה-Framework פירושו לנעול את חבילות ה-NuGet. אלה שני מנגנונים נפרדים, גרסת הפלטפורמה מול ניהול תלויות חיצוניות.
חזרה לתוכן העניינים

Assembly, GAC ו-COM

Assembly היא יחידת האריזה של קוד ב-.NET, כלומר .exe או .dll מנוהל. המונח כאן מטעה לרגע: אין לו קשר לשפת סף, והוא מציין 'חבילה' של קוד מנוהל. בתוכה שלושה רכיבים: ה-IL עצמו; Metadata שמתעדת במלואם את הטיפוסים, המתודות והשדות; ו-Manifest שנושא שם, גרסה ורשימת תלויות.

Assembly יכולה לקבל גם שם חזק (Strong Name), כלומר צירוף של שם וגרסה עם חתימה דיגיטלית חתומה במפתח היצרן.

שאלהDLL קלאסית של Win32Assembly מנוהלת
מה יש בתוך הקובץ?הוראות מכונה של משפחת מעבדים אחתIL, ולצדו Metadata שמתארת את הטיפוסים
מי מבצע אותו?המעבד, ישירות אחרי המיפוי לזיכרוןהמעבד, אבל רק אחרי שה-CLR המיר את ה-IL
איך הוא מגיע ל-WinAPI?קורא לפונקציות בלי תיווךדרך P/Invoke, והקובץ נשאר IL ואינו מהודר מחדש ל-native

GAC (Global Assembly Cache) הוא מחסן מרכזי במכונה שבו שוכנות Assemblies בעלות שם חזק, כדי שכמה יישומים יוכלו להישען על אותו עותק. תחת 4.x הוא ממוקם ב-C:\Windows\Microsoft.NET\assembly. מכיוון שהוא מחזיק כמה גרסאות של אותה Assembly במקביל, כל יישום נקשר בדיוק לגרסה שמולה נבנה.

כך נראית גרסה של אותה Assembly בשני מאגרים, במחשב שיש בו גם CLR 2.0 וגם CLR 4:

Text
dir /b C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Xml
dir /b C:\Windows\assembly\GAC_MSIL\System.Xml
פלט
v4.0_4.0.0.0__b77a5c561934e089
2.0.0.0__b77a5c561934e089

כל תיקייה כזו היא גרסה אחת של System.Xml: מספר הגרסה, ואחריו אסימון המפתח הציבורי של היצרן, שהוא חלק מהשם החזק. גרסה 4.0 יושבת ב-GAC של 4.x, וגרסה 2.0 ב-GAC הישן של CLR 2.0, C:\Windows\assembly.

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

ומה שמבלבל הכי הרבה: ה-GAC מחזיק IL, לא קוד מכונה מוכן. הידור מראש הוא העבודה של NGen, שמניח את התמונות שהוא מייצר במטמון נפרד, Native Image Cache.

COM (Component Object Model) היא טכנולוגיית רכיבים משל Microsoft שקדמה ל-.NET. הזיהוי שלה עובר דרך ה-Registry: כל מחלקה נושאת GUID קבוע (CLSID), וה-Registry מפנה ממנו אל ה-DLL של הרכיב; את הרישום מבצעים עם regsvr32.

את משך החיים של אובייקט COM מנהלים ידנית בספירת הפניות, דרך AddRef ו-Release שבממשק IUnknown. בניגוד ל-.NET, COM אינו תלוי ב-CLR כדי לרוץ.

היבטרכיב COMAssembly של .NET
איך המערכת מוצאת את הקודמחפשת את ה-CLSID ב-Registry, ומשם מגיעה לקובץהקובץ מתאר את עצמו ב-Metadata; Assembly שיושבת בתיקיית היישום לא צריכה שום רישום
כמה גרסאות אפשר להחזיקקשה להחזיק יותר מאחת, כי לכל מחלקה יש רישום יחידכמה, כי השם החזק כולל גרסה, וה-GAC מחזיק אותן במקביל
מי מחליט מתי אובייקט מתמונה ההפניות, שמתעדכן ידנית ב-AddRef וב-Releaseה-Garbage Collector של ה-CLR
האם צריך CLRלאכן
.NET יכולה לעבוד עם רכיבי COM ישנים דרך COM Interop, שבונה סביבם עטיפות. זה מנגנון שונה מ-P/Invoke, שקורא לפונקציות רגילות ב-DLL של native.
טעויות נפוצות
  • המילה Assembly מעידה שהקובץ נכתב בשפת סף ורץ ישר על המעבד. היא מכילה IL ודורשת CLR; השם 'Assembly' כאן אינו שפת סף.
  • ב-DLL של Win32 יש IL, וב-Assembly יש קוד מכונה מוכן. זה הפוך: DLL קלאסית מכילה קוד מכונה, Assembly מכילה IL.
  • רכיב COM לא יעבוד במחשב שאין בו CLR. COM קדם ל-.NET ופועל בלעדיו לגמרי.
  • ב-COM אוסף זבל מנקה אובייקטים, וב-.NET סופרים הפניות. הפוך: COM בספירת הפניות, .NET ב-Garbage Collector.
  • COM מחזיק בקלות כמה גרסאות במקביל, ואילו Assembly תמיד חייבת רישום ב-Registry. הפוך: קשה להחזיק גרסאות מקבילות ב-COM, ו-Assembly פרטית של .NET אינה צריכה רישום.
  • ב-GAC שמורות תמונות native מוכנות להרצה. זה תפקיד NGen, ששומר תמונות native במטמון נפרד.
בדקו את עצמכם
שתי אפליקציות נזקקות לגרסאות נבדלות של אותה ספריית .NET שחתומה בשם חזק. היכן מתקינים את שתי הגרסאות כדי שיישבו במאגר אחד משותף?

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

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

CLR: סביבת הריצה של .NET

מה ה-CLR עושה בפועל

ה-CLR (Common Language Runtime) הוא המנוע שתחתיו רץ קוד .NET. להבדיל ממהדר, שסיים את עבודתו בבנייה, הוא נוכח ופעיל לכל אורך חיי התוכנית. אפשר לדמות אותו למנהל סמוי שמטפל בכל מה שהמתכנת לא רוצה לכתוב בעצמו.

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

  1. בהפעלה, ה-CLR מאתר וממפה את ה-Assemblies שהתוכנית צריכה.
  2. כשמתודה מופעלת לראשונה, ה-JIT שלו הופך את ה-IL שלה לקוד מכונה.
  3. בכל new הוא מקצה מקום לאובייקט, ובהמשך ה-Garbage Collector מפנה אובייקטים שאיש לא מגיע אליהם.
  4. בכל גישה למערך או המרת טיפוס הוא מוודא שהפעולה חוקית: אינדקס בטווח, טיפוס מתאים.
  5. כשמשהו משתבש, הוא זורק חריגה ומחפש לה מטפל.

מהרשימה רואים שה-JIT הוא שלב אחד מתוך חמישה; התמונה הכוללת היא ניהול של הקוד, הזיכרון והבטיחות של תוכנית מנוהלת. ומה שהוא מריץ הוא IL של .NET, לא Bytecode של Java.

טעויות נפוצות
  • ה-CLR רק מבצע JIT ותו לא. הוא גם מנהל זיכרון, מטפל בחריגות ואוכף בטיחות טיפוסים.
  • ה-CLR פעיל רק בזמן הקומפילציה. הוא סביבת הריצה עצמה, ופעיל כל עוד התוכנית רצה.
  • ה-CLR הוא שכבת תאימות ל-Java. הוא מריץ IL של .NET, לא Bytecode של Java.
חזרה לתוכן העניינים

JIT: תרגום ה-IL תוך כדי ריצה

ה-JIT (Just-In-Time) הוא מהדר פנימי של ה-CLR שעובד תוך כדי ריצה. בפעם הראשונה שמגיעים למתודה, הוא לוקח את ה-IL שלה ומתרגם אותו לקוד מכונה של המעבד שעליו אנחנו רצים כעת. את התוצר הוא מחזיק בזיכרון, וכל הגעה חוזרת לאותה מתודה כבר מדלגת על התרגום וקופצת ישר לקוד המוכן.

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

מכאן גם מגיע הפתרון להבדלי ארכיטקטורה: קובץ IL יחיד מתאים ל-x86, ל-x64 ול-ARM64, כי על כל מכונה ה-JIT תופר קוד למעבד המקומי, בלי בנייה נפרדת לכל פלטפורמה.

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

תרחיש 9: מה ה-JIT עושה בלולאה של 1000 סיבובים

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

הסיבוב הראשון יוצא איטי מהשאר, כי רק בו ה-JIT עוצר כדי לייצר קוד מכונה ל-Settle. 999 הסיבובים הבאים מהירים באותה מידה, כי כולם קופצים לאותו קוד שכבר שמור בזיכרון.

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

טעויות נפוצות
  • ה-IL מבוצע בפרשנות, הוראה אחרי הוראה, בכל פעם מחדש. ה-JIT מייצר קוד מכונה אמיתי; זו אינה פרשנות.
  • את ה-IL מקבלת הליבה של Windows ומריצה בעצמה. הליבה אינה מבינה IL; ה-CLR חייב לתרגם אותו קודם.
  • לפני ההרצה ה-CLR משחזר מה-IL את קוד ה-C# המקורי. קוד המקור אינו נדרש להרצה; התרגום הוא ל-IL ואז לקוד מכונה.
  • בגלל ה-CLR, כל יישום מנוהל נאלץ לרוץ כתהליך של 32 סיביות. ה-JIT מייצר קוד לארכיטקטורה הנוכחית, כולל 64 סיביות.
  • NGen מפיק קובץ native אחד שמתאים לכל סוגי המעבדים. קוד מכונה תמיד שייך לארכיטקטורה מסוימת.
חזרה לתוכן העניינים

Garbage Collector וניהול זיכרון

ב-C וב-C++ ההקצאה והשחרור נופלים על המתכנת: malloc מול free, new מול delete, ו-CloseHandle לסגירת Handles. אם שוכחים לשחרר נוצרת דליפה, ואם משחררים פעמיים או נוגעים בזיכרון אחרי שחרור התוכנית עלולה ליפול.

ב-.NET העול הזה עובר לידי ה-Garbage Collector (GC) שבתוך ה-CLR. המתכנת מייצר אובייקטים ב-new וממשיך הלאה, בלי לשחרר אותם במו ידיו.

השיטה שבה ה-GC פועלת נקראת Tracing, כלומר מעקב אחר נגישות. נקודת ההתחלה היא קבוצת השורשים (Roots): מצביעים חיים שיושבים ברגיסטרים, בשדות הסטטיים ובמסגרות המקומיות שבמחסנית של כל thread.

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

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

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

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

class Room { public Key Key; }
class Key  { public Room Opens; }

class Cycle
{
    [MethodImpl(MethodImplOptions.NoInlining)]
    static WeakReference BuildPair()
    {
        var room = new Room();
        var key = new Key();
        room.Key = key;      // room -> key
        key.Opens = room;    // key -> room: a cycle
        return new WeakReference(room);   // watches room without keeping it alive
    }

    static void Main()
    {
        WeakReference watch = BuildPair();   // the locals are gone now
        Console.WriteLine("before collection: alive = " + watch.IsAlive);
        GC.Collect();
        Console.WriteLine("after collection:  alive = " + watch.IsAlive);
    }
}
פלט
before collection: alive = True
after collection:  alive = False

Room ו-Key מצביעים זה על זה, וזו בדיוק התבנית שספירת הפניות הייתה נתקעת בה: מונה של 1 אצל כל אחד לנצח. אצל ה-GC, ברגע שהמשתנים המקומיים של BuildPair נעלמו, שום שורש לא מוביל לזוג.

ה-WeakReference רק עוקב אחרי Room בלי להאריך את חייו, ולכן אחרי GC.Collect הוא מדווח False: הזוג כולו נאסף.

גבול האחריות של ה-GC. תחום הטיפול שלו הוא אך ורק זיכרון מנוהל. דברים חיצוניים, למשל Handle של קובץ או חיבור פתוח למסד נתונים, אינם משתחררים מעצמם: סוגרים אותם במפורש ב-Dispose או Close, וב-C# בלוק using דואג לכך בסוף הבלוק:

C#
using System;
using System.IO;

class Release
{
    static void Main()
    {
        File.WriteAllText("draft.txt", "v1");

        var leaked = new StreamReader("draft.txt");   // never disposed
        try { File.Delete("draft.txt"); }
        catch (IOException ex) { Console.WriteLine("delete failed: " + ex.GetType().Name + ", file still open"); }
        leaked.Dispose();

        using (var reader = new StreamReader("draft.txt"))
        {
            Console.WriteLine("read: " + reader.ReadLine());
        }   // Dispose() closes the file handle here

        File.Delete("draft.txt");
        Console.WriteLine("deleted: " + !File.Exists("draft.txt"));
    }
}
פלט
delete failed: IOException, file still open
read: v1
deleted: True

השורה הראשונה בפלט לוכדת את הסכנה: כל עוד הקורא הראשון לא עבר Dispose, הקובץ נשאר נעול ו-File.Delete זורק IOException. ברגע שהבלוק using סוגר את הקורא השני, אותה מחיקה כבר עוברת חלק.

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

תרחיש 10: מה רואה כל אחת מהשיטות במעגל

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

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

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

טעויות נפוצות
  • ה-CLR סופר הפניות לכל אובייקט ומשחרר אותו ברגע שהספירה מתאפסת. הוא משתמש ב-GC שעוקב אחרי נגישות מהשורשים, לא במונה הפניות.
  • מתכנת C# צריך לסיים כל בלוק בקריאת שחרור, בדומה ל-free. ה-GC משחרר זיכרון מנוהל לבד; השחרור הידני שמור למשאבים לא מנוהלים.
  • ה-CLR תופס את כל הזיכרון בתחילת הריצה ולא מחזיר ממנו דבר. ה-GC משחרר זיכרון בזמן ריצה, לפי נגישות.
  • גם זיכרון שהוקצה בצד ה-native מנוקה בידי ה-CLR. קוד native אחראי לשחרר את הזיכרון שלו בעצמו.
  • ברגע שאובייקט קובץ יוצא משימוש, ה-GC סוגר את הקובץ מיד. משאבים לא מנוהלים נסגרים עם Dispose או Close, לא על ידי ה-GC.
חזרה לתוכן העניינים

בטיחות טיפוסים ובדיקת גבולות

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

C#
using System;

class Bounds
{
    static void Main()
    {
        int[] scores = new int[4];          // valid indexes: 0..3
        try
        {
            scores[6] = 100;                // checked by the CLR at run time
            Console.WriteLine("written");
        }
        catch (IndexOutOfRangeException ex)
        {
            Console.WriteLine(ex.GetType().Name + ": " + ex.Message);
        }
    }
}
פלט
IndexOutOfRangeException: Index was outside the bounds of the array.

מכאן שקוד מנוהל שגרתי, כל עוד הוא מחוץ לבלוק unsafe ומחוץ לקריאות native, אינו מסוגל לדרוס שטח זיכרון שלא שייך לו, ותקלות מסוכנות כמו גלישת חוצץ (Buffer Overflow) כמעט נמחקות ממנו. בזה בדיוק נעוץ חיזוק האבטחה של ה-CLR. אותה כתיבה ב-C, לעומת זאת, לא הייתה נבדקת כלל, והערך היה חודר בשקט אל נתונים שכנים.

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

בדקו את עצמכם
בקוד C# יש double[] temps = new double[7]; ואחריו קריאה של temps[7]. מה יקרה בזמן ריצה, ומה היה קורה בקריאה דומה ב-C?

האינדקס החוקי האחרון הוא 6, ולכן ה-CLR עוצר את הגישה וזורק IndexOutOfRangeException. ב-C אין בדיקת גבולות, והקריאה הייתה מחזירה בשקט את מה שבמקרה יושב בזיכרון שאחרי המערך.

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

חריגות ב-CLR והקשר ל-SEH

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

ברגע ההשלכה ה-CLR מקפיא את הזרימה הרגילה ומתחיל לטפס במעלה מחסנית הקריאות (Call Stack), מהמתודה הפעילה כלפי מי שקרא לה. בכל שכבה הוא מחפש catch שסוגו תואם לחריגה; כשנמצא כזה, הביצוע קופץ לתוכו וממשיך משם.

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

לכידה של מה שלא טופל נשענת על שני מנגנונים משלימים. עטיפה רחבה של גוף Main ב-try-catch חוסמת את מה שעולה ב-thread הראשי, ורישום לאירוע AppDomain.CurrentDomain.UnhandledException מגיע גם אל תקלות חסרות מטפל ב-threads נוספים.

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

C#
using System;
using System.Threading;

class Fault
{
    static void Parse(string line)  { throw new FormatException("bad amount: " + line); }
    static void Import(string line) { Parse(line); }                 // no catch here

    static void Main()
    {
        AppDomain.CurrentDomain.UnhandledException += (s, e) =>
        {
            Console.WriteLine("logged: " + ((Exception)e.ExceptionObject).Message);
            Console.WriteLine("terminating: " + e.IsTerminating);
        };

        try
        {
            Import("12a");
        }
        catch (Exception ex)                // general catch, found two frames up the stack
        {
            Console.WriteLine("caught in Main: " + ex.GetType().Name);
            Console.WriteLine("thrown in: " + ex.TargetSite.Name);
        }

        var worker = new Thread(() => { throw new InvalidOperationException("queue file is locked"); });
        worker.Start();
        worker.Join();
        Console.WriteLine("never printed");
    }
}
פלט
caught in Main: FormatException
thrown in: Parse
logged: queue file is locked
terminating: True

Unhandled Exception: System.InvalidOperationException: queue file is locked
...

ה-FormatException עלתה מתוך Parse, ונבלמה ב-catch של Main שתי קומות מעליה; זה בדיוק הטיפוס במעלה המחסנית. תקלת ה-thread ברקע, לעומת זאת, חמקה מאותו catch, פשוט כי אירעה בנתיב ביצוע אחר.

במקומה נכנס לפעולה האירוע UnhandledException: הוא רשם את ההודעה, ומיד אחריו התהליך ירד (terminating: True) תוך הדפסת החריגה שלא טופלה. שלוש דרכים שנראות דומות ואינן נכונות: אתחול מחדש מתוזמן אחרי נפילה אינו 'תופס' את החריגה; בדיקת קלט מקדימה מקטינה סיכון אך אינה מבטיחה שקט; ו-SetUnhandledExceptionFilter שייכת לעולם ה-WinAPI של native.

החיבור ל-SEH. למערכת ההפעלה יש מנגנון חריגות עצמאי משלה, SEH (Structured Exception Handling), שפועל מתחת לכל תהליך. הטיפול המנוהל של .NET אינו תחליף לו אלא שכבה שיושבת מעליו ונשענת עליו.

לכן חריגה מנוהלת זורמת דרך SEH, ותקלה שמקורה במעבד, למשל נגיעה בכתובת פסולה, נכנסת ל-CLR דרך SEH והופכת שם לאובייקט מנוהל כמו NullReferenceException. אין כאן תהליך נוסף שנפתח לכל חריגה, והמרה ל-HRESULT שמורה אך ורק למעבר מול רכיבי COM.

תרחיש 11: רשומה בלוג אחרי קריסה

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

החריגה נזרקה ב-thread רקע שעיבד קבצים ולא היה בו catch. ה-try-catch הכללי ב-Main לא יכול היה לעזור, כי הוא עוטף רק את ה-thread הראשי.

את הרשומה כתב המטפל של AppDomain.CurrentDomain.UnhandledException, שהופעל עבור החריגה הזו; כשהוא סיים, התהליך נסגר, בדיוק כמו בפלט של הדוגמה למעלה.

טעויות נפוצות
  • בעיני ה-CLR החריגה היא בסך הכול מספר שמוחזר מהפונקציה. החריגה היא אובייקט שנזרק ומטפס במעלה המחסנית עד למטפל.
  • מיד אחרי ההשלכה ה-CLR מוחק את ההודעה ואת עקבת המחסנית. הפרטים נשמרים באובייקט החריגה, כולל ההודעה ומחסנית הקריאות.
  • ב-.NET ההחלטה מה לעשות בחריגה עוברת למערכת ההפעלה, ואין try/catch. try/catch הוא הכלי המרכזי לטיפול בחריגות בקוד מנוהל.
  • ה-CLR זנח את SEH והחליף אותו במנגנון עצמאי. הוא נשען על SEH ומוסיף מעליו ניהול מנוהל.
  • מי שנרשם ל-UnhandledException יכול למנוע מהתוכנית להיסגר. מ-.NET 2.0 הוא רק מאפשר לתעד; התהליך נסגר אחריו.
חזרה לתוכן העניינים

P/Invoke: קוד מנוהל קורא ל-WinAPI

DllImport ו-Marshalling

מרבית פונקציות WinAPI חיות בספריות native, בהן kernel32.dll ו-user32.dll, ולא נמצאות כלל בתוך ה-BCL של .NET. הגשר שמחבר ביניהן לקוד מנוהל נקרא Platform Invocation Services, ובקיצור P/Invoke.

בצד ה-C# מתארים זאת בהצהרת מתודה extern שנושאת את התכונה [DllImport]. בתוכה נוקבים בשם הקובץ ובחתימה המלאה של הפונקציה כפי שהיא ב-native.

C#
using System;
using System.Runtime.InteropServices;
using System.Text;

static class Native
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern uint GetFileAttributesW(string path);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern uint GetSystemDirectoryW(StringBuilder buffer, uint size);
}

class Probe
{
    const uint INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF;

    static void Main()
    {
        var dir = new StringBuilder(260);
        uint len = Native.GetSystemDirectoryW(dir, (uint)dir.Capacity);   // string marshalled both ways
        Console.WriteLine("system folder: " + dir + " (" + len + " chars)");

        uint attrs = Native.GetFileAttributesW(@"C:\Windows\notepad.exe");
        Console.WriteLine("notepad attributes: 0x" + attrs.ToString("X"));

        attrs = Native.GetFileAttributesW(@"C:\no\such\ledger.db");
        if (attrs == INVALID_FILE_ATTRIBUTES)
            Console.WriteLine("ledger.db: failed, Win32 error " + Marshal.GetLastWin32Error());
    }
}
פלט
system folder: C:\Windows\system32 (19 chars)
notepad attributes: 0x20
ledger.db: failed, Win32 error 3

ברגע הקריאה ה-CLR מוודא שה-DLL בזיכרון התהליך, ומאתר בה את הפונקציה. לפני המסירה הוא מתרגם כל פרמטר מטיפוס מנוהל לייצוג ה-native המתאים, למשל string למחרוזת Unicode או StringBuilder לחוצץ שהפונקציה תמלא; הצעד הזה הוא ה-Marshalling.

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

בדוגמה, GetSystemDirectoryW מילא את ה-StringBuilder בנתיב, ו-GetFileAttributesW החזיר 0x20 (FILE_ATTRIBUTE_ARCHIVE) עבור notepad.exe. על קובץ שאינו קיים הוא החזיר ערך שגיאה, ובזכות SetLastError = true נשמר קוד השגיאה של WinAPI, שקוראים אותו עם Marshal.GetLastWin32Error (כאן 3, 'הנתיב לא נמצא').

בזכות המנגנון הזה מגיעים ליכולות של Windows שה-BCL לא חושף, בלי לצאת מ-C#. כדי לא לייחס לו יותר מדי, כדאי להפריד אותו מכמה דברים שנשמעים דומים:

מה שנשמע סבירמה באמת קורה
ה-DLL הופכת לקוד מנוהלהקוד שבה נשאר native ורץ כמו שהוא; רק הפרמטרים וערך ההחזרה עוברים Marshalling
קוד C# נארז ל-DLL שרץ בלי CLRאין דבר כזה; קוד C# תמיד זקוק ל-CLR
גם ספרייה שנכתבה ב-C# נצרכת כךל-Assembly מנוהלת מוסיפים Reference; המנגנון מיועד לפונקציות לא מנוהלות
זה בעצם JIT, או COM Interopה-JIT מתרגם IL לקוד מכונה, ו-COM Interop עוטף רכיבי COM; אלה מנגנונים נפרדים
טעויות נפוצות
  • [DllImport] מורה ל-CLR להדר IL לקוד מכונה. זה תפקיד ה-JIT; P/Invoke מגשר אל פונקציה ב-DLL של native.
  • המנגנון הזה הופך את תוכן ה-DLL לקוד מנוהל. הקוד נשאר native ורץ כמו שהוא; רק הפרמטרים וערך ההחזרה עוברים Marshalling.
  • כדי לקרוא למחלקה שכתבתם ב-C# בפרויקט אחר צריך P/Invoke. הוא נועד לפונקציות לא מנוהלות; ל-Assembly מנוהלת מוסיפים Reference.
  • P/Invoke הוא מה שעוטף רכיבי ActiveX ישנים לשימוש מ-C#. זה מנגנון אחר; P/Invoke קורא לפונקציות רגילות ב-DLL.
חזרה לתוכן העניינים

הסיכונים: ההגנות של ה-CLR נעצרות בגבול

ברגע שהביצוע חוצה את הקו אל native, מטריית ההגנה של ה-CLR נסגרת. הבעיה הראשונה היא הצהרה שלא תואמת את המקור. ה-CLR מאמין להצהרת ה-DllImport כלשונה ואינו מצליב אותה מול ה-DLL, פשוט כי ל-DLL של native אין Metadata שתתאר את סוגי הפרמטרים.

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

C#
using System;
using System.Runtime.InteropServices;

static class Wrong
{
    [DllImport("disk.dll")]
    public static extern int used_bytes();     // declared 32-bit: the CLR trusts this
}

static class Right
{
    [DllImport("disk.dll")]
    public static extern long used_bytes();    // matches the native long long
}

class Usage
{
    static void Main()
    {
        Console.WriteLine("int declaration:  " + Wrong.used_bytes());
        Console.WriteLine("long declaration: " + Right.used_bytes());
    }
}
פלט
int declaration:  1705032704
long declaration: 6000000000

אותה פונקציית native מחזירה מספר של 64 סיביות. ההצהרה עם int קוראת רק 32 סיביות ממנו ומחזירה ערך שגוי לגמרי (1705032704), בלי כל אזהרה; ההצהרה עם long תואמת בגודלה ומחזירה את הערך הנכון. הקומפיילר לא התלונן באף אחד מהמקרים, כי הוא לא ראה את ה-DLL.

הבעיה השנייה נוגעת לזיכרון ומשאבים. כל מה שחזר מהצד ה-native, שטח זיכרון שהוקצה שם, מצביעים או Handles, נמצא מחוץ לשליטת ה-GC. האחריות לשחרר, למשל CloseHandle על Handle שקיבלתם, ולוודא שההמרות מדויקות, עוברת כולה אליכם; פספוס כאן מסתיים בדליפה או בנפילה.

ומה שלא כדאי לצפות לו מהמנגנון:

  • הגנה מקריסה: P/Invoke לא מוסיף שום בדיקת בטיחות סביב הקריאה.
  • הרשאות מיוחדות: אין צורך בהרשאות מנהל, והפונקציה פועלת עם מה שכבר יש לתהליך.
  • תרגום ל-IL: המהדר לא נוגע בקוד ה-native, והוא נשאר כמו שהוא.
  • חסימה מצד ה-CLS: ה-CLS (Common Language Specification) הוא רק כללי תאימות בין שפות .NET, ואינו מונע גישה לקוד חיצוני.
תרחיש 12: רוחב שגוי בפרמטר

דמיינו שב-disk.dll נוספת פונקציה reserve_bytes, שמקבלת כמות בתים כמספר של 64 סיביות.

בצד ה-C# מישהו כותב את הפרמטר כ-int. אין שגיאת הידור, וגם ההרצה הראשונה לא מתריעה על כלום.

בפועל הפונקציה קוראת 64 סיביות, בזמן שה-C# מילא רק 32 מהן, והשאר הוא מה שבמקרה היה שם. כמו בערך ההחזרה שראיתם בפלט למעלה, המספר יוצא שגוי בשקט, ובמקרה גרוע התהליך נופל; התיקון הוא הצהרה עם long.

טעויות נפוצות
  • המהדר של C# יתריע על הצהרה שלא תואמת את ה-DLL. המהדר אינו רואה את ה-DLL, ולכן אינו יכול להשוות.
  • לפני הקריאה ה-CLR מאמת את ההצהרה שלכם אל מול הקובץ, וזורק חריגה מסודרת. ה-CLR סומך על ההצהרה ואינו בודק אותה מול ה-DLL.
  • כדי לקרוא לפונקציה דרך DllImport חייבים להריץ כמנהל. אין בו הרשאה מיוחדת; הפונקציה רצה עם ההרשאות של התהליך.
  • זיכרון שהוחזר מפונקציית native ישוחרר בסוף על ידי ה-GC. ה-GC מנהל רק זיכרון מנוהל; את זיכרון ה-native משחרר המפתח.
חזרה לתוכן העניינים

Wrapper מנוהל, ודרכים שאינן עובדות

Wrapper מנוהל הוא מחלקת .NET שחוצצת בין שאר הקוד לבין DLL ותיקה שנכתבה ב-C או ב-C++. בלבה היא נשענת על P/Invoke, אך כלפי חוץ היא מציגה פנים נקיות ובטוחות.

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

C#
using System;
using System.ComponentModel;            // Win32Exception
using System.IO;                        // FileAttributes
using System.Runtime.InteropServices;   // DllImport, Marshal

public static class FileFlags           // the only class that touches P/Invoke
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    static extern uint GetFileAttributesW(string path);

    public static bool IsHidden(string path)
    {
        uint raw = GetFileAttributesW(path);
        if (raw == 0xFFFFFFFF)
            throw new Win32Exception(Marshal.GetLastWin32Error());   // error code -> exception
        return ((FileAttributes)raw & FileAttributes.Hidden) != 0;
    }
}

class Guard
{
    static void Main()
    {
        Console.WriteLine("ProgramData hidden: " + FileFlags.IsHidden(@"C:\ProgramData"));
        Console.WriteLine("Windows hidden:     " + FileFlags.IsHidden(@"C:\Windows"));
        try
        {
            FileFlags.IsHidden(@"C:\no\such\ledger.db");
        }
        catch (Win32Exception ex)
        {
            Console.WriteLine("error " + ex.NativeErrorCode + ": " + ex.Message);
        }
    }
}
פלט
ProgramData hidden: True
Windows hidden:     False
error 3: The system cannot find the path specified

הקריאה הגולמית ל-GetFileAttributesW ובדיקת הכישלון שלה כלואות כולן בתוך FileFlags. מי שמשתמש ב-IsHidden רואה רק ערך בוליאני, ובמקום מספר שגיאה מקבל Win32Exception עם הודעה מילולית (כאן קוד 3).

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

נסו לדמיין ש-FileFlags לא קיימת, ומישהו מחפש קיצור דרך אל GetFileAttributesW בלי DllImport. אף אחד מהניסיונות האלה לא יעבוד:

הניסיוןלמה הוא נכשל
להוסיף את ה-DLL כ-Reference בפרויקטReference מקבל רק Assemblies של .NET; ל-DLL של native אין Metadata, והמהדר עוצר בשגיאה CS0009
לרשום את ה-DLL ב-GACה-GAC מקבל רק Assemblies מנוהלות
להדביק את קוד ה-C של הפונקציה בתוך בלוק unsafeunsafe רק מתיר מצביעים בתוך C#; הוא לא מהדר שפה אחרת
לאתר את הפונקציה ב-ReflectionReflection עובד על טיפוסים מנוהלים, ול-DLL של native אין כאלה
לחפש דגל מהדר שיחבר את הפונקציותאין דגל כזה; החיבור נעשה רק בהצהרת DllImport
להריץ קובץ batch של cmd ולקרוא את התוצאהbatch אינו מתווך קריאות WinAPI מתוך הקוד
טעויות נפוצות
  • בונים Wrapper מנוהל כדי להאיץ את הקריאות ל-DLL. הוא מוסיף Marshalling בכל קריאה; המטרה היא נוחות ובטיחות, לא מהירות.
  • Wrapper מנוהל מבטל את פעולת ה-GC בזמן הקריאה. ה-GC ממשיך לנהל את הזיכרון המנוהל כרגיל.
  • Wrapper מנוהל חוסם יישומים אחרים מלהשתמש ב-DLL. ה-DLL נשארת זמינה לכל תהליך שטוען אותה.
  • מוסיפים DLL של native כ-Reference ב-Visual Studio כדי לקרוא לפונקציות שלה. Reference מיועד ל-Assemblies מנוהלות; ל-native צריך DllImport.
בדקו את עצמכם
בצוות של כמה עשרות מפתחים רוצים לצרוך ספריית C ותיקה, אך בלי שאיש יכתוב DllImport או יתעסק עם מצביעים. מה בונים, ומה העלות?

מעטפת מנוהלת יחידה, שבתוכה P/Invoke וכלפי חוץ ממשק .NET רגיל. העלות: תוספת Marshalling זניחה בכל קריאה.

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

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

מה cmd עושה, ומה הוא לא

פתחו Command Prompt ותקבלו חלון כהה עם שורת הנחיה, למשל C:\Users\noa>, וסמן מהבהב. כל שורה שתכתבו שם ותשלחו ב-Enter מגיעה אל cmd.exe, מפרש הפקודות (Command Interpreter) הקלאסי של Windows, והתשובה שלו מודפסת ממש מתחת לשורה ששלחתם.

מה אפשר לבקש ממנו? שלושה סוגים של דברים:

  • פקודה שבנויה לתוך cmd עצמו (פקודה פנימית), למשל cd או dir.
  • תוכנית נפרדת שיושבת על הדיסק (פקודה חיצונית), למשל reg, sc או tasklist.
  • קובץ אצווה (Batch File): קובץ .bat או .cmd שמרכז רצף של פקודות.

קובץ .bat שנכתב עוד בימי DOS יכול לרוץ גם היום. cmd.exe, שהגיע עם משפחת Windows NT, נבנה כיורש של מפרש הפקודות של DOS ושמר על השפה שלו, כולל הפקודות הישנות וקובצי ה-batch. בזכות זה הוא לא נעלם: מנהלי מערכת עדיין פותחים אותו כדי להפעיל סקריפט ותיק, לאבחן תקלה או להקליד פקודה בודדת ולסיים.

המשתנה ComSpec מצביע על המפרש עצמו:

Text
echo %ComSpec%
פלט
C:\Windows\system32\cmd.exe
שני תהליכים, שני תפקידים. את החלון עצמו, עם המסגרת, הגופן והגלילה, מצייר תהליך אחר בשם Console Host (conhost.exe). cmd רק מפרש ומריץ את מה שהקלדתם.

פעולות שדורשות הרשאות מנהל מבצעים מחלון שנפתח בלחיצה ימנית ובחירה ב-Run as administrator. קל לזהות חלון כזה: הכותרת שלו מתחילה ב-Administrator:.

בשאלות על cmd חוזרים כמה תיאורים שגויים. כדאי להכיר אותם מראש:

התיאור השגוימה נכון
רכיב בליבה שמדבר עם החומרהcmd הוא תוכנית רגילה במצב משתמש. גישה לחומרה שייכת לליבה ולמנהלי ההתקנים.
הרכיב שמחליט איזה תהליך יקבל זמן מעבדתזמון תהליכים הוא עבודה של הליבה, לא של מפרש פקודות.
ממשק גרפי לגלישה בין קבציםתיקיות בחלונות ובתפריטים מציג סייר הקבצים. cmd כולו טקסט.
עורך שבו כותבים קובצי batchאת הקבצים כותבים בכל עורך טקסט, ו-cmd רק מבצע אותם.
שירות שמריץ ברקע משימות מתוזמנות בלי חלוןcmd ממתין לקלט ומדפיס לחלון. הוא לא שירות מערכת.
תוכנית ההתקנה של Windowsההתקנה היא תוכנית אחרת לגמרי.
PowerShell בשם אחרPowerShell היא מעטפת נפרדת, בנויה על .NET, שמעבירה אובייקטים בין פקודות. cmd מעביר טקסט.
טעויות נפוצות
  • cmd מעביר בין הפקודות שלו אובייקטים של .NET. זה מה שמאפיין את PowerShell. cmd עובד עם טקסט בלבד.
  • הגופן, הצבעים והגלילה של החלון הם חלק מ-cmd.exe. את החלון מנהל Console Host (conhost.exe), תהליך נפרד. cmd הוא רק המפרש שמשתמש בו.
  • cmd יושב בליבה, ולכן הוא זה שמתזמן את התהליכים. cmd רץ במצב משתמש כמו כל תוכנית. התזמון נעשה בליבה.
חזרה לתוכן העניינים

פנימית או חיצונית: איך cmd מוצא את מה שהקלדתם

על כל שם פקודה cmd עונה קודם על שאלה אחת: האם הקוד שלה כתוב בתוכו? פקודה פנימית היא חלק מ-cmd.exe, ולכן אין לה קובץ משלה על הדיסק.

הפקודות הפנימיות שכדאי להכיר: dir, cd, copy, move, del, mkdir (או בקיצור md), type, cls, echo, set, vol, for ו-if.

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

Text
where dir
where tasklist
פלט
INFO: Could not find files for the given pattern(s).
C:\Windows\System32\tasklist.exe

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

  1. התיקייה שבה אתם נמצאים כרגע.
  2. התיקיות שרשומות במשתנה PATH, אחת אחרי השנייה לפי סדר הכתיבה. C:\Windows\System32 היא אחת מהן.

בכל תיקייה cmd מצרף לשם את הסיומות מהמשתנה PATHEXT, ביניהן .com, .exe, .bat ו-.cmd. הקובץ הראשון שנמצא הוא זה שרץ, ומקומות אחרים, כמו מפתחות ה-Registry, לא משתתפים בחיפוש בכלל.

רוב הכלים החיצוניים המוכרים יושבים ב-System32: tasklist ו-taskkill לתהליכים, sc לשירותים, reg ל-Registry, וגם whoami, systeminfo, attrib ו-findstr. שימו לב ש-tasklist מדפיסה את רשימת התהליכים כטקסט בתוך החלון, ולא פותחת את Task Manager.

נניח שהקלדתם chcpp במקום chcp. תקבלו הודעת שגיאה קבועה באנגלית, בשתי שורות: השם שכתבתם בין גרשים, ואחריו הקביעה שאין פקודה, תוכנית או קובץ batch שעונים לשם הזה. שום דבר לא רץ, ו-cmd לא מנסה לנחש.

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

שני כלים כן עומדים לרשותכם:

  • לתחביר הנכון של פקודה מוסיפים /? מיד אחרי השם שלה, או כותבים help ואחריה את השם. הפלט מתאר את המתגים, כמו בדוגמה שלמטה.
  • מקש Tab חוסך הקלדה של נתיבים: לחיצה עליו משלימה שם של קובץ או של תיקייה. בלי הלחיצה הזו אין ב-cmd שום השלמה.
Text
vol /?
פלט
Displays the disk volume label and serial number, if they exist.

VOL [drive:]
תרחיש 13: מה עובר על cmd כשמקלידים chcp

אתם מקלידים chcp ולוחצים Enter. מאחורי הקלעים:

  1. cmd בודק ברשימת הפקודות הפנימיות שלו. chcp לא שם.
  2. הוא מחפש בתיקייה הנוכחית קובץ בשם chcp עם אחת הסיומות של PATHEXT, ולא מוצא.
  3. הוא עובר על התיקיות של PATH לפי הסדר, ובתיקיית System32 נמצא chcp.com.
  4. הקובץ רץ ומדפיס לאותו חלון את דף הקוד (code page) הפעיל.
Text
chcp
פלט
Active code page: 65001

עכשיו מניחים בתיקייה הנוכחית קובץ בשם chcp.bat. התיקייה הנוכחית נבדקת לפני System32, ולכן הקובץ המקומי הוא שירוץ, אף שהכלי האמיתי עדיין קיים:

Text
rem contents of chcp.bat in the current folder:
@echo off
echo chcp.bat from the current folder ran instead

rem then, typed at the prompt:
chcp
פלט
chcp.bat from the current folder ran instead

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

טעויות נפוצות
  • tasklist כתובה בתוך cmd.exe, בדיוק כמו dir. היא קובץ נפרד, tasklist.exe שב-System32, ו-cmd מגיע אליו דרך החיפוש ב-PATH.
  • tasklist מקפיצה את החלון הגרפי של Task Manager. היא כלי טקסט: רשימת התהליכים מודפסת לתוך חלון cmd.
  • כשהפקודה לא נמצאת בתיקייה, cmd מחפש אותה ב-Registry. החיפוש מוגבל לתיקייה הנוכחית ולתיקיות של PATH.
  • שם ש-cmd לא מכיר עובר מעצמו ל-PowerShell, או שרצה במקומו הפקודה הקרובה ביותר. cmd עוצר ומדפיס הודעת שגיאה, ושום דבר אחר לא רץ.
חזרה לתוכן העניינים

ארגז הכלים היומיומי: dir, cd, echo ועוד

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

תחוםפקודהמה היא עושהדוגמה
ניווטcdבלי ארגומנט מדפיסה את הנתיב הנוכחי; עם נתיב עוברת אליו, ו-.. מעלה רמהcd D:\Music
ניווטdirמפרטת מה יש בתיקייה: שמות, גדלים, תאריכים ושעותdir /p
קבצים ותיקיותmd או mkdirפותחת תיקייה חדשה, בלי להיכנס אליהmd Drafts
קבצים ותיקיותcopyמשכפלת קובץ ליעד אחר, והמקור נשאר במקומוcopy photo.jpg F:\Album
קבצים ותיקיותmoveמעבירה קובץ, כך שבמקום המקורי הוא כבר לא קייםmove photo.jpg F:\Album
קבצים ותיקיותdelמוחקת קובץdel draft.tmp
קבצים ותיקיותtypeשופכת למסך את התוכן של קובץ טקסטtype todo.txt
מסךechoכותבת למסך מחרוזת, או ערך של משתנהecho %COMPUTERNAME%
מסךclsמרוקנת את החלון מכל מה שהודפס בוcls
סביבה וכונןsetבלי ארגומנט מציגה את משתני הסביבה; עם NAME=value קובעת אחד מהםset LEVEL=3
סביבה וכונןvolמדפיסה רק את תווית הכונן ואת המספר הסידורי שלוvol E:

בתיקייה עם מאות קבצים הרשימה של dir גוללת מהר מדי. dir /p מציגה מסך אחד בכל פעם וממתינה ללחיצה על מקש, ו-dir /w מוותרת על הפרטים ומסדרת את השמות בעמודות זו לצד זו.

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

Text
cd /d C:\Windows
cd
cd System32
cd
cd ..
cd
פלט
C:\Windows
C:\Windows\System32
C:\Windows

ניתוב פלט: התו > שולח את מה שהפקודה מדפיסה לקובץ במקום למסך, ודורס קובץ קיים; >> מוסיף לסוף הקובץ. הקובץ basics.bat שלהלן יוצר תיקייה, כותב לתוכה יומן קצר ומציג אותו:

Text
@echo off
md reports
cd reports
echo Backup job started > job.txt
echo Copied 12 files >> job.txt
type job.txt
cd ..
dir /b reports
פלט
Backup job started 
Copied 12 files 
job.txt

ו-vol מספרת על הכונן עצמו, לא על הקבצים שבו:

Text
vol C:
פלט
 Volume in drive C has no label.
 Volume Serial Number is 26FC-0E68

מי שמגיע מ-Linux או מ-macOS נוטה להקליד מתוך הרגל דברים שלא עובדים כאן:

ההרגלמה cmd עושה איתומה כותבים במקום
lsמודיע שאין פקודה כזו. את השם מכירה רק PowerShell, ככינוי (alias)dir
pwdאותה הודעת שגיאה: גם זו פקודה מעולם ה-Unixcd בלי ארגומנט
לחפש כתובת IP בפלט של dirלא תמצאו: dir עוסקת רק בקבצים ובתיקיותכלי הרשת ipconfig
טעויות נפוצות
  • md Reports מכניסה אתכם לתיקייה Reports. md רק יוצרת אותה. כדי להיכנס צריך אחריה cd Reports.
  • vol C: מפרטת את הקבצים שבכונן. היא מדפיסה שתי שורות בלבד: התווית והמספר הסידורי.
  • בעזרת echo מעתיקים קובץ, או מוודאים שקובץ batch כתוב נכון. echo רק מדפיסה. להעתקה יש copy, ופקודה לבדיקת תחביר של batch אין ב-cmd בכלל.
  • dir מפעילה קובץ .bat שבתיקייה, או מחזירה את המערכת לנקודת שחזור. dir קוראת בלבד: היא מציגה את תוכן התיקייה ולא משנה דבר.
בדקו את עצמכם
אתם בתיקייה C:\Media. מה תקלידו כדי לראות איפה אתם, לפתוח תיקייה חדשה בשם Clips ולהיכנס אליה?

שלוש פקודות לפי הסדר: cd לבדה, אחריה md Clips, ולבסוף cd Clips.

הפקודה echo ready > state.txt רצה פעמיים, ואחריה echo done >> state.txt. מה יש בקובץ?

שתי שורות, ready ואחריה done. ההרצה השנייה עם > דרסה את הראשונה, ו->> הוסיפה שורה בסוף.

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

משתני סביבה: %NAME% ומתי הוא מוחלף

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

כשכותביםcmd מציב במקומולמשל
%PATH%את רשימת התיקיות שבהן מחפשים תוכניות, עם נקודה-פסיק בין תיקייה לתיקייהC:\Windows\System32;...
%ERRORLEVEL%את קוד היציאה שהשאירה הפקודה או התוכנית האחרונה0
%TEMP%את תיקיית הקבצים הזמניים בפרופיל של המשתמש המחוברC:\Users\noa\AppData\Local\Temp
%SystemRoot%את תיקיית ההתקנה של WindowsC:\Windows
Text
@echo off
rem vars.bat
echo %SystemRoot%
echo %SystemRoot%\Temp
set TEAM=Falcon
echo Deploying for %TEAM%
פלט
C:\Windows
C:\Windows\Temp
Deploying for Falcon
%SystemRoot%\Temp ו-%TEMP% נשמעים כמעט אותו דבר ומובילים לשני מקומות שונים. הראשון הוא תיקיית Temp בתוך תיקיית Windows; השני הוא תיקייה בתוך הפרופיל של המשתמש.

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

%ERRORLEVEL% מחזיק את הקוד שהתוכנית כולה החזירה כשהסתיימה, וברוב הכלים 0 מסמן הצלחה. הוא לא קוד השגיאה של קריאת WinAPI מסוימת בתוך התוכנית; את זה מבררים מתוך הקוד עם GetLastError. אצל findstr, למשל, 0 אומר שנמצאה התאמה ו-1 שלא:

Text
@echo off
rem level.bat - service.log has one line with the word WARNING
findstr /i "timeout" service.log
echo findstr returned %ERRORLEVEL%
findstr /i "warning" service.log
echo findstr returned %ERRORLEVEL%
פלט
findstr returned 1
10:05 WARNING queue length 480
findstr returned 0

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

כדי לראות בתוך הבלוק את הערך העדכני משתמשים בהרחבה מושהית (Delayed Expansion): כותבים את השם בין סימני קריאה, !total!. את התחביר הזה מדליקה השורה setlocal EnableDelayedExpansion; בלעדיה cmd מדפיס את !total! כמו שהוא, אות באות.

Text
@echo off
setlocal EnableDelayedExpansion
set total=0
for %%n in (5 10 20) do (
  set /a total+=%%n
  echo plain: %total%  delayed: !total!
)
echo after the loop: %total%
פלט
plain: 0  delayed: 5
plain: 0  delayed: 15
plain: 0  delayed: 35
after the loop: 35

set /a מחשבת ביטוי חשבוני. בכל הסיבובים plain נשאר 0 ורק !total! מתקדם, ואחרי הלולאה %total% כבר מחזיר 35, כי זו שורה חדשה שנקראת אחרי הבלוק.

טעויות נפוצות
  • %SystemRoot%\Temp היא התיקייה הזמנית של המשתמש. התיקייה של המשתמש היא %TEMP%, בתוך הפרופיל שלו. %SystemRoot%\Temp נמצאת בתוך תיקיית Windows.
  • בקובץ batch %SystemRoot% לא מוגדר, כי הוא קיים רק בחלון האינטראקטיבי. זה משתנה סביבה ככל המשתנים, והוא מוחלף בקובץ בדיוק כמו בחלון.
  • %ERRORLEVEL% מגלה איזו קריאת WinAPI נכשלה בתוך התוכנית. הוא קוד היציאה של התוכנית כולה. את סיבת הכישלון של קריאה בודדת שולפים מתוך התוכנית עם GetLastError.
חזרה לתוכן העניינים

קובצי batch: פקודות שרצות לבד

נתחיל מקובץ אמיתי. את stash.bat כתבנו ב-Notepad ושמרנו עם הסיומת .bat (הסיומת .cmd עובדת באותה צורה), ובתוכו רק פקודות cmd רגילות. זה כל מה שקובץ batch (קובץ אצווה) הוא.

מפעילים אותו בשורה stash.bat budget.xlsx, מתיקייה שיש בה תת-תיקייה בשם vault. cmd קורא את הקובץ מלמעלה למטה ומבצע כל שורה בתורה, בדיוק כאילו הקלדתם אותה ידנית:

Text
@echo off
rem stash.bat - copies the file named in the first argument into the vault folder
echo Script: %0
echo Saving %1 ...
copy %1 vault
פלט
Script: stash.bat
Saving budget.xlsx ...
        1 file(s) copied.

מה הפלט מלמד:

  • budget.xlsx הגיע לפקודה דרך %1, הארגומנט הראשון שנכתב אחרי שם הסקריפט. ארגומנטים נוספים יחכו ב-%2, %3 וכן הלאה, עד %9.
  • %0 הדפיס את שם הסקריפט עצמו, כפי שהקלדתם אותו. הפעלה בשורה stash budget.xlsx, בלי הסיומת, מדפיסה Script: stash.
  • השורה שמתחילה ב-rem לא השאירה סימן: זו הערה, ו-cmd מדלג עליה.
  • בחלון הופיעו רק תוצאות, בלי הפקודות עצמן. זה תפקידו של @echo off בשורה הראשונה; בלעדיו cmd מציג כל פקודה רגע לפני שהוא מבצע אותה.

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

תרחיש 14: סקריפט ניקוי שמקבל שם תיקייה

בקובץ purge.bat יש, אחרי @echo off, שורה אחת: del %1\*.bak. בתיקייה cache נמצאים old1.bak, old2.bak ו-keep.txt.

  1. מריצים purge.bat cache.
  2. לפני הביצוע cmd מציב את הארגומנט במקום %1, והפקודה שרצה בפועל היא del cache\*.bak.
  3. שני קובצי ה-.bak נמחקים. keep.txt נשאר, וגם purge.bat עצמו, שאליו מפנה %0, לא נפגע.
Text
rem after running purge.bat cache:
dir /b cache
פלט
keep.txt
חזרה לתוכן העניינים

לולאות, תנאים וכלים לסקריפטים מורכבים

במשתנה של לולאת for יש הבדל שמפיל הרבה אנשים. בשורת הפקודה כותבים אותו עם אחוז אחד, %c; בתוך קובץ batch חייבים שניים, %%c.

הסיבה היא סדר העבודה. בקובץ, cmd עובר על השורה ומפענח כל % בודד עוד לפני ש-for מתחילה לפעול, כי הוא מניח שזה פרמטר כמו %1 או משתנה כמו %TEMP%. הצמד %% הופך באותו מעבר ל-% אחד, ורק אותו for מקבלת.

Text
rem typed at the prompt:
for %c in (red green) do @echo color %c
פלט
color red
color green

אותה תבנית עם אחוז בודד, הפעם בתוך loop.bat, נשברת עוד לפני הסיבוב הראשון:

Text
@echo off
rem loop.bat - a single percent sign inside a batch file
for %s in (north south) do echo %s
echo this line is never reached
פלט
s was unexpected at this time.

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

Text
@echo off
rem loop2.bat - the batch file form
for %%s in (north south) do echo %%s
פלט
north
south

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

watch.bat קורא את hosts.txt, שבכל שורה בו שם של שרת ומצבו: web01 up, db02 down, cache03 up. לידו בתיקייה יושב notify.bat, ובו שורה אחת: echo notify.bat ran.

Text
@echo off
if not exist hosts.txt goto nofile
rem first word of every line in hosts.txt
for /f "tokens=1" %%h in (hosts.txt) do echo host: %%h
rem the second part of the output of chcp, split at the colon
for /f "tokens=2 delims=:" %%c in ('chcp') do echo code page:%%c
findstr /i "down" hosts.txt
if errorlevel 1 goto allup
echo At least one host is down
call notify.bat
goto :eof
:allup
echo Every host is up
goto :eof
:nofile
echo hosts.txt is missing
פלט
host: web01
host: db02
host: cache03
code page: 65001
db02 down
At least one host is down
notify.bat ran

עוברים על הסקריפט לפי סדר השורות:

  • if not exist hosts.txt goto nofile: התנאי if exist בודק אם קובץ קיים, וכאן, בתוספת not, שולח את הביצוע לתווית :nofile כשהקובץ חסר. goto קופצת לתווית, כלומר לשורה שמתחילה בנקודתיים.
  • שתי שורות ה-for /f עוברות שורה אחרי שורה, הראשונה על קובץ והשנייה על הפלט של הפקודה chcp, ומפרקות כל שורה לחלקים (tokens). tokens=1 לוקח את המילה הראשונה; delims=: קובע שהחיתוך ייעשה בנקודתיים, ו-tokens=2 לוקח את מה שבא אחריהם.
  • findstr מחפשת את המחרוזת down בקובץ ומדפיסה את השורה שמצאה. כשיש התאמה היא מסיימת עם קוד 0, וכשאין, עם 1.
  • if errorlevel 1 מתקיים כשקוד היציאה האחרון הוא 1 או גבוה יותר. כאן הקוד היה 0, ולכן לא הייתה קפיצה ל-:allup.
  • call notify.bat מפעילה את הסקריפט השני. כשהוא מסיים, הביצוע חוזר ל-watch.bat וממשיך ל-goto :eof, שמסיים את הקובץ.

כשמחקנו מ-hosts.txt את השורה של db02, findstr החזירה 1, התנאי התקיים, והפלט הסתיים ב-Every host is up.

שלוש דרכים נשמעות כמו הרחבה של cmd, ואף אחת מהן לא עובדת כך:

  • Bash: מעטפת עצמאית. מי שעובר אליה מחליף את cmd, ולא מוסיף לו יכולות.
  • VBScript: שפה עם מנוע הרצה משלה. אי אפשר לשתול אותה בתוך cmd.exe במקום מנוע הפקודות שלו.
  • Registry: עריכה שלו לא פותחת פקודות סקריפט נסתרות, פשוט כי ב-cmd אין כאלה.
תרחיש 15: לולאה שעברה מהחלון לקובץ

טכנאית בודקת בחלון cmd את השורה for %u in (Sales Ops) do md %u, ומקבלת שתי תיקיות חדשות.

  1. היא מעתיקה את השורה כמו שהיא לקובץ folders.bat.
  2. בהרצה, cmd מפענח את סימני האחוז הבודדים לפני ש-for מתחילה, והשורה מתפרקת.
  3. מופיעה שגיאת תחביר, ואף תיקייה לא נוצרת.
  4. התיקון: %%u בשני המקומות, גם אחרי for וגם אחרי md.
טעויות נפוצות
  • בתוך קובץ batch, %1 מחזיק את שם הקובץ. שם הקובץ הוא %0. %1 הוא הארגומנט הראשון שנכתב אחריו.
  • משתנה של for נכתב עם אחוז אחד, גם בחלון וגם בקובץ. בקובץ batch כותבים %%c. אחוז אחד מתאים רק לשורת הפקודה.
  • עם אחוז בודד בקובץ, cmd פשוט ידפיס את הטקסט %c כמו שהוא. cmd מפענח את סימני האחוז, השורה נשברת ומודפסת שגיאת תחביר.
  • קובצי batch לא תומכים ב-for, ולכן cmd מדלג על השורה. for עובדת היטב בקבצים, בתנאי שהמשתנה כתוב עם שני סימני אחוז.
  • if errorlevel 1 מתקיים רק כשהקוד שווה בדיוק ל-1. הוא מתקיים לכל קוד יציאה של 1 ומעלה.
בדקו את עצמכם
בקובץ report.bat כתוב @echo off ואחריו echo %0 got %2. מה יודפס בהרצה report.bat north south?

report.bat got south. %0 הוא שם הסקריפט כפי שהוקלד, ו-%2 הוא הארגומנט השני.

בסקריפט, findstr לא מצאה את המחרוזת. האם השורה if errorlevel 1 echo missing תדפיס משהו?

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

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

cmd או PowerShell

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

השאלהב-cmdב-PowerShell
סקריפט .bat בן עשר שנים: ירוץ בלי שינוי?כן, זו סביבת הבית שלולא בהכרח; לא כל דבר מתנהג אחד לאחד
איך תופסים כישלון?בודקים את ERRORLEVELעוטפים ב-try/catch
מה הפקודה הבאה מקבלת מהקודמת?שורות טקסטאובייקטים של .NET עם מאפיינים
אפשר לשלב רכיבי .NET ולטעון DLL מנוהלת?לאכן, זו יכולת מובנית
כמה צריך ללמוד כדי להתחיל?מעט: תחביר פשוט ומוכריותר: השפה עשירה וגם מסובכת יותר

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

ויש דברים שאף אחד לא צריך לצפות מ-cmd: התקנה או החלפה של גרסאות .NET Framework לא נעשית דרכו, ותוכנות של Linux הוא לא יודע להפעיל.

טעויות נפוצות
  • צריך לעבד אובייקטים של .NET? cmd הוא הכלי לזה. cmd מכיר רק טקסט. עבודה עם אובייקטים היא בדיוק היתרון המרכזי של PowerShell.
  • cmd עדיף כשרוצים לתפוס שגיאות ב-try/catch. ב-cmd אין try/catch בכלל; שם בודקים את ERRORLEVEL.
בדקו את עצמכם
צוות תפעול מריץ כל בוקר כ-200 קובצי .bat שנכתבו לפני שנים, וצריך לשנות בכל אחד מהם נתיב אחד. האם זו סיבה להמיר את כולם ל-PowerShell?

לא. cmd ימשיך להריץ את הקבצים בדיוק כמו תמיד, ואפשר לערוך את השורה ולהשאיר אותם batch. המרה הייתה מוצדקת רק אם היה צורך ביכולות של PowerShell.

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

ב-PowerShell. טעינת DLL מנוהלות ו-try/catch קיימות בה, וב-cmd אין לאף אחת מהן תמיכה.

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

סיכום

השכבות של Windows, מלמטה ועד ה-API:

  • תוכניות רצות במצב משתמש, והליבה, ntoskrnl.exe, רצה במצב ליבה. המעבר ביניהן הוא קריאת מערכת (syscall).
  • WinAPI הוא אוסף פונקציות C ש-Windows מציעה לתוכניות, מחולק לפי DLL: kernel32.dll לקבצים ולתהליכים, user32.dll לחלונות ול-MessageBox, gdi32.dll לציור ו-advapi32.dll ל-Registry ולאבטחה.
  • לפונקציות שמקבלות מחרוזות יש בדרך כלל זוג: סיומת A למחרוזות ANSI וסיומת W ל-Unicode, עם אותה עבודה בדיוק.
  • HANDLE הוא ערך אטום, רשומה בטבלת ה-Handles של התהליך שמייצגת אובייקט ליבה. בסיום משחררים אותו עם CloseHandle.
  • בכישלון CreateFile מחזירה INVALID_HANDLE_VALUE, כלומר -1, ורוב הפונקציות האחרות מחזירות NULL. את הסיבה שואלים מ-GetLastError, מיד אחרי הקריאה ובאותו thread.
  • CreateProcess פותחת תהליך חדש ו-CreateThread מוסיפה thread לתהליך קיים; ל-fork אין כאן מקבילה. Mutex, Event ו-Semaphore מתאמים גישה, ונתונים עוברים בין תהליכים בזיכרון משותף או ב-Pipes.
  • קריאה חוסמת מחכה לתוצאה, וקריאה לא חוסמת חוזרת מיד. ERROR_IO_PENDING אומר שהפעולה עדיין בדרך, לא שהיא נכשלה.

ntdll.dll והדרך אל הליבה:

  • ntdll.dll יושבת בתחתית מצב המשתמש, מתחת לכל ה-DLL האחרות. כל תהליך טוען אותה, ובה נמצאים ה-Native API (פונקציות Nt ו-Zw) וקטעי הקוד שמבצעים את ה-syscall.
  • קריאה עוברת מ-kernel32.dll או kernelbase.dll אל ntdll.dll, ומשם ב-syscall אל ntoskrnl.exe. גם קוד .NET מגיע לליבה באותה דרך.
  • החלפה של ntdll.dll פוגעת בכל התהליכים בבת אחת. כלי אבטחה מציבים בה hooks כדי לראות קריאות, ותוכנות זדוניות מנסות לעקוף אותם בקריאת מערכת ישירה.

ספריות DLL:

  • DLL נטענת לתוך התהליך בזמן ריצה, וכמה תוכניות חולקות אותה. התוצאה: פחות זיכרון, ואפשר להחליף רכיב בלי לבנות מחדש את כל התוכנה.
  • שתי דרכים לטעון: דרך טבלת הייבוא, אוטומטית בעליית התוכנית, ואז ספרייה חסרה עוצרת את העלייה; או בקוד, עם LoadLibrary, GetProcAddress ו-FreeLibrary, ואז ספרייה חסרה מתבטאת ב-NULL שאפשר לטפל בו.
  • הקישור לפונקציה נעשה לפי השם שלה. אם מישהו שינה את הפרמטרים ושמר על השם, הטוען לא ישים לב, והתוכנית תחשב ערכים שגויים או תקרוס.
  • כשתוכנות שונות דרשו גרסאות שונות של אותה DLL נוצר DLL Hell. הפתרון של Windows הוא Side-by-Side, עם מאגר WinSxS שמחזיק כמה גרסאות זו לצד זו.
  • מי שקורא ל-LoadLibrary עם שם קובץ בלבד משאיר לסדר החיפוש להחליט איזו DLL תיטען, וזה הבסיס ל-DLL search order hijacking. מגינים בנתיב מלא, ברשימת KnownDLLs ובהפעלה של Safe DLL Search Mode.

.NET Framework וה-CLR:

  • .NET Framework היא CLR ועוד ספריית מחלקות, לשפות כמו C#, VB.NET ו-F#. היא רצה רק על Windows, הגרסה האחרונה שלה היא 4.8.x, וההמשך שלה הוא .NET 5 ומעלה.
  • Assembly מכילה IL ו-Metadata. ה-GAC מאפשר לכמה תוכניות לשתף Assemblies בעלות שם חזק, גם בכמה גרסאות במקביל. רכיבי COM נרשמים ב-Registry ומנהלים את חייהם בספירת הפניות.
  • ה-CLR טוען Assemblies ומתרגם ב-JIT את ה-IL לקוד מכונה של המעבד שעליו התוכנית רצה. ה-Garbage Collector שלו מסמן אובייקטים חיים החל מהשורשים, ולכן משחרר גם מבנים מעגליים, ובנוסף הוא אוכף בטיחות טיפוסים ובדיקות גבולות ומנהל חריגות.
  • חריגה מטפסת במחסנית הקריאות עד ה-catch המתאים הראשון, ואם אין כזה התוכנית נסגרת. כדי לתעד חריגות שלא נתפסו עוטפים את Main ב-try-catch ונרשמים ל-AppDomain.UnhandledException; מתחת לכל זה ה-CLR נשען על SEH.
  • P/Invoke מאפשר לקוד מנוהל לקרוא ל-DLL של native בעזרת DllImport ו-Marshalling. ה-CLR לא מאמת שהחתימה שהצהרתם נכונה, ושחרור משאבים לא מנוהלים נשאר באחריותכם.

שורת הפקודה:

  • cmd מפרש שורות: מה שמובנה בו, כמו set, echo, cd ו-dir, רץ מיד; לשם כמו tasklist הוא מחפש קובץ, קודם בתיקייה שבה אתם ואחר כך לאורך PATH.
  • קוד היציאה של הפקודה הקודמת יושב ב-%ERRORLEVEL%, הקבצים הזמניים של המשתמש ב-%TEMP%, ותיקיית Windows ב-%SystemRoot% (על רוב המחשבים C:\Windows).
  • בתוך קובץ batch, לולאת for כותבת את המשתנה שלה עם שני אחוזים (%%i), %1 הוא הארגומנט הראשון ו-%0 הוא שם הסקריפט.
  • לתחזוקה של קובצי .bat ותיקים בוחרים ב-cmd; לאובייקטים, לרכיבי .NET ולטיפול בשגיאות ב-try/catch בוחרים ב-PowerShell.