hwbp4mw

// set our debug information in the Dr registers

SetThreadContext(thd, &context);

هناك 8 سجلات تصحيح (Debug registers)، من Dr0 إلى Dr7. التي تهمنا هي فقط
Dr0-3 حيث نخزن العناوين التي نريد التوقف عندها، وDr6 هو مجرد حالة
التصحيح. الأهم هو Dr7، الذي يصف شروط نقاط التوقف التي سيرمي
المعالج استثناءً عندها. هناك قيود مختلفة عند استخدام سجلات التصحيح،
مثل عدد محدود (4) وعدم تطبيقها على جميع الخيوط/الخيوط المنشأة حديثًا.
سنسعى إلى معالجة بعض هذه القيود!

عندما يتم رمي الاستثناء، سيبحث عن معالج استثناء يمكننا تعريفه
وتسجيله في برنامجنا [1]. في معالج الاستثناء المعرّف لدينا، نريد أن يتم تشغيل الكود المرتبط
(مسارات كود مختلفة) عندما يتم تفعيل نقطة التوقف المقابلة.```c
LONG WINAPI ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
{
	if (ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_SINGLE_STEP)
	{
		// Look for our associated code flow relative to our RIP 
		if (HWBP_ADDRESS_MAP.contains(ExceptionInfo->ContextRecord->Rip)) {
			HWBP_ADDRESS_MAP.at(ExceptionInfo->ContextRecord->Rip).func(ExceptionInfo);
			return EXCEPTION_CONTINUE_EXECUTION;
		}
	}
	return EXCEPTION_CONTINUE_SEARCH;
}

يجب علينا التكرار عبر جميع مؤشرات ترابط العملية وتعيين التعديلات المقابلة
للسياق لكل منها. يمكن تحقيق ذلك باستخدام الدوال المساعدة ToolHelp32:
CreateToolhelp32Snapshot، وThread32Next. هذا ليس شيئًا معقدًا، لكنه يعالج أحد
قيودنا المتمثلة في عدم الارتباط بجميع مؤشرات الترابط.```c
VOID SetHWBPS(const uintptr_t address, const UINT pos, const bool init = true)
{
	DWORD pid{ GetCurrentProcessId() };
	HANDLE h{ CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0) };
	if (h != INVALID_HANDLE_VALUE) {
		THREADENTRY32 te{ .dwSize = sizeof(THREADENTRY32) };
		if (Thread32First(h, &te)) {
			do {
				if ((te.dwSize >= FIELD_OFFSET(THREADENTRY32, th32OwnerProcessID) +
					sizeof(te.th32OwnerProcessID)) && te.th32OwnerProcessID == pid) {

					HANDLE thd = OpenThread(THREAD_ALL_ACCESS, FALSE, te.th32ThreadID);
					if (thd != INVALID_HANDLE_VALUE) {
						SetHWBP(thd, address, pos, init);
						CloseHandle(thd);
					}
				}
				te.dwSize = sizeof(te);
			} while (Thread32Next(h, &te));
		}
		CloseHandle(h);
	}
}

