spoofsocket.cpp

一个可订制ip packet的程序

	try
	{
		//Add option do nothing
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_DONT_COPY,IPOption_CONTROL,IPOption_NO_OPERATION);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));
	}
	ERROR_HANDLER("AddOption_Nothing")
}

//##ModelId=3B43E6F1005F
tOptionType CIPOptions::GetOption(unsigned char CopyFlag, unsigned char ClassFlag, unsigned char TypeFlag)
{
	//Return a single option type
	return CopyFlag | ClassFlag | TypeFlag;
}

//##ModelId=3B43E6F1004C
void CIPOptions::AddToBuffer(char *buf, int BufLength)
{
	if (m_BufferLength<IPOption_SIZE)
	{
		//Add our option to the buffer
		memcpy(m_Buffer+m_BufferLength,buf,BufLength);
		m_BufferLength+=BufLength;
	}
}

//##ModelId=3B43E6F10100
const char* CIPOptions::GetBuffer()
{
	return m_Buffer;
}

//##ModelId=3B43E6F100F6
int CIPOptions::GetBufferLength()
{
	try
	{
		//Check if auto pad or not
		if (m_AutoPAD)
			if (m_BufferLength/IPOption_WRAPSIZE==(m_BufferLength/IPOption_WRAPSIZE)*IPOption_WRAPSIZE && m_BufferLength>=IPOption_WRAPSIZE)
				return m_BufferLength;
			else
				return int((float)m_BufferLength/IPOption_WRAPSIZE+1)*IPOption_WRAPSIZE;
		else
			return m_BufferLength;
	}
	ERROR_HANDLER_RETURN("GetBufferLength",0)
}

//##ModelId=3B43E6F100EC
void CIPOptions::AddOption_ENDLIST()
{
	try
	{
		//End the list of options
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_DONT_COPY,IPOption_CONTROL,IPOption_END_OPTION);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));
	}
	ERROR_HANDLER("AddOption_ENDLIST")
}

//##ModelId=3B43E6F100D8
void CIPOptions::SetAutoPad(BOOL bAutoPAD)
{
	m_AutoPAD=bAutoPAD;
}

//##ModelId=3B43E6F201EA
CIPOptions* CSpoofSocket::GetOptions()
{
	return m_IPOptions;
}

//##ModelId=3B43E6F100CE
void CIPOptions::Reset()
{
	try
	{
		//Set all to zeros
		memset(m_Buffer,0,IPOption_SIZE);

		//Our buffer length
		m_BufferLength=0;
	}
	ERROR_HANDLER("Reset")
}

//##ModelId=3B43E6F100AF
void CIPOptions::AddOption_Security(unsigned short usType)
{
	try
	{
		//Add option security
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_COPY,IPOption_CONTROL,IPOption_SECURITY);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add length
		OT=IPOption_SECURITY_LENGTH;
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add options
		AddToBuffer((char*)&usType,sizeof(usType));

		//Add zeros
		unsigned short usZeros=0;
		unsigned char ucZeros=0;

		//A hacker would enumarate these values, according to the RFC
		//Compartments
		AddToBuffer((char*)&usZeros,sizeof(usZeros));

		//Handling restrictions
		AddToBuffer((char*)&usZeros,sizeof(usZeros));


		//Transmition control code (TCC)
		AddToBuffer((char*)&usZeros,sizeof(usZeros));
		AddToBuffer((char*)&ucZeros,sizeof(ucZeros));

		//Done
	}
	ERROR_HANDLER("AddOption_Security")
}

//##ModelId=3B43E6F100A5
void CIPOptions::AddOption_Stream(unsigned short usStreamID)
{
	try
	{
		//Add option security
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_COPY,IPOption_CONTROL,IPOption_STREAM);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add length
		OT=IPOption_STREAM_LENGTH;
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add options
		unsigned short usnStreamID;
		usnStreamID=htons(usStreamID);

		AddToBuffer((char*)&usnStreamID,sizeof(usnStreamID));
	}
	ERROR_HANDLER("AddOption_Stream")
}

//##ModelId=3B43E6F1009B
void CIPOptions::AddOption_StrictRoute(tRouting tRoute)
{
	try
	{
		AddOption_Route(IPOption_STRICT_ROUTING,tRoute);
	}
	ERROR_HANDLER("AddOption_StrictRoute")
}

