C++杀毒软件 需要windows 10以上

已于 2024-07-25 13:04:32 修改
阅读量120 收藏
点赞数 1
文章标签： 算法
于 2024-07-24 11:17:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vliu612/article/details/140658034
版权 
​
#include <windows.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <thread>
#include <chrono>
#include <filesystem>
#include <psapi.h>
#include <tlhelp32.h>
#include <atlbase.h>
#include <atlcom.h>
#include <appmodel.h>

namespace fs = std::filesystem;

HINSTANCE hInst;
HWND hMainWnd, hLogWnd;
std::thread monitorThread, backgroundThread;
std::vector<std::string> virusSignatures;

std::vector<std::string> loadVirusSignatures(const std::string& configFilePath);
bool containsVirusSignature(const std::string& filePath, const std::vector<std::string>& virusSignatures);
std::vector<std::string> scanDirectory(const std::string& directoryPath, const std::vector<std::string>& virusSignatures);
void saveReport(const std::string& reportPath, const std::vector<std::string>& infectedFiles);
double GetProcessCpuUsage(DWORD processID);
void MonitorHighCpuUsageProcesses(double threshold);
void backgroundTask(const std::vector<std::string>& virusSignatures, const std::string& directoryPath, const std::string& reportPath, double cpuUsageThreshold);
void AddToStartup(const std::string& appName, const std::string& appPath);
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
void StartMonitoring();
void StartScanning();
void RemoveNonMicrosoftStoreApps();
bool IsMicrosoftStoreApp(const std::wstring& appName);
void LogMessage(const std::string& message);

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
    switch (message) {
    case WM_CREATE: {
        CreateWindow(TEXT("BUTTON"), TEXT("Monitor programs"), WS_VISIBLE | WS_CHILD, 10, 10, 150, 30, hWnd, (HMENU)1, hInst, NULL);
        CreateWindow(TEXT("BUTTON"), TEXT("Start Scanning"), WS_VISIBLE | WS_CHILD, 10, 50, 150, 30, hWnd, (HMENU)2, hInst, NULL);
        CreateWindow(TEXT("BUTTON"), TEXT("Remove Malicious Apps"), WS_VISIBLE | WS_CHILD, 10, 90, 150, 30, hWnd, (HMENU)3, hInst, NULL);
        hLogWnd = CreateWindow(TEXT("EDIT"), NULL, WS_VISIBLE | WS_CHILD | WS_VSCROLL | ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL, 10, 130, 300, 200, hWnd, NULL, hInst, NULL);
        break;
    }
    case WM_COMMAND: {
        switch (LOWORD(wParam)) {
        case 1:
            StartMonitoring();
            break;
        case 2:
            StartScanning();
            break;
        case 3:
            RemoveNonMicrosoftStoreApps();
            break;
        }
        break;
    }
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

void LogMessage(const std::string& message) {
    int len = GetWindowTextLength(hLogWnd);
    SendMessage(hLogWnd, EM_SETSEL, len, len);
    SendMessage(hLogWnd, EM_REPLACESEL, 0, (LPARAM)message.c_str());
}

void StartMonitoring() {
    monitorThread = std::thread(MonitorHighCpuUsageProcesses, 20.0);
    monitorThread.detach();
    LogMessage("Started monitoring high CPU usage processes.\n");
}

void StartScanning() {
    std::string directoryPathC = "C:\\";
    std::string directoryPathD = "D:\\";
    std::string reportPath = "scan_report.txt";
    backgroundThread = std::thread(backgroundTask, virusSignatures, directoryPathC, reportPath, 20.0);
    backgroundThread.detach();
    backgroundThread = std::thread(backgroundTask, virusSignatures, directoryPathD, reportPath, 20.0);
    backgroundThread.detach();
    LogMessage("Started background scanning on C: and D: drives.\n");
}

void MonitorHighCpuUsageProcesses(double threshold) {
    while (true) {
        HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hProcessSnap == INVALID_HANDLE_VALUE) {
            LogMessage("Unable to create toolhelp snapshot!\n");
            continue;
        }

        PROCESSENTRY32 pe32;
        pe32.dwSize = sizeof(PROCESSENTRY32);

        if (!Process32First(hProcessSnap, &pe32)) {
            LogMessage("Unable to get first process!\n");
            CloseHandle(hProcessSnap);
            continue;
        }

        do {
            double cpuUsage = GetProcessCpuUsage(pe32.th32ProcessID);
            if (cpuUsage > threshold) {
                std::string logMsg = "Malicious program detected: " + std::string(pe32.szExeFile) + " (PID: " + std::to_string(pe32.th32ProcessID) + ") - " + std::to_string(cpuUsage) + "%\n";
                LogMessage(logMsg);
                std::string command = "taskkill /PID " + std::to_string(pe32.th32ProcessID) + " /F";
                system(command.c_str());

                std::string notificationCommand = "powershell -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('High CPU usage detected and process terminated: " + std::string(pe32.szExeFile) + "')\"";
                system(notificationCommand.c_str());
            }
        } while (Process32Next(hProcessSnap, &pe32));

        CloseHandle(hProcessSnap);
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
}

void backgroundTask(const std::vector<std::string>& virusSignatures, const std::string& directoryPath, const std::string& reportPath, double cpuUsageThreshold) {
    while (true) {
        std::vector<std::string> infectedFiles = scanDirectory(directoryPath, virusSignatures);
        saveReport(reportPath, infectedFiles);

        std::string logMsg = "Scanning complete. Infected files: " + std::to_string(infectedFiles.size()) + "\n";
        LogMessage(logMsg);

        std::this_thread::sleep_for(std::chrono::hours(1));
    }
}

std::vector<std::string> loadVirusSignatures(const std::string& configFilePath) {
    std::vector<std::string> virusSignatures;
    std::ifstream configFile(configFilePath);
    if (!configFile.is_open()) {
        LogMessage("Unable to open virus signature config file: " + configFilePath + "\n");
        return virusSignatures;
    }

    std::string line;
    while (std::getline(configFile, line)) {
        virusSignatures.push_back(line);
    }

    return virusSignatures;
}

bool containsVirusSignature(const std::string& filePath, const std::vector<std::string>& virusSignatures) {
    std::ifstream file(filePath, std::ios::binary);
    if (!file.is_open()) {
        return false;
    }

    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());

    for (const auto& signature : virusSignatures) {
        if (content.find(signature) != std::string::npos) {
            return true;
        }
    }

    return false;
}

