第14周：邻居子系统与 ARP

字数统计: 2.3k字   |   阅读时长≈ 11分

第14周：邻居子系统与 ARP

目标：理解 ARP 缓存管理、邻居状态机，以及 L2 与 L3 如何协作完成地址解析。

1. 邻居子系统概览

1.1 L2 与 L3 的关系

1
2
3
4
5
6
7
8
9
10
11
12
三层（IP 层）：只知道目的 IP 地址
二层（链路层）：需要目的 MAC 地址才能发包

邻居子系统 = 桥梁
  输入：IP 地址
  输出：MAC 地址（或下一跳）

流程：
  1. 路由查找确定出接口和下一跳 IP
  2. 邻居子系统查找：IP → MAC 映射
  3. 如果未命中 → 发送 ARP 请求
  4. 收到 ARP 应答 → 填充 MAC，发送数据包

1.2 邻居子系统的角色

1
2
3
4
5
6
7
邻居子系统不只是 ARP（IPv4）：

协议      邻居表类型      解析协议
──────────────────────────────────
IPv4      ARP             ARP 请求/应答
IPv6      IPv6 ND         Neighbor Solicitation/Advertisement
InfiniBand IB             直接可达（不需要解析）

2. ARP 协议详解

2.1 ARP 报文格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
ARP 报文（28 字节）：

 0      2      4      6      8      10     12     14
+-------+-------+-------+-------+-------+------+------+
| 硬件类型 | 协议类型 | HLEN | PLEN | OPERATION  |
+-------+-------+-------+-------+-------+------+------+
|     发送方 MAC 地址（6 字节）                    |
+--------------------------------------------------+
|     发送方 IP 地址（4 字节）                      |
+--------------------------------------------------+
|     目标 MAC 地址（6 字节）                      |
+--------------------------------------------------+
|     目标 IP 地址（4 字节）                       |
+--------------------------------------------------+

字段说明：
  硬件类型（HTYPE）：1 = Ethernet
  协议类型（PTYPE）：0x0800 = IPv4
  HLEN：硬件地址长度（Ethernet = 6）
  PLEN：协议地址长度（IPv4 = 4）
  OPERATION：
    1 = ARP 请求
    2 = ARP 应答
    3 = RARP 请求
    4 = RARP 应答

2.2 ARP 工作流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1. 主机 A（192.168.1.1）要给 B（192.168.1.2）发包
   → 查邻居表，没有 B 的 MAC

2. 发送 ARP Request（广播）：
   "Who has 192.168.1.2? Tell 192.168.1.1"
   - 源 MAC: AA:BB:CC:DD:EE:FF (A)
   - 源 IP: 192.168.1.1
   - 目的 MAC: FF:FF:FF:FF:FF:FF (广播)
   - 目的 IP: 192.168.1.2

3. 主机 B 收到：
   - 检查目的 IP 匹配自己
   - 发送 ARP Reply（单播）：
     "192.168.1.2 is at BB:CC:DD:EE:FF:AA"
     - 源 MAC: BB:CC:DD:EE:FF:AA (B)
     - 源 IP: 192.168.1.2
     - 目的 MAC: AA:BB:CC:DD:EE:FF (A)
     - 目的 IP: 192.168.1.1

4. 主机 A 收到 ARP Reply：
   - 添加 B 的 IP→MAC 映射到邻居表
   - 发送 IP 包到 B

2.3 ARP 内核数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// include/net/neighbour.h

struct neighbour {
    struct neighbour __rcu    *next;
    struct neigh_table       *tbl;
    struct neigh_parms       *parms;
    struct net_device        *dev;
    unsigned long            confirmed;     // 上次确认时间（jiffies）
    unsigned long            updated;       // 上次更新时间
    unsigned long            arp_filter;    // ARP 过滤
    __u8                     flags;         // NTF_*
    __u8                     dead;          // 是否已删除
    __u8                     lock;          // 引用计数（低 8 位）
    __u8                     used;          // 是否被使用
    atomic_t                 refcnt;        // 引用计数
    rwlock_t                 lock;
    struct timer_list        timer;
    unsigned long            reachable_time; // reachable 超时
    atomic_t                 probes;        // ARP 探测计数
    struct sk_buff_head      arp_queue;     // 等待 ARP 解析的包
    struct sk_buff_head      skb;           // 待处理包
    unsigned char            ha[NEIGH_MAX_HWADDR]; // MAC 地址
    struct hh_cache          hh;            // 硬件头缓存
    struct rcu_head          rcu;
    struct list_head         gc_list;       // 垃圾回收链表
};

