2.学习怎么设置网卡工作模式为：混杂模式，最后开始设计软件：
===========以下为转载内容，解析不错，直接复制粘贴，呵呵~·====================
代码（转载）：
/************************Tcp_sniff_2.c********************/
1.#include
2.#include
3.#include
4.#include
5.#include
6.#include
7.#include
8.#include
9.#include "headers.h"
#define INTERFACE "eth0"
/*Prototype area*/
10.int Open_Raw_Socket(void)
11.int Set_Promisc(char *interface, int sock)
12.int main() {
13.int sock, bytes_recieved, fromlen腔升
14.char buffer[65535]
15.struct sockaddr_in from
16.struct ip *ip
17.struct tcp *tcp
18.sock = Open_Raw_Socket()
19. Set_Promisc(INTERFACE, sock)
20. while(1)
22. {
23. fromlen = sizeof from
24. bytes_recieved = recvfrom(sock, buffer, sizeof buffer, 0, (struct sockaddr *)&from, &fromlen)
25. printf("\nBytes received ::: %5d\n",bytes_recieved)
26. printf("Source address ::: %s\n",inet_ntoa(from.sin_addr))
27. ip = (struct ip *)buffer
/*See if this is a TCP packet*/
28. if(ip->ip_protocol == 6) {
29. printf("IP header length ::: %d\n",ip->ip_length)
30. printf("rotocol ::: %d\租基n",ip->ip_protocol)
31. tcp = (struct tcp *)(buffer + (4*ip->ip_length))
32. printf("Source port ::: %d\n",ntohs(tcp->tcp_source_port))
33. printf("Dest port ::: %d\n",ntohs(tcp->tcp_dest_port))
34. }
35. }
36.}
37.int Open_Raw_Socket() {
38. int sock
39. if((sock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) <0) {
/*Then the socket was not created properly and must die*/
40. perror("The raw socket was not created"
41. exit(0)
42. }
43. return(sock)
44. }
45.int Set_Promisc(char *interface, int sock ) {
46. struct ifreq ifr
47. strncpy(ifr.ifr_name, interface,strnlen(interface)+1)
48. if((ioctl(sock, SIOCGIFFLAGS, &ifr) == -1)) {
/*Could not retrieve flags for the interface*/
49. perror("Could not retrive flags for the interface"
50. exit(0)
51. }
52. printf("The interface is ::: %s\n", interface)
53. perror("Retrieved flags from interface successfully"
54. ifr.ifr_flags |= IFF_PROMISC
55. if (ioctl (sock, SIOCSIFFLAGS, &ifr) == -1 ) {
/*Could not set the flags on the interface */
56. perror("Could not set the PROMISC flag:"
57. exit(0)
58. }
59. printf("Setting interface ::: %s ::: to promisc", interface)
60. return(0)
61. }
/***********************EOF**********************************/
上面这段程序中有很详细的注解，不过我想还是有必要说一说，首先
第10行--int Open_Raw_Socket(void) 是我们的自定义函数，具体内容如下：
37.int Open_Raw_Socket() {
38. int sock
39. if((sock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) <0) {
/*Then the socket was not created properly and must die*/
40. perror("The raw socket was not created"
41. exit(0)
42. }
43. return(sock)
44. }
第39行 if((sock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) <0) {
这里我们调用了socket函数，使创建了了一个原始套接口，使之收到TCP/IP信息包。
接下来第11行-int Set_Promisc(char *interface, int sock)，这也是我们的自定义函数，
目的是把网卡置于混杂模式，具体内容如下：
45.int Set_Promisc(char *interface, int sock ) {
46. struct ifreq ifr
47. strncpy(ifr.ifr_name, interface,strnlen(interface)+1)
48. if((ioctl(sock, SIOCGIFFLAGS, &ifr) == -1)) {
/*Could not retrieve flags for the interface*/
49. perror("Could not retrive flags for the interface"
50. exit(0)
51. }
52. printf("The interface is ::: %s\n", interface)
53. perror("Retrieved flags from interface successfully"
54. ifr.ifr_flags |= IFF_PROMISC
55. if (ioctl (sock, SIOCSIFFLAGS, &ifr) == -1 ) {
/*Could not set the flags on the interface */
56. perror("Could not set the PROMISC flag:"
57. exit(0)
58. }
59. printf("Setting interface ::: %s ::: to promisc", interface)
60. return(0)
61. }
首先 struct ifreq ifr定一了一个ifrreg的结构ifr，接下来
strncpy(ifr.ifr_name, interface,strnlen(interface)+1)，就是把我们网络设备的名字填
充到ifr结构中，在这里 #define INTERFACE "eth0" ，让我们再往下看,
ioctl(sock, SIOCGIFFLAGS, &ifr),SIOCGIFFLAGS请求表示需要获取接口标志，现在到了
第54行，在我们成功的获取接口标志后把他设置成混杂模式，
ifr.ifr_flags |= IFF_PROMISCioctl (sock, SIOCSIFFLAGS, &ifr)。OK，现在我们所说的
第一步已经完成--------把网卡置于混杂模式。
现在进入第二步，捕获数据包。从第20行开始，我们进入了一个死循环，while(1)，在
第24行，recvfrom(sock, buffer, sizeof buffer, 0, (struct sockaddr *)&from, &fromlen)，
这个函数要做的就是接收数据，冰把接收到的数据放入buffer中。就是这么简单，已经完成了我
们要捕获数据包的任务。
到了第三步，分析数据包。27行，ip = (struct ip *)buffer，使我们在头文件中的IP结
构对应于所接收到的数据，接下来判断在网络层中是否使用的是TCP协议，
if(ip->ip_protocol == 6) ，如果答案是，tcp信息包从整个IP/TCP包 buffer + (4*ip->ip_length)
地址处开始，所以31行 tcp = (struct tcp *)(buffer + (4*ip->ip_length))，然后对应
结构把你所需要的信息输出。
/*************************headers.h**************************/
/*structure of an ip header*/
struct ip {
unsigned int ip_length:4/*little-endian*/
unsigned int ip_version:4
unsigned char ip_tos
unsigned short ip_total_length
unsigned short ip_id
unsigned short ip_flags
unsigned char ip_ttl
unsigned char ip_protocol
unsigned short ip_cksum
unsigned int ip_sourceunsigned int ip_dest
}
/* Structure of a TCP header */
struct tcp {
unsigned short tcp_source_port
unsigned short tcp_dest_port
unsigned int tcp_seqno
unsigned int tcp_ackno
unsigned int tcp_res1:4, /*little-endian*/
tcp_hlen:4,
tcp_fin:1,
tcp_syn:1,
tcp_rst:1,
tcp_psh:1,
tcp_ack:1,
tcp_urg:1,
tcp_res2:2
unsigned short tcp_winsize
unsigned short tcp_cksum
unsigned short tcp_urgent
}
/*********************EOF***********************************/
============================
其他的自己追加，这只是原理！ ===
============================
从上面的分析我们可以清楚的认识到，认识一个SNIFF需要对TCP/IP协议有着详细的了解，
否则你根本无法找到你需要的信息。有了上面的基础，你可以自己来做一个你需要的SNIFF了。
要知道在以太网中，所有的通讯都是广播的，也就是说通常在同一个网段的所有网络接口都可以访问在物理媒体上传输的所有数据，而每一个网络接口都有一个唯一的硬件地址，这个硬件地址也就是网卡的MAC地址，大多数系统使用48比特的地址，这个地址用来表示网络中的每一个设备，一般来说每一块网卡上的MAC地址都是不同的，每个网卡厂家得到一段地址，然后用这段地址分配给其生产的每个网卡一个地址。在硬件地址和IP地址间使用ARP和RARP协议进行相互转换。
在正常的情况下，一个网络接口应该只响应这样的两种数据帧：
1.与自己硬件地址相匹配的数据帧。
2.发向所有机器的广播数据帧。
在一个实际的系统中，数据的收发是由网卡来完成的，网卡接收到传输来的数据，网卡内的单片程序接收数据帧的目的MAC地址，根据计算机上的网卡驱动程序设置的接收模式判断该不该接收，认为该接收就接收后产生中断信号通知CPU，认为不该接收就丢掉不管，所以不该接收的数据网卡就截断了，计算机根本就不知道。CPU得到中断信号产生中断， *** 作系统就根据网卡的驱动程序设置的网卡中断程序地址调用驱动程序接收数据，驱动程序接收数据后放入信号堆栈让 *** 作系统处理。而对于网卡来说一般有四种接收模式：
广播方式：该模式下的网卡能够接收网络中的广播信息。 组播方式：设置在该模式下的网卡能够接收组播数据。
直接方式：在这种模式下，只有目的网卡才能接收该数御稿据。混杂模式：在这种模式下的网卡能够接收一切通过它的数据，而不管该数据是否是传给它的。
好了，现在我们总结一下，首先，我们知道了在以太网中是基于广播方式传送数据的，也就是说，所有的物理信号都要经过我的机器，再次，网卡可以置于一种模式叫混杂模式（promiscuous），在这种模式下工作的网卡能够接收到一切通过它的数据，而不管实际上数据的目的地址是不是他。这实际上就是我们SNIFF工作的基本原理：让网卡接收一切他所能接收的数据。
我们来看一个简单的例子，如图一所示，机器A、B、C与集线器HUB相连接，集线器HUB通过路由器Router访问外部网络。这是一个很简单也很常见的情况，比如说在公司大楼里，我所在的网络部办公室里的几台机器通过集线器连接，而网络部、开发部、市场部也是同样如此，几个部门的集线器通过路由器连接。还是回到我们的图一上来，值得注意的一点是机器A、B、C使用一个普通的HUB连接的，不是用SWITCH，也不是用ROUTER，使用SWITCH和ROUTER的情况要比这复杂得多。
我们假设一下机器A上的管理员为了维护机器C，使用了一个FTP命令向机器C进行远程登陆，那么在这个用HUB连接的网络里数据走向过程是这样的。首先机器A上的管理员输入的登陆机器C的FTP口令经过应用层FTP协议、传输层TCP协议、网络层IP协议、数据链路层上的以太网驱动程序一层一察御层的包裹，最后送到了物理层，我们的网线上。接下来数据帧送到了HUB上，现在由HUB向每一个接点广播由机器A发出的数据帧，机器B接收到由HUB广播发出的数据帧，并检查在数据帧中的地址是镇没孝否和自己的地址相匹配，发现不是发向自己的后把这数据帧丢弃，不予理睬。而机器C也接收到了数据帧，并在比较之后发现是发现自己的，接下来他就对这数据帧进行分析处理。
在上面这个简单的例子中，机器B上的管理员如果很好奇，他很想知道究竟登陆机器C上FTP口令是什么？那么他要做的很简单，仅仅需要把自己机器上的网卡置于混杂模式，并对接收到的数据帧进行分析，从而找到包含在数据帧中的口令信息。
sniff做法
在上一节里，我们已经知道了SNIFF的基本原理是怎么一回事，这一节我们来亲自动手做一个自己的sniff，毕竟，用程序代码来说话比什么都要来得真实，也容易加深理解。
回头想一想我们上面说的原理，我们要做的事情有几件：
1. 把网卡置于混杂模式。 2. 捕获数据包。 3.分析数据包。
注：下面的源代码取至Chad Renfro的《Basic Packet-SnifferConstruction from the Ground Up》一文中
/************************Tcp_sniff_2.c********************/
1.#include
2.#include
3.#include
4.#include
5.#include
6.#include
7.#include
8.#include
9.#include headers.h
#define INTERFACE eth0
/*Prototype area*/
1 0 int Open_Raw_Socket(void）；
11 int Set_Promisc(char *interface,intsock）；
12 int main() {
13int sock,bytes_recieved,fromlen；
14.char buffer[65535]
15.struct sockaddr_in from；
16.struct ip *ip
17.struct tcp *tcp
18.sock = Open_Raw_Socket()
19. Set_Promisc(INTERFACE,sock)
20. while（1）
22. {
23. fromlen = sizeof from
24. bytes_recieved = recvfrom(sock,buffer,sizeofbuffer,0,(struct sockaddr *)&from,&fromlen)
25. printf(\nBytes received :::%5d\n,bytes_recieved)
26. printf(Source address :::%s\n,inet_ntoa(from.sin_addr))
27. ip = (struct ip *)buffer
/*See if this is a TCP packet*/
28. if(ip->ip_protocol == 6） {
29. printf(IP header length :::%d\n,ip->ip_length)
30. printf(Protocol :::%d\n,ip->ip_protocol)
31. tcp = (struct tcp *)(buffer +（4*ip->ip_length))
32. printf(Source port :::%d\n,ntohs(tcp->tcp_source_port))
33. printf(Dest port :::%d\n,ntohs(tcp->tcp_dest_port))
34. }
35. }
36.}
37 int Open_Raw_Socket() {
38. int sock
39. if((sock = socket(AF_INET,SOCK_RAW,IPPROTO_TCP)) <0){
/*Then the socket was not created properly and must die*/
40. perror(The raw socket was not created)
41. exit(0)
42. }
43. return(sock）；
44. }
45 int Set_Promisc(char *interface,int sock ) {
46. struct ifreq ifr
47. strncpy(ifr.ifr_name,interface,strnlen(interface)+1）
48. if((ioctl(sock,SIOCGIFFLAGS,&ifr) == -1）) {
/*Could not retrieve flags for the interface*/
49. perror(Could not retrive flags for the interface)
50. exit(0)
51. }
52. printf(The interface is ::: %s\n,interface）；
53. perror(Retrieved flags from interface successfully)
54. ifr.ifr_flags |= IFF_PROMISC
55. if (ioctl (sock,SIOCSIFFLAGS,&ifr) == -1 ) {
/*Could not set the flags on the interface */
56. perror(Could not set the PROMISC flag:)
57. exit(0）；
58. }
59. printf(Setting interface ::: %s ::: to promisc,interface)
60. return(0)
61. }
/***********************EOF**********************************/
上面这段程序中有很详细的注解，不过我想还是有必要说一说，首先第10行--intOpen_Raw_Socket(void）； 是我们的自定义函数，具体内容如下：
37 int Open_Raw_Socket() {
38. int sock
39. if((sock = socket(AF_INET,SOCK_RAW,IPPROTO_TCP)) <0){
/*Then the socket was not created properly and must die*/
40. perror(The raw socket was not created)
41. exit(0)
42. }
43. return(sock）；
44. }
第39行 if((sock = socket(AF_INET,SOCK_RAW,IPPROTO_TCP)) <0) {
这里我们调用了socket函数，使创建了了一个原始套接口，使之收到TCP/IP信息包。
接下来第11行-int Set_Promisc(char *interface,intsock），这也是我们的自定义函数，目的是把网卡置于混杂模式，具体内容如下：
45 int Set_Promisc(char *interface,int sock ) {
46. struct ifreq ifr
47. strncpy(ifr.ifr_name,interface,strlen(interface)+1）
48. if((ioctl(sock,SIOCGIFFLAGS,&ifr) == -1）) {
/*Could not retrieve flags for the interface*/
49. perror(Could not retrive flags for the interface)
50. exit(0)
51. }
52. printf(The interface is ::: %s\n,interface）；
53. perror(Retrieved flags from interface successfully)
54. ifr.ifr_flags |= IFF_PROMISC
55. if (ioctl (sock,SIOCSIFFLAGS,&ifr) == -1 ) {
/*Could not set the flags on the interface */
56. perror(Could not set the PROMISC flag:)
57. exit(0）；
58. }
59. printf(Setting interface ::: %s ::: to promisc,interface)
60. return(0)
61. }
首先 struct ifreq ifr定一了一个ifrreg的结构ifr，接下来strncpy(ifr.ifr_name,interface,strnlen(interface)+1）；，就是把我们网络设备的名字填充到ifr结构中，在这里#define INTERFACE eth0 ，让我们再往下看，ioctl(sock,SIOCGIFFLAGS,&ifr),SIOCGIFFLAGS请求表示需要获取接口标志，现在到了第54行，在我们成功的获取接口标志后把他设置成混杂模式，ifr.ifr_flags|= IFF_PROMISCioctl (sock,SIOCSIFFLAGS,&ifr）。OK，现在我们所说的第一步已经完成--------把网卡置于混杂模式。
现在进入第二步，捕获数据包。从第20行开始，我们进入了一个死循环，while（1），在第24行，recvfrom(sock,buffer,sizeof buffer,0,(struct sockaddr *)&from,&fromlen），这个函数要做的就是接收数据，并把接收到的数据放入buffer中。就是这么简单，已经完成了我们要捕获数据包的任务。
到了第三步，分析数据包。27行，ip = (struct ip*)buffer，使我们在头文件中的IP结构对应于所接收到的数据，接下来判断在网络层中是否使用的是TCP协议，if(ip->ip_protocol== 6） ，如果答案是，tcp信息包从整个IP/TCP包 buffer +（4*ip->ip_length) 地址处开始，所以31行 tcp = (struct tcp*)(buffer +（4*ip->ip_length）），然后对应结构把你所需要的信息输出。
/*************************headers.h**************************/
/*structure of an ip header*/
struct ip {
unsigned int ip_length:4/*little-endian*/
unsigned int ip_version:4
unsigned char ip_tos；
unsigned short ip_total_length
unsigned short ip_id
unsigned short ip_flags
unsigned char ip_ttl
unsigned char ip_protocol
unsigned short ip_cksum
unsigned int ip_sourceunsigned int ip_dest
}
/* Structure of a TCP header */
struct tcp {
unsigned short tcp_source_port
unsigned short tcp_dest_port
unsigned int tcp_seqno
unsigned int tcp_ackno
unsigned int tcp_res1:4,/*little-endian*/
tcp_hlen:4,
tcp_fin:1,
tcp_syn:1,
tcp_rst:1,
tcp_psh:1,
tcp_ack:1,
tcp_urg:1,
tcp_res2:2
unsigned short tcp_winsize
unsigned short tcp_cksum
unsigned short tcp_urgent
}
/*********************EOF***********************************/
从上面的分析我们可以清楚的认识到，认识一个SNIFF需要对TCP/IP协议有着详细的了解，否则你根本无法找到你需要的信息。有了上面的基础，你可以自己来做一个你需要的SNIFF了。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）