مثال على نقطة توقف الأجهزة سيكون Sleep، حيث نستبدل مدة السكون
بـ 0.```c
HWBP HWBPSleep{ (uintptr_t)&Sleep, 0,	// Set Dr 0 
	([&](PEXCEPTION_POINTERS ExceptionInfo) {
		ExceptionInfo->ContextRecord->Rcx = 0;
		ExceptionInfo->ContextRecord->EFlags |= (1 << 16);	// continue execution
}) };

// save original thread address
START_THREAD = (PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x28);
// set the start address to our thread address 
*(PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x28) = (uintptr_t)&HijackThread;

ExceptionInfo->ContextRecord->EFlags |= (1 << 16);

// Set required HWBP
for (auto& i : HWBP_ADDRESS_MAP) {
	SetHWBP(GetCurrentThread(), i.first, i.second.pos, true);
}

// restore execution to original thread
return ((typeThreadProc)START_THREAD)(lpParameter);

أحد قيود هذا الحل هو أن مكدس الاستدعاءات للخيط سينشأ في
`HijackThread` الخاص بـ DLL المحقون لدينا وليس في الخيط الأصلي! بدلاً من ذلك، الحل الأفضل
سيكون استدعاء `NtCreateThreadEx` بأنفسنا ولكن تشغيله في حالة معلّقة
ثم تعيين نقاط التوقف العتادية المطلوبة. ثم نستعيد التنفيذ عن طريق استئناف
الخيط المعلّق مع ضبط سجلات التصحيح لهذا الخيط الجديد. هذا سيعالج
قيودًا أخرى لاستخدام سجلات التصحيح.

استدعاء التعليمات التي لدينا نقطة توقف مضبوطة عليها سيؤدي إلى حلقة لا نهائية؛
لذلك، نعطّل مؤقتًا نقطة التوقف العتادية المسؤولة عن تشغيل
عنوان `RIP` الحالي لدينا. وبمجرد الانتهاء من إجراء الاستدعاء، يمكننا استعادتها. سيتيح لنا هذا
استدعاء الدالة الأصلية (مثل الترامبولين). في هذه الحالة، يجب أن نشير إلى `RIP` الخاص بنا إلى
أداة `ret` بحيث يمكنها العودة وعدم تنفيذ تعليمة `syscall` أخرى.

المعامل الخامس، ومنه فصاعدًا، يمكن العثور عليه مدفوعًا على المكدس على فترات `0x8` بايت [2]. يبدو مكدسنا شيئًا كهذا عندما نشغّل نقطة التوقف.```
                ___________________________
               |                           |
               | 0x8 + lpBytesBuffer       |
               |___________________________|
               |                           |
               | 0x8 + SizeOfStackReserve  |
               |___________________________|
               |                           |
               | 0x8 + SizeOfStackCommit   |
               |___________________________|
               |                           |
               | 0x8 + StackZeroBits       |
               |___________________________|
               |                           |
               | 0x8 + Flags               |
               |___________________________|
               |                           |
               | 0x8 + lpParameter         |
               |___________________________|
               |                           |
               | 0x8 + lpStartAddress      |
RSP + 0x28 +-> |___________________________|
               |                           |
               |                           |
               |                           |  R9  +-> (HANDLE)ProcessHandle
               | 0x20 + Shadow Store       |  R8  |-> (PVOID) ObjectAttributes
               |                           |  RDX |-> (ACCESS_MASK) DesiredAccess
               |                           |  RCX +-> (PHANDLE) hThread
               |___________________________|
               |                           |
               | 0x8 + Call Ret Addr       |  RIP +-> NtCreateThreadEx
       RSP +-> |___________________________|

// Find our ret ROP gadget 
uintptr_t FindRetAddr(const uintptr_t function)
{
	BYTE stub[]{ 0xC3 };
	for (unsigned int i = 0; i < (unsigned int)25; i++)
	{	
		// do not worry this will be optimized
		if (memcmp((LPVOID)(function + i), stub, sizeof(stub)) == 0) {
			return (function + i);
		}
	}
	return NULL;
}

typedef LONG(NTAPI* typeNtCreateThreadEx)(
	OUT PHANDLE hThread,
	IN ACCESS_MASK DesiredAccess,
	IN PVOID ObjectAttributes,
	IN HANDLE ProcessHandle,
	IN PVOID lpStartAddress,
	IN PVOID lpParameter,
	IN ULONG Flags,
	IN SIZE_T StackZeroBits,
	IN SIZE_T SizeOfStackCommit,
	IN SIZE_T SizeOfStackReserve,
	OUT PVOID lpBytesBuffer
); 

