arp报文及使用go实现

一、ARP协议报文格式及ARP表

ARP（Address Resolution Protocal，地址解析协议）是将IP地址解析为以太网的MAC地址（或者称为物理地址）的协议。在局域网中，当主机或其他网络设备有数据要发送给另一个主机或设备时，它必须知道对方的网络层地址（即IP地址）。但是仅仅有IP地址还是不够的，因为IP数据报文必须封装成帧才能通过物理网络发送，因为发送站还必须有接收站的物理地址，所以需要一个从IP地址到物理地址的映射。ARP就是实现这个功能的协议。

ARP报文

ARP是一个独立的三层协议，所以ARP报文在向数据链路层传输时不需要经过IP协议的封装，而是直接生成自己的报文，其中包括ARP报头，到数据链路层后再由对应的数据链路层协议（如以太网协议）进行封装。ARP报文分为ARP请求和ARP应答报文两种，它们的报文格式可以统一为下图所示。

硬件类型：占两字节，表示ARP报文可以在哪种类型的网络上传输，值为1时表示为以太网地址。
上层协议类型：占两字节，表示硬件地址要映射的协议地址类型，映射IP地址时的值为0x0800
MAC地址长度：占一字节，标识mac地址长度，以字节为单位，此处为6.
IP协议地址长度：占一字节，标识IP地址长度，以字节为单位，此处为4
操作类型：占两字节，指定本次ARP报文类型。1表示arp请求报文，2表示arp应答报文，3表示RARP请求，4表示RARP应答
源MAC地址：占六字节，标识发送设备的硬件地址
源IP地址：占4字节，标识发送方设备的IP地址
目的MAC地址：占六字节，标识接收方设备的硬件地址，在请求报文中该字段全为0，即00-00-00-00-00-00，表示任意地址，因为现在不知道这个地址
目的IP地址：占四字节，表示接收方的IP地址

ARP报文不是直接在网络层上发送的，它还是需要向下传输到数据链路层，所以当ARP报文传输到数据链路层之后，需要再次进行封装。以以太网为例，ARP报文传输到以太网数据链路层后会形成ARP帧。ARP帧如下图所示，他就是在ARP报文前面加了一个以太网帧头

以太网帧头的三个字段说明：

目的MAC地址：占6字节，如果是ARP请求帧，因为它是一个广播帧，所以要填上广播MAC地址（FF-FF-FF-FF-FF-FF），其目标主机是网络上所有主机
源MAC地址：占6字节，这是发送ARP帧的节点MAC地址
帧类型：占两字节，这里用来标识帧封装的上层协议，因为本帧的数据部分是ARP部分，所以直接用ARP的协议号0x0806表示就可以了。

ARP映射表

无论是主机，还是交换机都会有一个用来缓存同一网段设备IP地址和MAC地址的ARP映射表，用于数据帧的转发。设备通过ARP解析到目的MAC之后，将会在自己的ARP映射表中增加IP地址到MAC地址的映射表，以用于后续到同一目的地数据帧的转发。ARP表项分为动态ARP表项和静态ARP表项。

动态ARP表项

动态ARP表项由ARP协议通过ARP报文自动生成和维护，可以被老化，可以被新的ARP报文更新，也可以被静态ARP表项所覆盖。当到达老化时间或接口关闭时会删除相应的动态ARP表项

静态ARP表项

静态ARP表项通过手工配置（通过对应设备的IP地址与MAC地址绑定命定进行）和维护。不会被老化，也不会被动态ARP表项覆盖。配置静态ARP表项可以增加通信的安全性，因为静态ARP可以限定和指定IP地址的设备通信时只使用指定的MAC地址（也就是我们通常所说的IP地址和MAC地址的绑定），此时攻击报文无法修改此表项的IP地址和MAC地址的映射关系，从而保护了本设备和指定设备间正常通信。静态ARP表项又分为短静态ARP表项和长静态ARP表项

短静态ARP表项

在配置短静态ARP表项时，只需要配置IP地址和MAC地址项。如果出接口是三层以太网接口，短静态ARP表项可以直接用于报文转发；如果出接口是VLAN虚接口，短静态ARP表项不能直接用于报文转发，当要发送IP数据包时，先发送ARP请求报文，如果收到的相应报文中的源IP地址和源MAC地址与所配置的IP地址和MAC地址相同，则将接受ARP响应报文的接口加入该静态表项中，之后就可以用于IP数据包的转发了。

长静态ARP表项

在配置长静态ARP表项时，除了配置IP地址和MAC地址项外，还必须配置该ARP表所对应的VLAN（虚拟局域网）和出接口。也就是长静态ARP表项同事绑定了IP地址、MAC地址、VLAN和端口，可以直接用于报文转发。

二、arp解析过程

