cstring.cpp.svn-base

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

/*	Agobot3 - a modular IRC bot for Win32 / Linux
	Copyright (C) 2003 Ago

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. */

#include "main.h"
#include "cstring.h"
#include "mainctrl.h"
#include "cthread.h"

#include <vector>

// Token cache
token_data	 g_tData[128];
CMutex		 g_mMutex;
bool		 g_bInited=false;

CString::CString() {
	if(!g_bInited) {
		for(int i=0;i<128; i++) {
			token_data *pData=&g_tData[i]; pData->szDelim=NULL; pData->szString=NULL;
		}
		g_bInited=true; }

	m_szString=NULL;
	m_iLength=0;
	m_bIsCryptStr=false;
	m_szTemp=NULL; }

CString::CString(const char *szString) {
	if(!g_bInited) {
		for(int i=0;i<128; i++) {
			token_data *pData=&g_tData[i]; pData->szDelim=NULL; pData->szString=NULL;
		}
		g_bInited=true; }

	m_szString=NULL; m_iLength=0;
	Assign(szString); m_bIsCryptStr=false;
	m_szTemp=NULL; }

CString::CString(const CString &pString) {
	if(!g_bInited) {
		for(int i=0;i<128; i++) {
			token_data *pData=&g_tData[i]; pData->szDelim=NULL; pData->szString=NULL;
		}
		g_bInited=true; }

	m_szString=NULL; m_iLength=0;
	Assign(pString); m_szTemp=NULL; }

CString::CString(const int iValue) {
	if(!g_bInited) {
		for(int i=0;i<128; i++) {
			token_data *pData=&g_tData[i]; pData->szDelim=NULL; pData->szString=NULL;
		}
		g_bInited=true; }

	char szTemp[16];
	sprintf(szTemp, "%d", iValue);
	m_szString=NULL; m_iLength=0;
	Assign(szTemp); m_bIsCryptStr=false;
	m_szTemp=NULL; }

CString::~CString() {
	if(m_szString!=NULL) { delete [] m_szString; m_szString=NULL; }
	if(m_szTemp!=NULL) { delete [] m_szTemp; m_szTemp=NULL; }
	m_iLength=0; }

void CString::Assign(const char *szString)
{	if(!szString) return;

	int iLength=::strlen(szString);
	if(m_szString) { delete [] m_szString; m_szString=NULL; }
	m_bIsCryptStr=false;

	m_szString=new char [iLength+2]; if(!m_szString) return; m_iLength=iLength;
	memset(m_szString, 0, m_iLength+2); ::strncpy(m_szString, szString, m_iLength); }
void CString::Assign(const CString &pString) {
	Assign(pString.CStr());
	m_bIsCryptStr=pString.m_bIsCryptStr;
	strncpy(m_szKey, pString.m_szKey, sizeof(m_szKey));
}
void CString::Assign(const int iValue) { char szTemp[16]; sprintf(szTemp, "%d", iValue); Assign(szTemp); }

void CString::Append(const char *szString)
{	if(!szString || !m_szString) return;
	int iLength=m_iLength+strlen(szString); char *szTemp=new char[iLength+20];
	if(!szTemp) return;
 	m_iLength=iLength; strncpy(szTemp, m_szString, iLength+1);
	strncat(szTemp, szString, iLength+1);
	if(m_szString) delete [] m_szString;
	m_szString=szTemp; }
void CString::Append(const CString &pString) { Append(pString.CStr()); }
void CString::Append(const int iValue) { char szTemp[16]; sprintf(szTemp, "%d", iValue); Append(szTemp); }

int CString::Compare(const char *szString) const
{	if(!szString || !m_szString) return 0; if(!szString) return 1;
	if(m_bIsCryptStr) return Decrypt().Compare(szString);
	else return ::strcmp(m_szString, szString); }
int CString::Compare(const CString &pString) const { return Compare(pString.CStr()); }
int CString::CompareNoCase(const char *szString) const
{	if(!szString || !m_szString) return 0; if(!szString) return 1;
	if(m_bIsCryptStr) return Decrypt().CompareNoCase(szString);
	else return stricmp(m_szString, szString); }
int CString::CompareNoCase(const CString &pString) const { return Compare(pString.CStr()); }

// Returns the current string in decrypted form
CString CString::Decrypt() const {
	if(!m_bIsCryptStr) return CString("");
	CString sRetVal; sRetVal.Assign("");
	
	strncpy(sRetVal.m_szKey, m_szKey, sizeof(sRetVal.m_szKey));
	sRetVal.m_cSapphire.initialize((unsigned char*)sRetVal.m_szKey, strlen(sRetVal.m_szKey));

	for(int i=0;i<strlen(m_szString);i++) {
		char cDecrypted=sRetVal.m_cSapphire.decrypt(*(m_szString+i));
		char szDecStr[3]={cDecrypted,0,0};
		sRetVal.Append(szDecStr); }

	sRetVal.m_cSapphire.burn();
	sRetVal.m_bIsCryptStr=false;

	return sRetVal; }