HWBP HWBPNtCreateThreadEx{ (uintptr_t)GetProcAddress(GetModuleHandle(L"NTDLL.dll"),
										  "NtCreateThreadEx"), 1,
	([&](PEXCEPTION_POINTERS ExceptionInfo) {

		// temporary disable of NtCreateThreadEx in our current thread.
		for (auto& i : HWBP_ADDRESS_MAP) {
			if (i.first == ExceptionInfo->ContextRecord->Rip) {	
				SetHWBP(GetCurrentThread(), i.first, i.second.pos, false);
			}
		}

		// create the original thread BUT suspended 
		// THREAD_CREATE_FLAGS_CREATE_SUSPENDED == 0x00000001
		// ( Flags | THREAD_CREATE_FLAGS_CREATE_SUSPENDED)
		LONG status = ((typeNtCreateThreadEx)ExceptionInfo->ContextRecord->Rip)(
			(PHANDLE)ExceptionInfo->ContextRecord->Rcx,
			(ACCESS_MASK)ExceptionInfo->ContextRecord->Rdx,
			(PVOID)ExceptionInfo->ContextRecord->R8,
			(HANDLE)ExceptionInfo->ContextRecord->R9,
			(PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x28),
			(PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x30),
			(ULONG) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x38) | 0x1ull,
			(SIZE_T) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x40),
			(SIZE_T) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x48),
			(SIZE_T) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x50),
			(PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x58)
		);


		CONTEXT context = { .ContextFlags = CONTEXT_DEBUG_REGISTERS };

		GetThreadContext((HANDLE)(*(PULONG64)ExceptionInfo->ContextRecord->Rcx),
			&context);
		
		// Setup required HWBP
		for (auto& i : HWBP_ADDRESS_MAP) {
			(&context.Dr0)[i.second.pos] = i.first;

			context.Dr7 &= ~(3ull << (16 + 4 * i.second.pos));
			context.Dr7 &= ~(3ull << (18 + 4 * i.second.pos));
			context.Dr7 |= 1ull << (2 * i.second.pos);
		}

		SetThreadContext((HANDLE)(*(PULONG64)ExceptionInfo->ContextRecord->Rcx),
			&context);

		ResumeThread((HANDLE)(*(PULONG64)ExceptionInfo->ContextRecord->Rcx));

		// restore our HWBP on NtCreateThreadEx
		for (auto& i : HWBP_ADDRESS_MAP) {
			if (i.first == ExceptionInfo->ContextRecord->Rip) {	
				SetHWBP(GetCurrentThread(), i.first, i.second.pos, false);
			}
		}
		
		// RAX contains the return value.
		ExceptionInfo->ContextRecord->Rax = status;

		// Set RIP to a ret gadget to avoid creating 
		// another new thread (skip syscall instruction) 
		ExceptionInfo->ContextRecord->Rip = 
			FindRetAddr(ExceptionInfo->ContextRecord->Rip);
}) };

if (init) {
	(&context.Dr0)[pos] = address;

	context.Dr7 &= ~(3ull << (16 + 4 * pos));
	context.Dr7 &= ~(3ull << (18 + 4 * pos));
	context.Dr7 |= 1ull << (2 * pos);
}
else {
	if ((&context.Dr0)[pos] == address) {
		context.Dr7 &= ~(1ull << (2 * pos));
		(&context.Dr0)[pos] = NULL;
	}
}

SetThreadContext(thd, &context);

				const HANDLE thd = 
								OpenThread(THREAD_ALL_ACCESS, FALSE, te.th32ThreadID);
				if (thd != INVALID_HANDLE_VALUE) {
					SetHWBP(thd, address, pos, init);
					CloseHandle(thd);
				}
			}
			te.dwSize = sizeof(te);
		} while (Thread32Next(h, &te));
	}
	CloseHandle(h);
}

	HWBP_ADDRESS_MAP[address].func = function;
	HWBP_ADDRESS_MAP[address].pos = pos;
};

VOID RemoveHWBPS()
{
	SetHWBPS(address, pos, false);
	HWBP_ADDRESS_MAP.erase(address);
}

~HWBP()
{
	RemoveHWBPS();
}

}; break;
case DLL_PROCESS_DETACH: {
	if (handler != nullptr) RemoveVectoredExceptionHandler(handler);
}; break;
}
return TRUE;

كما ناقشنا سابقًا، فإن إبقاء سجلات التصحيح (debug registers) محجوزة هو ممارسة سيئة. لذلك، سنكمّل استخدامنا لسجلات التصحيح بخطافات PAGE_GUARD، مما يتيح لنا تحرير أحد سجلات التصحيح: Dr1 (المستخدم لـ NtCreateThreadEx).

إن PAGE_GUARDs هي في الأساس حماية ذاكرة تُستخدم لمرة واحدة وتُطلق استثناءً. تُطبَّق على الصفحات عند أدنى مستوى من دقة التخصيص (allocation granularity) الموجود في النظام (والذي قد يثبت أحيانًا أنه عائق). إن ربط PAGE_GUARD ليس بأمر جديد، لكن يمكننا استخدامه لمعالجة بعض القيود التي نواجهها. سنطبّق في البداية PAGE_GUARD على العنوان، وسيتم تشغيل PAGE_GUARD عبر إطلاق استثناء PAGE_GUARD_VIOLATION.

VirtualProtect((LPVOID)address, 1, PAGE_EXECUTE_READ | PAGE_GUARD, &old);

