免杀之反调试

反调试

反调试的意义

反调试技术，恶意代码用它识别是否被调试，或者让调试器失效。恶意代码编写者意识到分析人员经常使用调试器来观察恶意代码的操作，因此他们使用反调试技术尽可能地延长恶意代码的分析时间。为了阻止调试器的分析，当恶意代码意识到自己被调试时，它们可能改变正常的执行路径或者修改自身程序让自己崩溃，从而增加调试时间和复杂度。很多种反调试技术可以达到反调试效果。

反调试相关函数

IsDebuggerPresent()

这是恶意代码中使用最高的反调试函数，是在win32API里面的应用层函数。

1
BOOL IsDebuggerPresent();

image-20221030134932179

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <windows.h>
#include <stdio.h>
BOOL CheckDebug()
{
	return IsDebuggerPresent();
}
int main() 
{
	if (CheckDebug())
	{
		printf("a");
		//exit(0);
	}
	else
	{
		printf("b");
		//shellcodeloader();
	}
    return 0;
}

正如以上描述，如果存在调试的环境，就输出A，如果不是调试的环境，就会输出B。

该函数原理：

image-20221030135722934

我们知道OD和其他动态调试器的原理都是通过附加到另一个进程上使用windows的debug机制去进行调试，而IsDebuggerpresent函数本来就是该debug机制的一个函数，它负责查看这个环节中函数返回的值是否为0用来判断是否是调试环境。

效果展示：如果在vs中直接使用本地windows调试器方法去运行，便会出现a。

image-20221030140101608

而直接在命令行中去执行

image-20221030140215849

CheckRemoteDebuggerPresent()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
BOOL CheckRemoteDebuggerPresent(
  [in]      HANDLE hProcess,
  [in, out] PBOOL  pbDebuggerPresent
);

参数
[in] hProcess
进程的句柄。
[in, out] pbDebuggerPresent
如果正在调试指定的进程，则函数设置为 TRUE 的变量的指针，否则为 FALSE 。
    
返回值
如果该函数成功，则返回值为非零值。
如果函数失败，则返回值为零。 要获得更多的错误信息，请调用 GetLastError。

该函数不仅可以检测自己是否正在被debug，还可以检测其他任意句柄是否被debug。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
BOOL CheckDebug1()
{
	BOOL ret;//定义了一个布尔类型的变量
	CheckRemoteDebuggerPresent(GetCurrentProcess(), &ret);//变量就有地址，这个api函数就可以找到这个地址直接在地址里面写true还是false
	return ret;//直接返回变量的值就是刚才修改的内容
}
int main()
{
	if (CheckDebug1())
	{
		printf("a");
	}
	else
	{
		printf("b");
	}
}

它会把结果传输给一个布尔变量的指针，往这个地址里面直接写true或者false，用来判断是否是调试环境。

效果展示：

image-20221030140918860

NtQueryInformationProcess

NtQueryInformationProcess是ntdll.dll里面的函数，所以要想调用这个函数，是比较麻烦的，需要loadlibrary加getprocaddress

1
2
3
4
5
6
7
__kernel_entry NTSTATUS NtQueryInformationProcess(
  [in]            HANDLE           ProcessHandle,
  [in]            PROCESSINFOCLASS ProcessInformationClass,
  [out]           PVOID            ProcessInformation,
  [in]            ULONG            ProcessInformationLength,
  [out, optional] PULONG           ReturnLength
);

https://learn.microsoft.com/zh-cn/windows/win32/api/winternl/nf-winternl-ntqueryinformationprocess

最关键的是参数中

image-20221030141919465

用来检测是否是调试器环境。（如果是非0的值，就表示有一个调试器。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
bool NtQueryInformationProcessApproach()

{

    int debugPort = 0;

    HMODULE hModule = LoadLibrary(TEXT("Ntdll.dll "));

    NtQueryInformationProcessPtr NtQueryInformationProcess = (NtQueryInformationProcessPtr)GetProcAddress(hModule, "NtQueryInformationProcess");

    if (NtQueryInformationProcess(GetCurrentProcess(), (PROCESSINFOCLASS)7, &debugPort, sizeof(debugPort), NULL)) 
    {

        printf("[ERROR NtQueryInformationProcessApproach] NtQueryInformationProcess failed\n");
    }
    else
    {
        return debugPort == -1;
    }

    return false;

}

int main()
{
    if (NtQueryInformationProcessApproach())
    {
        printf("a");
    }
    else
    {
        printf("b");
    }
}

大致的意义就是将这个函数里面的值取出来放在定义的debugPort变量中。用来检测是否是调试器环境。

效果展示：

image-20221030142533101

运用调试器的异常接管来判断

image-20221030143131130

