发现局域网所有主机

迈不过友情╰ 2022-07-18 04:20 243阅读 0赞

遇到问题：

1。接入一个不知道网段网段的局域网；

2。需要发现局域网的所有的ip；

处理步骤

1。用原始套接字，监听arp消息，获取接口的mac地址；

2。根据收到的arp广播，可以从arp协议的sip字段，提取出源ip；

3。根据ip地址，然后掩码上24位，然后发送从1 ~255的地址的arp 广播；

4。通过收到的arp repy 来获取所有的局域网地址；

5。如果收到了新的ip地址24位掩码。不等于原来保持的ip地址24位掩码，掩码就变成16位；然后发送65535个报文；（猜想掩码位16位做处理）

![Center][]

下面代码是参考，需要用我个人封装好的libevent库才可以运行，如果需要可以联系我~~

#include <unistd.h>
    #include <errno.h>
    #include <netdb.h>
    #include <signal.h>
    #include <sys/socket.h>
    #include <sys/poll.h>
    #include <sys/ioctl.h>
    #include <netinet/if_ether.h>
    #include <net/if_arp.h>
    #include <netinet/udp.h>
    #include <netinet/ip.h>
    #include <stdio.h>
    #include <stdarg.h>
    #include <net/if.h>
    #include <string.h>
    #include <arpa/inet.h>
    #include <map>
    #include <iostream>
    
    #include <fcntl.h>
    using namespace std;
    #include "cneos_event.h"
    enum {
    	ARP_MSG_SIZE = 0x2a
    };
    typedef map<int, string> ARP;
    
    ARP arp_table;
    
    #define MASK_16 0xffff0000
    #define MASK_24 0xffffff00
    int network=0;
    uint32_t sip;
    uint8_t smac[6];
    
    char interface[] = "eno16777984"; 	
    
    
    
    char* strncpy_IFNAMSIZ(char *dst, const char *src)
    {
    #ifndef IFNAMSIZ
    	enum { IFNAMSIZ = 16 };
    #endif
    	return strncpy(dst, src, IFNAMSIZ);
    }
    
    struct arpMsg {
        /* Ethernet header */
    	uint8_t h_dest[6]; /* 00 destination ether addr */
    	uint8_t h_source[6]; /* 06 source ether addr */
    	uint16_t h_proto; /* 0c packet type ID field */
    
    	    /* ARP packet */
    	uint16_t htype; /* 0e hardware type (must be ARPHRD_ETHER) */
    	uint16_t ptype; /* 10 protocol type (must be ETH_P_IP) */
    	uint8_t hlen; /* 12 hardware address length (must be 6) */
    	uint8_t plen; /* 13 protocol address length (must be 4) */
    	uint16_t operation; /* 14 ARP opcode */
    	uint8_t sHaddr[6]; /* 16 sender's hardware address */
    	uint8_t sInaddr[4]; /* 1c sender's IP address */
    	uint8_t tHaddr[6]; /* 20 target's hardware address */
    	uint8_t tInaddr[4]; /* 26 target's IP address */
    	uint8_t pad[18]; /* 2a pad for min. ethernet payload (60 bytes) */
    } PACKED;
    const int const_int_1 = 1;
    
    //设置套接子为广播
    int setsockopt_broadcast(int fd)
    {
    	return setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &const_int_1, sizeof(const_int_1));
    }
    
    char* safe_strncpy(char *dst, const char *src, size_t size)
    {
    	if (!size) return dst;
    	dst[--size] = '\0';
    	return strncpy(dst, src, size);
    }
    int set_socket_bloking(int socket)
    {
    	int flags = fcntl(socket, F_GETFL, 0); 
    	fcntl(socket, F_SETFL, flags & ~O_NONBLOCK);
    }
    
    
    //发送ARP请求
    int arpping(int s,uint32_t test_ip, uint32_t from_ip)
    {
    	int timeout_ms;
    
    	int rv = 1; /* "no reply received" yet */
    	struct sockaddr addr; /* for interface name */
    	struct arpMsg arp;
       
        //构造ARP数据包
        /* send arp request */
    	memset(&arp, 0, sizeof(arp));
    	memset(arp.h_dest, 0xff, 6); /* MAC DA */
    	memcpy(arp.h_source, smac, 6); /* MAC SA */
    	arp.h_proto = htons(ETH_P_ARP); /* protocol type (Ethernet) */
    	arp.htype = htons(ARPHRD_ETHER); /* hardware type */
    	arp.ptype = htons(ETH_P_IP); /* protocol type (ARP message) */
    	arp.hlen = 6; /* hardware address length */
    	arp.plen = 4; /* protocol address length */
    	arp.operation = htons(ARPOP_REQUEST); /* ARP op code */
    	memcpy(arp.sHaddr, smac, 6); /* source hardware address */
    	memcpy(arp.sInaddr, &from_ip, sizeof(from_ip)); /* source IP address */
    	/* tHaddr is zero-fiiled */ /* target hardware address */
    	memcpy(arp.tInaddr, &test_ip, sizeof(test_ip)); /* target IP address */
       //构造目标网络地址
    	memset(&addr, 0, sizeof(addr));
    	safe_strncpy(addr.sa_data, interface, sizeof(addr.sa_data));
    	//set_socket_bloking(s);
    	
    	int try_count = 0;
    	while (sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0)
    	{
    		printf("send to error\n");
    		try_count++;
    		if (try_count == 1000) break;
    	}
    		
    	return rv;
    }
    
    
    int read_interface(const char *interface, int *ifindex, uint32_t *addr, uint8_t *arp)
    {
    	int fd;
    	struct ifreq ifr;
    	struct sockaddr_in *our_ip;
    
    	memset(&ifr, 0, sizeof(ifr));
    	fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
    
    	ifr.ifr_addr.sa_family = AF_INET;
    	strncpy_IFNAMSIZ(ifr.ifr_name, interface);
    	if (addr) {
    		if (ioctl(fd, SIOCGIFADDR, &ifr) != 0) {
    			perror("ioctl");
    			close(fd);
    			return -1;
    		}
    		our_ip = (struct sockaddr_in *) &ifr.ifr_addr;
    		*addr = our_ip->sin_addr.s_addr;
    		printf("ip of %s = %s \n", interface, inet_ntoa(our_ip->sin_addr));
    	}
    
    	if (ifindex) {
    		if (ioctl(fd, SIOCGIFINDEX, &ifr) != 0) {
    			close(fd);
    			return -1;
    		}
    		printf("adapter index %d", ifr.ifr_ifindex);
    		*ifindex = ifr.ifr_ifindex;
    	}
    
    	if (arp) {
    		if (ioctl(fd, SIOCGIFHWADDR, &ifr) != 0) {
    			close(fd);
    			return -1;
    		}
    		memcpy(arp, ifr.ifr_hwaddr.sa_data, 6);
    		printf("adapter hardware address %02x:%02x:%02x:%02x:%02x:%02x\n",
    			arp[0],arp[1],arp[2],arp[3],arp[4],	arp[5]);
    	}
    	close(fd);
    	return 0;
    }
    
    void ReadEventCb(struct bufferevent *bev, void *data)
    {
    	char buffer[2000];
    	int len = GetReadBuffer(buffer, sizeof(buffer));
    	if (len >= sizeof(struct arpMsg))
    	{
    		struct arpMsg *arp1 = (struct arpMsg *)buffer; 
    		char mac[20];
    		sprintf(mac,"%02x:%02x:%02x:%02x:%02x:%02x",
    			arp1->sHaddr[0],
    			arp1->sHaddr[1],
    			arp1->sHaddr[2],
    			arp1->sHaddr[3],
    			arp1->sHaddr[4],
    			arp1->sHaddr[5]);		
    		//if (arp1->htype == htons(0x0001) && arp1->h_proto == htons(0x0800))
    		int sip = ntohl(((int *)(arp1->sInaddr))[0]);
    		if (sip)
    		{
    		
    			if (sip&MASK_24 != network && arp_table.find(sip) == arp_table.end()) {
    				network = sip >> 8 << 8;	
    				printf("ip of %s %d.%d.%d.%d \n", mac, arp1->sInaddr[0], arp1->sInaddr[1], arp1->sInaddr[2], arp1->sInaddr[3]);
    				for (int i = 1; i < 255; i++)
    				{
    					arpping(bufferevent_getfd(bev), htonl(network + i), htonl(network+254));
    				}
    			}
    			arp_table[sip] = mac;
    
    		}
    	}
    
    }
    
    int main(int argc, char **argv)
    {
    	uint32_t TEST_IP =1||inet_addr(argv[1]);
    		//网卡名字
    
    	read_interface(interface, NULL, &sip, smac); //根据网卡名字读取本地的mac地址和ip地址
    	
    	int arp_fd = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP)); 
    	if (arp_fd <=0 || setsockopt_broadcast(arp_fd) == -1) {
    		perror("cannot enable bcast on raw socket");
    	}
    	evutil_make_socket_nonblocking(arp_fd);
    	AddBuffEvent(arp_fd, ReadEventCb, NULL, NULL,NULL);
    	event_run();
    	
    	return 0;
    }

[Center]: /images/20220717/0ad50e16f08f44948a62eba3551c57ce.png