يمكننا تطبيق نفس مفهوم ربط lambda للتفعيل عند عنوان معيّن. سننفّذ تعليمات الدالة خطوة بخطوة (single-step) على صفحتنا الحالية مع إعادة تطبيق PAGE_GUARD. من الواضح أن هذا بطيء نسبيًا، لكن له ميزة عدم شغل سجل تصحيح (Debug register). ولأن السبب الرئيسي هو البطء، فقد اخترنا عدم استخدامها كخيار أساسي.```c
typedef struct {
	EXCEPTION_FUNC								func;
} PG_CALLBACK;

std::unordered_map<uintptr_t, PG_CALLBACK>	PG_ADDRESS_MAP{ 0 };

PG_ADDRESS_MAP[address].func = function;

if (init) {
    (&context.Dr0)[pos] = address;

    context.Dr7 &= ~(3ull << (16 + 4 * pos));
    context.Dr7 &= ~(3ull << (18 + 4 * pos));
    context.Dr7 |= 1ull << (2 * pos);
}
else {
    if ((&context.Dr0)[pos] == address) {
        context.Dr7 &= ~(1ull << (2 * pos));
        (&context.Dr0)[pos] = NULL;
    }
}

SetThreadContext(thd, &context);

                const HANDLE thd = OpenThread(THREAD_ALL_ACCESS, FALSE, te.th32ThreadID);
                if (thd != INVALID_HANDLE_VALUE) {
                    SetHWBP(thd, address, pos, init);
                    CloseHandle(thd);
                }
            }
            te.dwSize = sizeof(te);
        } while (Thread32Next(h, &te));
    }
    CloseHandle(h);
}

return 0;

    HWBP_ADDRESS_MAP[address].func = function;
    HWBP_ADDRESS_MAP[address].pos = pos;
};

VOID RemoveHWBPS()
{
    SetHWBPS(address, pos, false);
    HWBP_ADDRESS_MAP.erase(address);
}

~HWBP()
{
    RemoveHWBPS();
}

    VirtualProtect((LPVOID)address, 1, PAGE_EXECUTE_READ | PAGE_GUARD, &old);

    PG_ADDRESS_MAP[address].func = function;
}

VOID RemovePGEntry()
{
    VirtualProtect((LPVOID)address, 1, old, &old);
    PG_ADDRESS_MAP.erase(address);
}

~PGBP()
{
    RemovePGEntry();
}

HWBP HWBPSleep{
    (uintptr_t)&Sleep,
    1,
    ([&](PEXCEPTION_POINTERS ExceptionInfo) {
        printf("Sleeping %lld\n", ExceptionInfo->ContextRecord->Rcx);
        ExceptionInfo->ContextRecord->Rcx = 0;
        ExceptionInfo->ContextRecord->EFlags |= (1 << 16);    // continue execution
}) };


PGBP VEHNtCreateThreadEx{
    (uintptr_t)GetProcAddress(
        GetModuleHandle(L"NTDLL.dll"),
        "NtCreateThreadEx"
    ),
([&](PEXCEPTION_POINTERS ExceptionInfo) {

        // create a new thread suspended
        LONG status = ((typeNtCreateThreadEx)ExceptionInfo->ContextRecord->Rip)(
            (PHANDLE)ExceptionInfo->ContextRecord->Rcx,
            (ACCESS_MASK)ExceptionInfo->ContextRecord->Rdx,
            (PVOID)ExceptionInfo->ContextRecord->R8,
            (HANDLE)ExceptionInfo->ContextRecord->R9,
            (PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x28),
            (PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x30),
            (ULONG) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x38) | 0x1ull,
            (SIZE_T) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x40),
            (SIZE_T) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x48),
            (SIZE_T) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x50),
            (PVOID) * (PULONG64)(ExceptionInfo->ContextRecord->Rsp + 0x58)
        );

        CONTEXT context{ 0 };
        context.ContextFlags = CONTEXT_DEBUG_REGISTERS;

        GetThreadContext((HANDLE)(*(PULONG64)ExceptionInfo->ContextRecord->Rcx),
            &context);

        for (auto& i : HWBP_ADDRESS_MAP) {
            (&context.Dr0)[i.second.pos] = i.first;

            context.Dr7 &= ~(3ull << (16 + 4 * i.second.pos));
            context.Dr7 &= ~(3ull << (18 + 4 * i.second.pos));
            context.Dr7 |= 1ull << (2 * i.second.pos);
        }

        SetThreadContext((HANDLE)(*(PULONG64)ExceptionInfo->ContextRecord->Rcx),
            &context);

        ResumeThread((HANDLE)(*(PULONG64)ExceptionInfo->ContextRecord->Rcx));

        ExceptionInfo->ContextRecord->Rax = status;

        ExceptionInfo->ContextRecord->Rip =
            FindRetAddr(ExceptionInfo->ContextRecord->Rip);
    }) };


Sleep(1000000);

for (unsigned int i = 0; i < 2; ++i) {
    HANDLE t = CreateThread(NULL, 0, TestThread, NULL, 0, NULL);
    if (t) WaitForSingleObject(t, INFINITE);
}

if (handler) RemoveVectoredExceptionHandler(handler);

بعد تطبيق النظرية لإنشاء محرك ربط نقاط توقف العتاد متعدد الاستخدامات، سنواصل استخدام مزيج من سجلات التصحيح وPAGE_GUARDs، كما هو موضح في أمثلتنا السابقة، لتنفيذ باب خلفي مستوحى من SockDetour [3] كـ DLL بلغة C++. سنضع نقطة توقف عتادية على دالة recv لتحقيق ذلك وبناء المنطق المطلوب في lambda المقابلة. سنطبّق أيضًا PAGE_GUARD على NtCreateThreadEx ونستخدم أسلوبنا السابق في إنشاء الخيط في حالة معلّقة لتعيين سجلات التصحيح الصحيحة.

على الرغم من الطبيعة البطيئة لروابط PAGE_GUARD، لا ينبغي أن يكون ذلك مشكلة طالما أن نموذج الخادم لا ينشئ خيطًا جديدًا لكل طلب، مما يؤدي إلى أداء دون المستوى الأمثل. تحتفظ معظم نماذج خوادم الشبكات بمجموعة من الخيوط التي تبدأ وتُهيأ عند بدء البرنامج. لمزيد من الفهم حول نماذج الخوادم هذه، توفّر Microsoft مجموعة متنوعة من الأمثلة على Github [4]؛ مثال IOCP هو مثال ممتاز لما يبدو عليه نموذج خادم فعّال وقابل للتوسع للسياق.

يمكن أن تبدو بداية بابك الخلفي على هذا النحو:

HWBP recv_hook{ (uintptr_t)GetProcAddress((LoadLibrary(L"WS2_32.dll"),
	GetModuleHandle(L"WS2_32.dll")),"recv"), 3,
	([&](PEXCEPTION_POINTERS ExceptionInfo) {
		
		for (auto& i : ADDRESS_MAP) {
			if (i.first == ExceptionInfo->ContextRecord->Rip) {
				SetHWBP(GetCurrentThread(), i.first, i.second.pos, false);
			}
		}

		char verbuf[9]{ 0 };
		int	verbuflen{ 9 }, recvlen{ 0 };

		recvlen = recv(ExceptionInfo->ContextRecord->Rcx, verbuf,
				   verbuflen, MSG_PEEK);

		BYTE TLS[] = { 0x17, 0x03, 0x03 };

		if (recvlen >= 3) {
			if ((memcmp(verbuf, TLS, 3) == 0))1
			{
				MSG_AUTH msg{ 0 };
				// We'll peek like SockDetour as to not eat the message
				recvlen = recv(ExceptionInfo->ContextRecord->Rcx, (char*)&msg,
					sizeof(MSG_AUTH), MSG_PEEK);
					// Authenticate and proceed

			}
		}

		// Set corresponding Dr
		for (auto& i : ADDRESS_MAP) {
			if (i.first == ExceptionInfo->ContextRecord->Rip) {
				SetHWBP(GetCurrentThread(), i.first, i.second.pos, true);
			}
		}

		ExceptionInfo->ContextRecord->EFlags |= (1 << 16);
}) };


سننهي بتنفيذ تقنية مراوغة عامة في مساحة المستخدم (userland) على x64 مستوحاة من TamperingSyscalls، والتي تستخدم نسخة معدلة بشكل مناسب من محرك نقاط توقف العتاد الذي عُرض سابقًا لإخفاء ما يصل إلى 12 وسيطًا من وسائط أي 4 استدعاءات نظامية (Nt syscalls) في أي وقت واحد لكل خيط. لاحظ أنني اخترت عدم نشر محتوى سجلات التصحيح إلى جميع الخيوط، لأن ذلك قد يكون غير مرغوب فيه (إذا رغبت، استبدل SetHWBP بـ SetHWBPS).

لا حاجة لوصف سبب كون هذا مرغوبًا وفائق الروعة (super EPIC)، ولا للخوض في ربط مساحة المستخدم (userland hooking)، فهذه ليست الموضوعات المطروحة أو موضع الاهتمام، وقد تمت تغطيتها بعمق عدة مرات [5].

ننشئ تعيينًا جديدًا (mapping) باستخدام (address | ThreadID) كمفتاح فريد، وتكون القيمة بنية تحتوي على وسائط الدالة. سننشئ مدخلًا جديدًا في تعييننا عند الدخول إلى الاستدعاء النظامي ونمسح القيم الموجودة في السجلات والمكدس.

نستخدم التنفيذ خطوة بخطوة (single-stepping) عبر علم المصيدة (trap flag) للتظاهر بأن لدينا سجلات تصحيح أكثر مما نمتلك فعليًا. يمكننا فعل ذلك، لأننا نعرف متى وأين يجب أن تحدث إجراءات محددة.

عندما نصل إلى عنوان الاستدعاء النظامي المطلوب، نستعيد قيمنا من مدخل hashmap المرتبط بمفتاحنا. يؤدي هذا إلى إعادة القيم الموجودة على المكدس إلى السجلات. ثم نتابع التنفيذ خطوة بخطوة حتى تعليمة الإرجاع، حيث نتوقف عن التنفيذ خطوة بخطوة ونكمل!

يتيح لنا ذلك في النهاية ربطًا بلا أنواع (typeless hooking). علاوة على ذلك، حددنا في البداية أننا سنخفي 12 وسيطًا فقط، 4 من السجلات و8 من المكدس. هذه القيمة "8" تعسفية لكنها موصى بها، وقد يؤدي إخفاء أو تغيير المزيد من القيم/الوسائط على المكدس إلى سلوك غير مرغوب.

يجب أن ينشأ مكدس الاستدعاءات لدينا بالفعل من DLL مناسب، وبالتالي لن تحتاج إلى استدعاء الدوال الأصلية (Native functions) ويمكنك استدعاء غلاف مناسب (wrapper) من أي DLL بشرط استدعاء المُنشئ مع عنوان الدالة الأصلية في NTDLL.

هذا أمر تافه ويمكن تحقيقه بتغيير الماكرو:
#define STK_ARGS 8		// 12 - 4 = 8 - should cover most Nt functions. 

في المثال، نعرضه وهو يعمل مع NtCreateThreadEx وNtCreateMutant! تأكد من أنك تستخدم سجلات التصحيح الأربعة بشكل فردي لكل خيط فقط. بمجرد الانتهاء من دالة معينة، يمكنك تحرير سجل التصحيح المرتبط بها عن طريق استدعاء طريقة RemoveHWBPS.

1. إذا كان (addr == entry.first) فهذا يعني أننا عند تعليمة mov r10, rcx
 - نخزن وسائطنا في مدخل hashmap باستخدام المفتاح (TID | address)

const auto key = (address + 0x12) | GetCurrentThreadId();

SYSCALL_MAP[key].Rcx = ExceptionInfo->ContextRecord->Rcx;
SYSCALL_MAP[key].Rdx = ExceptionInfo->ContextRecord->Rdx;
SYSCALL_MAP[key].R8 = ExceptionInfo->ContextRecord->R8;
SYSCALL_MAP[key].R9 = ExceptionInfo->ContextRecord->R9;

for (size_t idx = 0; idx < STK_ARGS; idx++)
{
	const size_t offset = idx * 0x8 + 0x28;
	SYSCALL_MAP[key].stk[idx] =
		*(PULONG64)(ExceptionInfo->ContextRecord->Rsp + offset);
}
 - ثم نضبط قيم هذه الوسائط إلى 0 (يمكن أن تكون أي قيمة تعسفية أخرى)

ExceptionInfo->ContextRecord->Rcx = 0;
ExceptionInfo->ContextRecord->Rdx = 0;
ExceptionInfo->ContextRecord->R8 = 0;
ExceptionInfo->ContextRecord->R9 = 0;
// ...

 - ثم نضبط علم الاستئناف (Resume Flag) في البت 16 وعلم المصيدة (Trap Flag) في البت 8
 - سيؤدي هذا إلى متابعة التنفيذ، كالمعتاد، مع التأثير على الأداء بشكل طفيف فقط.

ExceptionInfo->ContextRecord->EFlags |= (1 << 16); // Resume Flag
ExceptionInfo->ContextRecord->EFlags |= (1 << 8);	// Trap Flag

2. واصل التنفيذ خطوة بخطوة حتى (addr == entry.second.sysc)
 - نحن الآن عند تعليمة الاستدعاء النظامي (syscall) وقد تجاوزنا أي روابط في مساحة المستخدم
 - نستعيد وسائطنا باستخدام مفتاح البحث السابق (TID | address).```c
