Fork me on GitHub

seedlab实验Sniffing_Spoofing

字数统计: 3.7k字   |   阅读时长≈ 18分

seedlab实验Sniffing_Spoofing

一、实验目标

对数据包进行嗅探与伪造（本次实验代码在底部）

二、实验原理

Sniffing就是一种能将本地网卡状态设成‘混杂’状态的模式，当网卡处于这种“混杂”方式时，该网卡具备“广播地址”，它对遇到的每一个帧都产生一个硬件中断以便提醒操作系统处理流经该物理媒体上的每一个报文包。（绝大多数的网卡具备置成混杂模式的能力）
一般来说，sniffing和poofing会联合起来使用。当攻击者嗅探到关键信息时，通常会使用poofing技术来构造数据包来劫持会话或者去获取更多信息，通常会造成很大的危害。Poofing技术就是攻击者自己构造数据包的ip/tcp数据包帧头部数据来达到自己的目的。
本次实验就是基于以上原理，在linux下模拟整个过程。

三、实验步骤及运行结果

Task1．编写嗅探程序

1、深入理解并可以编写嗅探程序
Problem1：用自己的话描述库调用的顺序。
首先需要确定监听的端口，之后初始化pcap，告诉pcap我们要嗅探的设备。然后可以设置过滤条件，比如只收icmp包，再之后进入执行循环，每当它收到一个包之后，就可以进入我们设置的函数中进行处理。最后结束退出。
Problem2：为何需要root权限执行，没有root的话，哪里造成的出错。
因为讲网卡设为混杂模式需要root权限。没有root的话，pcap_open_live()函数的返回值是NULL，也就是没有获得设备的权限。
Problem3:打开和关闭混杂模式，演示二者的区别。
在一台主机上构造一个包，from 1.2.3.4 to 5.6.7.8,
在另外一台主机上运行嗅探程序，对于打开混杂模式的程序，可以捕获到，因为所有的包都会传入内核。而对于关闭混杂模式的程序，不会捕获。

对于第一个编写嗅探程序，可以通过程序写一个服务端和一个请求端，然后进行嗅探。
运行结果如下：

同时运行服务器和嗅探程序，当请求端向服务器发送请求后，程序显示got a packet。

2.1只抓取icmp包
把程序设成可以抓取所有的包，然后使用嗅探程序去嗅探。
当运行server/client的时候，运行嗅探程序：

说明无法获得udp包
然后，两台机器ping一下，再运行嗅探程序：

发现能抓到icmp包。

2.2捕获TCP数据包有一个目的端口范围从端口10 – 100
只需把过滤条件在2.1的基础上从’icmp’改为’ tcp and dst portrange 10-100’即可。

运行程序，打开seedlab网站，发现可以抓取80端口下的tcp包，而运行9090的server/client则没有包可以捕获不行。

Task2、包欺骗

在正常的情况下，当一个用户发送一个数据包时，操作系统通常不允许用户设
4
置所有的在协议头字段（如TCP，UDP，和IP报头）。操作系统将大部分的领域，而
只允许用户设置几个字段，如目标IP地址、目标端口号等。但是当用户有有root权限，他们可以在数据包标头设置为任意字段。这就是所谓的包欺骗，它可以通过原始套接字完成。
原始套接字给程序员的数据包结构的绝对控制，允许程序员构建任何任意的数据包，包括设置头字段和有效载荷。使用原始套接字是相当简单的，它包括四个步骤：（1）创建一个原始套接字，（2）设置套接字选项，（3）构建数据包，和（4）通过原始套接字发送数据包。有许多在线教程，可以教你如何使用原始套接字在C编程。我们已经把一些教程与实验室的网页联系起来了。请阅读它们，并学习如何写一个spoonfing程序包。我们展示了一个简单的的程序。

Problem4:能否随意设置ip报文的大小
很明显不能。
Problem5:使用raw socket编程时，是否一定要计算检验和。
需要。
Problem6: 为什么需要root权限才能运行使用原始套接字的程序？在哪里？如果没有根权限执行程序，程序会失败吗？
因为在发送数据包时需要使用网卡设备，如果没有root，程序没有权限使用设备

2.a:发送IP

运行完程序之后是这个结果，说明成功。

伪造udp
对于该任务，在一台主机上连接一个ip地址和端口，向该端口发送一个udp数据包，在另一台主机上提前运行伪造程序，结果如下：

发现该主机向2.9.5.6的9999端口发送包后，收到了伪造的包，并且在攻击主机上有来往记录。

Task3:综合使用

