一份发送数据包的源代码

 

本来这种东西网络上很多了,最近写后门,需要一个发包的工具,简简单单的,与其用别人的,不如自己写一个...同样,既然要写了,就干脆写全了点..
下面这个是前几天写的源码,提取文件部分还没怎么测试(一般用不到,我就不测试了)..
代码的帮助我写的很详细,这里就不做罗嗦的说明了,简单说一下这个咚咚的作用...
软件提供了常用的4种报文的自定义发送(包括所有能修改的字段),并提供5种伪造源格式,用预先计算效验和的办法,提高发送报文速度等...其他的,就用代码说明吧.....

写的仓卒,难免出错,希望大家给予指出...
//
// //
// 数据包发送程序1.0 //
// //
// 日期: [2004.4.25] //
// 作者: [Zvrop][zvrop@163.com] //
// 环境: [WINXP + Visual C++ 6.0] //
// 主页: [http://www.gedao.com][http://www.ringz.org] //
// 声名: [如果你修改了什么,请发给我一份拷贝,谢谢] //
// //
//

//
//若干的头文件
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <winsock2.h>
#include <windows.h>
#include <Ws2tcpip.h>

//
//若干的宏定义
//
#define IPVER 4 //ip协议预定
#define MAX_TIMEOUT 2000 //最大超时时间
#define MAX_HOSTNAME_LAN 1024 //主机名最长
#define MAX_BUFF_LEN 65500 //发送缓冲区最大
#define MAX_PORT 65500 //端口最大
#define MAX_CHAR 255 //uchar类型最大
#define MAX_SHORT 65535 //ushort类型最大
#define MAX_LONG 4294967294 //ulong类型最大
#define DEF_PORT_DA 1025 //默认的端口
#define DEF_FORGE_IP 0xffffffff //默认的伪造IP
#define DEF_FORGE_PORT 0xffff //默认的伪造端口

//
//若干的报文头部首部结构定义
//
//定义IP首部
typedef struct _iphdr{
UCHAR h_verlen; //4位首部长度,4位IP版本号
UCHAR tos; //8位服务类型TOS
USHORT total_len; //16位总长度（字节）
USHORT ident; //16位标识
USHORT frag_and_flags; //3位标志位
UCHAR ttl; //8位生存时间 TTL
UCHAR proto; //8位协议 (TCP, UDP 或其他)
USHORT checksum; //16位IP首部校验和
ULONG sourceIP; //32位源IP地址
ULONG destIP; //32位目的IP地址
}IP_HEADER;
//定义TCP伪首部
typedef struct _psdhdr{
ULONG saddr; //源地址
ULONG daddr; //目的地址
UCHAR mbz; //没用
UCHAR ptcl; //协议类型
USHORT tcpl; //TCP长度
}PSD_HEADER;
//定义TCP首部
typedef struct _tcphdr{
USHORT th_sport; //16位源端口
USHORT th_dport; //16位目的端口
ULONG th_seq; //32位序列号
ULONG th_ack; //32位确认号
UCHAR th_lenres; //4位首部长度/6位保留字
UCHAR th_flag; //6位标志位
USHORT th_win; //16位窗口大小
USHORT th_sum; //16位校验和
USHORT th_urp; //16位紧急数据偏移量
}TCP_HEADER;
//定义UDP首部
typedef struct _udphdr{
USHORT uh_sport; //16位源端口
USHORT uh_dport; //16位目的端口
USHORT uh_len; //16位长度
USHORT uh_sum; //16位校验和
} UDP_HEADER;
//定义ICMP首部
typedef struct _icmphdr{
UCHAR i_type; //8位类型
UCHAR i_code; //8位代码
USHORT i_cksum; //16位校验和
USHORT i_id; //识别号（一般用进程号作为识别号）
USHORT i_seq; //报文序列号
ULONG timestamp; //时间戳
}ICMP_HEADER;
//定义IGMP首部
typedef struct _igmphdr{
UCHAR i_code; //8位代码
UCHAR i_type; //8位类型
USHORT i_nv; //没用
USHORT i_cksum; //16位校验和
ULONG i_addr; //32位组地址
}IGMP_HEADER;

//
//若干的报文首部结构变量
//
IP_HEADER ip_header = {0}; //ip首部结构
PSD_HEADER psd_header = {0}; //伪首部结构
TCP_HEADER tcp_header = {0}; //tcp首部结构
UDP_HEADER udp_header = {0}; //udp首部结构
ICMP_HEADER icmp_header = {0}; //icmp首部结构
IGMP_HEADER igmp_header = {0}; //igmp首部结构

//
//若干的全局变量
//
//有关临时堆变量的指针
ULONG *Ip_Buff = NULL; //IP缓冲区
USHORT *Port_Buff = NULL; //端口缓冲区
USHORT *Ip_Chk_Buff = NULL; //IP首部效验和缓冲区
USHORT *Other_Chk_Buff = NULL; //其他首部效验和缓冲区
//发送有关的参数
char Dest_Ip[MAX_HOSTNAME_LAN] = {0}; //目的ip
short Send_Data_Type = 2; //发送类型
ULONG Send_Degree = 10; //发送次数
ULONG Send_Sdeg = 1; //同一报文发送次数
USHORT Delay_Time = 0; //延时时间
SOCKET SockRaw = 0; //socket句柄
struct sockaddr_in DestAddr = {0}; //socket地址结构
char Send_Dest_Data[MAX_BUFF_LEN] = {0}; //发送的报文信息
char Send_Data_File[MAX_PATH] = {0}; //数据文件路径
int Send_Data_Size = 0; //发送信息大小
//各个报文的可变参数变量
UCHAR IP_TOSE = 0; //IP服务类型
USHORT IP_IDENT = 0; //IP16位标识
USHORT IP_FLAG = 0; //IP标志
UCHAR IP_TTLE = 128; //IP ttl值
USHORT TCP_WINS = 16384; //TCP窗口值
UCHAR TCP_FLAG = 2; //TCP标志
ULONG TCP_SEQ = 1; //32位序列号
ULONG TCP_ACK = 0; //32位确认号
USHORT TCP_URP = 0; //TCP紧急数据偏移
USHORT ICMP_TYPE = 8; //ICMP类型值
USHORT ICMP_CODE = 0; //ICMP代码值
USHORT ICMP_ID = 2; //ICMP识别号值
USHORT ICMP_SEQ = 1; //ICMP序号值
ULONG ICMP_TIME = 1; //ICMP时间戳值
USHORT IGMP_CODE = 1; //IGMP版本值
USHORT IGMP_TYPE = 1; //IGMP类型值
ULONG IGMP_ADDR = 100; //IGMP32位组地址
//伪造有关的变量
ULONG Ip_Forge_Deg = 100; //伪造个数
short Forge_Type = 1; //伪造模式
char Forge_Ip_File[MAX_PATH] = {0}; //伪造ip文件路径
char Forge_Ip[MAX_HOSTNAME_LAN] = {0}; //伪造IP
USHORT Forge_Port = DEF_PORT_DA; //伪造的端口
//和程序有关的临时变量
USHORT PORTT = 0; //临时变量,记录目的IP的端口
ULONG IPTL = 0; //临时变量,记录目的ip
int ErrorCode = 0; //错误返回寄存变量