auto const key = (address | GetCurrentThreadId());

// mov rcx, r10 
ExceptionInfo->ContextRecord->R10 = SYSCALL_MAP[key].Rcx;
ExceptionInfo->ContextRecord->Rcx = SYSCALL_MAP[key].Rcx;	
ExceptionInfo->ContextRecord->Rdx = SYSCALL_MAP[key].Rdx;
ExceptionInfo->ContextRecord->R8 = SYSCALL_MAP[key].R8;
ExceptionInfo->ContextRecord->R9 = SYSCALL_MAP[key].R9;

for (size_t idx = 0; idx < STK_ARGS; idx++)
{
	const size_t offset = idx * 0x8 + 0x28;
	*(PULONG64)(ExceptionInfo->ContextRecord->Rsp + offset) =
		SYSCALL_MAP[key].stk[idx];
}

					// 12 - 4 = 8 - should cover most Nt functions. 

if (init) {
	(&context.Dr0)[pos] = address;

	context.Dr7 &= ~(3ull << (16 + 4 * pos));
	context.Dr7 &= ~(3ull << (18 + 4 * pos));
	context.Dr7 |= 1ull << (2 * pos);
}
else {
	if ((&context.Dr0)[pos] == address) {
		context.Dr7 &= ~(1ull << (2 * pos));
		(&context.Dr0)[pos] = NULL;
	}
}