在这个任务中，你将嗅探和欺骗技术实现连接，并实现程序。你需要在同一局域网两虚拟机。从VMA ping 另一个VM的IP，这将产生一个ICMP回送请求报文。如果X是活着的，ping程序将收到一个回音答复，并打印出响应。你嗅探到数据包然后伪造程序运行在虚拟机B、监控网络数据包嗅探。每当它看到ICMP回送请求，不管目标IP地址是什么，你的程序应该立即发出回声应答数据包欺骗技术的使用。因此，考虑到机器X是否是活的，这个程序将总是收到一个回复，这表明X是活的。你要写这样一个程序，包括在你显示你的程序的工作报告screendumps。请在你的报告中附上代码。

本次实验从10.0.2.4ping到10.0.2.3，在10.0.2.1的主机上进行嗅探操作：
运行结果如下：

发现程序进行了对回复的包的伪造，并且收到目的主机的响应，证明它是活的。

四、代码

Task1、

1、server:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/ip.h>
void main()
{
    struct sockaddr_in server;
    struct sockaddr_in client;
    int clientlen;
    char buf[1500];
    int sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
    memset((char *)&server,0,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_addr.s_addr=htonl(INADDR_ANY);
    server.sin_port=htons(9090);
    if(bind(sock,(struct sockaddr *)&server,sizeof(server))<0)
    perror("ERROR on binding");
    while(1)
    {
    bzero(buf,1500);
    recvfrom(sock,buf,1500-1,0,(struct sockaddr *)&client,&clientlen);
    printf("get one\n");
    }
    close(sock);
}

2、client:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/ip.h>
#include<arpa/inet.h>
void main()
{
    struct sockaddr_in dest_info;
    char *data="UDP message\n";
    int sock=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
    memset((char *)&dest_info,0,sizeof(dest_info));
    dest_info.sin_family=AF_INET;
    dest_info.sin_addr.s_addr=inet_addr("10.0.2.1");
    dest_info.sin_port=htons(9090);
    sendto(sock,data,strlen(data),0,(struct sockaddr *)&dest_info,sizeof(dest_info));
    close(sock);
}

嗅探程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<pcap.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
struct ethheader{
    u_char ether_dhost[6];
    u_char ether_shost[6];
    u_short ether_type;
};
void got_packet(u_char *args,const struct pcap_pkthdr *header,const u_char *packet)
{
    printf("got a packet!\n");
}
int main()
{
    pcap_t *handle;
    char errbuf[PCAP_ERRBUF_SIZE];
    struct bpf_program fp;
    char filter_exp[]="ip proto icmp";
    bpf_u_int32 net;
    handle=pcap_open_live("ens33",BUFSIZ,1,1000,errbuf);
    pcap_compile(handle,&fp,filter_exp,0,net);
    pcap_setfilter(handle,&fp);
    pcap_loop(handle,-1,got_packet,NULL);
    pcap_close(handle);
    return 0;
}

2.1、Icmp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include<pcap.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
struct ethheader{
    u_char ether_dhost[6];
    u_char ether_shost[6];
    u_short ether_type;
};
struct ipheader{
    unsigned char iph_ihl:4,iph_ver:4;
    unsigned char iph_tos;
    unsigned short int iph_len;
    unsigned short int iph_ident;
    unsigned short int iph_flag:3,ip_offset:13;
    unsigned char iph_ttl;
    unsigned char iph_protocol;
    unsigned short int iph_chksum;
    struct in_addr iph_sourceip;
    struct in_addr iph_destip;
};
void got_packet(u_char *args,const struct pcap_pkthdr *header,const u_char *packet)
{
    struct ethheader *eth =(struct ethheader *)packet;
    if(ntohs(eth->ether_type)==0x0800)
    {
    struct ipheader *ip =(struct ipheader *)(packet + sizeof(struct ethheader));
    printf(" From:%s\n",inet_ntoa(ip->iph_sourceip));
    printf(" To:%s\n",inet_ntoa(ip->iph_destip));
    switch(ip->iph_protocol)
    {
    case IPPROTO_TCP:
    printf(" Protocol:TCP\n");
    break;
    case IPPROTO_UDP:
    printf(" Protocol:UDP\n");
    break;
    case IPPROTO_ICMP:
    printf(" Protocol:ICMP\n");
    break;
    default:
    printf(" Protocol:others\n");
    break;
}
}
}
int main()
{
    pcap_t *handle;
    char errbuf[PCAP_ERRBUF_SIZE];
    struct bpf_program fp;
    char filter_exp[]="icmp";
    
    bpf_u_int32 net;
    handle=pcap_open_live("ens33",BUFSIZ,1,1000,errbuf);
    pcap_compile(handle,&fp,filter_exp,0,net);
    pcap_setfilter(handle,&fp);
    pcap_loop(handle,-1,got_packet,NULL);
    pcap_close(handle);
    return 0;
}

2.2、tcp10-100：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#include <pcap.h>
#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <ctype.h> 
#include <errno.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 

/*ETH HEADER*/
struct ethheader
{
	u_char ether_dhost[6];
	u_char ether_shost[6];
	u_short ether_type;
};

/*IP HEADER*/
struct ipheader
{
	unsigned char iph_ihl:4,iph_ver:4;
	unsigned char iph_tos;
	unsigned short int iph_len;
	unsigned short int iph_ident;
	unsigned short int iph_flag:3,iph_offset:13;
	unsigned char iph_ttl;
	unsigned char iph_protocol;
	unsigned short int iph_checksum;
	struct in_addr iph_sourceip;
	struct in_addr iph_destip;
};

/*TCP HEADER*/
struct tcpheader
{
	u_int16_t tcp_sport;
	u_int16_t tcp_dport;
	u_int32_t tcp_seq;
	u_int32_t tcp_ack;
	u_char tcp_offset;
	#define TCP_OFF(tcp)	(((tcp)->tcp_offset & 0xf0)>>4)
	u_char tcp_flags;


	#define TCP_FIN 0x01
	#define TCP_SYN 0x02
	#define TCP_RST 0x04
	#define TCP_PUSH 0x08
	#define TCP_ACK 0x10
	#define TCP_URG 0x20
	#define TCP_FLAGS (TCP_FIN|TCP_SYN|TCP_RST|TCP_PUSH|TCP_ACK|TCP_URG)
	u_int16_t tcp_win;
	u_int16_t tcp_sum;
	u_int16_t tcp_urp;
};

void print_hex_ascii_line(const u_char *payload,int len,int offset)
{
	int i,gap;
	const u_char *ch;
	printf("%05d	",offset);
	ch=payload;
	for(i=0;i<len;i++)
	{
		printf("%02x",*ch);
		ch++;
		if(i==7)printf(" ");
	}
	if(len<8)printf(" ");
	if(len<16)
	{
		gap=16-len;
		for(i=0;i<gap;i++)printf("	");
	}
	printf("	");
	ch=payload;
	for(i=0;i<len;i++)
	{
		if(isprint(*ch))printf("%c",*ch);
		else printf(".");
		ch++;
	}
	printf("\n");
	return;
}

void print_payload(const u_char *payload,int len)
{
	int len_rem=len;
	int line_width=16;
	int line_len;
	int offset=0;
	const u_char *ch=payload;

	if(len<=0)return;
	if(len<=line_width){print_hex_ascii_line(ch,len,offset);return;}
	for(;;)
	{
		line_len=line_width % len_rem;
		print_hex_ascii_line(ch,line_len,offset);
		len_rem=len_rem-line_len;
		ch=ch+line_len;
		offset=offset+line_width;
		if(len_rem<=line_width)
		{
			print_hex_ascii_line(ch,len_rem,offset);
			break;
		}
	}
	return;
}

void got_packet(u_char *args,const struct pcap_pkthdr *header,const u_char *packet)
{
	struct ethheader *eth=(struct ethheader *)packet;
	const char *payload;
	int size_payload;

	if(ntohs(eth->ether_type)==0x0800)
	{
		struct ipheader *ip=(struct ipheader *)(packet+sizeof(struct ethheader));
		printf("\nFrom: %s\n",inet_ntoa(ip->iph_sourceip));
		printf("To: %s\n",inet_ntoa(ip->iph_destip));


		/*determine protocol*/
		switch(ip->iph_protocol)
		{
			case IPPROTO_TCP:
				printf("Protocol:TCP\n");
				int ip_header_len=ip->iph_ihl * 4;
				struct tcpheader *tcp=(struct tcpheader *)(packet+sizeof(struct ethheader)+ip_header_len);
				printf("Source port: %u\n",ntohs(tcp->tcp_sport));
				printf("Dest port: %u\n",ntohs(tcp->tcp_dport));
				return;
			case IPPROTO_UDP:
				printf("Protocol:UDP\n");
				return;
			case IPPROTO_ICMP:
				printf("Protocol:ICMP\n");
				return;
			default:
				printf("Protocol:others\n");
				return;
		}

 	}
}


int main()
{
	pcap_t *handle;
	char errbuf[PCAP_ERRBUF_SIZE];
	struct bpf_program fp;
	char filter_exp[]="tcp and dst portrange 10-100";
	bpf_u_int32 net;

	handle=pcap_open_live("ens33",BUFSIZ,1,1000,errbuf);

	if(handle==NULL){printf("ERROR!\n");}
	
	pcap_compile(handle,&fp,filter_exp,0,net);
	pcap_setfilter(handle,&fp);

	pcap_loop(handle,-1,got_packet,NULL);

	pcap_close(handle);
	return 0;
}

Task2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include<pcap.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
struct ethheader{
    u_char ether_dhost[6];
    u_char ether_shost[6];
    u_short ether_type;
};
struct udpheader{
    u_int16_t udp_sport;
    u_int16_t udp_dport;
    u_int16_t udp_ulen;
    u_int16_t udp_sum;
};
struct ipheader{
    unsigned char iph_ihl:4,iph_ver:4;
    unsigned char iph_tos;
    unsigned short int iph_len;
    unsigned short int iph_ident;
    unsigned short int iph_flag:3,ip_offset:13;
    unsigned char iph_ttl;
    unsigned char iph_protocol;
    unsigned short int iph_chksum;
    struct in_addr iph_sourceip;
    struct in_addr iph_destip;
};
void send_raw_ip_packet(struct ipheader* ip)
{
    struct sockaddr_in dest_info;
    int enable=1;

    int sock=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);
    setsockopt(sock,IPPROTO_IP,IP_HDRINCL,&enable,sizeof(enable));
    dest_info.sin_family=AF_INET;
    dest_info.sin_addr=ip->iph_destip;
    sendto(sock,ip,ntohs(ip->iph_len),0,(struct sockaddr*)&dest_info,sizeof(dest_info));
    close(sock);
}
void spoof_reply(struct ipheader* ip)
{
    const char buffer[1500];
    int ip_header_len=ip->iph_ihl*4;
    struct udpheader* udp =(struct udpheader*) ((u_char *)ip+ip_header_len);
    if (ntohs(udp->udp_dport)!=9999)
    {
    return;
    }
    memset((char *)buffer,0,1500);
    memcpy((char *)buffer,ip,ntohs(ip->iph_len));
    struct ipheader *newip =(struct ipheader *)buffer;
    struct udpheader *newudp =(struct udpheader *)(buffer + ip_header_len);
    char *data =(char *)newudp + sizeof(struct udpheader);
    const char *msg="I an not real 1.2.3.4!\n";
    int data_len=strlen(msg);
    strncpy(data,msg,data_len);
    newudp->udp_sport=udp->udp_dport;
    newudp->udp_dport=udp->udp_sport;
    newudp->udp_ulen=htons(sizeof(struct udpheader)+data_len);
    newudp->udp_sum=0;
    newip->iph_sourceip=ip->iph_destip;
    1
    newip->iph_destip=ip->iph_sourceip;
    newip->iph_ttl=50;
    newip->iph_len=htons(sizeof(struct ipheader)+sizeof(struct udpheader)+data_len);
    send_raw_ip_packet(newip);
}
void got_packet(u_char *args,const struct pcap_pkthdr *header,const u_char *packet)
{
    struct ethheader *eth =(struct ethheader *)packet;
    if(ntohs(eth->ether_type)==0x0800)
    {
    struct ipheader *ip =(struct ipheader *)(packet + sizeof(struct ethheader));
    printf(" From:%s\n",inet_ntoa(ip->iph_sourceip));
    printf(" To:%s\n",inet_ntoa(ip->iph_destip));
    switch(ip->iph_protocol)
    {
    case IPPROTO_TCP:
    printf(" Protocol:TCP\n");
    break;
    case IPPROTO_UDP:
    printf(" Protocol:UDP\n");
    break;
    case IPPROTO_ICMP:
    printf(" Protocol:ICMP\n");
    break;
    default:
    printf(" Protocol:others\n");
    break;
    }
    spoof_reply(ip);
}
}
int main()
{
pcap_t *handle;
char errbuf[PCAP_ERRBUF_SIZE];
1
struct bpf_program fp;
char filter_exp[]="ip proto icmp";
bpf_u_int32 net;
handle=pcap_open_live("ens33",BUFSIZ,1,1000,errbuf);
pcap_compile(handle,&fp,filter_exp,0,net);
pcap_setfilter(handle,&fp);
pcap_loop(handle,-1,got_packet,NULL);
pcap_close(handle);
return 0;
}

