Linux 编制程序之 Ping 的落到实处

我们想知道我这台主机能不能和另一台进行通信,向网络上的另一个主机系统发送ICMP报文,就是对目的主机发送洪水般的ping包,使得目的主机忙于处理ping包而无能力处理其他正常请求,ping的过程是向目的IP发送一个type=8的ICMP响应请求报文,我)回复一个type=0的ICMP响应应答报文

图片 13

PING的得以完结看起来并不复杂,笔者想本人写代码达成这一个效用,供给些什么文化储备?笔者归纳罗列了弹指间:

我们使用了六十六个线程一起发包,当然这么些线程数还足以大大扩张,来充实攻击强度。但我们只是做做尝试,没要求搞那么大。

IP头部:

三、收包线程的搭建

大家近似创制一个抽取包的线程,这里我们接收select函数进行收包,并为select函数设置超时时间为200us,若爆发超时,则开展下二个周而复始。相像地,大家也急需一个全局变量来记录成功接到到的ping回复包的数量。

void ping_recv()
{
    struct timeval tv;
    tv.tv_usec = 200;  //设置select函数的超时时间为200us
    tv.tv_sec = 0;
    fd_set read_fd;
    char recv_buf[512];
    memset(recv_buf, 0 ,sizeof(recv_buf));
    while(alive)
    {
        int ret = 0;
        FD_ZERO(&read_fd);
        FD_SET(rawsock, &read_fd);
        ret = select(rawsock+1, &read_fd, NULL, NULL, &tv);
        switch(ret)
        {
            case -1:
                fprintf(stderr,"fail to select!\n");
                break;
            case 0:
                break;
            default:
                {
                    int size = recv(rawsock, recv_buf, sizeof(recv_buf), 0);
                    if(size < 0)
                    {
                        fprintf(stderr,"recv data fail!\n");
                        continue;
                    }

                    ret = icmp_unpack(recv_buf, size); //对接收的包进行解封
                    if(ret == -1)  //不是属于自己的icmp包,丢弃不处理
                    {
                        continue;
                    }
                    recv_count++; //接收包计数
                }
                break;
        }

    }
}

 

     

二、发包线程的搭建

基于PING程序的框架,大家需求树立八个线程用于ping包的发送,笔者的主张是那样的:使用sendto举行发包,发包速率大家保持在1秒1发,大家必要用贰个全局变量记录第五个ping包发生的小运,除此而外,咱们还亟需多个全局变量来记录我们发出的ping包到底有多少个,这四个变量用于后来吸收接纳ping包回复后的数额计算。

void ping_send()
{
    char send_buf[128];
    memset(send_buf, 0, sizeof(send_buf));
    gettimeofday(&start_time, NULL); //记录第一个ping包发出的时间
    while(alive)
    {
        int size = 0;
        gettimeofday(&(ping_packet[send_count].begin_time), NULL);
        ping_packet[send_count].flag = 1; //将该标记为设置为该包已发送

        icmp_pack((struct icmp*)send_buf, send_count, 64); //封装icmp包
        size = sendto(rawsock, send_buf, 64, 0, (struct sockaddr*)&dest, sizeof(dest));
        send_count++; //记录发出ping包的数量
        if(size < 0)
        {
            fprintf(stderr, "send icmp packet fail!\n");
            continue;
        }

        sleep(1);
    }
}

 

首要参照:

PING(Packet InterNet
Groper)中文名字为因特网包摸索器,是用来查看互连网上另二个主机系统的网络连接是或不是健康的二个工具。ping命令的劳作规律是:向网络上的另二个主机系统一发布送ICMP报文,假诺钦点系统拿到了报文,它将把苏醒报文字传递回给发送者,那有一些象潜水艇声纳系统中使用的发声装置。所以,大家想理解自个儿那台主机能否和另一台实行通讯,我们第生机勃勃须要断定的是大家两台主机间的网络是还是不是通的,也等于自身说的话能还是无法传到您那边,那是两岸开展通信的前提。在Linux下行使指令ping的法子和场景如下:

3.编写制定发包开关

 

图片 1

1.组ICMP包

中间也超过了好些个难点,头文件包蕴,WSAStartup函数伊始化战败。。。

豆蔻梢头、ICMP包的包裹和解封

(1) ICMP共同商议驾驭

要扩充PING的开销,大家先是须求理解PING的达成是依照ICMP左券来支付的。要开展ICMP包的包装和解封,大家率先要求驾驭ICMP左券。ICMP坐落于网络层,允许主机大概路由器报告差错情形和提供有关非凡景况的告知。ICMP报文是封装在IP数据报中,作为内部的多寡部分。ICMP报文作为IP层数据报的多寡,加上数量报头,组成IP数据报发送出去。ICMP报文格式如下:

图片 2

ICMP报文的品类有三种,即ICMP差错报告报文和ICMP询问报文。PING程序选用的ICMP报文子禽类为ICMP询问报文。注意一下上边谈起的ICMP报文格式中的“类型”字段,我们在组包的时候能够向该字段填写差异的值来标定该ICMP报文的花色。上边列出的是二种常用的ICMP报文类型。

图片 3

咱俩的PING程序必要使用的ICMP的类型是回送诉求(8)。

因为ICMP报文的切切实实格式会因为ICMP报文的花色而各不雷同,大家ping包的格式是这么的:

图片 4

(2) ICMP包的建设布局

相对而言上边的ping包格式,大家封装ping包的代码能够如此写:

void icmp_pack(struct icmp* icmphdr, int seq, int length)
{
    int i = 0;

    icmphdr->icmp_type = ICMP_ECHO;  //类型填回送请求
    icmphdr->icmp_code = 0;   
    icmphdr->icmp_cksum = 0; //注意,这里先填写0,很重要!
    icmphdr->icmp_seq = seq;  //这里的序列号我们填1,2,3,4....
    icmphdr->icmp_id = pid & 0xffff;  //我们使用pid作为icmp_id,icmp_id只是2字节,而pid有4字节
    for(i=0;i<length;i++)
    {
        icmphdr->icmp_data[i] = i;  //填充数据段,使ICMP报文大于64B
    }

    icmphdr->icmp_cksum = cal_chksum((unsigned short*)icmphdr, length); //校验和计算
}

那边每每升迁一下,icmp_cksum
必得先填写为0再施行校验和算法总括,不然ping时对方主机会因为校验和测算错误而抛开诉求包,引致ping的诉讼失败。作者叁个同事早已就因为这么贰个荒诞而各种考察许久,血的教训请牢牢记住。

此处大致介绍一下checksum(校验和)。

微处理机网络通讯时,为了检查在数量传输进程中数据是不是发生了不当,平日在传输数据的时候连同校验和一块传输,当选用端接纳多少时候会从新计算校验和,假如与原校验和莫衷一是就视为出错,屏弃该数据包,并重临icmp报文。

算法基本思路:

