第39周：DDoS 防护系统

字数统计: 2.9k字   |   阅读时长≈ 15分

第39周：DDoS 防护系统

目标：理解 DDoS 防护的核心技术（SYN Cookie、流量牵引），能够基于 XDP 实现高性能的 SYN Proxy 和流量清洗。

1. DDoS 攻击类型

1.1 攻击分类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
┌──────────────┬────────────┬─────────────┬──────────────┐
│ 攻击类型      │ 攻击层     │ 特征         │ 防护策略      │
├──────────────┼────────────┼─────────────┼──────────────┤
│ SYN Flood    │ L4         │ 半开连接     │ SYN Cookie    │
│ UDP Flood    │ L3/L4      │ 大流量 UDP   │ 限速 / 丢弃   │
│ ICMP Flood   │ L3         │ ping 风暴    │ 限速 / 丢弃   │
│ HTTP Flood   │ L7         │ 大量 GET     │ JS / 验证码   │
│ Slowloris    │ L7         │ 慢请求       │ 超时          │
│ DNS Amp      │ L7         │ DNS 反射     │ 源 IP 验证    │
│ NTP Amp      │ L3         │ NTP 反射     │ 源 IP 验证    │
│ SSDP Amp     │ L7         │ UPnP 反射    │ 源 IP 验证    │
│ Memcached    │ L7         │ 反射放大     │ 关闭 UDP 服务 │
│ HTTP/2      │ L7         │ Rapid Reset │ 协议验证      │
│ QUIC Initial │ L4         │ 大包         │ 挑战响应      │
└──────────────┴────────────┴─────────────┴──────────────┘

1.2 攻击规模

1
2
3
4
5
6
7
8
9
10
11
12
DDoS 攻击规模演进：

  2010:  100 Gbps
  2015:  500 Gbps
  2020:  1.5 Tbps（Mirai 变种）
  2023+: 5+ Tbps（UDP amplification）
  
  反射放大倍数：
  - DNS:  28-54x
  - NTP:  556x（最严重）
  - SSDP:  30x
  - Memcached: 51,000x（已被修复但仍可能）

2.1 SYN Flood 原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
正常 TCP 三次握手：

  Client                  Server
    |                       |
    |--- SYN (seq=x) ------>|  ← 分配连接资源（SYN queue）
    |                       |
    |<-- SYN+ACK (seq=y,    |
    |     ack=x+1) ---------|
    |                       |
    |--- ACK (ack=y+1) ----->|  ← 移动到 accept queue
    |                       |
    |     Connection        |
    |     Established       |

SYN Flood 攻击：

  Attacker                Server
    |                       |
    |--- SYN 1 ------------>|  ← 分配资源
    |--- SYN 2 ------------>|  ← 分配资源
    |--- SYN 3 ------------>|  ← 分配资源
    |  ... 百万次 SYN ...   |
    |                       |  ← 资源耗尽，无法响应合法连接
    |   (不发送 ACK)        |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
SYN Cookie 思想：
  - 不为半开连接分配资源
  - 在 SYN+ACK 的 seq 字段中编码信息
  - 收到合法 ACK 时验证 seq 中的"cookie"

seq 编码（32 bit）：
  ┌───────────┬──────────┬──────────┐
  │ 低 5 bit  │  中 3 bit │  高 24 bit│
  │  t mod 32 │  mss 编码  │  hash     │
  └───────────┴──────────┴──────────┘
  
  - 低 5 bit: 服务器启动时间 t mod 32
  - 中 3 bit: MSS 编码（最多 8 种）
  - 高 24 bit: hash(saddr, daddr, sport, dport, t)
    = HMAC 截断前 24 bit

  验证：
  - ACK 中的 seq - 1 = cookie
  - 重新计算 hash，比对
  - 同时检查 t mod 32 防止重放
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
43
44
45
46
47
48
49
50
51
52
// Linux 内核 SYN Cookie 实现（简化）
#include <crypto/siphash.h>

static siphash_key_t syncookie_secret;  // 启动时随机生成