// 状态标志
#define NTF_USE         0x01    // 正在使用
#define NTF_PROXY       0x02    // 代理 ARP
#define NTF_ROUTER      0x04    // 是路由器

// 邻居状态
#define NUD_INCOMPLETE  0x01    // 解析中（ARP 请求已发）
#define NUD_REACHABLE   0x02    // 可达（最近确认）
#define NUD_STALE       0x04    // 过期（但可能仍可用）
#define NUD_DELAY       0x08    // 延迟状态（收到包后进入）
#define NUD_PROBE       0x10    // 正在探测（ARP 重试中）
#define NUD_FAILED      0x20    // 解析失败
#define NUD_NOARP       0x40    // 不需要 ARP（直接连接）
#define NUD_PERMANENT   0x80    // 永久（静态 ARP）
#define NUD_NONE        0x00    // 初始状态

3. 邻居状态机

3.1 状态转换图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
                           ARP Request
                     ┌────────────────────┐
                     │                    │
                     ▼                    │ ARP Reply
               +───────────┐              │
收到包 →──────▶│ REACHABLE  │◀────────────┘
               +─────┬─────┘
                     │ 超时 (reachable_time，默认 30s)
                     ▼
               +───────────┐
发送包 ───────▶│  STALE     │
(已有 MAC)     +─────┬─────┘
                     │ 收到任何包
                     ▼
               +───────────┐
               │  DELAY     │ ← 5 秒内
               +─────┬─────┘
                     │ 超时 / 收到确认
                     ▼
               +───────────┐
探测中 ─────────│  PROBE     │ ← 发送 ARP 请求
(ARP 重试)     +─────┬─────┘
                     │ 收到 ARP Reply
                     ▼
               ┌───────────┐
超时失败 ─────▶│  FAILED    │
(3 次探测失败)  +─────┬─────┘
                     │ 删除条目
                     ▼
               ┌───────────┐
新建条目 ─────▶│ INCOMPLETE │
               +───────────┘
                     │ ARP Reply
                     ▼
               ┌───────────┐
               │ REACHABLE  │
               └───────────┘

3.2 超时参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 查看参数
cat /proc/sys/net/ipv4/neigh/default/

# 关键参数：
# base_reachable_time_ms    # reachable 超时（ms，默认 30000 = 30s）
# retrans_time_ms           # ARP 重试间隔（ms，默认 1000）
# gc_stale_time             # 垃圾回收间隔（s，默认 60）
# delay_first_probe_time    # 从 STALE 到 PROBE 的延迟（s，默认 5）
# unres_qlen_bytes          # 未解析队列长度
# anycast_delay             # anycast 延迟（ms，默认 1000）
# proxy_delay               # 代理 ARP 延迟（ms，默认 800）
# locktime                  # ARP 缓存锁定时间（ms，默认 0）

# 查看具体接口的参数
cat /proc/sys/net/ipv4/neigh/eth0/

# 临时修改
echo 60 > /proc/sys/net/ipv4/neigh/default/base_reachable_time_ms

4. 邻居表操作

4.1 查看 ARP 缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# === ip 命令（推荐）===

# 查看 ARP 缓存
ip neigh show
ip neigh show dev eth0

# 输出格式：
# 192.168.1.1 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE
# 192.168.1.2 dev eth0 lladdr 00:00:00:00:00:00 FAILED
# 192.168.1.3 dev eth0 STALE

# 状态：REACHABLE / STALE / DELAY / PROBE / FAILED / PERMANENT

# 查看详细统计
ip -s neigh show
# 显示：lastused, confirmed, used, packets, bytes

# === /proc 方式 ===
cat /proc/net/arp
# IP address       HW address     Flags Device
# 192.168.1.1      aa:bb:cc:dd:ee:ff  0x2  eth0

# 0x2 = ATF_COM (complete)
# 0x4 = ATF_PERM (permanent)
# 0x8 = ATF_PUBL (publish)

