Авторизация ICQ

// MyICQ.cpp: определяет точку входа для консольного приложения.
//
#include "stdafx.h"

struct FlapHeader//6 bytes
{
	BYTE Sign;//Command Start always 0x2a
	BYTE ChID;//Channel ID
	WORD SeqNum;//Sequence Number
	WORD DFLen;//Data Field Length
};
struct FlapPacket
{
	FlapHeader Header;
	BYTE *Data;
};
struct SnacHeader
{
	WORD FamID;//Family ID
	WORD SubTypeID;//SubType ID
	BYTE Flags0;//Flags 0
	BYTE Flags1;//Flags 1
	DWORD ReqID;//Request ID
};
struct SnacPacket
{
	SnacHeader Header;
	BYTE Data[4096];
};
struct TLVPacket
{
	WORD TypeCode;
	WORD LengthCode;
	BYTE Data[4096];
};

HANDLE ReciveThreadHandle;
stack<FlapPacket> PacketQueue;
WORD Sequence;
bool EndWork;

void ReciveThread(void *Param);
void QueueThread(void *Param);

void AuthorizeInIcq(SOCKET Socket, FlapPacket *FirstPacket);
WORD SwapWord(WORD value);
DWORD SwapDWord(DWORD value);
void AddTLVStringToPacket(FlapPacket *inFlapPacket, WORD TypeCode, char *value);
void AddTLVWordToPacket(FlapPacket *inFlapPacket, WORD TypeCode, WORD value);
void AddTLVDWordToPacket(FlapPacket *inFlapPacket, WORD TypeCode, DWORD value);

int main(int argc, char* argv[])
{
	SOCKET ServerSock;
	sockaddr_in IcqServerAddress;

	//starting sockets
	WSADATA wsaData;
    int wsaret=WSAStartup(0x101,&wsaData);
	if(wsaret!=0)
    {
		cout<<"WSAStartup false"<<endl;
		cin.get();
        return 1;
    }

	//get ip of login.icq.com
	const char* const host = "login.icq.com";
	const in_addr* address;
    const hostent* host_info = 0 ;
    for( int attempt=0; (host_info==0) && (attempt<3); ++attempt )
		host_info = gethostbyname(host);
    if(host_info)
    {
		for( int i=0; host_info->h_addr_list[i]; ++i )
			address = (in_addr*)host_info->h_addr_list[i];
	}
	else
	{
		cout << "Cannot get ip of login.icq.com" << endl;
		return 1;
		cin.get();
	}

	//connecting to login.icq.com
	IcqServerAddress.sin_addr = *address;
	cout << "IP of login.icq.com: " << inet_ntoa( IcqServerAddress.sin_addr ) << endl ;
	IcqServerAddress.sin_family=AF_INET;
	IcqServerAddress.sin_port=htons(5190);
	ServerSock=socket(AF_INET, SOCK_STREAM, 0);
	if(connect(ServerSock,(sockaddr*)&(IcqServerAddress),sizeof(IcqServerAddress))==SOCKET_ERROR)
	{
		cout<<"Connection failed"<<endl;
		closesocket(ServerSock);
		ServerSock=0;
		WSACleanup();
		cin.get();
		return 1;
	}
	cout<<"Connected to login.icq.com"<<endl;

	//start analyse packets thread
	EndWork = false;
	ReciveThreadHandle = (HANDLE)_beginthread(QueueThread, 0, &ServerSock);
	//start recieve packets thread
	ReciveThreadHandle = (HANDLE)_beginthread(ReciveThread, 0, &ServerSock);
	while(!_kbhit())
	{
		Sleep(1);
	}
	EndWork = true;
	Sleep(10);

	//closing sockets and thread
	closesocket(ServerSock);
	WSACleanup();
	cout<<"Disconnected from login.icq.com";

	Sleep(1000);
	return 0;
}