SetThreadContext(thd, &context);

	BYTE syscop[] = { 0x0F, 0x05 };
	ADDRESS_MAP[address].syscall_addr =
		FindRopAddress(address, syscop, sizeof(syscop));
	BYTE retnop[] = { 0xC3 };
	ADDRESS_MAP[address].return_addr =
		FindRopAddress(address, retnop, sizeof(retnop));
};

VOID RemoveHWBPS()
{
	SetHWBP(GetCurrentThread(), address, pos, false);
}

~TS2_HWBP()
{
	RemoveHWBPS();
}

			if (address == syscall_instr) // mov r10, rcx
			{
				const auto key = (address + 0x12) | GetCurrentThreadId();

				SYSCALL_MAP[key].Rcx = ExceptionInfo->ContextRecord->Rcx;
				SYSCALL_MAP[key].Rdx = ExceptionInfo->ContextRecord->Rdx;
				SYSCALL_MAP[key].R8 = ExceptionInfo->ContextRecord->R8;
				SYSCALL_MAP[key].R9 = ExceptionInfo->ContextRecord->R9;

				for (size_t idx = 0; idx < STK_ARGS; idx++)
				{
					const size_t offset = idx * 0x8 + 0x28;
					SYSCALL_MAP[key].stk[idx] =
						*(PULONG64)(ExceptionInfo->ContextRecord->Rsp + offset);
				}

				PRINT_ARGS("HIDING", ExceptionInfo);

				ExceptionInfo->ContextRecord->Rcx = 0;
				ExceptionInfo->ContextRecord->Rdx = 0;
				ExceptionInfo->ContextRecord->R8 = 0;
				ExceptionInfo->ContextRecord->R9 = 0;

				for (size_t idx = 0; idx < STK_ARGS; idx++)
				{
					const size_t offset = idx * 0x8 + 0x28;
					*(PULONG64)(ExceptionInfo->ContextRecord->Rsp + offset) = 0ull;
				}

				PRINT_ARGS("HIDDEN", ExceptionInfo);

				ExceptionInfo->ContextRecord->EFlags |= (1 << 16); // Resume Flag
			}
			else if (address == ai.syscall_addr)
			{
				auto const key = (address | GetCurrentThreadId());

				// SSN in ExceptionInfo->ContextRecord->Rax

				// mov rcx, r10 
				ExceptionInfo->ContextRecord->R10 = SYSCALL_MAP[key].Rcx;
				ExceptionInfo->ContextRecord->Rcx = SYSCALL_MAP[key].Rcx;
				ExceptionInfo->ContextRecord->Rdx = SYSCALL_MAP[key].Rdx;
				ExceptionInfo->ContextRecord->R8 = SYSCALL_MAP[key].R8;
				ExceptionInfo->ContextRecord->R9 = SYSCALL_MAP[key].R9;

				for (size_t idx = 0; idx < STK_ARGS; idx++)
				{
					const size_t offset = idx * 0x8 + 0x28;
					*(PULONG64)(ExceptionInfo->ContextRecord->Rsp + offset) =
						SYSCALL_MAP[key].stk[idx];
				}

				PRINT_ARGS("RESTORED", ExceptionInfo);

				SYSCALL_MAP.erase(key);
			}
			else if (address == ai.return_addr)
			{
				ExceptionInfo->ContextRecord->EFlags |= (1 << 16); // Resume Flag
				return EXCEPTION_CONTINUE_EXECUTION;
			}
			ExceptionInfo->ContextRecord->EFlags |= (1 << 8);	// Trap Flag
			return EXCEPTION_CONTINUE_EXECUTION;
		}
	}
}
return EXCEPTION_CONTINUE_SEARCH;

