基于winpcap的网络mac地址发现

arp数据包格式：



主要文件有：

datastruct.h 存储数据包格式的数据结构

transfunc.h 发送arp的封装函数声明

transfunc.cpp 定义

Winpcap_arp.cpp main函数

datastruct.h

#ifndef HEADERSTRUCT_H
#define HEADERSTRUCT_H

// ip地址
typedef struct ip_address
{
unsigned char byte1;
unsigned char byte2;
unsigned char byte3;
unsigned char byte4;
}ip_address;

// ipv4首部
typedef struct ip_header
{
unsigned char ver_ihl;  // 版本和首部长度各占4位，长度是4位数据乘以4，所以首部长度最长是60字节
unsigned char tos;      // 区分服务
unsigned short tlen;    // 总长度
unsigned short identification;  // 标识
unsigned short flags_fo;    // 标志 和 片偏移
unsigned char ttl;          // 生存时间
unsigned char proto;        // 协议
unsigned short crc;         // 首部检验和
ip_address saddr;           // 源地址
ip_address daddr;           // 目的地址
unsigned int op_pad;        // 可选字段 + 填充
}ip_header;

// udp首部
typedef struct udp_header
{
unsigned short sport;
unsigned short dport;
unsigned short len;
unsigned short crc;
}udp_header;

// arp数据包中的帧头
typedef struct ether_header
{   // 注意：类型字段需要转为网络字节序
char etherdaddr[6];   // 以太网目的地址
char ethersaddr[6];   // 以太网源地址
unsigned short etherflametype;  // 以太网帧类型，0x0806是arp,0x0800是IP
}ether_header;

//
// arp 头部
#pragma pack(push, 1)
// c struct 编译层面字节对齐，编译器做，根据数据类型进行对齐，通过pack设置
typedef struct arp_header
{   // 注意：类型字段 和 操作码均需要转为网络字节序
unsigned short hardtype;   // 硬件类型，如以太网为1
unsigned short prototype;   // 协议类型,如ip 是0x0800
unsigned char hardaddrlen;  // 硬件地址长度(6)
unsigned char protoaddrlen; //协议地址长度，ip为4
unsigned short operate;     // 操作字段，1为arp请求，2为arp应答
char sendetheraddr[6]; // 发送端以太网地址
unsigned long sendipaddr;       // 发送端ip地址
char destetheraddr[6];    // 接收端以太网地址
unsigned long destipaddr;       // 接收端ip地址
}arp_header/*__attribute__((aligned(1))) or __attribute__((pack)) 都是设置1字节对齐*/;
#pragma pack(pop)
//

// 值得注意的是，MSVN编译器编译结果中，两个struct并非按声明顺序在内存中存放，
// 而且，两个struct地址并不连续
typedef struct arp_packet
{
struct ether_header etherheader;
struct arp_header arpheader;
}arp_packet;

#endif // HEADERSTRUCT_H

transfunc.cpp

#include "stdafx.h"

#include "transfunc.h"