//##ModelId=3B43E6F10088
void CIPOptions::AddOption_RecordRoute(int iMaxRoutes)
{
	try
	{
		//Option for strict routine
		//Add option strict route
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_DONT_COPY,IPOption_CONTROL,IPOption_RECORD_ROUTE);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add the length
		OT=iMaxRoutes*4+IPOption_STRICT_ROUTING_LENGTH;
		AddToBuffer((char*)&OT,sizeof(OT));
		
		//Add the pointer
		OT=IPOption_STRICT_ROUTING_POINTER;
		AddToBuffer((char*)&OT,sizeof(OT));
		
		char cNothing[IPOption_SIZE]="";
		AddToBuffer(cNothing,iMaxRoutes*4);
	}
	ERROR_HANDLER("AddOption_RecordRoute")
}

//##ModelId=3B43E6F10041
void CIPOptions::AddOption_Route(tOptionType tRouteType,tRouting tRoute)
{
	try
	{
		//Option for strict routine
		//Add option strict route
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_COPY,IPOption_CONTROL,tRouteType);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add the length
		OT=tRoute.iRoutes*4+IPOption_STRICT_ROUTING_LENGTH;
		AddToBuffer((char*)&OT,sizeof(OT));
		
		//Add the pointer
		OT=IPOption_STRICT_ROUTING_POINTER;
		AddToBuffer((char*)&OT,sizeof(OT));
		
		//Add the routing table
		AddToBuffer((char*)tRoute.ulRoutes,tRoute.iRoutes*4);
	}
	ERROR_HANDLER("AddOption_Route")
}

//##ModelId=3B43E6F1007F
void CIPOptions::AddOption_LooseRoute(tRouting tRoute)
{
	try
	{
		AddOption_Route(IPOption_LOOSE_ROUTING,tRoute);
	}
	ERROR_HANDLER("AddOption_LooseRoute")
}

//##ModelId=3B43E6F10073
void CIPOptions::AddOption_Timestamp(tOptionType tFlags, int iMaxStamps)
{
	try
	{
		//Add option for timestamp
		tOptionType OT;

		//Get the option
		OT=GetOption(IPOption_DONT_COPY,IPOption_DEBUGGING,IPOption_TIMESTAMP);

		//Add it to buffer
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add the length
		OT=iMaxStamps*IPOption_TIMESTAMP_SIZE+IPOption_TIMESTAMP_LENGTH-1;
		AddToBuffer((char*)&OT,sizeof(OT));
		
		//Add the pointer
		OT=IPOption_TIMESTAMP_LENGTH;
		AddToBuffer((char*)&OT,sizeof(OT));

		//Add the flags
		AddToBuffer((char*)&tFlags,sizeof(tFlags));

		//Add the empty buffer
		char cNothing[IPOption_SIZE]="";
		AddToBuffer(cNothing,iMaxStamps*IPOption_TIMESTAMP_SIZE);
	}
	ERROR_HANDLER("AddOption_Timestamp")
}

//##ModelId=3B43E6F20346
BOOL CSpoofSocket::isRaw()
{
	return m_Raw;
}


//##ModelId=3B43E6F203AA
void CSpoofSocket::InitializeIP()
{
	try
	{
		//Invalid the socket
		m_SpoofSocket=INVALID_SOCKET;

		//More invalids
		m_SourceAddress=NULL;

		//Some defaults
		m_TTL=IP_DEF_TTL;

		//We don't want raw header (so it can work on win 98/NT)
		m_Raw=FALSE;

		//Set our options
		m_IPOptions=NULL;

		//Not connected
		memset(&m_ConnectedTo,0,sizeof(m_ConnectedTo));

		//Set options to false
		SetOptions(FALSE);
	}
	ERROR_HANDLER("InitializeIP")
}

//##ModelId=3B43E6F20314
void CSpoofSocket::AssignSocket(SOCKET sok,unsigned char ucProtocol)
{
	try
	{
		//Sets the protocol
		m_Protocol=ucProtocol;

		//Binds to a socket
		m_SpoofSocket=sok;

		//Set non raw
		SetRaw(FALSE);
	}
	ERROR_HANDLER("AssignSocket")
}

//##ModelId=3B43E6F201DE
int CSpoofSocket::Receive(char *buf, int bufLen)
{
	try
	{
		if (!ValidSocket())
			return SOCKET_ERROR;

		//Receive data
		int iResult;

		//Receive
		if (m_Protocol!=IPPROTO_TCP)
		{
			sockaddr saConnected;

			int iTmp;
			iTmp=sizeof(saConnected);

			//Accept it
			iResult=recvfrom(GetHandle(),buf,bufLen,NULL,&saConnected,&iTmp);

			//If OK set it
			if (iResult!=SOCKET_ERROR)
				memcpy(&m_ConnectedTo,&saConnected,sizeof(saConnected));
		}
		else
			iResult=recv(GetHandle(),buf,bufLen,NULL);

		//Check if error
		if (iResult==SOCKET_ERROR)
			//Error
			SetLastError("Receive");

		//Number of bytes received
		return iResult;
	}
	ERROR_HANDLER_RETURN("Receive",SOCKET_ERROR)
}

