精华内容
下载资源
问答
  • Linux下Sniffer程序的实现 http://www.nsfocus.net/index.php?act=magazine&do=view&mid=1797
    展开全文
  • 作者:Gianluca Insolvibile 整理:Seal(永远FLASH) 出处:http://www.nsfocus.com 日期:2003-04-02 ... ...嗅探——Sniffer技术是网络安全领域里一项非常重要技术!对于“Hacker”来说,他们可以以非

    作者:Gianluca Insolvibile
    整理:Seal(永远的FLASH)
    出处:http://www.nsfocus.com
    日期:2003-04-02

    原文地址:http://www.cnblogs.com/rollenholt/articles/2585432.html

    嗅探——Sniffer技术是网络安全领域里一项非常重要的技术!对于“Hacker”来说,他们可以以非常隐蔽的方式得到网络中传输的大量的敏感信息,如Telnet,ftp帐号和密码等等明文传送的信息!与主动扫描相比,嗅探的行为更加难以被察觉,操作起来也不是很复杂!对于网络管理人员来说,可以利用嗅探技术对网络活动进行监控,并及时发现各种攻击行为!


    在这篇文章里,我们主要探讨在Linux下如何利用C语言来实现一个Sniffer!我们将假设所有的主机在一个局域网内。
        
    首先,我们将简短的回顾一下一个普通的以太网卡是怎么工作的!(如果你对这方面的知识早已熟悉,那么你可以直接跳到下一段)来源于应用程序的IP报文被封装成以太网帧(这
    是在以太网上传播的数据报文的名称),它是底层链路层报文上面的一层报文,包含有源地址
    报文和一些需要用来传送至目标主机的信息。通常情况下,目的IP地址对应着一个6字节的目的以太网址(经常叫做MAC地址),它们之间通过ARP协议进行映射!就这样,包含着以太网帧的报文从源主机传输到目的主机,中间经过一些网络设备,如交换机,路由器等等,当然,因为我们的前提是主机在同一网内,所以我们的讨论不涉及以上这些网络设备!

        在链路层中并不存在路线的概念,换句话说,源主机发出的帧不会直接指向目的主机,
    而是基于广播方式传播,网络中的所有网卡都能看到它的传输。每个网卡会检查帧开始的6个字节(目的主机的MAC地址),但是只有一个网卡会发现自己的地址和其相符合,然后它接收这个帧,这个帧会被网络驱动程序分解,原来的IP报文将通过网络协议栈传送至接收的应用程序!

    更准确的说,网络驱动程序会检查帧中报文头部的协议标识,以确定接收数据的上层协
    议!大多数情况下,上层是IP协议,所以接收机制将去掉IP报文头部,然后把剩下的传送
    至UDP或者TCP接收机制!这些协议,将把报文送到socket-handling机制,它将最后把报
    文数据变成应用程序可接收的方式发送出去。在这个过程中,报文将失去所有的和其有关的
    网络信息,比如源地址(IP和MAC),端口号,IP选择,TCP参数等等!所以如果目的主机没
    有一个包含正确参数的打开端口,那么这个报文将被丢弃而且永远不会被送到应用层去!

    因此我们在进行网络嗅探的时候有两个不同的问题:一个和以太网址有关,我们不能抓
    到不是发给自己主机的包,另一个和协议栈的运行过程有关,我们需要一个SOCKET去监听每
    个端口,得到那些没有被丢弃的报文!

    第一个问题不是最根本的,因为我们可能不会对发往其他主机的报文有兴趣而只想嗅探
    所有发往自己主机的报文。第二个问题是必须要解决的,下面我们将看到这个问题是怎么样
    一步一步解决的!

    当你打开一个标准的SOCKET套接字时,你需要指明你将使用哪个协议簇,大多数情况下
    我们一般用PF_UNIX在本地机器间进行通信,PF_INET在基于IPv4协议簇基础之上进行通信,
    你还需要指明所用的协议类型及与协议簇相关的确切数值,,在PF_INET协议簇中,常用的有
    SOCK_STREAM(与TCP相关),SOCK_DGRAM(与UDP相关)。在把报文发送到应用程序前内核对
    其的处理与SOCKET类型有关,你指定的协议将处理报文在SOCKET的传输!(具体细节问题你
    可以man socket(3))

    在LINUX内核版本中(2.0 releases),一个名为PF_PACKET的协议簇被加了进来!这个簇允许应用程序直接利用网络驱动程序发送和接收报文,避免了原来的协议栈处理过程,在这种情况下,所有SOCKET发出的报文直接送到以太网卡接口,而接口收到的任何报文将直接送到应用程序

    PF_PACKET协议簇支持两个稍微有点不同的SOCKET类型,SOCK_DGRAM和SOCK_RAW。
    前者让内核处理添加或者去除以太网报文头部工作,而后者则让应用程序对以太网报文头部
    有完全的控制!

    在SOCKET调用中的协议类型必须符合/usr/include/linux/if_ether.h
    中定义的以太网IDs中的一个,除非遇到特别声明的协议,一般你可以用ETH_P_IP来处理
    IP的一组协议(TCP,UDP,ICMP,raw IP等等)因为它们容易受到一些很严重的安全问题的牵
    连(比如你可以伪造一个MAC地址),所以只有具有root权限才可以使用PF_PACKET-family 
    socket.这也就是为什么只有具有root权限后才能运行嗅探器的原因!

    PF_PACKET-family 协议簇可以很容易解决协议栈处理嗅探来的数据报文时候遇到的问
    题!我们一起来看看程序1,我们打开一个属于PF_PACKET-family 协议簇的SOCKET,指定
    一个SOCK_RAW socket类型和IP相关协议类型。这时我们开始从SOCKET抓包,在一些相关
    检查后.我们开始得到从链路层和IP层抓来的头部信息,。通过阅读程序一,你将会发现让应
    用程序从网络层抓包其实并不难!

    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
    Example 1.
    #include <stdio.h>
    #include <errno.h> 
    #include <unistd.h>
    #include <sys/socket.h>
    #include <sys/types.h> 
    #include <linux/in.h>
    #include <linux/if_ether.h>
     
    int main(int argc, char **argv) {
      int sock, n;
      char buffer[2048];
      unsigned char *iphead, *ethhead;
       
      if ( (sock=socket(PF_PACKET, SOCK_RAW,
                        htons(ETH_P_IP)))<0) {
        perror("socket");
        exit(1);
      }
     
      while (1) {
        printf("----------\n");
        n = recvfrom(sock,buffer,2048,0,NULL,NULL);
        printf("%d bytes read\n",n);
     
        /* Check to see if the packet contains at least
         * complete Ethernet (14), IP (20) and TCP/UDP
         * (8) headers.
         */
        if (n<42) {
          perror("recvfrom():");
          printf("Incomplete packet (errno is %d)\n",
                 errno);
          close(sock);
          exit(0);
        }
     
        ethhead = buffer;
        printf("Source MAC address: "
               "%02x:%02x:%02x:%02x:%02x:%02x\n",
               ethhead[0],ethhead[1],ethhead[2],
               ethhead[3],ethhead[4],ethhead[5]);
        printf("Destination MAC address: "
               "%02x:%02x:%02x:%02x:%02x:%02x\n",
               ethhead[6],ethhead[7],ethhead[8],
               ethhead[9],ethhead[10],ethhead[11]);
     
        iphead = buffer+14; /* Skip Ethernet header */
        if (*iphead==0x45) { /* Double check for IPv4
                              * and no options present */
          printf("Source host %d.%d.%d.%d\n",
                 iphead[12],iphead[13],
                 iphead[14],iphead[15]);
          printf("Dest host %d.%d.%d.%d\n",
                 iphead[16],iphead[17],
                 iphead[18],iphead[19]);
          printf("Source,Dest ports %d,%d\n",
                 (iphead[20]<<8)+iphead[21],
                 (iphead[22]<<8)+iphead[23]);
          printf("Layer-4 protocol %d\n",iphead[9]);
        }
      }
       
    }

      PF_PACKET协议簇可以让一个应用程序把数据包变成似乎从网络层接收的样子,但是
    没有办法抓到那些不是发向自己主机的包。正如我们前面看到的,网卡丢弃所有不含有主机
    MAC地址的数据包,这是因为网卡处于非混杂模式,即每个网卡只处理源地址是它自己的帧!
    只有三个例外:如果一个帧的目的MAC地址是一个受限的广播地址(255.255.255.255)那么
    它将被所有的网卡接收:如果一个帧的目的地址是组播地址,那么它将被那些打开组播接收
    功能的网卡所接收;网卡如被设置成混杂模式,那么它将接收所有流经它的数据包


    最后一种情况当然是我们最感兴趣的了,把网卡设置成混杂模式,我们只需要发出一个
    特殊的ioctl()调用在那个网卡上打开一个socket,因为这是一个具有危险性的操作,所以这
    个调用只有具有root权限的用户才可完成,假设那个“sock”包含一个已经打开的socket,

    下面的代码将完成这个操作:

    1
    2
    3
    4
    strncpy(ethreq.ifr_name,"eth0",IFNAMSIZ);
    ioctl(sock, SIOCGIFFLAGS, &ethreq);
    ethreq.ifr_flags |= IFF_PROMISC;
    ioctl(sock, SIOCSIFFLAGS, &ethreq);

      下面我们来看一个完整的例子:

    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
    Example 2.
     
    #include <stdio.h>
    #include <string.h>
    #include <errno.h> 
    #include <unistd.h>
    #include <sys/socket.h>
    #include <sys/types.h> 
    #include <linux/in.h>
    #include <linux/if_ether.h>
    #include <net/if.h>
    #include <sys/ioctl.h>
     
    int main(int argc, char **argv) {
      int sock, n;
      char buffer[2048];
      unsigned char *iphead, *ethhead;
      struct ifreq ethreq;
       
      if ( (sock=socket(PF_PACKET, SOCK_RAW,
                        htons(ETH_P_IP)))<0) {
        perror("socket");
        exit(1);
      }
     
      /* Set the network card in promiscuos mode */
      strncpy(ethreq.ifr_name,"eth0",IFNAMSIZ);
      if (ioctl(sock,SIOCGIFFLAGS,?req)==-1) {
        perror("ioctl");
        close(sock);
        exit(1);
      }
      ethreq.ifr_flags|=IFF_PROMISC;
      if (ioctl(sock,SIOCSIFFLAGS,?req)==-1) {
        perror("ioctl");
        close(sock);
        exit(1);
      }
       
      while (1) {
        printf("----------\n");
        n = recvfrom(sock,buffer,2048,0,NULL,NULL);
        printf("%d bytes read\n",n);
     
        /* Check to see if the packet contains at least
         * complete Ethernet (14), IP (20) and TCP/UDP
         * (8) headers.
         */
        if (n<42) {
          perror("recvfrom():");
          printf("Incomplete packet (errno is %d)\n",
                 errno);
          close(sock);
          exit(0);
        }
     
        ethhead = buffer;
        printf("Source MAC address: "
               "%02x:%02x:%02x:%02x:%02x:%02x\n",
               ethhead[0],ethhead[1],ethhead[2],
               ethhead[3],ethhead[4],ethhead[5]);
        printf("Destination MAC address: "
               "%02x:%02x:%02x:%02x:%02x:%02x\n",
               ethhead[6],ethhead[7],ethhead[8],
               ethhead[9],ethhead[10],ethhead[11]);
     
        iphead = buffer+14; /* Skip Ethernet header */
        if (*iphead==0x45) { /* Double check for IPv4
                              * and no options present */
          printf("Source host %d.%d.%d.%d\n",
                 iphead[12],iphead[13],
                 iphead[14],iphead[15]);
          printf("Dest host %d.%d.%d.%d\n",
                 iphead[16],iphead[17],
                 iphead[18],iphead[19]);
          printf("Source,Dest ports %d,%d\n",
                 (iphead[20]<<8)+iphead[21],
                 (iphead[22]<<8)+iphead[23]);
          printf("Layer-4 protocol %d\n",iphead[9]);
        }
      }
       
    }

      如果我们在一个与局域网相连的主机上以root权限编译和运行这个程序,你将会看到流
    经的所有数据包,即使它不是发向自己主机的,这是因为你的网卡现在处于混杂模式,你可
    以很容易的用ifconfig这个命令看到!

    注意,如果你的局域网用的是交换机而不是集线器,那么你只能抓到在你主机所在的交
    换分支中的数据包,这是由于交换的工作原理,在这种情况下,你没有什么其他可做的了(除非你利用MAC地址欺骗来瞒过交换机,这个内容超出本文讨论的范围了),如果你想知道这方面更多的信息,你可以去www.google.com,那里你将会搜索到很多你需要的东西!

    我们关于嗅探方面的问题似乎都解决了,但是还有一个问题值得我们去思考!如果我们
    实验Example2的时候正好遇到了网络拥塞,我们将会看到我们的嗅探器将打出非常多的数据,随着网络拥塞的加剧,主机将不能顺畅的执行这个程序,嗅探器这时会开始丢包!

    解决这个问题的方法就是对你抓到的包进行过滤,使它只显示那些你感兴趣的那些部分!
    在源代码中多使用一些if语句,这将有益于去除那些不需要的信息,当然这样也许效率不是
    很高!内核仍然将处理所有的报文,这将浪费进程时间。 

    最好的解决办法就是把过滤过程尽可能早的放报文进程链(packet-processing chain)
    中(它开始于链路层,终止于应用层)LINUX的内核允许我们把一个名为LPF的过滤器直接放到PF_PACKET protocol-processing routines(在网卡接收中断执行后立即执行)中,过滤器将决定哪些包被送到应用程序,哪些包被丢弃!


    为了做到尽可能的灵活,这个过滤程序可以根据使用者的定义来运行!这个程序是由一种名为BPF的伪机器码写成的。BPF看上去很象带着一对寄存器和保存值的汇编语言,完成数学运算和条件分支程序!过滤程序检查每个包,BP进程操作的内存空间包含着报文数据!过滤的结果是一个整数,指出有多少字节的报文需要送到应用层。这是一个更进一步的优点,因为我们一般只对报文的前面几个字节感兴趣,这样可以避免复制过量的数据以节省进程时间。

    虽然BPF语言非常简单易学,但是大多数人还是习惯于人类可以阅读的表达方式!所以
    为了不用BPF语言去描述那些细节和代码,我们将下面开始讨论如何得到一个过滤器的代码!

    首先,你需要安装tcpdump,可以从LBL得到!但是,如果你正在读本文,那似乎说明
    你已经会使用tcpdump了!第一个版本的作者也是那些写BPF的人,事实上,tcpdump要用
    到BPF,它要用到一个叫libpcap的类库,以此去抓包和过滤。这个类库是一个与操作系统
    无关的独立的包,为BPF的实现提供支持,当在装有LINUX的机器上使用时,BPF的功能就
    由LINUX包过滤器实现了!

    libpcap提供的一个最有用的函数是pcap_compile(), 它可以把一个输入输出的逻辑表
    达式变为BPF代码!tcpdump利用这个函数完成在用户输入的命令行和BPF代码之间的转换!
    tcpdump有个我们很感兴趣但是很少使用的参数 ,-d,可以输出BPF代码!

    举个例子,如果tcpdump host 192.168.9.10那么将启动嗅探器并只抓到源地址或者目
    的地址是192.168.9.10的报文!如果tcpdump -d host 192.168.9.10那么将显示出BPF代
    码,见下面

    Example 3. 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    Seal:~# tcpdump -d host 192.168.9.10
    (000) ldh      [12]
    (001) jeq      #0x800           jt 2    jf 6
    (002) ld       [26]
    (003) jeq      #0xc0a8090a      jt 12   jf 4
    (004) ld       [30]
    (005) jeq      #0xc0a8090a      jt 12   jf 13
    (006) jeq      #0x806           jt 8    jf 7
    (007) jeq      #0x8035          jt 8    jf 13
    (008) ld       [28]
    (009) jeq      #0xc0a8090a      jt 12   jf 10
    (010) ld       [38]
    (011) jeq      #0xc0a8090a      jt 12   jf 13
    (012) ret      #68
    (013) ret      #0

      我们简单的分析一下这个代码,0-1,6-7行在确定被抓到的帧是否在传输着IP,ARP或
    者RARP协议,通过比较帧的第12格的值与协议的特征值(见/usr/include/linux/if_ether.h)!如果比较失败,那么丢弃这个包!

    2-5,8-11行是比较帧的源地址和目的地址是否与192.168.9.10相同!注意,不同的
    协议,地址值在帧中的偏移位不同,如果是IP协议,它在26-30,如果是其他协议,它在
    28-38如果有一个地址符合,那么帧的前68字节将被送到应用程序去(第12行)

    这个过滤器也不是总是有效的,因为它产生于一般的使用BPF的机器,没考虑到一些特
    殊结构的机器!在一些特殊情况下,过滤器由PF_PACKET进程运行,也许已经检查过以太协
    议了!这个根据你在socket()调用初使化的时候指定的那些协议!如果不是ETH_P_ALL(抓
    所有的报文),那么只有那些符合指定的协议类型的报文会流过过滤器!举个例子,如果是
    ETH_P_IP socket,我们可以重写一个更快且代码更紧凑的过滤器,代码如下

    1
    2
    3
    4
    5
    (000) ld       [26]
    (001) jeq      #0xc0a8090a      jt 4    jf 2
    (002) ld       [30]
    (003) jeq      #0xc0a8090a      jt 4    jf 5
    (004) ret      #68(005) ret      #0

      
    安装LPF是一个一往直前的操作,所有你需要做的就是建立一个sock_filter并为
    它绑定一个打开的端口!一个过滤器很容易得到,只要把tcpdump -d中的-d换成-dd就可以了!过滤器将显示出一段C代码,你可以把它复制到自己的程序中,见Example 4,这样你就可以通过调用setsockopt()来过滤端口!

    Example 4. 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    Seal:~# tcpdump -dd host 192.168.9.01
    { 0x28, 0, 0, 0x0000000c },
    { 0x15, 0, 4, 0x00000800 },
    { 0x20, 0, 0, 0x0000001a },
    { 0x15, 8, 0, 0xc0a80901 },
    { 0x20, 0, 0, 0x0000001e },
    { 0x15, 6, 7, 0xc0a80901 },
    { 0x15, 1, 0, 0x00000806 },
    { 0x15, 0, 5, 0x00008035 },
    { 0x20, 0, 0, 0x0000001c },
    { 0x15, 2, 0, 0xc0a80901 },
    { 0x20, 0, 0, 0x00000026 },
    { 0x15, 0, 1, 0xc0a80901 },
    { 0x6, 0, 0, 0x00000044 },
    { 0x6, 0, 0, 0x00000000

      
    A Complete Example

    我们将用一个完整的程序Example 5来结束这篇文章

    Example 5

    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
    #include <stdio.h>
    #include <string.h>
    #include <errno.h> 
    #include <unistd.h>
    #include <sys/socket.h>
    #include <sys/types.h> 
    #include <linux/in.h>
    #include <linux/if_ether.h>
    #include <net/if.h>
    #include <linux/filter.h>
    #include <sys/ioctl.h>
     
    int main(int argc, char **argv) {
      int sock, n;
      char buffer[2048];
      unsigned char *iphead, *ethhead;
      struct ifreq ethreq;
     
      /*
        udp and host 192.168.9.10 and src port 5000
        (000) ldh      [12]
        (001) jeq      #0x800           jt 2        jf 14
        (002) ldb      [23]
        (003) jeq      #0x11            jt 4        jf 14
        (004) ld       [26]
        (005) jeq      #0xc0a8090a      jt 8        jf 6
        (006) ld       [30]
        (007) jeq      #0xc0a8090a      jt 8        jf 14
        (008) ldh      [20]
        (009) jset     #0x1fff          jt 14       jf 10
        (010) ldxb     4*([14]&0xf)
        (011) ldh      [x + 14]
        (012) jeq      #0x1388          jt 13       jf 14
        (013) ret      #68
        (014) ret      #0
      */
      struct sock_filter BPF_code[]= {
        { 0x28, 0, 0, 0x0000000c },
        { 0x15, 0, 12, 0x00000800 },
        { 0x30, 0, 0, 0x00000017 },
        { 0x15, 0, 10, 0x00000011 },
        { 0x20, 0, 0, 0x0000001a },
        { 0x15, 2, 0, 0xc0a8090a },
        { 0x20, 0, 0, 0x0000001e },
        { 0x15, 0, 6, 0xc0a8090a },
        { 0x28, 0, 0, 0x00000014 },
        { 0x45, 4, 0, 0x00001fff },
        { 0xb1, 0, 0, 0x0000000e },
        { 0x48, 0, 0, 0x0000000e },
        { 0x15, 0, 1, 0x00001388 },
        { 0x6, 0, 0, 0x00000044 },
        { 0x6, 0, 0, 0x00000000 }
      };                           
      struct sock_fprog Filter;
         
      Filter.len = 15;
      Filter.filter = BPF_code;
       
      if ( (sock=socket(PF_PACKET, SOCK_RAW,
                        htons(ETH_P_IP)))<0) {
        perror("socket");
        exit(1);
      }
     
      /* Set the network card in promiscuos mode */
      strncpy(ethreq.ifr_name,"eth0",IFNAMSIZ);
      if (ioctl(sock,SIOCGIFFLAGS,?req)==-1) {
        perror("ioctl");
        close(sock);
        exit(1);
      }
      ethreq.ifr_flags|=IFF_PROMISC;
      if (ioctl(sock,SIOCSIFFLAGS,?req)==-1) {
        perror("ioctl");
        close(sock);
        exit(1);
      }
     
      /* Attach the filter to the socket */
      if(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,
                    &Filter, sizeof(Filter))<0){
        perror("setsockopt");
        close(sock);
        exit(1);
      }
     
      while (1) {
        printf("----------\n");
        n = recvfrom(sock,buffer,2048,0,NULL,NULL);
        printf("%d bytes read\n",n);
     
        /* Check to see if the packet contains at least
         * complete Ethernet (14), IP (20) and TCP/UDP
         * (8) headers.
         */
        if (n<42) {
          perror("recvfrom():");
          printf("Incomplete packet (errno is %d)\n",
                 errno);
          close(sock);
          exit(0);
        }
     
        ethhead = buffer;
        printf("Source MAC address: "
               "%02x:%02x:%02x:%02x:%02x:%02x\n",
               ethhead[0],ethhead[1],ethhead[2],
               ethhead[3],ethhead[4],ethhead[5]);
        printf("Destination MAC address: "
               "%02x:%02x:%02x:%02x:%02x:%02x\n",
               ethhead[6],ethhead[7],ethhead[8],
               ethhead[9],ethhead[10],ethhead[11]);
     
        iphead = buffer+14; /* Skip Ethernet  header */
        if (*iphead==0x45) { /* Double check for IPv4
                              * and no options present */
          printf("Source host %d.%d.%d.%d\n",
                 iphead[12],iphead[13],
                 iphead[14],iphead[15]);
          printf("Dest host %d.%d.%d.%d\n",
                 iphead[16],iphead[17],
                 iphead[18],iphead[19]);
          printf("Source,Dest ports %d,%d\n",
                 (iphead[20]<<8)+iphead[21],
                 (iphead[22]<<8)+iphead[23]);
          printf("Layer-4 protocol %d\n",iphead[9]);
        }
      }
       
    }

      这个程序和开始的前两个程序很类似,只是增加了LSP代码和setsockopt()调用,这个
    过滤器被用来嗅探UDP报文(源地址或者目的地址为192.168.9.10且源地址的端口为5000)
    为了测试这个程序,你需要一个简单的方法去生成不断的UDP报文(如发送或者接受IP),而且你可以把程序修改为你指定的机器的IP地址,你只需要把代码中的0xc0a8090a替换成你要的IP地址的16进制形式!

    最后想说的就是关闭程序后如果我们没有重新设置网卡,那么它还是处于混杂模式!你
    可以加一个Control-C信号句柄来使网卡在程序关闭前恢复以前的默认配置。

    进行网络嗅探对于诊断网络运行错误或者进行流量分析都是非常重要的!有些时候常用
    的工具如tcpdump或者Ethereal不能非常符合我们的需要的时候,我们可以自己写一个嗅探
    器!为此我们应该感谢LPF,它使我们做到这点变的很容易!

     


    ==============================================================================我喜欢程序员,他们单纯、固执、容易体会到成就感;面对压力,能够挑灯夜战不眠不休;面对困难,能够迎难而上挑战自我。他们也会感到困惑与傍徨,但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧开创属于自己的事业”。我想说的是,其实我是一个程序员。==============================================================================
    展开全文
  • } } } 这个程序和开始前两个程序很类似,只是增加了LSP代码和setsockopt()调用,这个 过滤器被用来嗅探UDP报文(源地址或者目的地址为192.168.9.10且源地址端口为5000) 为了测试这个程序,你需要一个简单方法...

    #include int main(int argc, char **argv) {

    int sock, n;

    char buffer[2048];

    unsigned char *iphead, *ethhead;

    struct ifreq ethreq;

    /*

    udp and host 192.168.9.10 and src port 5000

    (000) ldh       [12]

    (001) jeq       #0x800           jt 2         jf 14

    (002) ldb       [23]

    (003) jeq       #0x11             jt 4         jf 14

    (004) ld       [26]

    (005) jeq       #0xc0a8090a       jt 8         jf 6

    (006) ld       [30]

    (007) jeq       #0xc0a8090a       jt 8         jf 14

    (008) ldh       [20]

    (009) jset     #0x1fff           jt 14       jf 10

    (010) ldxb     4*([14]&0xf)

    (011) ldh       [x + 14]

    (012) jeq       #0x1388           jt 13       jf 14

    (013) ret       #68

    (014) ret       #0

    */

    struct sock_filter BPF_code[]= {

    { 0x28, 0, 0, 0x0000000c },

    { 0x15, 0, 12, 0x00000800 },

    { 0x30, 0, 0, 0x00000017 },

    { 0x15, 0, 10, 0x00000011 },

    { 0x20, 0, 0, 0x0000001a },

    { 0x15, 2, 0, 0xc0a8090a },

    { 0x20, 0, 0, 0x0000001e },

    { 0x15, 0, 6, 0xc0a8090a },

    { 0x28, 0, 0, 0x00000014 },

    { 0x45, 4, 0, 0x00001fff },

    { 0xb1, 0, 0, 0x0000000e },

    { 0x48, 0, 0, 0x0000000e },

    { 0x15, 0, 1, 0x00001388 },

    { 0x6, 0, 0, 0x00000044 },

    { 0x6, 0, 0, 0x00000000 }

    };

    struct sock_fprog Filter;

    Filter.len = 15;

    Filter.filter = BPF_code;

    if ( (sock=socket(PF_PACKET, SOCK_RAW,

    htons(ETH_P_IP)))<0) {

    perror("socket");

    exit(1);

    }

    /* Set the network card in promiscuos mode */

    strncpy(ethreq.ifr_name,"eth0",IFNAMSIZ);

    if (ioctl(sock,SIOCGIFFLAGS,?req)==-1) {

    perror("ioctl");

    close(sock);

    exit(1);

    }

    ethreq.ifr_flags|=IFF_PROMISC;

    if (ioctl(sock,SIOCSIFFLAGS,?req)==-1) {

    perror("ioctl");

    close(sock);

    exit(1);

    }

    /* Attach the filter to the socket */

    if(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER,

    &Filter, sizeof(Filter))<0){

    perror("setsockopt");

    close(sock);

    exit(1);

    }

    while (1) {

    printf("----------\n");

    n = recvfrom(sock,buffer,2048,0,NULL,NULL);

    printf("%d bytes read\n",n);

    /* Check to see if the packet contains at least

    * complete Ethernet (14), IP (20) and TCP/UDP

    * (8) headers.

    */

    if (n<42) {

    perror("recvfrom():");

    printf("Incomplete packet (errno is %d)\n",

    errno);

    close(sock);

    exit(0);

    }

    ethhead = buffer;

    printf("Source MAC address: "

    "%02x:%02x:%02x:%02x:%02x:%02x\n",

    ethhead[0],ethhead[1],ethhead[2],

    ethhead[3],ethhead[4],ethhead[5]);

    printf("Destination MAC address: "

    "%02x:%02x:%02x:%02x:%02x:%02x\n",

    ethhead[6],ethhead[7],ethhead[8],

    ethhead[9],ethhead[10],ethhead[11]);

    iphead = buffer+14; /* Skip Ethernet   header */

    if (*iphead==0x45) { /* Double check for IPv4

    * and no options present */

    printf("Source host %d.%d.%d.%d\n",

    iphead[12],iphead[13],

    iphead[14],iphead[15]);

    printf("Dest host %d.%d.%d.%d\n",

    iphead[16],iphead[17],

    iphead[18],iphead[19]);

    printf("Source,Dest ports %d,%d\n",

    (iphead[20]<<8)+iphead[21],

    (iphead[22]<<8)+iphead[23]);

    printf("Layer-4 protocol %d\n",iphead[9]);

    }

    }

    }

    这个程序和开始的前两个程序很类似,只是增加了LSP代码和setsockopt()调用,这个

    过滤器被用来嗅探UDP报文(源地址或者目的地址为192.168.9.10且源地址的端口为5000)

    为了测试这个程序,你需要一个简单的方法去生成不断的UDP报文(如发送或者接受IP),而且你可以把程序修改为你指定的机器的IP地址,你只需要把代码中的0xc0a8090a替换成你要的IP地址的16进制形式!

    最后想说的就是关闭程序后如果我们没有重新设置网卡,那么它还是处于混杂模式!你

    可以加一个Control-C信号句柄来使网卡在程序关闭前恢复以前的默认配置。

    进行网络嗅探对于诊断网络运行错误或者进行流量分析都是非常重要的!有些时候常用

    的工具如tcpdump或者Ethereal不能非常符合我们的需要的时候,我们可以自己写一个嗅探

    器!为此我们应该感谢LPF,它使我们做到这点变的很容易!

    展开全文
  •  在这篇文章里,我们主要探讨在Linux下如何利用C语言来实现一个Sniffer!我们将假设所有主机在一个局域网内。  首先,我们将简短回顾一下一个普通以太网卡是怎么工作!(如果你对这方面知识早已熟悉,那么...
  • #include #include#include#include#include#include#include#include#include#include#includeint main(int argc, char **argv) {intsock, n;char buffer[2048];unsignedchar *iphead, *ethhead;...

    #include #include#include#include#include#include#include#include#include#include#include

    int main(int argc, char **argv) {intsock, n;char buffer[2048];

    unsignedchar *iphead, *ethhead;structifreq ethreq;/*my ip: 10.219.119.23 == 0x0adb7716*/

    /*udp and host 192.168.13.41 and src port 5000

    (000) ldh [12]

    (001) jeq #0x800 jt 2 jf 14

    (002) ldb [23]

    (003) jeq #0x11 jt 4 jf 14

    (004) ld [26]

    (005) jeq #0x0adb7716 jt 8 jf 6

    (006) ld [30]

    (007) jeq #0x0adb7716 jt 8 jf 14

    (008) ldh [20]

    (009) jset #0x1fff jt 14 jf 10

    (010) ldxb 4*([14]&0xf)

    (011) ldh [x + 14]

    (012) jeq #0x1388 jt 13 jf 14

    (013) ret #68

    (014) ret #0*/

    struct sock_filter BPF_code[]={

    {0x28, 0, 0, 0x0000000c},

    {0x15, 0, 12, 0x00000800},

    {0x30, 0, 0, 0x00000017},

    {0x15, 0, 10, 0x00000011},

    {0x20, 0, 0, 0x0000001a},

    {0x15, 2, 0, 0x0adb7716},

    {0x20, 0, 0, 0x0000001e},

    {0x15, 0, 6, 0x0adb7716},

    {0x28, 0, 0, 0x00000014},

    {0x45, 4, 0, 0x00001fff},

    {0xb1, 0, 0, 0x0000000e},

    {0x48, 0, 0, 0x0000000e},

    {0x15, 0, 1, 0x00001388},

    {0x6, 0, 0, 0x00000044},

    {0x6, 0, 0, 0x00000000}

    };structsock_fprog Filter;

    Filter.len= 15;

    Filter.filter=BPF_code;if ( (sock=socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP)))<0) {

    perror("socket");return -1;

    }/*Set the network card in promiscuous mode 设置网卡为混杂模式*/strncpy(ethreq.ifr_name,"eth3",IFNAMSIZ); //hardcode, please check your computer: $ifconfig

    if (ioctl(sock,SIOCGIFFLAGS,&ethreq)==-1) {

    perror("ioctl");

    close(sock);return -1;

    }

    ethreq.ifr_flags|=IFF_PROMISC;if (ioctl(sock,SIOCSIFFLAGS,&ethreq)==-1) {

    perror("ioctl");

    close(sock);return -1;

    }/*Attach the filter to the socket*/

    if(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &Filter, sizeof(Filter))<0){

    perror("setsockopt");

    close(sock);return -1;

    }while (1) {

    printf("----------\n");

    n= recvfrom(sock,buffer,2048,0,NULL,NULL);

    printf("%d bytes read\n",n);/*Check to see if the packet contains at least

    * complete Ethernet (14), IP (20) and TCP/UDP

    * (8) headers.*/

    if (n<42) {

    perror("recvfrom():");

    printf("Incomplete packet (errno is %d)\n", errno);

    close(sock);return 0;

    }

    ethhead=buffer;

    printf("Source MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n",

    ethhead[0],ethhead[1],ethhead[2],ethhead[3],ethhead[4],ethhead[5]);

    printf("Destination MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n",

    ethhead[6],ethhead[7],ethhead[8],ethhead[9],ethhead[10],ethhead[11]);

    iphead= buffer+14; /*Skip Ethernet header*/

    if (*iphead==0x45) { /*Double check for IPv4 and no options present*/printf("Source host %d.%d.%d.%d\n", iphead[12],iphead[13],iphead[14],iphead[15]);

    printf("Dest host %d.%d.%d.%d\n", iphead[16],iphead[17], iphead[18],iphead[19]);

    printf("Source,Dest ports %d,%d\n", (iphead[20]<<8)+iphead[21], (iphead[22]<<8)+iphead[23]);

    printf("Layer-4 protocol %d\n",iphead[9]);

    }

    }

    }

    展开全文
  • //设置原始套接字方式为接收所有数据包 if((sock=socket(PF_PACKET,SOCK_RAW,htons(ETH_P_IP)))){ perror("\n原始套接字建立失败\n");exit(1);} //设置网卡工作方式为混杂模式,SIOCGIFFLAGS请求表示需要获取接口...
  • Linux下Sniffer程序的实现(转)

    千次阅读 2013-01-10 14:17:54
    作者:Gianluca Insolvibile 整理:Seal(永远FLASH) 出处:http://www.nsfocus.com 日期:2003-04-02 ...嗅探——Sniffer技术是网络安全领域里一项非常重要技术!对于“Hacker”来说,他们可以以非常隐蔽
  • 作者:Gianluca Insolvibile整理:Seal(永远FLASH)日期:2004-11-05嗅探——Sniffer技术是网络安全领域里一项非常重要技术!对于“Hacker”来说,他们可以以非常隐蔽方式得到网络中传输大量敏感信息,如...
  • Linux下sniffer抓包程序程序的实现

    千次阅读 2009-11-13 10:14:00
    Linux下Sniffer程序的实现作者:Gianluca Insolvibile整理:Seal(永远的FLASH)日期:2004-11-05嗅探——Sniffer技术是网络安全领域里一项非常重要的技术!对于“Hacker”来说,他们可以以非常隐蔽的方式得到网络中...
  • Sniffer是一种常用收集有用数据方法,这些数据可以是用户帐号和密码,可以是一些商用机密数据等等。...通常sniffer程序只看一个数据包前200-300个字节数据,就能发现想口令和用户名这样信息。
  •  在这篇文章里,我们主要探讨在Linux下如何利用C语言来实现一个Sniffer!我们将假设所有主机在一个局域网内。  首先,我们将简短回顾一下一个普通以太网卡是怎么工作!(如果你对这方面知识早已熟悉,那么...
  • Sniffer技术是网络安全领域里一项非常重要技术!对于“Hacker”来说,他们可以以非常隐蔽方式得到网络中传输大量敏感信息,如 Telnet,ftp帐号和密码等等明文传送信息!与主动扫描相比,嗅探行为更加难以被...
  • linuxbpf封包

    千次阅读 2015-08-29 16:39:22
    柏克莱封包过滤器(Berkeley Packet Filter,缩写 BPF),是类Unix系统上数据链路层的一种原始接口,提供原始链路层封包的...《Linux下Sniffer程序的实现》这篇文章对其关系表述的比较准确。 另外一篇英文参考Inside
  • ...《Linux下Sniffer程序的实现》这篇文章对其关系表述的比较准确。 另外一篇英文参考Inside the Linux Packet Filter 很深入 http://www.linuxjournal.com/article/4852 1,LINUX中PF_PAC
  • C语言实现Linux网络嗅探器 0x01 实验简介 网络嗅探器是拦截通过网络接口流入和流出数据...本程序使用c语言编程,实现linux环境网络嗅探功能,并实现对接收到UDP数据报进行解析。 0x03程序代码 sniffer.h #...
  • 抓包分析(很好,很强大)

    千次阅读 2009-03-20 16:05:00
    Linux下Sniffer程序的实现作者:Gianluca Insolvibile整理:Seal(永远的FLASH)出处:http://www.nsfocus.com日期:2003-04-02嗅探——Sniffer技术是网络安全领域里一项非常重要的技术!对于“Hacker”来说,他们可以...

空空如也

空空如也

1 2 3
收藏数 48
精华内容 19
关键字:

linux下sniffer程序的实现

linux 订阅