当PC1想发送数据给PC2，首先在自己的本地ARP缓存表中检查主机PC2匹配的MAC地址
如果PC1缓存中没有找到响应的条目，它将询问主机PC2的MAC地址，从而将ARP请求帧广播到本地网络的所有主机。该帧中包括源主机PC1的IP、MAC地址，本地网络中的所有主机都接收到ARP请求，并且检查是否与自己的ip地址相匹配。如果发现请求中的IP地址与自己的IP不匹配，则丢弃ARP请求
主机PC2确定ARP请求中的IP地址与自己的IP地址匹配，则将主机pc1的地址和mac地址添加到本地缓存表中。
主机PC2将包含其mac地址的ARP回复消息直接发送回主机pc1（数据帧为单播）
主机pc1收到PC2返回的ARP回复消息，将PC2的IP和MAC地址添加至自己的ARP缓存表中，本机缓存是有生存期的，默认ARP缓存表有效期120s。当超过该有效期后，则将重复上面过程。主机pc2的MAC地址一旦确定，主机PC1就能向主机PC2发送IP信息

rp中，如果内网IP10.10.10.10，访问外网IP 100.100.100.100，网关为10.10.10.1，网关对外映射IP 100.100.100.1 ，这是arp的过程是什么样子的？

主机发送数据包：

主机在发送数据包时，发现目标 IP 地址（100.100.100.100）不在同一子网内。
主机会查找其本地 ARP 缓存表，如果没有找到目标 IP 对应的 MAC 地址，则会尝试发送 ARP 请求以获取目标 MAC 地址。

ARP 请求发送：

主机将发送一个 ARP 请求，目标 IP 地址为网关的 IP 地址（10.10.10.1）。
ARP 请求中包含主机自身的 IP 地址（10.10.10.10）、MAC 地址（主机的物理地址）以及目标 IP 地址（10.10.10.1）。

网关收到 ARP 请求：

网关接收到 ARP 请求，检查请求中的目标 IP 地址。
网关发现自己的 IP 地址与 ARP 请求中的目标 IP 地址匹配（即10.10.10.1），因此它会作出响应。

网关发送 ARP 响应：

网关将会发送一个 ARP 响应给主机，包含网关自身的 MAC 地址。
这个 ARP 响应中会包含主机之前请求的目标 IP 地址（10.10.10.1）和网关的 MAC 地址。

主机收到 ARP 响应：

主机接收到网关的 ARP 响应后，将该映射关系存储到 ARP 缓存表中，以备将来使用。
接着，主机会更新自己要发送到目标 IP 地址（100.100.100.100）的数据包，使用网关的 MAC 地址作为目标 MAC 地址。

数据包转发：

网关接收到主机发来的数据包，因为它知道如何到达外部的 100.100.100.100，所以它会根据自身的路由表进行转发。
网关将该数据包重新封装，将目标 IP 地址更改为 100.100.100.100，并将数据包发送到下一个目标，即外部网络。

arp报文抓包分析

arp请求报文

arp返回报文

三、用go实现发送ARP包

package main

import (
	"bytes"
	"errors"
	"fmt"
	"log"
	"net"
	"time"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/google/gopacket/pcap"
	"github.com/google/gopacket/routing"
	"github.com/jackpal/gateway"
	"github.com/libp2p/go-netroute"
)

func main() {
	//targetIP := net.IP{100, 100, 100, 100} //设置目标地址
	//device, _ := GetDevByIp(targetIP)
	device, _ := GetDevByIp(net.IP{10, 100, 100, 100})
	srcIP, srcMac, gw, device2, _ := GetIpFromRouter(net.IP{100, 100, 200, 100})
	fmt.Println(srcIP, srcMac, gw)
	fmt.Println(device, device2)

	//构建ARP请求包
	arpLayer := &layers.ARP{
		AddrType:          layers.LinkTypeEthernet,  //硬件类型 1
		Protocol:          layers.EthernetTypeIPv4,  //上层协议类型0x0800
		HwAddressSize:     6,                        //mac地址长度
		ProtAddressSize:   4,                        // IP地址长度
		Operation:         layers.ARPRequest,        //操作类型，1为arp请求
		SourceHwAddress:   []byte(srcMac),           //本机的mac地址
		SourceProtAddress: []byte(srcIP),            //本机的IP地址
		DstHwAddress:      []byte{0, 0, 0, 0, 0, 0}, //目标mac地址，使用任意地址，未知
		DstProtAddress:    []byte{10, 122, 131, 225},
	}

	ethLayer := &layers.Ethernet{
		EthernetType: layers.EthernetTypeARP,                               //帧类型 0x0806
		SrcMAC:       srcMac,                                               //本机mac地址
		DstMAC:       net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, //广播mac地址
	}

	buffer := gopacket.NewSerializeBuffer()
	opts := gopacket.SerializeOptions{FixLengths: true}
	err := gopacket.SerializeLayers(buffer, opts, ethLayer, arpLayer)
	if err != nil {
		log.Fatal(err)
	}

	outgoingPacket := buffer.Bytes()

	handle, err := pcap.OpenLive(device, 1024, true, pcap.BlockForever)
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close()

	//发送 ARP请求包
	err = handle.WritePacketData(outgoingPacket)
	fmt.Printf("Outgoing Packet: %x\n", outgoingPacket)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("arp request sent")
	time.Sleep(3 * time.Second)

	// 接收并处理响应包
	packetSource := gopacket.NewPacketSource(handle, handle.LinkType())

	timeout := time.After(5 * time.Second) // 设置超时时间为5秒

	// 接收并处理响应包
	for {
		select {
		case packet := <-packetSource.Packets():
			arpLayer := packet.Layer(layers.LayerTypeARP)
			if arpLayer != nil {
				arpPacket, _ := arpLayer.(*layers.ARP)
				if arpPacket.Operation == layers.ARPReply && bytes.Equal(arpPacket.SourceProtAddress, gw) {
					fmt.Printf("MAC address of %s is %s\n", gw.String(), arpPacket.SourceHwAddress)
					return
				}
			}
		case <-timeout:
			fmt.Println("Timeout: No response received")
			return
		}
	}
}