std::vector<std::string> scanDirectory(const std::string& directoryPath, const std::vector<std::string>& virusSignatures) {
    std::vector<std::string> infectedFiles;

    for (const auto& entry : fs::recursive_directory_iterator(directoryPath)) {
        if (fs::is_regular_file(entry.path())) {
            std::string filePath = entry.path().string();
            if (containsVirusSignature(filePath, virusSignatures)) {
                infectedFiles.push_back(filePath);
                LogMessage("Infected file detected: " + filePath + "\n");
            } else if (filePath.ends_with(".vbs") || filePath.ends_with(".bat") || filePath.ends_with(".cmd")) {
                std::error_code ec;
                fs::remove(filePath, ec);
                if (!ec) {
                    LogMessage("Deleted script file: " + filePath + "\n");
                } else {
                    LogMessage("Failed to delete script file: " + filePath + "\n");
                }
            }
        }
    }

    return infectedFiles;
}

void saveReport(const std::string& reportPath, const std::vector<std::string>& infectedFiles) {
    std::ofstream reportFile(reportPath, std::ios::app);
    if (!reportFile.is_open()) {
        LogMessage("Unable to open report file: " + reportPath + "\n");
        return;
    }

    for (const auto& file : infectedFiles) {
        reportFile << file << "\n";
    }
}

double GetProcessCpuUsage(DWORD processID) {
    FILETIME ftCreation, ftExit, ftKernel, ftUser;
    ULARGE_INTEGER liKernel, liUser;

    HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
    if (!hProcess) {
        return 0.0;
    }

    if (GetProcessTimes(hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser)) {
        CloseHandle(hProcess);
        liKernel.LowPart = ftKernel.dwLowDateTime;
        liKernel.HighPart = ftKernel.dwHighDateTime;
        liUser.LowPart = ftUser.dwLowDateTime;
        liUser.HighPart = ftUser.dwHighDateTime;

        return (liKernel.QuadPart + liUser.QuadPart) / 10000.0;
    }

    CloseHandle(hProcess);
    return 0.0;
}

void AddToStartup(const std::string& appName, const std::string& appPath) {
    HKEY hKey;
    LONG result = RegOpenKeyEx(HKEY_CURRENT_USER, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_WRITE, &hKey);
    if (result != ERROR_SUCCESS) {
        LogMessage("Failed to open startup registry key.\n");
        return;
    }

    result = RegSetValueEx(hKey, appName.c_str(), 0, REG_SZ, (BYTE*)appPath.c_str(), appPath.size() + 1);
    if (result == ERROR_SUCCESS) {
        LogMessage("Successfully added to startup.\n");
    } else {
        LogMessage("Failed to add to startup.\n");
    }

    RegCloseKey(hKey);
}