TS2_HWBP TS2NtCreateThreadEx{
	(uintptr_t)(GetProcAddress(GetModuleHandleW(L"NTDLL.dll"),
	"NtCreateThreadEx")),
	0
};

for (unsigned int i = 0; i < 2; ++i) {
	HANDLE t = CreateThread(nullptr, 0, TestThread, nullptr, 0, nullptr);
	if (t) WaitForSingleObject(t, INFINITE);
}

TS2NtCreateThreadEx.RemoveHWBPS();

if (handler != nullptr) RemoveVectoredExceptionHandler(handler);

TS2_HWBP TS2NtCreateMutant{
	(uintptr_t)(GetProcAddress(GetModuleHandleW(L"NTDLL.dll"),
	"NtCreateMutant")),
	0
};

HANDLE m = CreateMutexA(NULL, TRUE, "rad98");
if (m) CloseHandle(m);

return 0;

فيما يلي مثال على المخرجات، يُظهر وسائط NtCreateThreadEx المخفية.```
0x00007FFBDF485400 >= 0x00007FFBDF485400
0x00007FFBDF485400 <= 0x00007FFBDF485414
HIDING 12 arguments and stack for 0x00007FFBDF485400 || TID : 0x9ecc
1:      0x00000062618FF8D8
2:      0x00000000001FFFFF
3:      0x0000000000000000
4:      0xFFFFFFFFFFFFFFFF
5:      0x00007FF79FB01FA0
6:      0x0000000000000000
7:      0x0000000000000000
8:      0x0000000000000000
9:      0x0000000000000000
10:     0x0000000000000000
11:     0x00000062618FF9F0
12:     0x000001C700000000
HIDDEN 12 arguments and stack for 0x00007FFBDF485400 || TID : 0x9ecc
1:      0x0000000000000000
2:      0x0000000000000000
3:      0x0000000000000000
4:      0x0000000000000000
5:      0x0000000000000000
6:      0x0000000000000000
7:      0x0000000000000000
8:      0x0000000000000000
9:      0x0000000000000000
10:     0x0000000000000000
11:     0x0000000000000000
12:     0x0000000000000000
0x00007FFBDF485403 >= 0x00007FFBDF485400
0x00007FFBDF485403 <= 0x00007FFBDF485414
0x00007FFBDF485408 >= 0x00007FFBDF485400
0x00007FFBDF485408 <= 0x00007FFBDF485414
0x00007FFBDF485410 >= 0x00007FFBDF485400
0x00007FFBDF485410 <= 0x00007FFBDF485414
0x00007FFBDF485412 >= 0x00007FFBDF485400
0x00007FFBDF485412 <= 0x00007FFBDF485414
RESTORED 12 arguments and stack for 0x00007FFBDF485412 || TID : 0x9ecc
1:      0x00000062618FF8D8
2:      0x00000000001FFFFF
3:      0x0000000000000000
4:      0xFFFFFFFFFFFFFFFF
5:      0x00007FF79FB01FA0
6:      0x0000000000000000
7:      0x0000000000000000
8:      0x0000000000000000
9:      0x0000000000000000
10:     0x0000000000000000
11:     0x00000062618FF9F0
12:     0x000001C700000000
0x00007FFBDF485414 >= 0x00007FFBDF485400
0x00007FFBDF485414 <= 0x00007FFBDF485414

----TestThread----
[...]