#define COOKIEBITS 24
#define COOKIEMASK (((u32)1 << COOKIEBITS) - 1)
#define COOKIE_MAXAGE 4  // TCP 时间戳模式 64

static u32 cookie_hash(u32 saddr, u32 daddr, u16 sport, u16 dport,
                     u32 count, u32 t)
{
    // siphash
    return siphash_4u32(saddr, daddr, ((u32)sport << 16) | dport, count, &syncookie_secret) &
           COOKIEMASK;
}

static u32 syn_cookie_value(u32 saddr, u32 daddr, u16 sport, u16 dport,
                            u32 t, u32 mssind)
{
    return (t & COOKIEBITS) | (mssind << COOKIEBITS) |
           (cookie_hash(saddr, daddr, sport, dport, 0, t) << (COOKIEBITS + 3));
}

// 生成 SYN+ACK 的 seq
static u32 syn_cookie(u32 saddr, u32 daddr, u16 sport, u16 dport,
                     u32 sseq, u32 t, u32 mssind)
{
    return syn_cookie_value(saddr, daddr, sport, dport, t, mssind);
}

// 验证 ACK 中的 seq
static int syn_cookie_check(u32 cookie, u32 saddr, u32 daddr,
                           u16 sport, u16 dport, u32 sseq,
                           u32 t, u32 mssind)
{
    u32 value = syn_cookie_value(saddr, daddr, sport, dport, t, mssind);

    if (cookie == value)
        return 0;  // 合法

    // 尝试时间戳模式（更宽松）
    if (sysctl_tcp_timestamps) {
        u32 diff = t - ((cookie >> 26) & 0x1F);
        if (diff < COOKIE_MAXAGE) {
            value = syn_cookie_value(saddr, daddr, sport, dport, t - diff, mssind);
            if (cookie == value)
                return 0;
        }
    }
    return -1;  // 非法
}
1
2
3
4
5
6
7
8
9
10
# 查看当前状态
cat /proc/sys/net/ipv4/tcp_syncookies
# 0=禁用 1=启用 2=被动启用（仅在压力大时）

# 启用
echo 1 | sudo tee /proc/sys/net/ipv4/tcp_syncookies

# 永久生效
echo "net.ipv4.tcp_syncookies = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

3. XDP SYN Proxy

3.1 架构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
XDP SYN Proxy 架构：

  Attacker            XDP Proxy              Real Server
    |                    |                       |
    |--- SYN ----------->|                       |
    |                    |   1. 验证攻击          |
    |                    |   2. SYN Cookie 生成  |
    |<-- SYN+ACK (cookie)|   ← 不传递给后端      |
    |                    |                       |
    |--- ACK (cookie) --->|                      |
    |                    |  3. 验证 cookie        |
    |                    |  4. 重新发起到后端     |
    |                    |----- SYN ------------>|
    |                    |                       |
    |                    |     (后续正常代理)     |

  优势：
    - 后端看不到攻击流量
    - 资源消耗极低
    - 内核级处理（极快）

3.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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
// xdp_synproxy.bpf.c
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>
#include <bpf/bpf_helpers.h>

// 配置：代理配置
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, struct {
        u32 real_saddr;       // 真实服务器 IP
        u16 real_dport;       // 真实服务器端口
        u16 vport;            // VIP 端口
    });
} proxy_config SEC(".maps");

// 计数器
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 8);
    __type(key, u32);
    __type(value, u64);
} stats SEC(".maps");

// 速率限制（每个源 IP）
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 65536);
    __type(key, u32);
    __type(value, u64);  // 上一秒时间戳
} rate_limit SEC(".maps");

// 简易 hash（生产用应使用 siphash）
static inline u32 simple_hash(u32 saddr, u16 sport) {
    u32 h = saddr * 2654435761U;
    h ^= sport;
    h *= 2654435761U;
    h ^= h >> 16;
    return h;
}

