ARP的C代码实现

偏执的太偏执、 2022-08-07 00:14 156阅读 0赞

<h2 id="t_412ef3420100mvbp" class="titName SG_txta">linux下C语言实现ARP数据包发送</h2>
    
    #include <netdb.h>
    #include <sys/socket.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <errno.h>
    #include <sys/ioctl.h>
    #include <net/if.h>
    #include <signal.h>
    #include <netinet/ip.h>
    #include <netinet/in.h>
    #include <string.h>
    #include <arpa/inet.h>
    #include <netinet/ip_icmp.h>
    #include <linux/if_ether.h>
    #define ETH_HW_ADDR_LEN 6
    #define IP_ADDR_LEN 4
    #define ARP_FRAME_TYPE 0x0806
    #define ETHER_HW_TYPE 1
    #define IP_PROTO_TYPE 0x0800
    #define OP_ARP_REQUEST 2
    #define OP_ARP_QUEST 1
    #define DEFAULT_DEVICE "eth0"
    
    char usage[] =
    {"send_arp: sends out custom ARP packet. ferrysnow@gmail.com \nusage : send_arp src_ip_addr src_hw_addr targ_ip_addr tar_hw_addr number"};
    
    struct arp_packet
    {
    u_char targ_hw_addr[ETH_HW_ADDR_LEN];
    u_char src_hw_addr[ETH_HW_ADDR_LEN];
    u_short frame_type;
    u_short hw_type;
    u_short prot_type;
    u_char hw_addr_size;
    u_char prot_addr_size;
    u_short op;
    u_char sndr_hw_addr[ETH_HW_ADDR_LEN];
    u_char sndr_ip_addr[IP_ADDR_LEN];
    u_char rcpt_hw_addr[ETH_HW_ADDR_LEN];
    u_char rcpt_ip_addr[IP_ADDR_LEN];
    u_char padding[18];
    };
    
    void die(char*);
    void get_ip_addr(struct in_addr*, char*);
    void get_hw_addr(char*, char*);
    
    int main(int argc, char* argv[])
    {
            struct in_addr src_in_addr, targ_in_addr;
            struct arp_packet pkt;
            struct sockaddr sa;
            int sock;
            int j, number;
            if (argc != 6)
            {
                    die(usage);
            }
            sock = socket(AF_INET, SOCK_PACKET, htons(ETH_P_RARP));
            if (sock < 0)
            {
                    perror("socket");
                    exit(1);
            }
            number = atoi(argv[5]);
            pkt.frame_type = htons(ARP_FRAME_TYPE);
            pkt.hw_type = htons(ETHER_HW_TYPE);
            pkt.prot_type = htons(IP_PROTO_TYPE);
            pkt.hw_addr_size = ETH_HW_ADDR_LEN;
            pkt.prot_addr_size = IP_ADDR_LEN;
            pkt.op = htons(OP_ARP_QUEST);
            get_hw_addr(pkt.targ_hw_addr, argv[4]);
            get_hw_addr(pkt.rcpt_hw_addr, argv[4]);
            get_hw_addr(pkt.src_hw_addr, argv[2]);
            get_hw_addr(pkt.sndr_hw_addr, argv[2]);
            get_ip_addr(&src_in_addr, argv[1]);
            get_ip_addr(&targ_in_addr, argv[3]);
            memcpy(pkt.sndr_ip_addr, &src_in_addr, IP_ADDR_LEN);
            memcpy(pkt.rcpt_ip_addr, &targ_in_addr, IP_ADDR_LEN);
            bzero(pkt.padding, 18);
            strcpy(sa.sa_data, DEFAULT_DEVICE);
            for (j = 0; j < number; j++)
            {
                    if (sendto(sock, &pkt, sizeof(pkt), 0, &sa, sizeof(sa)) < 0)
                    {
                            perror("sendto");
                            exit(1);
                    }
            }
            exit(0);
    }
    
    
    void die(char* str)
    {
            fprintf(stderr, "%s\n", str);
            exit(1);
    }
    
    
    void get_ip_addr(struct in_addr* in_addr, char* str)
    {
            struct hostent* hostp;
            in_addr->s_addr = inet_addr(str);
            if (in_addr->s_addr == -1)
            {
                    if ((hostp = gethostbyname(str)))
                    {
                            bcopy(hostp->h_addr, in_addr, hostp->h_length);
                    }
                    else
                    {
                            fprintf(stderr, "send_arp: unknown host %s\n", str);
                            exit(1);
                    }
            }
    }
    
    
    void get_hw_addr(char* buf, char* str)
    {
            int i;
            char c, val;
            for (i = 0; i < ETH_HW_ADDR_LEN; i++)
            {
                    if (!(c = tolower(*str++)))
                    {
                            die("Invalid hardware address");
                    }
                    if (isdigit(c))
                    {
                            val = c - '0';
                    }
                    else if (c >= 'a' && c <= 'f')
                    {
                            val = c - 'a' + 10;
                    }
                    else
                    {
                            die("Invalid hardware address");
                    }
                    *buf = val << 4;
                    if (!(c = tolower(*str++)))
                    {
                            die("Invalid hardware address");
                    }
                    if (isdigit(c))
                    {
                            val = c - '0';
                    }
                    else if (c >= 'a' && c <= 'f')
                    {
                            val = c - 'a' + 10;
                    }
                    else
                    {
                            die("Invalid hardware address");
                    }
                    *buf++ |= val;
                    if (*str == ':')
                    {
                            str++;
                    }
            }
    }