void AuthorizeInIcq(SOCKET Socket, FlapPacket *FirstPacket)
{
	FlapPacket *AuthorizePacket = new FlapPacket;
	memset(AuthorizePacket, 0x00, sizeof(FlapPacket));
	char strUIN[] = "1234567";
	char strPassOpen[] = "xxxxxx";

	AuthorizePacket->Header.Sign = 0x2A;
	AuthorizePacket->Header.ChID = 0x01;
	Sequence = rand()%0x7FFF;
	AuthorizePacket->Header.SeqNum = Sequence;
	//copy original length and data
	AuthorizePacket->Header.DFLen = FirstPacket->Header.DFLen;
	WORD DataLen = SwapWord(AuthorizePacket->Header.DFLen);
	AuthorizePacket->Data = new BYTE[DataLen];
	memset(AuthorizePacket->Data, 0, DataLen);
	memcpy(AuthorizePacket->Data, FirstPacket->Data, DataLen);

	//create enrypted password
	char strPassEncr[32] = {0};//encrypted password
	BYTE PassTab[] = {0xF3,0x26,0x81,0xC4,0x39,0x86,0xDB,0x92,0x71,0xA3,0xB9,0xE6,0x53,0x7A,0x95,0x7C};
	for(unsigned int i=0; i<strlen(strPassOpen); i++)
		strPassEncr[i] = strPassOpen[i]^PassTab[i];

	//create FlapPacket with authorize information
	AddTLVStringToPacket(AuthorizePacket, 0x0001, strUIN);
	AddTLVStringToPacket(AuthorizePacket, 0x0002, strPassEncr);
	AddTLVStringToPacket(AuthorizePacket, 0x0003, "Self-made ICQ");
	AddTLVWordToPacket(AuthorizePacket, 0x0016, 0x010A);
	AddTLVWordToPacket(AuthorizePacket, 0x0017, 0x0007);
	AddTLVWordToPacket(AuthorizePacket, 0x0018, 0x0000);
	AddTLVWordToPacket(AuthorizePacket, 0x0019, 0x0001);
	AddTLVWordToPacket(AuthorizePacket, 0x001a, 0x04b5);
	AddTLVDWordToPacket(AuthorizePacket, 0x0014, 0x00000055);
	AddTLVStringToPacket(AuthorizePacket, 0x000f, "en");
	AddTLVStringToPacket(AuthorizePacket, 0x000e, "us");
	cout<<endl<<"<<====Out packet:"<<endl;
	for(unsigned int i=0; i<SwapWord(AuthorizePacket->Header.DFLen); i++)
		cout<<" 0x"<<hex<<(short int)AuthorizePacket->Data[i];
	cout<<endl<<endl;
	
	//send authorize information to server
	unsigned int SizeData = send(Socket, (const char*)AuthorizePacket, SwapWord(AuthorizePacket->Header.DFLen), 0);
	if(SizeData == SOCKET_ERROR)
	{
		cout<<"Error while sending authorize packet"<<endl;
		if(AuthorizePacket) delete AuthorizePacket;
		return;
	}
	cout<<"Authorize packet was sended"<<endl;

	if(AuthorizePacket) delete AuthorizePacket;
}

WORD SwapWord(WORD value)
{
	return ((value & 0x00FF) << 8) + ((value & 0xFF00) >> 8);
}

DWORD SwapDWord(DWORD value)
{
	DWORD Result=0;
	__asm
	{
		MOV EAX, value
		BSWAP EAX
		MOV Result,EAX
	};
	return Result;
}

void AddTLVStringToPacket(FlapPacket *inFlapPacket, WORD TypeCode, char *value)
{
	//create tlvpacket
	TLVPacket Result;
	memset((void*)&Result, 0, sizeof(TLVPacket));
	Result.TypeCode = SwapWord(TypeCode);
	Result.LengthCode = SwapWord(strlen(value));
	memcpy((void*)Result.Data, (void *)value, strlen(value));

	//insert tlv in the end
	WORD DataLen = SwapWord(inFlapPacket->Header.DFLen);
	WORD SizeOfTLV = 2 + 2 + SwapWord(Result.LengthCode);
	BYTE *Copy = new BYTE[DataLen];
	memcpy(Copy, inFlapPacket->Data, DataLen);
	inFlapPacket->Data = new BYTE[DataLen + SizeOfTLV];
	memcpy(inFlapPacket->Data, Copy, DataLen);
	memcpy(inFlapPacket->Data+DataLen, (void*)&Result, SizeOfTLV);
	inFlapPacket->Header.DFLen = SwapWord(DataLen + SizeOfTLV);
	delete [] Copy;
}

void AddTLVWordToPacket(FlapPacket *inFlapPacket, WORD TypeCode, WORD value)
{
	//create tlvpacket
	TLVPacket Result;
	memset((void*)&Result, 0, sizeof(TLVPacket));
	Result.TypeCode = SwapWord(TypeCode);
	Result.LengthCode = SwapWord(sizeof(WORD));
	WORD SwapValue = SwapWord(value);
	memcpy((void*)Result.Data, (void *)&SwapValue, sizeof(WORD));

	//insert tlv in the end
	WORD DataLen = SwapWord(inFlapPacket->Header.DFLen);
	WORD SizeOfTLV = 2 + 2 + SwapWord(Result.LengthCode);
	BYTE *Copy = new BYTE[DataLen];
	memcpy(Copy, inFlapPacket->Data, DataLen);
	inFlapPacket->Data = new BYTE[DataLen + SizeOfTLV];
	memcpy(inFlapPacket->Data, Copy, DataLen);
	memcpy(inFlapPacket->Data+DataLen, (void*)&Result, SizeOfTLV);
	inFlapPacket->Header.DFLen = SwapWord(DataLen + SizeOfTLV);
	delete [] Copy;
}