IP/ICMP/IGMP/TCP/UDP等协商的校验和算法一点差别也没有的,选择的都以将数据流视为15人整数流举行重复叠合总结。为了总计考验和,首先把检察和字段置为0。然后,对有效数据范围里边各类十几个人展开二进制反码求和,结果存在考验和字段中,若是数量长度为奇数则补一字节0。当接过数额后,相仿对有效数据范围中各样13人数进行二进制反码的求和。由于接收方在计算进程中隐含了发送方存在首部中的查验和,因而,借使首部在传输进度中绝非生出任何错误,那么选择方总计的结果应为全0或全1(具体看落到实处了,本质同样卡塔尔国。假若结果不是全0或全1,那么表示数据失实。

/*校验和算法*/
unsigned short cal_chksum(unsigned short *addr,int len)
{       int nleft=len;
        int sum=0;
        unsigned short *w=addr;
        unsigned short answer=0;

        /*把ICMP报头二进制数据以2字节为单位累加起来*/
        while(nleft>1)
        {       
            sum+=*w++;
            nleft-=2;
        }
        /*若ICMP报头为奇数个字节,会剩下最后一字节。把最后一个字节视为一个2字节数据的高字节,这个2字节数据的低字节为0,继续累加*/
        if( nleft==1)
        {       
            *(unsigned char *)(&answer)=*(unsigned char *)w;
            sum+=answer;
        }
        sum=(sum>>16)+(sum&0xffff);
        sum+=(sum>>16);
        answer=~sum;
        return answer;
}

(3) ICMP包的解包

了解怎么封装包,那解包就也遥遥相对了,注意的是,收到七个ICMP包,大家不要就以为这些包正是大家发出去的ICMP回送回答包,大家供给加大器晚成层代码来推断该ICMP报文的id和seq字段是还是不是符合大家发送的ICMP报文的设置,来验证ICMP回复包的没有错。

int icmp_unpack(char* buf, int len)
{
    int iphdr_len;
    struct timeval begin_time, recv_time, offset_time;
    int rtt;  //round trip time

    struct ip* ip_hdr = (struct ip *)buf;
    iphdr_len = ip_hdr->ip_hl*4;
    struct icmp* icmp = (struct icmp*)(buf+iphdr_len); //使指针跳过IP头指向ICMP头
    len-=iphdr_len;  //icmp包长度
    if(len < 8)   //判断长度是否为ICMP包长度
    {
        fprintf(stderr, "Invalid icmp packet.Its length is less than 8\n");
        return -1;
    }

    //判断该包是ICMP回送回答包且该包是我们发出去的
    if((icmp->icmp_type == ICMP_ECHOREPLY) && (icmp->icmp_id == (pid & 0xffff))) 
    {
        if((icmp->icmp_seq < 0) || (icmp->icmp_seq > PACKET_SEND_MAX_NUM))
        {
            fprintf(stderr, "icmp packet seq is out of range!\n");
            return -1;
        }

        ping_packet[icmp->icmp_seq].flag = 0;
        begin_time = ping_packet[icmp->icmp_seq].begin_time;  //去除该包的发出时间
        gettimeofday(&recv_time, NULL);

        offset_time = cal_time_offset(begin_time, recv_time);
        rtt = offset_time.tv_sec*1000 + offset_time.tv_usec/1000; //毫秒为单位

        printf("%d byte from %s: icmp_seq=%u ttl=%d rtt=%d ms\n",
            len, inet_ntoa(ip_hdr->ip_src), icmp->icmp_seq, ip_hdr->ip_ttl, rtt);        

    }
    else
    {
        fprintf(stderr, "Invalid ICMP packet! Its id is not matched!\n");
        return -1;
    }
    return 0;
}

 

2、0+0=0   0+1=1   1+1=0进1

四、中断管理

小编们规定了二遍ping发送的包的最大值为61个,若高于该数值就截至发送。作为PING的使用者,我们平时只会发送若干个包,若有那多少个包顺手重临,我们就crtl+c中断ping。这里的代码首若是为中失联号写一个刹车管理函数,将alive这几个全局变量设置为0,进而使出殡和埋葬ping包的轮回结束而终止程序。

void icmp_sigint(int signo)
{
    alive = 0;
    gettimeofday(&end_time, NULL);
    time_interval = cal_time_offset(start_time, end_time);
}

signal(SIGINT, icmp_sigint);

此番实验本着学习的目标,想使用协和手上的配备,想进一层精通互联网和协商的运用,所以攻击的大幅相当的小,时间也就几秒,不对别的设施形成影响。

ping.cpp

搭建这么一个ping程序的手续如下:

图片 5

ping.h

五、总体达成

各模块介绍完了,现在贴出完整代码。

#include <stdio.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <unistd.h>
#include <signal.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/time.h>
#include <string.h>
#include <netdb.h>
#include <pthread.h>

#define PACKET_SEND_MAX_NUM 64

typedef struct ping_packet_status
{
    struct timeval begin_time;
    struct timeval end_time;
    int flag;   //发送标志,1为已发送
    int seq;     //包的序列号
}ping_packet_status;

ping_packet_status ping_packet[PACKET_SEND_MAX_NUM];

int alive;
int rawsock;
int send_count;
int recv_count;
pid_t pid;
struct sockaddr_in dest;
struct timeval start_time;
struct timeval end_time;
struct timeval time_interval;

/*校验和算法*/
unsigned short cal_chksum(unsigned short *addr,int len)
{       int nleft=len;
        int sum=0;
        unsigned short *w=addr;
        unsigned short answer=0;

        /*把ICMP报头二进制数据以2字节为单位累加起来*/
        while(nleft>1)
        {       
            sum+=*w++;
            nleft-=2;
        }
        /*若ICMP报头为奇数个字节,会剩下最后一字节。把最后一个字节视为一个2字节数据的高字节,这个2字节数据的低字节为0,继续累加*/
        if( nleft==1)
        {       
            *(unsigned char *)(&answer)=*(unsigned char *)w;
            sum+=answer;
        }
        sum=(sum>>16)+(sum&0xffff);
        sum+=(sum>>16);
        answer=~sum;
        return answer;
}

struct timeval cal_time_offset(struct timeval begin, struct timeval end)
{
    struct timeval ans;
    ans.tv_sec = end.tv_sec - begin.tv_sec;
    ans.tv_usec = end.tv_usec - begin.tv_usec;
    if(ans.tv_usec < 0) //如果接收时间的usec小于发送时间的usec,则向sec域借位
    {
        ans.tv_sec--;
        ans.tv_usec+=1000000;
    }
    return ans;
}

void icmp_pack(struct icmp* icmphdr, int seq, int length)
{
    int i = 0;

    icmphdr->icmp_type = ICMP_ECHO;
    icmphdr->icmp_code = 0;
    icmphdr->icmp_cksum = 0;
    icmphdr->icmp_seq = seq;
    icmphdr->icmp_id = pid & 0xffff;
    for(i=0;i<length;i++)
    {
        icmphdr->icmp_data[i] = i;
    }

    icmphdr->icmp_cksum = cal_chksum((unsigned short*)icmphdr, length);
}

int icmp_unpack(char* buf, int len)
{
    int iphdr_len;
    struct timeval begin_time, recv_time, offset_time;
    int rtt;  //round trip time

    struct ip* ip_hdr = (struct ip *)buf;
    iphdr_len = ip_hdr->ip_hl*4;
    struct icmp* icmp = (struct icmp*)(buf+iphdr_len);
    len-=iphdr_len;  //icmp包长度
    if(len < 8)   //判断长度是否为ICMP包长度
    {
        fprintf(stderr, "Invalid icmp packet.Its length is less than 8\n");
        return -1;
    }

    //判断该包是ICMP回送回答包且该包是我们发出去的
    if((icmp->icmp_type == ICMP_ECHOREPLY) && (icmp->icmp_id == (pid & 0xffff))) 
    {
        if((icmp->icmp_seq < 0) || (icmp->icmp_seq > PACKET_SEND_MAX_NUM))
        {
            fprintf(stderr, "icmp packet seq is out of range!\n");
            return -1;
        }

        ping_packet[icmp->icmp_seq].flag = 0;
        begin_time = ping_packet[icmp->icmp_seq].begin_time;
        gettimeofday(&recv_time, NULL);

        offset_time = cal_time_offset(begin_time, recv_time);
        rtt = offset_time.tv_sec*1000 + offset_time.tv_usec/1000; //毫秒为单位

        printf("%d byte from %s: icmp_seq=%u ttl=%d rtt=%d ms\n",
            len, inet_ntoa(ip_hdr->ip_src), icmp->icmp_seq, ip_hdr->ip_ttl, rtt);        

    }
    else
    {
        fprintf(stderr, "Invalid ICMP packet! Its id is not matched!\n");
        return -1;
    }
    return 0;
}

void ping_send()
{
    char send_buf[128];
    memset(send_buf, 0, sizeof(send_buf));
    gettimeofday(&start_time, NULL); //记录第一个ping包发出的时间
    while(alive)
    {
        int size = 0;
        gettimeofday(&(ping_packet[send_count].begin_time), NULL);
        ping_packet[send_count].flag = 1; //将该标记为设置为该包已发送

        icmp_pack((struct icmp*)send_buf, send_count, 64); //封装icmp包
        size = sendto(rawsock, send_buf, 64, 0, (struct sockaddr*)&dest, sizeof(dest));
        send_count++; //记录发出ping包的数量
        if(size < 0)
        {
            fprintf(stderr, "send icmp packet fail!\n");
            continue;
        }

        sleep(1);
    }
}

void ping_recv()
{
    struct timeval tv;
    tv.tv_usec = 200;  //设置select函数的超时时间为200us
    tv.tv_sec = 0;
    fd_set read_fd;
    char recv_buf[512];
    memset(recv_buf, 0 ,sizeof(recv_buf));
    while(alive)
    {
        int ret = 0;
        FD_ZERO(&read_fd);
        FD_SET(rawsock, &read_fd);
        ret = select(rawsock+1, &read_fd, NULL, NULL, &tv);
        switch(ret)
        {
            case -1:
                fprintf(stderr,"fail to select!\n");
                break;
            case 0:
                break;
            default:
                {
                    int size = recv(rawsock, recv_buf, sizeof(recv_buf), 0);
                    if(size < 0)
                    {
                        fprintf(stderr,"recv data fail!\n");
                        continue;
                    }

                    ret = icmp_unpack(recv_buf, size); //对接收的包进行解封
                    if(ret == -1)  //不是属于自己的icmp包,丢弃不处理
                    {
                        continue;
                    }
                    recv_count++; //接收包计数
                }
                break;
        }

    }
}

void icmp_sigint(int signo)
{
    alive = 0;
    gettimeofday(&end_time, NULL);
    time_interval = cal_time_offset(start_time, end_time);
}

void ping_stats_show()
{
    long time = time_interval.tv_sec*1000+time_interval.tv_usec/1000;
    /*注意除数不能为零,这里send_count有可能为零,所以运行时提示错误*/
    printf("%d packets transmitted, %d recieved, %d%c packet loss, time %ldms\n",
        send_count, recv_count, (send_count-recv_count)*100/send_count, '%', time);
}

int main(int argc, char* argv[])
{
    int size = 128*1024;//128k
    struct protoent* protocol = NULL;
    char dest_addr_str[80];
    memset(dest_addr_str, 0, 80);
    unsigned int inaddr = 1;
    struct hostent* host = NULL;

    pthread_t send_id,recv_id;

    if(argc < 2)
    {
        printf("Invalid IP ADDRESS!\n");
        return -1;
    }

    protocol = getprotobyname("icmp"); //获取协议类型ICMP
    if(protocol == NULL)
    {
        printf("Fail to getprotobyname!\n");
        return -1;
    }

    memcpy(dest_addr_str, argv[1], strlen(argv[1])+1);

    rawsock = socket(AF_INET,SOCK_RAW,protocol->p_proto);
    if(rawsock < 0)
    {
        printf("Fail to create socket!\n");
        return -1;
    }

    pid = getpid();

    setsockopt(rawsock, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); //增大接收缓冲区至128K

    bzero(&dest,sizeof(dest));

    dest.sin_family = AF_INET;

    inaddr = inet_addr(argv[1]);
    if(inaddr == INADDR_NONE)   //判断用户输入的是否为IP地址还是域名
    {
        //输入的是域名地址
        host = gethostbyname(argv[1]);
        if(host == NULL)
        {
            printf("Fail to gethostbyname!\n");
            return -1;
        }

        memcpy((char*)&dest.sin_addr, host->h_addr, host->h_length);
    }
    else
    {
        memcpy((char*)&dest.sin_addr, &inaddr, sizeof(inaddr));//输入的是IP地址
    }
    inaddr = dest.sin_addr.s_addr;
    printf("PING %s, (%d.%d.%d.%d) 56(84) bytes of data.\n",dest_addr_str,
        (inaddr&0x000000ff), (inaddr&0x0000ff00)>>8, 
        (inaddr&0x00ff0000)>>16, (inaddr&0xff000000)>>24);

    alive = 1;  //控制ping的发送和接收

    signal(SIGINT, icmp_sigint);

    if(pthread_create(&send_id, NULL, (void*)ping_send, NULL))
    {
        printf("Fail to create ping send thread!\n");
        return -1;
    }

    if(pthread_create(&recv_id, NULL, (void*)ping_recv, NULL))
    {
        printf("Fail to create ping recv thread!\n");
        return -1;
    }

    pthread_join(send_id, NULL);//等待send ping线程结束后进程再结束
    pthread_join(recv_id, NULL);//等待recv ping线程结束后进程再结束

    ping_stats_show();

    close(rawsock);
    return 0;

}

编写翻译以至实验现象如下:

本人的尝试景况是两台服务器,发起ping的主机是172.0.5.183,被ping的主机是172.0.5.182,以下是本身的两遍试验现象(ping
IP和ping 域名)。

特别注意: 

独有root客商才干使用socket(卡塔尔国函数生成原始套接字,要让Linux的相仿客商能进行以上程序,需进行如下的特意操作:用root登录,编写翻译以上程序gcc
-lpthread -o ping ping.c

图片 6

实验现象能够见到,PING是马到功成的,注脚两主机间的网络是通的,发出的持有ping包都摄取了苏醒。

上边是Linux系统自带的PING程序,我们能够相比较一下大家规划的PING程序跟系统自带的PING程序有啥分歧。

图片 7

在直接山洪攻击的根基上,我们将发送方的IP地址伪装成其余IP,假使是伪装成贰个随意的IP,那就足以很好地潜伏本身的职责;假设将和谐的IP伪装成别的受害人的IP,就能够以致“离间离间”的图景,受害主机1的icmp回复包也如山洪般发送给受害主机2,倘诺主机1的指挥者要查是哪个混蛋发包攻击本身,他后生可畏查ICMP包的源地址,咦原本是主机2,那样子主机2就成了戴罪羔羊了。

IHL:首局长度。因为IP的头顶不是定长的,所以须要那个音信实行IP包的分析,进而找到Data字段的开始点。

  1. ICMP包的包装和平解决封
  2. 创制一个线程用于ICMP包的出殡和下葬
  3. 创设一个线程用于ICMP包的选用
  4. 原始套接字编制程序
  • DOS攻击原理
  • ICMP的深远精通
  • 原始套接字的编制程序工夫

Ping程序实现步骤

PING的流水生产线如下:

攻击计谋十分小巧,说来讲去,正是将源地址伪装成攻击主机的IP,然后发广播的给持有主机,主机们接到该echo
request后公共向攻击主机回包,形成群起攻击的景观。

    其它注意那个IHL是以4个字节为单位的,所以首部实际上尺寸是IHL*4字节。

图片 8

 

#include "ping.h"
#include <iostream>
USHORT CPing::s_usPacketSeq = 0;

CPing::CPing() :m_szICMPData(NULL),m_bIsInitSucc(FALSE)
{
    WSADATA WSAData;
    //WSAStartup(MAKEWORD(2, 2), &WSAData);
    if (WSAStartup(MAKEWORD(1, 1), &WSAData) != 0)
    {
        /*如果初始化不成功则报错,GetLastError()返回发生的错误信息*/
        printf("WSAStartup() failed: %d\n", GetLastError());
        return;
    }
    m_event = WSACreateEvent();
    m_usCurrentProcID = (USHORT)GetCurrentProcessId();
    //setsockopt(m_sockRaw);
    /*if ((m_sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0)) != SOCKET_ERROR)
    {
        WSAEventSelect(m_sockRaw, m_event, FD_READ);
        m_bIsInitSucc = TRUE;

        m_szICMPData = (char*)malloc(DEF_PACKET_SIZE + sizeof(ICMPHeader));

        if (m_szICMPData == NULL)
        {
            m_bIsInitSucc = FALSE;
        }
    }*/
    m_sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
    if (m_sockRaw == INVALID_SOCKET)
    {
        std::cerr << "WSASocket() failed:" << WSAGetLastError ()<< std::endl;  //10013 以一种访问权限不允许的方式做了一个访问套接字的尝试。
    }
    else
    {
        WSAEventSelect(m_sockRaw, m_event, FD_READ);
        m_bIsInitSucc = TRUE;

        m_szICMPData = (char*)malloc(DEF_PACKET_SIZE + sizeof(ICMPHeader));

        if (m_szICMPData == NULL)
        {
            m_bIsInitSucc = FALSE;
        }
    }
}

CPing::~CPing()
{
    WSACleanup();

    if (NULL != m_szICMPData)
    {
        free(m_szICMPData);
        m_szICMPData = NULL;
    }
}

BOOL CPing::Ping(DWORD dwDestIP, PingReply *pPingReply, DWORD dwTimeout)
{
    return PingCore(dwDestIP, pPingReply, dwTimeout);
}

BOOL CPing::Ping(char *szDestIP, PingReply *pPingReply, DWORD dwTimeout)
{
    if (NULL != szDestIP)
    {
        return PingCore(inet_addr(szDestIP), pPingReply, dwTimeout);
    }
    return FALSE;
}

BOOL CPing::PingCore(DWORD dwDestIP, PingReply *pPingReply, DWORD dwTimeout)
{
    //判断初始化是否成功
    if (!m_bIsInitSucc)
    {
        return FALSE;
    }

    //配置SOCKET
    sockaddr_in sockaddrDest;
    sockaddrDest.sin_family = AF_INET;
    sockaddrDest.sin_addr.s_addr = dwDestIP;
    int nSockaddrDestSize = sizeof(sockaddrDest);

    //构建ICMP包
    int nICMPDataSize = DEF_PACKET_SIZE + sizeof(ICMPHeader);
    ULONG ulSendTimestamp = GetTickCountCalibrate();
    USHORT usSeq = ++s_usPacketSeq;
    memset(m_szICMPData, 0, nICMPDataSize);
    ICMPHeader *pICMPHeader = (ICMPHeader*)m_szICMPData;
    pICMPHeader->m_byType = ECHO_REQUEST;
    pICMPHeader->m_byCode = 0;
    pICMPHeader->m_usID = m_usCurrentProcID;
    pICMPHeader->m_usSeq = usSeq;
    pICMPHeader->m_ulTimeStamp = ulSendTimestamp;
    pICMPHeader->m_usChecksum = CalCheckSum((USHORT*)m_szICMPData, nICMPDataSize);

    //发送ICMP报文
    if (sendto(m_sockRaw, m_szICMPData, nICMPDataSize, 0, (struct sockaddr*)&sockaddrDest, nSockaddrDestSize) == SOCKET_ERROR)
    {
        return FALSE;
    }

    //判断是否需要接收相应报文
    if (pPingReply == NULL)
    {
        return TRUE;
    }

    char recvbuf[256] = { "\0" };
    while (TRUE)
    {
        //接收响应报文
        if (WSAWaitForMultipleEvents(1, &m_event, FALSE, 100, FALSE) != WSA_WAIT_TIMEOUT)
        {
            WSANETWORKEVENTS netEvent;
            WSAEnumNetworkEvents(m_sockRaw, m_event, &netEvent);

            if (netEvent.lNetworkEvents & FD_READ)
            {
                ULONG nRecvTimestamp = GetTickCountCalibrate();
                int nPacketSize = recvfrom(m_sockRaw, recvbuf, 256, 0, (struct sockaddr*)&sockaddrDest, &nSockaddrDestSize);
                if (nPacketSize != SOCKET_ERROR)
                {
                    IPHeader *pIPHeader = (IPHeader*)recvbuf;
                    USHORT usIPHeaderLen = (USHORT)((pIPHeader->m_byVerHLen & 0x0f) * 4);
                    ICMPHeader *pICMPHeader = (ICMPHeader*)(recvbuf + usIPHeaderLen);

                    if (pICMPHeader->m_usID == m_usCurrentProcID //是当前进程发出的报文
                        && pICMPHeader->m_byType == ECHO_REPLY //是ICMP响应报文
                        && pICMPHeader->m_usSeq == usSeq //是本次请求报文的响应报文
                        )
                    {
                        pPingReply->m_usSeq = usSeq;
                        pPingReply->m_dwRoundTripTime = nRecvTimestamp - pICMPHeader->m_ulTimeStamp;
                        pPingReply->m_dwBytes = nPacketSize - usIPHeaderLen - sizeof(ICMPHeader);
                        pPingReply->m_dwTTL = pIPHeader->m_byTTL;
                        return TRUE;
                    }
                }
            }
        }
        //超时
        if (GetTickCountCalibrate() - ulSendTimestamp >= dwTimeout)
        {
            return FALSE;
        }
    }
}

USHORT CPing::CalCheckSum(USHORT *pBuffer, int nSize)
{
    unsigned long ulCheckSum = 0;
    while (nSize > 1)
    {
        ulCheckSum += *pBuffer++;
        nSize -= sizeof(USHORT);
    }
    if (nSize)
    {
        ulCheckSum += *(UCHAR*)pBuffer;
    }

    ulCheckSum = (ulCheckSum >> 16) + (ulCheckSum & 0xffff);
    ulCheckSum += (ulCheckSum >> 16);

    return (USHORT)(~ulCheckSum);
}

ULONG CPing::GetTickCountCalibrate()
{
    static ULONG s_ulFirstCallTick = 0;
    static LONGLONG s_ullFirstCallTickMS = 0;

    SYSTEMTIME systemtime;
    FILETIME filetime;
    GetLocalTime(&systemtime);
    SystemTimeToFileTime(&systemtime, &filetime);
    LARGE_INTEGER liCurrentTime;
    liCurrentTime.HighPart = filetime.dwHighDateTime;
    liCurrentTime.LowPart = filetime.dwLowDateTime;
    LONGLONG llCurrentTimeMS = liCurrentTime.QuadPart / 10000;

    if (s_ulFirstCallTick == 0)
    {
        s_ulFirstCallTick = GetTickCount();
    }
    if (s_ullFirstCallTickMS == 0)
    {
        s_ullFirstCallTickMS = llCurrentTimeMS;
    }

    return s_ulFirstCallTick + (ULONG)(llCurrentTimeMS - s_ullFirstCallTickMS);
}
  • ICMP合同的驾驭
  • RAW套接字
  • 互连网封包和平解决包手艺

(3)反射攻击

   
 前日吸取急供给落到实处ping的法力,然后英特网查了后生可畏部分质地,对网络编制程序的一些函数熟稔了风流倜傥晃,即使还大概有部分细节不知道,可是稳步储存。

 

Checksum:核查和,那一个是全数ICMP报文的侦查和,富含Type、Code、…、Data。

 

 

 

图片 9

 

3、把收获的结果存入核准和字段中

 

 

 

图片 10

先是付诸攻击的模型图:

Data:那有的是IP包的数据,也便是ICMP的报文内容。

图片 11

结果:

 

1、将源数据转成反码

2.搭建发包线程

Type:类型,type=8表示响应央求报文,type=0表示响应应答报文。

大水攻击(FLOOD ATTACK)指的是利用Computer互连网技术向目标主机发送大批量无效数据报文,使得指标主机忙于管理无用的数据报文而一点办法也想不出来提供健康劳动的互联网行为。

  1. 创办项目为SOCK_RAW的三个套接字,同不经常间设定左券IPPROTO_ICMP。
  2. 制造并开首化ICMP头。
  3. 调用sendto或WSASendto,将ICMP央求发给远程主机。
  4. 调用recvfrom或WSARecvfrom,以吸收接纳任何ICMP响应。

图片 12

图片 13