Open source winsock TCP/IP library V4: TCPCrafter.cpp Source File

00001 /*
00002  *  Copyright (c) 2000-2003 Barak Weichselbaum <barak@komodia.com>
00003  *  All rights reserved.
00004  *
00005  * Redistribution and use in source and binary forms, with or without
00006  * modification, are permitted provided that the following conditions
00007  * are met:
00008  * 1. Redistributions of source code must retain the above copyright
00009  *    notice, this list of conditions and the following disclaimer.
00010  * 2. Redistributions in binary form must reproduce the above copyright
00011  *    notice, this list of conditions and the following disclaimer in the
00012  *    documentation and/or other materials provided with the distribution.
00013  *
00014  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
00015  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00016  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00017  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
00018  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00019  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
00020  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
00021  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00022  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
00023  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00024  * SUCH DAMAGE.
00025  *
00026  * Contact info:
00027  * -------------
00028  *
00029  * Site:                    http://www.komodia.com
00030  * Main contact:            barak@komodia.com
00031  * For custom projects, 
00032  * consulting, or other
00033  * paid services:           sales@komodia.com
00034  */
00035 
00036 #include "stdafx.h"
00037 #include "TCPCrafter.h"
00038 
00039 #include "ErrorHandlerMacros.h"
00040 #include "Array_ptr.h"
00041 
00042 #include <memory>
00043 
00044 #ifdef _MEMORY_DEBUG 
00045     #define new    DEBUG_NEW  
00046     #define malloc DEBUG_MALLOC  
00047     static char THIS_FILE[] = __FILE__;  
00048 #endif
00049 
00050 KOMODIA_NAMESPACE_START
00051 
00052 #define CTCPCrafter_Class "CTCPCrafter"
00053 
00054 CTCPCrafter::CTCPCrafter() : CTCPSocket(TRUE), 
00055                              CIPCrafter()
00056 {
00057     try
00058     {
00059         //Set our name
00060         CTCPSocket::SetName(CTCPCrafter_Class);
00061 
00062         //Set our default
00063         m_bTCPUseDefaultChecksum=TRUE;
00064 
00065         //No sequence
00066         m_uiSequenceNumber=0;
00067 
00068         //No ack
00069         m_uiAcknowledgeNumber=0;
00070 
00071         //No offset
00072         m_ucDataOffset=TCPHeaderLength/4;
00073 
00074         //No flags
00075         m_ucFlags=0;
00076 
00077         //No window
00078         m_usWindow=512;
00079 
00080         //No urgent pointer
00081         m_usUrgentPointer=0;
00082 
00083         //Set the protocol
00084         SetProtocol(IPPROTO_TCP);
00085     }
00086     ERROR_HANDLER("CTCPCrafter")
00087 }
00088 
00089 CTCPCrafter::~CTCPCrafter()
00090 {
00091 }
00092 
00093 LPIpHeader CTCPCrafter::ConstructIPHeader(unsigned char  ucProtocol,
00094                                           unsigned short usFragmentationFlags,
00095                                           unsigned char  ucTTL,
00096                                           unsigned short usIdentification,
00097                                           unsigned char  ucHeaderLength)const
00098 {
00099     return ConstructCraftedIPHeader(ucProtocol,
00100                                     usFragmentationFlags,
00101                                     ucTTL,
00102                                     usIdentification,
00103                                     ucHeaderLength);
00104 }
00105 
00106 void CTCPCrafter::FinalIPHeader(LPIpHeader lpHead)const
00107 {
00108     try
00109     {
00110         //Check if we need to modify the header
00111         if (!m_DefaultChecksum)
00112             lpHead->usChecksum=htons(m_usChecksum);
00113     }
00114     ERROR_HANDLER("FinalIPHeader")
00115 }
00116 
00117 void CTCPCrafter::SetSequenceNumber(unsigned int uiSequenceNumber)
00118 {
00119     m_uiSequenceNumber=uiSequenceNumber;
00120 }
00121 
00122 void CTCPCrafter::SetAcknowledgeNumber(unsigned int uiAcknowledgeNumber)
00123 {
00124     m_uiAcknowledgeNumber=uiAcknowledgeNumber;
00125 }
00126 
00127 void CTCPCrafter::SetDataOffset(unsigned char ucDataOffset)
00128 {
00129     m_ucDataOffset=ucDataOffset;
00130 }
00131 
00132 void CTCPCrafter::SetFlags(unsigned char ucFlags)
00133 {
00134     m_ucFlags=ucFlags;
00135 }
00136 
00137 void CTCPCrafter::SetWindow(unsigned short usWindow)
00138 {
00139     m_usWindow=usWindow;
00140 }
00141 
00142 void CTCPCrafter::SetTCPChecksum(unsigned short usTCPChecksum)
00143 {
00144     m_usTCPChecksum=usTCPChecksum;
00145 }
00146 
00147 void CTCPCrafter::SetTCPUseDefaultChecksum(BOOL bDefault)
00148 {
00149     m_bTCPUseDefaultChecksum=bDefault;
00150 }
00151 
00152 void CTCPCrafter::SetUrgentPointer(unsigned short usUrgentPointer)
00153 {
00154     m_usUrgentPointer=usUrgentPointer;
00155 }
00156 
00157 LPTCPHeader CTCPCrafter::ConstructTCPHeader(unsigned short usSourcePort,
00158                                             unsigned short usDestinationPort,
00159                                             unsigned char ucHeaderLength)const
00160 {
00161     try
00162     {
00163         //Create the initial header
00164         LPTCPHeader lpHead;
00165         lpHead=CTCPSocket::ConstructTCPHeader(usSourcePort,
00166                                               usDestinationPort,
00167                                               ucHeaderLength);
00168 
00169         if (!lpHead)
00170         {
00171             //Report it
00172             ReportError("ConstructTCPHeader","Received null TCP header!");
00173 
00174             //Exit
00175             return NULL;
00176         }
00177 
00178         //Overide some data
00179         lpHead->usWindows=htons(m_usWindow);
00180 
00181         //Set the packet number
00182         lpHead->ulAcknowledgeNumber=htonl(m_uiAcknowledgeNumber);
00183 
00184         //And the sequence
00185         lpHead->ulSequenceNumber=htonl(m_uiSequenceNumber);
00186 
00187         //Data offset
00188         lpHead->ucDataOffset=m_ucDataOffset << 4;
00189 
00190         //Flags
00191         lpHead->ucFlags=m_ucFlags;
00192 
00193         //Urgent pointer
00194         lpHead->usUrgentPointer=htons(m_usUrgentPointer);
00195 
00196         //Return it to the user
00197         return lpHead;
00198     }
00199     ERROR_HANDLER_RETURN("ConstructTCPHeader",NULL)
00200 }
00201 
00202 void CTCPCrafter::FinalTCPHeader(LPTCPHeader lpHead)const
00203 {
00204     try
00205     {
00206         if (!m_bTCPUseDefaultChecksum)
00207             lpHead->usChecksum=htons(m_usTCPChecksum);
00208     }
00209     ERROR_HANDLER("FinalTCPHeader")
00210 }
00211 
00212 BOOL CTCPCrafter::SendRaw(unsigned short usSourcePort, 
00213                           const std::string& rDestinationAddress, 
00214                           unsigned short usDestinationPort,
00215                           const char* pBuffer,
00216                           unsigned long ulBufLength,
00217                           unsigned char ucFlags)
00218 {
00219     try
00220     {
00221         return CTCPSocket::SendRaw(usSourcePort,
00222                                    rDestinationAddress,
00223                                    usDestinationPort,
00224                                    pBuffer,
00225                                    ulBufLength,
00226                                    ucFlags);
00227     }
00228     ERROR_HANDLER_RETURN("SendRaw",FALSE)
00229 }
00230 
00231 BOOL CTCPCrafter::SendRaw(unsigned short usSourcePort, 
00232                           IP aDestinationAddress, 
00233                           unsigned short usDestinationPort,
00234                           const char* pBuffer,
00235                           unsigned long ulBufLength,
00236                           unsigned char ucFlags)
00237 {
00238     try
00239     {
00240         //Our TCP flags
00241         unsigned char uclFlags;
00242         
00243         if (!ucFlags)
00244             uclFlags=m_ucFlags;
00245         else
00246             uclFlags=ucFlags;
00247 
00248         return CTCPSocket::SendRaw(usSourcePort,
00249                                    aDestinationAddress,
00250                                    usDestinationPort,
00251                                    pBuffer,
00252                                    ulBufLength,
00253                                    uclFlags);
00254     }
00255     ERROR_HANDLER_RETURN("SendRaw",FALSE)
00256 }
00257 
00258 char* CTCPCrafter::GetCraftedPacket(unsigned short usSourcePort,
00259                                     unsigned long ulDestinationAddress,
00260                                     const char* pBuffer,
00261                                     unsigned long ulBufferSize,
00262                                     unsigned short usDestinationPort,
00263                                     unsigned short& usTotalSize)const
00264 {
00265     try
00266     {
00267         //Let's try our first attack
00268         LPTCPHeader lpHead;
00269 
00270         //Header length
00271         int iHeaderLength;
00272         iHeaderLength=TCPHeaderLength;
00273 
00274         //Create the header
00275         lpHead=ConstructTCPHeader(usSourcePort,
00276                                   usDestinationPort,
00277                                   iHeaderLength);
00278 
00279         //Protect it
00280         std::auto_ptr<TCPHeader> pProtection(lpHead);
00281 
00282         //Our total length
00283         int iTotalLength;
00284         iTotalLength=iHeaderLength+ulBufferSize;
00285 
00286         //Allocate the buffer
00287         char* pNewBuffer;
00288         pNewBuffer=new char[iTotalLength];
00289 
00290         //Protect it
00291         CArray_ptr<char> pBufferProtection(pNewBuffer);
00292 
00293         //Copy the header
00294         memcpy(pNewBuffer,
00295                lpHead,
00296                iHeaderLength);
00297 
00298         //Copy the data
00299         if (ulBufferSize)
00300             //Copy the data
00301             memcpy(pNewBuffer+iHeaderLength,
00302                    pBuffer,
00303                    ulBufferSize);
00304 
00305         //Calculate the checksum
00306         lpHead->usChecksum=CalculatePseudoChecksum(pNewBuffer,
00307                                                    iTotalLength,
00308                                                    ulDestinationAddress,
00309                                                    iTotalLength);
00310 
00311         //Last change to the header
00312         FinalTCPHeader(lpHead);
00313 
00314         //Copy the header
00315         memcpy(pNewBuffer,
00316                lpHead,
00317                iHeaderLength);
00318 
00319         //Send the data
00320         char* pNewData;
00321         pNewData=CIPCrafter::GetCraftedPacket(this,
00322                                               ulDestinationAddress,
00323                                               pNewBuffer,
00324                                               iTotalLength,
00325                                               usTotalSize);
00326 
00327         //Exit
00328         return pNewData;
00329     }
00330     ERROR_HANDLER_RETURN("GetCraftedPacket",NULL)
00331 }
00332 
00333 KOMODIA_NAMESPACE_END
Retail products

Documentation

TCPCrafter.cpp