void AddTLVDWordToPacket(FlapPacket *inFlapPacket, WORD TypeCode, DWORD value)
{
	//create tlvpacket
	TLVPacket Result;
	memset((void*)&Result, 0, sizeof(TLVPacket));
	Result.TypeCode = SwapWord(TypeCode);
	Result.LengthCode = SwapWord(sizeof(DWORD));
	DWORD SwapValue = SwapDWord(value);
	memcpy((void*)Result.Data, (void *)&SwapValue, sizeof(DWORD));

	//insert tlv in the end
	WORD DataLen = SwapWord(inFlapPacket->Header.DFLen);
	WORD SizeOfTLV = 2 + 2 + SwapWord(Result.LengthCode);
	BYTE *Copy = new BYTE[DataLen];
	memcpy(Copy, inFlapPacket->Data, DataLen);
	inFlapPacket->Data = new BYTE[DataLen + SizeOfTLV];
	memcpy(inFlapPacket->Data, Copy, DataLen);
	memcpy(inFlapPacket->Data+DataLen, (void*)&Result, SizeOfTLV);
	inFlapPacket->Header.DFLen = SwapWord(DataLen + SizeOfTLV);
	delete [] Copy;
}

void ReciveThread(void *Param)
{
	//reciving first packet
	SOCKET *Socket = (SOCKET*)Param;
	unsigned char Buf[4096]={0};
	unsigned int SizeData;
	FlapPacket mFlapPacket;

	while(1)
	{
		memset((void*)&mFlapPacket, 0, sizeof(FlapPacket));
		if(EndWork) return;
		//get packet from login.icq.com
		SizeData = recv(*Socket, (char*)Buf, sizeof(Buf), 0);
		if(SizeData == SOCKET_ERROR)
		{
			cout<<"Recive thread closed"<<endl;
			EndWork = true;
			return;
		}
		//get flap header from first packet
		memcpy((void*)&mFlapPacket.Header, Buf, sizeof(FlapHeader));//read 6 bytes
		//get flap data size
		WORD DataLen = SwapWord(mFlapPacket.Header.DFLen);
		mFlapPacket.Data = new BYTE[DataLen];
		memset(mFlapPacket.Data, 0, DataLen);
		//get flap data
		memcpy((void*)mFlapPacket.Data, Buf+sizeof(FlapHeader), DataLen);

		//copy packet to queue
		PacketQueue.push(mFlapPacket);
	}
}

void QueueThread(void *Param)
{
	SOCKET *Socket = (SOCKET*)Param;
	while(1)
	{
		if(EndWork) return;
		if(PacketQueue.empty())
		{
			Sleep(1);
			continue;
		}
		//output source of packet
		BYTE *Mass = (BYTE*)&PacketQueue.top();
		cout<<endl<<"=====>>In packet:"<<endl;
		for(unsigned int i=0; i<6+SwapWord(PacketQueue.top().Header.DFLen); i++)
			cout<<" 0x"<<hex<<(unsigned short int)Mass[i];

		//is this first packet?
		if(PacketQueue.top().Data[0]==0x0 
			&& PacketQueue.top().Data[1]==0x0
			&& PacketQueue.top().Data[2]==0x0
			&& PacketQueue.top().Data[3]==0x1
			&& PacketQueue.top().Header.DFLen == 0x0400)
		{
			//do authorizing
			AuthorizeInIcq(*Socket, &PacketQueue.top());
			//PacketQueue.pop();
			//Sleep(1);
			//continue;
		}
		PacketQueue.pop();
		Sleep(1);
	}
}

Connect to server
< SERVER FLAP (login) типа хэлло
> CLIENT FLAP (login) ответ превед
> CLIENT SNAC (17,06) засылаем UIN
< SERVER SNAC (17,07) получаем хэш для шифрования пароля
> CLIENT SNAC (17,02) засылаем параметры клиента, набор может быть разный, зависит от того какую версию ICQ клиента вы имитируете
< SERVER SNAC (17,03) получаем последнее слово логин сервера, если все ок, то это айпи+порт сервера и кукис, иначе код ошибки и даже ссылка где скачать клиент получше :laugh:

BYTE *Mass1 = new BYTE[6+SwapWord(Packet->Header.DFLen)];
memcpy(Mass1, Packet, 6+SwapWord(Packet->Header.DFLen));
for(int i=0;i<6+SwapWord(Packet->Header.DFLen);i++)
  cout<<" 0x"<<(unsigned short int)Mass1[i];
cout<<endl;
delete [] Mass1;