//
//若干函数的声名
//
void Usage();
USHORT checksum(USHORT *buffer, int size);
int SetInitializeValue(int argc, char *argv[]);
int SetInitializeSock();
int GetIpAndPortByLine(char *IPL);
int MakeForgeData();
int AccCheckSum();
//重载函数
int AssMemory(ULONG **a, ULONG sa, USHORT **b, ULONG sb);
int AssMemory(USHORT **a, ULONG sa, USHORT **b, ULONG sb);

//
//主函数
//
int main(int argc, char *argv[]){
//参数少于2个,退出
if (argc < 2){
Usage();
return 0;
}
fprintf(stderr, "1.开始分析命令行,获得参数,稍等.../n");
//分析命令行,赋初始化值.
if(!SetInitializeValue(argc, argv))
return 0;

fprintf(stderr, "2.正在初始化网络,稍等.../n");
//初始化连接函数
if(!SetInitializeSock())
return 0;
fprintf(stderr, "3.正在构造伪造数据包,稍等.../n");
//构造伪造数据
if(!MakeForgeData())
return 0;

fprintf(stderr, "4.正在计算效验和,稍等.../n");
//计算效验和
if(!AccCheckSum())
return 0;
//下面开始发送信息

//填充地址结构
memset(&DestAddr, 0, sizeof(DestAddr));
DestAddr.sin_family = AF_INET; //internet网络
DestAddr.sin_port = htons(PORTT);
DestAddr.sin_addr.s_addr = htonl(IPTL); //目的IP

//开始循环发送消息,因为效验和已经计算好,这里就是一些指针和内存的操作
char Sendto_Buff[MAX_BUFF_LEN];
ULONG i = 0, j, HL = 0, SZE = sizeof(DestAddr);
for(j = 0; j < Send_Degree; j++, i++){
//循环使用ip段
if(i >= Ip_Forge_Deg)
i = 0;
//发送缓冲区清空,可要可不要
memset(Sendto_Buff, 0, MAX_BUFF_LEN);
//填充可变参数
ip_header.sourceIP = htonl(Ip_Buff[i]);
ip_header.ident = htons((USHORT)((i + IP_IDENT) % MAX_SHORT) + 1);
ip_header.checksum = Ip_Chk_Buff[i];

//填充发送缓冲区
memcpy(Sendto_Buff, &ip_header, sizeof(IP_HEADER));
//判断是什么类型报文,发送
switch(Send_Data_Type){
case 1:

//填充tcp伪首部和tcp首部
psd_header.saddr = ip_header.sourceIP;
tcp_header.th_seq = htonl((TCP_SEQ + i) % MAX_SHORT);;
tcp_header.th_sport = htons(Port_Buff[i]);

//填充效验和,已经计算的
tcp_header.th_sum = Other_Chk_Buff[i];
//填充缓冲区
memcpy(Sendto_Buff + sizeof(IP_HEADER), &tcp_header, sizeof(TCP_HEADER));
memcpy(Sendto_Buff + sizeof(IP_HEADER) + sizeof(TCP_HEADER),
Send_Dest_Data, Send_Data_Size);
//计算报文长度
HL = sizeof(IP_HEADER) + sizeof(TCP_HEADER) + Send_Data_Size;
break;
case 2:
psd_header.saddr = ip_header.sourceIP;
udp_header.uh_sport = htons(Port_Buff[i]);
udp_header.uh_sum = Other_Chk_Buff[i];
memcpy(Sendto_Buff + sizeof(IP_HEADER), &udp_header, sizeof(UDP_HEADER));
memcpy(Sendto_Buff + sizeof(IP_HEADER) + sizeof(UDP_HEADER),
Send_Dest_Data, Send_Data_Size);
HL = sizeof(IP_HEADER) + sizeof(UDP_HEADER) + Send_Data_Size;
break;
case 3:
icmp_header.i_seq = htons((USHORT)((ICMP_SEQ + i) % MAX_SHORT));
icmp_header.timestamp = htonl((ICMP_TIME + i) % MAX_SHORT);
icmp_header.i_cksum = Other_Chk_Buff[i];

memcpy(Sendto_Buff + sizeof(IP_HEADER), &icmp_header, sizeof(ICMP_HEADER));
memcpy(Sendto_Buff + sizeof(IP_HEADER) + sizeof(ICMP_HEADER),
Send_Dest_Data, Send_Data_Size);
HL = sizeof(IP_HEADER) + sizeof(ICMP_HEADER) + Send_Data_Size;
break;
case 4:
igmp_header.i_cksum = Other_Chk_Buff[i];
memcpy(Sendto_Buff + sizeof(IP_HEADER), &icmp_header, sizeof(IGMP_HEADER));
memcpy(Sendto_Buff + sizeof(IP_HEADER) + sizeof(IGMP_HEADER),
Send_Dest_Data, Send_Data_Size);
HL = sizeof(IP_HEADER) + sizeof(IGMP_HEADER) + Send_Data_Size;
break;
}//End of switch
//发送
for(ULONG SN = 0; SN < Send_Sdeg; SN++){
ErrorCode = sendto(SockRaw,
Sendto_Buff,
HL,
0,
(struct sockaddr*) &DestAddr,
SZE);
}//End of for
//打印提示符
fprintf(stderr, ".");
//如果出错,打印出错信息,并暂停
if (ErrorCode == SOCKET_ERROR){
fprintf(stderr, "/n数据发送错误,错误代码:%d/n"
"Ctrl+C退出,任意键继续发送.../n",GetLastError());
system("PAUSE");
}
//延迟一定时间
Sleep(Delay_Time);
}//End of for
//释放一些内存
if(Ip_Buff) free(Ip_Buff);
if(Port_Buff) free(Port_Buff);
if(Ip_Chk_Buff) free(Ip_Chk_Buff);
if(Other_Chk_Buff) free(Other_Chk_Buff);
//关闭句柄
closesocket(SockRaw);
WSACleanup();
return 1;
}