void arp_handler(unsigned char*param,                   // 对应pcap_loop / pcap_dispatch 的参数
const struct pcap_pkthdr *header,      //winpcap 生成的一个头
const unsigned char *pkt_data)         // 数据包
{   // 代解决：解析响应得arp 数据包
struct arp_packet arp;
memcpy(&arp.etherheader, pkt_data, 14);
memcpy(&arp.arpheader, pkt_data + 14, 28);
//struct ip_address *ipaddr = (struct ip_address *)(static_cast<void *>(&(arp->arpheader.sendipaddr)));

unsigned char mac[6];
for (int index = 0; index < 6; ++index)
{
mac[index] = arp.etherheader.ethersaddr[index];
}
unsigned long sendip = arp.arpheader.sendipaddr;
struct ip_address *ipaddr = static_cast<struct ip_address *>((void *)&sendip);
// 注意，这里会看到输出mac 为全0，因为我在BroadArp函数里广播了一个arp包，
// 曾发送一个源mac为全零的arp，估计现在收到了

// 后来正确了，那是arp系统自动发的包（不是我触发的），我抓取到了
if (arp.etherheader.etherflametype == htons(0x0806))
printf("ip: %d.%d.%d.%d -> MAC:%.2x-%.2x-%.2x-%.2x-%.2x-%.2x\n",
ipaddr->byte1, ipaddr->byte2, ipaddr->byte3, ipaddr->byte4,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

}
// 问：为什么需要网络字节序？
void BroadcastArp(pcap_t *handle, pcap_if_t *dev)
{
struct arp_packet arp;
char mac[6];
if (dev->addresses->addr->sa_family == AF_INET6)
dev->addresses = dev->addresses->next;

if (
GetSelfMac(handle,
inet_ntoa(((struct sockaddr_in *)(dev->addresses->addr))->sin_addr),
mac)
< 0)
{
fprintf(stderr, "GetSelfMac error\n");
exit(-1);
}

bpf_u_int32 broadip = 0;

//    inet_addr 得到的正数解析出的地址顺序相反，就是说传输中的Ip是按照反序（8bit为一段）存储的
//    如192.168.1.107,则在整数的存储方式为 (((107*256 + 1)*256)+168)*256 + 192
broadip = ((struct sockaddr_in *)(dev->addresses->broadaddr))->sin_addr.S_un.S_addr;
//    printf("1.%u\n", broadip);

//初始化以太网头部
memset(arp.etherheader.etherdaddr, 0xff, 6); // 广播MAC地址

strncpy(arp.etherheader.ethersaddr, mac, 6);
arp.etherheader.etherflametype = htons(0x0806); // 0x8060是arp
//初始化arp头， 请求时，arp_header里的mac地址可以是任意值，不受影响
arp.arpheader.hardtype = htons(1);
arp.arpheader.prototype = htons(0x0800); // 0x0800是ip
arp.arpheader.hardaddrlen = 6;
arp.arpheader.protoaddrlen = 4;
arp.arpheader.operate = htons(1); // 1是arp请求,2是arp应答
strncpy(arp.arpheader.sendetheraddr, arp.etherheader.ethersaddr, 6);
// 任意值
memset(arp.arpheader.destetheraddr, 0xff, 6);
arp.arpheader.sendipaddr = ((struct sockaddr_in *)(dev->addresses->addr))->sin_addr.S_un.S_addr;
// 这里broadip 是255.255.255.255（全网广播IP来的），用wireshark发现提示，谁是255.255.255.255 ，请告诉上面设置的sendipaddr
arp.arpheader.destipaddr = broadip;
// 发送arp数据包

unsigned char *buf = (unsigned char *)malloc(42);
memset(buf, 0, 42);
memcpy(buf, &(arp.etherheader), sizeof(arp.etherheader));
memcpy(buf + sizeof(arp.etherheader), &(arp.arpheader), sizeof(arp.arpheader));
// fatal bad memory block!!!
if (pcap_sendpacket(handle, buf, 42) < 0)
{
fprintf(stderr, "pacap_sendpacket error\n");
exit(-1);
}
free(buf);
}
int GetSelfMac(pcap_t *adhandle, const char *ip_addr, char *ip_mac)
{
//
unsigned char sendbuf[42]; //arp包结构大小
int i = -1;
int res;
ether_header eh; //以太网帧头
arp_header ah;  //ARP帧头
struct pcap_pkthdr * pkt_header;
const u_char * pkt_data;
//将已开辟内存空间 eh.dest_mac_add 的首 6个字节的值设为值 0xff。
memset(eh.etherdaddr, 0xff, 6); //目的地址为全为广播地址
// 以以太网源地址为0发送arp, 接收端网卡接收到无端的arp，就发送一个包含自己mac地址的arp
// 到”无端“的ip对应的主机，
memset(eh.ethersaddr, 0x00, 6);

// 当有源mac地址则是正式的arp请求
// arpheader里的以太网地址没用
memset(ah.destetheraddr, 0xff, 6);
memset(ah.sendetheraddr, 0x00, 6);
//htons将一个无符号短整型的主机数值转换为网络字节顺序
eh.etherflametype = htons(0x0806);
ah.hardtype = htons(0x0001);
ah.prototype = htons(0x0800);
ah.hardaddrlen = 6;
ah.protoaddrlen = 4;
ah.sendipaddr = inet_addr(ip_addr); //随便设的请求方ip
ah.operate = htons(0x0001);
// 如果是192.168.223.255, 则是提高这个地址是谁的，因为这是个广播地址
// 是否什么错误？（vmnet8 的测试），xxx.1则是gratuitous（无端的）请求，来自xxx.1
ah.destipaddr = inet_addr(ip_addr);
printf("sizeof(eh) = %d \t sizeof(ah) = %d\n", sizeof(eh), sizeof(ah));
memset(sendbuf, sizeof(sendbuf), 0);
memcpy(sendbuf, &eh, sizeof(eh));
memcpy(sendbuf + sizeof(eh), &ah, sizeof(ah));
///	printf("%s", sendbuf);
if (pcap_sendpacket(adhandle, sendbuf, 42) == 0) {
printf("\nPacketSend succeed\n");
}
else {
printf("PacketSendPacket in getmine Error: %d\n", GetLastError());
return 0;
}
//从interface或离线记录文件获取一个报文
//pcap_next_ex(pcap_t* p,struct pcap_pkthdr** pkt_header,const u_char** pkt_data)
int count = 0;
while ((res = pcap_next_ex(adhandle, &pkt_header, &pkt_data)) >= 0) {
if (*(unsigned short *)(pkt_data + 12) == htons(0x0806)
&& *(unsigned short*)(pkt_data + 20) == htons(0x0002)
&& *(unsigned long*)(pkt_data + 28)
== inet_addr(ip_addr)) {
for (i = 0; i < 6; i++) {
ip_mac[i] = *(unsigned char *)(pkt_data + 22 + i);
}
// 为什么会输出很多ffff
printf("MAC:%2.2x.%2.2x.%2.2x.%2.2x.%2.2x.%2.2x\t", ip_mac[0], ip_mac[1], ip_mac[2], ip_mac[3], ip_mac[4],
ip_mac[5]);
printf("Get mac success !\n");
break;
}
}
if (i == 6) {
return 1;
}
else {
return -1;
}
}

// 网上有这个方法，只是我调用时总是打开适配器的函数出错
int GetMacAddress(char* source, char* mac_buf)
{
LPADAPTER lpAdapter;
PPACKET_OID_DATA  OidData;
BOOLEAN status;

lpAdapter = PacketOpenAdapter(source);

if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
{
printf("error : %d\n", GetLastError());
return -1;
}

OidData = (PPACKET_OID_DATA)malloc(6 + sizeof(PACKET_OID_DATA));
if (OidData == NULL)
{
return 0;
}

OidData->Oid = 0x01010102;//OID_802_3_CURRENT_ADDRESS;
OidData->Length = 6;
ZeroMemory(OidData->Data, 6);

status = PacketRequest(lpAdapter, FALSE, OidData);
if (!status)
{
return -1;
}

memcpy((void *)mac_buf, (void *)OidData->Data, 6);

printf("The MAC address of the adapter is %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
(PCHAR)(OidData->Data)[0],
(PCHAR)(OidData->Data)[1],
(PCHAR)(OidData->Data)[2],
(PCHAR)(OidData->Data)[3],
(PCHAR)(OidData->Data)[4],
(PCHAR)(OidData->Data)[5]);

free(OidData);
PacketCloseAdapter((LPADAPTER)source);

return 1;
}

char *ip6toa(struct sockaddr *sockaddr, char *address, int addrlen)
{
socklen_t sockaddrlen;
#ifdef WIN32
sockaddrlen = sizeof(struct sockaddr_in6);
#else
sockaddrlen = sizeof(struct sockaddr_storage);
#endif
if (getnameinfo(sockaddr, sockaddrlen, address, addrlen, NULL,
0, NI_NUMERICHOST) != 0)
address[0] = '\0';
return address;
}

winpcap_arp.cpp

// Winpcap_arp.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
// 为remote***.h 头文件
#ifndef HAVE_REMOTE
#define HAVE_REMOTE
#endif

#include "pcap.h"
#include "remote-ext.h"
#include <winsock.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include "datastruct.h"
#include "transfunc.h"

#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "Packet.lib")
#pragma comment(lib, "Ws2_32.lib")

int _tmain(int argc, _TCHAR* argv[])
{
// 设备类型
/*
* struct pcap_if{
* struct pcap_if *next;
* char *name;
* char *description;
* struct pcap_addr *addresses;  设备地址结构
* bpf_u_int32 flags;
* };
*/
pcap_if_t *alldevs = NULL, *onedev = NULL;
/*
* struct pcap_addr{
* struct pcap_addr *next;
* struct sockaddr *addr;
* ...              netmask, broadaddr, dstaddr;
* };
*/
pcap_addr *devsaddr = NULL;
char ip6str[128];
char error[PCAP_ERRBUF_SIZE];
char source[PCAP_BUF_SIZE] = "rpcap://";
int index;

// 获取所有网卡设备
if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &alldevs, error) < 0)
{
fprintf(stderr, "pcap_findalldevs error.\n");
exit(-1);
}
if (alldevs == NULL)
{
printf("No device found\n");
return 0;
}
// 遍历所有获取到的网卡设备
for (onedev = alldevs, index = 1; onedev != NULL; onedev = onedev->next, ++index)
{
printf("(%d)%s", index, onedev->name);
if (onedev->description)
printf("description: %s\n", onedev->description);
else
printf("No description available\n");
if (onedev->flags == PCAP_IF_LOOPBACK)
printf("Lookback device.\n");
devsaddr = onedev->addresses;

for (; devsaddr; devsaddr = devsaddr->next)
{
switch (devsaddr->addr->sa_family)
{   // 1.待解决：解析本地地址等等 2.获取本机适配器mac 地址
case AF_INET:
printf("\tAddress family name : AF_INET\n");
if (devsaddr->addr)
printf("\tAddress : %s\n", inet_ntoa(
((struct sockaddr_in *)(devsaddr->addr))->sin_addr));
if (devsaddr->netmask)
printf("\tAddress netmask : %s\n", inet_ntoa(
((struct sockaddr_in *)(devsaddr->netmask))->sin_addr));
if (devsaddr->broadaddr)
printf("\tAddress broadcast : %s\n", inet_ntoa(
((struct sockaddr_in *)(devsaddr->broadaddr))->sin_addr));
if (devsaddr->dstaddr)
printf("\tAddress destination : %s\n", inet_ntoa(
((struct sockaddr_in *)(devsaddr->dstaddr))->sin_addr));
break;
case AF_INET6:
printf("\tAddress family name : AF_INET6\n");
if (devsaddr->addr)
{
//                    memset(ip6str, 0, sizeof(ip6str));
//                    ip6toa(devsaddr->addr, ip6str, sizeof(ip6str));
//                    printf("\tAddress : %s\n", ip6str);
}
break;
default:
printf("\tAddress family no found\n");
break;

}
}
printf(("-----------------------------------sperator-------------------------------------\n"));
}