[ARP协议的c语言实现源代码][ARP_c]

#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"
    #define device  "eth0"
    #define fill_buf "aaaaaaaaaaaa"
    int socket_id;
    char *target = src_addr;
    int send_count = 0;
    int recv_count = 0;
    struct in_addr  src, dst;
    struct sockaddr_ll   me,  he;
    struct timeval   send_time, recv_time;
    struct in_addr get_src_ip(char * devices)
    {
    struct sockaddr_in saddr;
    int sock_id = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_id < 0) {
      perror("socket");
      exit(2);
    }
    if (devices) {
          if (setsockopt(sock_id, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device)+1) == -1)
       perror("WARNING: interface is ignored");
    }
    int alen = sizeof(saddr);
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_port = htons(0x1000);
    saddr.sin_family = AF_INET; 
    if (connect(sock_id, (struct sockaddr*)&saddr, sizeof(saddr)) == -1) {
      perror("connect");
      exit(2);
    }
    if (getsockname(sock_id, (struct sockaddr*)&saddr, &alen) == -1) {
      perror("getsockname");
      exit(2);
    }
    close(sock_id);
    return saddr.sin_addr;
    }
    int check_device(char* if_dev, int ss)
    {
    int ifindex;
    struct ifreq ifr;
    memset(&ifr, 0, sizeof(ifr));
    strncpy(ifr.ifr_name, if_dev, IFNAMSIZ-1);
      if (ioctl(ss, SIOCGIFINDEX, &ifr) < 0) {
       fprintf(stderr, "arping: unknown iface %s\n", if_dev);
       exit(2);
      }
      ifindex = ifr.ifr_ifindex;
      if (ioctl(ss, SIOCGIFFLAGS, (char*)&ifr)) {
       perror("ioctl(SIOCGIFFLAGS)");
       exit(2);
      }
      if (!(ifr.ifr_flags&IFF_UP)) {
        printf("Interface \"%s\" is down\n", if_dev);
       exit(2);
      }
      if (ifr.ifr_flags&(IFF_NOARP|IFF_LOOPBACK)) {
        printf("Interface \"%s\" is not ARPable\n", if_dev);
       exit(2);
      }
    return ifindex;
    } // check_device()
    int socket_init()
    {
    int s,  s_errno;
    s = socket(PF_PACKET,  SOCK_DGRAM,  0);
    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)) == -1) {
      perror("bind");
      exit(2); 
    }
    int alen = sizeof(me);
    if (getsockname(s, (struct sockaddr*)&me, &alen) == -1) {
      perror("getsockname");
      exit(2);
    }
    if (me.sll_halen == 0) {
      printf("Interface \"%s\" is not ARPable (no ll address)\n", device);
      exit(2);
    }
    he = me;
    memset(he.sll_addr, -1, 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+1);
    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 = 4;
    ah->ar_op  =  htons(ARPOP_REQUEST);
    memcpy(p, &FROM->sll_addr, ah->ar_hln);
    p+=FROM->sll_halen;
    memcpy(p, &src, 4);
    p+=4;
    memcpy(p, &TO->sll_addr, ah->ar_hln);
    p+=ah->ar_hln;
    memcpy(p, &dst, 4);
    p+=4;
    memcpy(p, fill_buf, strlen(fill_buf) );
    p+=12;
    return  (p-buf);
    }
    void send_pkt()
    {
    unsigned char send_buf[256];
    int pkt_size = create_pkt(send_buf,  src,  dst,  &me,  &he);
    gettimeofday(&send_time, NULL); 
    int cc = sendto(socket_id, send_buf, pkt_size, 0, (struct sockaddr*)&he, sizeof(he));
    if( cc == pkt_size )
      send_count++; 
    alarm(1);
    }
    int chk_recv_pkt(unsigned char * buf, struct sockaddr_ll * FROM)
    {
    struct arphdr *ah = (struct arphdr*)buf;
    unsigned char *p = (unsigned char *)(ah+1);
    struct in_addr src_ip, dst_ip;
    if (ah->ar_op != htons(ARPOP_REQUEST) &&  ah->ar_op != htons(ARPOP_REPLY))
      return 0;
    if (ah->ar_pro != htons(ETH_P_IP) || ah->ar_pln != 4 || ah->ar_hln != me.sll_halen )
      return 0;
    memcpy(&src_ip, p+ah->ar_hln, 4);
    memcpy(&dst_ip, p+ah->ar_hln+4+ah->ar_hln, 4);
    if (src_ip.s_addr != dst.s_addr || src.s_addr != dst_ip.s_addr )
      return 0;
    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[0], from.sll_addr[1], \
      from.sll_addr[2], from.sll_addr[3], from.sll_addr[4], from.sll_addr[5]);   
    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+1) != NULL )
      target = *(argv+1);
    if (inet_aton(target, &dst) != 1) {
      struct hostent *hp;
      hp = gethostbyname2(target, AF_INET);
      printf("\ntarget = %s \n", target );
      if (!hp) {
       fprintf(stderr, "arping: unknown host %s\n", target);
       exit(2);
      }
      memcpy(&dst, hp->h_addr, 4);
    }
    src =  get_src_ip(device);
    if (!src.s_addr ) {
      fprintf(stderr, "arping: no source address in not-DAD mode\n");
      exit(2);
    }
    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(1)
    {
      struct sockaddr_ll from;
      int alen = sizeof(from);
      char recv_buf[0x1000];
     
      int recv_size = recvfrom(socket_id, recv_buf,  sizeof(recv_buf), 0,  (struct sockaddr *)&from, &alen );
     
      gettimeofday(&recv_time, NULL); 
      if( recv_size < 0 ) {
       perror("arping: recvfrom");
       continue;
      }
      if( chk_recv_pkt(recv_buf, &from) > 0 ) {
       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) * 1000000 + recv_time.tv_usec - send_time.tv_usec;
        msecs = (usecs+500)/1000;
        usecs -= msecs*1000 - 500;
       }   
       recv_count++;
       disp_info(recv_count,  dst,  msecs,  usecs,  from);     
      } // if (chk...)   
     
    }
    return 0;
    }