//##ModelId=3B43E6F201D5
BOOL CSpoofSocket::ValidAddress(LPCSTR lpAddress)
{
	try
	{
		return inet_addr(lpAddress)!=INADDR_NONE;
	}
	ERROR_HANDLER_RETURN("ValidAddress",FALSE)
}

//##ModelId=3B43E6F30012
sockaddr_in CSpoofSocket::pResolveDNS(LPCSTR lpAddress)
{
	//Convert it to the address
	sockaddr_in adr;
	memset(&adr,0,sizeof(adr));

	try
	{
		//Resolve the DNS
		hostent* hp;
		hp=gethostbyname(lpAddress);

		//Check if this address exists
		if (!hp)
			//Error
			SetLastError("pResolveDNS");
		else
			//Copy the data
			memcpy(&adr.sin_addr,hp->h_addr,hp->h_length);

		return adr;
	}
	ERROR_HANDLER_RETURN("pResolveDNS",adr)
}

//##ModelId=3B43E6F201D3
long CSpoofSocket::ResolveDNS(LPCSTR lpAddress)
{
	try
	{
		//Resolve the DNS
		sockaddr_in tmp;

		tmp=pResolveDNS(lpAddress);

		//Check if valid
		if (tmp.sin_addr.S_un.S_addr==0)
			//Error
			return 0;
		else
			return tmp.sin_addr.S_un.S_addr;
	}
	ERROR_HANDLER_RETURN("ResolveDNS",0)
}

//##ModelId=3B43E6F201C9
BOOL CSpoofSocket::Sniff(BOOL bSniff)
{
	//Start sniffing
	if (!ValidSocket())
		return FALSE;

	try
	{
		unsigned long ulBytes;
		if (WSAIoctl(GetHandle(),SIO_RCVALL,&bSniff,sizeof(bSniff),NULL,0,&ulBytes,NULL,NULL))
		{
			//Error
			SetLastError("Sniff");
			return FALSE;
		}

		return TRUE;
	}
	ERROR_HANDLER_RETURN("Sniff",FALSE)
}

//##ModelId=3B43E6F201BF
long CSpoofSocket::GetPeerAddress()
{
	//Get the address we are connected to
	return m_ConnectedTo.sin_addr.S_un.S_addr;
}

//##ModelId=3B43E6F20179
BOOL CSpoofSocket::Shutdown(SocketShutdown eHow)
{
	if (!CheckSocketValid())
		return FALSE;

	try
	{
		int iHow;

		//Convert the how to a real flag
		if (eHow==ssReceive)
			iHow=SD_RECEIVE;
		else if (eHow==ssSend)
			iHow=SD_SEND;
		else
			iHow=SD_BOTH;

		//Do it
		if (shutdown(GetHandle(),iHow))
		{
			SetLastError("Shutdown");
			return FALSE;
		}

		return TRUE;
	}
	ERROR_HANDLER_RETURN("Shutdown",FALSE)
}

//##ModelId=3B43E6F20170
unsigned short CSpoofSocket::GetPeerPort()
{
	return htons(m_ConnectedTo.sin_port);
}

//##ModelId=3B43E6F203DC
void CSpoofSocket::FinalIPHeader(LPIpHeader lpHead)
{
	//We don't do anything
}

//##ModelId=3B43E6F202CE
LPIpHeader CSpoofSocket::ConstructStaticIPHeader(unsigned char  ucProtocol,
												 unsigned short usFragmentationFlags,
												 unsigned char  ucTTL,
												 unsigned short usIdentification,
												 unsigned char  ucHeaderLength)
{
	try
	{
		//Need to construct the IP header
		LPIpHeader lpHead=new _IpHeader;

		//Header length (in 32 bits)
		lpHead->HeaderLength_Version=ucHeaderLength/4 + IpVersion*16;

		//Protocol
		lpHead->Protocol=ucProtocol;

		//Fragmentation flags
		lpHead->FragmentationFlags=htons(usFragmentationFlags);

		//Time to live
		lpHead->TTL=ucTTL;

		//Checksum - set to 0
		lpHead->CheckSum=0;

		//Identification
		lpHead->Identification=htons(usIdentification);

		//Precedence
		lpHead->TypeOfService=IpService_ROUTINE;

		//Return IP to user
		return lpHead;
	}
	ERROR_HANDLER_STATIC_RETURN(CSpoofSocket_LOGNAME,"ConstructIPHeader",NULL)
}