// 选择监控的设备
reenter:
printf("Enter which interface[1,%d] you want to scrap:", index - 1);
int which, iindex;
scanf("%d", &which);
if (which < 1 || which > index - 1)
{
printf("enter error\n");
goto reenter;
}
for (onedev = alldevs, iindex = 1; iindex <= index - 1; ++iindex, onedev = onedev->next)
{
if (iindex == which)
{
break;
}
}
if (iindex == index)
{
fprintf(stderr, "Find device error\n");
exit(-1);
}
pcap_t *capHandle = NULL;

// 打开设备
if ((capHandle = pcap_open_live(onedev->name,
65536,   // 最大数据包长度
1,  // PCAP_OPENFLAG_PROMISCUOUS，1为混杂模式
1000,  // 超时时间，单位毫秒。注意：
// pcap_loop 不会因为超时而返回，直到当cnt（pcap_loop第二个参数）
// 个数据包被捕获后才返回，pcap_dispatch则因超时会返回。
NULL   // error buf
)) == NULL)
{
fprintf(stderr, "pcap_open error\n");
pcap_freealldevs(alldevs);
exit(-1);
}

// 返回链路层的类型，如以太网/wifi 。。等等不同的帧格式对应的类型
if (pcap_datalink(capHandle) != DLT_EN10MB)
{
fprintf(stderr, "pcap_datalink error\n");
pcap_freealldevs(alldevs);
exit(-1);
}