4.2 添加/删除 ARP 条目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 添加静态 ARP
sudo ip neigh add 192.168.1.100 dev eth0 lladdr aa:bb:cc:dd:ee:ff nud permanent
sudo ip neigh change 192.168.1.100 dev eth0 lladdr aa:bb:cc:dd:ee:ff nud permanent

# 删除 ARP 条目
sudo ip neigh del 192.168.1.100 dev eth0

# 清空 ARP 缓存
sudo ip neigh flush dev eth0
sudo ip neigh flush all

# arp 命令（旧版）
sudo arp -s 192.168.1.100 aa:bb:cc:dd:ee:ff -i eth0
sudo arp -d 192.168.1.100 -i eth0

5. ARP 攻击

5.1 ARP 欺骗原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
正常情况：
  Host A                    Host B
    │                          │
    │ ARP: B is at BB:CC:DD   │
    │                          │
    │────── packet to B ─────▶│

ARP 欺骗（中间人攻击）：
  Host A         Attacker          Host B
    │               │                │
    │◀── ARP Reply:│ │ "I am B"     │
    │   B is at    │ │ BB:CC:DD →   │
    │   AA:BB:CC   │ │ FF:EE:DD     │
    │               │                │
    │──── packet ──│──▶─────────────▶│
    │               │   (被监听/篡改)  │
    │◀── reply ────│──◀──────────────│

5.2 防护措施

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# === 内核级防护 ===

# 开启 ARP 认证
echo 1 | sudo tee /proc/sys/net/ipv4/conf/all/arp_accept
echo 1 | sudo tee /proc/sys/net/ipv4/conf/all/arp_announce
echo 1 | sudo tee /proc/sys/net/ipv4/conf/all/arp_filter

# 参数说明：
# arp_accept:      0=只响应目标 IP 的 ARP 请求
#                  1=响应所有 ARP 请求
# arp_announce:    0=用任意 IP 发 ARP
#                  1=只用目标 IP
#                  2=只用本地 IP
# arp_filter:      0=对所有接口响应
#                  1=只在目标接口响应
# arp_ignore:      0=响应所有 ARP
#                  1=只响应目标 IP = 本机 IP
#                  2=只响应目标 IP 在目标接口子网

# 推荐服务器设置
for f in /proc/sys/net/ipv4/conf/*/arp_ignore; do
    echo 1 | sudo tee $f
done
for f in /proc/sys/net/ipv4/conf/*/arp_accept; do
    echo 0 | sudo tee $f
done

# === 静态 ARP（小规模）===
sudo ip neigh add 192.168.1.1 dev eth0 lladdr aa:bb:cc:dd:ee:ff nud permanent

# === 工具检测 ===
# arpwatch — 监控 ARP 变化
sudo apt install arpwatch
sudo arpwatch -i eth0
# 检测到 ARP 变化时发送告警

# arpspoof 检测
sudo arp -a | grep -v "incomplete"

6. 邻居子系统内核 API

6.1 查找邻居

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <net/neighbour.h>
#include <net/netevent.h>

// 查找邻居条目
struct neighbour *neigh_lookup(struct neigh_table *tbl,
                               void *pkey, struct net_device *dev);

// 创建新条目
struct neighbour *neigh_create(struct neigh_table *tbl,
                               void *pkey, struct net_device *dev);

// 销毁条目
void neigh_destroy(struct neighbour *neigh);

// 发送 ARP 请求
int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);

// 状态转换
void neigh_update(struct neighbour *neigh, const u8 *lladdr,
                  u8 new_state);

// 状态枚举
#define NUD_INCOMPLETE  0x01
#define NUD_REACHABLE   0x02
#define NUD_STALE       0x04
#define NUD_DELAY       0x08
#define NUD_PROBE       0x10
#define NUD_FAILED      0x20
#define NUD_PERMANENT   0x80

6.2 邻居表实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// include/net/neighbour.h

struct neigh_table {
    struct neighbour __rcu    *phash_buckets[NEIGH_HASHMASK + 1];
    rwlock_t                  phash_lock;
    spinlock_t                lock;
    spinlock_t                parms.lock;
    struct kmem_cache         *nmb_cache;
    struct timer_list         gc_timer;
    unsigned int             hash_shift;  // hash 表大小 = 2^hash_shift
    unsigned int             entry_size;  // 每个条目大小
    __be32                   primary_key; // 默认 key（IPv4 = 目的 IP）