# [免费ARP简单介绍和程序编写 ][ARP_] #

免费ARP，在网络上有很多的介绍。在《tcp/ip协议卷》中的第四章也有介绍，下面再啰嗦一下介绍其作用和操作：

免费ARP，主要用于检测网络中IP地址是否冲突，它是一种功能而非协议。当设备重启或代理ARP功能开启时就会向本地网络主动发免费ARP以检测IP地址是否冲突。免费ARP是以源、目的IP都是自己，源MAC也是自己，目标MAC是广播，即向自己所在网络请求自己的MAC地址，当网络中如果有其他主机使用了与自己相同的IP地址，他就会给主机一个ARP回复，此时如果发免费ARP的主机收到了回复就证明自己所用的IP地址有冲突，如果没有收到回复则说明没有IP地址冲突。

（若上面的文字有雷同，则以别人的文章为主；若有版权请告知我，本人会在24小时撤掉，谢谢~~~）

下面是免费ARP的代码，作为一个参考吧：

**\[cpp\]** [ view plain][view plain] [copy][view plain]

1.  /
2.  // 文件名： arp\_func.c
3.  // 作者： cfjtaishan
4.  // 版本： 1.0
5.  // 日期： 2013-05-14
6.  // 描述： 免费ARP--用于检测IP地址是否冲突.
7.  // 历史记录：
8.  /
9.  
10. 
11. \#include <stdio.h>
12. \#include <stdlib.h>
13. \#include <string.h>
14. \#include <errno.h>
15. \#include <sys/types.h>
16. \#include <sys/socket.h>
17. \#include <linux/if\_packet.h>
18. \#include <netdb.h>
19. \#include <unistd.h>
20. \#include <arpa/inet.h>
21. \#include <sys/ioctl.h>
22. \#include <net/ethernet.h>
23. \#include <netinet/ether.h>
24. \#include <net/if.h>
25. \#include <netinet/ip.h>
26. 
27. \#define FAILURE -1
28. \#define SUCCESS 0
29. 
30. unsigned char src\_ip\[4\] = \{ 192, 168, 9, 118 \}; //要检测的主机IP地址
31. unsigned char src\_mac\[6\] = \{0x00, 0x0c, 0x29, 0x4b, 0x6c, 0x13\}; //要检测的主机的MAC地址
32. unsigned char dst\_ip\[4\] = \{ 192, 168, 9, 118 \}; //目标IP地址
33. unsigned char dst\_mac\[6\] = \{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff \}; //ARP广播地址
34. 
35. int send\_arp(int sockfd, struct sockaddr\_ll \*peer\_addr);
36. int recv\_arp(int sockfd, struct sockaddr\_ll \*peer\_addr);
37. 
38. //ARP封装包
39. typedef struct \_tagARP\_PACKET\{
40. struct ether\_header eh;
41. struct ether\_arp arp;
42. \}ARP\_PACKET\_OBJ, \*ARP\_PACKET\_HANDLE;
43. 
44. int main(int argc, char \*argv\[\])
45. \{
46. int sockfd;
47. int rtval = -1;
48. struct sockaddr\_ll peer\_addr;
49. //创建socket
50. sockfd = socket(AF\_PACKET, SOCK\_RAW, htons(ETH\_P\_ARP));
51. if (sockfd < 0)
52. \{
53. fprintf(stderr, "socket error: %s\\n", strerror(errno));
54. exit(EXIT\_FAILURE);
55. \}
56. 
57. memset(&peer\_addr, 0, sizeof(peer\_addr));
58. peer\_addr.sll\_family = AF\_PACKET;
59. struct ifreq req;
60. bzero(&req, sizeof(struct ifreq));
61. strcpy(req.ifr\_name, "eth0");
62. if(ioctl(sockfd, SIOCGIFINDEX, &req) != 0)
63. perror("ioctl()");
64. peer\_addr.sll\_ifindex = req.ifr\_ifindex;
65. peer\_addr.sll\_protocol = htons(ETH\_P\_ARP);
66. //peer\_addr.sll\_family = AF\_PACKET;
67. while (1)
68. \{
69. rtval = send\_arp(sockfd, &peer\_addr);
70. if (FAILURE == rtval)
71. \{
72. fprintf(stderr, "Send arp socket failed: %s\\n", strerror(errno));
73. \}
74. rtval = recv\_arp(sockfd, &peer\_addr);
75. if (rtval == SUCCESS)
76. \{
77. printf ("Get packet from peer and IP conflicts!\\n");
78. \}
79. else if (rtval == FAILURE)
80. \{
81. fprintf(stderr, "Recv arp IP not conflicts: %s\\n", strerror(errno));
82. \}
83. else
84. \{
85. fprintf(stderr, "Recv arp socket failed: %s\\n", strerror(errno));
86. \}
87. //sleep(1);
88. \}
89. return 0;
90. \}
91. //
92. // 函数名: send\_arp 
93. // 描述 : 填充ARP数据包报文并发送出去。
94. // 参数: 
95. // \[in\] sockfd -- 创建的socket描述符;
96. // \[in\] peer\_addr -- 对端的IP信息
97. // 返回值: 
98. // 成功: SUCCESS, 失败: FAILURE;
99. // 说明: 
100. //
101. int send\_arp(int sockfd, struct sockaddr\_ll \*peer\_addr)
102. \{
103. int rtval;
104. ARP\_PACKET\_OBJ frame;
105. memset(&frame, 0x00, sizeof(ARP\_PACKET\_OBJ));
106. 
107. //填充以太网头部
108. memcpy(frame.eh.ether\_dhost, dst\_mac, 6); //目的MAC地址
109. memcpy(frame.eh.ether\_shost, src\_mac, 6); //源MAC地址
110. frame.eh.ether\_type = htons(ETH\_P\_ARP); //协议 
111. 
112. //填充ARP报文头部
113. frame.arp.ea\_hdr.ar\_hrd = htons(ARPHRD\_ETHER); //硬件类型 
114. frame.arp.ea\_hdr.ar\_pro = htons(ETHERTYPE\_IP); //协议类型 ETHERTYPE\_IP | ETH\_P\_IP
115. frame.arp.ea\_hdr.ar\_hln = 6; //硬件地址长度
116. frame.arp.ea\_hdr.ar\_pln = 4; //协议地址长度
117. frame.arp.ea\_hdr.ar\_op = htons(ARPOP\_REQUEST); //ARP请求操作
118. memcpy(frame.arp.arp\_sha, src\_mac, 6); //源MAC地址
119. memcpy(frame.arp.arp\_spa, src\_ip, 4); //源IP地址
120. memcpy(frame.arp.arp\_tha, dst\_mac, 6); //目的MAC地址
121. memcpy(frame.arp.arp\_tpa, dst\_ip, 4); //目的IP地址
122. 
123. rtval = sendto(sockfd, &frame, sizeof(ARP\_PACKET\_OBJ), 0,
124. (struct sockaddr\*)peer\_addr, sizeof(struct sockaddr\_ll));
125. if (rtval < 0)
126. \{
127. return FAILURE;
128. \}
129. return SUCCESS;
130. \}