// 获取设备名称
func GetDevByIp(ip net.IP) (devName string, err error) {
	devices, err := pcap.FindAllDevs()
	if err != nil {
		return
	}
	for _, d := range devices {
		for _, address := range d.Addresses {
			_ip := address.IP.To4()
			if _ip != nil && _ip.IsGlobalUnicast() && _ip.Equal(ip) {
				fmt.Println()
				fmt.Println("找到网络设备：", d.Name)
				//return d.Name, nil
			}
		}
		return d.Name, nil
	}
	return "", errors.New("can not find dev")
}

// 通过扫描的目标IP获取发包的网卡信息，返回源IP、源mac、网关IP、设备名称
func GetIpFromRouter(dstIp net.IP) (srcIp net.IP, srcMac net.HardwareAddr, gw net.IP, devName string, err error) {
	//先验证扫描IP是否同网段
	srcIp, srcMac = GetIfaceMac(dstIp)
	if srcIp == nil {
		//如果不是同网段，则查询路由
		var r routing.Router    //创建一个 routing.Router 类型的变量，用于查询路由信息
		r, err = netroute.New() //初始化routing.Router
		if err == nil {
			var iface *net.Interface               //创建变量iface用于保存与路由相关的网络接口信息
			iface, gw, srcIp, err = r.Route(dstIp) //通过路由查询路由信息，包括目标IP地址 dstIp 对应的路由信息。iface 保存了与该路由信息关联的网络接口，gw 保存了网关IP地址，srcIp 保存了与该路由信息关联的本地IP地址
			if err == nil {
				if iface != nil {
					srcMac = iface.HardwareAddr //如果找到了与目标IP地址匹配的路由信息，即 iface 不为 nil，则设置 srcMac 为该网络接口的MAC地址。否则，继续下一步
				} else {
					_, srcMac = GetIfaceMac(srcIp)
				}
			}
		}
		//如果在之前的步骤中出现错误或者 srcMac 为 nil，它尝试取得第一个默认网关的信息。
		if err != nil || srcMac == nil {
			//取第一个默认路由
			gw, err = gateway.DiscoverGateway() //获取第一个默认网关的IP地址
			if err == nil {
				srcIp, srcMac = GetIfaceMac(gw)
			}
		}
	}
	gw = gw.To4()
	srcIp = srcIp.To4()
	devName, err = GetDevByIp(srcIp)
	if srcIp == nil || err != nil || srcMac == nil {
		if err == nil {
			err = fmt.Errorf("err")

		}
		return nil, nil, nil, "", fmt.Errorf("no router,%s", err)
	}
	return

}

// 查找与指定IP地址相匹配的本地IP地址和MAC地址,其实就是检测是否同网段
func GetIfaceMac(ifaceAddr net.IP) (src net.IP, mac net.HardwareAddr) {
	interfaces, _ := net.Interfaces()  //获取本地计算机上的网络接口信息
	for _, iface := range interfaces { //遍历所有网络接口
		if addrs, err := iface.Addrs(); err == nil { //获取接口的IP地址列表
			for _, addr := range addrs { //遍历该接口的IP地址
				if addr.(*net.IPNet).Contains(ifaceAddr) { //检查每个IP地址是否包含了给定的ifaceAddr（即传参），这里用的contains方法，检查给定IP和接口IP是否同一子网
					return addr.(*net.IPNet).IP, iface.HardwareAddr //匹配就返回接口IP和mac地址
				}
			}

		}

	}
	return nil, nil

}