    // 哈希函数
    __u32 (*hash)(const void *pkey, const struct net_device *dev);

    // 关键操作
    int (*constructor)(struct neighbour *neigh);
    void (*pconstructor)(struct pneigh_entry *pneigh);
    void (*pdestructor)(struct pneigh_entry *pneigh);
    void (*proxy_redo)(struct sk_buff *skb);

    int (*output)(struct neighbour *neigh, struct sk_buff *skb);

    struct neigh_parms       parms;
    // ... 更多
};

// IPv4 邻居表
extern struct neigh_table arp_tbl;

6.3 邻居表初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// net/ipv4/arp.c

// 全局 ARP 表
struct neigh_table arp_tbl = {
    .family       = AF_INET,
    .entry_size   = sizeof(struct neighbour),
    .key_eq       = arp_key_eq,
    .constructor  = arp_constructor,
    .pconstructor = pneigh_constructor,
    .pdestructor  = pneigh_destructor,
    .proxy_redo   = arp_redo,
    .id           = "arp_cache",
    .parms        = {
        .t_reachable_time = 30 * HZ,    // 30 秒
        .t_probe_time     = 5 * HZ,     // 5 秒
        .t_stall_reprob   = 1 * HZ,     // 1 秒
    },
};

7. 实践：用 arping 和 tcpdump 观察 ARP

7.1 ARP 交互观察

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# === arping 工具 ===
# 向指定 IP 发送 ARP 请求

# 基本用法
sudo arping -I eth0 -c 3 192.168.1.1
# -I: 接口
# -c: 发送次数

# 查看 ARP 响应
sudo arping -I eth0 -c 3 -f 192.168.1.1
# -f: 收到第一个响应后停止

# ARP 扫描（发现网段内主机）
sudo arping -I eth0 -c 1 192.168.1.1
sudo arping -I eth0 -c 1 192.168.1.2
# ...

# 与 tcpdump 配合观察
sudo tcpdump -i eth0 -nn arp &
sudo arping -I eth0 -c 3 192.168.1.1
# 观察 ARP request/reply 交互

# tcpdump 输出：
# ARP, Request who-has 192.168.1.1 tell 192.168.1.100, length 28
# ARP, Reply 192.168.1.1 is-at aa:bb:cc:dd:ee:ff, length 46

7.2 观察 ARP 表变化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/bin/bash
# observe_arp.sh

INTERFACE=${1:-eth0}
TARGET=${2:-192.168.1.1}

echo "=== Monitoring ARP cache on $INTERFACE ==="

while true; do
    echo "--- $(date) ---"
    echo "ARP cache:"
    ip neigh show dev $INTERFACE

    echo "Active connections:"
    ss -tn state established | wc -l

    echo ""
    sleep 2
done

7.3 检测 ARP 欺骗

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/bin/bash
# detect_arp_spoof.sh

INTERFACE=${1:-eth0}
KNOWN_MACS="/etc/known_macs.txt"  # 预存的 MAC 地址

if [ ! -f "$KNOWN_MACS" ]; then
    echo "Creating known MACs database..."
    ip neigh show dev $INTERFACE | awk '{print $1, $5}' > $KNOWN_MACS
    echo "Done. Edit $KNOWN_MACS to fix known MACs."
    exit 0
fi

echo "Monitoring ARP for changes..."

while true; do
    ip neigh show dev $INTERFACE | while read ip mac flags; do
        expected=$(grep "^$ip " $KNOWN_MACS | awk '{print $2}')
        if [ -n "$expected" ] && [ "$mac" != "$expected" ]; then
            echo "[ALERT] ARP changed for $ip!"
            echo "  Expected: $expected"
            echo "  Got:      $mac"
        fi
    done
    sleep 5
done

8. IPv6 邻居发现（NDP）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
IPv6 不需要 ARP，使用 Neighbor Discovery Protocol (NDP)：

1. Neighbor Solicitation (NS)  ≈ ARP Request
   "Who has IPv6 address X? Please tell me"
   目的地址： solicit-node 多播地址

2. Neighbor Advertisement (NA) ≈ ARP Reply
   "I have address X, my MAC is Y"

3. 重定向：路由器通知主机有更优下一跳

命令：
  ndisc6 -1 eth0 fe80::1    # 邻居发现
  rdisc6 eth0               # 路由器发现
  rdnssd                    # DNS 发现
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870