//начало куска======================================
unsigned char Buf[4096]={0};
FlapPacket mFlapPacket;
memset((void*)&mFlapPacket, 0, sizeof(FlapPacket));
//get packet from login.icq.com
int SizeData = recv(ServerSock, (char*)Buf, sizeof(Buf), 0);
if(SizeData == SOCKET_ERROR)
{
	cout<<"recv error 1"<<endl;
	cin.get();
	return 0;
}
cout<<"Recived packet"<<endl;
for(int i=0;i<SizeData;i++)
	cout<<" 0x"<<hex<<(unsigned short int)Buf[i];
cout<<endl;

AuthorizeInIcq(ServerSock);

memset(Buf, 0x00, 4096);
SizeData = recv(ServerSock, (char*)Buf, sizeof(Buf), 0);
if(SizeData == SOCKET_ERROR)
{
	if(WSAGetLastError()==10054) cout<<"Server closed connection";
	closesocket(ServerSock);
	WSACleanup();
	cin.get();
	return 0;
}
cout<<"Recived packet"<<endl;
for(int i=0;i<SizeData;i++)
        cout<<" 0x"<<hex<<(unsigned short int)Buf[i];
cout<<endl;
//конец куска======================================

void AuthorizeInIcq(SOCKET Socket)
{
	BYTE HelloPacket[18]={0x2a,0x01,0x65,0xea,0x00,0x0c,0x00,0x00,0x00,0x01,0x80,0x03,0x00,0x04,0x00,0x10,0x00};
	unsigned int SizeData = send(Socket, (const char*)HelloPacket, 18, 0);
	if(SizeData == SOCKET_ERROR)
	{
		cout<<"Error while sending packet"<<endl;
		return;
	}
	cout<<"Send packet"<<endl;
	for(int i=0;i<18;i++)
		cout<<" 0x"<<hex<<(unsigned short int)HelloPacket[i];
	cout<<endl;

	FlapPacket *Packet = new FlapPacket;
	memset(Packet, 0x00, sizeof(FlapPacket));
	char strUIN[] = "123456789";
	Packet->Header.Sign = 0x2A;
	Packet->Header.ChID = 0x02;
	Packet->Header.SeqNum = 0xeb65;//0x65eb
	Packet->Header.DFLen = 0x0a00;//0x00a0
	Packet->Data = new BYTE[10];
	memset(Packet->Data, 0, 10);
	Packet->Data[0]=0x00;
	Packet->Data[1]=0x17;
	Packet->Data[2]=0x00;
	Packet->Data[3]=0x06;
	Packet->Data[4]=0x00;
	Packet->Data[5]=0x00;
	Packet->Data[6]=0x00;
	Packet->Data[7]=0x00;
	Packet->Data[8]=0x00;
	Packet->Data[9]=0x01;
	AddTLVStringToPacket(Packet, 0x0001, strUIN);
	BYTE Mass[29]={0};
	memcpy(Mass, (void*)&Packet->Header, sizeof(FlapHeader));
	memcpy(Mass+6, (void*)Packet->Data, 23);

	SizeData = send(Socket, (const char*)Mass, 18, 0);
	if(SizeData == SOCKET_ERROR)
	{
		cout<<"Error while sending packet"<<endl;
		return;
	}
	cout<<"Send packet"<<endl;
	for(int i=0;i<29;i++)
		cout<<" 0x"<<hex<<(unsigned short int)Mass[i];
	cout<<endl;

	delete Packet;
}

#pragma pack(push, 1)

typedef struct _TWndMethod
{
	LPVOID Method;
	LPVOID Object;
} TWndMethod;

#pragma pack(pop)

function TICQSession.HashPassword: AnsiString;
var
  HashPwd: AnsiString;
  MD5Digest: TMD5Digest;
  MD5Context: TMD5Context;
const
  AIM_MD5_STRING: AnsiString = 'AOL Instant Messenger (SM)';
begin
  HashPwd := MD5Pass(Pwd);
  FillChar(MD5Digest, SizeOf(TMD5Digest), 0);
  MD5Init(MD5Context);
  MD5UpdateBuffer(MD5Context, PAnsiChar(FAuthKey), Length(FAuthKey));
  MD5UpdateBuffer(MD5Context, PAnsiChar(HashPwd), Length(HashPwd));
  MD5UpdateBuffer(MD5Context, PAnsiChar(AIM_MD5_STRING), Length(AIM_MD5_STRING));
  MD5Final(MD5Digest, MD5Context);
  SetLength(Result, Length(MD5Digest));
  StrPLCopy(@Result[1], PAnsiChar(@MD5Digest), Length(MD5Digest))
end;

packDWord(&packet, 0x004C0000); // empty TLV(0x4C): unknown

//вариант 1 один за одним
recv();
recv();
recv();
//вариант 2 поток
void *ReciveThread()
{
while(1)
{
recv();
Sleep(1);
}
}

BYTE UUID_SupportICQ[16] = {0x09, 0x46,0x13, 0x4D, 0x4C, 0x7F, 0x11, 0xD1, 0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00};