> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# الخطافات Hooks في Windows: كيف يعترض البرنامج الرسائل
- URL: https://arabroot.io/articles/الخطافات-hooks-في-windows-كيف-يعترض-البرنامج-الرسائل/
- Published: 2026-11-20T14:44:36.000Z
- Updated: 2026-11-20T15:44:45.000Z
- Description: نركب خطافات SetWindowsHookEx على خيوط برنامج C صغير ونوافذه فقط على Windows 11 دون صلاحيات المدير، فنرى ترتيب السلسلة وتغيير الرسائل وحقن المكتبة في عملية أخرى وكلفة الخطاف، ثم نشرح الخطافات العامة وبرامج تسجيل لوحة المفاتيح من جهة الكشف.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, Windows للمسؤولين والمطورين

إذا كنت تكتب برنامجاً مكتبياً لـ Windows، فغالب الظن أنك واجهت يوماً موقفاً لا تجد له تفسيراً في الكود الذي كتبته: اختصار لوحة مفاتيح Keyboard Shortcut يعمل على جهازك ولا يصل إلى برنامجك على جهاز العميل، أو نافذة تتصرف بشكل مختلف عندما يعمل بجانبها برنامج ترجمة فورية أو أداة تسجيل شاشة، أو برنامج يبطئ كل الواجهات في الجهاز ما دام يعمل. وإذا كنت مسؤول أنظمة System Administrator، فقد يصلك سؤال من نوع آخر: «هل على هذا الجهاز برنامج يسجل ما نكتبه؟»، ولا تعرف من أين تبدأ البحث. وهذه المواقف كلها تعود في أغلب الأحيان إلى آلية واحدة قديمة في Windows، موجودة منذ الإصدارات الأولى، وما زالت تعمل في Windows 11، وهي الخطافات Hooks: نقاط يسمح فيها النظام لبرنامج أن يقف في طريق الرسائل Messages قبل أن تصل إلى نافذتها، فيراها أو يغيرها أو يحذفها.