//
//计算效验和
//填充报文必须注意网络字节和主机字节的切换
//
int AccCheckSum(){
//计算缓冲区
char MakeSumBuff[MAX_BUFF_LEN];
//分析目的IP流
if(!GetIpAndPortByLine(Dest_Ip))
return 0;
//开始设置IP首部的变量

ip_header.h_verlen = (IPVER << 4 | sizeof(ip_header) / sizeof(unsigned long)); //版本号
ip_header.tos = (UCHAR)IP_TOSE; //服务类型
//这里还差加一个具体的报文字段的长度
ip_header.total_len = sizeof(IP_HEADER) + Send_Data_Size; //16位总长度（字节）
//下面这个表示每发送一次加1,需要更改
ip_header.ident = 0; //16位标识
ip_header.frag_and_flags = IP_FLAG; //3位标志位
ip_header.ttl = (UCHAR)IP_TTLE; //8位生存时间TTL
//协议类型需要更改
ip_header.proto = 0; //协议类型
//效验和需要更改
ip_header.checksum = 0; //效验和
//源地址需要更改
ip_header.sourceIP = 0; //32位源IP地址
//这里改变了字节顺序
ip_header.destIP = htonl(IPTL); //32位目的IP地址

if(!AssMemory(&Ip_Chk_Buff, Ip_Forge_Deg, &Other_Chk_Buff, Ip_Forge_Deg))
return 0;
ULONG i;
switch(Send_Data_Type){
case 1://tcp包
//协议设置为TCP
ip_header.proto = IPPROTO_TCP;
//加上TCP结构,赋值给IP头部
ip_header.total_len = htons(ip_header.total_len + sizeof(TCP_HEADER));
//源地址需要更改
psd_header.saddr = 0; //源地址
psd_header.daddr = ip_header.destIP; //目的地址
psd_header.mbz = 0;
psd_header.ptcl = ip_header.proto; //直接取上面的协议
psd_header.tcpl = htons(sizeof(TCP_HEADER) + Send_Data_Size);

//填充TCP首部
//源端口号需要更改
tcp_header.th_sport = 0; //源端口号
tcp_header.th_dport = htons(PORTT); //目的端口号
//syn序列号要改的
tcp_header.th_seq = 0; //SYN序列号
tcp_header.th_ack = htonl(TCP_ACK); //ACK序列号置为0
tcp_header.th_lenres = (sizeof(TCP_HEADER) /sizeof(unsigned long) << 4 | 0); //TCP长度和保留位
tcp_header.th_flag = (UCHAR)TCP_FLAG; //SYN 标志
tcp_header.th_win = htons(TCP_WINS); //窗口大小
tcp_header.th_urp = htons(TCP_URP); //偏移
//效验和需要更改
tcp_header.th_sum = 0; //校验和
//循环计算Ip_Forge_Deg个效验和出来
for(i = 0; i < Ip_Forge_Deg; i++){
//填充一些每次都改变的变量,比如源IP,源端口,seq等等.
ip_header.sourceIP = htonl(Ip_Buff[i]);
ip_header.ident = htons((USHORT)((i + IP_IDENT) % MAX_SHORT) + 1);

psd_header.saddr = ip_header.sourceIP;
tcp_header.th_sport = htons(Port_Buff[i]);
tcp_header.th_seq = htonl((TCP_SEQ + i) % MAX_SHORT);
//吧tcp伪首部和tcp首部先送入计算出tcp首部效验和
memset(MakeSumBuff, 0, MAX_BUFF_LEN);
memcpy(MakeSumBuff, &psd_header, sizeof(PSD_HEADER));
memcpy(MakeSumBuff + sizeof(PSD_HEADER), &tcp_header, sizeof(TCP_HEADER));
memcpy(MakeSumBuff + sizeof(PSD_HEADER) + sizeof(TCP_HEADER),
Send_Dest_Data, Send_Data_Size);
Other_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(PSD_HEADER) + sizeof(TCP_HEADER) + Send_Data_Size);
//然后结合IP首部,计算出IP首部效验和
memset(MakeSumBuff, 0, MAX_BUFF_LEN);
memcpy(MakeSumBuff, &ip_header, sizeof(IP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER), &tcp_header, sizeof(TCP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER) + sizeof(TCP_HEADER),
Send_Dest_Data, Send_Data_Size);
Ip_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(IP_HEADER) + sizeof(TCP_HEADER) + Send_Data_Size);
}//End of for

break;
case 2://udp包

ip_header.proto = IPPROTO_UDP;
ip_header.total_len = htons(ip_header.total_len + sizeof(UDP_HEADER));
psd_header.saddr = 0;
psd_header.daddr = ip_header.destIP;
psd_header.mbz = 0;
psd_header.ptcl = ip_header.proto;
psd_header.tcpl = htons(sizeof(UDP_HEADER) + Send_Data_Size);
udp_header.uh_sport = 0;
udp_header.uh_dport = htons(PORTT);
udp_header.uh_len = htons(sizeof(UDP_HEADER) + Send_Data_Size);
udp_header.uh_sum = 0;