Task3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include<pcap.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
struct ethheader{
    u_char ether_dhost[6];
    u_char ether_shost[6];
    u_short ether_type;
};
struct udpheader{
    u_int16_t udp_sport;
    u_int16_t udp_dport;
    u_int16_t udp_ulen;
    u_int16_t udp_sum;
};
struct icmpheader {
    unsigned char icmp_type; // ICMP message type
    unsigned char icmp_code; // Error code
    unsigned short int icmp_chksum; //Checksum for ICMP Header and data
    unsigned short int icmp_id; //Used for identifying request
    
    unsigned short int icmp_seq; //Sequence number
};
struct ipheader{
    unsigned char iph_ihl:4,iph_ver:4;
    unsigned char iph_tos;
    unsigned short int iph_len;
    unsigned short int iph_ident;
    unsigned short int iph_flag:3,ip_offset:13;
    unsigned char iph_ttl;
    unsigned char iph_protocol;
    unsigned short int iph_chksum;
    struct in_addr iph_sourceip;
    struct in_addr iph_destip;
};
unsigned short in_cksum(unsigned short *buf,int length)
{
    unsigned short *w=buf;
    int nleft=length;
    int sum=0;
    unsigned short temp=0;
    while(nleft>1)
    {
    sum+=*w++;
    nleft-=2;
    }
    if(nleft==1)
    {
    *(u_char *)(&temp)=*(u_char*)w;
    sum+=temp;
    }
    sum=(sum>>16)+(sum&0xffff);
    sum+=(sum>>16);
    return (unsigned short)(~sum);
}
void send_raw_ip_packet(struct ipheader* ip)
{
    struct sockaddr_in dest_info;
    int enable=1;
    int sock=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);
    setsockopt(sock,IPPROTO_IP,IP_HDRINCL,&enable,sizeof(enable));
    dest_info.sin_family=AF_INET;
    dest_info.sin_addr=ip->iph_destip;
    sendto(sock,ip,ntohs(ip->iph_len),0,(struct sockaddr*)&dest_info,sizeof(dest_info));
    close(sock);
}
void spoof_reply(struct ipheader* ip)
{
    char buffer[1500];
    memset(buffer, 0, 1500);
    struct icmpheader *icmp = (struct icmpheader *)
    (buffer + sizeof(struct ipheader));
    icmp->icmp_type = 0;
    icmp->icmp_chksum = 0;
    icmp->icmp_chksum = in_cksum((unsigned short *)icmp,
    sizeof(struct icmpheader));
    struct ipheader *lip = (struct ipheader *) buffer;
    lip->iph_ver = 4;
    lip->iph_ihl = 5;
    lip->iph_ttl = 20;
    lip->iph_sourceip.s_addr = inet_addr("10.0.2.3");
    lip->iph_destip.s_addr = inet_addr("10.0.2.4");
    lip->iph_protocol = IPPROTO_ICMP;
    lip->iph_len = htons(sizeof(struct ipheader) +
    sizeof(struct icmpheader));
    send_raw_ip_packet(lip);
}
void got_packet(u_char *args,const struct pcap_pkthdr *header,const u_char *packet)
{
    struct ethheader *eth =(struct ethheader *)packet;
    if(ntohs(eth->ether_type)==0x0800)
    {
    struct ipheader *ip =(struct ipheader *)(packet + sizeof(struct ethheader));
    printf(" From:%s\n",inet_ntoa(ip->iph_sourceip));
    printf(" To:%s\n",inet_ntoa(ip->iph_destip));
    switch(ip->iph_protocol)
    {
    case IPPROTO_TCP:
    printf(" Protocol:TCP\n");
    break;
    case IPPROTO_UDP:
    printf(" Protocol:UDP\n");
    break;
    case IPPROTO_ICMP:
    printf(" Protocol:ICMP\n");
    int ip_header_len=ip->iph_ihl*4;
    struct icmpheader *icmp1=(struct icmpheader*)(packet+sizeof(struct ethheader)+ip_header_len);
    if(ntohs(icmp1->icmp_type=8))
    {
    printf("I am not real packet\n");spoof_reply(ip);}
    else
    {
    printf("I am alive");
    }
    break;
    default:
    printf(" Protocol:others\n");
    break;
}
}
}
int main()
{
    pcap_t *handle;
    char errbuf[PCAP_ERRBUF_SIZE];
    struct bpf_program fp;
    char filter_exp[]="ip proto icmp";
    bpf_u_int32 net;
    handle=pcap_open_live("ens33",BUFSIZ,1,1000,errbuf);
    pcap_compile(handle,&fp,filter_exp,0,net);
    pcap_setfilter(handle,&fp);
    pcap_loop(handle,-1,got_packet,NULL);
    pcap_close(handle);
    return 0;
}
赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
CTF-pwn、安全、
密码、Linux

联系QQ:3028115458