// Returns the current string encrypted with szKey
CString CString::Encrypt(const char *szKey) const {
	if(m_bIsCryptStr) return CString("");
	CString sRetVal; sRetVal.Assign("");

	strncpy(sRetVal.m_szKey, szKey, sizeof(sRetVal.m_szKey));
	sRetVal.m_cSapphire.initialize((unsigned char*)sRetVal.m_szKey, strlen(sRetVal.m_szKey));

	int i;
	for(i=0;i<strlen(m_szString);i++) {
		char cEncrypted=sRetVal.m_cSapphire.encrypt(*(m_szString+i));
		char szEncStr[3]={cEncrypted,0,0};
		sRetVal.Append(szEncStr); }

	sRetVal.m_cSapphire.burn();
	sRetVal.m_bIsCryptStr=true;

	CString sCheckStr("");
	sRetVal.m_cSapphire.initialize((unsigned char*)sRetVal.m_szKey, strlen(sRetVal.m_szKey));

	for(i=0;i<sRetVal.GetLength();i++) {
		char cDecrypted=sRetVal.m_cSapphire.decrypt(sRetVal.operator [](i));
		char szDecStr[3]={cDecrypted,0,0};
		sCheckStr.Append(szDecStr); }

	sRetVal.m_cSapphire.burn();

//	if(sRetVal.Compare(sCheckStr)) {
//		init_random();
//	}

	return sRetVal; }

void CString::Empty() { if(m_szString) delete [] m_szString; m_szString=NULL; }

void CString::Format(const char *szFormat, ...)
{	if(!szFormat) return;
	va_list va_alist; char formatbuf[8192]; va_start(va_alist, szFormat);
	vsnprintf(formatbuf, sizeof(formatbuf), szFormat, va_alist); va_end(va_alist);
	Assign(formatbuf); }

int CString::Find(const char cChar) const { return Find(cChar, 0); }
int CString::Find(const char cChar, int iStart) const
{	if(m_bIsCryptStr) return Decrypt().Find(cChar, iStart);
	if(::strchr(m_szString, cChar)==NULL) return 0;
	return (int)((char*)::strchr(m_szString, cChar)-(char*)m_szString)+1; }
int CString::Find(const CString &pString) const { return Find(pString, 0); }
int CString::Find(const CString &pString, int iStart) const { return Find(pString.CStr(), iStart); }
int CString::Find(const char *szString) const { return Find(szString, 0); }
int CString::Find(const char *szString, int iStart) const
{	if(!szString) return 0;
	if(m_bIsCryptStr) return Decrypt().Find(szString, iStart);
	if(::strstr(m_szString, szString)==NULL) return 0;
	return (int)((char*)::strstr(m_szString, szString)-(char*)m_szString)+1; }

char *CString::GetBuffer(int iBufLen)
{	if(!iBufLen) return NULL;
	m_iLength=iBufLen;
	char *szNewString=new char[iBufLen+1]; if(!szNewString) return NULL;
	if(m_szString) delete [] m_szString; m_szString=szNewString;
	memset(m_szString, 0, iBufLen+1); return m_szString; }

int CString::GetLength() const
{	if(!m_szString) return 0;
	if(m_bIsCryptStr) return Decrypt().GetLength();
	return strlen(m_szString); }

int CString::GetLength()
{	if(!m_szString) return 0;
	if(m_bIsCryptStr) return Decrypt().GetLength();
	m_iLength=strlen(m_szString);
	return m_iLength; }

CString CString::Mid(int iFirst, int iCount) const
{	if(iCount<1) return CString("");
	if(m_bIsCryptStr) return Decrypt().Mid(iFirst, iCount);
	CString sTemp; char *szBuf=new char[iCount+1]; if(!szBuf) return CString("");
	memset(szBuf, 0, iCount+1); memcpy(szBuf, &m_szString[iFirst], iCount);
	sTemp.Assign(szBuf);
	delete [] szBuf; return sTemp; }
CString CString::Mid(int iFirst) const
{	int iCount=GetLength()-iFirst; return Mid(iFirst, iCount); }

/*
typedef struct token_data_s {
	unsigned char		 szMD5[16];
	char				*szString;
	char				*szDelim;
	std::vector<char*>	 vTokens;
} token_data;
*/

CString CString::Token(int iNum, const char *szDelim, bool bUseQuotes)
{	static int iCacheIndex=0; int i; char *szStrCopy;