for(i = 0; i < Ip_Forge_Deg; i++){
ip_header.sourceIP = htonl(Ip_Buff[i]);
ip_header.ident = htons((USHORT)((i + IP_IDENT) % MAX_SHORT) + 1);

psd_header.saddr = ip_header.sourceIP;
udp_header.uh_sport = htons(Port_Buff[i]);
memset(MakeSumBuff, 0, MAX_BUFF_LEN);
memcpy(MakeSumBuff, &psd_header, sizeof(PSD_HEADER));
memcpy(MakeSumBuff + sizeof(PSD_HEADER), &udp_header, sizeof(UDP_HEADER));
memcpy(MakeSumBuff + sizeof(PSD_HEADER) + sizeof(UDP_HEADER),
Send_Dest_Data, Send_Data_Size);
Other_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(PSD_HEADER) + sizeof(UDP_HEADER) + Send_Data_Size);
memset(MakeSumBuff, 0, MAX_BUFF_LEN);
memcpy(MakeSumBuff, &ip_header, sizeof(IP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER), &udp_header, sizeof(UDP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER) + sizeof(UDP_HEADER),
Send_Dest_Data, Send_Data_Size);
Ip_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(IP_HEADER) + sizeof(UDP_HEADER) + Send_Data_Size);
}//End of for
break;
case 3://icmp包
ip_header.proto = IPPROTO_ICMP;
ip_header.total_len = htons(ip_header.total_len + sizeof(ICMP_HEADER));
icmp_header.i_type = (UCHAR)ICMP_TYPE;
icmp_header.i_code = (UCHAR)ICMP_CODE;
icmp_header.i_cksum = 0;
icmp_header.i_id = htons(ICMP_ID);
icmp_header.i_seq = 0;
icmp_header.timestamp = 0;
for(i = 0; i < Ip_Forge_Deg; i++){
ip_header.sourceIP = htonl(Ip_Buff[i]);
ip_header.ident = htons((USHORT)((i + IP_IDENT) % MAX_SHORT) + 1);

icmp_header.i_seq = htons((USHORT)((ICMP_SEQ + i) % MAX_SHORT));
icmp_header.timestamp = htonl((ICMP_TIME + i) % MAX_SHORT);
memcpy(MakeSumBuff, &icmp_header, sizeof(ICMP_HEADER));
memcpy(MakeSumBuff + sizeof(icmp_header),
Send_Dest_Data, Send_Data_Size);
Other_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(ICMP_HEADER) + Send_Data_Size);
memcpy(MakeSumBuff, &ip_header, sizeof(IP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER), &icmp_header, sizeof(ICMP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER) + sizeof(ICMP_HEADER),
Send_Dest_Data, Send_Data_Size);
Ip_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(IP_HEADER) + sizeof(ICMP_HEADER) + Send_Data_Size);
}
break;
case 4://igmp包
ip_header.proto = IPPROTO_IGMP;
ip_header.total_len = htons(ip_header.total_len + sizeof(IGMP_HEADER));
igmp_header.i_code = (UCHAR)IGMP_CODE;
igmp_header.i_type = (UCHAR)IGMP_TYPE;
igmp_header.i_addr = htonl(IGMP_ADDR);
igmp_header.i_nv = 0;
for(i = 0; i < Ip_Forge_Deg; i++){
ip_header.sourceIP = htonl(Ip_Buff[i]);
ip_header.ident = htons((USHORT)((i + IP_IDENT) % MAX_SHORT) + 1);

memcpy(MakeSumBuff, &igmp_header, sizeof(IGMP_HEADER));
memcpy(MakeSumBuff + sizeof(igmp_header),
Send_Dest_Data, Send_Data_Size);
Other_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(IGMP_HEADER) + Send_Data_Size);
memcpy(MakeSumBuff, &ip_header, sizeof(IP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER), &igmp_header, sizeof(IGMP_HEADER));
memcpy(MakeSumBuff + sizeof(IP_HEADER) + sizeof(IGMP_HEADER),
Send_Dest_Data, Send_Data_Size);
Ip_Chk_Buff[i] = checksum((USHORT *)MakeSumBuff,
sizeof(IP_HEADER) + sizeof(IGMP_HEADER) + Send_Data_Size);
}
break;
default:
fprintf(stderr, "Unknow Data Type/n");
return 0;
}//End of switch
return 1;
}