**\[cpp\]** [ view plain][view plain] [copy][view plain]

1.  //
2.  // 函数名: recv\_arp 
3.  // 描述 : 接收ARP回复数据报文并判断是不是对免费ARP的回复。
4.  // 参数: 
5.  // \[in\] sockfd -- 创建的socket描述符;
6.  // \[in\] peer\_addr -- 对端的IP信息
7.  // 返回值: 
8.  // 成功: SUCCESS, 失败: FAILURE;
9.  // 说明: 
10. // 若是对免费arp请求的回复则返回:SUCCESS.
11. //
12. int recv\_arp(int sockfd, struct sockaddr\_ll \*peer\_addr)
13. \{
14. int rtval;
15. ARP\_PACKET\_OBJ frame;
16. 
17. memset(&frame, 0, sizeof(ARP\_PACKET\_OBJ));
18. rtval = recvfrom(sockfd, &frame, sizeof(frame), 0,
19. NULL, NULL);
20. //判断是否接收到数据并且是否为回应包
21. if (htons(ARPOP\_REPLY) == frame.arp.ea\_hdr.ar\_op && rtval > 0)
22. \{
23. //判断源地址是否为冲突的IP地址
24. if (memcmp(frame.arp.arp\_spa, src\_ip, 4) == 0)
25. \{
26. fprintf(stdout, "IP address is common~\\n");
27. return SUCCESS;
28. \}
29. \}
30. if (rtval < 0)
31. \{
32. return FAILURE;
33. \}
34. return FAILURE;
35. \}

该程序可以测试局域网中的某个IP地址是否有冲突的，以便于确定该地址是否可以作为本机的IP地址。下面是通过wireshark抓到了免费的ARP数据包，以及回应包，如下： ![20130515133730754][]

[ARP_c]: http://blog.chinaunix.net/uid-13703776-id-67853.html
[ARP_]: http://blog.csdn.net/cfjtaishan/article/details/8929718
[view plain]: http://blog.csdn.net/cfjtaishan/article/details/8929718#
[20130515133730754]: /images/20220805/1c165d0a6f4e45b3b40b03c03d75a4f8.png