// 问题：整形数据怎么和ip,掩码等等转换？
struct bpf_program fcode;
char packet_filter[] = "arp";   // or / and / not / src 192.168.1.x / 等等布尔表达式树

bpf_u_int32 mask; //掩码

if (onedev->addresses->addr->sa_family == AF_INET6)
onedev->addresses = onedev->addresses->next;

// 网络字节序是大端，一般电脑是小端字节序（针对long 和 short 等控制字段要注意字节序）
if (onedev)
mask = ((struct sockaddr_in *)(onedev->addresses->netmask))->sin_addr.S_un.S_addr;
else
mask = 0xffffff;

// 将packet_filter 字符串表达式转换成过滤结构
// int pcap_compile(pcap_t *p, struct bpf_program *fp,char *str, int optimize, bpf_u_int32 netmask)
if (pcap_compile(capHandle, &fcode, packet_filter, 1, mask) < 0)
{
fprintf(stderr, "pcap_compile error\n");
pcap_freealldevs(alldevs);
exit(-1);
}
// 设置过滤
if (pcap_setfilter(capHandle, &fcode) < 0)
{
fprintf(stderr, "pcap_setfilter error\n");
pcap_freealldevs(alldevs);
exit(-1);
}

// 广播arp数据包
BroadcastArp(capHandle, onedev);

printf("\nListening on %s ...\n", onedev->description);

// pcap_breakloop ， 设置标志，强制使pcap_loop , pcap_dispatch 返回，不继续循环
// pcap_loop 不会因为超时而返回，直到当cnt个数据包被捕获后才返回，pcap_dispatch则因超时会返回。
// 第二个参数为-1表示无限捕获
pcap_loop(capHandle, -1, arp_handler, NULL);
// pcap_next_ex 可用易于并发的读取帧

//释放资源
pcap_freealldevs(alldevs);

return 0;
}