//
//构造伪造数据
//
int MakeForgeData(){
//填充伪造IP
switch(Forge_Type){
case 1://本机型
//获得主机名
char name[MAX_HOSTNAME_LAN];
memset(name, 0, MAX_HOSTNAME_LAN);
if(SOCKET_ERROR == gethostname(name, MAX_HOSTNAME_LAN)){
fprintf(stderr, "gethostname 函数失败,错误代码: %d/n",WSAGetLastError());
return 0;
}
//通过主机名获得IP
struct hostent * pHostent;
pHostent = NULL;
pHostent = gethostbyname(name);
if(pHostent == NULL){
fprintf(stderr, "gethostbyname 函数失败,错误代码: %d/n",WSAGetLastError());
return 0;
}
//获得本机IP,注意,这里是主机字节顺序,pHost指向的是网络字节顺序
//要累加必须先转化为主机字节,然后进行+1等操作,最后再转到网络字节
//当然这里可以不需要,不过为了兼容后面的操作,还是转换了.
IPTL = ntohl((ULONG)(*(struct in_addr*)pHostent->h_addr).s_addr);

//伪造个数设置为1
//同样,为了代码看起来比较清楚
Ip_Forge_Deg = 1;
//申请缓冲区,这里只有1个
//后面不要忘记释放了
//另外,这两个的值是不同类型的,注意
if(!AssMemory(&Ip_Buff, Ip_Forge_Deg, &Port_Buff, Ip_Forge_Deg))
return 0;

//填充缓冲区
PORTT = Forge_Port;
Port_Buff[0] = PORTT;
Ip_Buff[0] = IPTL;
break;
case 2://指定ip型
//拆分参数里面的命令行
//值得注意的是,这里返回的IPTL的值就是主机字节了,不需要再做转换
if(!GetIpAndPortByLine(Forge_Ip))
return 0;
Ip_Forge_Deg = 1;
if(!AssMemory(&Ip_Buff, Ip_Forge_Deg, &Port_Buff, Ip_Forge_Deg))
return 0;

Port_Buff[0] = PORTT;
Ip_Buff[0] = IPTL;
break;
case 3://指定ip递增型
if(!GetIpAndPortByLine(Forge_Ip))
return 0;

//申请缓冲区,这里只有N个,从初始IP开始递增
//具体的数量根据伪造个数那里设置到
if(!AssMemory(&Ip_Buff, Ip_Forge_Deg, &Port_Buff, Ip_Forge_Deg))
return 0;
//全部赋值
//这里赋值也全部都是主机字节,到后面统一转换
ULONG i;
for(i = 0; i < Ip_Forge_Deg; i++){
Ip_Buff[i] = IPTL;
Port_Buff[i] = PORTT;
IPTL ++;
PORTT ++;
if(PORTT >= MAX_PORT)
PORTT = 1;
}//End of for
break;
case 4://指定文件型
//打开该ip文件
FILE *IpFp;
IpFp = NULL;
IpFp = fopen(Forge_Ip_File, "r");
if(IpFp == NULL){
fprintf(stderr, "打开文件/"%s/"出错,出错代码:%d/n", Forge_Ip_File, GetLastError());
return 0;
}
ULONG numread;
Ip_Forge_Deg = 0;
//获取文件中IP的个数
while(1){
memset(Send_Dest_Data, 0, MAX_BUFF_LEN);
numread = fread(Send_Dest_Data, sizeof(char), MAX_BUFF_LEN, IpFp);
if(numread <= 0)
break;
ULONG i;
for(i = 0; i < numread; i++)
if(Send_Dest_Data[i] == '/n')
Ip_Forge_Deg ++;
}//End of while
//出错关闭句柄,返回
//注意关闭句柄
if(Ip_Forge_Deg <= 0){
fprintf(stderr, "获取文件中IP个数出错./n");
fclose(IpFp);
return 0;
}
//根据个数申请变量
if(!AssMemory(&Ip_Buff, Ip_Forge_Deg, &Port_Buff, Ip_Forge_Deg)){
fclose(IpFp);
return 0;
}

//定位到文件开头
fseek(IpFp, 0, SEEK_SET);
char IPtemp[MAX_HOSTNAME_LAN];
//开始取每一个IP
for(i = 0; i < Ip_Forge_Deg; i++){
//清空缓冲区
memset(IPtemp, 0, MAX_HOSTNAME_LAN);
//获得IP,就是获取一行的信息
fgets(IPtemp, MAX_HOSTNAME_LAN, IpFp);
//fgets会取得末尾的/n,去掉最后的/n
IPtemp[strlen(IPtemp) - 1] = 0;
//分析IP,出错赋默认值
if(!GetIpAndPortByLine(IPtemp)){
//如果出错,就赋值默认的值
Ip_Buff[i] = DEF_FORGE_IP;
Port_Buff[i] = DEF_FORGE_PORT;
}else{//End of if
//赋值给每一个缓冲区
Ip_Buff[i] = IPTL;
Port_Buff[i] = PORTT;
}//End of else
}//End of for

//关闭文件句柄
fclose(IpFp);

break;
case 5://随机型
//申请缓冲区,这里有N个
if(!AssMemory(&Ip_Buff, Ip_Forge_Deg, &Port_Buff, Ip_Forge_Deg))
return 0;
//设置随机种子
srand((unsigned)time(NULL));
char IP[20];
//填充随机IP和端口
for(i = 0; i < Ip_Forge_Deg; i++){
memset(IP, 0, 20);
sprintf(IP, "%d.%d.%d.%d", ((rand() % 255) + 1),
(rand() % 256), (rand() % 256), (rand() % 256));
//转换后存入缓冲区
Ip_Buff[i] = inet_addr(IP);
Port_Buff[i] = ((rand() % MAX_PORT) + 1);
}//End of For
break;
default:
fprintf(stderr, "未知的伪造类型/n");
return 0;
}//End of switch
//定义一个宏
#define MAX_READ_FILE_BUFF 1024
//如果指定了一个信息的文件,则开始取信息
if(Send_Data_File == ""){
FILE *SdFp = NULL;
//打开文件
SdFp = fopen(Send_Data_File, "r");
if(SdFp == NULL){
fprintf(stderr, "打开文件/":%s/"出错,出错代码:%d/n", Send_Data_File, GetLastError());
return 0;
}
memset(Send_Dest_Data, 0, MAX_BUFF_LEN);
char tempbuff[MAX_READ_FILE_BUFF];
int tempread;
int ReadSendDataNum = 0;
while(1){
//读取文件,如果文件结束,则退出
//如果文件内容超过最大缓冲区,则退出
memset(tempbuff, 0, MAX_READ_FILE_BUFF);
tempread = fread(tempbuff, sizeof(char), MAX_READ_FILE_BUFF, SdFp);
if(tempread <= 0 || ReadSendDataNum == MAX_BUFF_LEN)
break;
if(ReadSendDataNum + tempread > MAX_BUFF_LEN)
tempread = MAX_BUFF_LEN - ReadSendDataNum;
memcpy(Send_Dest_Data + ReadSendDataNum, tempbuff, tempread);
ReadSendDataNum += tempread;
}//End of while
fclose(SdFp);
//如果尚未指定发送信息的大小,则采用实际读取的数据大小
if(Send_Data_Size == 0)
Send_Data_Size = ReadSendDataNum;
//需要对齐数据
if(Send_Data_Size % 32 != 0)
Send_Data_Size += (32 - (Send_Data_Size % 32));
}//End of if
return 1;
}

