一份发送数据包的VC源代码

软件提供了常用的4种报文的自定义发送(包括所有能修改的字段),并提供5种伪造源格式,用预先计算效验和的办法,提高发送报文速度等...其他的,就用代码说明吧

// 数据包发送程序1.0 //

//////////////////////////////////////////////////////////////

//若干的头文件


//////////////////////////////////////////////////////////////

#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;&nbs, p;

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][[email][e-mail][/email]]/n"

"环境: [WINXP + Visual C++ 6.0]/n"


"主页: [[url]http://www.gedao.com[/url]][[url]http://www.ringz.org[/url]]/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,[url]www.web.com:54321.[/url]/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

);

}

http://www.315safe.com/tech/program/16279.shtml