当没有调试器的时候，我们关闭一个不存在的进程，错误会自动交给windows操作系统，但是如果在有调试器的情况下，当系统报错时，会将报错交给调试器。同时这个就是调试器的原理，OD的普通断点就是使用int3报错的方式来下的断点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <windows.h>
#include <stdio.h>
BOOL CheckDebug()
{
    DWORD ret = CloseHandle((HANDLE)0x1234);
    //SetLastError
    if (ret != 0 || GetLastError() != ERROR_INVALID_HANDLE)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


int main() 
{
    if (CheckDebug())
    {
        printf("a");
    }
    else
    {
        printf("b");
    }
}

image-20221030143428587

内核级调试的反调试

不同于OD等，windbg是内核级调试器。这种内核级调试器同样有内核级的反调试手段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include "kernelmode_antidbg.h"
#include <iostream>
#include "connector.h"
#ifdef __cplusplus
extern "C" {
#endif 




#define KUSER_SHARED_VA 0x7FFE0000
#define KUSER_SHARED_SIZE 0x3B8
 //_KUSER_SHARED_DATA
    inline bool is_kuser_shared_mapped()
    {
        if (IsBadReadPtr((BYTE*)KUSER_SHARED_VA, KUSER_SHARED_SIZE)) {
            std::cerr << "KDB: Failed to retrieve KUSER_SHARED_DATA\n";
            return false;
        }
        return true;
    }

    // from Hidden Bee malware:
    t_kdb_mode is_kernelmode_dbg_enabled() {
        const ULONGLONG KdDebuggerEnable_offset = 0x2d4;
        if (!is_kuser_shared_mapped()) {
            return KDB_UNKNOWN;
        }
        BYTE* KdDebuggerEnable = (BYTE*)(KUSER_SHARED_VA + KdDebuggerEnable_offset);
       
        if (*KdDebuggerEnable) {
            if (*KdDebuggerEnable == 3) {
                std::cout << "KDB: Remote enabled!\n";
                //windbg双机调试 一台虚拟机作为被调试的对象 一台机器作为调试结果查看的机器
                return KDB_REMOTE_ENABLED;
            }
            std::cout << "KDB: Local enabled!\n";
            return KDB_LOCAL_ENABLED;
        }
        std::cout << "KDB: Disabled\n";
        return KDB_DISABLED;
    }

#ifdef __cplusplus
}
#endif

原理：

image-20221030145508438

在32位下，KUSER_SHARED_VA 0x7FFE0000这段内存是一个内核层和用户层都能访问的内存段。而在偏移量2d4这个位置，也就是0x7FFE02d4这个位置，会有一个关于是否是内核级调试器的标志位，这就是问题的关键，通过这个标志位置，可以知道是否是在调试环境中。

image-20221030145851200

因为没有用windbg，所以可以检测出来是disabled的。

进程名称查看是否在调试环境

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <winternl.h>
BOOL CheckDebug()
{
    DWORD ID;
    DWORD ret = 0;
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(pe32);
    HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
    BOOL bMore = Process32First(hProcessSnap, &pe32);
    while (bMore)
    {
        if (_stricmp(pe32.szExeFile, "OllyDBG.EXE") == 0 || _stricmp(pe32.szExeFile, "OllyICE.exe") == 0 || _stricmp(pe32.szExeFile, "x64_dbg.exe") == 0 || _stricmp(pe32.szExeFile, "windbg.exe") == 0 || _stricmp(pe32.szExeFile, "ImmunityDebugger.exe") == 0)
        {
            return TRUE;
        }
        bMore = Process32Next(hProcessSnap, &pe32);
    }
    CloseHandle(hProcessSnap);
    return FALSE;
}
int main() 
{
    if (CheckDebug())
    {
        printf("a");
    }
    else
    {
        printf("b");
    }
}

这个很明显，就是比对一下任务管理器中有不有进程名字与这几个调试器的名字相同。

image-20221030150208316

GetTickCount

这个也是逻辑上的检测方式，执行三条指令，看程序的执行时间来看是不是调试环境。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <windows.h>
#include <stdio.h>
BOOL CheckDebug()//就到这里来了
{
    DWORD time1 = GetTickCount();
    __asm
    {
        mov     ecx, 10
        mov     edx, 6
        mov     ecx, 10
    }
    DWORD time2 = GetTickCount();
    if (time2 - time1 > 0xA)
                           
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

int main() //入口点
{
    if (CheckDebug())//肯定是这个
    {
        printf("a");
    }
    else
    {
        printf("b");
    }
    return 0;

image-20221030151539004

TLS加载器

TLS就是在运行主函数之前，就运行一段程序的机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <stdio.h>  
#include <windows.h>  

void NTAPI __stdcall TLS_CALLBACK1(PVOID DllHandle, DWORD dwReason, PVOID Reserved);

#ifdef _M_IX86  
#pragma comment (linker, "/INCLUDE:__tls_used")  
#pragma comment (linker, "/INCLUDE:__tls_callback")  
#else  
#pragma comment (linker, "/INCLUDE:_tls_used")  
#pragma comment (linker, "/INCLUDE:_tls_callback")  
#endif  
EXTERN_C
#ifdef _M_X64  
#pragma const_seg (".CRT$XLB")  
const
#else  
#pragma data_seg (".CRT$XLB")  
#endif  

PIMAGE_TLS_CALLBACK _tls_callback[] = { TLS_CALLBACK1,0 };
#pragma data_seg ()  
#pragma const_seg ()  

#include <iostream>  

void NTAPI __stdcall TLS_CALLBACK1(PVOID DllHandle, DWORD Reason, PVOID Reserved)
{
    if (IsDebuggerPresent())
    {
        exit(0);
    }
    else
    {
        MessageBox(NULL,"aaaaaaaa","bbbbbbbb",0);
    }
}

int main(int argc, char* argv[])
{
    printf("233\n");
    return 0;
}

即在程序运行main前就会报异常

image-20221030151941214

自动下断点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <windows.h>
#include <stdio.h>
BOOL CheckDebug()
{
    __try
    {
        __asm int 3
    }
    __except (1)
    {
        return FALSE;
    }
    return TRUE;
}

int main() 
{
    if (CheckDebug())
    {
        printf("a");
    }
    else
    {
        printf("b");
    }
    return 0;
}

它使用汇编语言自动写一个int3断点，如果你在调试器环境，那么就会被调试器接管，如果说你用od去调试他，就会发现他会退出，如果是正常环境就不管。

image-20221030152534715

补充项目

https://github.com/MrH1TM4N86/Al-Khaser-Master

这个项目里面包含了各种各样的反调试手段和代码，可以用于借鉴。

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<br><br>平荒尽处是春山<br>Life is a fucking movie.