// 速率限制（每秒最多 100 个 SYN）
static int is_rate_limited(u32 saddr) {
    u64 *last = bpf_map_lookup_elem(&rate_limit, &saddr);
    u64 now = bpf_ktime_get_ns();

    if (last && (now - *last) < 10000000ULL) {
        // 10ms 内已发过 SYN（> 100 pps）
        return 1;  // 限速
    }

    if (!last) {
        bpf_map_update_elem(&rate_limit, &saddr, &now, BPF_ANY);
    } else {
        *last = now;
    }
    return 0;
}

// SYN Cookie 计算（简化）
static inline u32 syn_cookie(u32 saddr, u16 sport, u16 dport) {
    u32 h = simple_hash(saddr, sport);
    h ^= dport;
    h ^= bpf_get_smp_processor_id() << 16;  // 加扰
    return h & 0xFFFFFF;  // 24 bit cookie
}

// 验证 cookie
static inline int check_cookie(u32 saddr, u16 sport, u16 dport, u32 cookie) {
    return (syn_cookie(saddr, sport, dport) == cookie);
}

SEC("xdp")
int xdp_synproxy(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    if (ip->protocol != IPPROTO_TCP)
        return XDP_PASS;

    struct tcphdr *tcp = (void *)ip + (ip->ihl * 4);
    if ((void *)(tcp + 1) > data_end)
        return XDP_PASS;

    u8 tcp_flags = tcp->tcp_flags & 0x3F;
    int is_syn = (tcp_flags & RTE_TCP_SYN_FLAG) && !(tcp_flags & RTE_TCP_ACK_FLAG);
    int is_ack = (tcp_flags & RTE_TCP_ACK_FLAG) && !(tcp_flags & RTE_TCP_SYN_FLAG);

    // 读取配置
    u32 key = 0;
    struct {
        u32 real_saddr;
        u16 real_dport;
        u16 vport;
    } *cfg = bpf_map_lookup_elem(&proxy_config, &key);
    if (!cfg) return XDP_PASS;

    // 只代理指定 VIP 端口的 TCP
    if (tcp->dest != cfg->vport && bpf_ntohs(tcp->dest) != cfg->vport) {
        return XDP_PASS;  // 非代理端口
    }

    if (is_syn) {
        // === SYN 包：速率限制并生成 cookie ===

        // 速率限制检查
        if (is_rate_limited(ip->saddr)) {
            u32 k = 1;  // STAT_RATE_LIMITED
            u64 *c = bpf_map_lookup_elem(&stats, &k);
            if (c) (*c)++;
            return XDP_DROP;  // 攻击，丢弃
        }

        // 修改为 SYN+ACK 回送
        // 1. 交换 MAC
        u8 tmp_mac[6];
        memcpy(tmp_mac, eth->h_source, 6);
        memcpy(eth->h_source, eth->h_dest, 6);
        memcpy(eth->h_dest, tmp_mac, 6);

        // 2. 计算 cookie 作为 ACK seq
        u32 cookie = syn_cookie(ip->saddr, tcp->source, tcp->dest);
        tcp->ack_seq = bpf_htonl(bpf_ntohl(tcp->seq) + 1);
        tcp->seq = bpf_htonl(cookie);

        // 3. 设置 SYN+ACK 标志
        tcp->tcp_flags = 0x12;  // SYN=1, ACK=1

        // 4. 交换 IP
        u32 tmp_ip = ip->saddr;
        ip->saddr = ip->daddr;
        ip->daddr = tmp_ip;

        // 5. 端口交换
        u16 tmp_port = tcp->source;
        tcp->source = tcp->dest;
        tcp->dest = tmp_port;

        // 6. 校验和
        tcp->check = 0;
        ip->check = 0;
        tcp->check = bpf_csum_diff();  // 需要补全
        ip->check = bpf_csum_diff();

        u32 k = 2;  // STAT_SYN_PROXIED
        u64 *c = bpf_map_lookup_elem(&stats, &k);
        if (c) (*c)++;

        return XDP_TX;  // 发回
    }

    if (is_ack) {
        // === ACK 包：验证 cookie 后转发到后端 ===

        // 从 seq - 1 提取 cookie
        u32 cookie = bpf_ntohl(tcp->seq) - 1;

        if (!check_cookie(ip->saddr, tcp->source, tcp->dest, cookie)) {
            return XDP_DROP;  // 非法
        }

        // 修改目的为真实服务器
        ip->daddr = cfg->real_saddr;
        tcp->dest = cfg->real_dport;

        // 重新计算校验和
        tcp->check = 0;
        ip->check = 0;
        // 重新计算（略）

        u32 k = 3;  // STAT_ACK_FORWARDED
        u64 *c = bpf_map_lookup_elem(&stats, &k);
        if (c) (*c)++;

        return XDP_PASS;  // 传递给协议栈，最终到后端
    }

    return XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";
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
// 完整的 SYN Cookie（参考 Linux 内核）
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

// 实际生产应使用 siphash
// 这里用简化 hash

#define COOKIEBITS 24
#define COOKIEMASK ((1u << COOKIEBITS) - 1)

static u32 cookie_secret = 0x12345678;  // 启动时随机

static inline u32 my_hash(u32 a, u32 b) {
    u32 h = a * 0x9E3779B1U;
    h ^= b * 0x85EBCA77U;
    h = (h << 13) | (h >> 19);
    h *= 0xC2B2AE3DU;
    h ^= h >> 16;
    return h;
}

static inline u32 make_cookie(u32 saddr, u32 daddr,
                              u16 sport, u16 dport,
                              u32 sseq, u32 count) {
    u32 h = my_hash(saddr ^ cookie_secret, daddr);
    h ^= ((u32)sport << 16) | dport;
    h ^= sseq;
    h ^= count;
    return h & COOKIEMASK;
}

static inline int check_cookie(u32 cookie, u32 saddr, u32 daddr,
                                u16 sport, u16 dport, u32 sseq, u32 count) {
    return cookie == make_cookie(saddr, daddr, sport, dport, sseq, count);
}

4. 流量牵引与清洗架构

4.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
DDoS 防护部署架构：

  正常流量                攻击流量
      |                      |
      ▼                      ▼
  ┌────────┐            ┌────────┐
  │ 入口 LB │            │ 入口 LB │
  │(BGP Anycast)         │        │
  └───┬────┘            └───┬────┘
      │                      │
      │                      ▼
      │                 ┌──────────┐
      │                 │ 牵引路由 │
      │                 │  BGP    │
      │                 └───┬──────┘
      │                     │
      │                     ▼
      │              ┌────────────┐
      │              │ 清洗中心   │
      │              │ (Scrubbing)│
      │              │  - SYN 验证│
      │              │  - 协议合规│
      │              │  - 限速    │
      │              │  - 信誉库  │
      │              └────┬───────┘
      │                   │
      │ 清洗后的合法流量    │
      │◄──────────────────┘
      │
      ▼
   真实业务

4.2 BGP 牵引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# === 正常路由 ===
# router1: 10.0.0.0/24 via 192.168.1.1
# 正常用户从 router1 进来

# === 攻击时牵引 ===
# 1. 在清洗中心路由器上发布更具体的路由
router-2# bird: route 10.0.0.0/25 via <清洗中心>  # 比 /24 更具体
router-2# bird: route 10.0.0.128/25 via <清洗中心>

# 2. 路由选择：最长前缀匹配 → 攻击流量流向清洗中心

# === 清洗后回注 ===
# 清洗后从清洗中心路由器：
route 10.0.0.0/24 via <业务网关>  # 通过 GRE/VXLAN 隧道

4.3 GRE 回注

1
2
3
4
5
6
7
8
9
10
11
# 清洗中心 → 业务网段
ip tunnel add gre-back mode gre \
    local <清洗中心> \
    remote <业务网关> \
    ttl 64

ip addr add 10.99.0.1/30 dev gre-back
ip link set gre-back up

# 路由
ip route add 10.0.0.0/24 dev gre-back

4.4 XDP 清洗实现

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// xdp_scrubber.bpf.c
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <bpf/bpf_helpers.h>

// 黑名单（黑洞）
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 65536);
    __type(key, u32);   // 源 IP
    __type(value, u64);  // 过期时间
} blacklist SEC(".maps");

