CS-反沙箱杂谈

#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指令并获取信息    
}

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
}

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); // 打印虚拟化厂商签名
}

#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;
}

#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();
}

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;

#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");
    }
}

#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();  // 调用自定义反调试函数，检查当前进程是否被调试
}

#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();  // 调用函数以检查当前线程是否被调试。
}

#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 表示程序执行完毕。
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}

#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;
}