bool IsMicrosoftStoreApp(const std::wstring& appName) {
    CComPtr<IAppxPackageManager> packageManager;
    HRESULT hr = CoCreateInstance(__uuidof(AppxPackageManager), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&packageManager));
    if (FAILED(hr)) {
        return false;
    }

    CComPtr<IAppxPackageQuery> query;
    hr = packageManager->QueryInterface(IID_PPV_ARGS(&query));
    if (FAILED(hr)) {
        return false;
    }

    CComPtr<IAppxPackageCollection> packages;
    hr = query->GetInstalledPackages(&packages);
    if (FAILED(hr)) {
        return false;
    }

    UINT32 count = 0;
    hr = packages->GetCount(&count);
    if (FAILED(hr)) {
        return false;
    }

    for (UINT32 i = 0; i < count; ++i) {
        CComPtr<IAppxPackage> package;
        hr = packages->GetAt(i, &package);
        if (FAILED(hr)) {
            continue;
        }

        CComBSTR name;
        hr = package->GetName(&name);
        if (FAILED(hr)) {
            continue;
        }

        if (appName == name) {
            return true;
        }
    }

    return false;
}

void RemoveNonMicrosoftStoreApps() {
    LogMessage("Removing non-Microsoft Store applications.\n");

    CComPtr<IAppxPackageManager> packageManager;
    HRESULT hr = CoCreateInstance(__uuidof(AppxPackageManager), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&packageManager));
    if (FAILED(hr)) {
        LogMessage("Failed to create AppxPackageManager instance.\n");
        return;
    }

    CComPtr<IAppxPackageQuery> query;
    hr = packageManager->QueryInterface(IID_PPV_ARGS(&query));
    if (FAILED(hr)) {
        LogMessage("Failed to query package manager.\n");
        return;
    }

    CComPtr<IAppxPackageCollection> packages;
    hr = query->GetInstalledPackages(&packages);
    if (FAILED(hr)) {
        LogMessage("Failed to get installed packages.\n");
        return;
    }

    UINT32 count = 0;
    hr = packages->GetCount(&count);
    if (FAILED(hr)) {
        LogMessage("Failed to get package count.\n");
        return;
    }

    for (UINT32 i = 0; i < count; ++i) {
        CComPtr<IAppxPackage> package;
        hr = packages->GetAt(i, &package);
        if (FAILED(hr)) {
            continue;
        }

        CComBSTR name;
        hr = package->GetName(&name);
        if (FAILED(hr)) {
            continue;
        }

        if (!IsMicrosoftStoreApp(name)) {
            LogMessage("Removing non-Microsoft Store application: " + std::wstring(name) + "\n");
            hr = packageManager->RemovePackage(name);
            if (FAILED(hr)) {
                LogMessage("Failed to remove application: " + std::wstring(name) + "\n");
            }
        }
    }
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow) {
    hInst = hInstance;

    WNDCLASS wc = {};
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = TEXT("VirusKillerClass");

    RegisterClass(&wc);

    hMainWnd = CreateWindowEx(0, wc.lpszClassName, TEXT("Virus Killer"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 640, 480, NULL, NULL, hInstance, NULL);

    if (hMainWnd == NULL) {
        return 0;
    }

    ShowWindow(hMainWnd, nCmdShow);

    virusSignatures = loadVirusSignatures("virus_signatures.txt");

    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
}

​

vliu612
关注
C++常用软件分析工具从入门到精通案例集锦汇总
dvlinker的技术专栏
06-26 11万+
C++软件分析工具案例分析集锦！根据近几年C++软件异常排查的项目实践，详细地讲述如何使用PE工具、Dependency Walker、GDIView、Process Explorer、Process Monitor、API Monitor、Clumsy、DebugDiag、Windbg、IDA Pro等常用分析工具，以及如何使用这些工具去巧妙地分析和解决日常工作中遇到的问题，有很强的实战参考价值！
引发C++软件异常的常见原因分析与总结（实战经验分享）
热门推荐
dvlinker的技术专栏
05-30 5万+
本文根据近几年排查C++软件异常的实践经历与实战经验，详细地总结出引发C++软件异常的常见原因，给大家提供一些借鉴和参考，以帮助大家快速地定位问题。
vc++ 360杀毒代码（高仿）
12-30
vc++ 360安全卫生代码（高仿）作为简单的界面开发框架，简单易用一直是我们的追求。SkinUI界面库上手快、扩展性好、集成方便。采用xml布局界面，逻辑与界面分离，助您轻松完成界面开发。
C++ 编写的杀毒软件
01-17
利用Visual C++ 编写的杀毒软件，中文介面
杀毒软件的简单实现
10-30 1285
#include "FunDef.h"int main (int argc, char *argv[]){if (argc==1){Usage(argv[0]);return 0;}if (!(ScanFileVXER(argv[1]))){printf("ScanFileVXER() GetLastError reports %d/n",erron);return 0;}if (!(Proces
自制杀毒软件C++源码
07-23
自制杀毒软件C++源码
一款国外的 C++ 编写杀毒软件
01-17
一款国外的 C++ 编写杀毒软件，cmd模式下执行
C++写的一个杀毒软件
11-16
编译器DevC++，仅使用Windows API库，可以杀掉病毒进程，病毒库可自定义，有一点内存泄漏问题，可以用long long整形多撑一会儿，可以把文件读到内存里再查杀（只是我不会），仅供参考，切勿使用
超强c/c++病毒程序，中毒+杀毒
asuf1364的博客
07-08 2590
【代码】超强c/c++病毒程序，中毒+杀毒。
杀毒小程序杀毒小程序
12-15
杀毒小程序杀毒小程序杀毒小程序杀毒小程序
C++/MFC/Python杀毒软件 安全卫士项目
qq_43572067的博客
11-17 3521
本次安全卫士项目已实现的功能 遍历进程(操作)，线程(操作)，模块(操作)，桌面窗口 CPU，内存使用情况，内存优化 系统垃圾，浏览器垃圾，VS垃圾清理 遍历，开启，关闭系统服务 遍历系统启动项，软件卸载 本地，云端病毒库杀毒，进程白名单扫描 PE文件解析 保护进程不被结束 遍历，断开网络连接，流量监控。 老板键，待机，等等。 源码分享：https://github.com/Mr-Hock/MyS...
基于VisualC++2010开发Windows7杀毒应用程序范例(3)---检测所有驱动程序，并启动，暂停，终止驱动
尹成的技术博客
07-01 3765
<br />作为一个杀毒软件，必须扫描所有的驱动，才能检测到所有的驱动层病毒！<br />微软的.net framework4.0提供了关于驱动访问的类，<br />启动VS2010，<br />创建一个CLR工程如下<br /> <br /> <br />具体核心代码如下，详情见代码注释<br /> <br />#pragma once namespace yincheng { using namespace System; using namespace System::Compo
Shellcode免杀对抗(C/C++)
最新发布
qq_74806534的博客
02-17 2万+
这里便是杀毒软件杀毒的原理，这就是特征，我们只需要将木马程序进行简单的分析，就能得到shell回连的IP地址和端口，如果杀毒软件发现我们的可执行文件是一个木马程序。加载器的作用：由于shellcode是一段可以执行的二进制代码，因此需要开辟出一段可以读写可操作的地址来运行shellcode，而这就是加载器的作用。之后打开.c文件是一个未编译代码，放到上文的编译代码中，注意这里是x64编译，用的方式三，使用.c文件。因为我们的加载器的特征，各平台杀毒软件都有了已经，所有我们就要用新的，特征没有被锁定。
远控免杀从入门到实践(3)-代码篇-C/C++
weixin_46236101的博客
03-13 1941
郑重声明：文中所涉及的技术、思路和工具仅供以安全为目的的学习交流使用，任何人不得将其用于非法用途以及盈利等目的，否则后果自行承担！ 《远控免杀从入门到实践》系列文章目录： 1、远控免杀从入门到实践 (1)基础篇 2、远控免杀从入门到实践 (2)工具总结篇 3、远控免杀从入门到实践 (3)代码篇-C/C++ 4、远控免杀从入门到实践 (4)代码篇-C# 5、远控免杀从入门到实践 (5)代码篇-Python 6、远控免杀从入门到实践 (6)代码篇-Powershell 7、远控免杀从入门到实.
超强c++病毒代码（附源码），让你的电脑快快乐乐
yaosichengalpha的博客
07-05 4916
超强c++病毒代码（附源码），让你的电脑快快乐乐
c语言编写u盘杀毒软件,一个简单的C++编写的u盘病毒代码
weixin_32340873的博客
05-25 2283
该楼层疑似违规已被系统折叠隐藏此楼查看此楼一个简单的C++编写的u盘病毒代码一个win32下能用的U盘病毒 研究原理可以 别编译拿去害人就行 (ring3的病毒貌似也害不了人) 前久用IDA逆向出来的 感兴趣的可以看看。。。#include#include BOOL UDevice(); void ResourceToFile(char *filename,char *Name,char* ...
如何利用十行C++代码，绕过杀毒软件实现免杀？
03-17 2845
我相信大部分的读者都会同意这个观点，绕过大部分杀毒软件的基本方法都很平常没什么特殊的。然而，我也偶尔会遇到一些人仅仅依靠工具生成二进制文件，这些文件很容易被杀毒软件通过指纹标记出来。本文主要是为这些人所准备的。 下面是小编整理好的一套C/C++资料，加小编C/C++编程学习群825414254，获取系统性学习C/C++的学习资料 在我们开始接触这段小巧的 C++ 代码前，我想先介绍一个可以非常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值