// 信誉库（IP 信誉）
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 1000000);
    __type(key, u32);
    __type(value, u8);  // 信誉分数 0-100
} reputation SEC(".maps");

// 检查包是否符合 TCP 协议规范
static int is_valid_tcp(struct tcphdr *tcp) {
    // TCP 头长度必须 ≥ 20
    if (tcp->doff < 5) return 0;

    // SYN 包不能有 payload
    if (tcp->syn && !tcp->ack) {
        if (tcp->doff > 5) return 0;  // 有选项可允许
    }

    // 标志位组合检查
    if (tcp->syn && tcp->fin) return 0;  // SYN+FIN 非法
    if (tcp->syn && tcp->rst) return 0;  // SYN+RST 非法
    if (tcp->fin && tcp->rst) return 0;  // FIN+RST 非法

    return 1;
}

SEC("xdp")
int xdp_scrubber(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    // 1. 黑名单检查
    if (bpf_map_lookup_elem(&blacklist, &ip->saddr)) {
        return XDP_DROP;
    }

    // 2. IP 头合法性
    if (ip->version != 4) return XDP_DROP;
    if (ip->ttl == 0) return XDP_DROP;
    if (ip->frag_off & bpf_htons(0x1FFF)) return XDP_DROP;  // 有碎片
    if (ip->frag_off & bpf_htons(0x4000)) {
        // DF=1（不分片）
    }

    // 3. TCP 包详细验证
    if (ip->protocol == IPPROTO_TCP) {
        struct tcphdr *tcp = (void *)ip + (ip->ihl * 4);
        if ((void *)(tcp + 1) > data_end)
            return XDP_DROP;

        if (!is_valid_tcp(tcp)) {
            return XDP_DROP;
        }
    }

    return XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";

5. 防护效果测试

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
# === 测试准备 ===

# 1. 安装 hping3
sudo apt install hping3

# 2. 加载 XDP 防护
sudo ip link set dev eth0 xdp obj xdp_synproxy.bpf.o sec xdp

# 3. 启动目标 HTTP 服务
python3 -m http.server 80 &

# 4. 启动 netcat 监听
nc -lnvp 80

# === 测试 1：SYN Flood 模拟 ===

# 1. 未防护前：发 1000 个 SYN，看是否能响应
for i in $(seq 1 1000); do
    hping3 -S -p 80 -c 1 10.0.0.1 2>/dev/null &
done
# 攻击期间，正常用户应能继续访问

# 2. 防护开启后
# （在另一台机器上）正常访问
curl http://10.0.0.1/  # 应该正常

# === 测试 2：SYN Cookie 验证 ===

# 1. 启动连接
hping3 -S -p 80 10.0.0.1
# 收到 SYN+ACK 后，记录 seq

# 2. 验证 cookie（用正确的 seq 发送 ACK）
# 实际测试比较复杂，需要解析 hping3 输出

6. 主流 DDoS 防护产品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
云防护：
  - AWS Shield（基础/高级）
  - Cloudflare Magic Transit
  - Azure DDoS Protection
  - GCP Cloud Armor

硬件/软件方案：
  - Arbor Networks（业界领先）
  - Radware DefensePro
  - F5 ASM
  - A10 Thunder
  - Nexusguard

开源/自研：
  - FastNetMon（流量分析）
  - CrowdSec（行为分析）
  - XDP/eBPF 自研（云原生）

7. 性能基准

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
XDP SYN Proxy 性能（10GbE，64B 包）：

  无防护（基线）：
    - 14.88 Mpps
    - SYN 队列耗尽 → 合法连接失败

  XDP SYN Cookie：
    - 14.5 Mpps（基本无损耗）
    - 攻击时仍能处理合法 SYN

  混合 SYN Proxy + 速率限制：
    - 14.0 Mpps
    - 攻击期间性能下降 < 5%
    - 后端完全无感

  对比 iptables：
    - iptables: 1-3 Mpps（syncookies 模式）
    - XDP: 14 Mpps（5-10x 性能提升）
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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