//
//赋初始化值函数
//
int SetInitializeValue(int argc, char *argv[]){
int temp;
//分析命令行,赋初值.
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '/' || argv[i][0] == '-' || argv[i][0] == '//') {
//开始分析每个参数
switch (argv[i][1]) {
case '?':
case 'H':
case 'h':
Usage();
break;

case 't'://tcp数据包
//send_data_type的值1为tcp,2为udp,3为icmp,4为igmp
Send_Data_Type = 1;
//预取参数长度
temp = strlen(&argv[i][3]);
//检查ip参数长度
if(temp <= 0 || temp > MAX_HOSTNAME_LAN) {
fprintf(stderr, "目的长度出错:%s/n", argv[i]);
return 0;
}
//接受ip参数
strcpy(Dest_Ip, &argv[i][3]);
break;
case 'u'://udp数据包
Send_Data_Type = 2;
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_HOSTNAME_LAN) {
fprintf(stderr, "目的长度出错:%s/n", argv[i]);
return 0;
}
strcpy(Dest_Ip, &argv[i][3]);
break;
case 'c'://icmp数据包
Send_Data_Type = 3;
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_HOSTNAME_LAN) {
fprintf(stderr, "目的长度出错:%s/n", argv[i]);
return 0;
}
strcpy(Dest_Ip, &argv[i][3]);
break;
case 'g'://igmp数据包
Send_Data_Type = 4;
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_HOSTNAME_LAN) {
fprintf(stderr, "目的长度出错:%s/n", argv[i]);
return 0;
}
strcpy(Dest_Ip, &argv[i][3]);
break;
case 'n'://发送次数
Send_Degree = atol(&argv[i][3]);
if(Send_Degree <= 0){
fprintf(stderr, "发送次数参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'x'://每个报文发送次数
Send_Sdeg = atol(&argv[i][3]);
if(Send_Sdeg <= 0){
fprintf(stderr, "每个报文发送次数参数出错:%s/n", argv[i]);
return 0;
}
break;

case 'm'://延迟时间
Delay_Time = atoi(&argv[i][3]);
if(Delay_Time <= 0 || Delay_Time >= MAX_PORT) {
fprintf(stderr, "延迟参数出错:%s/n", argv[i]);
return 0;
}
break;

case 'd'://发送的信息
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_BUFF_LEN) {
fprintf(stderr, "目的长度出错:%s/n", argv[i]);
return 0;
}
memset(Send_Dest_Data, 0, MAX_BUFF_LEN);
strcpy(Send_Dest_Data, &argv[i][3]);
//获得附加数据的大小
Send_Data_Size = temp;
break;
case 'F'://发送信息由文件指定
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_PATH) {
fprintf(stderr, "文件长度超出:%s/n", argv[i]);
return 0;
}
memset(Send_Data_File, 0, MAX_PATH);
strcpy(Send_Data_File, &argv[i][3]);
break;
case 'S'://发送信息最大长度
Send_Data_Size = atoi(&argv[i][3]);
if(Send_Data_Size <= 0 || Send_Data_Size >= MAX_BUFF_LEN) {
fprintf(stderr, "信息最大长度:%s/n", argv[i]);
return 0;
}
break;
//IP报文参数设置
case 'I':
switch(argv[i][2]) {
case 'S':
IP_TOSE = (UCHAR)atoi(&argv[i][4]);
if(IP_TOSE <= 0 || IP_TOSE >= MAX_CHAR) {
fprintf(stderr, "IP TOS参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'I':
IP_IDENT = atoi(&argv[i][4]);
if(IP_IDENT <= 0 || IP_IDENT >= MAX_SHORT) {
fprintf(stderr, "IP IDENT参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'F':
IP_FLAG = atoi(&argv[i][4]);
if(IP_FLAG <= 0 || IP_FLAG >= MAX_SHORT) {
fprintf(stderr, "IP FLAG参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'T':
IP_TTLE = (UCHAR)atoi(&argv[i][4]);
if(IP_TTLE <= 0 || IP_TTLE >= MAX_CHAR) {
fprintf(stderr, "IP TTL参数出错:%s/n", argv[i]);
return 0;
}
break;
}//End of switch
break;
case 'T':
switch(argv[i][2]) {
case 'W':
TCP_WINS = atoi(&argv[i][4]);
if(TCP_WINS <= 0 || TCP_WINS >= MAX_SHORT) {
fprintf(stderr, "TCP WINS参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'F':
TCP_FLAG = atoi(&argv[i][4]);
if(TCP_FLAG <= 0 || TCP_FLAG >= MAX_CHAR) {
fprintf(stderr, "TCP FLAG参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'S':
TCP_SEQ = atol(&argv[i][4]);
if(TCP_SEQ <= 0 || TCP_SEQ >= MAX_LONG) {
fprintf(stderr, "TCP SEQ参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'A':
TCP_ACK = atol(&argv[i][4]);
if(TCP_ACK <= 0 || TCP_ACK >= MAX_LONG) {
fprintf(stderr, "TCP ACK参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'U':
TCP_URP = atoi(&argv[i][4]);
if(TCP_URP <= 0 || TCP_URP >= MAX_SHORT) {
fprintf(stderr, "TCP URP参数出错:%s/n", argv[i]);
return 0;
}
break;
}//End of switch
break;

case 'C':
switch(argv[i][2]) {
case 'T':
ICMP_TYPE = atoi(&argv[i][4]);
if(ICMP_TYPE <= 0 || ICMP_TYPE >= MAX_SHORT) {
fprintf(stderr, "ICMP TYPE参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'C':
ICMP_CODE = atoi(&argv[i][4]);
if(ICMP_CODE <= 0 || ICMP_CODE >= MAX_SHORT) {
fprintf(stderr, "ICMP CODE参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'I':
ICMP_ID = atoi(&argv[i][4]);
if(ICMP_ID <= 0 || ICMP_ID >= MAX_SHORT) {
fprintf(stderr, "ICMP ID参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'S':
ICMP_SEQ = atoi(&argv[i][4]);
if(ICMP_SEQ <= 0 || ICMP_SEQ >= MAX_SHORT) {
fprintf(stderr, "ICMP SEQ参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'M':
ICMP_TIME = atol(&argv[i][4]);
if(ICMP_TIME <= 0 || ICMP_TIME >= MAX_LONG) {
fprintf(stderr, "ICMP TIM参数出错:%s/n", argv[i]);
return 0;
}
break;
}//End of switch
break;

case 'G':
switch(argv[i][2]) {
case 'C':
IGMP_CODE = atoi(&argv[i][4]);
if(IGMP_CODE <= 0 || IGMP_CODE >= MAX_SHORT) {
fprintf(stderr, "IGMP CODE参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'T':
IGMP_TYPE = atoi(&argv[i][4]);
if(IGMP_TYPE <= 0 || IGMP_TYPE >= MAX_SHORT) {
fprintf(stderr, "IGMP TYPEE参数出错:%s/n", argv[i]);
return 0;
}
break;
case 'A':
IGMP_ADDR = atol(&argv[i][4]);
if(IGMP_ADDR <= 0 || IGMP_ADDR >= MAX_LONG) {
fprintf(stderr, "ICMP ID参数出错:%s/n", argv[i]);
return 0;
}
break;
}//End of switch
break;

case 'l'://伪造个数设置
Ip_Forge_Deg = atoi(&argv[i][3]);
if(Ip_Forge_Deg <= 0) {
fprintf(stderr, "伪造个数出错:%s/n", argv[i]);
return 0;
}
break;

case 'f'://伪造模式
switch(argv[i][2]) {
case '1'://模式1,本机IP,需要指定一个端口数据
Forge_Type = 1;
Forge_Port = atoi(&argv[i][4]);
if(Forge_Port <= 0 || Forge_Port >= MAX_PORT) {
Forge_Port = DEF_PORT_DA;
}
break;
case '2'://模式2,固定IP设置,必须指定IP和端口
Forge_Type = 2;
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_HOSTNAME_LAN) {
fprintf(stderr, "伪造ip地址出错:%s/n", argv[i]);
return 0;
}
strcpy(Forge_Ip, &argv[i][4]);
break;
case '3'://模式3,指定IP开始递增
Forge_Type = 3;
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_HOSTNAME_LAN) {
fprintf(stderr, "伪造ip地址出错:%s/n", argv[i]);
return 0;
}
strcpy(Forge_Ip, &argv[i][4]);
break;
case '4'://模式4,ip由文件提供
Forge_Type = 4;
//预取参数长度
temp = strlen(&argv[i][3]);
if(temp <= 0 || temp > MAX_PATH) {
fprintf(stderr, "文件信息出错:%s/n", argv[i]);
return 0;
}
strcpy(Forge_Ip_File, &argv[i][4]);
break;
case '5'://模式5,随机产生IP
Forge_Type = 5;
break;
}//End of switch
break;
}//End of switch
}//End of if
}//End of for
if(Dest_Ip == ""){
fprintf(stderr, "必须包含一个目的地址./n");
return 0;
}
return 1;
}

//
//分析ip段
//
int GetIpAndPortByLine(char *IPL){
//变量
char IP[MAX_HOSTNAME_LAN] = "";
//获取IP
char *fgp = strrchr(IPL, ':');
//判断是否只包含IP
if(fgp != NULL){
//拷贝ip
strncpy(IP, IPL, (fgp - IPL));
//出错
if(IP == ""){
fprintf(stderr, "IP数据出错./n");
return 0;
}
//拷贝端口
fgp++;
PORTT = atoi(fgp);
//端口选择出错,设置默认端口
if(PORTT <= 0 || PORTT >= MAX_PORT){
PORTT = DEF_PORT_DA;
}
}else{
//只包含ip,设置默认端口
strcpy(IP, IPL);
PORTT = DEF_PORT_DA;
}
//如果有域名,则要转化为IP
if(IP[0] < '0' || IP[0] > '9'){
struct hostent *server_host = NULL;
server_host = gethostbyname(IP);

//出错
if(server_host == NULL){
fprintf(stderr, "无法转换IP,出错代码: %d/n", WSAGetLastError());
return 0;
}
//地址转化为主机地址,赋值,返回
IPTL = ntohl((ULONG)(*(struct in_addr*)server_host->h_addr).s_addr);
}else{
IPTL = ntohl(inet_addr(IP));
}
return 1;
}

//
//初始化连接函数
//
int SetInitializeSock(){
int TimeOut = MAX_TIMEOUT;
int flag = 1;

//初始化SOCK_RAW
WSADATA wsaData = {0};
if((ErrorCode = WSAStartup(MAKEWORD(2, 1), &wsaData)) != 0){
fprintf(stderr, "WSAStartup 函数失败,错误代码: %d/n", WSAGetLastError());
return 0;
}
SockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_RAW, NULL, 0, WSA_FLAG_OVERLAPPED);
if (SockRaw == INVALID_SOCKET){
fprintf(stderr, "WSASocket() 函数失败,错误代码: %d/n", WSAGetLastError());
return 0;
}

//设置IP_HDRINCL以自己填充IP首部
ErrorCode = setsockopt(SockRaw, IPPROTO_IP, IP_HDRINCL, (char *)&flag, sizeof(int));
if (ErrorCode == SOCKET_ERROR){
fprintf(stderr, "setsockopt(IP_HDRINCL) 函数失败,错误代码: %d/n", WSAGetLastError());
return 0;
}
//设置发送超时
ErrorCode = setsockopt(SockRaw, SOL_SOCKET, SO_SNDTIMEO, (char*)&TimeOut, sizeof(TimeOut));
if(ErrorCode == SOCKET_ERROR){
fprintf(stderr, "setsockopt(SO_SNDTIMEO) 函数失败,错误代码: %d/n", WSAGetLastError());
return 0;
}
return 1;
}

//
//效验和函数
//
USHORT checksum(USHORT *buffer, int size) {
unsigned long 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);
}

//
//分配内存函数1
//
int AssMemory(ULONG **a, ULONG sa, USHORT **b, ULONG sb){
*a = (ULONG *)malloc(sa * sizeof(ULONG));
*b = (USHORT *)malloc(sb * sizeof(USHORT));

if(*a == NULL || *b == NULL){
fprintf(stderr, "分配内存失败./n");
return 0;
}
memset(*a, 0, sa * sizeof(ULONG));
memset(*b, 0, sb * sizeof(USHORT));

return 1;
}
//
//分配内存函数2
//
int AssMemory(USHORT **a, ULONG sa, USHORT **b, ULONG sb){
*a = (USHORT *)malloc(sa * sizeof(USHORT));
*b = (USHORT *)malloc(sb * sizeof(USHORT));
if(*a == NULL || *b == NULL){
fprintf(stderr, "分配内存失败./n");
return 0;
}
memset(*a, 0, sa * sizeof(USHORT));
memset(*b, 0, sb * sizeof(USHORT));

return 1;
}
//
//打印帮助
//
void Usage(){
//软件版权信息,帮助信息
fprintf(stderr, "================================================================/n"
"数据包发送程序1.0 (lecher后门附带软件)/n"
"日期: [2004.4.25]/n"
"作者: [Zvrop][zvrop@163.com]/n"
"环境: [WINXP + Visual C++ 6.0]/n"
"主页: [http://www.gedao.com][http://www.ringz.org]/n"
"================================================================/n"
"使用方法:/n"
"NetSendData.exe/n"
"/t-t:[chr]/-u:[chr]/-c:[chr]/-g:[chr]/n"
"/t-n:[num]/n"
"/t-x:[num]/n"
"/t-m:[num]/n"
"/t-d:[chr]/-F:[chr]/n"
"/t-S:[num]/n"
"/t-IS:[num]|-II:[num]|-IF:[num]|-IT:[num]/n"
"/t-TW:[num]|-TF:[num]|-TS:[num]|-TA:[num]|-TU:[num]/n"
"/t-CT:[num]|-CC:[num]|-CI:[num]|-CS:[num]|-CM:[num]/n"
"/t-GC:[num]|-GT:[num]|-GA:[num]/n"
"/t-l:[num]/n"
"/t-f1:[num]/-f2:[chr]/-f3:[chr]/-f4:[chr]/-f5/n"
"/t-?/-h/-H/n"
"================================================================/n"
"以上/"chr/"标识表示该参数为字符串型,/"num/"标识表示该参数为纯数值型/n"
"/"|/"标识符标识该组参数可以同时设置多个,/"//"标识符表示该组参数同时只能设置一个,若设置了多个,则以最后出现的参数为准./n"
"================================================================/n"
"基本参数:/n"
"-t:[chr] 发送tcp报文,后跟着一个目的位置地址(IP:<PORT>,端口默认为:%u)/n"
"-u:[chr] 发送udp报文,后跟着一个目的位置地址(IP:<PORT>)/n"
"-c:[chr] 发送icmp报文,后跟着一个目的位置地址(IP:<PORT>)/n"
"-g:[chr] 发送igmp报文,后跟着一个目的位置地址(IP:<PORT>)/n"
"-n:[num] 发送数据报文组的组数,一组报文中可包含任意数量的报文,默认值:%u,最大值:%u/n"
"-x:[num] 每组发送的报文数量,默认值:%u,最大值:%u/n"
"-m:[num] 每发送一组报文的延迟时间,在发送一组信息时候,不输出出错信息,默认值:%u/n"
"-?/-h/-H 打印帮助信息/n"
"/n附加信息参数:/n"
"-d:[chr] 发送报文的附加数据,最大长度:%u字节/n"
"-F:[chr] 发送报文的附加数值由文件指定,必须给出完整文件名./n"
"-S:[num] 发送报文附加数据的最大长度,当该值大于你提供的信息长度时,数据不足处补/"0/",当该值不等于32的整数倍时,将被自动扩充.默认值:0,表示不要 对报文添加任何附加数据,通常情况下,-d和-F参数会自动改版该值,但是如果你设置了该值,则-d和-F参数就不会更改该值./n"
"/n报文字段参数(建议不要使用,除非您完全了解每个字段的含义,挂号内为该字段占的空间字节数,在没有特殊说明的情况下,该值在发送之前将会被转换字节位置(主机->网络)):/n"
"-IS:[num] IP报文(1):服务类型(TOS)位参数字段设置,默认:%u/n"
"-II:[num] IP报文(2):标识位参数字段设置,默认值:%u/n"
"-IF:[num] IP报文(2):标志位参数设置,默认值:%u/n"
"-IT:[num] IP报文(1):TTL位参数设置,默认值:%u/n"
"-TW:[num] TCP报文(2):窗口大小位参数设置,默认值:%u/n"
"-TF:[num] TCP报文(1):标志位参数设置,默认值:%u/n"
"-TS:[num] TCP报文(4):序列号位参数设置,默认值:%u/n"
"-TA:[num] TCP报文(4):确认号位参数设置,默认值:%u/n"
"-TU:[num] TCP报文(2):紧急数据偏移位参数设置,默认值:%u/n"
"-CT:[num] ICMP报文(2):类型位参数设置,默认值:%u/n"
"-CC:[num] ICMP报文(2):代码位参数设置,默认值:%u/n"
"-CI:[num] ICMP报文(2):识别号位参数设置,默认值:%u/n"
"-CS:[num] ICMP报文(2):序号位参数设置,默认值:%u/n"
"-CM:[num] ICMP报文(4):时间戳位参数设置,默认值:%u/n"
"-GC:[num] IGMP报文(2):版本位参数设置,默认值:%u/n"
"-GT:[num] IGMP报文(2):类型位参数设置,默认值:%u/n"
"-GA:[num] IGMP报文(4):组地址位参数设置,默认值:%u/n"
"/n伪造源参数设置:/n"
"-l:[num] 伪造源个数设置,默认值:%u,该值可以和发送次数参数没有关系,系统会自动循环发送.但是设置少了,后面的参数将不会被发送,理论上可以设置到%u个,但这取决于你内存的大小./n"
"-f1:[num] 伪造模式1,本机IP,需要提供一个端口参数,默认为:%u,所有的伪造IP均采用这个参数提供,也就是说,提供了这个参数,设置伪造源个数参数就已经无效,白白占用内存而已./n"
"-f2:[chr] 伪造模式2,固定IP,需要提供一个源位置参数(IP:<PORT>),[表示含义同本机IP设置]/n"
"-f3:[chr] 伪造模式3,固定IP递增,需要提供一个起始伪造位置参数(IP:<PORT>),对这个提供的参数进行递增操作,比如你想制造一个c段的伪 造源,就设置这个参数为192.168.1.1:12345,然后伪造源个数设置为255个既可,注意,递增IP的同时,端口也在递增./n"
"-f4:[chr] 伪造模式4,从文件获取源位置参数,须提供一个本地文件名,文件中每个地址占一行,默认端口为%u,支持域名格式(运行期间也会转换为IP),采用IP: <PORT>格式,例如:192.168.1.2:12345,www.web.com:54321./n"
"-f5 伪造模式5,随机产生IP,端口/n"
"================================================================/n"
"[警告:本软件有一定危险性,请您在完全了解的情况下使用]/n"
"[作者不对软件造成的任何问题负任何形式的责任]/n"
"该软件作为Lecher后门附带的一个发送数据包的程序,事实上同样的例子网上已经有很多,也很早就有了,我这次写全了几个常用的数据格式,用预先计算 效验和的办法,提高发送报文速度,几乎提供了所有可变参数的修改,希望大家用的时候能方便一点,如果觉得比较麻烦,哪位仁兄可以写一个shell来调用, 也是很方便的啦,俺不擅长写GUI的程序了,^_^~/n"
,
DEF_PORT_DA,
Send_Degree,MAX_LONG,
Send_Sdeg,MAX_LONG,
Delay_Time,
MAX_BUFF_LEN,
IP_TOSE,
IP_IDENT,
IP_FLAG,
IP_TTLE,
TCP_WINS,
TCP_FLAG,
TCP_SEQ,
TCP_ACK,
TCP_URP,
ICMP_TYPE,
ICMP_CODE,
ICMP_ID,
ICMP_SEQ,
ICMP_TIME,
IGMP_CODE,
IGMP_TYPE,
IGMP_ADDR,
Ip_Forge_Deg,MAX_LONG,
DEF_PORT_DA
);
}