وهذا المقال هو الأول في مرحلة برمجة النظام في Windows، ويأتي بعد مقال [أول برنامج Win32 بلغة C](https://arabroot.io/articles/%D8%A7%D9%88%D9%84-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC-win32-%D8%A8%D9%84%D8%BA%D8%A9-c-%D9%86%D8%A7%D9%81%D8%B0%D8%A9-%D9%88%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D8%B1%D8%B3%D8%A7%D8%A6%D9%84/) الذي شرح حلقة الرسائل Message Loop ودالة النافذة Window Procedure، ومقال [المكتبات المشتركة DLL](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%83%D8%AA%D8%A8%D8%A7%D8%AA-%D8%A7%D9%84%D9%85%D8%B4%D8%AA%D8%B1%D9%83%D8%A9-dll-%D8%A7%D9%84%D8%AA%D8%AD%D9%85%D9%8A%D9%84-%D9%88%D8%AA%D8%B1%D8%AA%D9%8A%D8%A8-%D8%A7%D9%84%D8%A8%D8%AD%D8%AB-%D9%88dll-hell/) الذي شرح كيف تحمل المكتبة في العملية. أما هنا فنقف بين الاثنين: كيف يدخل كود من خارج النافذة في طريق رسائلها، ومتى يحمل النظام مكتبة DLL كتبها برنامج آخر داخل عمليتك دون أن تطلب ذلك. وسوف نعمل كله ببرنامج صغير بلغة C على جهاز Windows 11 حقيقي دون صلاحيات المدير، وعلى خيوط Threads برنامجنا ونوافذه فقط، فلا نلمس أي نافذة أو برنامج آخر على سطح المكتب.

[![](https://arabroot.io/content/images/2026/11/win32-first-window-cover-cover.webp)دليلأول برنامج Win32 بلغة C: نافذة وحلقة الرسائلنكتب نافذة Win32 بلغة C ونسجل كل رسالة تصلها، ثم نجعلها عربية بـ WS\_EX\_LAYOUTRTL ونرى لماذا يعلن Windows بعد خمس ثوان أن البرنامج لا يستجيب.](https://arabroot.io/articles/%D8%A7%D9%88%D9%84-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC-win32-%D8%A8%D9%84%D8%BA%D8%A9-c-%D9%86%D8%A7%D9%81%D8%B0%D8%A9-%D9%88%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D8%B1%D8%B3%D8%A7%D8%A6%D9%84/)[![](https://arabroot.io/content/images/2026/11/dll-explained-cover-cover.webp)دليلالمكتبات المشتركة DLL: التحميل وترتيب البحث وDLL Hellنبني مكتبة DLL صغيرة بأنفسنا ونراقب المحمل وهو يقرأ جداولها ويحملها ويستدعي DllMain، ثم نرى من أين جاء جحيم المكتبات وكيف عزله Windows بالنسخ جنباً إلى جنب.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%83%D8%AA%D8%A8%D8%A7%D8%AA-%D8%A7%D9%84%D9%85%D8%B4%D8%AA%D8%B1%D9%83%D8%A9-dll-%D8%A7%D9%84%D8%AA%D8%AD%D9%85%D9%8A%D9%84-%D9%88%D8%AA%D8%B1%D8%AA%D9%8A%D8%A8-%D8%A7%D9%84%D8%A8%D8%AD%D8%AB-%D9%88dll-hell/)[![](https://arabroot.io/content/images/2026/11/api-hooking-detours-cover-cover.webp)دليلاعتراض الدوال API Hooking مع Detours في Windowsنعترض CreateFileW داخل برنامج C صغير بجدول الاستيراد ثم بمكتبة Detours على Windows 11 دون صلاحيات المدير، ونرى البايتات والترامبولين في cdb، ونقيس الكلفة، ونكشف الاعتراض بمقارنة الذاكرة بالملف، ونفهم لماذا انتقلت برامج الحماية إلى النواة.](https://arabroot.io/articles/%D8%A7%D8%B9%D8%AA%D8%B1%D8%A7%D8%B6-%D8%A7%D9%84%D8%AF%D9%88%D8%A7%D9%84-api-hooking-%D9%85%D8%B9-detours-%D9%81%D9%8A-windows/)[![](https://arabroot.io/content/images/2026/11/etw-tracing-cover-cover.webp)دليلتتبع الأحداث ETW: المصدر الذي تقرأ منه أدوات الحمايةنكتب مزود TraceLogging في برنامج C، ونجمع أحداثه بجلسة logman ثم بجلسة لحظية مع أحداث PowerShell على Windows 11 دون صلاحيات المدير، ونقيس كلفة الحدث، ونرى بالأرقام ما يبقى للمدير والنواة ولماذا تعتمد عليه برامج الحماية.](https://arabroot.io/articles/%D8%AA%D8%AA%D8%A8%D8%B9-%D8%A7%D9%84%D8%A7%D8%AD%D8%AF%D8%A7%D8%AB-etw-%D8%A7%D9%84%D9%85%D8%B5%D8%AF%D8%B1-%D8%A7%D9%84%D8%B0%D9%8A-%D8%AA%D9%82%D8%B1%D8%A7-%D9%85%D9%86%D9%87-%D8%A7%D8%AF%D9%88%D8%A7%D8%AA-%D8%A7%D9%84%D8%AD%D9%85%D8%A7%D9%8A%D8%A9/)[![](https://arabroot.io/content/images/2026/11/win-processes-threads-cover-cover.webp)دليلالعمليات والخيوط وكائنات Job في Windowsنقيس بلغة C على Windows 11 كيف يختار المجدول الخيط الذي يعمل، ولماذا تكفي درجة أولوية واحدة لتجويع برنامج، وكيف تضع كائنات Job سقفاً للمعالج وتنهي شجرة العمليات كلها.](https://arabroot.io/articles/%D8%A7%D9%84%D8%B9%D9%85%D9%84%D9%8A%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D8%AE%D9%8A%D9%88%D8%B7-%D9%88%D9%83%D8%A7%D8%A6%D9%86%D8%A7%D8%AA-job-%D9%81%D9%8A-windows/)

وسوف نناقش في هذا المقال ما يلي:

- ما هو الخطاف Hook، وأنواعه، والفرق بين الخطاف على خيط واحد Thread-specific Hook والخطاف العام Global Hook.
- كيف يعمل الخطاف من الداخل: سلسلة الخطافات Hook Chain، ومتى يعمل الكود داخل العملية المستهدفة In-context ومتى يعمل في عملية من ركبه.
- مختبر عملي: خطافان على رسائل برنامجنا، وترتيب استدعائهما، وخطاف يغير الرسالة أو يحذفها، وخطاف ينسى تمرير الرسالة.
- لماذا لم يعمل خطاف لوحة المفاتيح WH\_KEYBOARD مع رسائل أرسلناها بأنفسنا، وما الذي يعنيه ذلك.
- كيف يحمل النظام مكتبة DLL كتبتها أنت داخل عملية أخرى بسبب خطاف، ومتى يزيلها.
- كم يكلف الخطاف من وقت لكل رسالة، والبديل الأخف للمراقبة: أحداث الواجهة WinEvents.
- الخطافات العامة وخطافات المستوى المنخفض Low-level Hooks وبرامج تسجيل لوحة المفاتيح Keyloggers من جهة الدفاع، والأخطاء الشائعة، وجدول قرار، وتدريب عملي.

## ما هو الخطاف Hook في Windows؟

الخطاف Hook في Windows هو دالة تكتبها أنت، وتطلب من النظام أن يستدعيها عند نوع معين من الأحداث قبل أن يكمل معالجته المعتادة، والدالة نفسها اسمها إجراء الخطاف Hook Procedure. فالنظام يملك عدداً من النقاط الثابتة في طريق الرسائل والأحداث، مثل لحظة خروج الرسالة من طابور الخيط Message Queue، أو لحظة استدعاء دالة النافذة برسالة مرسلة بـ `SendMessage`، أو لحظة وصول ضغطة مفتاح من لوحة المفاتيح، وكل نقطة منها لها رقم ثابت يبدأ بـ `WH_`، وتركب الخطاف عليها بالدالة `SetWindowsHookExW`، وتزيله بالدالة `UnhookWindowsHookEx`. وتقول [نظرة Microsoft العامة على الخطافات](https://learn.microsoft.com/en-us/windows/win32/winmsg/about-hooks?ref=arabroot.io) إن إجراء الخطاف يستطيع أن يتصرف في كل حدث يصله، وأن يغيره أو يلغيه، وإن من استعمالاتها مراقبة الرسائل لأغراض تصحيح الأخطاء Debugging، وتسجيل الماكرو Macro وإعادة تشغيله، ودعم مفتاح المساعدة F1، وبرامج التدريب.

والمثال الأقرب من الحياة هو نقطة تفتيش على الطريق المؤدي إلى بيت: الرسالة سيارة خرجت من مكان ما وتريد الوصول إلى بيتها، أي النافذة، ونقطة التفتيش تستطيع أن تنظر في السيارة وتتركها تمر، أو تبدل ما فيها، أو تعيدها من حيث أتت. وقد تكون على الطريق عدة نقاط تفتيش متتالية، وكل نقطة مسؤولة عن تمرير السيارة إلى النقطة التي بعدها، فإذا نسيت نقطة واحدة أن تمررها، لم تر النقاط التالية شيئاً. وهذا بالضبط ما سوف نراه بالأرقام في المختبر.

وهنا يجب التفريق بين الخطافات بهذا المعنى وبين ما يسمى اعتراض الدوال API Hooking، وهو تغيير كود دالة مثل `CreateFileW` في ذاكرة العملية حتى تمر كل الاستدعاءات عبر كودك، وهذا موضوع المقال التالي في هذه المرحلة. أما الخطافات هنا فهي خدمة رسمية يقدمها Windows نفسه في نظام الرسائل، بواجهة موثقة، ولا يغير فيها أحد كود أحد.

### لماذا وجدت الخطافات أصلاً؟

الخطافات من أقدم واجهات Windows، وأسماء أنواعها تحكي الغرض الذي صممت له. فالنوع `WH_CBT` اسمه مأخوذ من برامج التدريب بالحاسب Computer-Based Training، وهي برامج كانت تشرح للمستخدم تطبيقاً آخر خطوة بخطوة، فتحتاج أن تعرف متى أنشئت نافذة أو فعلت، وأن تمنع المستخدم أحياناً من الضغط خارج الخطوة الحالية، وتشرح [صفحة CBTProc](https://learn.microsoft.com/en-us/windows/win32/winmsg/cbtproc?ref=arabroot.io) أن الإجراء يستطيع أن يلغي هذه العمليات بقيمة يعيدها. والنوعان `WH_JOURNALRECORD` و`WH_JOURNALPLAYBACK` صمما لتسجيل ما يفعله المستخدم بالفأرة ولوحة المفاتيح ثم إعادته، أي الماكرو بمعناه الأول. وفي ذلك الزمن كانت كل البرامج تعمل في مساحة ذاكرة واحدة تقريباً، فكان استدعاء دالة برنامج آخر أمراً بسيطاً، ولما جاءت مساحات العناوين المنفصلة في Windows NT بقيت الواجهة كما هي، وصار النظام يحمل المكتبة في كل عملية حتى يستطيع أن يستدعي الدالة من داخلها. ولهذا تبدو الخطافات اليوم غريبة في نظام حديث يعزل العمليات عن بعضها: هي واجهة من عصر آخر، بقيت لأن آلاف البرامج تعتمد عليها.

## أنواع الخطافات Hook Types ومداها

لكل نوع من الخطافات نقطة في طريق الرسائل، ومدى Scope يحدد أي الخيوط يشملها: خيط واحد تحدد رقمه، أو كل الخيوط على سطح المكتب Desktop نفسه الذي يعمل عليه البرنامج الذي ركب الخطاف، وهذا هو الخطاف العام Global Hook. والجدول التالي يلخص الأنواع التي تهمك، من [صفحة SetWindowsHookExW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowshookexw?ref=arabroot.io) ونظرة Microsoft العامة:

| النوع                                  | متى يستدعى                                                 | المدى              | أين يعمل الكود                  |
| -------------------------------------- | ---------------------------------------------------------- | ------------------ | ------------------------------- |
| WH\_GETMESSAGE                         | عند خروج رسالة من طابور الخيط بـ GetMessage أو PeekMessage | خيط أو عام         | داخل العملية صاحبة الخيط        |
| WH\_CALLWNDPROC وWH\_CALLWNDPROCRET    | قبل دالة النافذة وبعدها لرسالة مرسلة بـ SendMessage        | خيط أو عام         | داخل العملية صاحبة النافذة      |
| WH\_KEYBOARD وWH\_MOUSE                | عند معالجة رسالة لوحة مفاتيح أو فأرة قادمة من الإدخال      | خيط أو عام         | داخل العملية صاحبة الخيط        |
| WH\_CBT                                | قبل إنشاء نافذة أو تفعيلها أو تحريكها أو إغلاقها           | خيط أو عام         | داخل العملية صاحبة الخيط        |
| WH\_MSGFILTER وWH\_SYSMSGFILTER        | رسائل القوائم Menus وصناديق الحوار Dialog Boxes            | خيط، أو عام للثاني | داخل العملية صاحبة الخيط        |
| WH\_KEYBOARD\_LL وWH\_MOUSE\_LL        | قبل أن يدخل الإدخال طابور أي خيط                           | عام فقط            | في خيط البرنامج الذي ركب الخطاف |
| WH\_JOURNALRECORD وWH\_JOURNALPLAYBACK | تسجيل الإدخال وإعادته                                      | عام فقط            | غير مدعوم منذ Windows 11        |

والعمود الأخير هو أهم عمود في الجدول، لأنه يحدد ما يحدث فعلاً على الجهاز. فأغلب الأنواع تعمل في سياق الخيط المستهدف In-context، أي أن النظام يستدعي دالتك من داخل الخيط الذي خرجت منه الرسالة، وبالتالي إذا كان الخيط في عملية أخرى، فإن دالتك يجب أن تكون في مكتبة DLL، والنظام نفسه يحمل هذه المكتبة داخل تلك العملية. ولذلك تقول الصفحة إن الخطاف العام يجب أن يكون إجراؤه في مكتبة DLL منفصلة، وإن الخطاف على خيط من برنامج آخر يجب أن يكون في مكتبة كذلك، أما الخطاف على خيط من خيوط برنامجك فيمكن أن يكون في البرنامج نفسه. وأما خطافات المستوى المنخفض Low-level Hooks، أي `WH_KEYBOARD_LL` و`WH_MOUSE_LL`، فلا تحمل أي مكتبة في أي عملية، وإنما يرسل النظام الحدث إلى خيط البرنامج الذي ركب الخطاف، وينتظر رده قبل أن يكمل، وهذا فرق سوف نعود إليه في قسم الخطافات العامة.

⚠️

تنصح Microsoft في الصفحة نفسها باستعمال الخطافات العامة لأغراض تصحيح الأخطاء فقط، لأنها تبطئ الجهاز كله وتتعارض مع برامج أخرى تركب النوع نفسه. ولهذا لا يركب مختبر هذا المقال أي خطاف عام، ولا أي خطاف مستوى منخفض على لوحة المفاتيح، لأن هذا الخطاف يرى كل ما تكتبه في كل البرامج، وإنما نشرح هذين النوعين من الوثائق ومن جهة الكشف والدفاع.

## كيف يعمل الخطاف من الداخل؟

الرسائل في Windows يديرها الجزء الرسومي من النواة، وهو المكون `win32k.sys` ومعه المكتبة `user32.dll` في وضع المستخدم User Mode، وقد شرح مقال [كيف يعمل Windows من الداخل](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-windows-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84-%D9%88%D8%B6%D8%B9-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9/) هذا التقسيم. وكل خيط أنشأ نافذة أو استدعى دالة رسائل له طابور رسائل خاص به، وعندما تستدعي `SetWindowsHookExW` يضيف النظام سجلاً في سلسلة الخطافات Hook Chain لهذا النوع، إما في سلسلة الخيط المحدد أو في السلسلة العامة لسطح المكتب. وعند كل حدث من هذا النوع ينظر النظام في السلسلة، فإذا وجد فيها خطافات استدعى أحدثها أولاً، وأول خطاف يستدعى هو آخر خطاف ركب، والدالة `CallNextHookEx` هي التي تمرر الحدث إلى الخطاف التالي. وتقول [صفحة CallNextHookEx](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-callnexthookex?ref=arabroot.io) إن استدعاءها اختياري، ولكنها توصي به بقوة، لأن البرامج الأخرى التي ركبت خطافات من النوع نفسه لن تصلها الأحداث إذا لم تستدعها.

وفي حالة الخطاف داخل العملية In-context، وعندما يكون الخيط المستهدف في عملية أخرى، يحفظ النظام مع الخطاف اسم المكتبة وموقع الدالة داخلها نسبة إلى بداية المكتبة. ثم في المرة التالية التي يمر فيها حدث من هذا النوع على ذلك الخيط، يحمل النظام المكتبة في العملية المستهدفة بالطريقة نفسها التي تعمل بها `LoadLibrary`، فيعمل `DllMain` فيها، ثم يستدعي دالة الخطاف من داخل الخيط المستهدف. ولذلك تقول صفحة `SetWindowsHookExW` صراحة إن هذه الدالة يمكن أن تستعمل لحقن مكتبة DLL في عملية أخرى DLL Injection، وإن المكتبة يجب أن تطابق العملية في عدد البتات Bitness: مكتبة 64 بت لعمليات 64 بت ومكتبة 32 بت لعمليات 32 بت، فإذا ركب برنامج 64 بت خطافاً عاماً، فإن عمليات 32 بت لا تحمل مكتبته، وإنما يستدعي النظام الخطاف في خيط البرنامج الذي ركبه.

وهناك حدود يفرضها النظام على هذا الحقن. فالخطاف لا يتجاوز سطح المكتب الذي يعمل عليه، والجلسة Session التي ينتمي إليها، فبرنامج في جلستك لا يرى رسائل جلسة مستخدم آخر، ولا رسائل شاشة الدخول التي تعمل على سطح مكتب آخر اسمه Winlogon. وبالإضافة إلى ذلك يمنع عزل امتيازات واجهة المستخدم User Interface Privilege Isolation، واختصاراً UIPI، البرنامج الذي يعمل بمستوى سلامة Integrity Level متوسط من تركيب خطاف على عملية بمستوى أعلى، مثل برنامج يعمل كمدير بعد طلب الرفع، وقد شرح مقال [رموز الأمان Tokens والتحكم UAC](https://arabroot.io/articles/%D8%B1%D9%85%D9%88%D8%B2-%D8%A7%D9%84%D8%A7%D9%85%D8%A7%D9%86-tokens-%D9%88%D9%82%D9%88%D8%A7%D8%A6%D9%85-acl-%D9%88%D8%A7%D9%84%D8%AA%D8%AD%D9%83%D9%85-uac-%D9%81%D9%8A-windows/) مستويات السلامة هذه. وتفصيل ما يحدث داخل `win32k` مذكور في كتاب [Windows Internals](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals?ref=arabroot.io)، أما في هذا المقال فنكتفي بما نستطيع أن نراه ونقيسه من خارج النواة.

![مسار الرسالة من PostMessage إلى طابور الخيط ثم سلسلة خطافات WH_GETMESSAGE بالترتيب B ثم A ثم DispatchMessage ودالة النافذة، ومسار SendMessage عبر WH_CALLWNDPROC ثم دالة النافذة ثم WH_CALLWNDPROCRET](https://arabroot.io/content/images/2026/11/windows-hooks-01-hook-chain.webp)

طريقان للرسالة إلى النافذة، ولكل طريق نقطة خطاف خاصة به. والأرقام من تشغيل المختبر.

## تجهيز المختبر Lab

المختبر برنامج واحد اسمه `hooklab.exe` ومكتبة واحدة اسمها `hookdll.dll`، وكلاهما بلغة C، ونبنيهما بأدوات Microsoft للغة C++ x64، وهي موجودة مع Visual Studio أو مع حزمة Build Tools المجانية. والبرنامج ينشئ نافذة لا يعرضها أبداً، فهي نافذة حقيقية لها طابور رسائل وتصلها الرسائل المرسلة إليها، ولكنها لا تظهر على الشاشة ولا تأخذ أي إدخال من المستخدم. وكل رسالة في المختبر نرسلها نحن إلى هذه النافذة أو إلى خيوط برنامجنا، وكل خطاف نركبه على خيط من خيوطنا، فلا يرى المختبر أي ضغطة مفتاح حقيقية ولا أي نافذة لبرنامج آخر. وكل السكربتات تعمل بـ Windows PowerShell 5.1 كمستخدم عادي، وكل الملفات في مجلد مؤقت داخل `%TEMP%` يحذفه السكربت الأخير. وملف البناء هو:

```bat
@echo off
rem Build with the MSVC x64 tools (run from "x64 Native Tools Command Prompt for VS", or let 00-setup.ps1 call it).
cl 2>&1 | findstr /c:"Version"
cl /nologo /W3 /O2 /Zi hooklab.c /link /PDBALTPATH:%%_PDB%% user32.lib || exit /b 1
cl /nologo /W3 /O2 /LD hookdll.c /link user32.lib || exit /b 1
dir /b *.exe *.dll
```

والسكربت `00-setup.ps1` يجد أدوات Visual Studio بالأداة `vswhere.exe`، وينسخ الملفات إلى مجلد المختبر، ويبني فيه، ثم يطبع البيئة:

```text
OS        : Microsoft Windows 11 Pro (build 26100.9711)
PowerShell: 5.1.26100.9711
Elevated  : False
Lab folder: C:\lab
Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36256 for x64
hooklab.c
hookdll.c
   Creating library hookdll.lib and object hookdll.exp
hooklab.exe
hookdll.dll
```

والسطر `Elevated : False` مهم في كل مقالات هذه المرحلة، لأنه يعني أن كل ما سوف تراه يعمل بحساب مستخدم عادي، وهذا هو الحساب الذي يعمل به برنامج ضار وصل إلى جهازك عبر مرفق في بريد. أما مسار المجلد فيظهر في المخرجات `C:\lab` لأن السكربت يستبدل به المسار الحقيقي داخل `%TEMP%`، وكذلك يستبدل اسم المستخدم واسم الجهاز قبل حفظ المخرجات.

## التجربة الأولى: سلسلة الخطافات Hook Chain بالترتيب

نبدأ بخطافين من النوع `WH_GETMESSAGE` على الخيط الرئيسي في برنامجنا، نسميهما A وB، ونركب A أولاً ثم B. وكل منهما يطبع ما يراه من رسائل نافذتنا ثم يستدعي `CallNextHookEx`. ونركب معهما الخطافين `WH_CALLWNDPROC` و`WH_CALLWNDPROCRET` اللذين يحيطان بدالة النافذة عند كل رسالة مرسلة بـ `SendMessage`. والخطاف B هو الذي سوف نستعمله بعد قليل لتغيير الرسائل:

```c
static LRESULT CALLBACK GetMsgA(int code, WPARAM w, LPARAM l) {
    MSG *m = (MSG *)l;
    if (code == HC_ACTION && m->hwnd == g_wnd) printf("  hook A (WH_GETMESSAGE) sees %-10s\n", msgname(m->message));
    return CallNextHookEx(NULL, code, w, l);
}
static LRESULT CALLBACK GetMsgB(int code, WPARAM w, LPARAM l) {
    MSG *m = (MSG *)l;
    if (code == HC_ACTION && m->hwnd == g_wnd) {
        printf("  hook B (WH_GETMESSAGE) sees %-10s", msgname(m->message));
        if (g_mode_modify && m->message == WM_CHAR && m->wParam == 'a') { m->wParam = 'b'; printf("  -> changed 'a' to 'b'"); }
        if (g_mode_modify && m->message == WM_APP + 2) { m->message = WM_NULL; printf("  -> swallowed (now WM_NULL)"); }
        printf("\n");
    }
    if (!g_b_calls_next) return 0;   // the chain stops here: hook A never sees the message
    return CallNextHookEx(NULL, code, w, l);
}
```

لاحظ أن الخطاف يأخذ الرسالة كمؤشر `MSG *`، أي أنه يرى الرسالة نفسها التي سوف تصل إلى `DispatchMessageW` بعده، وليس نسخة منها، وأن `NULL` في أول معامل لـ `CallNextHookEx` مقبول منذ زمن، لأن النظام لم يعد يحتاج مقبض الخطاف في هذا الاستدعاء. وعند التشغيل نرسل إلى نافذتنا رسالة بـ `PostMessage`، ثم رسالة بـ `SendMessage`، ثم نغير عنوان النافذة، ثم نزيل الخطافات ونعيد الرسالة الأولى. والمخرج سوف يكون كما يلي:

```text
> hooklab.exe chain
thread 43212: installed A then B (WH_GETMESSAGE), WH_CALLWNDPROC, WH_CALLWNDPROCRET: 00000000226A17B7 0000000019C213BB 00000000131913F3 00000000023B0F23

[1] PostMessage(WM_APP+1) to our window, then the message loop:
  hook B (WH_GETMESSAGE) sees WM_DWMNCRENDERINGCHANGED
  hook A (WH_GETMESSAGE) sees WM_DWMNCRENDERINGCHANGED
  hook B (WH_GETMESSAGE) sees WM_APP+1
  hook A (WH_GETMESSAGE) sees WM_APP+1
    WndProc         got WM_APP+1   wParam=7

[2] SendMessage(WM_APP+1) to our window (no queue, the window procedure is called directly):
  WH_CALLWNDPROC    before WM_APP+1   (sent by this thread)
    WndProc         got WM_APP+1   wParam=8
  WH_CALLWNDPROCRET after  WM_APP+1   result=42
    SendMessage returned 42

[3] SetWindowTextW(our window) sends WM_SETTEXT:
  WH_CALLWNDPROC    before WM_SETTEXT (sent by this thread)
    WndProc         got WM_SETTEXT "hooked title"
  WH_CALLWNDPROCRET after  WM_SETTEXT result=1

[4] after UnhookWindowsHookEx, PostMessage(WM_APP+1) again:
    WndProc         got WM_APP+1   wParam=9
[exit code 0 = 0x00000000]
```

وفي هذا المخرج لاحظ التالي:

- في الخطوة \[1\] رأى الخطاف B الرسالة قبل A، مع أننا ركبنا A أولاً. فالسلسلة تبدأ بآخر خطاف ركب، وهذا يعني أن البرنامج الذي يركب خطافه بعد برنامجك يقف أمامك في الطريق، ويستطيع أن يقرر هل تصلك الرسالة أم لا.
- وقبل رسالتنا مرت رسالة لم نرسلها نحن: `WM_DWMNCRENDERINGCHANGED`. وهذه رسالة يرسلها مدير النوافذ Desktop Window Manager إلى كل نافذة جديدة ليخبرها هل يرسم إطارها أم لا، وتشرحها [صفحة WM\_DWMNCRENDERINGCHANGED](https://learn.microsoft.com/en-us/windows/win32/dwm/wm-dwmncrenderingchanged?ref=arabroot.io). ولم نتوقعها عند كتابة المختبر، فكانت أول درس عملي: الخطاف يرى كل ما يمر في الطابور، لا ما أرسلته أنت فقط، فإذا بنيت منطقاً على عدد الرسائل أو ترتيبها، فسوف يفاجئك النظام برسائل لم تكن في حسابك.
- في الخطوة \[2\] لم يعمل `WH_GETMESSAGE` أبداً، لأن `SendMessage` إلى نافذة في الخيط نفسه لا تمر بالطابور، وإنما يستدعي النظام دالة النافذة مباشرة، وهذا ما شرحه مقال حلقة الرسائل. ولذلك عمل هنا `WH_CALLWNDPROC` قبل دالة النافذة، و`WH_CALLWNDPROCRET` بعدها، ورأى الأخير القيمة التي أعادتها الدالة، وهي 42، قبل أن تصل إلى من استدعى `SendMessage`.
- في الخطوة \[3\] لم نرسل أي رسالة بأنفسنا، وإنما استدعينا `SetWindowTextW`، ومع ذلك رأى الخطاف رسالة `WM_SETTEXT`، لأن هذه الدالة ترسل الرسالة إلى النافذة. وبالتالي يرى الخطاف أيضاً ما تفعله دوال Windows نيابة عنك، وهذا ما يجعل الخطافات مفيدة لأدوات قراءة الشاشة Screen Readers وأدوات الأتمتة.
- وفي الخطوة \[4\] بعد `UnhookWindowsHookEx` وصلت الرسالة إلى النافذة دون أن يراها أحد، أي أن إزالة الخطاف فورية في الخيط نفسه.

## الخطاف يغير الرسالة أو يحذفها

الخطاف `WH_GETMESSAGE` يملك الرسالة قبل أن تصل إلى النافذة، ولذلك تقول [صفحة GetMsgProc](https://learn.microsoft.com/en-us/windows/win32/winmsg/getmsgproc?ref=arabroot.io) إن الإجراء يستطيع أن يفحص الرسالة أو يغيرها. وفي هذه التجربة يغير الخطاف B الحرف `a` إلى `b` في رسالة `WM_CHAR`، ويحذف الرسالة `WM_APP+2` بأن يجعل رقمها `WM_NULL`، وهي رسالة لا تفعل شيئاً. ثم نجرب نسخة ثانية من الخطاف B لا تستدعي `CallNextHookEx` أبداً وتعيد صفراً:

```text
> hooklab.exe modify
post WM_CHAR 'a', WM_APP+2, WM_CHAR 'c' to our window
  hook B (WH_GETMESSAGE) sees WM_DWMNCRENDERINGCHANGED
  hook A (WH_GETMESSAGE) sees WM_DWMNCRENDERINGCHANGED
  hook B (WH_GETMESSAGE) sees WM_CHAR     -> changed 'a' to 'b'
  hook A (WH_GETMESSAGE) sees WM_CHAR
    WndProc         got WM_CHAR    'b'
  hook B (WH_GETMESSAGE) sees WM_APP+2    -> swallowed (now WM_NULL)
  hook A (WH_GETMESSAGE) sees WM_NULL
  hook B (WH_GETMESSAGE) sees WM_CHAR
  hook A (WH_GETMESSAGE) sees WM_CHAR
    WndProc         got WM_CHAR    'c'
[exit code 0 = 0x00000000]

> hooklab.exe nonext
post WM_CHAR 'a', WM_APP+2, WM_CHAR 'c' to our window
  hook B (WH_GETMESSAGE) sees WM_DWMNCRENDERINGCHANGED
  hook B (WH_GETMESSAGE) sees WM_CHAR
    WndProc         got WM_CHAR    'a'
  hook B (WH_GETMESSAGE) sees WM_APP+2
    WndProc         got WM_APP+2   wParam=1
  hook B (WH_GETMESSAGE) sees WM_CHAR
    WndProc         got WM_CHAR    'c'
[exit code 0 = 0x00000000]
```

في التشغيل الأول وصل إلى دالة النافذة الحرف `b` بدلاً من `a`، ولم تعرف النافذة أن أحداً غيره، وهذا هو الحد الذي يجعل الخطافات أداة قوية وخطرة في الوقت نفسه: برنامج ترجمة لوحة مفاتيح Keyboard Remapper يستطيع أن يفعل هذا لمصلحتك، وبرنامج ضار يستطيع أن يفعله ضدك. ولاحظ أيضاً أن الخطاف A رأى الرسالة بعد تعديلها، أي أن كل خطاف في السلسلة يرى ما تركه الخطاف الذي قبله. ورأى A الرسالة المحذوفة كـ `WM_NULL`، ولم تصل إلى دالة النافذة أي رسالة `WM_APP+2`.

وفي التشغيل الثاني اختفى الخطاف A تماماً من المخرج، لأن B لم يمرر له أي رسالة، بينما وصلت الرسائل إلى النافذة كما هي. وقد يتساءل البعض: إذا كان B لا يمرر الرسالة، فلماذا وصلت إلى النافذة؟ والإجابة على ذلك أن `WH_GETMESSAGE` خطاف مراقبة، والقيمة التي يعيدها لا تمنع وصول الرسالة، وإنما تمنعها عن بقية الخطافات فقط. وبعض الأنواع الأخرى، مثل `WH_KEYBOARD` و`WH_CBT`، تفهم القيمة المعادة كقرار، فإذا أعاد إجراؤها قيمة غير الصفر ألغى النظام الحدث نفسه. وهذا الخطأ، أي نسيان `CallNextHookEx`، هو بالضبط ما يجعل برنامجاً يعطل اختصارات برنامج آخر على الجهاز نفسه دون أن يعرف أحد السبب.

![ثلاث رسائل تمر بالخطاف B ثم A ثم دالة النافذة: الحرف a يصبح b، والرسالة WM_APP+2 تصبح WM_NULL، وفي النسخة التي لا تستدعي CallNextHookEx لا يرى A شيئاً](https://arabroot.io/content/images/2026/11/windows-hooks-02-modify.webp)

ما يتركه كل خطاف هو ما يراه الخطاف الذي بعده، والخطاف الذي لا يمرر يحجب من بعده.

## لماذا لم يعمل خطاف لوحة المفاتيح WH\_KEYBOARD؟

أردنا في هذه التجربة أن نرى خطاف لوحة المفاتيح `WH_KEYBOARD` يعمل على خيطنا فقط، دون أن نلمس لوحة المفاتيح الحقيقية، فركبنا الخطاف ثم أرسلنا إلى نافذتنا بأنفسنا رسالة `WM_KEYDOWN` للحرف K ثم `WM_KEYUP`:

```text
> hooklab.exe keyboard
WH_KEYBOARD on thread 35688: 00000000023E0F23
[1] PostMessage(WM_KEYDOWN 'K') to our window:
    WndProc         got WM_KEYDOWN wParam=75
    WndProc         got WM_CHAR    'k'
[2] PostMessage(WM_KEYUP 'K') to our window:
WH_KEYBOARD removed
[exit code 0 = 0x00000000]
```

ولم يطبع الخطاف أي سطر، مع أن النافذة استلمت `WM_KEYDOWN`، بل وصلها أيضاً `WM_CHAR` بالحرف `k` صغيراً لأن `TranslateMessage` في حلقة الرسائل حولت الضغطة إلى حرف. وهذه كانت المشكلة التي قابلتنا أثناء كتابة المختبر، وتوقعنا عكسها، لأن [صفحة KeyboardProc](https://learn.microsoft.com/en-us/windows/win32/winmsg/keyboardproc?ref=arabroot.io) تقول إن النظام يستدعي الخطاف كلما استدعى البرنامج GetMessage أو PeekMessage وكانت هناك رسالة WM\_KEYDOWN أو WM\_KEYUP للمعالجة. والذي يفسر النتيجة أن النظام يستدعي هذا الخطاف عند خروج رسالة لوحة المفاتيح من طابور الإدخال الخاص بالخيط، وهو الطابور الذي يملؤه النظام من لوحة المفاتيح الحقيقية أو من `SendInput`، أما الرسالة التي نضعها بـ `PostMessage` فتدخل طابور الرسائل المرسلة Posted Messages، وتمر بخطاف `WH_GETMESSAGE` كأي رسالة أخرى، ولا يعدها النظام ضغطة مفتاح.

وهذا الدرس له أثر عملي في الاتجاهين. فمن جهة، برنامج يحاكي ضغطات المفاتيح بـ `PostMessage` لا يمر بخطافات لوحة المفاتيح، وبالتالي برامج الحماية التي تراقب لوحة المفاتيح لا ترى هذه الطريقة. ومن جهة أخرى، النافذة التي تتوقع اختصاراً لا تفرق بين الضغطة الحقيقية والرسالة المصطنعة إلا إذا نظرت في مصدرها، ولذلك فإن تجربة الخطاف على لوحة المفاتيح لا تكتمل إلا بضغطات حقيقية، وهذا ما لا يفعله المختبر عن قصد، لأن خطافاً يرى ضغطات حقيقية على سطح مكتب حقيقي هو برنامج تسجيل لوحة مفاتيح Keylogger بالتعريف، حتى لو كان على خيط برنامجك فقط وأنت تكتب في نافذة أخرى.

## خطاف على خيط آخر من خيوط برنامجك

الخيط الذي يركب الخطاف ليس بالضرورة الخيط الذي يراقبه. ففي هذه التجربة ينشئ الخيط الرئيسي خيطاً عاملاً Worker Thread له طابور رسائل خاص، ثم يركب عليه خطاف `WH_GETMESSAGE` بمكتبة `NULL`، لأن الخيط من برنامجنا والدالة في برنامجنا، ثم يرسل إليه رسالتين: الأولى والخطاف موجود، والثانية بعد إزالته. وفي الجزء الثاني نجرب ما يرفضه النظام: خطافاً لكل الخيوط دون مكتبة، وخطافاً على رقم خيط غير موجود:

```text
> hooklab.exe thread
main thread 17084 installs WH_GETMESSAGE on worker thread 8076
SetWindowsHookExW -> 0000000002400F23 (error 0)
  hook proc runs on thread 8076 for WM_APP+1 (wParam=5)
  worker 8076 got WM_APP+1 from its queue
  worker 8076 got WM_APP+1 from its queue
[exit code 0 = 0x00000000]

> hooklab.exe needmod
SetWindowsHookExW(WH_GETMESSAGE, proc, hMod=NULL, dwThreadId=0) -> 0000000000000000, GetLastError = 1428
SetWindowsHookExW(WH_GETMESSAGE, proc, NULL, dwThreadId=4) -> 0000000000000000, GetLastError = 87
[exit code 0 = 0x00000000]
```

والسطر المهم في الجزء الأول هو أن إجراء الخطاف عمل على الخيط رقم 8076، أي الخيط العامل نفسه، لا على الخيط الرئيسي 17084 الذي ركبه، وهذا هو معنى أن الخطاف يعمل في سياق الخيط المستهدف In-context. وبالتالي إذا كان الإجراء بطيئاً أو علق، فإن الخيط المستهدف هو الذي يعلق، لا الخيط الذي ركب الخطاف. ولم ير الخطاف الرسالة الثانية لأننا أزلناه قبلها.

وفي الجزء الثاني رفض النظام الطلب الأول بالخطأ 1428، وهو `ERROR_HOOK_NEEDS_HMOD`، أي أن الخطاف العام يحتاج مقبض مكتبة، لأن النظام سوف يحمل الإجراء في عمليات أخرى ولا يستطيع ذلك من برنامج تنفيذي. وهذا الطلب لم يركب أي خطاف عام، لأن النظام رفضه قبل أي شيء، وهو موثق في الصفحة كما رأينا. ورفض الطلب الثاني بالخطأ 87، أي معامل غير صحيح، لأن رقم الخيط 4 لا يخص أي خيط له طابور رسائل في جلستنا.

## كيف يحمل الخطاف مكتبتك داخل عملية أخرى؟

هذه أهم تجربة في المقال، لأنها تبين الحقن الذي تتحدث عنه الوثائق بالأرقام. والعملية الأخرى هنا هي نسخة ثانية من `hooklab.exe` يشغلها برنامجنا نفسه في الوضع `target`، فهي عملية مستقلة تماماً، لها خيط ونافذة وحلقة رسائل، ولكنها من صنعنا. والمكتبة `hookdll.dll` صغيرة: تطبع سطراً عند تحميلها وعند إزالتها، وتطبع كل رسالة `WM_APP+1` تراها مع رقم العملية التي تعمل فيها:

```c
// hookdll.c: the hook procedure in a DLL. The system loads this DLL into the process whose thread is hooked.
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
static void say(const char *t) {
    char b[200]; DWORD n; wsprintfA(b, "    [hookdll in PID %lu] %s\r\n", GetCurrentProcessId(), t);
    WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), b, lstrlenA(b), &n, NULL);
}
BOOL WINAPI DllMain(HINSTANCE h, DWORD reason, LPVOID r) {
    if (reason == DLL_PROCESS_ATTACH) say("DLL_PROCESS_ATTACH");
    if (reason == DLL_PROCESS_DETACH) say("DLL_PROCESS_DETACH");
    return TRUE;
}
__declspec(dllexport) LRESULT CALLBACK GetMsgProc(int code, WPARAM w, LPARAM l) {
    MSG *m = (MSG *)l; char b[120];
    if (code == HC_ACTION && m->message == WM_APP + 1) { wsprintfA(b, "GetMsgProc sees WM_APP+1 (%lu) on thread %lu", (DWORD)m->wParam, GetCurrentThreadId()); say(b); }
    return CallNextHookEx(NULL, code, w, l);
}
```

والبرنامج الأب يحمل المكتبة في نفسه، ويأخذ عنوان `GetMsgProc`، ثم يركب الخطاف على خيط العملية الابن، ثم يرسل إلى ذلك الخيط أربع رسائل بـ `PostThreadMessageW`: اثنتين والخطاف موجود، واثنتين بعد إزالته:

```c
    HMODULE dll = LoadLibraryW(L"hookdll.dll");
    HOOKPROC proc = (HOOKPROC)GetProcAddress(dll, "GetMsgProc");
    printf("parent loaded hookdll.dll at %p, GetMsgProc at %p\n", dll, proc);
    HHOOK h = SetWindowsHookExW(WH_GETMESSAGE, proc, dll, pi.dwThreadId);
    printf("parent SetWindowsHookExW(WH_GETMESSAGE, GetMsgProc, hookdll, thread %lu) -> %p\n", pi.dwThreadId, h);
    PostThreadMessageW(pi.dwThreadId, WM_APP + 1, 1, 0); Sleep(500);
    PostThreadMessageW(pi.dwThreadId, WM_APP + 1, 2, 0); Sleep(500);
    printf("parent UnhookWindowsHookEx -> %d\n", UnhookWindowsHookEx(h));
    PostThreadMessageW(pi.dwThreadId, WM_APP + 1, 3, 0); Sleep(500);
    PostThreadMessageW(pi.dwThreadId, WM_APP + 1, 4, 0); Sleep(500);
    PostThreadMessageW(pi.dwThreadId, WM_QUIT, 0, 0);
```

والمخرج سوف يكون كما يلي:

```text
> hooklab.exe inject
  target 20208: hookdll.dll loaded? no
parent 45160 started our target: PID 20208, GUI thread 25664
    [hookdll in PID 45160] DLL_PROCESS_ATTACH
parent loaded hookdll.dll at 00007FF994130000, GetMsgProc at 00007FF994131040
parent SetWindowsHookExW(WH_GETMESSAGE, GetMsgProc, hookdll, thread 25664) -> 0000000019C313BB
    [hookdll in PID 20208] DLL_PROCESS_ATTACH
    [hookdll in PID 20208] GetMsgProc sees WM_APP+1 (1) on thread 25664
  target got WM_APP+1 (1) in its loop; hookdll.dll loaded? yes
    [hookdll in PID 20208] GetMsgProc sees WM_APP+1 (2) on thread 25664
  target got WM_APP+1 (2) in its loop; hookdll.dll loaded? yes
parent UnhookWindowsHookEx -> 1
  target got WM_APP+1 (3) in its loop; hookdll.dll loaded? yes
    [hookdll in PID 20208] DLL_PROCESS_DETACH
  target got WM_APP+1 (4) in its loop; hookdll.dll loaded? no
  target: WM_QUIT, exiting
target exited with 0
    [hookdll in PID 45160] DLL_PROCESS_DETACH
[exit code 0 = 0x00000000]
```

اقرأ المخرج سطراً سطراً، لأن كل سطر فيه مرحلة:

- السطر الثاني: العملية الابن رقم 20208 بدأت، والمكتبة غير محملة فيها.
- السطر الرابع: الأب حمل المكتبة في نفسه، فعمل `DllMain` في عملية الأب 45160، وهذا طبيعي لأن `LoadLibraryW` حدثت فيه.
- السطر السادس: نجح تركيب الخطاف على الخيط 25664، ولم يحدث في الابن أي شيء بعد.
- السطر السابع: مع أول رسالة على خيط الابن عمل `DllMain` داخل العملية 20208\. والابن لم يستدع `LoadLibrary` ولا يعرف اسم المكتبة أصلاً، وإنما حملها النظام فيه لأن رسالة مرت على خيط عليه خطاف إجراؤه في هذه المكتبة.
- السطر الثامن: الخطاف رأى الرسالة على الخيط 25664 داخل الابن، ثم وصلت الرسالة إلى حلقة الابن، وصار الجواب على سؤال «هل المكتبة محملة؟» نعم.
- السطر الثاني عشر وما بعده: أزال الأب الخطاف، ومع ذلك بقيت المكتبة في الابن بعد الرسالة الثالثة، ثم أزالها النظام عند الرسالة الرابعة. أي أن النظام يحمل المكتبة عند أول حاجة، ويزيلها لاحقاً عندما يمر الخيط بحدث جديد ويجد أن الخطاف لم يعد موجوداً، لا لحظة `UnhookWindowsHookEx`.

وهذه النتيجة الأخيرة لها أثر عند التحقيق في حادثة: وجود مكتبة غريبة محملة في عملية لا يعني أن خطافاً ما زال موجوداً، وغيابها لا يعني أنه لم يكن هناك خطاف قبل دقائق. والحقن بالخطافات من أقدم طرق إدخال الكود في عمليات أخرى، ولذلك تذكره [صفحة حقن العمليات Process Injection في MITRE ATT&CK](https://attack.mitre.org/techniques/T1055/?ref=arabroot.io) ضمن الطرق المعروفة، وتجد في مقال [MITRE ATT&CK](https://arabroot.io/articles/mitre-attack-%D9%83%D9%8A%D9%81-%D9%8A%D9%81%D9%83%D8%B1-%D8%A7%D9%84%D9%85%D9%87%D8%A7%D8%AC%D9%85-%D8%AE%D8%B7%D9%88%D8%A9-%D8%A8%D8%AE%D8%B7%D9%88%D8%A9/) كيف تقرأ هذه الصفحات. ومن جهة الدفاع، مكتبة تظهر في عمليات كثيرة في وقت واحد وليست من Microsoft أو من برنامج تعرفه تستحق السؤال، وتجد قائمة المكتبات المحملة في كل عملية بـ [Process Explorer](https://arabroot.io/articles/process-explorer-%D9%85%D8%AF%D9%8A%D8%B1-%D8%A7%D9%84%D9%85%D9%87%D8%A7%D9%85-%D9%83%D9%85%D8%A7-%D9%8A%D8%AC%D8%A8-%D8%A7%D9%86-%D9%8A%D9%83%D9%88%D9%86/)، وتجد أحداث تحميل المكتبات Image Load في [Sysmon](https://arabroot.io/articles/sysmon-%D9%85%D8%B1%D8%A7%D9%82%D8%A8%D8%A9-%D8%A7%D9%85%D9%86%D9%8A%D8%A9-%D9%85%D8%AC%D8%A7%D9%86%D9%8A%D8%A9-%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-windows/) بالحدث رقم 7.

![خط زمني لعمليتين: الأب يركب الخطاف، ومع أول رسالة على خيط الابن يحمل النظام hookdll.dll فيه، وبعد إزالة الخطاف تبقى المكتبة حتى الرسالة التالية ثم تزال](https://arabroot.io/content/images/2026/11/windows-hooks-03-inject.webp)

النظام يحمل مكتبة الخطاف عند أول حدث، ويزيلها عند حدث لاحق، لا لحظة التركيب ولا لحظة الإزالة.

## كم يكلف الخطاف؟

تقول نظرة Microsoft العامة إن الخطافات تبطئ النظام لأنها تزيد العمل الذي يجب أن يفعله النظام لكل رسالة، فقسنا ذلك على نافذتنا: 200,000 رسالة بـ `PostMessage` ثم حلقة `PeekMessage` بلا خطاف ثم مع خطاف `WH_GETMESSAGE` فارغ لا يفعل إلا `CallNextHookEx`، ثم 200,000 رسالة بـ `SendMessage` مع خطاف `WH_CALLWNDPROC` فارغ ثم بلا خطاف:

```text
> hooklab.exe cost 200000
no hook         post+peek  200000 messages in   1078.3 ms =   5391 ns per message
WH_GETMESSAGE   post+peek  200000 messages in   1476.8 ms =   7384 ns per message
WH_CALLWNDPROC  SendMessage  200000 messages in   1189.2 ms =   5946 ns per message
no hook         SendMessage  200000 messages in     15.6 ms =     78 ns per message
[exit code 0 = 0x00000000]
```

والنتيجة الأولى متوقعة: الرسالة عبر الطابور كلفت 5.4 ميكروثانية، وزادها الخطاف الفارغ إلى 7.4 ميكروثانية، أي قرابة 37%. أما النتيجة الثانية فهي التي تستحق الانتباه: `SendMessage` إلى نافذة في الخيط نفسه كلفت 78 نانوثانية فقط، لأنها استدعاء دالة تقريباً دون أي مرور بالنواة، وعندما وجد خطاف `WH_CALLWNDPROC` ولو كان فارغاً صارت 5,946 نانوثانية، أي أبطأ بأكثر من 70 ضعفاً. والسبب أن النظام يجب أن يستدعي الخطاف قبل كل رسالة، فلم يعد يستطيع أن يأخذ الطريق المختصر. وفي برنامج حقيقي ترسل الواجهة آلاف الرسائل في الثانية لكل حركة فأرة وكل إعادة رسم، وبالتالي برنامج واحد يركب خطافاً عاماً من هذا النوع يبطئ واجهات كل البرامج على سطح المكتب، وهذا تفسير الموقف الثالث في بداية المقال.

![أعمدة تقارن كلفة الرسالة: SendMessage دون خطاف 78 نانوثانية ومع WH_CALLWNDPROC 5946 نانوثانية، وPostMessage مع الحلقة دون خطاف 5391 ومع WH_GETMESSAGE 7384](https://arabroot.io/content/images/2026/11/windows-hooks-04-cost.webp)

خطاف فارغ لا يفعل شيئاً جعل SendMessage أبطأ بأكثر من 70 ضعفاً.

## البديل الأخف: أحداث الواجهة WinEvents

إذا كان كل ما تريده أن تعرف متى أنشئت نافذة أو تغير عنوانها أو انتقل التركيز Focus، فلا تحتاج خطافاً على الرسائل. فقد أضافت Microsoft مع إمكانية الوصول Accessibility آلية أخرى اسمها أحداث الواجهة WinEvents، تركبها بالدالة `SetWinEventHook`، وتشرح [نظرتها العامة](https://learn.microsoft.com/en-us/windows/win32/winauto/winevents-overview?ref=arabroot.io) أن الأحداث تصلك عن تغيرات كائنات الواجهة لا عن الرسائل نفسها. وأهم ما فيها الخيار `WINEVENT_OUTOFCONTEXT`، الذي يجعل النظام يرسل الحدث إلى خيطك أنت بدلاً من حقن مكتبة في العملية الأخرى، وتشرح صفحة [الدوال داخل السياق وخارجه](https://learn.microsoft.com/en-us/windows/win32/winauto/in-context-and-out-of-context-hook-functions?ref=arabroot.io) الفرق بين الطريقتين. وفي المختبر حصرنا الأحداث في عمليتنا فقط برقمها، ثم أنشأنا زراً داخل نافذتنا وغيرنا العنوان وحذفنا الزر:

```text
> hooklab.exe winevent
SetWinEventHook(OUTOFCONTEXT, only process 30700) -> 00000000132413F3
    WndProc         got WM_SETTEXT "title 2"
  WinEvent EVENT_OBJECT_CREATE      hwnd class=? thread=11456
  WinEvent EVENT_OBJECT_NAMECHANGE  hwnd class=HookLabWindow thread=11456
  WinEvent EVENT_OBJECT_DESTROY     hwnd class=? thread=11456
[exit code 0 = 0x00000000]
```

وصلتنا الأحداث الثلاثة، ولكن لاحظ أن اسم كلاس النافذة ظهر `?` في حدث الإنشاء وحدث الحذف، وظهر `HookLabWindow` في حدث تغيير العنوان. والسبب أن الأحداث خارج السياق غير متزامنة Asynchronous، فالنظام يضعها في طابور خيطك ويكمل، وعندما وصل حدث الإنشاء إلى دالتنا كان الزر قد حذف بالفعل، فلم تجد `GetClassNameW` نافذة تسأل عنها. وهذا هو الثمن: لا تأخير على البرنامج المراقب، ولكن ما تراه قد يكون تاريخاً لا حاضراً، فاحفظ ما تحتاجه من الحدث نفسه ولا تفترض أن النافذة ما زالت موجودة.

## الخطافات العامة والمستوى المنخفض Low-level Hooks: ما لا نجربه على جهاز حقيقي

الخطاف العام من نوع `WH_KEYBOARD` أو `WH_GETMESSAGE` يعمل كما رأينا في تجربة الحقن، ولكن على كل خيط في سطح المكتب: كل برنامج له واجهة على سطح مكتبك تحمل فيه المكتبة عند أول رسالة، ما دام بالعدد نفسه من البتات وبمستوى سلامة لا يزيد على مستوى البرنامج الذي ركب الخطاف. أما `WH_KEYBOARD_LL` فطريقه مختلف، وتشرحه [صفحة LowLevelKeyboardProc](https://learn.microsoft.com/en-us/windows/win32/winmsg/lowlevelkeyboardproc?ref=arabroot.io): النظام لا يحمل أي مكتبة في أي عملية، وإنما يرسل كل ضغطة مفتاح إلى خيط البرنامج الذي ركب الخطاف وينتظر رده، قبل أن يضعها في طابور البرنامج الذي يكتب فيه المستخدم. وبالتالي يجب أن يكون في ذلك الخيط حلقة رسائل تعمل، ويجب أن يرد بسرعة، والمهلة مكتوبة في القيمة `LowLevelHooksTimeout` تحت `HKEY_CURRENT_USER\Control Panel\Desktop`، وتقول الصفحة إن الحد الأعلى منذ Windows 10 الإصدار 1709 ثانية واحدة، وإن النظام منذ Windows 7 يزيل الخطاف بصمت إذا تجاوز المهلة، دون أن يعرف البرنامج أن خطافه أزيل.

وهذا التصميم هو سبب انتشار `WH_KEYBOARD_LL` في برامج تسجيل لوحة المفاتيح Keyloggers، لأنه لا يحتاج مكتبة، ولا يحتاج صلاحيات المدير، ويرى كل ضغطة في الجلسة قبل أن تصل إلى أي نافذة. ولذلك تذكر [تقنية تسجيل لوحة المفاتيح T1056.001 في MITRE ATT&CK](https://attack.mitre.org/techniques/T1056/001/?ref=arabroot.io) الدالة `SetWindowsHookEx` صراحة ضمن طرق التنفيذ. وفي المقابل له حدود تحميك: فهو لا يرى ضغطات شاشة الدخول ولا شاشة `Ctrl+Alt+Del`، لأنها على سطح مكتب آخر، ولا يرى ما تكتبه في نافذة تعمل كمدير إذا كان البرنامج نفسه يعمل بمستوى متوسط. وأما خطافات التسجيل وإعادة التشغيل `WH_JOURNALRECORD` و`WH_JOURNALPLAYBACK` فتقول نظرة Microsoft العامة إنها غير مدعومة منذ Windows 11 وسوف تزال، وتنصح بـ `SendInput` بدلاً منها.

### كيف تكتشف خطافاً عاماً على جهاز؟

لا توجد في Windows دالة موثقة في وضع المستخدم تعطيك قائمة الخطافات المركبة على سطح المكتب، فالسلاسل نفسها في ذاكرة `win32k` في النواة، ولا تعرض أدوات Sysinternals المعروفة مثل Process Explorer وAutoruns قائمة بها. والطريقة الوحيدة لقراءتها مباشرة هي مصحح النواة Kernel Debugger مع رموز `win32k`، وهذا عمل مختبر تحليل لا عمل مسؤول على جهاز مستخدم. ولذلك يعتمد الكشف عملياً على الآثار الجانبية بدلاً من القائمة نفسها:

- مكتبة واحدة غير معروفة محملة في عدد كبير من العمليات التي لها واجهة، وهذا أثر الخطاف العام داخل السياق، وتراه في Process Explorer بالبحث عن اسم المكتبة، وفي أحداث Sysmon رقم 7.
- عملية تعمل في الخلفية دون أي نافذة ظاهرة، ولكن لها خيط فيه حلقة رسائل، وتبدأ مع الدخول من مفتاح تشغيل تلقائي، وتجد مفاتيح التشغيل التلقائي كلها في [Autoruns](https://arabroot.io/articles/autoruns-%D9%83%D9%84-%D9%85%D8%A7-%D9%8A%D8%B9%D9%85%D9%84-%D8%AA%D9%84%D9%82%D8%A7%D8%A6%D9%8A%D8%A7-%D9%85%D8%B9-windows/). وهذا أثر خطاف المستوى المنخفض الذي لا يحمل مكتبة في أحد.
- برامج الحماية الحديثة من نوع EDR تسجل استدعاءات `SetWindowsHookEx` نفسها من داخل النواة، وقد شرح مقال [كيف يعمل وكيل EDR](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D9%88%D9%83%D9%8A%D9%84-edr-%D8%B9%D9%84%D9%89-%D8%A7%D9%84%D8%A3%D8%AC%D9%87%D8%B2%D8%A9/) من أين يأتي هذا النوع من المعلومات، وسوف نرى مصدره الأهم، أي تتبع الأحداث ETW، في مقال قادم من هذه المرحلة.
- وبطء عام في الواجهة يختفي عند إيقاف برنامج معين، وهذا ما قسناه في قسم الكلفة.

![مقارنة بين الخطاف العام WH_KEYBOARD الذي يحمل مكتبة في كل عملية لها واجهة، والخطاف WH_KEYBOARD_LL الذي يرسل كل ضغطة إلى خيط البرنامج المركب وينتظر رده بمهلة ثانية، مع آثار الكشف لكل منهما](https://arabroot.io/content/images/2026/11/windows-hooks-05-global.webp)

نوعان من الخطاف العام، ولكل نوع أثر مختلف تبحث عنه عند الكشف.

## هل الخطاف ثغرة أمنية؟

قد يتساءل البعض بعد التجارب السابقة: إذا كان أي برنامج بحساب مستخدم عادي يستطيع أن يحمل مكتبته في برامجي الأخرى، وأن يرى ما أكتبه، فلماذا لا تعده Microsoft ثغرة؟ والإجابة على ذلك أن حدود الأمان في Windows ليست بين برامج المستخدم نفسه، وإنما بين المستخدمين، وبين الجلسات، وبين مستويات السلامة. فالبرنامج الذي يعمل بحسابك يستطيع أصلاً أن يقرأ ملفاتك، وأن يفتح عملياتك الأخرى ويقرأ ذاكرتها، كما رأينا في مقالات Windows من الداخل، والخطاف لا يعطيه أكثر مما يملكه. أما الحدود الحقيقية فهي التي رأيناها في قسم العمل من الداخل: سطح المكتب، والجلسة، وUIPI. ولذلك يعرض Windows نافذة طلب الرفع في التحكم بحساب المستخدم UAC على سطح مكتب آمن Secure Desktop منفصل، كما تشرح [صفحة كيف يعمل UAC](https://learn.microsoft.com/en-us/windows/security/application-security/application-control/user-account-control/how-it-works?ref=arabroot.io)، حتى لا يستطيع برنامج يعمل بحسابك أن يرى أو يحاكي الضغط على زر الموافقة. والدرس العملي من هذا أن الحماية من خطاف ضار تبدأ قبل الخطاف نفسه: ألا يعمل البرنامج الضار بحسابك أصلاً، وأن تكتب كلمات المرور الحساسة في نوافذ يعرضها النظام على سطح المكتب الآمن، لا في نوافذ عادية يراها كل برنامج في جلستك.

## أخطاء شائعة Common Mistakes

- **نسيان `CallNextHookEx`**. رأينا في المختبر أن الخطاف الذي لا يمرر الحدث يحجب كل الخطافات بعده، وفي الأنواع التي تفهم القيمة المعادة كقرار يلغي الحدث نفسه. لذلك استدع `CallNextHookEx` في كل مسار داخل الإجراء، وأعد قيمتها كما هي إلا إذا كنت تقصد الإلغاء.
- **إهمال `code` السالب**. تقول كل صفحات الإجراءات إن قيمة `code` إذا كانت أقل من صفر يجب أن تمرر الحدث مباشرة دون أي معالجة، وفي المختبر نتحقق من `HC_ACTION` قبل أي عمل.
- **عمل طويل داخل الإجراء**. الإجراء يعمل في الخيط المستهدف، أو في خيطك مع خطافات المستوى المنخفض، فأي انتظار فيه يعلق الواجهة، ومع `WH_KEYBOARD_LL` يزيل النظام خطافك بصمت بعد ثانية. لذلك انسخ ما تحتاجه وأرسله إلى خيط آخر، وارجع فوراً.
- **مكتبة واحدة لعمليات 32 و64 بت**. النظام لا يحمل مكتبة 64 بت في عملية 32 بت، فإذا احتجت خطافاً عاماً يشمل الاثنين فتحتاج مكتبتين باسمين مختلفين وبرنامجين يركبانهما.
- **افتراض أن الخطاف زال لحظة `UnhookWindowsHookEx`**. رأينا أن المكتبة بقيت في العملية الأخرى حتى الحدث التالي، فلا تحذف ملف المكتبة أو تحدثه وأنت تفترض أن لا أحد يستعمله.
- **اختبار خطاف لوحة المفاتيح برسائل مصطنعة**. رسالة `WM_KEYDOWN` المرسلة بـ `PostMessage` لا تمر بـ `WH_KEYBOARD`، فإذا اعتمدت عليها في الاختبار ستظن أن الخطاف لا يعمل.
- **خطاف عام لحل مشكلة نافذتك أنت**. إذا أردت تغيير سلوك نافذة في برنامجك، فإن الإحلال الفرعي Subclassing بالدالة `SetWindowSubclass` يعمل على نافذتك وحدها دون أي أثر على الجهاز، وتشرحه [صفحة الإحلال الفرعي](https://learn.microsoft.com/en-us/windows/win32/controls/subclassing-overview?ref=arabroot.io).

## جدول قرار Decision Table: أي آلية تحتاج؟

| ما تريده                                                 | الآلية المناسبة                               | لماذا                                                     |
| -------------------------------------------------------- | --------------------------------------------- | --------------------------------------------------------- |
| تغيير سلوك نافذة في برنامجك                              | الإحلال الفرعي SetWindowSubclass              | لا يمس أي خيط أو عملية أخرى                               |
| مراقبة رسائل خيوط برنامجك لتصحيح خطأ                     | WH\_GETMESSAGE وWH\_CALLWNDPROC على خيطك      | داخل عمليتك، دون مكتبة، وتزيله بعد الانتهاء               |
| اختصار عام يعمل والبرنامج في الخلفية                     | RegisterHotKey                                | يصلك المفتاح المسجل فقط، لا كل ما يكتبه المستخدم          |
| معرفة إنشاء النوافذ وتغير التركيز في برامج أخرى          | SetWinEventHook خارج السياق، أو UI Automation | لا حقن لمكتبات، ولا تأخير على البرامج المراقبة            |
| إدخال لوحة المفاتيح والفأرة الخام في لعبة أو تطبيق رسومي | الإدخال الخام Raw Input                       | موثق لهذا الغرض، ويصلك الإدخال عندما تكون نافذتك المقصودة |
| إعادة تعيين المفاتيح على مستوى الجهاز كله                | WH\_KEYBOARD\_LL في خيط مخصص                  | الطريقة الوحيدة الموثقة، مع مسؤولية أمنية وأداء كبيرة     |
| محاكاة إدخال المستخدم في الاختبار الآلي                  | SendInput أو UI Automation                    | خطافات Journal غير مدعومة منذ Windows 11                  |

وتشرح [صفحة RegisterHotKey](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-registerhotkey?ref=arabroot.io) و[صفحة الإدخال الخام Raw Input](https://learn.microsoft.com/en-us/windows/win32/inputdev/about-raw-input?ref=arabroot.io) البديلين الأكثر استعمالاً، والقاعدة العامة أن تختار الآلية التي ترى أقل قدر من بيانات المستخدم يكفي لعملك، لأن كل ما يراه برنامجك يصبح مسؤوليتك إذا اخترق.

## قائمة فحص قبل أن تنشر برنامجاً فيه خطاف Checklist

- هل الخطاف على خيط برنامجك فقط؟ وإذا كان عاماً، فهل هناك سبب لا تحله آلية من جدول القرار؟
- هل يستدعي الإجراء `CallNextHookEx` في كل مسار، ويتجاهل `code` السالب؟
- هل الإجراء ينسخ ما يحتاجه ويرجع خلال ميلي ثوان قليلة، دون ملفات أو شبكة أو أقفال؟
- هل تزيل الخطاف عند الخروج وعند كل مسار خطأ، وهل يتحمل برنامجك بقاء المكتبة لحظات في العمليات الأخرى؟
- هل تبني المكتبة بنسختي 32 و64 بت إذا كان الخطاف عاماً، وهل وقعت المكتبة بتوقيع رقمي حتى لا تبدو لبرامج الحماية مكتبة غريبة؟
- هل يكتب البرنامج أي شيء مما يراه إلى القرص أو الشبكة؟ وإذا كان يرى ضغطات مفاتيح، فهل المستخدم يعرف ذلك ووافق عليه؟

## تدريب عملي Practice

1. أضف إلى `hooklab.c` خطافاً ثالثاً C من النوع `WH_GETMESSAGE` يركب بعد B، ويحذف كل رسالة `WM_CHAR` بحرف صوتي. وتوقع قبل التشغيل ماذا سوف يرى B وA ودالة النافذة.
2. ركب خطاف `WH_CBT` على خيطك، ثم أنشئ زراً داخل نافذتك المخفية، واجعل الإجراء يعيد قيمة غير الصفر عند `HCBT_CREATEWND`. ماذا تعيد `CreateWindowExW`؟
3. في تجربة الحقن، أرسل الرسائل الثالثة والرابعة بعد ثانيتين من الإزالة بدلاً من نصف ثانية. هل يتغير وقت إزالة المكتبة من الابن؟ وماذا تستنتج؟
4. قس كلفة `WH_GETMESSAGE` بخطاف واحد ثم بخمسة خطافات فارغة متتالية، وارسم النتيجة.

## حذف المختبر Cleanup

السكربت `99-cleanup.ps1` يوقف أي نسخة من `hooklab.exe` بقيت من مجلد المختبر، ثم يحذف المجلد، وطبع:

```text
lab folder removed: True
```

والخطافات نفسها لا تحتاج أي حذف، لأن النظام يزيل كل خطافات الخيط عندما ينتهي الخيط الذي ركبها، وكل خطاف في المختبر ركبته عملية انتهت قبل أن يصل السكربت إلى هذه الخطوة. ولم يغير المختبر أي شيء في السجل Registry، ولم يفتح أي نافذة ظاهرة، ولم يرسل أي رسالة أو إدخال إلى برنامج لم يشغله بنفسه.

## الخلاصة Summary

- الخطاف إجراء يستدعيه النظام عند نقطة ثابتة في طريق الرسائل، وآخر خطاف ركب هو أول من يرى الحدث، وكل خطاف يرى ما تركه الذي قبله.
- أغلب الأنواع تعمل داخل الخيط المستهدف، فإذا كان الخيط في عملية أخرى حمل النظام مكتبتك فيها عند أول حدث، وأزالها عند حدث لاحق بعد الإزالة.
- `WH_KEYBOARD` لا يرى الرسائل المصطنعة بـ `PostMessage`، وإنما الإدخال الحقيقي، و`WH_KEYBOARD_LL` يرى كل ضغطة في الجلسة دون أي مكتبة، ولذلك هو أداة برامج تسجيل لوحة المفاتيح.
- خطاف فارغ جعل `SendMessage` أبطأ بأكثر من 70 ضعفاً، فالخطاف العام كلفة يدفعها كل برنامج على سطح المكتب.
- لا توجد قائمة موثقة للخطافات في وضع المستخدم، فالكشف يكون بالآثار: مكتبة في عمليات كثيرة، أو عملية خلفية بحلقة رسائل تبدأ مع الدخول، أو سجلات EDR.
- اختر أضيق آلية تكفي: الإحلال الفرعي لنافذتك، و`RegisterHotKey` للاختصار، وWinEvents للمراقبة، وقبل أي خطاف عام.

وفي المقال التالي من هذه المرحلة ننتقل من الخطافات التي يقدمها النظام إلى اعتراض الدوال API Hooking: كيف تغير أدوات المراقبة وبرامج الحماية أول بايتات دالة مثل `CreateFileW` في الذاكرة، وكيف تفعل ذلك مكتبة Detours من Microsoft، وكيف تكتشف هذا التغيير بمقارنة الذاكرة بالملف.

## سجل التحديثات Changelog

- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) بـ Windows PowerShell 5.1 دون صلاحيات المدير، مع hooklab.exe وhookdll.dll مبنيين بمترجم Microsoft C/C++ الإصدار 19.51 لمعمارية x64.