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.
לא נדרש ידע מוקדם מעבר להיכרות עם המושגים תוכנית, קובץ ותיקייה, ועם העובדה שמחשב מריץ כמה תוכניות בו בזמן.
מצב משתמש ומצב ליבה: שתי רמות ההרשאה ומה שמחבר ביניהן
שתי רמות ההרשאה של המעבד
נפתח בניסוי. התוכנית הבאה היא תהליך (Process) רגיל, כמו כל תוכנית שנמצאת בריצה, והיא מבקשת מהמעבד לבצע את cli, הוראה שמכבה פסיקות:
#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 0xC0000096Windows קטעה את התוכנית עם חריגה 0xC0000096, הוראה מוגנת (STATUS_PRIVILEGED_INSTRUCTION). לפני כל הוראה רגישה המעבד בודק באיזו רמת הרשאה רץ הקוד ששלח אותה, ויש לו שתיים כאלה. הקוד שלנו רץ ברמה הנמוכה, ולכן נעצר.
| רמה | מי רץ בה | מה מותר בה |
|---|---|---|
| מצב משתמש (User Mode) | כל התוכניות הרגילות: עורך טקסט, משחק, דפדפן, שירות רקע או תוכנית C# שכתבתם | רק הזיכרון של התהליך עצמו. אין גישה ישירה לחומרה, לדיסק או לזיכרון של תהליך אחר |
| מצב ליבה (Kernel Mode) | הגרעין של Windows, הקובץ ntoskrnl.exe, וגם מנהלי ההתקן (Drivers) | גישה מלאה לחומרה, לכל הזיכרון ולכל המשאבים |
גם תהליך שהופעל כמנהל היה נעצר באותה נקודה. 'מנהל' הוא הרשאה ש-Windows נותנת למשתמש, ואילו רמת ההרשאה של הקוד נאכפת בחומרה של המעבד, ולכן גם תהליך כזה אינו מגיע לבדו לדיסק, לכרטיס הרשת או לזיכרון של תהליך שכן.
אז איך תוכנית כן קוראת קובץ? כמו לקוח בבנק: הוא אינו נכנס לכספת, אלא ניגש לאשנב, ורק לאשנב, וממלא טופס. האשנב הוא נקודת כניסה שהבנק קבע, ואין ללקוח דלת אחרת לבחור בה.
במחשב, הטופס הוא קריאת מערכת (System Call), והאשנב הוא כתובת קבועה בליבה. הוראת מעבד מיוחדת קופצת לשם ומעלה את רמת ההרשאה באותו צעד, כך שהקוד הראשון שרץ ברמה הגבוהה הוא תמיד של הליבה.
מאחורי האשנב יושב הפקיד: הליבה מוודאת שלמבקש מותר, למשל שיש לו גישה לקובץ, מבצעת ומחזירה תשובה לתוכנית. כל דרך אל משאב של המערכת עוברת בבדיקה הזו.
כדי שהשמירה תהיה שלמה, Windows מבודדת גם את הזיכרון. כל תהליך מקבל מרחב כתובות (Address Space) משלו, ומה שתהליך אחד מוצא בכתובת מסוימת אינו מה שתהליך אחר מוצא בה.
טעויות נפוצות
- תוכנית C שקוראת ישירות לפונקציות של Windows, בלי .NET באמצע, רצה ברמת הליבה. הקוד של התוכנית, וגם הקוד של הספריות שהיא קוראת להן, רץ כולו במצב משתמש. רק ברגע של קריאת מערכת המעבד עובר לליבה, ובסיומה חוזר.
- תהליך מתוחכם מספיק יכול לדבר עם החומרה בעצמו, אם רק ידלג על הליבה. המעבד חוסם במצב משתמש את ההוראות והגישות המוגנות, כמו שראיתם עם
cli. הדרך היחידה אל החומרה היא לבקש מהליבה.
מפת השכבות: מהקוד שלכם ועד הליבה
את רוב הפרק אפשר לתלות על תרשים אחד. כל חץ בו פירושו 'קורא ל'.
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.
בדקו את עצמכם
באיזו רמת הרשאה רץ הקוד של 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.
ואילו הייתה זו תוכנית קונסול בלי חלון, או שירות שרץ ברקע, היא הייתה משתמשת באותו ממשק בדיוק. אין גרסה נפרדת לכל סוג תוכנית.
פונקציות שכדאי להכיר בשם:
| פונקציה | תפקיד |
|---|---|
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 וטעינת DLL | CreateFile, ReadFile, CreateProcess, CreateThread, VirtualAlloc, LoadLibrary |
user32.dll | ממשק המשתמש: חלונות, תיבות דו-שיח, הודעות, קלט ממקלדת ומעכבר | MessageBox, CreateWindowEx, DestroyWindow |
gdi32.dll | ציור: קווים, צורות, טקסט וגופנים | LineTo, TextOut |
advapi32.dll | Registry, אבטחה ושירותים | RegOpenKeyEx, RegSetValueEx, OpenProcessToken |
kernel32.dll היא כיום בעיקר שער: ברוב הפונקציות שלה הקוד עצמו נמצא ב-kernelbase.dll, ש-Windows פיצלה ממנה בגרסאות החדשות. השם הישן נשמר כדי שתוכניות ותיקות ימצאו את מה שהן מחפשות.
אפשר לבדוק את החלוקה בעצמכם. התוכנית הבאה שואלת כל אחת מארבע הספריות אם היא מייצאת שם מסוים, ומדפיסה ליד כל פונקציה את הספריות שענו בחיוב:
#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.
תרחיש 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 מכירה שני ייצוגים של טקסט, ולכן לכל פונקציה כזו יש זוג גרסאות עם אותו שם וסיומת שונה.
| סיומת | משמעות | סוג המחרוזת | דוגמאות |
|---|---|---|---|
| A | ANSI | char, בקידוד שנקבע לפי דף הקוד (Code Page) הפעיל: תו בבית אחד ברוב השפות, ועד שני בתים לתו בדפי הקוד של סינית, יפנית וקוריאנית | MessageBoxA, CreateFileA |
| W | Wide, כלומר Unicode | wchar_t, תווים 'רחבים' (שני בתים ב-Windows) | MessageBoxW, CreateFileW |
הפעולה, ה-DLL והתמיכה ב-32 וב-64 סיביות זהים בשני בני הזוג. מה שמפריד ביניהם הוא רק סוג המחרוזות שמועבר בפרמטרים.
בקוד C ו-C++ כותבים לרוב את השם בלי סיומת. MessageBox ו-CreateFile הם מאקרו בקובצי הכותרת, והקומפיילר מחליף אותם בגרסת A או W לפי השאלה אם הוגדר הסמל UNICODE. המאקרו TEXT והטיפוס TCHAR עובדים באותו עיקרון.
התוכנית הבאה הודרה פעמיים, פעם בלי הגדרה ופעם עם -DUNICODE:
#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;
}gcc aw.c -o aw_ansi.exe && ./aw_ansi.exe
gcc -DUNICODE aw.c -o aw_wide.exe && ./aw_wide.exeUNICODE 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 בתים כמחרוזת רחבה.
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 עובד בדיוק כך.
התוכנית הבאה פותחת קובץ, כותבת אליו שורה, וסופרת לאורך הדרך כמה 'כרטיסים' כאלה התהליך מחזיק:
#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, וזה כל מה שהיא מספרת.
#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.
| סוג הפונקציה | מה היא מחזירה כשהיא נכשלת |
|---|---|
CreateFile | INVALID_HANDLE_VALUE, שערכו המספרי הוא -1 |
רוב שאר פונקציות ה-Create, כמו CreateThread ו-CreateEvent, וגם LoadLibrary | NULL |
פונקציות שמחזירות BOOL, כמו ReadFile | FALSE |
פונקציות ה-Registry, כמו RegOpenKeyEx | את קוד השגיאה עצמו, ישירות בערך ההחזרה |
GetLastError קוראת תא ששמור ל-thread שקרא לה, ולכן ה-thread הנוסף, שנכשל בעצמו, קיבל 3 מהתא שלו ולא את ה-2 של ה-thread הראשי. thread אחר לעולם אינו רואה את הקוד שלכם.
אבל התא אינו כספת. כל קריאה ל-WinAPI אחרי הכישלון רשאית לכתוב בו, כולל קריאות שהצליחו: בחלק על סנכרון תראו CreateMutexW שהצליחה ובכל זאת השאירה בתא 183. לכן בודקים קודם את ערך ההחזרה, ורק כשהוא מסמן כישלון שולפים את הקוד, מיד ובאותו thread, אל משתנה.
זה התפקיד של saved בדוגמה. השורה שאחרי הכישלון השני מראה מה קורה לתא עצמו: 3 החליף את 2.
פונקציות ה-Registry נוהגות אחרת, ולכן אצלן בודקים את ערך ההחזרה עצמו:
#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| קוד | קבוע | משמעות |
|---|---|---|
| 2 | ERROR_FILE_NOT_FOUND | הקובץ (או מפתח ה-Registry) לא נמצא |
| 3 | ERROR_PATH_NOT_FOUND | תיקייה בנתיב אינה קיימת |
| 5 | ERROR_ACCESS_DENIED | אין הרשאת גישה |
| 126 | ERROR_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 עם פקודה קצרה, מחכה לו וקורא את קוד היציאה שלו:
#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 2CreateProcessW הקימה תהליך חדש, טענה לתוכו את 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 ראשון | מרחב כתובות חדש ונפרד |
CreateThread | thread נוסף בתהליך הקיים | אותו מרחב כתובות, משותף לכל ה-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:
#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 פותרת זאת באובייקטי סנכרון:
| אובייקט | פונקציות | מה הוא נותן |
|---|---|---|
| Mutex | CreateMutex, WaitForSingleObject, ReleaseMutex | מנעול בלעדי: בכל רגע רק thread אחד מחזיק בו, ומי שמבקש אחריו ממתין |
| Event | CreateEvent, SetEvent, WaitForSingleObject | אות: thread אחד מודיע שמשהו קרה, וה-threads שחיכו לאות ממשיכים |
| Semaphore | CreateSemaphore, ReleaseSemaphore | מונה: עד N threads מחזיקים בו במקביל, והבא בתור ממתין |
| Critical Section | EnterCriticalSection, LeaveCriticalSection | מנעול מהיר שפועל רק בין threads של אותו תהליך |
שלושת הראשונים הם אובייקטי ליבה, ולכן מקבלים עליהם HANDLE. Critical Section הוא מבנה רגיל בזיכרון של התהליך, בלי HANDLE, ולכן אינו משמש בין תהליכים.
כשנותנים לאובייקט ליבה שם, כל תהליך באותו מחשב שפותח את השם מגיע לאותו אובייקט, וכך Mutex אחד מסנכרן כמה תהליכים. הנה אותו מונה, הפעם מוגן ב-Mutex בעל שם:
#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) כדי לדווח על כך. והפעם הספירה מדויקת: שני מיליון.
תרחיש 4: שתי קופות ומדפסת קבלות אחת
בחנות, שני עובדים מחוברים לאותו מחשב קופה בשני חשבונות Windows נפרדים, ובכל חשבון רץ מופע של תוכנת הקופה. שני המופעים כותבים קבלות לאותו קובץ תור של המדפסת, ומדי פעם יוצאת קבלה שחציה שייך ללקוח אחר.
הפתרון הוא Mutex בעל שם, Global\ReceiptQueue. הקידומת Global\ שמה את השם במרחב שמות שמשותף לכל הסשנים במחשב, ובלעדיה כל סשן היה מקבל Mutex נפרד. ושם של אובייקט ליבה תקף רק בתוך מחשב אחד: שתי קופות על שני מחשבים לא היו מסתנכרנות כך.
- כל מופע קורא ל-
CreateMutexWעם השם הזה ומקבלHANDLEלאותו אובייקט. - לפני כתיבת קבלה הוא ממתין ב-
WaitForSingleObjectעד שה-Mutex עובר לחזקתו. - אחרי הכתיבה הוא קורא ל-
ReleaseMutex, והמופע השני, אם חיכה, נכנס.
שימו לב מה ה-Mutex עשה ומה לא. הוא לא העביר אף קבלה: הקבלות עדיין עוברות דרך הקובץ, וכשרוצים להעביר נתונים בין תהליכים משתמשים בזיכרון משותף או בצינור (Pipe). הוא גם לא קבע איזה מופע ירוץ קודם: על כך מחליט המתזמן לפי עדיפויות, וה-Mutex רק השאיר את המופע השני ממתין.
טעויות נפוצות
- משתנה
bool busyמשותף עושה את העבודה של Mutex. קריאת הדגל וכתיבתו הן צעדים נפרדים, ושני threads יכולים לעבור את הבדיקה יחד. Mutex מבטיח שהתפיסה היא פעולה אחת, ומספק גם המתנה. - Event ו-Mutex משמשים להעברת נתונים בין תהליכים. הם רק מתאמים את התזמון של הגישה. את הנתונים עצמם מעבירים בזיכרון משותף או ב-Pipe.
- אובייקט סנכרון קובע באיזה סדר המעבד יריץ את ה-threads. המתזמן ממשיך להחליט מי רץ. האובייקט רק גורם ל-thread שאינו יכול להמשיך לחכות.
קריאה חוסמת וקריאה לא חוסמת
התוכנית הבאה מקימה צינור בעל שם (Named Pipe), מתחברת אליו כלקוח, ומבקשת לקרוא ממנו לפני שמישהו כתב בו משהו:
#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 על שלושה שמות:
#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: nontdll.dll היא השורה הראשונה אחרי התוכנית עצמה, עוד לפני kernel32.dll: היא ממופה לתהליך לפני כל ספרייה אחרת, והיא ה-DLL הנמוכה ביותר במצב משתמש. במחשב אחר, או עם ספריית זמן ריצה אחרת של C, ייתכן שיופיעו מודולים נוספים (למשל apphelp.dll) או msvcrt.dll במקום ucrtbase.dll, אבל ntdll.dll תמיד ראשונה.
התוכנית הזו לא הורצה כמנהל, ואינה שירות. כלומר אין צורך בהרשאות מיוחדות או בסוג מיוחד של תהליך: כל תהליך רגיל במצב משתמש מקבל אותה.
ומה עם תוכנית מנוהלת? הנה תוכנית 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 בשם התוכנית.
טעויות נפוצות
- ntdll.dll קיימת רק בתהליכי מערכת ובשירותים. כל תהליך במצב משתמש טוען אותה, כולל התוכנית הקטנה שבדוגמה.
- בתהליך .NET אין ntdll.dll, כי ה-CLR מטפל בהכול. תהליך .NET הוא תהליך Windows רגיל. תוכנית ה-C# בדוגמה מצאה את ntdll.dll בין המודולים שלה.
- רק תהליך שהורץ כמנהל מקבל את ntdll.dll. ההרשאות אינן משנות כאן דבר: גם תהליך של משתמש רגיל טוען אותה.
- ntdll.dll רצה בליבה, כחלק מ-ntoskrnl.exe או כמנהל התקן. זו DLL של מצב משתמש שממופה לכל תהליך. הליבה נמצאת מעבר לקריאת המערכת שהיא מבצעת.
- ntdll.dll אחראית לטעון מנהלי התקן בזמן האתחול, או לנהל את תעבורת הרשת. היא מעבירה בקשות לליבה ומספקת לתהליך קוד טעינה, ערימה ופונקציות עזר. מנהלי התקן ורשת הם עניין של הליבה.
הדרך של CreateFile עד הליבה וחזרה
נלווה תוכנית C שפותחת קובץ בשם invoices.db, ונראה מי מטפל בבקשה בכל שלב.
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:
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: ה-CLR, כמו כל תוכנית, קורא לפונקציית WinAPI, כאן
VirtualAlloc. - שלבים 2 ו-3:
VirtualAllocמכינה את הבקשה ומעבירה אותה ל-NtAllocateVirtualMemory. - שלב 4: ntdll.dll מבצעת
syscall. - שלב 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, ומי שלא עובר בקוד הזה אינו נתקל בו |
טעויות נפוצות
- אם תוכנית אחת מחליפה את 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 רצה כתהליך נפרד ומדברת עם התוכנה דרך צינורות (Pipes). היא נטענת לתוך התהליך הקורא ורצה בתוכו, בלי תהליך משלה ובלי ערוץ תקשורת בין תהליכים.
- DLL נטענת לזיכרון בזמן ההתקנה ונשארת שם עד שמסירים את התוכנה. היא נטענת כשתהליך זקוק לה, ומשתחררת כשאין בה עוד צורך; היא אינה תושבת קבע בזיכרון.
- קוד ה-DLL מוטמע בכל exe כבר בזמן ההידור. זו ההגדרה של ספרייה סטטית. ב-DLL החיבור קורה בזמן ריצה, והקוד נשאר בקובץ חיצוני.
- רק תוכנה אחת יכולה להחזיק DLL בכל רגע, והשאר ממתינות בתור. השיתוף בו-זמני בין תהליכים הוא היתרון המרכזי של המנגנון, לא מגבלה.
- DLL היא קובץ הגדרות של קבוצת משתמשים, או יישום גרפי שרץ לבד. היא ספריית קוד שנטענת לתוך תהליך אחר; היא אינה קובץ קונפיגורציה ואינה אפליקציה עצמאית.
שתי דרכים לטעון: מרומזת ומפורשת
יש שתי דרכים עיקריות לחבר DLL לתוכנית, והן נבדלות ברגע שבו הקובץ נטען.
טעינה מרומזת (Implicit Linking) מתחילה כבר בבנייה. המקשר (Linker) משאיר בקובץ ה-exe טבלת ייבוא (Import Table), שמפרטת לכל DLL אילו פונקציות נדרשות ממנה. כשמפעילים את התוכנית, הטוען עובר על הטבלה, ממפה כל DLL שמופיעה בה ומציב את כתובות הפונקציות, וכל זה מסתיים לפני ש-main מתחיל; את הפונקציות הוא מזהה לפי שם או מספר סידורי (Ordinal), ואין לו מושג אילו סוגי פרמטרים הן מצפות לקבל.
#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 והפונקציה:
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 של התהליך, אלא פשוט הכתובת שבה הספרייה מתחילה בזיכרון.
#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) | רק כשהקוד מגיע לקריאת LoadLibrary | LoadLibrary מחזירה 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. היא פוגעת בכל תהליך שטוען אותה, כולל תוכנות מערכת.
סדר חיפוש DLL וחטיפתו (DLL search order hijacking)
אם בקריאה ל-LoadLibrary נמסר שם קובץ חשוף בלי נתיב, נותר ל-Windows לאתר אותו בעצמה. היא סורקת רשימת תיקיות בסדר קבוע, ועוצרת על ההתאמה הראשונה שהיא מוצאת.
כך נראית שרשרת החיפוש הבסיסית, בגרסה מפושטת, כשמצב החיפוש המאובטח (Safe DLL Search Mode) דולק כברירת מחדל:
- התיקייה שממנה נטענה התוכנית.
- תיקיית המערכת,
C:\Windows\System32. - תיקיית Windows,
C:\Windows. - התיקייה הנוכחית.
- התיקיות שמופיעות במשתנה הסביבה PATH.
החולשה נובעת מהסדר עצמו, וכאן היא מתוארת ברמת הרעיון בלבד. אם למישהו יש הרשאת כתיבה לאחת התחנות הראשונות ברשימה, למשל תיקיית התוכנית (שלב 1), מספיק שיניח שם קובץ בשם שהתוכנית מחפשת, והטוען יעצור עליו לפני שיגיע לקובץ האמיתי.
מה שמתקבל הוא קוד זר שרץ בתוך התהליך הזה, בדיוק עם ההרשאות שהתהליך כבר מחזיק ולא יותר. בסקירת קוד מחפשים את הסימן המובהק: קריאה ל-LoadLibrary עם שם קובץ בלבד.
כל אחת משלוש ההגנות סוגרת חלק אחר בשרשרת:
| הגנה | מה היא עושה לשרשרת |
|---|---|
נתיב מלא ב-LoadLibrary | מבטלת את השרשרת כולה: אין חיפוש, ולכן אין תחנה שאפשר להניח בה קובץ |
| KnownDLLs | רשימה ב-Registry של DLL מערכת חשובות; עבורן Windows הולכת ישר ל-System32 ומדלגת על כל שאר השלבים |
| Safe DLL Search Mode | הוא הסיבה שהתיקייה הנוכחית נמצאת בשלב 4, אחרי תיקיות המערכת; בלעדיו היא נבדקת מוקדם הרבה יותר |
הפונקציה load_system_dll שלהלן מממשת את ההגנה הראשונה: היא מרכיבה את הנתיב מתוך GetSystemDirectoryW, ולכן הטוען לא מחפש בשום תיקייה.
#include <windows.h>
#include <stdio.h>
// Build the full path, so the loader does not search any folder.
HMODULE load_system_dll(const wchar_t *name)
{
wchar_t path[MAX_PATH];
UINT n = GetSystemDirectoryW(path, MAX_PATH); // C:\Windows\system32
if (n == 0 || n + 1 + lstrlenW(name) >= MAX_PATH) return NULL;
lstrcatW(path, L"\\");
lstrcatW(path, name);
return LoadLibraryW(path);
}
int main(void)
{
wchar_t where[MAX_PATH];
HMODULE mod = load_system_dll(L"version.dll");
if (mod == NULL) { printf("load failed: %lu\n", GetLastError()); return 1; }
GetModuleFileNameW(mod, where, MAX_PATH);
wprintf(L"loaded from: %ls\n", where);
FreeLibrary(mod);
return 0;
}loaded from: C:\Windows\system32\version.dllטעויות נפוצות
- DLL שנטענה כך תקבל הרשאות SYSTEM. DLL רצה עם ההרשאות של התהליך שטען אותה, לא עם הרשאות גבוהות יותר.
- הטעינה תמיד מתבצעת מ-System32, ולכן אין סכנה. החיפוש עובר על כמה תיקיות, ותיקיית התוכנית נבדקת לפני System32; כתיבה ל-System32 עצמה דורשת הרשאות מנהל.
- קריאה כזאת עוקפת את UAC. ה-DLL מקבלת רק את ההרשאות שכבר יש לתהליך, ואינה מעלה אותן.
בדקו את עצמכם
תוכנה יושבת בתיקייה שפתוחה לכתיבה לכל משתמש, ומריצה LoadLibrary("vault.dll") ללא נתיב. במה הסכנה, ומה הפתרון?
התיקייה של התוכנה היא התחנה הראשונה בחיפוש, ולכן משתמש כלשהו יכול לשתול בה vault.dll משלו שייטען לפני המקורי. הפתרון כפול: לנקוב בנתיב מלא בקריאה, ולהעביר את ההתקנה לתיקייה שהכתיבה אליה שמורה למנהלים בלבד.
.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.
Report.cs --(C# compiler, build time)--> Report.exe (IL + metadata)
Report.exe --(CLR JIT, run time)---------> machine code for this CPUאפשר לראות זאת מתוך התוכנית עצמה. הקוד הבא בודק מה בעצם יושב בקובץ ה-exe שלו:
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?
csc -nologo -platform:x86 -out:Inspect32.exe Inspect.cs
Inspect32.exeCLR 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 רגיל אפשר לראות את שתי המשפחות זו לצד זו, כתיקיות נפרדות:
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 קלאסית של Win32 | Assembly מנוהלת |
|---|---|---|
| מה יש בתוך הקובץ? | הוראות מכונה של משפחת מעבדים אחת | 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:
dir /b C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Xml
dir /b C:\Windows\assembly\GAC_MSIL\System.Xmlv4.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 כדי לרוץ.
| היבט | רכיב COM | Assembly של .NET |
|---|---|---|
| איך המערכת מוצאת את הקוד | מחפשת את ה-CLSID ב-Registry, ומשם מגיעה לקובץ | הקובץ מתאר את עצמו ב-Metadata; Assembly שיושבת בתיקיית היישום לא צריכה שום רישום |
| כמה גרסאות אפשר להחזיק | קשה להחזיק יותר מאחת, כי לכל מחלקה יש רישום יחיד | כמה, כי השם החזק כולל גרסה, וה-GAC מחזיק אותן במקביל |
| מי מחליט מתי אובייקט מת | מונה ההפניות, שמתעדכן ידנית ב-AddRef וב-Release | ה-Garbage Collector של ה-CLR |
| האם צריך CLR | לא | כן |
טעויות נפוצות
- המילה 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. להבדיל ממהדר, שסיים את עבודתו בבנייה, הוא נוכח ופעיל לכל אורך חיי התוכנית. אפשר לדמות אותו למנהל סמוי שמטפל בכל מה שהמתכנת לא רוצה לכתוב בעצמו.
הדרך הקלה לראות את התפקידים שלו היא לעקוב אחרי הרצה אחת של תוכנית:
- בהפעלה, ה-CLR מאתר וממפה את ה-Assemblies שהתוכנית צריכה.
- כשמתודה מופעלת לראשונה, ה-JIT שלו הופך את ה-IL שלה לקוד מכונה.
- בכל
newהוא מקצה מקום לאובייקט, ובהמשך ה-Garbage Collector מפנה אובייקטים שאיש לא מגיע אליהם. - בכל גישה למערך או המרת טיפוס הוא מוודא שהפעולה חוקית: אינדקס בטווח, טיפוס מתאים.
- כשמשהו משתבש, הוא זורק חריגה ומחפש לה מטפל.
מהרשימה רואים שה-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 חסין בדיוק לתקלה הזו. מכיוון שהוא שואל 'האם אפשר להגיע לכאן מהשורשים' ולא 'כמה מצביעים יש כאן', מעגל מבודד פשוט לא יסומן, וייאסף.
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 = FalseRoom ו-Key מצביעים זה על זה, וזו בדיוק התבנית שספירת הפניות הייתה נתקעת בה: מונה של 1 אצל כל אחד לנצח. אצל ה-GC, ברגע שהמשתנים המקומיים של BuildPair נעלמו, שום שורש לא מוביל לזוג.
ה-WeakReference רק עוקב אחרי Room בלי להאריך את חייו, ולכן אחרי GC.Collect הוא מדווח False: הזוג כולו נאסף.
גבול האחריות של ה-GC. תחום הטיפול שלו הוא אך ורק זיכרון מנוהל. דברים חיצוניים, למשל Handle של קובץ או חיבור פתוח למסד נתונים, אינם משתחררים מעצמם: סוגרים אותם במפורש ב-Dispose או Close, וב-C# בלוק using דואג לכך בסוף הבלוק:
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): אסור להעמיד פנים שאובייקט מסוג מסוים הוא מסוג אחר, ואסור לקחת מספר כלשהו ולהתייחס אליו ככתובת בזיכרון. על זה הוא מוסיף בדיקת גבולות של מערכים תוך כדי ריצה.
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 האירוע הזה כבר אינו בולם את סיום התהליך; הוא נותן רק הזדמנות אחרונה לתעד.
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.
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 גם אינו מאפס או מתקן את החלק שלא תואם: מה שהוצהר, זה מה שעובר.
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.
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 של הפונקציה בתוך בלוק unsafe | unsafe רק מתיר מצביעים בתוך C#; הוא לא מהדר שפה אחרת |
| לאתר את הפונקציה ב-Reflection | Reflection עובד על טיפוסים מנוהלים, ול-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 מצביע על המפרש עצמו:
echo %ComSpec%C:\Windows\system32\cmd.execonhost.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 מחפש קובץ לפי שם: לפקודה חיצונית הוא מוצא קובץ, ולפנימית לא.
where dir
where tasklistINFO: Could not find files for the given pattern(s).
C:\Windows\System32\tasklist.exeכשהשם לא נמצא בין הפקודות הפנימיות, מתחיל חיפוש של קובץ הרצה, בסדר הזה:
- התיקייה שבה אתם נמצאים כרגע.
- התיקיות שרשומות במשתנה
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 שום השלמה.
vol /?Displays the disk volume label and serial number, if they exist.
VOL [drive:]תרחיש 13: מה עובר על cmd כשמקלידים chcp
אתם מקלידים chcp ולוחצים Enter. מאחורי הקלעים:
- cmd בודק ברשימת הפקודות הפנימיות שלו.
chcpלא שם. - הוא מחפש בתיקייה הנוכחית קובץ בשם
chcpעם אחת הסיומות שלPATHEXT, ולא מוצא. - הוא עובר על התיקיות של
PATHלפי הסדר, ובתיקיית System32 נמצאchcp.com. - הקובץ רץ ומדפיס לאותו חלון את דף הקוד (code page) הפעיל.
chcpActive code page: 65001עכשיו מניחים בתיקייה הנוכחית קובץ בשם chcp.bat. התיקייה הנוכחית נבדקת לפני System32, ולכן הקובץ המקומי הוא שירוץ, אף שהכלי האמיתי עדיין קיים:
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:
chcpchcp.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 מאפשר להחליף באותה פקודה גם את הכונן:
cd /d C:\Windows
cd
cd System32
cd
cd ..
cdC:\Windows
C:\Windows\System32
C:\Windowsניתוב פלט: התו > שולח את מה שהפקודה מדפיסה לקובץ במקום למסך, ודורס קובץ קיים; >> מוסיף לסוף הקובץ. הקובץ basics.bat שלהלן יוצר תיקייה, כותב לתוכה יומן קצר ומציג אותו:
@echo off
md reports
cd reports
echo Backup job started > job.txt
echo Copied 12 files >> job.txt
type job.txt
cd ..
dir /b reportsBackup job started
Copied 12 files
job.txtו-vol מספרת על הכונן עצמו, לא על הקבצים שבו:
vol C: Volume in drive C has no label.
Volume Serial Number is 26FC-0E68מי שמגיע מ-Linux או מ-macOS נוטה להקליד מתוך הרגל דברים שלא עובדים כאן:
| ההרגל | מה cmd עושה איתו | מה כותבים במקום |
|---|---|---|
ls | מודיע שאין פקודה כזו. את השם מכירה רק PowerShell, ככינוי (alias) | dir |
pwd | אותה הודעת שגיאה: גם זו פקודה מעולם ה-Unix | cd בלי ארגומנט |
לחפש כתובת 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% | את תיקיית ההתקנה של Windows | C:\Windows |
@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 שלא:
@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! כמו שהוא, אות באות.
@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: 35set /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 קורא את הקובץ מלמעלה למטה ומבצע כל שורה בתורה, בדיוק כאילו הקלדתם אותה ידנית:
@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 vaultScript: 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.
- מריצים
purge.bat cache. - לפני הביצוע cmd מציב את הארגומנט במקום
%1, והפקודה שרצה בפועל היאdel cache\*.bak. - שני קובצי ה-
.bakנמחקים.keep.txtנשאר, וגםpurge.batעצמו, שאליו מפנה%0, לא נפגע.
rem after running purge.bat cache:
dir /b cachekeep.txtלולאות, תנאים וכלים לסקריפטים מורכבים
במשתנה של לולאת for יש הבדל שמפיל הרבה אנשים. בשורת הפקודה כותבים אותו עם אחוז אחד, %c; בתוך קובץ batch חייבים שניים, %%c.
הסיבה היא סדר העבודה. בקובץ, cmd עובר על השורה ומפענח כל % בודד עוד לפני ש-for מתחילה לפעול, כי הוא מניח שזה פרמטר כמו %1 או משתנה כמו %TEMP%. הצמד %% הופך באותו מעבר ל-% אחד, ורק אותו for מקבלת.
rem typed at the prompt:
for %c in (red green) do @echo color %ccolor red
color greenאותה תבנית עם אחוז בודד, הפעם בתוך loop.bat, נשברת עוד לפני הסיבוב הראשון:
@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 reacheds was unexpected at this time.הקטע שבין שני סימני האחוז נבלע כמשתנה שלא קיים, ומה שנשאר הוא תחביר ש-for לא מבינה. cmd מדפיס שגיאת תחביר והלולאה לא רצה; כאן גם השורה שאחריה לא הודפסה, כי השגיאה עצרה את כל הקובץ. עם שני סימני אחוז הכול עובד:
@echo off
rem loop2.bat - the batch file form
for %%s in (north south) do echo %%snorth
southכשהסקריפט צריך לקבל החלטות ולעבד טקסט, אין צורך לעבור ל-PowerShell: ל-cmd יש כלים משלו. נכיר אותם דרך סקריפט אחד.
watch.bat קורא את hosts.txt, שבכל שורה בו שם של שרת ומצבו: web01 up, db02 down, cache03 up. לידו בתיקייה יושב notify.bat, ובו שורה אחת: echo notify.bat ran.
@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 missinghost: 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, ומקבלת שתי תיקיות חדשות.
- היא מעתיקה את השורה כמו שהיא לקובץ
folders.bat. - בהרצה, cmd מפענח את סימני האחוז הבודדים לפני ש-
forמתחילה, והשורה מתפרקת. - מופיעה שגיאת תחביר, ואף תיקייה לא נוצרת.
- התיקון:
%%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.